aidp 0.32.0 → 0.34.0

data/lib/aidp/harness/output_filter_config.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    # Value object for output filter configuration
+    # Provides validation and type-safe access to filtering options
+    class OutputFilterConfig
+      VALID_MODES = %i[full failures_only minimal].freeze
+      DEFAULT_MODE = :full
+      DEFAULT_INCLUDE_CONTEXT = true
+      DEFAULT_CONTEXT_LINES = 3
+      DEFAULT_MAX_LINES = 500
+      MIN_CONTEXT_LINES = 0
+      MAX_CONTEXT_LINES = 20
+      MIN_MAX_LINES = 10
+      MAX_MAX_LINES = 10_000
+
+      attr_reader :mode, :include_context, :context_lines, :max_lines
+
+      # Create a new OutputFilterConfig
+      # @param mode [Symbol] Output mode (:full, :failures_only, :minimal)
+      # @param include_context [Boolean] Include surrounding lines
+      # @param context_lines [Integer] Number of context lines (0-20)
+      # @param max_lines [Integer] Maximum output lines (10-10000)
+      # @raise [ArgumentError] If any parameter is invalid
+      def initialize(mode: DEFAULT_MODE, include_context: DEFAULT_INCLUDE_CONTEXT,
+        context_lines: DEFAULT_CONTEXT_LINES, max_lines: DEFAULT_MAX_LINES)
+        @mode = validate_mode(mode)
+        @include_context = validate_boolean(include_context, "include_context")
+        @context_lines = validate_context_lines(context_lines)
+        @max_lines = validate_max_lines(max_lines)
+
+        freeze
+      end
+
+      # Create from a hash (useful for configuration loading)
+      # @param hash [Hash] Configuration hash
+      # @return [OutputFilterConfig] New config instance
+      def self.from_hash(hash)
+        hash = hash.transform_keys(&:to_sym) if hash.respond_to?(:transform_keys)
+
+        new(
+          mode: hash[:mode] || DEFAULT_MODE,
+          include_context: hash.fetch(:include_context, DEFAULT_INCLUDE_CONTEXT),
+          context_lines: hash[:context_lines] || DEFAULT_CONTEXT_LINES,
+          max_lines: hash[:max_lines] || DEFAULT_MAX_LINES
+        )
+      end
+
+      # Convert to hash (useful for serialization)
+      # @return [Hash] Configuration as hash
+      def to_h
+        {
+          mode: @mode,
+          include_context: @include_context,
+          context_lines: @context_lines,
+          max_lines: @max_lines
+        }
+      end
+
+      # Check if filtering is enabled
+      # @return [Boolean] True if mode is not :full
+      def filtering_enabled?
+        @mode != :full
+      end
+
+      # Compare with another config
+      # @param other [OutputFilterConfig] Other config to compare
+      # @return [Boolean] True if equal
+      def ==(other)
+        return false unless other.is_a?(OutputFilterConfig)
+
+        @mode == other.mode &&
+          @include_context == other.include_context &&
+          @context_lines == other.context_lines &&
+          @max_lines == other.max_lines
+      end
+      alias_method :eql?, :==
+
+      # Hash for use in Hash/Set
+      def hash
+        [@mode, @include_context, @context_lines, @max_lines].hash
+      end
+
+      private
+
+      def validate_mode(mode)
+        mode = mode.to_sym if mode.respond_to?(:to_sym)
+
+        unless VALID_MODES.include?(mode)
+          raise ArgumentError,
+            "Invalid mode: #{mode.inspect}. Must be one of #{VALID_MODES.join(", ")}"
+        end
+
+        mode
+      end
+
+      def validate_boolean(value, name)
+        unless [true, false].include?(value)
+          raise ArgumentError, "#{name} must be a boolean, got: #{value.inspect}"
+        end
+
+        value
+      end
+
+      def validate_context_lines(value)
+        value = value.to_i if value.respond_to?(:to_i) && !value.is_a?(Integer)
+
+        unless value.is_a?(Integer) && value >= MIN_CONTEXT_LINES && value <= MAX_CONTEXT_LINES
+          raise ArgumentError,
+            "context_lines must be an integer between #{MIN_CONTEXT_LINES} and #{MAX_CONTEXT_LINES}, got: #{value.inspect}"
+        end
+
+        value
+      end
+
+      def validate_max_lines(value)
+        value = value.to_i if value.respond_to?(:to_i) && !value.is_a?(Integer)
+
+        unless value.is_a?(Integer) && value >= MIN_MAX_LINES && value <= MAX_MAX_LINES
+          raise ArgumentError,
+            "max_lines must be an integer between #{MIN_MAX_LINES} and #{MAX_MAX_LINES}, got: #{value.inspect}"
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/aidp/harness/provider_factory.rb

@@ -15,6 +15,9 @@ module Aidp
   module Harness
     # Factory for creating configured provider instances
     class ProviderFactory
