parabot 1.0.0

data/lib/parabot/cli/command_router.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../configuration"
+
+module Parabot
+  module CLI
+    # Routes commands to appropriate handlers based on command type
+    class CommandRouter
+      def initialize(registry)
+        @registry = registry
+      end
+
+      def find_builtin_command(args)
+        # Get all registered command names from the registry
+        result = @registry.get([])
+        node = result.instance_variable_get(:@node)
+        children = node.instance_variable_get(:@children).keys
+        aliases = node.instance_variable_get(:@aliases).keys
+        builtin_commands = children + aliases
+
+        args.find { |arg| builtin_commands.include?(arg) }
+      end
+
+      def find_custom_command(args)
+        custom_commands = Configuration.current.custom_commands
+        args.find { |arg| custom_commands.key?(arg) || custom_commands.key?(arg.to_sym) }
+      end
+
+      def route_command(args, parser)
+        # First, extract options to get project_root before any configuration access
+        options = parser.extract_options(args)
+
+        # Now identify if we have known builtin commands anywhere in args
+        builtin_command = find_builtin_command(args)
+
+        # Load configuration with proper project root early (skip for init command and help)
+        unless builtin_command == "init" || parser.help_requested?(args)
+          CLI.ensure_configuration_loaded(options[:config], options[:project_root])
+        end
+
+        if builtin_command
+          handle_builtin_command(args, builtin_command, parser)
+        elsif args.empty? || parser.only_options?(args)
+          handle_help([], parser)
+        elsif parser.help_requested?(args)
+          handle_help(args, parser)
+        else
+          # Check for custom commands or treat as message
+          custom_command = find_custom_command(args)
+          if custom_command
+            handle_custom_command(args, custom_command, parser)
+          else
+            handle_message(args, parser)
+          end
+        end
+      end
+
+      private
+
+      def handle_builtin_command(args, command, parser)
+        # Extract global options first
+        options = parser.extract_options(args)
+
+        # Remove global options, their values, and the command itself
+        remaining_args = parser.remove_options_and_values(args, command)
+        reordered_args = [command] + remaining_args
+
+        {
+          type: :builtin_command,
+          args: reordered_args,
+          options: options
+        }
+      end
+
+      def handle_custom_command(args, command, parser)
+        # Extract options and build message
+        options = parser.extract_options(args)
+        remaining_args = parser.remove_options_and_values(args, command)
+
+        custom_commands = Configuration.current.custom_commands
+        prompt = custom_commands[command] || custom_commands[command.to_sym]
+        message = [prompt, remaining_args.join(" ")].reject(&:empty?).join(" ")
+
+        {
+          type: :custom_command,
+          message: message,
+          options: options
+        }
+      end
+
+      def handle_message(args, parser)
+        # Treat entire input as message
+        options = parser.extract_options(args)
+        message_parts = parser.remove_options_and_values(args, nil) # No command to remove
+        message = message_parts.join(" ")
+
+        {
+          type: :message,
+          message: message,
+          options: options
+        }
+      end
+
+      def handle_help(args, parser)
+        options = parser.extract_options(args)
+        {
+          type: :help,
+          args: args.empty? ? ["help"] : args,
+          options: options
+        }
+      end
+    end
+  end
+end

