aidp 0.32.0 → 0.34.0

data/lib/aidp/loader.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+module Aidp
+  # Zeitwerk-based class loader with hot code reloading support
+  #
+  # This module configures Zeitwerk for autoloading AIDP classes and provides
+  # a reload capability similar to Rails development mode. When files change
+  # (e.g., after git pull in watch mode), calling Aidp::Loader.reload! will
+  # unload all classes and allow them to be reloaded on next reference.
+  #
+  # @example Enable reloading in development
+  #   Aidp::Loader.setup(enable_reloading: true)
+  #   # ... code changes on disk ...
+  #   Aidp::Loader.reload!
+  #
+  # @example Production mode (no reloading)
+  #   Aidp::Loader.setup(enable_reloading: false)
+  #   Aidp::Loader.eager_load!
+  module Loader
+    class << self
+      # @return [Zeitwerk::Loader, nil] The configured loader instance
+      attr_accessor :loader
+
+      # @return [Boolean] Whether reloading is enabled
+      attr_accessor :reloading_enabled
+
+      # Set up the Zeitwerk loader for AIDP
+      #
+      # @param enable_reloading [Boolean] Whether to enable hot reloading
+      # @param eager_load [Boolean] Whether to eager load all classes
+      # @return [Zeitwerk::Loader] The configured loader
+      def setup(enable_reloading: false, eager_load: false)
+        return @loader if @loader
+
+        Aidp.log_debug("loader", "setup_started",
+          enable_reloading: enable_reloading,
+          eager_load: eager_load)
+
+        @reloading_enabled = enable_reloading
+        @loader = create_loader
+        configure_inflections(@loader)
+        configure_ignores(@loader)
+
+        if enable_reloading
+          @loader.enable_reloading
+          Aidp.log_debug("loader", "reloading_enabled")
+        end
+
+        @loader.setup
+
+        if eager_load && !enable_reloading
+          @loader.eager_load
+          Aidp.log_debug("loader", "eager_load_complete")
+        end
+
+        Aidp.log_info("loader", "setup_complete",
+          reloading: enable_reloading,
+          eager_loaded: eager_load && !enable_reloading)
+
+        @loader
+      end
+
+      # Reload all autoloaded classes
+      #
+      # This unloads all classes managed by Zeitwerk and allows them to be
+      # reloaded on next reference. Only works if enable_reloading was true
+      # during setup.
+      #
+      # @return [Boolean] Whether reload was performed
+      def reload!
+        unless @loader
+          Aidp.log_warn("loader", "reload_skipped", reason: "loader_not_setup")
+          return false
+        end
+
+        unless @reloading_enabled
+          Aidp.log_warn("loader", "reload_skipped", reason: "reloading_disabled")
+          return false
+        end
+
+        Aidp.log_info("loader", "reload_started")
+
+        begin
+          @loader.reload
+          Aidp.log_info("loader", "reload_complete")
+          true
+        rescue => e
+          Aidp.log_error("loader", "reload_failed", error: e.message)
+          false
+        end
+      end
+
+      # Check if loader is set up for reloading
+      #
+      # @return [Boolean]
+      def reloading?
+        @reloading_enabled == true
+      end
+
+      # Check if loader is set up
+      #
+      # @return [Boolean]
+      def setup?
+        !@loader.nil?
+      end
+
+      # Eager load all classes (production mode)
+      #
+      # @return [void]
+      def eager_load!
+        @loader&.eager_load
+      end
+
+      # Reset the loader (mainly for testing)
+      #
+      # @return [void]
+      def reset!
+        if @loader
+          begin
+            @loader.unload if @reloading_enabled
+          rescue Zeitwerk::SetupRequired
+            # If loader was never set up, skip unload
+          end
+          @loader.unregister
+        end
+        @loader = nil
+        @reloading_enabled = false
+      end
+
+      private
+
+      def create_loader
+        loader = Zeitwerk::Loader.new
+        loader.tag = "aidp"
+
+        # Set the root directory for autoloading
+        lib_path = File.expand_path("..", __dir__)
+        loader.push_dir(lib_path, namespace: Object)
+
+        loader
+      end
+
+      # Configure inflections for non-standard class names
+      def configure_inflections(loader)
+        loader.inflector.inflect(
+          # AI-prefixed classes
+          "ai_decision_engine" => "AIDecisionEngine",
+          "ai_filter_factory" => "AIFilterFactory",
+
+          # Acronym-based names
+          "kb_inspector" => "KBInspector",
+          "ui_state" => "UIState",
+          "ui_error" => "UIError",
+          "rspec_filter_strategy" => "RSpecFilterStrategy",
+
+          # TTY-related
+          "tui" => "TUI",
+          "enhanced_tui" => "EnhancedTUI",
+
+          # Other acronyms
+          "pr_worktree_manager" => "PRWorktreeManager",
+          "csv_storage" => "CSVStorage",
+          "cli" => "CLI",
+          "ruby_llm_registry" => "RubyLLMRegistry",
+          "rubygems_api_adapter" => "RubyGemsAPIAdapter",
+          "submenu" => "SubMenu",
+          "terminal_io" => "TerminalIO",
+
+          # Module folders
+          "ui" => "UI"
+        )
+      end
+
+      # Configure files/directories to ignore
+      def configure_ignores(loader)
+        # Ignore files that are manually required before Zeitwerk
+        loader.ignore(File.expand_path("version.rb", __dir__))
+        loader.ignore(File.expand_path("core_ext", __dir__))
+        loader.ignore(File.expand_path("logger.rb", __dir__))
+        loader.ignore(File.expand_path("cli/issue_importer.rb", __dir__))
+        loader.ignore(File.expand_path("config/paths.rb", __dir__))
+
+        # Ignore the loader itself
+        loader.ignore(__FILE__)
+
+        # Ignore files with multiple constants (require manually after setup)
+        loader.ignore(File.expand_path("auto_update/errors.rb", __dir__))
+        loader.ignore(File.expand_path("errors.rb", __dir__))
+        loader.ignore(File.expand_path("harness/state/errors.rb", __dir__))
+      end
+    end
+  end
+end

