aidp 0.31.0 → 0.33.0

data/lib/aidp/harness/provider_manager.rb

@@ -38,6 +38,7 @@ module Aidp
         @model_fallback_chains = {}
         @model_switching_enabled = true
         @model_weights = {}
+        @model_denylist = Hash.new { |h, k| h[k] = [] }
         @unavailable_cache = {}
         @binary_check_cache = {}
         @binary_check_ttl = 300 # seconds
@@ -387,10 +388,30 @@ module Aidp
         # Check if model is configured for provider
         return false unless model_configured?(provider_name, model_name)
 
+        # Skip models that were explicitly denied (e.g., unsupported by provider)
+        return false if model_denied?(provider_name, model_name)
+
         # Check if model is not rate limited
         !is_model_rate_limited?(provider_name, model_name)
       end
 
+      # Check if a model has been denylisted for a provider
+      def model_denied?(provider_name, model_name)
+        @model_denylist[provider_name]&.include?(model_name)
+      end
+
+      # Add a model to the denylist for a provider (e.g., unsupported model errors)
+      def deny_model(provider_name, model_name, error: nil)
+        return if provider_name.nil? || model_name.nil?
+        return if model_denied?(provider_name, model_name)
+
+        @model_denylist[provider_name] << model_name
+        Aidp.log_debug("provider_manager", "model_denylisted",
+          provider: provider_name,
+          model: model_name,
+          error: error&.message)
+      end
+
       # Check if model is configured for provider
       def model_configured?(provider_name, model_name)
         models = provider_models(provider_name)
@@ -1219,6 +1240,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
@@ -1279,6 +1305,7 @@ module Aidp
         @model_health.clear
         @model_metrics.clear
         @model_fallback_chains.clear
+        @model_denylist.clear
         @model_rate_limit_info&.clear
         @model_history&.clear
         initialize_fallback_chains
@@ -1394,9 +1421,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
@@ -1418,7 +1479,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
         {
@@ -1436,6 +1497,32 @@ module Aidp
       rescue => e
         log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, model: model_name, prompt_length: prompt.length)
 
+        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
         error_message = e.message.to_s.downcase
         is_rate_limit = error_message.include?("rate limit") ||
@@ -1583,6 +1670,45 @@ module Aidp
         ((order[a] || 0) >= (order[b] || 0)) ? a : b
       end
 
+      # Detect unsupported/invalid model errors to avoid reusing the model
+      def unsupported_model_error?(error, model_name)
+        return false if model_name.nil?
+
+        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/provider_metrics.rb

@@ -3,6 +3,7 @@
 require "yaml"
 require "fileutils"
 require_relative "../rescue_logging"
+require_relative "../util"
 
 module Aidp
   module Harness
@@ -14,9 +15,10 @@ module Aidp
       attr_reader :project_dir, :metrics_file, :rate_limit_file
 
       def initialize(project_dir)
-        @project_dir = project_dir
-        @metrics_file = File.join(project_dir, ".aidp", "provider_metrics.yml")
-        @rate_limit_file = File.join(project_dir, ".aidp", "provider_rate_limits.yml")
+        # 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")
         ensure_directory
       end
 

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
@@ -61,7 +51,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/test_runner.rb

@@ -3,16 +3,19 @@
 require "open3"
 require_relative "../tooling_detector"
 require_relative "output_filter"
+require_relative "output_filter_config"
 
 module Aidp
   module Harness
     # Executes test and linter commands configured in aidp.yml
     # Returns results with exit status and output
+    # Applies intelligent output filtering to reduce token consumption
     class TestRunner
       def initialize(project_dir, config)
         @project_dir = project_dir
         @config = config
         @iteration_count = 0
+        @filter_stats = {total_input_bytes: 0, total_output_bytes: 0}
       end
 
       # Run all configured tests
@@ -47,6 +50,29 @@ module Aidp
         run_command_category(:documentation, "Documentation")
       end
 
+      # Preview the commands that will run for each category so callers can log intent
+      # Returns a hash of category => array of normalized command entries
+      def planned_commands
+        {
+          tests: resolved_commands(:test),
+          lints: resolved_commands(:lint),
+          formatters: resolved_commands(:formatter),
+          builds: resolved_commands(:build),
+          docs: resolved_commands(:documentation)
+        }
+      end
+
+      # Get current iteration count
+      attr_reader :iteration_count
+
+      # Get filtering statistics
+      attr_reader :filter_stats
+
+      # Reset iteration counter (useful for testing)
+      def reset_iteration_count
+        @iteration_count = 0
+      end
+
       private
 
       # Run commands for a specific category (test, lint, formatter, build, documentation)
@@ -59,6 +85,12 @@ module Aidp
         # Determine output mode based on category
         mode = determine_output_mode(category)
 
