aidp 0.25.0 → 0.27.0

data/lib/aidp/harness/rspec_filter_strategy.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "filter_strategy"
+
+module Aidp
+  module Harness
+    # RSpec-specific output filtering
+    class RSpecFilterStrategy < FilterStrategy
+      def filter(output, filter_instance)
+        case filter_instance.mode
+        when :failures_only
+          extract_failures_only(output, filter_instance)
+        when :minimal
+          extract_minimal(output, filter_instance)
+        else
+          output
+        end
+      end
+
+      private
+
+      def extract_failures_only(output, filter_instance)
+        lines = output.lines
+        parts = []
+
+        # Extract summary line
+        if (summary = lines.find { |l| l.match?(/^\d+ examples?, \d+ failures?/) })
+          parts << "RSpec Summary:"
+          parts << summary
+          parts << ""
+        end
+
+        # Extract failed examples
+        in_failure = false
+        failure_lines = []
+
+        lines.each_with_index do |line, index|
+          # Start of failure section
+          if line.match?(/^Failures:/)
+            in_failure = true
+            failure_lines << line
+            next
+          end
+
+          # End of failure section (start of pending/seed info)
+          if in_failure && (line.match?(/^Finished in/) || line.match?(/^Pending:/))
+            in_failure = false
+            break
+          end
+
+          failure_lines << line if in_failure
+        end
+
+        if failure_lines.any?
+          parts << failure_lines.join
+        end
+
+        parts.join("\n")
+      end
+
+      def extract_minimal(output, filter_instance)
+        lines = output.lines
+        parts = []
+
+        # Extract only summary and failure locations
+        if (summary = lines.find { |l| l.match?(/^\d+ examples?, \d+ failures?/) })
+          parts << summary
+        end
+
+        # Extract failure locations (file:line references)
+        failure_locations = lines.select { |l| l.match?(/# \.\/\S+:\d+/) }
+        if failure_locations.any?
+          parts << ""
+          parts << "Failed examples:"
+          parts.concat(failure_locations.map(&:strip))
+        end
+
+        parts.join("\n")
+      end
+    end
+  end
+end

data/lib/aidp/harness/runner.rb

@@ -11,6 +11,7 @@ require_relative "error_handler"
 require_relative "status_display"
 require_relative "completion_checker"
 require_relative "../concurrency"
+require_relative "../errors"
 
 module Aidp
   module Harness
@@ -135,6 +136,10 @@ module Aidp
               end
             end
           end
+        rescue Aidp::Errors::ConfigurationError
+          # Configuration errors should crash immediately (crash-early principle)
+          # Re-raise without catching
+          raise
         rescue => e
           @state = STATES[:error]
           @last_error = e

data/lib/aidp/harness/test_runner.rb

@@ -2,6 +2,7 @@
 
 require "open3"
 require_relative "../tooling_detector"
+require_relative "output_filter"
 
 module Aidp
   module Harness
@@ -11,30 +12,68 @@ module Aidp
       def initialize(project_dir, config)
         @project_dir = project_dir
         @config = config
+        @iteration_count = 0
       end
 
       # Run all configured tests
-      # Returns: { success: boolean, output: string, failures: array }
+      # Returns: { success: boolean, output: string, failures: array, required_failures: array }
       def run_tests
-        test_commands = resolved_test_commands
-        return {success: true, output: "", failures: []} if test_commands.empty?
-
-        results = test_commands.map { |cmd| execute_command(cmd, "test") }
-        aggregate_results(results, "Tests")
+        @iteration_count += 1
+        run_command_category(:test, "Tests")
       end
 
       # Run all configured linters
-      # Returns: { success: boolean, output: string, failures: array }
+      # Returns: { success: boolean, output: string, failures: array, required_failures: array }
       def run_linters
-        lint_commands = resolved_lint_commands
-        return {success: true, output: "", failures: []} if lint_commands.empty?
+        @iteration_count += 1
+        run_command_category(:lint, "Linters")
+      end
 
-        results = lint_commands.map { |cmd| execute_command(cmd, "linter") }
-        aggregate_results(results, "Linters")
+      # Run all configured formatters
+      # Returns: { success: boolean, output: string, failures: array, required_failures: array }
+      def run_formatters
+        run_command_category(:formatter, "Formatters")
+      end
+
+      # Run all configured build commands
+      # Returns: { success: boolean, output: string, failures: array, required_failures: array }
+      def run_builds
+        run_command_category(:build, "Build")
+      end
+
+      # Run all configured documentation commands
+      # Returns: { success: boolean, output: string, failures: array, required_failures: array }
+      def run_documentation
+        run_command_category(:documentation, "Documentation")
       end
 
       private
 
+      # Run commands for a specific category (test, lint, formatter, build, documentation)
+      def run_command_category(category, display_name)
+        commands = resolved_commands(category)
+
+        # If no commands configured, return success (empty check passes)
+        return {success: true, output: "", failures: [], required_failures: []} if commands.empty?
+
+        # Determine output mode based on category
+        mode = determine_output_mode(category)
+
+        # Execute all commands
+        results = commands.map do |cmd_config|
+          # Handle both string commands (legacy) and hash format (new)
+          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
+
       def execute_command(command, type)
         stdout, stderr, status = Open3.capture3(command, chdir: @project_dir)
 
@@ -48,53 +87,152 @@ module Aidp
         }
       end
 
-      def aggregate_results(results, category)
-        failures = results.reject { |r| r[:success] }
-        success = failures.empty?
+      def aggregate_results(results, category, mode: :full)
+        # Separate required and optional command failures
+        all_failures = results.reject { |r| r[:success] }
+        required_failures = all_failures.select { |r| r[:required] }
+        optional_failures = all_failures.reject { |r| r[:required] }
+
+        # Success only if all REQUIRED commands pass
+        # Optional command failures don't block completion
+        success = required_failures.empty?
 
-        output = if success
-          "#{category}: All passed"
+        output = if all_failures.empty?
+          "#{category}: All passed (#{results.length} commands)"
+        elsif required_failures.empty?
+          "#{category}: Required checks passed (#{optional_failures.length} optional warnings)\n" +
+            format_failures(optional_failures, "#{category} - Optional", mode: mode)
         else
-          format_failures(failures, category)
+          format_failures(required_failures, "#{category} - Required", mode: mode) +
+            (optional_failures.any? ? "\n" + format_failures(optional_failures, "#{category} - Optional", mode: mode) : "")
         end
 
         {
           success: success,
           output: output,
-          failures: failures
+          failures: all_failures,
+          required_failures: required_failures,
+          optional_failures: optional_failures
         }
       end
 
-      def format_failures(failures, category)
+      def format_failures(failures, category, mode: :full)
         output = ["#{category} Failures:", ""]
 
         failures.each do |failure|
           output << "Command: #{failure[:command]}"
           output << "Exit Code: #{failure[:exit_code]}"
           output << "--- Output ---"
-          output << failure[:stdout] unless failure[:stdout].strip.empty?
-          output << failure[:stderr] unless failure[:stderr].strip.empty?
+
+          # 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)
+
+          output << filtered_stdout unless filtered_stdout.strip.empty?
+          output << filtered_stderr unless filtered_stderr.strip.empty?
           output << ""
         end
 
         output.join("\n")
       end
 
+      def filter_output(raw_output, mode, framework)
+        return raw_output if mode == :full || raw_output.nil? || raw_output.empty?
+
+        filter_config = {
+          mode: mode,
+          include_context: true,
+          context_lines: 3,
+          max_lines: 500
+        }
+
+        filter = OutputFilter.new(filter_config)
+        filter.filter(raw_output, framework: framework)
+      rescue NameError
+        # Logging infrastructure not available
+        raw_output
+      rescue => e
+        Aidp.log_warn("test_runner", "filter_failed",
+          error: e.message,
+          framework: framework)
+        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
+        end
+      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
+        when :lint
+          if @config.respond_to?(:lint_output_mode)
+            @config.lint_output_mode
+          elsif @iteration_count > 1
+            :failures_only
+          else
+            :full
+          end
+        else
+          :full
+        end
+      end
+
+      # Resolve commands for a specific category
+      # Returns normalized command configs (array of {command:, required:} hashes)
+      def resolved_commands(category)
+        case category
+        when :test
+          resolved_test_commands
+        when :lint
+          resolved_lint_commands
+        when :formatter
+          @config.formatter_commands
+        when :build
+          @config.build_commands
+        when :documentation
+          @config.documentation_commands
+        else
+          []
+        end
+      end
+
       def resolved_test_commands
-        explicit = Array(@config.test_commands).compact.map(&:strip).reject(&:empty?)
+        explicit = @config.test_commands
         return explicit unless explicit.empty?
 
-        detected = detected_tooling.test_commands
-        log_fallback(:tests, detected) unless detected.empty?
+        # Auto-detect test commands if none explicitly configured
+        detected = detected_tooling.test_commands.map { |cmd| {command: cmd, required: true} }
+        log_fallback(:tests, detected.map { |c| c[:command] }) unless detected.empty?
         detected
       end
 
       def resolved_lint_commands
-        explicit = Array(@config.lint_commands).compact.map(&:strip).reject(&:empty?)
+        explicit = @config.lint_commands
         return explicit unless explicit.empty?
 
-        detected = detected_tooling.lint_commands
-        log_fallback(:linters, detected) unless detected.empty?
+        # Auto-detect lint commands if none explicitly configured
+        detected = detected_tooling.lint_commands.map { |cmd| {command: cmd, required: true} }
+        log_fallback(:linters, detected.map { |c| c[:command] }) unless detected.empty?
         detected
       end
 

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -2,12 +2,15 @@
 
 require_relative "capability_registry"
 require_relative "configuration"
+require_relative "../message_display"
 
 module Aidp
   module Harness
     # Manages thinking depth tier selection and escalation
     # Integrates with CapabilityRegistry and Configuration to select appropriate models
     class ThinkingDepthManager
+      include Aidp::MessageDisplay
+
       attr_reader :configuration, :registry
 
       def initialize(configuration, registry: nil, root_dir: nil)
@@ -150,11 +153,48 @@ module Aidp
         tier ||= current_tier
         validate_tier!(tier)
 
-        # If provider specified, try to find model for that provider
+        # First, try to get models from user's configuration for this tier
+        configured_models = configuration.models_for_tier(tier)
+
+        if configured_models.any?
+          # If provider specified, try to find model for that provider in config
+          if provider
+            matching_model = configured_models.find { |m| m[:provider] == provider }
+            if matching_model
+              Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
+                tier: tier,
+                provider: provider,
+                model: matching_model[:model])
+              return [matching_model[:provider], matching_model[:model], {}]
+            end
+
+            # If provider doesn't support tier and switching allowed, try other providers in config
+            unless configuration.allow_provider_switch_for_tier?
+              Aidp.log_warn("thinking_depth_manager", "Provider lacks tier in config, switching disabled",
+                tier: tier,
+                provider: provider)
+              return nil
+            end
+          end
+
+          # Try any configured model for this tier (prioritize first in list)
+          first_model = configured_models.first
+          if first_model
+            Aidp.log_info("thinking_depth_manager", "Selected model from user config",
+              tier: tier,
+              original_provider: provider,
+              selected_provider: first_model[:provider],
+              model: first_model[:model])
+            return [first_model[:provider], first_model[:model], {}]
+          end
+        end
+
+        # Fall back to catalog-based selection if no models in user config
+        # If provider specified, try to find model for that provider in catalog
         if provider
           model_name, model_data = @registry.best_model_for_tier(tier, provider)
           if model_name