data/lib/aidp/logger.rb

@@ -307,6 +307,9 @@ module Aidp
 
   # Module-level logger accessor
   class << self
+    # Expose for testability
+    attr_writer :logger
+
     # Set up global logger instance
     def setup_logger(project_dir = Dir.pwd, config = {})
       @logger = Logger.new(project_dir, config)

data/lib/aidp/message_display.rb

@@ -8,6 +8,11 @@ module Aidp
   #   include Aidp::MessageDisplay
   #   display_message("Hello", type: :success)
   # Supports color types: :error, :success, :warning, :info, :highlight, :muted
+  #
+  # Quiet mode:
+  #   When quiet mode is enabled (via CLI --quiet flag or setting quiet=true on instance),
+  #   only :error, :warning, and :success messages are displayed. Info, highlight, and muted
+  #   messages are suppressed to reduce output noise.
   module MessageDisplay
     COLOR_MAP = {
       error: :red,
@@ -19,12 +24,28 @@ module Aidp
       muted: :bright_black
     }.freeze
 
+    # Message types that are always shown even in quiet mode
+    CRITICAL_TYPES = %i[error warning warn success].freeze
+
     def self.included(base)
       base.extend(ClassMethods)
     end
 
+    # Check if quiet mode is enabled
+    # Priority: instance @quiet variable > CLI.last_options[:quiet]
+    def quiet_mode?
+      return @quiet if instance_variable_defined?(:@quiet) && !@quiet.nil?
+
+      Aidp::CLI.last_options&.dig(:quiet) || false
+    rescue
+      false
+    end
+
     # Instance helper for displaying a colored message via TTY::Prompt
     def display_message(message, type: :info)
