aidp 0.34.0 → 0.39.3

data/lib/aidp/harness/provider_metrics.rb

@@ -12,13 +12,14 @@ module Aidp
     class ProviderMetrics
       include Aidp::RescueLogging
 
-      attr_reader :project_dir, :metrics_file, :rate_limit_file
+      attr_reader :project_dir, :metrics_file, :rate_limit_file, :usage_tracking_dir
 
       def initialize(project_dir)
         # Store metrics at the repository root so different worktrees/modes share state
         @project_dir = Aidp::Util.find_project_root(project_dir)
         @metrics_file = File.join(@project_dir, ".aidp", "provider_metrics.yml")
         @rate_limit_file = File.join(@project_dir, ".aidp", "provider_rate_limits.yml")
+        @usage_tracking_dir = File.join(@project_dir, ".aidp", "usage_tracking")
         ensure_directory
       end
 
@@ -78,6 +79,76 @@ module Aidp
       def clear
         File.delete(@metrics_file) if File.exist?(@metrics_file)
         File.delete(@rate_limit_file) if File.exist?(@rate_limit_file)
+        clear_usage_tracking
+      end
+
+      # Save usage tracking data for a provider
+      #
+      # @param provider_name [String] Name of the provider
+      # @param usage_data [Hash] Usage tracking data
+      def save_usage_tracking(provider_name, usage_data)
+        return if usage_data.nil? || usage_data.empty?
+
+        ensure_usage_tracking_directory
+        usage_file = usage_tracking_file(provider_name)
+
+        # Serialize Time objects for YAML
+        serializable_data = serialize_usage_tracking(usage_data)
+
+        # Write atomically using temp file + rename
+        temp_file = "#{usage_file}.tmp"
+        File.write(temp_file, YAML.dump(serializable_data))
+        File.rename(temp_file, usage_file)
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "save_usage_tracking", fallback: nil)
+        File.delete(temp_file) if defined?(temp_file) && File.exist?(temp_file)
+      end
+
+      # Load usage tracking data for a provider
+      #
+      # @param provider_name [String] Name of the provider
+      # @return [Hash] Usage tracking data or empty hash
+      def load_usage_tracking(provider_name)
+        usage_file = usage_tracking_file(provider_name)
+        return {} unless File.exist?(usage_file)
+
+        data = YAML.safe_load_file(usage_file, permitted_classes: [Time, Date, Symbol], aliases: true)
+        return {} unless data.is_a?(Hash)
+
+        deserialize_usage_tracking(data)
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "load_usage_tracking", fallback: {})
+        {}
+      end
+
+      # Clear usage tracking data for a specific provider
+      #
+      # @param provider_name [String] Name of the provider (optional, clears all if nil)
+      def clear_usage_tracking(provider_name = nil)
+        if provider_name
+          usage_file = usage_tracking_file(provider_name)
+          File.delete(usage_file) if File.exist?(usage_file)
+        else
+          # Clear all usage tracking files
+          return unless File.directory?(@usage_tracking_dir)
+
+          Dir.glob(File.join(@usage_tracking_dir, "*.yml")).each do |file|
+            File.delete(file)
+          rescue => e
+            log_rescue(e, component: "provider_metrics", action: "clear_usage_file", fallback: nil)
+          end
+        end
+      end
+
+      # List all providers with usage tracking data
+      #
+      # @return [Array<String>] Array of provider names
+      def providers_with_usage_tracking
+        return [] unless File.directory?(@usage_tracking_dir)
+
+        Dir.glob(File.join(@usage_tracking_dir, "*.yml")).map do |file|
+          File.basename(file, ".yml")
+        end
       end
 
       private
@@ -87,6 +158,37 @@ module Aidp
         FileUtils.mkdir_p(aidp_dir) unless File.directory?(aidp_dir)
       end
 
+      def ensure_usage_tracking_directory
+        FileUtils.mkdir_p(@usage_tracking_dir) unless File.directory?(@usage_tracking_dir)
+      end
+
+      def usage_tracking_file(provider_name)
+        File.join(@usage_tracking_dir, "#{provider_name}.yml")
+      end
+
+      def serialize_usage_tracking(data)
+        deep_transform_values(data) do |value|
+          value.is_a?(Time) ? value.iso8601 : value
+        end
+      end
+
+      def deserialize_usage_tracking(data)
+        deep_transform_values(data) do |value|
+          parse_time_if_string(value)
+        end
+      end
+
+      def deep_transform_values(obj, &block)
+        case obj
+        when Hash
+          obj.transform_values { |v| deep_transform_values(v, &block) }
+        when Array
+          obj.map { |v| deep_transform_values(v, &block) }
+        else
+          yield(obj)
+        end
+      end
+
       def serialize_metrics(metrics_hash)
         metrics_hash.transform_values do |provider_metrics|
           next provider_metrics unless provider_metrics.is_a?(Hash)

