aidp 0.32.0 → 0.33.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_reader :loader
+
+      # @return [Boolean] Whether reloading is enabled
+      attr_reader :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/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

@@ -4,7 +4,7 @@ require "shellwords"
 
 module Aidp
   # Manages worktrees specifically for Pull Request branches
-  class PrWorktreeManager
+  class PRWorktreeManager
     def initialize(base_repo_path: nil, project_dir: nil, worktree_registry_path: nil)
       @base_repo_path = base_repo_path || project_dir || Dir.pwd
       @project_dir = project_dir
@@ -258,7 +258,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
       ]

data/lib/aidp/provider_manager.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "tty-prompt"
-require_relative "harness/provider_factory"
 
 module Aidp
   class ProviderManager
@@ -20,12 +19,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