+      # In quiet mode, suppress non-critical messages
+      return if quiet_mode? && !CRITICAL_TYPES.include?(type)
+
       # Ensure message is UTF-8 encoded to handle emoji and special characters
       message_str = message.to_s
       message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -43,8 +64,18 @@ module Aidp
     end
 
     module ClassMethods
+      # Check if quiet mode is enabled at class level
+      def quiet_mode?
+        Aidp::CLI.last_options&.dig(:quiet) || false
+      rescue
+        false
+      end
+
       # Class-level display helper (uses fresh prompt to respect $stdout changes)
       def display_message(message, type: :info)
+        # In quiet mode, suppress non-critical messages
+        return if quiet_mode? && !CRITICAL_TYPES.include?(type)
+
         # Ensure message is UTF-8 encoded to handle emoji and special characters
         message_str = message.to_s
         message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"

data/lib/aidp/metadata/compiler.rb

@@ -39,7 +39,7 @@ module Aidp
         Aidp.log_info("metadata", "Compiling tool directory", directories: @directories, output: output_path)
 
         # Scan all directories
-        scanner = Scanner.new(@directories)
+        scanner = Scanner.new(@directories, strict: @strict)
         @tools = scanner.scan_all
 
         # Validate tools
@@ -47,14 +47,24 @@ module Aidp
         validation_results = validator.validate_all
 
         # Handle validation failures
-        handle_validation_results(validation_results)
+        parse_error_results = scanner.parse_errors.map do |err|
+          Validator::ValidationResult.new(
+            tool_id: "(unknown)",
+            file_path: err[:file],
+            valid: false,
+            errors: [err[:error]],
+            warnings: []
+          )
+        end
+
+        invalid_results = handle_validation_results(validation_results + parse_error_results)
 
         # Build indexes and graphs
         build_indexes
         build_dependency_graph
 
         # Create directory structure
-        directory = create_directory_structure
+        directory = create_directory_structure(invalid_results: invalid_results)
 
         # Write to file
         write_directory(directory, output_path)
@@ -142,22 +152,23 @@ module Aidp
       # Create directory structure for serialization
       #
       # @return [Hash] Directory structure
-      def create_directory_structure
+      def create_directory_structure(invalid_results: [])
         {
-          version: "1.0.0",
-          compiled_at: Time.now.iso8601,
-          tools: @tools.map(&:to_h),
-          indexes: {
-            by_type: @indexes[:by_type].transform_values { |tools| tools.map(&:id) },
-            by_tag: @indexes[:by_tag].transform_values { |tools| tools.map(&:id) },
-            by_work_unit_type: @indexes[:by_work_unit_type].transform_values { |tools| tools.map(&:id) }
+          "version" => "1.0.0",
+          "compiled_at" => Time.now.iso8601,
+          "tools" => @tools.map(&:to_h),
+          "indexes" => {
+            "by_type" => @indexes[:by_type].transform_values { |tools| tools.map(&:id) },
+            "by_tags" => @indexes[:by_tag].transform_values { |tools| tools.map(&:id) },
+            "by_work_unit_type" => @indexes[:by_work_unit_type].transform_values { |tools| tools.map(&:id) }
           },
-          dependency_graph: @dependency_graph,
-          statistics: {
-            total_tools: @tools.size,
-            by_type: @tools.group_by(&:type).transform_values(&:size),
-            total_tags: @indexes[:by_tag].size,
-            total_work_unit_types: @indexes[:by_work_unit_type].size
+          "dependency_graph" => @dependency_graph,
+          "errors" => invalid_results.map { |res| {"tool_id" => res.tool_id, "errors" => res.errors, "warnings" => res.warnings} },
+          "statistics" => {
+            "total_tools" => @tools.size,
+            "by_type" => @tools.group_by(&:type).transform_values(&:size),
+            "total_tags" => @indexes[:by_tag].size,
+            "total_work_unit_types" => @indexes[:by_work_unit_type].size
           }
         }
       end
@@ -223,6 +234,7 @@ module Aidp
             warnings: result.warnings
           )
         end
+        invalid_results
       end
     end
   end

data/lib/aidp/metadata/query.rb

@@ -64,7 +64,7 @@ module Aidp
         Aidp.log_debug("metadata", "Finding by tags", tags: tags, match_all: match_all)
 
         tags = Array(tags).map(&:downcase)
-        indexes = directory["indexes"]["by_tag"]
+        indexes = directory["indexes"]["by_tags"] || {}
 
         if match_all
           # Find tools that have ALL specified tags

data/lib/aidp/metadata/scanner.rb

@@ -17,16 +17,21 @@ module Aidp
       # Initialize scanner with directory paths
       #
       # @param directories [Array<String>] Directories to scan
-      def initialize(directories = [])
+      def initialize(directories = [], strict: false)
         @directories = Array(directories)
+        @strict = strict
+        @parse_errors = []
       end
 
+      attr_reader :parse_errors
+
       # Scan all configured directories
       #
       # @return [Array<ToolMetadata>] All discovered tool metadata
       def scan_all
         Aidp.log_debug("metadata", "Scanning directories", directories: @directories)
 
+        @parse_errors = []
         all_tools = []
         @directories.each do |dir|
           tools = scan_directory(dir)
@@ -69,6 +74,8 @@ module Aidp
             file: file_path,
             error: e.message
           )