data/lib/aidp/harness/rspec_command_optimizer.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    # Optimizes RSpec command execution by using --only-failures on subsequent runs.
+    # This dramatically reduces both execution time and output volume when fixing
+    # failing tests during work loops.
+    #
+    # Requirements:
+    # - RSpec must be configured with example_status_persistence_file_path in spec_helper.rb
+    # - A .rspec_status file (or configured path) must exist from a previous run
+    #
+    # @example
+    #   optimizer = RSpecCommandOptimizer.new("/path/to/project")
+    #   result = optimizer.optimize_command("bundle exec rspec", iteration: 2, had_failures: true)
+    #   # => "bundle exec rspec --only-failures"
+    #
+    class RSpecCommandOptimizer
+      # Default paths where RSpec stores example status
+      DEFAULT_STATUS_PATHS = [
+        ".rspec_status",
+        "tmp/.rspec_status",
+        "spec/.rspec_status"
+      ].freeze
+
+      # Common spec_helper paths to check for persistence configuration
+      SPEC_HELPER_PATHS = [
+        "spec/spec_helper.rb",
+        "spec/rails_helper.rb"
+      ].freeze
+
+      attr_reader :project_dir
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @status_file_cache = nil
+        @persistence_configured_cache = nil
+      end
+
+      # Optimize an RSpec command based on iteration context
+      #
+      # @param command [String] The original RSpec command
+      # @param iteration [Integer] Current iteration number (1-indexed)
+      # @param had_failures [Boolean] Whether the previous iteration had test failures
+      # @return [Hash] { command: String, optimized: Boolean, reason: String }
+      def optimize_command(command, iteration:, had_failures:)
+        return skip_optimization(command, "not an RSpec command") unless rspec_command?(command)
+        return skip_optimization(command, "first iteration") if iteration <= 1
+        return skip_optimization(command, "no previous failures") unless had_failures
+        return skip_optimization(command, "already has --only-failures") if command.include?("--only-failures")
+
+        status_file = find_status_file
+        unless status_file
+          Aidp.log_debug("rspec_optimizer", "no_status_file",
+            project_dir: @project_dir,
+            checked_paths: DEFAULT_STATUS_PATHS)
+
+          return skip_optimization(command, "no .rspec_status file found - see setup instructions")
+        end
+
+        optimized_command = add_only_failures_flag(command)
+
+        Aidp.log_info("rspec_optimizer", "command_optimized",
+          original: command,
+          optimized: optimized_command,
+          iteration: iteration,
+          status_file: status_file)
+
+        {
+          command: optimized_command,
+          optimized: true,
+          reason: "using --only-failures (iteration #{iteration})",
+          status_file: status_file
+        }
+      end
+
+      # Check if RSpec persistence is properly configured in this project
+      #
+      # @return [Hash] { configured: Boolean, file_path: String, message: String }
+      def check_persistence_configuration
+        return @persistence_configured_cache if @persistence_configured_cache
+
+        @persistence_configured_cache = begin
+          # Check if any spec_helper configures persistence
+          configured_in_spec_helper = SPEC_HELPER_PATHS.any? do |path|
+            full_path = File.join(@project_dir, path)
+            next false unless File.exist?(full_path)
+
+            content = File.read(full_path, encoding: "UTF-8")
+            content.include?("example_status_persistence_file_path")
+          end
+
+          if configured_in_spec_helper
+            status_file = find_status_file
+            {
+              configured: true,
+              file_path: status_file,
+              message: "RSpec persistence configured" + (status_file ? " (#{status_file} exists)" : " (waiting for first run)")
+            }
+          else
+            {
+              configured: false,
+              file_path: nil,
+              message: "RSpec persistence not configured. Add to spec_helper.rb:\n" \
+                       "  config.example_status_persistence_file_path = '.rspec_status'"
+            }
+          end
+        end
+      end
+
+      # Find the RSpec status file if it exists
+      #
+      # @return [String, nil] Path to status file or nil if not found
+      def find_status_file
+        return @status_file_cache if @status_file_cache
+
+        @status_file_cache = DEFAULT_STATUS_PATHS.find do |path|
+          full_path = File.join(@project_dir, path)
+          File.exist?(full_path)
+        end
+      end
+
+      # Check if command is an RSpec command
+      #
+      # @param command [String] Command to check
+      # @return [Boolean]
+      def rspec_command?(command)
+        return false unless command.is_a?(String)
+        command.downcase.include?("rspec")
+      end
+
+      # Reset caches (useful after test runs that may create status file)
+      def reset_caches!
+        @status_file_cache = nil
+        @persistence_configured_cache = nil
+      end
+
+      private
+
+      def skip_optimization(command, reason)
+        {
+          command: command,
+          optimized: false,
+          reason: reason
+        }
+      end
+
+      def add_only_failures_flag(command)
+        # Insert --only-failures before any file arguments
+        # "bundle exec rspec" -> "bundle exec rspec --only-failures"
+        # "bundle exec rspec spec/foo_spec.rb" -> "bundle exec rspec --only-failures spec/foo_spec.rb"
+        parts = command.split(/\s+/)
+        rspec_index = parts.index { |p| p.downcase == "rspec" }
+
+        if rspec_index
+          # Insert after "rspec" but before any file arguments
+          parts.insert(rspec_index + 1, "--only-failures")
+          parts.join(" ")
+        else
+          # Fallback: append to end
+          "#{command} --only-failures"
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/ruby_llm_registry.rb

