aidp 0.32.0 → 0.34.0

data/lib/aidp/harness/enhanced_runner.rb

@@ -23,6 +23,15 @@ module Aidp
         error: "error"
       }.freeze
 
+      # Expose state for testability
+      attr_accessor :state, :current_step, :start_time
+      attr_writer :current_provider, :user_input, :execution_log
+      attr_accessor :mode, :project_dir, :selected_steps, :workflow_type
+      attr_reader :provider_manager, :sleeper
+      attr_writer :completion_checker, :workflow_controller, :error_handler
+      attr_accessor :condition_detector
+      attr_writer :state_manager, :configuration
+
       # Simple sleeper abstraction for test control
       class Sleeper
         def sleep(duration)
@@ -75,27 +84,21 @@ module Aidp
         @completion_checker = options[:completion_checker] || CompletionChecker.new(@project_dir, @workflow_type)
       end
 
-      # Get current provider (delegate to provider manager)
+      # Get current provider (delegate to provider manager with fallback)
       def current_provider
         @current_provider || @provider_manager&.current_provider || "unknown"
       end
 
-      # Get current step
-      attr_reader :current_step
-
-      # Get user input
+      # Get user input (with nil safety)
       def user_input
         @user_input || {}
       end
 
-      # Get execution log
+      # Get execution log (with nil safety)
       def execution_log
         @execution_log || []
       end
 
-      # Get provider manager
-      attr_reader :provider_manager
-
       # Main execution method with enhanced TUI
       def run
         @state = STATES[:running]
@@ -354,7 +357,7 @@ module Aidp
           duration: @start_time ? Time.now - @start_time : 0,
           user_input_count: @user_input.size,
           execution_log_count: @execution_log.size,
-          jobs_count: @tui.instance_variable_get(:@jobs).size
+          jobs_count: @tui.jobs.size
         }
       end
 
@@ -530,7 +533,7 @@ module Aidp
 
       def cleanup
         # Cleanup any remaining jobs
-        @tui.instance_variable_get(:@jobs).keys.each do |job_id|
+        @tui.jobs.keys.each do |job_id|
           @tui.remove_job(job_id)
         end
       end

data/lib/aidp/harness/error_handler.rb

@@ -12,6 +12,9 @@ module Aidp
     class ErrorHandler
       include Aidp::DebugMixin
 
+      # Expose internal components for testability
+      attr_reader :retry_strategies, :backoff_calculator, :error_classifier, :recovery_planner
+
       # Simple wrapper to allow dependency injection of sleep behavior in tests
       class Sleeper
         def sleep(seconds)