data/lib/parabot/cli.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "commands"
+require_relative "configuration"
+require_relative "logging_setup"
+require_relative "cli/argument_parser"
+require_relative "cli/command_router"
+
+module Parabot
+  module CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register "commands", Parabot::Commands::CustomCommands
+      register "doctor", Parabot::Commands::Doctor
+      register "init", Parabot::Commands::Init
+      register "message", Parabot::Commands::Message, aliases: ["m"]
+      register "start", Parabot::Commands::Start, aliases: ["s"]
+      register "test", Parabot::Commands::Test, aliases: ["t"]
+      register "version", Parabot::Commands::Version, aliases: ["-v", "--version"]
+    end
+
+    def self.start(args)
+      parser = ArgumentParser.new
+      router = CommandRouter.new(Commands)
+      result = router.route_command(args, parser) # Configuration is already loaded in route_command
+
+      args_with_options =
+        case result[:type]
+        when :builtin_command
+          build_args_with_options(result[:args], result[:options])
+        when :custom_command, :message
+          build_args_with_options(["message", result[:message]], result[:options])
+        when :help
+          result[:args]
+        end
+
+      execute_builtin_command(args_with_options)
+    end
+
+    def self.ensure_configuration_loaded(config_file = nil, project_root = nil)
+      return if Configuration.instance_variable_get(:@instance)
+
+      Configuration.load(config_file, project_root)
+      LoggingSetup.setup_with_config(Configuration.current)
+    end
+
+    def self.build_args_with_options(args, options)
+      result = args.dup
+
+      # Add global options back to args for dry-cli
+      result << "--dry-run" if options[:dry_run]
+      result << "--force" if options[:force]
+      result += ["--config", options[:config]] if options[:config]
+      result += ["--language", options[:language]] if options[:language]
+      result += ["--timeout", options[:timeout].to_s] if options[:timeout]
+      result += ["--project-root", options[:project_root]] if options[:project_root]
+
+      result
+    end
+
+    # Simplified CLI that delegates to separate components
+    # This maintains backward compatibility while improving architecture
+
+    def self.execute_builtin_command(args)
+      cli = Dry::CLI.new(Commands)
+      cli.call(arguments: args)
+    end
+  end
+end

data/lib/parabot/commands/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../messaging/adapter_factory"
+require_relative "../dry_run_logging"
+
+module Parabot
+  module Commands
+    class Base < Dry::CLI::Command
+      include DryRunLogging
+
+      # Global options available to all commands
+      option :config, aliases: ["c"], type: :string, desc: "Path to configuration file"
+      option :language, aliases: ["l"], type: :string, desc: "Force language detection (elixir, ruby, etc.)"
+      option :dry_run, type: :boolean, default: false, desc: "Show what would be done without executing"
+      option :timeout, aliases: ["t"], type: :integer, default: 30, desc: "Timeout in seconds"
+      option :project_root, aliases: ["p"], type: :string, default: ".",
+                            desc: "Project root directory for configuration and file detection"
+
+      protected
+
+      def config
+        @config ||= Configuration.current
+      end
+
+      def logger
+        require "semantic_logger"
+        SemanticLogger[self.class.name]
+      end
+
+      def handle_dry_run(message)
+        return false unless dry_run?
+
+        dry_run_log(message)
+        show_dry_run_details if respond_to?(:show_dry_run_details, true)
+        true
+      end
+
+      def dry_run?
+        options[:dry_run]
+      end
+
+      def init(**options)
+        @options = options
+        @options[:project_root] ||= "."  # Set default when not provided
+        @options[:language] = parse_language_option(@options[:language])
+
+        validate_git_repository
+      end
+
+      def validate_git_repository
+        return if git_repository?
+
+        warning_message = "Warning: Not running in a git repository. Some features may be limited."
+        dry_run_log(warning_message)
+        logger.warn(warning_message)
+      end
+
+      private
+
+      def options
+        @options ||= {}
+      end
+
+      def git_repository?
+        project_root = @options[:project_root] || "."
+        system("git -C #{project_root.shellescape} rev-parse --is-inside-work-tree > /dev/null 2>&1")
+      end
+
+      def parse_language_option(language_option)
+        language_option.to_s.split(",").map(&:strip).map(&:to_sym)
+      end
+
+      def language_detector
+        @language_detector ||= LanguageDetector.new(config)
+      end
+
+      def test_runner
+        @test_runner ||= TestRunner.new(messaging_adapter, language_detector, dry_run: dry_run?, config: config,
+                                                                              language: options[:language])
+      end
+
+      def messaging_adapter
+        @messaging_adapter ||= Messaging::AdapterFactory.create(config.messaging_adapter, dry_run: dry_run?)
+      end
+
+      def handle_unexpected_error(error)
+        logger.error("Unexpected error: #{error.message}")
+        logger.debug(error.backtrace.join("\n"))
+      end
+
+      def format_message(message)
+        <<~MESSAGE
+          Mandatory: Refer to @#{Parabot::System.determine_system_path('.parabot.md', @options[:project_root])} for complete instructions and test analysis. Read it unless you have it in your context already.
+          #{message}
+        MESSAGE
+      end
+
+      def send_message(message)
+        message = format_message(message)
+        logger.info("Sending message to Claude...")
+        dry_run_log "Would send message: #{message}"
+
+        messaging_adapter.send_message(message)
+      end
+    end
+  end
+end

