aidp 0.24.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,8 +25,13 @@ 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"
+      message_str = message_str.encode("UTF-8", invalid: :replace, undef: :replace)
       prompt = message_display_prompt
-      prompt.say(message, color: COLOR_MAP.fetch(type, :white))
+      prompt.say(message_str, color: COLOR_MAP.fetch(type, :white))
     end
 
     # Provide a memoized prompt per including instance (if it defines @prompt)
@@ -38,14 +43,63 @@ 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)
-        class_message_display_prompt.say(message, color: COLOR_MAP.fetch(type, :white))
+        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"
+        message_str = message_str.encode("UTF-8", invalid: :replace, undef: :replace)
+        class_message_display_prompt.say(message_str, color: COLOR_MAP.fetch(type, :white))
       end
 
       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/prompt_optimization/style_guide_indexer.rb

@@ -82,7 +82,7 @@ module Aidp
         guide_path = File.join(@project_dir, "docs", "LLM_STYLE_GUIDE.md")
         return nil unless File.exist?(guide_path)
 
-        File.read(guide_path)
+        File.read(guide_path, encoding: "UTF-8")
       end
 
       # Parse markdown content into fragments
@@ -90,6 +90,8 @@ module Aidp
       # @param content [String] Markdown content
       # @return [Array<Fragment>] Parsed fragments
       def parse_fragments(content)
+        # Ensure content is UTF-8 encoded
+        content = content.encode("UTF-8", invalid: :replace, undef: :replace) unless content.encoding == Encoding::UTF_8
         lines = content.lines
         current_content = []
         current_heading = nil

data/lib/aidp/provider_manager.rb

@@ -142,6 +142,8 @@ module Aidp
           Aidp::Providers::Anthropic.new(prompt: prompt)
         when "gemini"
           Aidp::Providers::Gemini.new(prompt: prompt)
+        when "kilocode"
+          Aidp::Providers::Kilocode.new(prompt: prompt)
         when "github_copilot"
           Aidp::Providers::GithubCopilot.new(prompt: prompt)
         when "codex"

