aidp 0.25.0 → 0.26.0

data/lib/aidp/harness/configuration.rb

@@ -168,12 +168,47 @@ module Aidp
 
       # Get test commands
       def test_commands
-        work_loop_config[:test_commands] || []
+        normalize_commands(work_loop_config[:test_commands] || [])
       end
 
       # Get lint commands
       def lint_commands
-        work_loop_config[:lint_commands] || []
+        normalize_commands(work_loop_config[:lint_commands] || [])
+      end
+
+      # Get formatter commands
+      def formatter_commands
+        normalize_commands(work_loop_config[:formatter_commands] || [])
+      end
+
+      # Get build commands
+      def build_commands
+        normalize_commands(work_loop_config[:build_commands] || [])
+      end
+
+      # Get documentation commands
+      def documentation_commands
+        normalize_commands(work_loop_config[:documentation_commands] || [])
+      end
+
+      # Get test output mode
+      def test_output_mode
+        work_loop_config.dig(:test, :output_mode) || :full
+      end
+
+      # Get max output lines for tests
+      def test_max_output_lines
+        work_loop_config.dig(:test, :max_output_lines) || 500
+      end
+
+      # Get lint output mode
+      def lint_output_mode
+        work_loop_config.dig(:lint, :output_mode) || :full
+      end
+
+      # Get max output lines for linters
+      def lint_max_output_lines
+        work_loop_config.dig(:lint, :max_output_lines) || 300
       end
 
       # Get guards configuration
@@ -704,6 +739,42 @@ module Aidp
 
       private
 
+      # Normalize command configuration to consistent format
+      # Supports both string format and object format with required flag
+      # Examples:
+      #   "bundle exec rspec" -> {command: "bundle exec rspec", required: true}
+      #   {command: "rubocop", required: false} -> {command: "rubocop", required: false}
+      def normalize_commands(commands)
+        return [] if commands.nil? || commands.empty?
+
+        commands.map do |cmd|
+          case cmd
+          when String
+            {command: cmd, required: true}
+          when Hash
+            # Handle both symbol and string keys
+            command_value = cmd[:command] || cmd["command"]
+            required_value = if cmd.key?(:required)
+              cmd[:required]
+            else
+              (cmd.key?("required") ? cmd["required"] : true)
+            end
+
+            unless command_value.is_a?(String) && !command_value.empty?
+              raise ConfigurationError, "Command must be a non-empty string, got: #{command_value.inspect}"
+            end
+
+            unless [true, false].include?(required_value)
+              raise ConfigurationError, "Required flag must be boolean, got: #{required_value.inspect}"
+            end
+
+            {command: command_value, required: required_value}
+          else
+            raise ConfigurationError, "Command must be a string or hash, got: #{cmd.class}"
+          end
+        end
+      end
+
       def validate_configuration!
         errors = Aidp::Config.validate_harness_config(@config, @project_dir)
 

data/lib/aidp/harness/filter_strategy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    # Base class for framework-specific filtering strategies
+    class FilterStrategy
+      # @param output [String] Raw output
+      # @param filter [OutputFilter] Filter instance for config access
+      # @return [String] Filtered output
+      def filter(output, filter_instance)
+        raise NotImplementedError, "Subclasses must implement #filter"
+      end
+
+      protected
+
+      # Extract lines around a match (for context)
+      def extract_with_context(lines, index, context_lines)
+        start_idx = [0, index - context_lines].max
+        end_idx = [lines.length - 1, index + context_lines].min
+
+        lines[start_idx..end_idx]
+      end
+
+      # Find failure markers in output
+      def find_failure_markers(output)
+        lines = output.lines
+        markers = []
+
+        lines.each_with_index do |line, index|
+          # Check for failure patterns using safe string methods
+          if line.match?(/FAILED/i) ||
+              line.match?(/ERROR/i) ||
+              line.match?(/FAIL:/i) ||
+              line.match?(/failures?:/i) ||
+              line.match?(/^\s*\d{1,4}\)\s/) ||  # Numbered failures (limit digits to prevent ReDoS)
+              line.include?(") ")  # Additional simple check for numbered patterns
+            markers << index
+          end
+        end
+
+        markers
+      end
+    end
+  end
+end

data/lib/aidp/harness/generic_filter_strategy.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "filter_strategy"
+
+module Aidp
+  module Harness
+    # Generic filtering for unknown frameworks
+    class GenericFilterStrategy < FilterStrategy
+      def filter(output, filter_instance)
+        case filter_instance.mode
+        when :failures_only
+          extract_failure_lines(output, filter_instance)
+        when :minimal
+          extract_summary(output, filter_instance)
+        else
+          output
+        end
+      end
+
+      private
+
+      def extract_failure_lines(output, filter_instance)
+        lines = output.lines
+        failure_indices = find_failure_markers(output)
+
+        return output if failure_indices.empty?
+
+        # Extract failures with context
+        relevant_lines = Set.new
+        failure_indices.each do |index|
+          if filter_instance.include_context
+            extract_with_context(lines, index, filter_instance.context_lines)
+            start_idx = [0, index - filter_instance.context_lines].max
+            end_idx = [lines.length - 1, index + filter_instance.context_lines].min
+            (start_idx..end_idx).each { |idx| relevant_lines.add(idx) }
+          else
+            relevant_lines.add(index)
+          end
+        end
+
+        selected = relevant_lines.to_a.sort.map { |idx| lines[idx] }
+        selected.join
+      end
+
+      def extract_summary(output, filter_instance)
+        lines = output.lines
+
+        # Take first line, last line, and any lines with numbers/statistics
+        parts = []
+        parts << lines.first if lines.first
+
+        summary_lines = lines.select do |line|
+          line.match?(/\d+/) || line.match?(/summary|total|passed|failed/i)
+        end
+
+        parts.concat(summary_lines.uniq)
+        parts << lines.last if lines.last && !parts.include?(lines.last)
+
+        parts.join("\n")
+      end
+    end
+  end
+end