+      # Expose for testability
+      attr_reader :provider_instances, :provider_configs
+
       PROVIDER_CLASSES = {
         "cursor" => Aidp::Providers::Cursor,
         "anthropic" => Aidp::Providers::Anthropic,

data/lib/aidp/harness/provider_manager.rb

@@ -13,6 +13,12 @@ module Aidp
       include Aidp::MessageDisplay
       include Aidp::RescueLogging
 
+      # Expose state for testability
+      attr_accessor :sticky_sessions, :load_balancing_enabled
+      attr_writer :current_model
+      attr_accessor :provider_health, :provider_metrics, :rate_limit_info
+      attr_reader :binary_check_cache, :binary_check_ttl
+
       def initialize(configuration, prompt: TTY::Prompt.new, binary_checker: Aidp::Util)
         @configuration = configuration
         @prompt = prompt
@@ -1240,6 +1246,11 @@ module Aidp
             total_tokens: m[:total_tokens] || 0,
             last_used: m[:last_used]
           }
+
+          # Set reason if currently rate limited (for display in Reason column)
+          if rl && reset_in && reset_in > 0
+            row[:unhealthy_reason] ||= "rate_limited"
+          end
           # Incorporate CLI check outcome into reason/availability if failing
           unless cli_ok_prefetch
             row[:available] = false
@@ -1416,9 +1427,43 @@ module Aidp
 
       # Execute a prompt with a specific provider
       def execute_with_provider(provider_type, prompt, options = {})
+        options = options.dup
+
         # Extract model from options if provided
         model_name = options.delete(:model)
-        retry_on_rate_limit = options.delete(:retry_on_rate_limit) != false # Default true
+        retry_on_rate_limit = if options.key?(:retry_on_rate_limit)
+          options.delete(:retry_on_rate_limit) != false
+        else
+          true
+        end
+        retry_on_unsupported = if options.key?(:retry_on_unsupported)
+          options.delete(:retry_on_unsupported) != false
+        else
+          true
+        end
+        tier = options[:tier]
+        base_options = options.dup
+
+        if model_name && model_denied?(provider_type, model_name)
+          alternate_model = select_alternate_model(provider_type, tier: tier, current_model: model_name)
+          if alternate_model
+            Aidp.logger.warn("provider_manager", "Model is denylisted, selecting alternate",
+              provider: provider_type,
+              model: model_name,
+              alternate_model: alternate_model,
+              tier: tier)
+
+            return execute_with_provider(
+              provider_type,
+              prompt,
+              base_options.merge(
+                model: alternate_model,
+                retry_on_rate_limit: retry_on_rate_limit,
+                retry_on_unsupported: false
+              )
+            )
+          end
+        end
 
         # Create provider factory instance
         provider_factory = ProviderFactory.new
@@ -1440,7 +1485,7 @@ module Aidp
           prompt_length: prompt.length)
 
         # Execute the prompt with the provider
-        result = provider.send_message(prompt: prompt, session: nil)
+        result = provider.send_message(prompt: prompt, session: nil, options: options)
 
         # Return structured result
         {
@@ -1460,6 +1505,28 @@ module Aidp
 
         if unsupported_model_error?(e, model_name)
           deny_model(provider_type, model_name, error: e)
+
+          if retry_on_unsupported
+            alternate_model = select_alternate_model(provider_type, tier: tier, current_model: model_name)
+
+            if alternate_model
+              Aidp.logger.info("provider_manager", "Retrying with alternate model after unsupported model error",
+                provider: provider_type,
+                original_model: model_name,
+                alternate_model: alternate_model,
+                tier: tier)
+
+              return execute_with_provider(
+                provider_type,
+                prompt,
+                base_options.merge(
+                  model: alternate_model,
+                  retry_on_rate_limit: retry_on_rate_limit,
+                  retry_on_unsupported: false
+                )
+              )
+            end
+          end
         end
 
         # Detect rate limit / quota errors and attempt fallback
@@ -1615,12 +1682,39 @@ module Aidp
 
         message = error&.message.to_s.downcase
         return false if message.empty?
+        return false unless message.include?(model_name.to_s.downcase)
 
         (message.include?("unsupported") && message.include?("model")) ||
           (message.include?("model") && message.include?("not supported")) ||
           message.include?("invalid model")
       end
 
+      # Select an alternate model for the provider and tier, excluding denylisted/current models
+      def select_alternate_model(provider_name, tier:, current_model: nil)
+        candidates = []
+
+        if tier && @configuration.respond_to?(:models_for_tier)
+          tier_models = Array(@configuration.models_for_tier(tier, provider_name)).map(&:to_s)
+          candidates.concat(tier_models)
+        end
+
+        if candidates.empty? && @configuration.respond_to?(:provider_models)
+          provider_models = Array(@configuration.provider_models(provider_name)).map(&:to_s)
+          candidates.concat(provider_models)
+        end
+
+        candidates = candidates.uniq
+        return nil if candidates.empty?
+
+        excluded = Array(current_model).compact + Array(@model_denylist[provider_name])
+        candidates.reject! { |model| excluded.include?(model) }
+        candidates.first
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "select_alternate_model", fallback: nil,
+          provider: provider_name, tier: tier, current_model: current_model)
+        nil
+      end
+
       public
 
       # Log provider switch

