git Added license, readme, task list, and logo images

Author: jerrens

LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Jerren Saunders
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,219 @@
+<!-- markdownlint-configure-file {
+    "no-inline-html": {
+        "allowed_elements": [ "div" ]
+    },
+    "no-multiple-blanks": {
+        "maximum": 4
+    }
+}
+-->
+<div align="center"><img style="max-width: 450px;" src="./logo/Myce - Blue.png" alt="MyCE Logo"></div>
+
+# My Command Engine (MyCE)
+
+
+## Overview
+
+My Command Engine or MyCE (as in "Mice") is a powerful, context-aware command-line tool, written intirely in bash, and designed to streamline project workflows by utilizing custom command definitions stored in `.myCommand` files within the directory tree.
+It searches for `.myCommand` files from the root down to the current directory, merging commands to create a localized and context-sensitive command set.
+This tool is ideal for developers who frequently switch between projects or environments and need specific commands scoped to each context.
+
+
+
+## Features
+
+- **Context-Aware Commands**: Executes commands based on the .myCommand file located in the current directory or its parent directories.
+- **Scoped Command Aliases**: Each directory (or project) can define its own command aliases without impacting other directories.
+- **Ease of Use**: A simple command `my <key>` is all you need to invoke the corresponding full command defined in the .myCommand file.
+- **Recursive Lookup**: If a .myCommand file is not found in the current directory, the script searches parent directories until one is found.
+- **Merged Configurations**: Reads .myCommand files from the root directory down to the present working directory, merging them to build a complete command set. If duplicates are found, the command closest to the current directory takes precedence.
+- **Sectioned Commands**: Uses INI-style sections in .myCommand files to organize and access commands with dot-delimited syntax. This allows grouping related commands for better clarity and organization:
+
+```ini
+[server]
+start="docker-compose up"
+stop="docker-compose down"
+```
+
+Running `my server.start` will execute docker-compose up.
+
+- **Argument Passing**: Additional arguments provided after the command alias are passed directly to the underlying command. This enables dynamic behavior and flexible command usage.
+- **Fallback to Shell**: If the requested alias is not found in the merged .myCommand configurations, the script will pass the command to the shell, allowing standard shell commands to work seamlessly with `my`.
+- **Cross-Domain Commands with Variables**: Commands can reference variables set in different .myCommand files, allowing for reusable, high-level command configurations across directories. This feature is useful for defining generic commands in higher-level folders and reusing them in specific contexts within the workspace.
+
+
+
+## Usage
+
+### Basic Structure of `.myCommand` File
+
+The `.myCommand` files uses INI-style sections to allow optional grouping, and key-value pairs where each key is an alias for a command, and the value is the corresponding command.
+
+Example `.myCommand` file:
+
+```ini
+# Variables
+LAST_CONTAINER="podman exec -it"
+DB_CONTAINER="pod-db"
+
+# Commands
+echo=echo "Custom Prefix: "
+npm="$LAST_CONTAINER npm"
+
+[db]
+backup=podman exec --interactive --tty --rm $DB_CONTAINER mongodump
+restore=podman exec --interactive --tty --rm $DB_CONTAINER mongorestore
+```
+
+### Running the my Script
+
+Create a `.myCommand` file in the root of your project or any directory where you want to define custom commands.
+Run the `my` script followed by the *alias* you want to execute, and any additional arguments you may want to pass.
+For example, if you're in a directory with the previous `.myCommand` file:
+
+```bash
+# Usage:
+#    my <alias>
+
+my echo Hello World
+#> Custom Prefix: Hello World
+
+my db.backup --gzip 
+# Runs: podman exec --interactive --tty --rm pod-db mongodump --gzip
+```
+
+### Arguments
+
+The `my` script has the following internal commands.
+These commands take priority over any keys or aliases of the same name that are defined in any `.myCommand` files, ***so consider them reserved keywords.***
+
+`help`:
+Don't worry if you forget the basics.  
+Simply type `my help` to view the usage details.
+
+`version`:
+Not sure if you have the latest version installed?  
+Just run `my version` and compare against the latest version on [GitHub](https://github.com/jerrens/MyCE)
+
+`set <cmd> <value>`:
+**Experimental!**
+This command may be used to add a new value to the `.myCommand` file in the current directory.
+The first argument is the key/alias, all remaining arguments will be treated as the value.
+If the command should belong inside an INI section, then use a '.' to separate group from the key.
+For example:
+
+```bash
+my set group.key echo "Hello World"
+```
+
+Will be stored as:
+
+```ini
+[group]
+key=echo "Hello World"
+```
+
+`list [-l]`:
+Can't remember what you used as the key?
+Just enter `my list` to view the available commands.
+If you don't like columns, add the `-l` option at the end to show one command per line
+
+
+### Options
+
+Options for the `my` script should be added immediately following the `my` script call (before the key).
+
+`-v | -vv | -vvv`:
+Log prints can be enabled for debugging by including the `-v` option.
+Crank up the level by stacking more (`-vv`, `-vvv`).
+Three levels is currently the most verbosity used in log prints, but if you get a little trigger happy with the `v` key, it will be ok.
+
+Example: `my -vv build`
+
+`-d`:
+Curious how your `.myCommand` entries will expand, but not brave enough to just try?
+A dry run can be enabled by using the `-d` option.
+In dry run mode, the expanded command will be printed, but not executed
+
+Example: `my -d build`
+
+
+## Command Lookup Process
+
+1. **Merging and Overriding**:
+    The script starts at the root directory, working down to the current directory (pwd), merging any `.myCommand` files found along the way.
+    Commands defined in `.myCommand` files closer to the current directory override duplicates from higher-level directories.
+    This makes the command engine adaptable for different projects without the need for globally defined aliases.
+
+2. **Sectioned Access**:
+    Commands are referenced using `section.key` syntax if using INI-style sections.
+
+3. **Fallback to Shell**:
+    If no matching alias is found, the command is sent to the shell for evaluation.
+
+### Handling Variables Across Directories
+
+Variables can be set in .myCommand files at any directory level and accessed by commands in lower directories, allowing for flexible and reusable configurations.
+
+
+
+## Installation
+
+1. **Download the script**:
+    Ensure the script file (`my`) is placed in a directory that is included in your system's $PATH.
+
+1. **Make the script executable**:
+    Run the following command to give the script execute permissions: `chmod +x /path/to/my`
+
+1. **Create `.myCommand` files**:
+    Add a .myCommand file in the root directories of your projects.
+
+**Optional**: You can add my to your .bashrc or .zshrc for easier access:
+
+```bash
+alias my='/path/to/my'
+```
+
+
+## Example Workflow
+
+You have two repositories, Repo1 and Repo2, both with their own .myCommand files.
+
+```ini
+# Repo1's .myCommand file:
+build="mvn clean package"
+run="java -jar target/app.jar"
+```
+
+```ini
+# Repo2's .myCommand file:
+
+build="npm run build"
+run="npm start"
+```
+
+When you are working in **Repo1**. To build and run the application:
+
+```bash
+my build   # Executes 'mvn clean package'
+my run     # Executes 'java -jar target/app.jar'
+```
+
+You switch to **Repo2**. Now, running the same my build command:
+
+```bash
+my build   # Executes 'npm run build'
+my run   # Executes 'npm start'
+```
+
+The command executed changes based on the directory you are in, as it reads the `.myCommand` file from that directory.
+
+
+
+## Troubleshooting
+
+
+License
+MIT License
+
+This README provides a comprehensive guide for users to install, configure, and use My Command Engine. For further assistance or contributions, feel free to open an issue or submit a pull request.

TaskList.md

@@ -0,0 +1,8 @@
+# Task List
+
+## Things TODO
+
+[ ] - Always include ~/.myCommand regardless of directory
+[ ] - Command Complete (Linux TAB)
+[ ] - Filter list 
+[ ] - 

logo/Myce - Blue.png

@@ -17,7 +17,7 @@ This can be used to allow local overriding of certain commands to point to a con
 instead of the local installed command.
 
 USAGE:
-    ${__ScriptName} [-OPTIONS] [help | version | add | list [-l] | COMMAND [args...]]
+    ${__ScriptName} [-OPTIONS] [help | version | set | list [-l] | COMMAND [args...]]
         set <cmd> <value>    Adds or updates the 'cmd' to the ${MY_CUSTOM_FILE} file in the current directory.
                              This command should be run in the workspace root directory.
                              The given command will be used whenever called from this level or a descendant.