aidp 0.25.0 → 0.26.0

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/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

data/lib/aidp/logger.rb

@@ -18,6 +18,27 @@ module Aidp
   #   Aidp.setup_logger(project_dir, config)
   #   Aidp.logger.info("component", "message", key: "value")
   class Logger
+    # Custom log device that suppresses IOError exceptions for closed streams.
+    # This prevents "log shifting failed. closed stream" errors during test cleanup.
+    class SafeLogDevice < ::Logger::LogDevice
+      private
+
+      # Override handle_write_errors to suppress warnings for closed stream errors.
+      # Ruby's Logger::LogDevice calls warn() when write operations fail, which
+      # produces "log shifting failed. closed stream" messages during test cleanup.
+      def handle_write_errors(mesg)
+        yield
+      rescue *@reraise_write_errors
+        raise
+      rescue IOError => e
+        # Silently ignore closed stream errors - these are expected during
+        # test cleanup when loggers are finalized after streams are closed
+        return if e.message.include?("closed stream")
+        warn("log #{mesg} failed. #{e}")
+      rescue => e
+        warn("log #{mesg} failed. #{e}")
+      end
+    end
     LEVELS = {
       debug: ::Logger::DEBUG,
       info: ::Logger::INFO,
@@ -140,14 +161,17 @@ module Aidp
       dir = File.dirname(path)
       FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
 
-      logger = ::Logger.new(path, @max_files, @max_size)
+      # Create logger with custom SafeLogDevice that suppresses closed stream errors
+      logdev = SafeLogDevice.new(path, shift_age: @max_files, shift_size: @max_size)
+      logger = ::Logger.new(logdev)
       logger.level = ::Logger::DEBUG # Control at write level instead
       logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
       logger
     rescue => e
       # Fall back to STDERR if file logging fails
       Kernel.warn "[AIDP Logger] Failed to create log file at #{path}: #{e.message}. Falling back to STDERR."
-      logger = ::Logger.new($stderr)
+      logdev = SafeLogDevice.new($stderr)
+      logger = ::Logger.new(logdev)
       logger.level = ::Logger::DEBUG
       logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
       logger
@@ -246,7 +270,9 @@ module Aidp
       raw_input = dir.to_s
       raw_invalid = raw_input.empty? || raw_input.match?(/[<>|]/) || raw_input.match?(/[\x00-\x1F]/)
       if raw_invalid
-        Kernel.warn "[AIDP Logger] Invalid project_dir '#{raw_input}' - falling back to #{Dir.pwd}"
+        unless ENV["RSPEC_RUNNING"] == "true"
+          Kernel.warn "[AIDP Logger] Invalid project_dir '#{raw_input}' - falling back to #{Dir.pwd}"
+        end
         if Dir.pwd == File::SEPARATOR
           fallback = begin
             home = Dir.home
@@ -255,7 +281,9 @@ module Aidp
             Dir.tmpdir
           end
           @root_fallback = fallback
-          Kernel.warn "[AIDP Logger] Root directory detected - using #{fallback} for logging instead of '#{Dir.pwd}'"
+          unless ENV["RSPEC_RUNNING"] == "true"
+            Kernel.warn "[AIDP Logger] Root directory detected - using #{fallback} for logging instead of '#{Dir.pwd}'"
+          end
           return fallback
         end
         return Dir.pwd
@@ -268,7 +296,9 @@ module Aidp
           Dir.tmpdir
         end
         @root_fallback = fallback
-        Kernel.warn "[AIDP Logger] Root directory detected - using #{fallback} for logging instead of '#{raw_input}'"
+        unless ENV["RSPEC_RUNNING"] == "true"
+          Kernel.warn "[AIDP Logger] Root directory detected - using #{fallback} for logging instead of '#{raw_input}'"
+        end
         return fallback
       end
       raw_input

data/lib/aidp/message_display.rb

@@ -25,6 +25,7 @@ module Aidp
 
     # Instance helper for displaying a colored message via TTY::Prompt
     def display_message(message, type: :info)
+      return if suppress_display_message?(message)
       # Ensure message is UTF-8 encoded to handle emoji and special characters
       message_str = message.to_s
       message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -42,9 +43,32 @@ module Aidp
       end
     end
 
+    # Check if specific display message should be suppressed in test/CI environments
+    def suppress_display_message?(message)
+      return false unless in_test_environment?
+
+      message_str = message.to_s
+      # Only suppress specific automated status messages, not CLI output
+      message_str.include?("🔄 Provider switch:") ||
+        message_str.include?("🔄 Model switch:") ||
+        message_str.include?("🔴 Circuit breaker opened") ||
+        message_str.include?("🟢 Circuit breaker reset") ||
+        message_str.include?("❌ No providers available") ||
+        message_str.include?("❌ No models available") ||
+        message_str.include?("📊 Execution Summary") ||
+        message_str.include?("▶️  [") ||  # Workstream execution messages
+        message_str.include?("✅ [") ||    # Workstream success messages
+        message_str.include?("❌ [")       # Workstream failure messages
+    end
+
+    def in_test_environment?
+      ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+    end
+
     module ClassMethods
       # Class-level display helper (uses fresh prompt to respect $stdout changes)
       def display_message(message, type: :info)
+        return if suppress_display_message?(message)
         # Ensure message is UTF-8 encoded to handle emoji and special characters
         message_str = message.to_s
         message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -54,6 +78,28 @@ module Aidp
 
       private
 
+      # Check if specific display message should be suppressed in test/CI environments
+      def suppress_display_message?(message)
+        return false unless in_test_environment?
+
+        message_str = message.to_s
+        # Only suppress specific automated status messages, not CLI output
+        message_str.include?("🔄 Provider switch:") ||
+          message_str.include?("🔄 Model switch:") ||
+          message_str.include?("🔴 Circuit breaker opened") ||
+          message_str.include?("🟢 Circuit breaker reset") ||
+          message_str.include?("❌ No providers available") ||
+          message_str.include?("❌ No models available") ||
+          message_str.include?("📊 Execution Summary") ||
+          message_str.include?("▶️  [") ||  # Workstream execution messages
+          message_str.include?("✅ [") ||    # Workstream success messages
+          message_str.include?("❌ [")       # Workstream failure messages
+      end
+
+      def in_test_environment?
+        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+      end
+
       # Don't memoize - create fresh prompt each time to respect $stdout redirection in tests
       def class_message_display_prompt
         TTY::Prompt.new

data/lib/aidp/safe_directory.rb

@@ -22,14 +22,21 @@ module Aidp
         path
       rescue SystemCallError => e
         fallback = determine_fallback_path(path)
-        Kernel.warn "[#{component_name}] Cannot create directory #{path}: #{e.class}: #{e.message}"
-        Kernel.warn "[#{component_name}] Using fallback directory: #{fallback}"
+
+        # Suppress permission warnings during tests to reduce noise
+        unless ENV["RSPEC_RUNNING"] == "true"
+          Kernel.warn "[#{component_name}] Cannot create directory #{path}: #{e.class}: #{e.message}"
+          Kernel.warn "[#{component_name}] Using fallback directory: #{fallback}"
+        end
 
         # Try to create fallback directory
         begin
           FileUtils.mkdir_p(fallback) unless Dir.exist?(fallback)
         rescue SystemCallError => e2
-          Kernel.warn "[#{component_name}] Fallback directory creation also failed: #{e2.class}: #{e2.message}"
+          # Suppress fallback errors during tests too
+          unless ENV["RSPEC_RUNNING"] == "true"
+            Kernel.warn "[#{component_name}] Fallback directory creation also failed: #{e2.class}: #{e2.message}"
+          end
         end
 
         fallback

data/lib/aidp/storage/csv_storage.rb

@@ -205,12 +205,12 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          warn_storage("[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}")
           @base_dir = fallback
           begin
             FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
           rescue SystemCallError => e2
-            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent CSV storage."
+            warn_storage("[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent CSV storage.")
           end
         end
       end
@@ -225,11 +225,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/storage/file_manager.rb

@@ -16,7 +16,7 @@ module Aidp
         csv_dir = @csv_storage.instance_variable_get(:@base_dir)
         if json_dir != @base_dir || csv_dir != @base_dir
           @base_dir = json_dir # Prefer JSON storage directory
-          Kernel.warn "[AIDP Storage] Base directory normalized to #{@base_dir} after fallback."
+          warn_storage("[AIDP Storage] Base directory normalized to #{@base_dir} after fallback.")
         end
       end
 
@@ -229,11 +229,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/storage/json_storage.rb

@@ -171,12 +171,12 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}"
+          warn_storage("[AIDP Storage] Cannot create base directory #{@base_dir}: #{e.class}: #{e.message}. Using fallback #{fallback}")
           @base_dir = fallback
           begin
             FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
           rescue SystemCallError => e2