data/lib/aidp/harness/filter_definition.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    # Value object representing a generated filter definition
+    # Created by AI during configuration, applied deterministically at runtime
+    #
+    # @example Usage
+    #   definition = FilterDefinition.new(
+    #     tool_name: "pytest",
+    #     summary_patterns: ["\\d+ passed", "\\d+ failed"],
+    #     failure_section_start: "=+ FAILURES =+",
+    #     failure_section_end: "=+ short test summary",
+    #     error_patterns: ["AssertionError", "Error:"],
+    #     location_patterns: ["\\S+\\.py:\\d+"],
+    #     noise_patterns: ["^\\s*$", "^platform "]
+    #   )
+    #
+    # @see AIFilterFactory for generation
+    # @see GeneratedFilterStrategy for runtime application
+    class FilterDefinition
+      attr_reader :tool_name, :tool_command, :summary_patterns, :failure_section_start,
+        :failure_section_end, :error_section_start, :error_section_end,
+        :error_patterns, :location_patterns, :noise_patterns,
+        :important_patterns, :context_lines, :created_at
+
+      # Initialize a filter definition
+      #
+      # @param tool_name [String] Human-readable tool name (e.g., "pytest", "eslint")
+      # @param tool_command [String, nil] The command used to run the tool
+      # @param summary_patterns [Array<String>] Regex patterns that match summary lines
+      # @param failure_section_start [String, nil] Regex pattern marking start of failures section
+      # @param failure_section_end [String, nil] Regex pattern marking end of failures section
+      # @param error_section_start [String, nil] Regex pattern marking start of errors section
+      # @param error_section_end [String, nil] Regex pattern marking end of errors section
+      # @param error_patterns [Array<String>] Regex patterns that match error indicators
+      # @param location_patterns [Array<String>] Regex patterns that extract file:line locations
+      # @param noise_patterns [Array<String>] Regex patterns for lines to filter out
+      # @param important_patterns [Array<String>] Regex patterns for lines to always keep
+      # @param context_lines [Integer] Number of context lines around failures
+      # @param created_at [Time, nil] When this definition was generated
+      def initialize(
+        tool_name:,
+        tool_command: nil,
+        summary_patterns: [],
+        failure_section_start: nil,
+        failure_section_end: nil,
+        error_section_start: nil,
+        error_section_end: nil,
+        error_patterns: [],
+        location_patterns: [],
+        noise_patterns: [],
+        important_patterns: [],
+        context_lines: 3,
+        created_at: nil
+      )
+        @tool_name = tool_name
+        @tool_command = tool_command
+        @summary_patterns = compile_patterns(summary_patterns)
+        @failure_section_start = compile_pattern(failure_section_start)
+        @failure_section_end = compile_pattern(failure_section_end)
+        @error_section_start = compile_pattern(error_section_start)
+        @error_section_end = compile_pattern(error_section_end)
+        @error_patterns = compile_patterns(error_patterns)
+        @location_patterns = compile_patterns(location_patterns)
+        @noise_patterns = compile_patterns(noise_patterns)
+        @important_patterns = compile_patterns(important_patterns)
+        @context_lines = context_lines
+        @created_at = created_at || Time.now
+
+        freeze
+      end
+
+      # Create from a hash (e.g., loaded from YAML config)
+      #
+      # @param hash [Hash] Definition data with string or symbol keys
+      # @return [FilterDefinition]
+      def self.from_hash(hash)
+        hash = hash.transform_keys(&:to_sym)
+
+        new(
+          tool_name: hash[:tool_name] || "unknown",
+          tool_command: hash[:tool_command],
+          summary_patterns: Array(hash[:summary_patterns]),
+          failure_section_start: hash[:failure_section_start],
+          failure_section_end: hash[:failure_section_end],
+          error_section_start: hash[:error_section_start],
+          error_section_end: hash[:error_section_end],
+          error_patterns: Array(hash[:error_patterns]),
+          location_patterns: Array(hash[:location_patterns]),
+          noise_patterns: Array(hash[:noise_patterns]),
+          important_patterns: Array(hash[:important_patterns]),
+          context_lines: hash[:context_lines] || 3,
+          created_at: hash[:created_at] ? Time.parse(hash[:created_at].to_s) : nil
+        )
+      end
+
+      # Convert to hash for serialization (e.g., saving to YAML)
+      #
+      # @return [Hash] Serializable representation
+      def to_h
+        {
+          tool_name: @tool_name,
+          tool_command: @tool_command,
+          summary_patterns: patterns_to_strings(@summary_patterns),
+          failure_section_start: pattern_to_string(@failure_section_start),
+          failure_section_end: pattern_to_string(@failure_section_end),
+          error_section_start: pattern_to_string(@error_section_start),
+          error_section_end: pattern_to_string(@error_section_end),
+          error_patterns: patterns_to_strings(@error_patterns),
+          location_patterns: patterns_to_strings(@location_patterns),
+          noise_patterns: patterns_to_strings(@noise_patterns),
+          important_patterns: patterns_to_strings(@important_patterns),
+          context_lines: @context_lines,
+          created_at: @created_at&.iso8601
+        }.compact
+      end
+
+      # Check if this definition has failure section markers
+      #
+      # @return [Boolean]
+      def has_failure_section?
+        !@failure_section_start.nil?
+      end
+
+      # Check if this definition has error section markers
+      #
+      # @return [Boolean]
+      def has_error_section?
+        !@error_section_start.nil?
+      end
+
+      # Check if a line matches any summary pattern
+      #
+      # @param line [String] Line to check
+      # @return [Boolean]
+      def summary_line?(line)
+        @summary_patterns.any? { |pattern| line.match?(pattern) }
+      end
+
+      # Check if a line matches any error pattern
+      #
+      # @param line [String] Line to check
+      # @return [Boolean]
+      def error_line?(line)
+        @error_patterns.any? { |pattern| line.match?(pattern) }
+      end
+
+      # Check if a line should be filtered as noise
+      #
+      # @param line [String] Line to check
+      # @return [Boolean]
+      def noise_line?(line)
+        @noise_patterns.any? { |pattern| line.match?(pattern) }
+      end
+
+      # Check if a line should always be kept
+      #
+      # @param line [String] Line to check
+      # @return [Boolean]
+      def important_line?(line)
+        @important_patterns.any? { |pattern| line.match?(pattern) }
+      end
+
+      # Extract file locations from a line
+      #
+      # @param line [String] Line to extract locations from
+      # @return [Array<String>] Extracted locations
+      def extract_locations(line)
+        @location_patterns.flat_map do |pattern|
+          line.scan(pattern).flatten
+        end.compact.uniq
+      end
+
+      # Equality based on all attributes
+      def ==(other)
+        return false unless other.is_a?(FilterDefinition)
+
+        to_h == other.to_h
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        to_h.hash
+      end
+
+      private
+
+      def compile_patterns(strings)
+        Array(strings).map { |s| compile_pattern(s) }.compact
+      end
+
+      def compile_pattern(string)
+        return nil if string.nil? || string.empty?
+        Regexp.new(string, Regexp::IGNORECASE)
+      rescue RegexpError => e
+        Aidp.log_warn("filter_definition", "Invalid regex pattern",
+          pattern: string, error: e.message)
+        nil
+      end
+
+      def patterns_to_strings(patterns)
+        patterns.map { |p| p&.source }.compact
+      end
+
+      def pattern_to_string(pattern)
+        pattern&.source
+      end
+    end
+  end
+end