data/lib/aidp/harness/runner.rb

@@ -2,16 +2,6 @@
 
 require "timeout"
 require "json"
-require_relative "configuration"
-require_relative "state_manager"
-require_relative "condition_detector"
-require_relative "provider_manager"
-require_relative "simple_user_interface"
-require_relative "error_handler"
-require_relative "status_display"
-require_relative "completion_checker"
-require_relative "../concurrency"
-require_relative "../errors"
 
 module Aidp
   module Harness
@@ -33,7 +23,11 @@ module Aidp
       }.freeze
 
       # Public accessors for testing and integration
-      attr_reader :current_provider, :current_step, :user_input, :execution_log, :provider_manager, :clarification_questions
+      attr_reader :clarification_questions, :last_error
+      attr_accessor :current_provider, :current_step, :user_input, :execution_log, :provider_manager
+      attr_accessor :state, :mode, :project_dir, :configuration, :condition_detector
+      attr_accessor :state_manager, :user_interface, :error_handler, :status_display
+      attr_writer :completion_checker, :workflow_type, :non_interactive
 
       def initialize(project_dir, mode = :analyze, options = {})
         @project_dir = project_dir
@@ -61,7 +55,6 @@ module Aidp
         # Use ZFC-enabled condition detector
         # ZfcConditionDetector will create its own ProviderFactory if needed
         # Falls back to legacy pattern matching when ZFC is disabled
-        require_relative "zfc_condition_detector"
         @condition_detector = ZfcConditionDetector.new(@configuration)
 
         @user_interface = SimpleUserInterface.new

data/lib/aidp/harness/state/persistence.rb

@@ -11,6 +11,9 @@ module Aidp
       class Persistence
         include Aidp::SafeDirectory
 
+        # Expose for testability
+        attr_reader :state_file, :lock_file
+
         def initialize(project_dir, mode, skip_persistence: false)
           @project_dir = project_dir
           @mode = mode

data/lib/aidp/harness/state_manager.rb

@@ -14,6 +14,9 @@ module Aidp
     class StateManager
       include Aidp::SafeDirectory
 
+      # Expose for testability
+      attr_reader :project_dir, :mode
+
       def initialize(project_dir, mode, skip_persistence: false)
         @project_dir = project_dir
         @mode = mode

data/lib/aidp/harness/status_display.rb

@@ -9,6 +9,17 @@ module Aidp
     class StatusDisplay
       include Aidp::MessageDisplay
 
+      # Expose state for testability
+      attr_accessor :current_step, :current_provider, :current_model
+      attr_accessor :start_time, :running
+      attr_accessor :performance_metrics, :error_summary
+      attr_accessor :provider_status, :token_usage, :circuit_breaker_status
+      attr_accessor :rate_limit_status, :recovery_status, :user_feedback_status
+      attr_accessor :work_completion_status, :display_config
+      attr_reader :status_formatter, :metrics_calculator, :alert_manager, :display_animator
+      # Internal status hash (separate from computed status_data method)
+      attr_accessor :internal_status_data
+
       def initialize(provider_manager = nil, metrics_manager = nil, circuit_breaker_manager = nil, error_logger = nil, prompt: TTY::Prompt.new)
         @provider_manager = provider_manager
         @metrics_manager = metrics_manager
@@ -27,6 +38,7 @@ module Aidp
         @update_interval = 2
         @last_update = Time.now
         @status_data = {}
+        @internal_status_data = @status_data # Alias for testability
         @performance_metrics = {}
         @error_summary = {}
         @provider_status = {}
@@ -167,16 +179,24 @@ module Aidp
         @error_summary[:last_updated] = Time.now
       end
 
-      # Set display mode
-      def display_mode(mode)
-        @display_mode = mode
-        @display_config[:mode] = mode
+      # Get or set display mode
+      def display_mode(mode = nil)
+        if mode.nil?
+          @display_mode
+        else
+          @display_mode = mode
+          @display_config[:mode] = mode
+        end
       end
 
-      # Set update interval
-      def update_interval(interval)
-        @update_interval = interval
-        @display_config[:update_interval] = interval
+      # Get or set update interval
+      def update_interval(interval = nil)
+        if interval.nil?
+          @update_interval
+        else
+          @update_interval = interval
+          @display_config[:update_interval] = interval
+        end
       end
 
       # Configure display settings
@@ -686,8 +706,6 @@ module Aidp
         }
       end
 
-      attr_reader :provider_status
-
       def performance_status
         @performance_metrics
       end
@@ -696,20 +714,10 @@ module Aidp
         @error_summary
       end
 
-      attr_reader :circuit_breaker_status
-
       def token_status
         @token_usage
       end
 
-      attr_reader :rate_limit_status
-
-      attr_reader :recovery_status
-
-      attr_reader :user_feedback_status
-
-      attr_reader :work_completion_status
-
       def alerts
         @alert_manager.active_alerts
       end