aidp 0.34.0 → 0.39.3

data/lib/aidp/harness/test_runner.rb

@@ -4,18 +4,82 @@ require "open3"
 require_relative "../tooling_detector"
 require_relative "output_filter"
 require_relative "output_filter_config"
+require_relative "rspec_command_optimizer"
 
 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
+    #
+    # Supports both legacy category-specific commands (test_commands, lint_commands, etc.)
+    # and the new generic commands array with run_after phases.
     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}
+        @previous_iteration_had_test_failures = false
+        @rspec_optimizer = RSpecCommandOptimizer.new(project_dir)
+      end
+
+      # Run all commands configured for a specific execution phase
+      # @param phase [Symbol] :each_unit, :full_loop, or :on_completion
+      # @return [Hash] Aggregated results with success status and outputs by command
+      def run_commands_for_phase(phase)
+        @iteration_count += 1
+        commands = @config.commands_for_phase(phase)
+
+        Aidp.log_debug("test_runner", "running_commands_for_phase",
+          phase: phase,
+          command_count: commands.length,
+          iteration: @iteration_count)
+
+        return empty_results if commands.empty?
+
+        results_by_command = {}
+        all_failures = []
+        required_failures = []
+
+        commands.each do |cmd_config|
+          result = execute_command(cmd_config[:command], cmd_config[:category].to_s)
+          result[:name] = cmd_config[:name]
+          result[:category] = cmd_config[:category]
+          result[:required] = cmd_config[:required]
+
+          results_by_command[cmd_config[:name]] = result
+
+          unless result[:success]
+            all_failures << result
+            required_failures << result if cmd_config[:required]
+          end
+        end
+
+        success = required_failures.empty?
+        output = if all_failures.empty?
+          "All #{commands.length} commands passed"
+        else
+          format_phase_failures(all_failures, phase)
+        end
+
+        {
+          success: success,
+          output: output,
+          failures: all_failures,
+          required_failures: required_failures,
+          results_by_command: results_by_command
+        }
+      end
+
+      # Get all commands organized by phase
+      # @return [Hash] Commands grouped by run_after phase
+      def commands_by_phase
+        {
+          each_unit: @config.commands_for_phase(:each_unit),
+          full_loop: @config.commands_for_phase(:full_loop),
+          on_completion: @config.commands_for_phase(:on_completion)
+        }
       end
 
       # Run all configured tests
@@ -68,13 +132,44 @@ module Aidp
       # Get filtering statistics
       attr_reader :filter_stats
 
+      # Get RSpec command optimizer (for inspection/testing)
+      attr_reader :rspec_optimizer
+
+      # Track if previous iteration had test failures (for --only-failures optimization)
+      attr_reader :previous_iteration_had_test_failures
+
       # Reset iteration counter (useful for testing)
       def reset_iteration_count
         @iteration_count = 0
+        @previous_iteration_had_test_failures = false
+        @rspec_optimizer.reset_caches!
       end
 
       private
 
+      # Return empty results structure
+      def empty_results
+        {success: true, output: "", failures: [], required_failures: [], results_by_command: {}}
+      end
+
+      # Format failures for phase-based execution
+      def format_phase_failures(failures, phase)
+        output = ["#{phase.to_s.tr("_", " ").capitalize} Phase Failures:", ""]
+
+        failures.each do |failure|
+          required_label = failure[:required] ? "[REQUIRED]" : "[OPTIONAL]"
+          output << "#{required_label} #{failure[:name]} (#{failure[:category]})"
+          output << "Command: #{failure[:command]}"
+          output << "Exit Code: #{failure[:exit_code]}"
+          output << "--- Output ---"
+          output << failure[:stdout] unless failure[:stdout].to_s.strip.empty?
+          output << failure[:stderr] unless failure[:stderr].to_s.strip.empty?
+          output << ""
+        end
+
+        output.join("\n")
+      end
+
       # Run commands for a specific category (test, lint, formatter, build, documentation)
       def run_command_category(category, display_name)
         commands = resolved_commands(category)
@@ -85,54 +180,115 @@ module Aidp
         # Determine output mode based on category
         mode = determine_output_mode(category)
 
