patcmd 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e08b470213e3e2014f9dbb67081a5bedc21eb0a6914039ebfa5d95cfbc8aa21c
-  data.tar.gz: 968f2c23d043c84887920498c2075ee0e327de83a6f4c43c53ab24b421cec8f6
+  metadata.gz: ca00a46642b861edd38385a45ef93e6d6cae49f2dd0fec6a4a2237d19a90be14
+  data.tar.gz: c3bdbadaf8ab1fc83f712e4a41d64da0b5f3eb1b9e05f12d99fb0914172150db
 SHA512:
-  metadata.gz: 13b6bd069fa64889bb29aff3f5a6c46ea6a4eb7a0fd6e60eda28d1863391748911a840e9a376269d873424b7ba080dd69814b7f98c08368741444a5638546b0a
-  data.tar.gz: 26c39484a084cd4908c0a56dc0d5eff01af124b5f029d0c7ad0b818369e2ea684480e29e9885819434c270bfc299e7d43474de4dd05b448b8207f2c0290b2bf8
+  metadata.gz: 50203822923ae061412d63b46dc351d9550ded803316372582f2d16b45b49b007fb38ae8e925ef6c91f178c55660352a806ccae2cb771862173a56916413ce59
+  data.tar.gz: 44c94cfb0f3aa36c8883ff3b193ebcee6112e76a9155dac48448b9b363289f41ab4659dbfd2813702c8a94ab5d37972717af22351b1d0da60e2c2dcfe293bebb

data/README.md