data/lib/aidp/harness/generated_filter_strategy.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "filter_strategy"
+require_relative "filter_definition"
+
+module Aidp
+  module Harness
+    # Deterministic filter strategy using AI-generated patterns
+    #
+    # This strategy applies a FilterDefinition at runtime without any AI calls.
+    # The patterns were generated by AIFilterFactory during configuration.
+    #
+    # @example Usage
+    #   definition = FilterDefinition.from_hash(config[:filter_definitions][:pytest])
+    #   strategy = GeneratedFilterStrategy.new(definition)
+    #   filtered = strategy.filter(raw_output, filter_instance)
+    #
+    # @see FilterDefinition for the pattern specification
+    # @see AIFilterFactory for how definitions are generated
+    class GeneratedFilterStrategy < FilterStrategy
+      attr_reader :definition
+
+      # Initialize with a filter definition
+      #
+      # @param definition [FilterDefinition] The AI-generated filter definition
+      def initialize(definition)
+        @definition = definition
+      end
+
+      # Filter output using the definition's patterns
+      #
+      # @param output [String] Raw output to filter
+      # @param filter_instance [OutputFilter] Filter instance with mode and config
+      # @return [String] Filtered output
+      def filter(output, filter_instance)
+        return output if output.nil? || output.empty?
+
+        case filter_instance.mode
+        when :failures_only
+          extract_failures_only(output)
+        when :minimal
+          extract_minimal(output)
+        else
+          output
+        end
+      end
+
+      private
+
+      # Extract failures and summary for failures_only mode
+      def extract_failures_only(output)
+        lines = output.lines
+        parts = []
+
+        # Extract summary lines
+        summary_lines = extract_summary_lines(lines)
+        if summary_lines.any?
+          parts << "#{@definition.tool_name} Summary:"
+          parts.concat(summary_lines.map(&:strip))
+          parts << ""
+        end
+
+        # Extract failure section if markers defined
+        if @definition.has_failure_section?
+          failure_content = extract_section(lines,
+            @definition.failure_section_start,
+            @definition.failure_section_end)
+          if failure_content.any?
+            parts << "Failures:"
+            parts.concat(failure_content)
+            parts << ""
+          end
+        end
+
+        # Extract error section if different from failures
+        if @definition.has_error_section?
+          error_content = extract_section(lines,
+            @definition.error_section_start,
+            @definition.error_section_end)
+          if error_content.any?
+            parts << "Errors:"
+            parts.concat(error_content)
+            parts << ""
+          end
+        end
+
+        # If no section markers are defined, extract lines with error patterns
+        # This handles tools that don't have structured failure sections
+        unless @definition.has_failure_section? || @definition.has_error_section?
+          error_lines = extract_error_lines(lines)
+          if error_lines.any?
+            parts << "Issues:"
+            parts.concat(error_lines)
+            parts << ""
+          end
+        end
+
+        result = parts.join("\n")
+        result.empty? ? output : result
+      end
+
+      # Extract minimal information (summary + locations only)
+      def extract_minimal(output)
+        lines = output.lines
+        parts = []
+
+        # Extract summary
+        summary_lines = extract_summary_lines(lines)
+        parts.concat(summary_lines.map(&:strip))
+
+        # Extract all file locations
+        locations = extract_all_locations(lines)
+        if locations.any?
+          parts << ""
+          parts << "Locations:"
+          parts.concat(locations.uniq.map { |loc| "  #{loc}" })
+        end
+
+        parts.join("\n")
+      end
+
+      # Extract lines matching summary patterns
+      def extract_summary_lines(lines)
+        lines.select { |line| @definition.summary_line?(line) }
+      end
+
+      # Extract content between section markers
+      def extract_section(lines, start_pattern, end_pattern)
+        return [] unless start_pattern
+
+        content = []
+        in_section = false
+
+        lines.each do |line|
+          if !in_section && line.match?(start_pattern)
+            in_section = true
+            content << line unless @definition.noise_line?(line)
+            next
+          end
+
+          if in_section
+            # Check for section end
+            if end_pattern && line.match?(end_pattern)
+              in_section = false
+              next
+            end
+
+            # Skip noise lines but keep important ones
+            if @definition.important_line?(line) || !@definition.noise_line?(line)
+              content << line
+            end
+          end
+        end
+
+        content.map(&:rstrip)
+      end
+
+      # Extract lines with error patterns (when no sections defined)
+      def extract_error_lines(lines)
+        result = []
+        context_buffer = []
+        context_lines = @definition.context_lines
+
+        lines.each_with_index do |line, index|
+          # Keep track of context
+          context_buffer << line
+          context_buffer.shift if context_buffer.size > context_lines
+
+          # Check for error indicators
+          if @definition.error_line?(line) || @definition.important_line?(line)
+            # Add preceding context
+            result.concat(context_buffer[0...-1]) if context_buffer.size > 1
+
+            # Add the error line
+            result << line
+
+            # Add following context
+            following = lines[index + 1, context_lines] || []
+            following.each do |following_line|
+              break if @definition.summary_line?(following_line)
+              result << following_line unless @definition.noise_line?(following_line)
+            end
+
+            context_buffer.clear
+          end
+        end
+
+        result.uniq.map(&:rstrip)
+      end
+
+      # Extract all file locations from output
+      def extract_all_locations(lines)
+        lines.flat_map { |line| @definition.extract_locations(line) }
+      end
+    end
+  end
+end