+        # Enable RSpec optimization for test commands
+        optimize_rspec = (category == :test)
+
         Aidp.log_debug("test_runner", "running_category",
           category: category,
           command_count: commands.length,
           iteration: @iteration_count,
-          output_mode: mode)
+          output_mode: mode,
+          optimize_rspec: optimize_rspec,
+          previous_had_failures: @previous_iteration_had_test_failures)
 
         # 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 = execute_command(cmd_config, category.to_s, optimize_rspec: optimize_rspec)
             result.merge(required: true)
           else
-            result = execute_command(cmd_config[:command], category.to_s)
+            result = execute_command(cmd_config[:command], category.to_s, optimize_rspec: optimize_rspec)
             result.merge(required: cmd_config[:required])
           end
         end
 
-        aggregate_results(results, display_name, mode: mode)
+        aggregated = aggregate_results(results, display_name, mode: mode)
+
+        # Track test failures for next iteration's --only-failures optimization
+        if category == :test
+          @previous_iteration_had_test_failures = !aggregated[:success]
+          @rspec_optimizer.reset_caches! if aggregated[:success]
+
+          Aidp.log_debug("test_runner", "test_failure_tracking",
+            iteration: @iteration_count,
+            had_failures: @previous_iteration_had_test_failures,
+            failure_count: aggregated[:failures]&.length || 0)
+        end
+
+        aggregated
       rescue NameError
         # Logging not available
         commands = resolved_commands(category)
         return {success: true, output: "", failures: [], required_failures: []} if commands.empty?
 
+        optimize_rspec = (category == :test)
         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 = execute_command(cmd_config, category.to_s, optimize_rspec: optimize_rspec)
             result.merge(required: true)
           else
-            result = execute_command(cmd_config[:command], category.to_s)
+            result = execute_command(cmd_config[:command], category.to_s, optimize_rspec: optimize_rspec)
             result.merge(required: cmd_config[:required])
           end
         end
 
-        aggregate_results(results, display_name, mode: mode)
+        aggregated = aggregate_results(results, display_name, mode: mode)
+
+        # Track test failures for next iteration (without logging)
+        if category == :test
+          @previous_iteration_had_test_failures = !aggregated[:success]
+          @rspec_optimizer.reset_caches! if aggregated[:success]
+        end
+
+        aggregated
       end
 
-      def execute_command(command, type)
-        stdout, stderr, status = Open3.capture3(command, chdir: @project_dir)
+      def execute_command(command, type, optimize_rspec: false)
+        actual_command = command
+        optimization_info = nil
+
+        # Apply RSpec --only-failures optimization for test commands on subsequent iterations
+        if optimize_rspec && type == "test"
+          optimization_info = @rspec_optimizer.optimize_command(
+            command,
+            iteration: @iteration_count,
+            had_failures: @previous_iteration_had_test_failures
+          )
+          actual_command = optimization_info[:command]
+
+          if optimization_info[:optimized]
+            Aidp.log_info("test_runner", "rspec_optimized",
+              original: command,
+              optimized: actual_command,
+              iteration: @iteration_count,
+              reason: optimization_info[:reason])
+          end
+        end
+
+        stdout, stderr, status = Open3.capture3(actual_command, chdir: @project_dir)
+
+        # Handle special case: --only-failures with no failures to rerun
+        # RSpec exits with 0 and says "All examples were filtered out"
+        if optimization_info&.dig(:optimized) && status.success? && stdout.include?("All examples were filtered out")
+          Aidp.log_info("test_runner", "rspec_only_failures_empty",
+            message: "No failures to rerun, running full suite")
+
+          # Fall back to full RSpec run
+          stdout, stderr, status = Open3.capture3(command, chdir: @project_dir)
+          actual_command = command
+        end
 
         {
-          command: command,
+          command: actual_command,
+          original_command: command,
           type: type,
           success: status.success?,
           exit_code: status.exitstatus,
           stdout: stdout,
-          stderr: stderr
+          stderr: stderr,
+          rspec_optimized: optimization_info&.dig(:optimized) || false
         }
       end