comfysage / hayashi Goto Github PK

View Code? Open in Web Editor NEW

2.0 2.0 1.0 270 KB

:seedling: a tiny distro-independent package manager written in Go.

Makefile 2.77% Go 96.30% Shell 0.93%

package-manager

hayashi's Introduction

hayashi

🌱 a tiny distro-independent package manager written in Go.

Warning

hayashi has been deprecated in favor of saku.

Hayashi

Hayashi is a lightweight package manager for macOS/linux, written in Go. It aims to provide an alternative solution to managing software packages on macOS/linux systems, addressing some of the issues faced with existing package managers like Homebrew.

Features

Simplified package management: Hayashi strives to provide a streamlined and user-friendly package management experience, making it easy to install, update, and remove software packages.
Lightweight and efficient: Hayashi is designed to be lightweight and efficient, minimizing resource usage while maintaining performance. It aims to provide fast and responsive package management operations.
Improved stability: Hayashi focuses on stability and reliability, aiming to minimize dependency conflicts and provide a robust package installation process.
Self maintaining: Hayashi has built-in support for installing updates and configuring new packages.

Installation

Run the installer using curl:

curl -fsSL https://raw.githubusercontent.com/CrispyBaccoon/hayashi/mega/install.sh | sh

Setup hayashi environment, add this to your .bashrc/.zshrc:

eval "$($HOME/.hayashi/pack/bin/hayashi env)"

Usage

Hayashi provides a simple command-line interface for managing packages. Here are some common commands:

hayashi install <package>: Installs the specified package.
hayashi update <package>: Updates the specified package to the latest version.
hayashi remove <package>: Removes the specified package.
hayashi search <keyword>: Searches for packages matching the specified keyword.

For more information on available commands and options, refer to the Hayashi documentation.

Contributing

Contributions to Hayashi are welcome! If you encounter any issues, have suggestions for improvements, or want to contribute new features, please submit a pull request or open an issue on the GitHub repository.

Before contributing, please review the contribution guidelines for instructions on how to contribute code, report bugs, and more.

License

Hayashi is released under the MIT License. Please review the license file for more details.

Acknowledgements

Hayashi is inspired by package managers like Homebrew. Special thanks to the contributors and the open-source community for their valuable contributions.

Contact

For any inquiries or questions, feel free to contact the project maintainer at [email protected].

hayashi's People

Contributors

Stargazers

Watchers

Forkers

jojo7682345

hayashi's Issues

pack using symlink instead of installing

Hayashi currently installs binaries and man files using install.
This is mostly usefull when repos won't always be available or hayashi tidy (not implemented yet) is used.

In some cases using symlinks instead might be more usefull.

Proposed feature (false by default):

pack:
  - path: path/to/file
    type: type
    symlink: true

This would use

ln -s $(repo_dir)/path/to/file ~/.hayashi/pack/type/

instead of

install $(repo_dir)/path/to/file ~/.hayashi/pack/type/

Repos take up a lot of space. Tidy feature needed.

Currently cloned (and built) repos take up a lot of space (especially rust repos).
A tidy feature would be called using:

hayashi tidy [pkg]

This would call Pkg.tidy: deletes leftover build artifacts like build/ or target/.
These artifacts are often deleted when rebuilt and are not used after installation (necessary files should be packed).

Pkg Templates

Adding templates for general package designs: node, make, rust.

Adding a template for a package:

pkg: name
template: rust

Defining a template template-rust.yaml:

install:
    - cargo build -r

package is not added to 'installed' when no pack prop is defined

When no pack property is defined in a package but the package is installed the package isn't added to the .store.yaml file.

Proposed changes:
hayashi should check whether the pack property is empty and should decide to add the package to the store after runnning the installation.

add `which` command; prints path to a package file.

repo packages do not test for name collisions.

when installing a repo package with name 'repo_name', hayashi will not check if a package with such a name already exists/is-installed.

add `home` command; prints url associated with a package.

merge local and no-local behaviour of `cli/install`.

Hayashi should be able to differentiate between paths and names.
For this to work paths require some conditions.

Paths are accepted if they are explicitly relative or absolute ('.' | '/').

pkg.yaml -> name
./pkg.yaml -> path
/path/to/pkg.yaml -> path

add support for collection packages

Currently packages that define a collection use arbitrary commands to link the repo to the pkg/ directory.

Proposed changes:
You should be able to define a collection package:

pkg: some-collection
collection: pkgs/

This behaviour overwrites the current use of the collection key. This is because the current use of this key is overwritten by the InferCollection() function.

Hayashi doesn;t always need to clone the repo

Sometimes (like with vim-plug, ohmyzsh) hayashi doesn't need to clone the repo in order to run the installer.

Proposed option (true by default):

pkg: name
url: github.com/owner/repo
clone: false

Create framework for building repo packages

Currently, if someone wanted to install a repo that contains a custom pkg, they would have to:

clone the repo
run $ hayashi add --local yuki.yaml

This would clone the repo (again) in ~/.hayashi/repo/<repo> and install the package.

Problems with the current state:

the repo is cloned twice
the user has to specify which pkg file to install; this could be automated. think of $ hayashi install ..
the pkg script is not added to custom, so updating the installed pkg would have to be done using $ hayashi update --local ~/.hayashi/repo/<repo>/yuki.yaml.