data/lib/aidp/harness/output_filter.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Harness
+    # Filters test and linter output to reduce token consumption
+    # Uses framework-specific strategies to extract relevant information
+    class OutputFilter
+      # Output modes
+      MODES = {
+        full: :full,                   # No filtering (default for first run)
+        failures_only: :failures_only, # Only failure information
+        minimal: :minimal              # Minimal failure info + summary
+      }.freeze
+
+      # @param config [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!
+
+        Aidp.log_debug("output_filter", "initialized",
+          mode: @mode,
+          include_context: @include_context,
+          max_lines: @max_lines)
+      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
+      # @return [String] Filtered output
+      def filter(output, framework: :unknown)
+        return output if @mode == :full
+        return "" if output.nil? || output.empty?
+
+        Aidp.log_debug("output_filter", "filtering_start",
+          framework: framework,
+          input_lines: output.lines.count)
+
+        strategy = strategy_for_framework(framework)
+        filtered = strategy.filter(output, self)
+
+        truncated = truncate_if_needed(filtered)
+
+        Aidp.log_debug("output_filter", "filtering_complete",
+          output_lines: truncated.lines.count,
+          reduction: reduction_stats(output, truncated))
+
+        truncated
+      rescue NameError
+        # Logging infrastructure not available
+        return output if @mode == :full
+        return "" if output.nil? || output.empty?
+
+        strategy = strategy_for_framework(framework)
+        filtered = strategy.filter(output, self)
+        truncate_if_needed(filtered)
+      rescue => e
+        # External failure - graceful degradation
+        begin
+          Aidp.log_error("output_filter", "filtering_failed",
+            framework: framework,
+            mode: @mode,
+            error: e.message,
+            error_class: e.class.name)
+        rescue NameError
+          # Logging not available
+        end
+
+        # Return original output as fallback
+        output
+      end
+
+      # Accessors for strategy use
+      attr_reader :mode, :include_context, :context_lines, :max_lines
+
+      private
+
+      def validate_mode!
+        unless MODES.key?(@mode)
+          raise ArgumentError, "Invalid mode: #{@mode}. Must be one of #{MODES.keys}"
+        end
+      end
+
+      def strategy_for_framework(framework)
+        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
+          require_relative "generic_filter_strategy"
+          GenericFilterStrategy.new
+        end
+      end
+
+      def truncate_if_needed(output)
+        lines = output.lines
+        return output if lines.count <= @max_lines
+
+        truncated = lines.first(@max_lines).join
+        # Only add newline if truncated doesn't already end with one
+        separator = truncated.end_with?("\n") ? "" : "\n"
+        truncated + separator + "[Output truncated - #{lines.count - @max_lines} more lines omitted]"
+      end
+
+      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)
+
+        {
+          input_bytes: input_size,
+          output_bytes: output_size,
+          reduction_percent: reduction
+        }
+      end
+    end
+  end
+end

data/lib/aidp/harness/provider_manager.rb

@@ -1394,14 +1394,27 @@ module Aidp
 
       # Execute a prompt with a specific provider
       def execute_with_provider(provider_type, prompt, options = {})
+        # Extract model from options if provided
+        model_name = options.delete(:model)
+
         # Create provider factory instance
         provider_factory = ProviderFactory.new
 
+        # Add model to provider options if specified
+        provider_options = options.dup
+        provider_options[:model] = model_name if model_name
+
         # Create provider instance
-        provider = provider_factory.create_provider(provider_type, options)
+        provider = provider_factory.create_provider(provider_type, provider_options)
 
-        # Set current provider
+        # Set current provider and model
         @current_provider = provider_type
+        @current_model = model_name if model_name
+
+        Aidp.logger.debug("provider_manager", "Executing with provider",
+          provider: provider_type,
+          model: model_name,
+          prompt_length: prompt.length)
 
         # Execute the prompt with the provider
         result = provider.send_message(prompt: prompt, session: nil)
@@ -1410,15 +1423,17 @@ module Aidp
         {
           status: "completed",
           provider: provider_type,
+          model: model_name,
           output: result,
           metadata: {
             provider_type: provider_type,
+            model: model_name,
             prompt_length: prompt.length,
             timestamp: Time.now.strftime("%Y-%m-%dT%H:%M:%S.%3N%z")
           }
         }
       rescue => e
-        log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, prompt_length: prompt.length)
+        log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, model: model_name, prompt_length: prompt.length)
         # Return error result
         {
           status: "error",

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