data/lib/parabot/commands/custom_commands.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Parabot
+  module Commands
+    class CustomCommands < Base
+      desc "List available custom commands"
+
+      def call(**)
+        return if handle_dry_run("Would list custom commands")
+
+        display_custom_commands
+      rescue ConfigurationError => e
+        handle_configuration_error(e)
+      rescue StandardError => e
+        handle_unexpected_error(e)
+      end
+
+      private
+
+      def display_custom_commands
+        logger.info("Loading and validating custom commands...")
+        custom_commands = config.custom_commands
+
+        if custom_commands.any?
+          show_commands(custom_commands)
+        else
+          show_no_commands_message
+        end
+      end
+
+      def show_commands(custom_commands)
+        puts "Available custom commands:"
+        custom_commands.each do |command, description|
+          puts "  #{command.to_s.ljust(15)} - #{truncated_description(description)}"
+        end
+        puts
+        logger.info("Found #{custom_commands.size} custom commands")
+      end
+
+      def truncated_description(description)
+        description.length > 60 ? "#{description[0..60]}..." : description
+      end
+
+      def show_no_commands_message
+        logger.error("No custom commands found in configuration")
+        puts "No custom commands configured."
+        puts "Add commands to your .parabot.yml file under the 'commands:' section."
+        exit(1)
+      end
+
+      def handle_configuration_error(error)
+        logger.error("Configuration error: #{error.message}")
+        exit(1)
+      end
+
+      def handle_unexpected_error(error)
+        logger.error("Unexpected error: #{error.message}")
+        logger.debug(error.backtrace.join("\n")) if options[:verbose]
+        exit(1)
+      end
+    end
+  end
+end