-            Aidp.log_debug("thinking_depth_manager", "Selected model",
+            Aidp.log_debug("thinking_depth_manager", "Selected model from catalog",
               tier: tier,
               provider: provider,
               model: model_name)
@@ -163,20 +203,24 @@ module Aidp
 
           # If provider doesn't support tier and switching allowed, try others
           unless configuration.allow_provider_switch_for_tier?
-            Aidp.log_warn("thinking_depth_manager", "Provider lacks tier, switching disabled",
+            Aidp.log_warn("thinking_depth_manager", "Provider lacks tier in catalog, switching disabled",
               tier: tier,
               provider: provider)
             return nil
           end
         end
 
-        # Try all providers
+        # Try all providers in catalog
+        if provider && !configuration.allow_provider_switch_for_tier?
+          return nil
+        end
+
         providers_to_try = provider ? [@registry.provider_names - [provider]].flatten : @registry.provider_names
 
         providers_to_try.each do |prov_name|
           model_name, model_data = @registry.best_model_for_tier(tier, prov_name)
           if model_name
-            Aidp.log_info("thinking_depth_manager", "Selected model from alternate provider",
+            Aidp.log_info("thinking_depth_manager", "Selected model from catalog (alternate provider)",
               tier: tier,
               original_provider: provider,
               selected_provider: prov_name,
@@ -185,10 +229,23 @@ module Aidp
           end
         end
 
-        Aidp.log_error("thinking_depth_manager", "No model found for tier",
+        # No model found for requested tier - try fallback to other tiers
+        Aidp.log_warn("thinking_depth_manager", "No model found for requested tier, trying fallback",
           tier: tier,
           provider: provider)
-        nil
+
+        result = try_fallback_tiers(tier, provider)
+
+        unless result
+          # Enhanced error message with discovery hints
+          display_enhanced_tier_error(tier, provider)
+
+          Aidp.log_error("thinking_depth_manager", "No model found for tier or fallback tiers",
+            tier: tier,
+            provider: provider)
+        end
+
+        result
       end
 
       # Get tier for a specific model
@@ -330,6 +387,165 @@ module Aidp
         # Keep history bounded
         @tier_history.shift if @tier_history.size > 100
       end
+
+      # Try to find a model in fallback tiers when requested tier has no models
+      # Tries lower tiers first (cheaper), then higher tiers
+      # Returns [provider_name, model_name, model_data] or nil
+      def try_fallback_tiers(requested_tier, provider)
+        # Generate fallback order: try lower tiers first, then higher
+        fallback_tiers = generate_fallback_tier_order(requested_tier)
+
+        fallback_tiers.each do |fallback_tier|
+          # First, try user's configuration for this fallback tier
+          configured_models = configuration.models_for_tier(fallback_tier)
+
+          if configured_models.any?
+            # Try specified provider first if given
+            if provider
+              matching_model = configured_models.find { |m| m[:provider] == provider }
+              if matching_model
+                Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from config)",
+                  requested_tier: requested_tier,
+                  fallback_tier: fallback_tier,
+                  provider: provider,
+                  model: matching_model[:model])
+                return [matching_model[:provider], matching_model[:model], {}]
+              end
+            end
+
+            # Try any configured model for this tier
+            first_model = configured_models.first
+            if first_model
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier and provider (from config)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                requested_provider: provider,
+                fallback_provider: first_model[:provider],
+                model: first_model[:model])
+              return [first_model[:provider], first_model[:model], {}]
+            end
+          end
+
+          # Fall back to catalog if no models in config
+          # Try specified provider first if given
+          if provider
+            model_name, model_data = @registry.best_model_for_tier(fallback_tier, provider)
+            if model_name
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from catalog)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, model_data]
+            end
+          end
+
+          # Try all available providers in catalog
+          @registry.provider_names.each do |prov_name|
+            next if prov_name == provider # Skip if already tried above
+
+            model_name, model_data = @registry.best_model_for_tier(fallback_tier, prov_name)
+            if model_name
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier and provider (from catalog)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                requested_provider: provider,
+                fallback_provider: prov_name,
+                model: model_name)
+              return [prov_name, model_name, model_data]
+            end
+          end
+        end
+
+        nil
+      end
+
+      # Generate fallback tier order: lower tiers first (cheaper), then higher
+      # For example, if tier is "standard", try: mini, thinking, pro, max
+      def generate_fallback_tier_order(tier)
+        current_priority = @registry.tier_priority(tier) || 1
+        all_tiers = CapabilityRegistry::VALID_TIERS
+
+        # Split into lower and higher tiers
+        lower_tiers = all_tiers.select { |t| (@registry.tier_priority(t) || 0) < current_priority }.reverse
+        higher_tiers = all_tiers.select { |t| (@registry.tier_priority(t) || 0) > current_priority }
+
+        # Try lower tiers first (cost optimization), then higher tiers
+        lower_tiers + higher_tiers
+      end
+
+      # Display enhanced error message with discovery hints
+      def display_enhanced_tier_error(tier, provider)
+        return unless defined?(Aidp::MessageDisplay)
+
+        # Check if there are discovered models in cache
+        discovered_models = check_discovered_models(tier, provider)
+
+        if discovered_models&.any?
+          display_tier_error_with_suggestions(tier, provider, discovered_models)
+        else
+          display_tier_error_with_discovery_hint(tier, provider)
+        end
+      end
+
+      # Check cache for discovered models for this tier
+      def check_discovered_models(tier, provider)
+        require_relative "model_cache"
+        require_relative "model_registry"
+
+        cache = Aidp::Harness::ModelCache.new
+        registry = Aidp::Harness::ModelRegistry.new
+
+        # Get all cached models for the provider
+        cached_models = cache.get_cached_models(provider)
+        return nil unless cached_models&.any?
+
+        # Filter to models for the requested tier
+        tier_models = cached_models.select do |model|
+          family = model[:family] || model["family"]
+          model_info = registry.get_model_info(family)
+          model_info && model_info["tier"] == tier.to_s
+        end
+
+        tier_models.any? ? tier_models : nil
+      rescue => e
+        Aidp.log_debug("thinking_depth_manager", "failed to check cached models",
+          error: e.message)
+        nil
+      end
+
+      # Display error with model suggestions from cache
+      def display_tier_error_with_suggestions(tier, provider, models)
+        display_message("\n❌ No model configured for '#{tier}' tier", type: :error)
+        display_message("   Provider: #{provider}", type: :info) if provider
+
+        display_message("\n💡 Discovered models for this tier:", type: :highlight)
+        models.first(3).each do |model|
+          model_name = model[:name] || model["name"]
+          display_message("   - #{model_name}", type: :info)
+        end
+
+        display_message("\n   Add to aidp.yml:", type: :highlight)
+        display_message("   providers:", type: :info)
+        display_message("     #{provider}:", type: :info)
+        display_message("       thinking:", type: :info)
+        display_message("         tiers:", type: :info)
+        display_message("           #{tier}:", type: :info)
+        display_message("             models:", type: :info)
+        first_model = models.first[:name] || models.first["name"]
+        display_message("               - model: #{first_model}\n", type: :info)
+      end
+
+      # Display error with discovery hint
+      def display_tier_error_with_discovery_hint(tier, provider)
+        display_message("\n❌ No model configured for '#{tier}' tier", type: :error)
+        display_message("   Provider: #{provider}", type: :info) if provider
+
+        display_message("\n💡 Suggested actions:", type: :highlight)
+        display_message("   1. Run 'aidp models discover' to find available models", type: :info)
+        display_message("   2. Run 'aidp models list --tier=#{tier}' to see models for this tier", type: :info)
+        display_message("   3. Run 'aidp models validate' to check your configuration\n", type: :info)
+      end
     end
   end
 end

data/lib/aidp/harness/ui/enhanced_tui.rb

@@ -23,13 +23,16 @@ module Aidp
         def initialize(prompt: TTY::Prompt.new, tty: $stdin)
           @cursor = TTY::Cursor
           @screen = TTY::Screen
-          @pastel = Pastel.new
           @prompt = prompt
 
           # Headless (non-interactive) detection for test/CI environments:
           # - STDIN not a TTY (captured by PTY/tmux harness or test environment)
           @headless = !!(tty.nil? || !tty.tty?)
 
+          # Initialize Pastel with disabled colors in headless mode to avoid
+          # "closed stream" errors when checking TTY capabilities
+          @pastel = Pastel.new(enabled: !@headless)
+
           @current_mode = nil
           @workflow_active = false
           @current_step = nil