+          @parse_errors << {file: file_path, error: e.message}
+          raise if @strict
         end
 
         Aidp.log_debug(

data/lib/aidp/metadata/tool_metadata.rb

@@ -146,19 +146,19 @@ module Aidp
       # @return [Hash] Metadata as hash (for JSON)
       def to_h
         {
-          type: type,
-          id: id,
-          title: title,
-          summary: summary,
-          version: version,
-          applies_to: applies_to,
-          work_unit_types: work_unit_types,
-          priority: priority,
-          capabilities: capabilities,
-          dependencies: dependencies,
-          experimental: experimental,
-          source_path: source_path,
-          file_hash: file_hash
+          "type" => type,
+          "id" => id,
+          "title" => title,
+          "summary" => summary,
+          "version" => version,
+          "applies_to" => applies_to,
+          "work_unit_types" => work_unit_types,
+          "priority" => priority,
+          "capabilities" => capabilities,
+          "dependencies" => dependencies,
+          "experimental" => experimental,
+          "source_path" => source_path,
+          "file_hash" => file_hash
         }
       end
 

data/lib/aidp/metadata/validator.rb

@@ -84,6 +84,10 @@ module Aidp
           warnings << "Tool content is very short (#{tool.content.length} characters)"
         end
 
+        unless valid_version_format?(tool.version)
+          warnings << "Version '#{tool.version}' is not in semver format (MAJOR.MINOR.PATCH)"
+        end
+
         ValidationResult.new(
           tool_id: tool.id,
           file_path: tool.source_path,
@@ -156,6 +160,12 @@ module Aidp
         # For now, this is a placeholder for future deprecation warnings
       end
 
+      def valid_version_format?(version)
+        version.to_s.match?(/\A\d+\.\d+\.\d+\z/)
+      rescue
+        false
+      end
+
       # Write validation errors to log file
       #
       # @param results [Array<ValidationResult>] Validation results

data/lib/aidp/metadata.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Aidp
+  # Namespace marker for metadata components
+  module Metadata
+  end
+end
+
+# Load key metadata components
+require_relative "metadata/parser"
+require_relative "metadata/tool_metadata"
+require_relative "metadata/scanner"
+require_relative "metadata/validator"
+require_relative "metadata/compiler"
+require_relative "metadata/cache"
+require_relative "metadata/query"

data/lib/aidp/pr_worktree_manager.rb

@@ -3,15 +3,27 @@ require "fileutils"
 require "shellwords"
 
 module Aidp
+  # Simple shell command executor wrapper for testability
+  class ShellExecutor
+    def run(command)
+      `#{command}`
+    end
+
+    def success?
+      $?.success?
+    end
+  end
+
   # Manages worktrees specifically for Pull Request branches
-  class PrWorktreeManager
-    def initialize(base_repo_path: nil, project_dir: nil, worktree_registry_path: nil)
+  class PRWorktreeManager
+    def initialize(base_repo_path: nil, project_dir: nil, worktree_registry_path: nil, shell_executor: nil)
       @base_repo_path = base_repo_path || project_dir || Dir.pwd
       @project_dir = project_dir
       @worktree_registry_path = worktree_registry_path || File.join(
         project_dir || File.expand_path("~/.aidp"),
         "pr_worktrees.json"
       )
+      @shell_executor = shell_executor || ShellExecutor.new
       FileUtils.mkdir_p(File.dirname(@worktree_registry_path))
       @worktrees = load_registry
     end
@@ -258,7 +270,7 @@ module Aidp
 
       # Advanced change detection patterns
       file_patterns = [
-        /(?:modify|update|add|delete)\s+file:\s*([^\n]+)/i,
+        /(modify|update|add|delete)\s+file:\s*([^\n]+)/i,
         /\[(\w+)\]\s*([^\n]+)/,           # GitHub-style change indicators
         /(?:Action:\s*(\w+))\s*File:\s*([^\n]+)/i
       ]
@@ -427,7 +439,7 @@ module Aidp
 
       Dir.chdir(worktree_path) do
         # Check staged changes with more robust capture
-        staged_changes_output = `git diff --staged --name-only`.strip
+        staged_changes_output = @shell_executor.run("git diff --staged --name-only").strip
 
         if !staged_changes_output.empty?
           push_result[:git_actions][:staged_changes] = true
@@ -436,16 +448,16 @@ module Aidp
           # More robust commit command with additional logging
           commit_message = "Changes applied via AIDP request-changes workflow for PR ##{pr_number}"
           commit_command = "git commit -m '#{commit_message}' 2>&1"
-          commit_output = `#{commit_command}`.strip
+          commit_output = @shell_executor.run(commit_command).strip
 
-          if $?.success?
+          if @shell_executor.success?
             push_result[:git_actions][:committed] = true
 
             # Enhanced push with verbose tracking
             push_command = "git push origin #{head_branch} 2>&1"
-            push_output = `#{push_command}`.strip
+            push_output = @shell_executor.run(push_command).strip
 
-            if $?.success?
+            if @shell_executor.success?
               push_result[:git_actions][:pushed] = true
               push_result[:success] = true
 

data/lib/aidp/provider_manager.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require "tty-prompt"
-require_relative "harness/provider_factory"
 
 module Aidp
   class ProviderManager
     class << self
+      # Expose for testability
+      attr_accessor :harness_factory
+
       def get_provider(provider_type, options = {})
         factory = get_harness_factory
         raise "Harness factory not available" unless factory
@@ -20,12 +22,7 @@ module Aidp
 
       # Get harness factory instance
       def get_harness_factory
-        @harness_factory ||= begin
-          require_relative "harness/config_manager"
-          Aidp::Harness::ProviderFactory.new
-        rescue LoadError
-          nil
-        end
+        @harness_factory ||= Aidp::Harness::ProviderFactory.new
       end
 
       # Create provider using harness configuration

data/lib/aidp/providers/base.rb

@@ -48,6 +48,8 @@ module Aidp
       }.freeze
 
       attr_reader :activity_state, :last_activity_time, :start_time, :step_name, :model
+      # Expose for testability
+      attr_writer :harness_context
 
       def initialize(output: nil, prompt: TTY::Prompt.new)
         @activity_state = :idle