data/lib/aidp/providers/kilocode.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "base"
+require_relative "../util"
+require_relative "../debug_mixin"
+
+module Aidp
+  module Providers
+    class Kilocode < Base
+      include Aidp::DebugMixin
+
+      def self.available?
+        !!Aidp::Util.which("kilocode")
+      end
+
+      def name
+        "kilocode"
+      end
+
+      def display_name
+        "Kilocode"
+      end
+
+      def send_message(prompt:, session: nil)
+        raise "kilocode not available" unless self.class.available?
+
+        # Smart timeout calculation
+        timeout_seconds = calculate_timeout
+
+        debug_provider("kilocode", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to kilocode (length: #{prompt.length})", level: :info)
+
+        # Check if streaming mode is enabled
+        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
+        if streaming_enabled
+          display_message("📺 Display streaming enabled - output buffering reduced", type: :info)
+        end
+
+        # Check if prompt is too large and warn
+        if prompt.length > 3000
+          debug_log("⚠️  Large prompt detected (#{prompt.length} chars) - this may cause rate limiting", level: :warn)
+        end
+
+        # Set up activity monitoring
+        setup_activity_monitoring("kilocode", method(:activity_callback))
+        record_activity("Starting kilocode execution")
+
+        # Create a spinner for activity display
+        spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
+        spinner.auto_spin
+
+        activity_display_thread = Thread.new do
+          start_time = Time.now
+          loop do
+            sleep 0.5 # Update every 500ms to reduce spam
+            elapsed = Time.now - start_time
+
+            # Break if we've been running too long or state changed
+            break if elapsed > timeout_seconds || @activity_state == :completed || @activity_state == :failed
+
+            update_spinner_status(spinner, elapsed, "🔄 kilocode")
+          end
+        end
+
+        begin
+          # Build kilocode command arguments
+          args = ["--auto"]
+
+          # Add model if specified
+          model = ENV["KILOCODE_MODEL"]
+          if model
+            args.concat(["-m", model])
+          end
+
+          # Add workspace detection if needed
+          if Dir.exist?(".git") && ENV["KILOCODE_WORKSPACE"]
+            args.concat(["--workspace", ENV["KILOCODE_WORKSPACE"]])
+          end
+
+          # Set authentication via environment variable
+          env_vars = {}
+          if ENV["KILOCODE_TOKEN"]
+            env_vars["KILOCODE_TOKEN"] = ENV["KILOCODE_TOKEN"]
+          end
+
+          # Use debug_execute_command for better debugging
+          result = debug_execute_command("kilocode", args: args, input: prompt, timeout: timeout_seconds, streaming: streaming_enabled, env: env_vars)
+
+          # Log the results
+          debug_command("kilocode", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
+
+          if result.exit_status == 0
+            spinner.success("✓")
+            mark_completed
+            result.out
+          else
+            spinner.error("✗")
+            mark_failed("kilocode failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("kilocode failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "kilocode failed with exit code #{result.exit_status}: #{result.err}"
+          end
+        rescue => e
+          spinner&.error("✗")
+          mark_failed("kilocode execution failed: #{e.message}")
+          debug_error(e, {provider: "kilocode", prompt_length: prompt.length})
+          raise
+        ensure
+          cleanup_activity_display(activity_display_thread, spinner)
+        end
+      end
+
+      private
+
+      def calculate_timeout
+        # Priority order for timeout calculation:
+        # 1. Quick mode (for testing)
+        # 2. Environment variable override
+        # 3. Adaptive timeout based on step type
+        # 4. Default timeout
+
+        if ENV["AIDP_QUICK_MODE"]
+          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
+          return TIMEOUT_QUICK_MODE
+        end
+
+        if ENV["AIDP_KILOCODE_TIMEOUT"]
+          return ENV["AIDP_KILOCODE_TIMEOUT"].to_i
+        end
+
+        if adaptive_timeout
+          display_message("🧠 Using adaptive timeout: #{adaptive_timeout} seconds", type: :info)
+          return adaptive_timeout
+        end
+
+        # Default timeout
+        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
+        TIMEOUT_DEFAULT
+      end
+
+      def adaptive_timeout
+        @adaptive_timeout ||= begin
+          # Timeout recommendations based on step type patterns
+          step_name = ENV["AIDP_CURRENT_STEP"] || ""
+
+          case step_name
+          when /REPOSITORY_ANALYSIS/
+            TIMEOUT_REPOSITORY_ANALYSIS
+          when /ARCHITECTURE_ANALYSIS/
+            TIMEOUT_ARCHITECTURE_ANALYSIS
+          when /TEST_ANALYSIS/
+            TIMEOUT_TEST_ANALYSIS
+          when /FUNCTIONALITY_ANALYSIS/
+            TIMEOUT_FUNCTIONALITY_ANALYSIS
+          when /DOCUMENTATION_ANALYSIS/
+            TIMEOUT_DOCUMENTATION_ANALYSIS
+          when /STATIC_ANALYSIS/
+            TIMEOUT_STATIC_ANALYSIS
+          when /REFACTORING_RECOMMENDATIONS/
+            TIMEOUT_REFACTORING_RECOMMENDATIONS
+          else
+            nil # Use default
+          end
+        end
+      end
+
+      def activity_callback(state, message, provider)
+        # This is now handled by the animated display thread
+        # Only print static messages for state changes
+        case state
+        when :starting
+          display_message("🚀 Starting kilocode execution...", type: :info)
+        when :completed
+          display_message("✅ kilocode execution completed", type: :success)
+        when :failed
+          display_message("❌ kilocode execution failed: #{message}", type: :error)
+        end
+      end
+
+      def setup_activity_monitoring(provider_name, callback)
+        @activity_callback = callback
+        @activity_state = :starting
+        @activity_start_time = Time.now
+      end
+
+      def record_activity(message)
+        @activity_state = :running
+        @activity_callback&.call(:running, message, "kilocode")
+      end
+
+      def mark_completed
+        @activity_state = :completed
+        @activity_callback&.call(:completed, "Execution completed", "kilocode")
+      end
+
+      def mark_failed(reason)
+        @activity_state = :failed
+        @activity_callback&.call(:failed, reason, "kilocode")
+      end
+    end
+  end
+end