@@ -12,6 +12,9 @@ module Aidp
       class RegistryError < StandardError; end
       class ModelNotFound < RegistryError; end
 
+      ENCODING_MUTEX = Mutex.new
+      private_constant :ENCODING_MUTEX
+
       # Map AIDP provider names to RubyLLM provider names
       # Some AIDP providers use different names than the upstream APIs
       PROVIDER_NAME_MAPPING = {
@@ -67,8 +70,8 @@ module Aidp
 
       def initialize(deprecation_cache: nil)
         @deprecation_cache = deprecation_cache
-        @models = RubyLLM::Models.instance.instance_variable_get(:@models)
-        @index_by_id = @models.to_h { |m| [m.id, m] }
+        @models = load_models_with_utf8_fallback
+        @index_by_id = build_id_index(@models)
 
         # Build family index for mapping versioned names to families
         @family_index = build_family_index
@@ -125,9 +128,12 @@ module Aidp
       # Get model information
       #
       # @param model_id [String] The model ID
+      # @param provider [String, nil] Optional AIDP provider name. When given,
+      #   returns info for that provider's entry (useful when the same model ID
+      #   exists under multiple providers, e.g. anthropic and azure).
       # @return [Hash, nil] Model information hash or nil if not found
-      def get_model_info(model_id)
-        model = @index_by_id[model_id]
+      def get_model_info(model_id, provider: nil)
+        model = find_model_entry(model_id, provider: provider)
         return nil unless model
 
         {
@@ -212,8 +218,8 @@ module Aidp
       # Refresh the model registry from ruby_llm
       def refresh!
         RubyLLM::Models.refresh!
-        @models = RubyLLM::Models.instance.instance_variable_get(:@models)
-        @index_by_id = @models.to_h { |m| [m.id, m] }
+        @models = load_models_with_utf8_fallback
+        @index_by_id = build_id_index(@models)
         @family_index = build_family_index
         Aidp.log_info("ruby_llm_registry", "refreshed", models: @models.size)
       end
@@ -229,7 +235,8 @@ module Aidp
       end
 
       # Find replacement for a deprecated model
-      # Returns the latest non-deprecated model in the same family/tier
+      # Returns the cached replacement if available, otherwise finds the latest
+      # non-deprecated model in the same family/tier
       # @param deprecated_model [String] The deprecated model ID
       # @param provider [String, nil] The provider name (AIDP format)
       # @return [String, nil] Replacement model ID or nil
@@ -237,7 +244,16 @@ module Aidp
         registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
         return nil unless registry_provider
 
-        # Determine tier of deprecated model
+        # First check the deprecation cache for a stored replacement
+        cached_replacement = deprecation_cache.replacement_for(provider: registry_provider, model_id: deprecated_model)
+        if cached_replacement
+          Aidp.log_info("ruby_llm_registry", "found cached replacement",
+            deprecated: deprecated_model,
+            replacement: cached_replacement)
+          return cached_replacement
+        end
+
+        # Determine tier of deprecated model for dynamic lookup
         deprecated_info = @index_by_id[deprecated_model]
         return nil unless deprecated_info
 
@@ -265,6 +281,79 @@ module Aidp
 
       private
 
+      # Load models from RubyLLM, working around encoding issues in the
+      # upstream gem when the process locale is US-ASCII.
+      def load_models_with_utf8_fallback
+        RubyLLM::Models.instance.instance_variable_get(:@models)
+      rescue Encoding::InvalidByteSequenceError => e
+        # Only switch encoding when the current default is US-ASCII, which is
+        # the known problematic locale for RubyLLM's UTF-8 model JSON.
+        # For other non-UTF-8 encodings, propagate the error rather than
+        # silently clobbering the process-wide setting.
+        ENCODING_MUTEX.synchronize do
+          unless Encoding.default_external == Encoding::US_ASCII
+            raise e
+          end
+
+          Aidp.log_debug(
+            "ruby_llm_registry",
+            "setting default external encoding from US-ASCII to UTF-8 for RubyLLM model load"
+          )
+          Encoding.default_external = Encoding::UTF_8
+
+          # RubyLLM::Models uses a singleton @instance that caches the parsed
+          # model list. We reset it so the retry re-reads the JSON under
+          # UTF-8 encoding. This relies on an internal implementation detail;
+          # if upstream adds a public reset API we should prefer that.
+          RubyLLM::Models.instance_variable_set(:@instance, nil)
+          RubyLLM::Models.instance.instance_variable_get(:@models)
+        end
+      end
+
+      # Find the model entry for a given ID, optionally scoped to a provider.
+      # When a provider is given, only returns entries for that provider;
+      # returns nil if the provider is unsupported or no match is found.
+      # Falls back to the flat index only when no provider is given.
+      def find_model_entry(model_id, provider: nil)
+        if provider
+          registry_provider = PROVIDER_NAME_MAPPING[provider]
+          unless registry_provider
+            Aidp.log_debug("ruby_llm_registry", "unsupported provider for model lookup",
+              provider: provider, model_id: model_id)
+            return nil
+          end
+
+          match = @models.find { |m| m.id == model_id && m.provider.to_s == registry_provider }
+          unless match
+            Aidp.log_debug("ruby_llm_registry", "model not found for provider",
+              model_id: model_id, provider: provider, registry_provider: registry_provider)
+          end
+          return match
+        end
+        @index_by_id[model_id]
+      end
+
+      # Build an index of model ID to model object, preferring primary
+      # providers (anthropic, openai, gemini) over resellers (azure, bedrock)
+      # when the same model ID appears under multiple providers.
+      #
+      # NOTE: This flat index stores one entry per model ID. Callers that need
+      # provider-specific results (e.g. models_for_provider) should filter
+      # @models directly rather than relying on this index.
+      PRIMARY_PROVIDERS = %w[anthropic openai gemini deepseek mistral].freeze
+
+      def build_id_index(models)
+        index = {}
+        models.each do |m|
+          existing = index[m.id]
+          if existing.nil? || (!PRIMARY_PROVIDERS.include?(existing.provider.to_s) &&
+                                PRIMARY_PROVIDERS.include?(m.provider.to_s))
+            index[m.id] = m
+          end
+        end
+        index
+      end
+
       # Build an index mapping family names to model objects
       # Family name is model ID with version suffix removed
       def build_family_index

data/lib/aidp/harness/runner.rb

@@ -50,7 +50,7 @@ module Aidp
         # Initialize components
         @configuration = Configuration.new(project_dir)
         @state_manager = StateManager.new(project_dir, @mode)
-        @provider_manager = ProviderManager.new(@configuration, prompt: @prompt)
+        @provider_manager = create_provider_manager(options)
 
         # Use ZFC-enabled condition detector
         # ZfcConditionDetector will create its own ProviderFactory if needed
@@ -224,6 +224,11 @@ module Aidp
 
       private
 
+      def create_provider_manager(_options)
+        require_relative "agent_harness_provider_manager"
+        AgentHarnessProviderManager.new(@configuration, prompt: @prompt)
+      end
+
       def get_mode_runner
         case @mode
         when :analyze
@@ -459,7 +464,7 @@ module Aidp
           **data.slice(:error, :error_class, :criteria, :all_complete, :summary).compact)
 
         # Also log to standard output in debug mode
-        puts "[#{Time.now.strftime("%H:%M:%S")}] #{message}" if ENV["AIDP_DEBUG"] == "1"
+        puts "[#{Time.now.strftime("%H:%M:%S")}] #{message}" if Aidp.debug_env_level >= 1
       end
 
       def get_completion_message

data/lib/aidp/harness/state_manager.rb

@@ -616,7 +616,7 @@ module Aidp
           end
         rescue => e
           # Ignore errors when cleaning up stale locks
-          warn "Failed to cleanup stale lock: #{e.message}" if ENV["DEBUG"]
+          warn "Failed to cleanup stale lock: #{e.message}" if Aidp.debug_env_enabled?
         end
       end
     end