data/lib/parabot/commands/doctor.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require_relative "../configuration"
+require_relative "../cli"
+
+module Parabot
+  module Commands
+    class Doctor < Dry::CLI::Command
+      desc "Diagnose configuration and environment health"
+
+      argument :file, required: false, desc: "Specific config file to validate"
+      option :plain, type: :boolean, default: false, desc: "Plain text output for logging or files"
+      option :project_root, aliases: ["p"], type: :string, desc: "Project root directory for configuration"
+
+      example [
+        "parabot doctor                    # Check default configuration and environment",
+        "parabot doctor custom.yml        # Check specific config file",
+        "parabot doctor --plain           # Plain text output for logging or files"
+      ]
+
+      def call(file: nil, plain: false, project_root: nil, **)
+        @plain_output = plain
+        log("Running Parabot health check...", :health_check)
+
+        begin
+          # Load configuration
+          config = Configuration.load(file, project_root)
+
+          log("Configuration loaded successfully", :ok)
+          validate_config_schema(config)
+
+          log("Health check completed!", :success)
+        rescue ConfigurationError => e
+          log("Configuration error: #{e.message}", :error)
+          exit 1
+        rescue StandardError => e
+          log("Unexpected error: #{e.message}", :fatal)
+          exit 1
+        end
+      end
+
+      private
+
+      def validate_config_schema(config)
+        header("Schema Validation:")
+
+        # Check recommended sections
+        validate_section_presence(config, "languages")
+        validate_section_presence(config, "commands")
+
+        # Validate specific sections
+        validate_test_commands_schema(config)
+        validate_custom_commands_schema(config)
+        validate_languages_schema(config)
+      end
+
+      def validate_section_presence(config, section_name)
+        if config.config.respond_to?(section_name) && config.config.public_send(section_name)
+          log("#{section_name} section found", :ok)
+        else
+          log("Missing recommended section: #{section_name}", :warn)
+        end
+      end
+
+      def validate_test_commands_schema(config)
+        return unless config.config.languages
+
+        header("Test Commands:")
+        test_commands = {}
+
+        # Extract test commands from language configurations
+        config.config.languages.to_h.each do |lang, lang_config|
+          if lang_config&.[]("test_command") || lang_config&.[](:test_command)
+            test_command = lang_config["test_command"] || lang_config[:test_command]
+            test_commands[lang] = test_command
+          end
+        end
+
+        if test_commands.empty?
+          log("No test commands configured in any language", :warn)
+          return
+        end
+
+        test_commands.each do |lang, command|
+          next unless command.is_a?(String) && !command.empty?
+
+          cmd_name = command.split.first
+          if system("which #{cmd_name} > /dev/null 2>&1")
+            log("#{lang}: #{command}", :ok)
+          else
+            log("#{lang}: #{command} (command '#{cmd_name}' not found in PATH)", :error)
+          end
+        end
+      end
+
+      def validate_custom_commands_schema(config)
+        return unless config.config.commands
+
+        header("Custom Commands:")
+        commands = config.config.commands.to_h
+
+        if commands.empty?
+          log("No custom commands configured", :info)
+          return
+        end
+
+        commands.each do |cmd, value|
+          if value.is_a?(String) && !value.empty?
+            log("#{cmd}: #{value.length > 50 ? "#{value[0..47]}..." : value}", :ok)
+          else
+            log("#{cmd}: invalid command definition", :error)
+          end
+        end
+      end
+
+      def validate_languages_schema(config)
+        return unless config.config.languages
+
+        header("Languages:")
+        languages = config.config.languages
+
+        if languages.to_h.empty?
+          log("No language configurations found", :info)
+          return
+        end
+
+        languages.each do |lang, lang_config|
+          next unless lang_config
+
+          status_items = []
+          status_items << "system_prompt" if lang_config["system_prompt"] || lang_config[:system_prompt]
+          status_items << "test_guidance" if lang_config["test_guidance"] || lang_config[:test_guidance]
+
+          file_extensions = lang_config["file_extensions"] || lang_config[:file_extensions]
+          if file_extensions&.any?
+            extensions = Array(file_extensions).join(", ")
+            status_items << "extensions: #{extensions}"
+          end
+
+          if status_items.any?
+            log("#{lang}: #{status_items.join(', ')}", :ok)
+          else
+            log("#{lang}: incomplete configuration", :warn)
+          end
+        end
+      end
+
+      # Doctor-specific output methods
+      def log(message, icon = nil)
+        formatted = format_with_icon(message, icon)
+        Kernel.puts formatted
+      end
+
+      def header(message)
+        Kernel.puts "" unless plain_output? # Add blank line before header
+        log(message, :info)
+      end
+
+      def format_with_icon(message, icon)
+        return message unless icon
+
+        # Use plain output if explicitly enabled
+        if plain_output?
+          text_icon = icon_to_text(icon)
+          text_icon ? "#{text_icon} #{message}" : message
+        else
+          emoji_icon = icon_to_emoji(icon)
+          emoji_icon ? "#{emoji_icon} #{message}" : message
+        end
+      end
+
+      def icon_to_emoji(icon)
+        case icon
+        when :success then "🎉"
+        when :error then "❌"
+        when :warn then "⚠️"
+        when :health_check then "🩺"
+        when :fatal then "💥"
+        when :ok then "🟢"
+        end
+      end
+
+      def icon_to_text(icon)
+        case icon
+        when :health_check then "[HEALTH CHECK]"
+        else "[#{icon.to_s.upcase}]"
+        end
+      end
+
+      def plain_output?
+        @plain_output || false
+      end
+    end
+  end
+end