data/lib/aidp/harness/output_filter.rb

@@ -1,9 +1,23 @@
 # frozen_string_literal: true
 
+require_relative "output_filter_config"
+
 module Aidp
   module Harness
     # Filters test and linter output to reduce token consumption
-    # Uses framework-specific strategies to extract relevant information
+    #
+    # Supports two filtering approaches:
+    # 1. AI-generated FilterDefinitions (preferred) - created once during config,
+    #    applied deterministically at runtime for ANY tool
+    # 2. Built-in RSpec strategy (fallback) - for backward compatibility
+    #
+    # @example Using AI-generated filter
+    #   definition = FilterDefinition.from_hash(config[:filter_definitions][:pytest])
+    #   filter = OutputFilter.new(mode: :failures_only, filter_definition: definition)
+    #   filtered = filter.filter(output)
+    #
+    # @see AIFilterFactory for generating filter definitions
+    # @see FilterDefinition for the definition format
     class OutputFilter
       # Output modes
       MODES = {
@@ -12,30 +26,32 @@ module Aidp
         minimal: :minimal              # Minimal failure info + summary
       }.freeze
 
-      # @param config [Hash] Configuration options
+      # @param config [OutputFilterConfig, Hash] Configuration options
       # @option config [Symbol] :mode Output mode (:full, :failures_only, :minimal)
       # @option config [Boolean] :include_context Include surrounding lines
       # @option config [Integer] :context_lines Number of context lines
       # @option config [Integer] :max_lines Maximum output lines