@@ -1,111 +1,104 @@
-# PatCmd
+# Patcmd
 
 [![Gem Version](https://badge.fury.io/rb/patcmd.svg)](https://badge.fury.io/rb/patcmd)
 [![Build Status](https://github.com/patrick204nqh/patcmd/actions/workflows/ruby.yml/badge.svg)](https://github.com/patrick204nqh/patcmd/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
-PatCmd is a Ruby-based command-line interface (CLI) tool built with Thor, designed to manage and execute tasks efficiently. Whether you're automating scripts, managing deployments, or handling routine operations, PatCmd provides a streamlined and customizable solution.
+Patcmd is a Ruby gem that provides a command-line interface (CLI) for managing and executing tasks from a YAML configuration file. It helps centralize your terminal commands into one file, making it easy to trigger frequently used tasks with memorable aliases.
 
 ## Features
 
-- **Task Management:** Easily add, list, and execute tasks.
-- **Configurable Environments:** Define environment variables per task.
-- **Extensible:** Add new commands and functionalities as needed.
-- **User-Friendly:** Intuitive CLI with clear help documentation.
+- **Centralized Task Management:** Store your commands and scripts in a single YAML configuration file.
+- **Preconfigured Default Task:** When initialized, the configuration file includes a default "hello" task that prints "Hello World."
+- **Flexible Task Definitions:** Each task can have a command, arguments, environment variables, description, and group.
+- **Easy Command-Line Interface:** Use Thor to quickly add, list, and run tasks.
 
 ## Installation
 
-Ensure you have [Ruby](https://www.ruby-lang.org/en/downloads/) (version 3.0 or higher) installed on your system.
+Add this line to your application's Gemfile:
 
-### Install via RubyGems
-
-```bash
-gem install patcmd
-```
-
-### From Source
-
-1. Clone the Repository:
-
-```bash
-git clone https://github.com/yourusername/patcmd.git
-cd patcmd
+```ruby
+gem 'patcmd'
 ```
 
-2. Build the Gem:
+Then execute:
 
 ```bash
-gem build patcmd.gemspec
+bundle install
 ```
 
-3. Install the Gem Locally:
+Or install it yourself as:
 
 ```bash
-gem install ./patcmd-0.1.0.gem
+gem install patcmd
 ```
 
 ## Usage
 
-After installation, you can use `patcmd` directly from your terminal.
-
-### Initialize Configuration
+### Initializing the Configuration File
 
-Initialize the PatCmd configuration file. This creates a default configuration file where tasks are stored.
+To create the configuration file (located at `~/.patcmd/config.yml`), run:
 
 ```bash
 patcmd init
 ```
 
-Example Output:
-
-```bash
-Configuration initialized at /home/username/.patcmd/config.yml
-```
-
-### Add a New Task
-
-```bash
-patcmd add \                   
-  --name "Backup" \
-  --description "Backup the database" \
-  --category "Utility" \
-  --path "/usr/local/bin" \
-  --action "execute" \
-  --command "backup_db" \
-  --args db1 db2 \
-  --environments NOdE
+This command creates the file with a default task named **hello**. The default task is defined as follows:
+
+```yaml
+---
+tasks:
+  hello:
+    command: bash
+    args:
+    - "-c"
+    - '''echo "$GREETING, $TARGET! Args: $ARG1, $ARG2"'''
+    env:
+      GREETING: Hello
+      TARGET: World
+      ARG1: Foo
+      ARG2: Bar
+    description: Print Hello World with multiple arguments and environment variables
+    group: default
 ```
 
-### List All Tasks
+### Listing Tasks
 
-Display all configured tasks.
+To list all available tasks, run:
 
 ```bash
 patcmd list
 ```
 
-### Execute a Task
+### Adding a Task with Multiple Arguments and Environment Variables
+
+You can add custom tasks using the CLI. For example, to add a task called **complex** that demonstrates multiple arguments and environment variables, run:
 
 ```bash
-patcmd exec Utility Backup execute
+patcmd add complex \
+  --command "bash" \
+  --args "-c" "echo 'Value1: $VAL1, Value2: $VAL2, extra args: arg1 arg2'" \
+  --env VAL1=value1,VAL2=value2 \
+  --description "A complex task with many args and env variables" \
+  --group custom
 ```
 
-### Help
+*Note:* The `--env` option is expected to be passed as a hash. Adjust the input format as needed based on your CLI parsing.
+
+### Running a Task
 
-Access help information for all commands or a specific command.
+To execute a task, for example the default **hello** task, run:
 
 ```bash
-patcmd help
-patcmd help add
-patcmd help list
+patcmd exec hello
 ```
 
-### Configuration
+This command executes the task, applying the defined environment variables and arguments.
 
-PatCmd uses a YAML configuration file to store tasks and settings. The default configuration file is located at `~/.patcmd/config.yml`. You can specify a different configuration file using the --config option.
+## Contributing
 
-**Example:**
+Bug reports and pull requests are welcome on GitHub at [https://github.com/patrick204nqh/patcmd](https://github.com/patrick204nqh/patcmd).
 
-```bash
-patcmd list --config=/path/to/custom_config.yml
-```
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/lib/patcmd/cli.rb

@@ -1,13 +1,25 @@
 # frozen_string_literal: true
 
-require "patcmd/cli/logger"
-require "patcmd/cli/configuration_manager"
-require "patcmd/cli/task_executor"
-require "patcmd/cli/presenters"
-require "patcmd/cli/services"
-require "patcmd/cli/commands"
+require "thor"
+require_relative "commands/version"
+require_relative "commands/init"
+require_relative "commands/list"
+require_relative "commands/add"
+require_relative "commands/exec"
 
 module Patcmd
-  module CLI
+  class CLI < Thor
+    class << self
+      def exit_on_failure?
+        true
+      end
+    end
+
+    # Register subcommands with Thor
+    register(Commands::Version, "version", "version", "Show Patcmd gem version")
+    register(Commands::Init, "init", "init", "Initialize configuration file")
+    register(Commands::List, "list", "list", "List all tasks")
+    register(Commands::Add, "add", "add NAME", "Add a new task")
+    register(Commands::Exec, "exec", "exec NAME", "Exec a specific task")
   end
 end

data/lib/patcmd/commands/add.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "patcmd/configuration"
+
+module Patcmd
+  module Commands
+    class Add < Base
+      desc "add NAME", "Add a new task"
+      option :description, desc: "Task description"
+      option :group, desc: "Task group"
+      option :command, required: true, desc: "The command to run"
+      option :args, type: :array, default: [], desc: "Command arguments"
+      option :env, type: :hash, default: {}, desc: "Environment variables"
+      def execute(name)
+        new_task = {
+          "description" => options[:description] || "",
+          "group" => options[:group] || "default",
+          "command" => options[:command],
+          "args" => options[:args],
+          "env" => options[:env],
+        }
+        Configuration.add_task(name, new_task)
+        say("Task '#{name}' added successfully.", :green)
+      end
+    end
+  end
+end

data/lib/patcmd/commands/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Patcmd
+  module Commands
+    class Base < Thor
+      default_task :execute
+
+      desc "execute", "Execute the command"
+      def execute
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/patcmd/commands/exec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "patcmd/configuration"
+require "patcmd/task"
+
+module Patcmd
+  module Commands
+    class Exec < Base
+      desc "exec NAME", "Exec a specific task"
+      def execute(name)
+        tasks = Configuration.load_tasks
+        unless tasks[name]
+          say("Task '#{name}' not found.", :red)
+          exit(1)
+        end
+        task = Task.new(name, tasks[name])
+        say("Running task '#{name}'...", :green)
+        task.execute
+      end
+    end
+  end
+end

data/lib/patcmd/commands/init.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "patcmd/configuration"
+
+module Patcmd
+  module Commands
+    class Init < Base
+      desc "init", "Initialize configuration file"
+      def execute(*)
+        if Configuration.exists?
+          say("Configuration file already exists at #{Configuration::CONFIG_PATH}", :yellow)
+        else
+          Configuration.create_default
+          say("Initialized configuration file at #{Configuration::CONFIG_PATH}", :green)
+        end
+      end
+    end
+  end
+end

data/lib/patcmd/commands/list.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "patcmd/configuration"
+require "patcmd/task"
+
+module Patcmd
+  module Commands
+    class List < Base
+      desc "list", "List all tasks"
+      def execute(*)
+        tasks = Configuration.load_tasks
+        if tasks.empty?
+          say("No tasks found. Use 'patcmd add <name>' to add tasks.", :yellow)
+        else
+          tasks.each do |name, task_data|
+            task = Task.new(name, task_data)
+            say("#{name} - #{task.description}", :blue)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/patcmd/commands/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "patcmd/version"
+
+module Patcmd
+  module Commands
+    class Version < Base
+      desc "version", "Show Patcmd gem version"
+      def execute(*)
+        say("Patcmd version #{Patcmd::VERSION}", :green)
+      end
+    end
+  end
+end

data/lib/patcmd/configuration.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Patcmd
+  class Configuration
+    CONFIG_PATH = File.expand_path("~/.patcmd/config.yml")
+
+    class << self
+      def exists?
+        File.exist?(CONFIG_PATH)
+      end
+
+      def create_default
+        default_config = {
+          "tasks" => {
+            "hello" => {
+              "command" => "bash",
+              "args" => ["-c", "'echo \"$GREETING, $TARGET! Args: $ARG1, $ARG2\"'"],
+              "env" => {
+                "GREETING" => "Hello",
+                "TARGET" => "World",
+                "ARG1" => "Foo",
+                "ARG2" => "Bar",
+              },
+              "description" => "Print Hello World with multiple arguments and environment variables",
+              "group" => "default",
+            },
+          },
+        }
+        File.write(CONFIG_PATH, default_config.to_yaml)
+      end
+
+      def load_config
+        if exists?
+          YAML.load_file(CONFIG_PATH) || { "tasks" => {} }
+        else
+          create_default
+          load_config
+        end
+      end
+
+      def load_tasks
+        load_config["tasks"] || {}
+      end
+
+      def add_task(name, task_data)
+        config = load_config
+        config["tasks"] ||= {}
+        config["tasks"][name] = task_data
+        File.write(CONFIG_PATH, config.to_yaml)
+      end
+
+      # TODO: Implement update and remove methods as needed.
+    end
+  end
+end

data/lib/patcmd/task.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Patcmd
+  class Task
+    attr_accessor :name, :group, :description, :command, :args, :env
+
+    def initialize(name, attributes = {})
+      @name        = name
+      @description = attributes["description"] || ""
+      @group       = attributes["group"] || "default"
+      @command     = attributes["command"]
+      @args        = attributes["args"] || []
+      @env         = attributes["env"] || {}
+    end
+
+    def execute
+      # Save original environment variables
+      original_env = ENV.to_hash
+      # Set the specified environment variables
+      @env.each { |key, value| ENV[key] = value }
+
+      # Build and run the command string
+      full_command = [@command, *@args].join(" ")
+      system(full_command)
+
+      # Restore original environment.
+      ENV.replace(original_env)
+    end
+  end
+end

data/lib/patcmd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Patcmd
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patcmd
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Huy Nguyen
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-09 00:00:00.000000000 Z
+date: 2025-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -24,8 +24,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: PatCmd allows you to define and execute tasks using a simple command-line
-  interface.
+description: Patcmd is a Ruby CLI tool that centralizes command execution via a YAML
+  config file.
 email:
 - patrick204nqh@gmail.com
 executables:
@@ -45,25 +45,14 @@ files:
 - bin/patcmd
 - lib/patcmd.rb
 - lib/patcmd/cli.rb
-- lib/patcmd/cli/command_runner.rb
-- lib/patcmd/cli/commands.rb
-- lib/patcmd/cli/commands/add_command.rb
-- lib/patcmd/cli/commands/base_command.rb
-- lib/patcmd/cli/commands/core.rb
-- lib/patcmd/cli/commands/exec_command.rb
-- lib/patcmd/cli/commands/init_command.rb
-- lib/patcmd/cli/commands/list_command.rb
-- lib/patcmd/cli/configuration_manager.rb
-- lib/patcmd/cli/environment_preparer.rb
-- lib/patcmd/cli/logger.rb
-- lib/patcmd/cli/path_resolver.rb
-- lib/patcmd/cli/presenters.rb
-- lib/patcmd/cli/presenters/task_presenter.rb
-- lib/patcmd/cli/services.rb
-- lib/patcmd/cli/services/task_builder.rb
-- lib/patcmd/cli/services/task_validator.rb
-- lib/patcmd/cli/task.rb
-- lib/patcmd/cli/task_executor.rb
+- lib/patcmd/commands/add.rb
+- lib/patcmd/commands/base.rb
+- lib/patcmd/commands/exec.rb
+- lib/patcmd/commands/init.rb
+- lib/patcmd/commands/list.rb
+- lib/patcmd/commands/version.rb
+- lib/patcmd/configuration.rb
+- lib/patcmd/task.rb
 - lib/patcmd/version.rb
 - sig/patcmd.rbs
 homepage: https://github.com/patrick204nqh/patcmd
@@ -73,7 +62,8 @@ metadata:
   homepage_uri: https://github.com/patrick204nqh/patcmd
   source_code_uri: https://github.com/patrick204nqh/patcmd
   changelog_uri: https://github.com/patrick204nqh/patcmd/blob/main/CHANGELOG.md
-post_install_message:
+  documentation_uri: https://www.rubydoc.info/gems/patcmd
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -89,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.5.3
-signing_key:
+signing_key: 
 specification_version: 4
-summary: A CLI tool for running tasks quickly.
+summary: A CLI tool to manage tasks using a YAML configuration.
 test_files: []

data/lib/patcmd/cli/command_runner.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    class CommandRunner
-      def initialize(task, options, env_vars)
-        @task = task
-        @options = options
-        @env_vars = env_vars
-        @logger = Logger.new(verbose: options[:verbose])
-      end
-
-      def execute
-        command = prepare_command
-        path = PathResolver.expand(@task.path)
-
-        unless Dir.exist?(path)
-          @logger.error("Path not found: #{path}")
-          exit(1)
-        end
-
-        @logger.info("Executing '#{@task.description}' in #{path}")
-        @logger.info("Command: #{command}") if @options[:verbose]
-        @logger.info("Environment Variables: #{@env_vars}") if @options[:verbose] && @env_vars.any?
-
-        Dir.chdir(path) do
-          result = system(@env_vars, command)
-          unless result
-            @logger.error("Command execution failed.")
-            exit(1)
-          end
-        end
-        @logger.success("Command executed successfully.")
-      rescue KeyError => e
-        @logger.error("Missing option for command substitution: #{e.message}")
-        exit(1)
-      end
-
-      private
-
-      def prepare_command
-        substitution_vars = @options[:options] ? @options[:options].transform_keys(&:to_sym) : {}
-        cmd = @task.command % substitution_vars
-        args = @task.args.map { |arg| arg % substitution_vars }
-        ([cmd] + args).join(" ")
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands/add_command.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Commands
-      class AddCommand < BaseCommand
-        default_task :add
-
-        desc "add", "Add a new task to the config"
-        method_option :name,         aliases: "-n", required: true, desc: "Task name"
-        method_option :description,  aliases: "-d", required: true, desc: "Task description"
-        method_option :category,     aliases: "-c", required: true, desc: "Category name"
-        method_option :path,         aliases: "-p", required: true, desc: "Execution path"
-        method_option :action,       aliases: "-a", required: true, desc: "Action name"
-        method_option :command,      aliases: "-m", required: true, desc: "Command to execute"
-        method_option :args,         aliases: "-g", type: :array, default: [], desc: "Arguments for the command"
-        method_option :environments, aliases: "-e", type: :hash, default: {}, desc: "Environment variables"
-
-        def add
-          task = Services::TaskBuilder.build_from_options(options)
-          Services::TaskValidator.validate(task)
-          config_manager.add_task(task)
-          Presenters::TaskPresenter.new($stdout).display(task)
-          logger.success(
-            "Added task '#{task["name"]}' under category '#{task["category"]}' with action '#{task["action"]}'.",
-          )
-        rescue Services::TaskValidator::ValidationError => e
-          logger.error("Error: #{e.message}")
-          exit(1)
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands/base_command.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Commands
-      class BaseCommand < Thor
-        CONFIG_PATH = File.expand_path("~/.patcmd/config.yml")
-
-        # Define global options
-        class_option :config, type: :string, default: CONFIG_PATH, desc: "Path to configuration file"
-
-        def initialize(*args)
-          super
-          @config_manager = ConfigurationManager.new(options[:config])
-          @logger = Logger.new(verbose: options[:verbose])
-        end
-
-        private
-
-        attr_reader :config_manager, :logger
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands/core.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "patcmd/cli/commands/base_command"
-require "patcmd/cli/commands/init_command"
-require "patcmd/cli/commands/add_command"
-require "patcmd/cli/commands/list_command"
-require "patcmd/cli/commands/exec_command"
-
-module Patcmd
-  module CLI
-    module Commands
-      class Core < Thor
-        class << self
-          # Ensure the CLI exits with a non-zero status code on failure
-          def exit_on_failure?
-            true
-          end
-        end
-
-        register InitCommand, "init", "init", "Initialize the PatCmd configuration"
-        register AddCommand, "add", "add", "Add a new task to the config"
-        register ListCommand, "list", "list", "List all configured tasks"
-        register ExecCommand, "exec", "exec CATEGORY NAME ACTION", "Execute a defined task"
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands/exec_command.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Commands
-      class ExecCommand < BaseCommand
-        default_task :exec
-
-        desc "exec CATEGORY NAME ACTION", "Execute a defined task"
-        def exec(category, name, action)
-          task = config_manager.find_task(category, name, action)
-          if task
-            executor = TaskExecutor.new(task, options)
-            executor.execute
-          else
-            puts "Task not found for category '#{category}', name '#{name}', and action '#{action}'."
-            exit(1)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands/init_command.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Commands
-      class InitCommand < BaseCommand
-        default_task :init
-
-        desc "init", "Initialize the PatCmd configuration"
-        def init
-          config_manager.init_config
-          puts "Configuration initialized at #{config_manager.config_path}"
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands/list_command.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Commands
-      class ListCommand < BaseCommand
-        default_task :list
-
-        desc "list", "List all configured tasks"
-        def list
-          tasks = config_manager.all_tasks
-          if tasks.empty?
-            logger.info("No tasks configured.")
-          else
-            presenter = Presenters::TaskPresenter.new($stdout)
-            tasks.each { |task| presenter.display(task) }
-          end
-        rescue StandardError => e
-          logger.error("An error occurred while listing tasks: #{e.message}")
-          exit(1)
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/commands.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "thor"
-require "patcmd/cli/commands/core"
-
-module Patcmd
-  module CLI
-    class << self
-      def start(argv)
-        Commands::Core.start(argv)
-      end
-    end
-  end
-end

data/lib/patcmd/cli/configuration_manager.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    class ConfigurationManager
-      require "yaml"
-      require "fileutils"
-
-      attr_reader :config_path
-
-      def initialize(config_path)
-        @config_path = config_path
-        ensure_config_file
-        @config = load_config
-      end
-
-      def init_config
-        unless File.exist?(@config_path)
-          default_task = {
-            "category" => "Default",
-            "name" => "HelloWorld",
-            "description" => "A simple Hello World task",
-            "path" => "/usr/local/bin",
-            "action" => "execute",
-            "command" => "echo",
-            "args" => ["Hello, World!"],
-            "environments" => { "ENV" => "development" },
-          }
-
-          default_config = { "tasks" => [default_task] }
-          FileUtils.mkdir_p(File.dirname(@config_path))
-          File.write(@config_path, default_config.to_yaml)
-        end
-      end
-
-      def add_task(task)
-        @config["tasks"] << task
-        save_config
-      end
-
-      def find_task(category, name, action)
-        @config["tasks"].find do |task|
-          task["category"] == category && task["name"] == name && task["action"] == action
-        end
-      end
-
-      def all_tasks
-        @config["tasks"]
-      end
-
-      private
-
-      def ensure_config_file
-        unless File.exist?(@config_path)
-          init_config
-        end
-      end
-
-      def load_config
-        YAML.load_file(@config_path)
-      end
-
-      def save_config
-        File.write(@config_path, @config.to_yaml)
-      end
-    end
-  end
-end

data/lib/patcmd/cli/environment_preparer.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    class EnvironmentPreparer
-      def initialize(options = {})
-        @options = options
-      end
-
-      def prepare(env_vars)
-        substitution_vars = prepare_substitution_vars
-        env_vars.transform_values { |v| v % substitution_vars }
-      end
-
-      private
-
-      def prepare_substitution_vars
-        return {} unless @options[:options]
-
-        @options[:options].transform_keys(&:to_sym)
-      end
-    end
-  end
-end

data/lib/patcmd/cli/logger.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    class Logger
-      COLORS = {
-        info: "\e[34m", # Blue
-        success: "\e[32m", # Green
-        error: "\e[31m", # Red
-        warn: "\e[33m", # Yellow
-        reset: "\e[0m", # Reset
-      }.freeze
-
-      def initialize(verbose: false)
-        @verbose = verbose
-      end
-
-      def info(message)
-        log(:info, message)
-      end
-
-      def success(message)
-        log(:success, message)
-      end
-
-      def error(message)
-        log(:error, message)
-      end
-
-      def warn(message)
-        log(:warn, message)
-      end
-
-      private
-
-      def log(level, message)
-        return unless @verbose || level == :error
-
-        color = COLORS[level] || COLORS[:info]
-        puts "#{color}[#{level.to_s.upcase}]#{COLORS[:reset]} #{message}"
-      end
-    end
-  end
-end

data/lib/patcmd/cli/path_resolver.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    class PathResolver
-      class << self
-        def expand(path)
-          return if path.nil? || path.strip.empty?
-
-          # Expand tilde (~) and substitute environment variables
-          expanded_path = path.gsub("~", Dir.home)
-          expanded_path.gsub!(/\$\{([^\}]+)\}/) { ENV[::Regexp.last_match(1)] || "" }
-
-          # Ensure the path does not double-resolve
-          File.expand_path(expanded_path)
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/presenters/task_presenter.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Presenters
-      class TaskPresenter
-        def initialize(output = $stdout)
-          @output = output
-        end
-
-        def display(task)
-          @output.puts "Category: #{task["category"]}"
-          @output.puts "  Name: #{task["name"]}"
-          @output.puts "  Action: #{task["action"]}"
-          @output.puts "  Description: #{task["description"]}"
-          @output.puts "  Path: #{task["path"]}"
-          @output.puts "  Command: #{task["command"]}"
-          @output.puts "  Args: #{task["args"].join(" ")}" if task["args"]&.any?
-          if task["environments"]&.any?
-            envs = task["environments"].map { |k, v| "#{k}=#{v}" }.join(", ")
-            @output.puts "  Environments: #{envs}"
-          end
-          @output.puts "-" * 40
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/presenters.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Presenters
-      Dir[File.join(__dir__, "presenters", "*.rb")].each do |file|
-        require file
-      end
-    end
-  end
-end

data/lib/patcmd/cli/services/task_builder.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Services
-      class TaskBuilder
-        class << self
-          def build_from_options(options)
-            {
-              "name" => options[:name],
-              "description" => options[:description],
-              "category" => options[:category],
-              "path" => options[:path],
-              "action" => options[:action],
-              "command" => options[:command],
-              "args" => options[:args],
-              "environments" => options[:environments],
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/services/task_validator.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Services
-      class TaskValidator
-        class ValidationError < StandardError; end
-
-        REQUIRED_FIELDS = ["name", "description", "category", "path", "action", "command"].freeze
-
-        class << self
-          def validate(task)
-            missing_fields = REQUIRED_FIELDS.select { |field| task[field].nil? || task[field].strip.empty? }
-
-            unless missing_fields.empty?
-              raise ValidationError, "Missing required fields: #{missing_fields.join(", ")}"
-            end
-
-            unless task["args"].is_a?(Array)
-              raise ValidationError, "The 'args' field must be an array."
-            end
-
-            unless task["environments"].is_a?(Hash)
-              raise ValidationError, "The 'environments' field must be a hash."
-            end
-
-            true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/patcmd/cli/services.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    module Services
-      Dir[File.join(__dir__, "services", "*.rb")].each do |file|
-        require file
-      end
-    end
-  end
-end

data/lib/patcmd/cli/task.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Patcmd
-  module CLI
-    class Task
-      attr_reader :description, :command, :args, :environments, :path
-
-      def initialize(task)
-        @description = task["description"]
-        @command = task["command"]
-        @args = task["args"] || []
-        @environments = task["environments"] || {}
-        @path = task["path"]
-      end
-    end
-  end
-end

data/lib/patcmd/cli/task_executor.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "patcmd/cli/task"
-require "patcmd/cli/environment_preparer"
-require "patcmd/cli/command_runner"
-require "patcmd/cli/path_resolver"
-
-module Patcmd
-  module CLI
-    class TaskExecutor
-      def initialize(task, options)
-        @task = Task.new(task)
-        @options = options
-      end
-
-      def execute
-        env_vars = EnvironmentPreparer.new(@options).prepare(@task.environments)
-        CommandRunner.new(@task, @options, env_vars).execute
-      end
-    end
-  end
-end