-            Kernel.warn "[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage."
+            warn_storage("[AIDP Storage] Fallback directory creation also failed: #{e2.class}: #{e2.message}. Continuing without persistent JSON storage.")
           end
         end
       end
@@ -192,11 +192,17 @@ module Aidp
           rescue
             File.join(Dir.tmpdir, "aidp_storage")
           end
-          Kernel.warn "[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'"
+          warn_storage("[AIDP Storage] Root base_dir detected - using fallback #{fallback} instead of '#{str}'")
           return fallback
         end
         str
       end
+
+      # Suppress storage warnings in test/CI environments
+      def warn_storage(message)
+        return if ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+        Kernel.warn(message)
+      end
     end
   end
 end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.25.0"
+  VERSION = "0.26.0"
 end

data/lib/aidp/watch/build_processor.rb

@@ -228,12 +228,51 @@ module Aidp
         relevant.map do |comment|
           author = comment["author"] || "unknown"
           created = comment["createdAt"] ? Time.parse(comment["createdAt"]).utc.iso8601 : "unknown"
-          "### #{author} (#{created})\n#{comment["body"]}"
+          body = strip_archived_plans(comment["body"])
+          "### #{author} (#{created})\n#{body}"
         end.join("\n\n")
       rescue
         "_Unable to parse comment thread._"
       end
 