-      def initialize(config = {})
-        @mode = config[:mode] || :full
-        @include_context = config.fetch(:include_context, true)
-        @context_lines = config.fetch(:context_lines, 3)
-        @max_lines = config.fetch(:max_lines, 500)
-
-        validate_mode!
+      # @param filter_definition [FilterDefinition, nil] AI-generated filter patterns
+      def initialize(config = {}, filter_definition: nil)
+        @config = normalize_config(config)
+        @mode = @config.mode
+        @include_context = @config.include_context
+        @context_lines = @config.context_lines
+        @max_lines = @config.max_lines
+        @filter_definition = filter_definition
 
         Aidp.log_debug("output_filter", "initialized",
           mode: @mode,
           include_context: @include_context,
-          max_lines: @max_lines)
+          max_lines: @max_lines,
+          has_definition: !@filter_definition.nil?)
       rescue NameError
         # Logging infrastructure not available in some tests
       end
 
       # Filter output based on framework and mode
       # @param output [String] Raw output
-      # @param framework [Symbol] Framework identifier
+      # @param framework [Symbol] Framework identifier (:rspec, :minitest, :jest, :pytest, :unknown)
       # @return [String] Filtered output
       def filter(output, framework: :unknown)
         return output if @mode == :full
@@ -43,6 +59,7 @@ module Aidp
 
         Aidp.log_debug("output_filter", "filtering_start",
           framework: framework,
+          mode: @mode,
           input_lines: output.lines.count)
 
         strategy = strategy_for_framework(framework)
@@ -51,6 +68,7 @@ module Aidp
         truncated = truncate_if_needed(filtered)
 
         Aidp.log_debug("output_filter", "filtering_complete",
+          framework: framework,
           output_lines: truncated.lines.count,
           reduction: reduction_stats(output, truncated))
 
@@ -80,31 +98,38 @@ module Aidp
       end
 
       # Accessors for strategy use
-      attr_reader :mode, :include_context, :context_lines, :max_lines
+      attr_reader :mode, :include_context, :context_lines, :max_lines, :config, :filter_definition
 
       private
 
-      def validate_mode!
-        unless MODES.key?(@mode)
-          raise ArgumentError, "Invalid mode: #{@mode}. Must be one of #{MODES.keys}"
+      def normalize_config(config)
+        case config
+        when OutputFilterConfig
+          config
+        when Hash
+          OutputFilterConfig.from_hash(config)
+        when nil
+          OutputFilterConfig.new
+        else
+          raise ArgumentError, "Config must be an OutputFilterConfig or Hash, got: #{config.class}"
         end
       end
 
       def strategy_for_framework(framework)
+        # Use AI-generated filter definition if available (preferred)
+        if @filter_definition
+          require_relative "generated_filter_strategy"
+          return GeneratedFilterStrategy.new(@filter_definition)
+        end
+
+        # Fall back to built-in strategies for backward compatibility
         case framework
         when :rspec
           require_relative "rspec_filter_strategy"
           RSpecFilterStrategy.new
-        when :minitest
-          require_relative "generic_filter_strategy"
-          GenericFilterStrategy.new
-        when :jest
-          require_relative "generic_filter_strategy"
-          GenericFilterStrategy.new
-        when :pytest
-          require_relative "generic_filter_strategy"
-          GenericFilterStrategy.new
         else
+          # Use generic strategy for all other frameworks
+          # Users should generate a FilterDefinition for better results
           require_relative "generic_filter_strategy"
           GenericFilterStrategy.new
         end
@@ -123,7 +148,7 @@ module Aidp
       def reduction_stats(input, output)
         input_size = input.bytesize
         output_size = output.bytesize
-        reduction = ((input_size - output_size).to_f / input_size * 100).round(1)
+        reduction = input_size.zero? ? 0 : ((input_size - output_size).to_f / input_size * 100).round(1)
 
         {
           input_bytes: input_size,