+        Aidp.log_debug("test_runner", "running_category",
+          category: category,
+          command_count: commands.length,
+          iteration: @iteration_count,
+          output_mode: mode)
+
         # Execute all commands
         results = commands.map do |cmd_config|
           # Handle both string commands (legacy) and hash format (new)
@@ -71,6 +103,23 @@ module Aidp
           end
         end
 
+        aggregate_results(results, display_name, mode: mode)
+      rescue NameError
+        # Logging not available
+        commands = resolved_commands(category)
+        return {success: true, output: "", failures: [], required_failures: []} if commands.empty?
+
+        mode = determine_output_mode(category)
+        results = commands.map do |cmd_config|
+          if cmd_config.is_a?(String)
+            result = execute_command(cmd_config, category.to_s)
+            result.merge(required: true)
+          else
+            result = execute_command(cmd_config[:command], category.to_s)
+            result.merge(required: cmd_config[:required])
+          end
+        end
+
         aggregate_results(results, display_name, mode: mode)
       end
 
@@ -107,6 +156,11 @@ module Aidp
             (optional_failures.any? ? "\n" + format_failures(optional_failures, "#{category} - Optional", mode: mode) : "")
         end
 
+        # Add filtering summary if filtering was applied
+        if mode != :full && all_failures.any?
+          output += "\n[Output filtered: mode=#{mode}]"
+        end
+
         {
           success: success,
           output: output,
@@ -124,9 +178,12 @@ module Aidp
           output << "Exit Code: #{failure[:exit_code]}"
           output << "--- Output ---"
 
+          # Detect framework for filtering
+          framework = detect_framework_from_command(failure[:command])
+
           # Apply filtering based on mode and framework
-          filtered_stdout = filter_output(failure[:stdout], mode, detect_framework_from_command(failure[:command]))
-          filtered_stderr = filter_output(failure[:stderr], mode, :unknown)
+          filtered_stdout = filter_output(failure[:stdout], mode, framework, :test)
+          filtered_stderr = filter_output(failure[:stderr], mode, :unknown, :lint)
 
           output << filtered_stdout unless filtered_stdout.strip.empty?
           output << filtered_stderr unless filtered_stderr.strip.empty?
@@ -136,67 +193,139 @@ module Aidp
         output.join("\n")
       end
 
-      def filter_output(raw_output, mode, framework)
+      def filter_output(raw_output, mode, framework, category)
         return raw_output if mode == :full || raw_output.nil? || raw_output.empty?
 
-        filter_config = {
+        # Build filter config from configuration or defaults
+        filter_config = build_filter_config(mode, category)
+
+        # Load AI-generated filter definition if available (AGD pattern)
+        filter_definition = load_filter_definition_for(category)
+
+        # Track input size for stats
+        @filter_stats[:total_input_bytes] += raw_output.bytesize
+
+        filter = OutputFilter.new(filter_config, filter_definition: filter_definition)
+        filtered = filter.filter(raw_output, framework: framework)
+
+        # Track output size for stats
+        @filter_stats[:total_output_bytes] += filtered.bytesize
+
+        Aidp.log_debug("test_runner", "output_filtered",
+          framework: framework,
           mode: mode,
-          include_context: true,
-          context_lines: 3,
-          max_lines: 500
-        }
+          input_size: raw_output.bytesize,
+          output_size: filtered.bytesize,
+          has_custom_definition: !filter_definition.nil?)
 
-        filter = OutputFilter.new(filter_config)
-        filter.filter(raw_output, framework: framework)
+        filtered
       rescue NameError
         # Logging infrastructure not available
         raw_output
       rescue => e
-        Aidp.log_warn("test_runner", "filter_failed",
-          error: e.message,
-          framework: framework)
+        begin
+          Aidp.log_warn("test_runner", "filter_failed",
+            error: e.message,
+            framework: framework)
+        rescue NameError
+          # Logging not available
+        end
         raw_output  # Fallback to unfiltered on error
       end
 
-      def detect_framework_from_command(command)
-        case command
-        when /rspec/
-          :rspec
-        when /minitest/
-          :minitest
-        when /jest/
-          :jest
-        when /pytest/
-          :pytest
-        else
-          :unknown
+      # Load AI-generated filter definition for a category
+      # @param category [Symbol] :test or :lint
+      # @return [FilterDefinition, nil]
+      def load_filter_definition_for(category)
+        return nil unless @config.respond_to?(:filter_definition_for)
+
+        # Map category to definition key (matches setup wizard keys)
+        definition_key = case category
+        when :test then "unit_test"
+        when :lint then "lint"
+        else category.to_s
         end
+
+        @config.filter_definition_for(definition_key)
+      end
+
+      def build_filter_config(mode, category)
+        config_hash = {
+          mode: mode,
+          include_context: output_filtering_include_context,
+          context_lines: output_filtering_context_lines,
+          max_lines: max_output_lines_for_category(category)
+        }
+
+        OutputFilterConfig.from_hash(config_hash)
+      end
+
+      def detect_framework_from_command(command)
+        # Use ToolingDetector's enhanced framework detection
+        Aidp::ToolingDetector.framework_from_command(command)
       end
 
       def determine_output_mode(category)
         # Check config for category-specific mode
         case category
         when :test
-          if @config.respond_to?(:test_output_mode)
-            @config.test_output_mode
-          elsif @iteration_count > 1
-            :failures_only
-          else
-            :full
-          end
+          configured_mode = test_output_mode_from_config
+          return configured_mode if configured_mode
+
+          # Default: full on first iteration, failures_only after
+          (@iteration_count > 1) ? :failures_only : :full
         when :lint
-          if @config.respond_to?(:lint_output_mode)
-            @config.lint_output_mode
-          elsif @iteration_count > 1
-            :failures_only
-          else
-            :full
-          end
+          configured_mode = lint_output_mode_from_config
+          return configured_mode if configured_mode
+
+          # Default: full on first iteration, failures_only after
+          (@iteration_count > 1) ? :failures_only : :full
         else
           :full
         end
       end
 
+      def test_output_mode_from_config
+        return nil unless @config.respond_to?(:test_output_mode)
+        mode = @config.test_output_mode
+        return nil if mode.nil?
+        mode.to_sym
+      rescue
+        nil
+      end
+
+      def lint_output_mode_from_config
+        return nil unless @config.respond_to?(:lint_output_mode)
+        mode = @config.lint_output_mode
+        return nil if mode.nil?
+        mode.to_sym
+      rescue
+        nil
+      end
+
+      def max_output_lines_for_category(category)
+        case category
+        when :test
+          return @config.test_max_output_lines if @config.respond_to?(:test_max_output_lines) && @config.test_max_output_lines
+          OutputFilterConfig::DEFAULT_MAX_LINES
+        when :lint
+          return @config.lint_max_output_lines if @config.respond_to?(:lint_max_output_lines) && @config.lint_max_output_lines
+          300  # Default smaller for lint output
+        else
+          OutputFilterConfig::DEFAULT_MAX_LINES
+        end
+      end
+
+      def output_filtering_include_context
+        return @config.output_filtering_include_context if @config.respond_to?(:output_filtering_include_context)
+        OutputFilterConfig::DEFAULT_INCLUDE_CONTEXT
+      end
+
+      def output_filtering_context_lines
+        return @config.output_filtering_context_lines if @config.respond_to?(:output_filtering_context_lines)
+        OutputFilterConfig::DEFAULT_CONTEXT_LINES
+      end
+
       # Resolve commands for a specific category
       # Returns normalized command configs (array of {command:, required:} hashes)
       def resolved_commands(category)
@@ -239,8 +368,17 @@ module Aidp
       def detected_tooling
         @detected_tooling ||= Aidp::ToolingDetector.detect(@project_dir)
       rescue => e
-        Aidp.log_warn("test_runner", "tooling_detection_failed", error: e.message)
-        Aidp::ToolingDetector::Result.new(test_commands: [], lint_commands: [])
+        begin
+          Aidp.log_warn("test_runner", "tooling_detection_failed", error: e.message)
+        rescue NameError
+          # Logging not available
+        end
+        Aidp::ToolingDetector::Result.new(
+          test_commands: [],
+          lint_commands: [],
+          formatter_commands: [],
+          frameworks: {}
+        )
       end
 
       def log_fallback(type, commands)

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -152,6 +152,15 @@ module Aidp
       def select_model_for_tier(tier = nil, provider: nil)
         tier ||= current_tier
         validate_tier!(tier)
+        provider_has_no_tiers = provider && configuration.configured_tiers(provider).empty?
+        provider_has_catalog_models = provider && !@registry.models_for_provider(provider).empty?
+
+        if provider_has_no_tiers && !provider_has_catalog_models
+          Aidp.log_info("thinking_depth_manager", "No configured tiers for provider, deferring to provider auto model selection",
+            requested_tier: tier,
+            provider: provider)
+          return [provider, nil, {auto_model: true, reason: "provider_has_no_tiers"}]
+        end
 
         # First, try to get models from user's configuration for this tier and provider
         if provider
@@ -270,6 +279,13 @@ module Aidp
 
         result = try_fallback_tiers(tier, provider)
 
+        if provider_has_no_tiers && result.nil? && provider
+          Aidp.log_info("thinking_depth_manager", "No configured tiers for provider, deferring to provider auto model selection",
+            requested_tier: tier,
+            provider: provider)
+          return [provider, nil, {auto_model: true, reason: "provider_has_no_tiers"}]
+        end
+
         unless result
           # Enhanced error message with discovery hints
           display_enhanced_tier_error(tier, provider)

data/lib/aidp/harness/ui/navigation/submenu.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "main_menu"
-
 module Aidp
   module Harness
     module UI