+      def strip_archived_plans(content)
+        return content unless content
+
+        # Remove all archived plan sections (wrapped in HTML comments)
+        result = content.dup
+
+        # Remove archived plan blocks
+        # Safe string-based approach to avoid ReDoS vulnerabilities
+        start_prefix = "<!-- ARCHIVED_PLAN_START"
+        end_marker = "<!-- ARCHIVED_PLAN_END -->"
+
+        loop do
+          # Find the start of an archived plan block (may have attributes after ARCHIVED_PLAN_START)
+          start_idx = result.index(start_prefix)
+          break unless start_idx
+
+          # Find the closing --> of the start marker
+          start_marker_end = result.index("-->", start_idx)
+          break unless start_marker_end
+
+          # Find the corresponding end marker
+          end_idx = result.index(end_marker, start_marker_end)
+          break unless end_idx
+
+          # Remove the entire block including markers
+          result = result[0...start_idx] + result[(end_idx + end_marker.length)..]
+        end
+
+        # Remove HTML-commented sections from active plan
+        # Keep the content between START and END markers, but strip the markers themselves
+        # This preserves the current plan while removing archived content
+        result = result.gsub(/<!-- (PLAN_SUMMARY_START|PLAN_TASKS_START|CLARIFYING_QUESTIONS_START) -->/, "")
+        result = result.gsub(/<!-- (PLAN_SUMMARY_END|PLAN_TASKS_END|CLARIFYING_QUESTIONS_END) -->/, "")
+
+        # Clean up any extra blank lines
+        result.gsub(/\n{3,}/, "\n\n").strip
+      end
+
       def write_prompt(content, working_dir: @project_dir)
         prompt_manager = Aidp::Execute::PromptManager.new(working_dir)
         prompt_manager.write(content, step_name: IMPLEMENTATION_STEP)