aidp 0.23.0 → 0.25.0

data/lib/aidp/harness/runner.rb

@@ -2,7 +2,7 @@
 
 require "timeout"
 require "json"
-require_relative "config_manager"
+require_relative "configuration"
 require_relative "state_manager"
 require_relative "condition_detector"
 require_relative "provider_manager"
@@ -44,27 +44,31 @@ module Aidp
         @current_provider = nil
         @user_input = options[:user_input] || {} # Include user input from workflow selection
         @execution_log = []
+        @last_error = nil
         @prompt = options[:prompt] || TTY::Prompt.new
 
         # Store workflow configuration
         @selected_steps = options[:selected_steps]
         @workflow_type = options[:workflow_type]
+        @non_interactive = options[:non_interactive] || (@workflow_type == :watch_mode)
 
         # Initialize components
-        @config_manager = ConfigManager.new(project_dir)
+        @configuration = Configuration.new(project_dir)
         @state_manager = StateManager.new(project_dir, @mode)
-        @provider_manager = ProviderManager.new(@config_manager, prompt: @prompt)
+        @provider_manager = ProviderManager.new(@configuration, prompt: @prompt)
 
         # Use ZFC-enabled condition detector
         # ZfcConditionDetector will create its own ProviderFactory if needed
         # Falls back to legacy pattern matching when ZFC is disabled
         require_relative "zfc_condition_detector"
-        @condition_detector = ZfcConditionDetector.new(@config_manager)
+        @condition_detector = ZfcConditionDetector.new(@configuration)
 
         @user_interface = SimpleUserInterface.new
-        @error_handler = ErrorHandler.new(@provider_manager, @config_manager)
+        @error_handler = ErrorHandler.new(@provider_manager, @configuration)
         @status_display = StatusDisplay.new
         @completion_checker = CompletionChecker.new(@project_dir, @workflow_type)
+        @failure_reason = nil
+        @failure_metadata = nil
       end
 
       # Main execution method - runs the harness loop
@@ -114,27 +118,55 @@ module Aidp
               display_message(completion_status[:summary], type: :info)
 
               # Ask user if they want to continue anyway
-              if @user_interface.get_confirmation("Continue anyway? This may indicate issues that should be addressed.", default: false)
-                @state = STATES[:completed]
-                log_execution("Harness completed with user override")
+              if confirmation_prompt_allowed?
+                if @user_interface.get_confirmation("Continue anyway? This may indicate issues that should be addressed.", default: false)
+                  @state = STATES[:completed]
+                  log_execution("Harness completed with user override")
+                else
+                  mark_completion_failure(completion_status)
+                  @state = STATES[:error]
+                  log_execution("Harness stopped due to unmet completion criteria")
+                end
               else
+                display_message("⚠️  Non-interactive mode: cannot override failed completion criteria. Stopping run.", type: :warning)
+                mark_completion_failure(completion_status)
                 @state = STATES[:error]
-                log_execution("Harness stopped due to unmet completion criteria")
+                log_execution("Harness stopped due to unmet completion criteria in non-interactive mode")
               end
             end
           end
         rescue => e
           @state = STATES[:error]
-          log_execution("Harness error: #{e.message}", {error: e.class.name})
+          @last_error = e
+          log_execution("Harness error: #{e.message}", {error: e.class.name, backtrace: e.backtrace&.first(5)})
           handle_error(e)
         ensure
-          # Save state before exiting
-          save_state
-          cleanup
+          # Save state before exiting - protect against exceptions during cleanup
+          begin
+            save_state
+          rescue => e
+            # Don't let state save failures kill the whole run or prevent cleanup
+            Aidp.logger.error("harness", "Failed to save state during cleanup: #{e.message}", error: e.class.name)
+            @last_error ||= e # Only set if no previous error
+          end
+
+          begin
+            cleanup
+          rescue => e
+            # Don't let cleanup failures propagate
+            Aidp.logger.error("harness", "Failed during cleanup: #{e.message}", error: e.class.name)
+          end
         end
 
         result = {status: @state, message: get_completion_message}
+        result[:reason] = @failure_reason if @failure_reason
+        result[:failure_metadata] = @failure_metadata if @failure_metadata
         result[:clarification_questions] = @clarification_questions if @clarification_questions
+        if @last_error
+          result[:error] = @last_error.message
+          result[:error_class] = @last_error.class.name
+          result[:backtrace] = @last_error.backtrace&.first(10)
+        end
         result
       end
 
@@ -183,9 +215,9 @@ module Aidp
         {
           harness: status,
           configuration: {
-            default_provider: @config_manager.default_provider,
-            fallback_providers: @config_manager.fallback_providers,
-            max_retries: @config_manager.harness_config[:max_retries]
+            default_provider: @configuration.default_provider,
+            fallback_providers: @configuration.fallback_providers,
+            max_retries: @configuration.harness_config[:max_retries]
           },
           provider_manager: @provider_manager.status,
           error_stats: @error_handler.error_stats
@@ -281,15 +313,30 @@ module Aidp
         log_execution("User feedback collected", {responses: user_responses.keys})
       end
 
-      def handle_rate_limit(_result)
+      def handle_rate_limit(result)
         @state = STATES[:waiting_for_rate_limit]
         log_execution("Rate limit detected, switching provider")
 
+        rate_limit_info = nil
+        if @condition_detector.respond_to?(:extract_rate_limit_info)
+          rate_limit_info = @condition_detector.extract_rate_limit_info(result, @current_provider)
+        end
+        reset_time = rate_limit_info && rate_limit_info[:reset_time]
+
         # Mark current provider as rate limited
-        @provider_manager.mark_rate_limited(@current_provider)
+        @provider_manager.mark_rate_limited(@current_provider, reset_time)
+
+        # Provider manager might already have switched upstream (e.g., during CLI execution)
+        manager_current = @provider_manager.current_provider
+        if manager_current && manager_current != @current_provider
+          @current_provider = manager_current
+          @state = STATES[:running]
+          log_execution("Provider already switched upstream", new_provider: manager_current)
+          return
+        end
 
-        # Switch to next provider
-        next_provider = @provider_manager.switch_provider
+        # Switch to next provider explicitly when still on the rate-limited provider
+        next_provider = @provider_manager.switch_provider("rate_limit", previous_provider: @current_provider)
         @current_provider = next_provider
 
         if next_provider
@@ -313,6 +360,10 @@ module Aidp
         end
       end
 
+      def confirmation_prompt_allowed?
+        !@non_interactive
+      end
+
       def sleep_until_reset(reset_time)
         while Time.now < reset_time && @state == STATES[:waiting_for_rate_limit]
           remaining = reset_time - Time.now
@@ -374,20 +425,14 @@ module Aidp
       end
 
       def save_state
-        # Save harness-specific state
+        # Save harness-specific state (execution_log removed to prevent unbounded growth)
         @state_manager.save_state({
           state: @state,
           current_step: @current_step,
           current_provider: @current_provider,
           user_input: @user_input,
-          execution_log: @execution_log,
           last_saved: Time.now
         })
-
-        # Also save execution log entries to state manager
-        @execution_log.each do |entry|
-          @state_manager.add_execution_log(entry)
-        end
       end
 
       def handle_error(error)
@@ -400,6 +445,7 @@ module Aidp
       end
 
       def log_execution(message, data = {})
+        # Keep in-memory log for runtime diagnostics (not persisted)
         log_entry = {
           timestamp: Time.now,
           message: message,
@@ -408,7 +454,13 @@ module Aidp
         }
         @execution_log << log_entry
 
-        # Also log to standard logging if available
+        # Log to persistent logger instead of state file
+        Aidp.logger.info("harness_execution", message,
+          state: @state,
+          step: @current_step,
+          **data.slice(:error, :error_class, :criteria, :all_complete, :summary).compact)
+
+        # Also log to standard output in debug mode
         puts "[#{Time.now.strftime("%H:%M:%S")}] #{message}" if ENV["AIDP_DEBUG"] == "1"
       end
 
@@ -419,12 +471,21 @@ module Aidp
         when STATES[:stopped]
           "Harness stopped by user."
         when STATES[:error]
-          "Harness encountered an error and stopped."
+          if @last_error
+            "Harness encountered an error and stopped: #{@last_error.class.name}: #{@last_error.message}"
+          else
+            "Harness encountered an error and stopped."
+          end
         else
           "Harness finished in state: #{@state}"
         end
       end
 
+      def mark_completion_failure(completion_status)
+        @failure_reason = :completion_criteria
+        @failure_metadata = completion_status
+      end
+
       private
     end
   end

data/lib/aidp/harness/simple_user_interface.rb

@@ -26,6 +26,10 @@ module Aidp
         responses
       end
 
+      def get_confirmation(message, default: true)
+        @prompt.yes?(message, default: default)
+      end
+
       private
 
       def show_context(context)

data/lib/aidp/harness/state/ui_state.rb

@@ -19,16 +19,6 @@ module Aidp
           update_state(user_input: current_input)
         end
 
-        def execution_log
-          state[:execution_log] || []
-        end
-
-        def add_execution_log(entry)
-          current_log = execution_log
-          current_log << entry
-          update_state(execution_log: current_log)
-        end
-
         def current_step
           state[:current_step]
         end

data/lib/aidp/harness/state_manager.rb

@@ -129,20 +129,6 @@ module Aidp
         update_state(user_input: current_input, last_updated: Time.now)
       end
 
-      # Get execution log
-      def execution_log
-        state = load_state
-        return [] unless state
-        state[:execution_log] || []
-      end
-
-      # Add to execution log
-      def add_execution_log(entry)
-        current_log = execution_log
-        current_log << entry
-        update_state(execution_log: current_log, last_updated: Time.now)
-      end
-
       # Get provider state
       def provider_state
         state = load_state
@@ -615,7 +601,7 @@ module Aidp
             yield
           end
         end
-      rescue Aidp::Concurrency::MaxAttemptsExceededError
+      rescue Aidp::Concurrency::MaxAttemptsError
         raise "Could not acquire state lock within timeout"
       ensure
         # Clean up lock file

data/lib/aidp/harness/test_runner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "open3"
+require_relative "../tooling_detector"
 
 module Aidp
   module Harness
@@ -15,7 +16,7 @@ module Aidp
       # Run all configured tests
       # Returns: { success: boolean, output: string, failures: array }
       def run_tests
-        test_commands = @config.test_commands || []
+        test_commands = resolved_test_commands
         return {success: true, output: "", failures: []} if test_commands.empty?
 
         results = test_commands.map { |cmd| execute_command(cmd, "test") }
@@ -25,7 +26,7 @@ module Aidp
       # Run all configured linters
       # Returns: { success: boolean, output: string, failures: array }
       def run_linters
-        lint_commands = @config.lint_commands || []
+        lint_commands = resolved_lint_commands
         return {success: true, output: "", failures: []} if lint_commands.empty?
 
         results = lint_commands.map { |cmd| execute_command(cmd, "linter") }
@@ -78,6 +79,42 @@ module Aidp
 
         output.join("\n")
       end
+
+      def resolved_test_commands
+        explicit = Array(@config.test_commands).compact.map(&:strip).reject(&:empty?)
+        return explicit unless explicit.empty?
+
+        detected = detected_tooling.test_commands
+        log_fallback(:tests, detected) unless detected.empty?
+        detected
+      end
+
+      def resolved_lint_commands
+        explicit = Array(@config.lint_commands).compact.map(&:strip).reject(&:empty?)
+        return explicit unless explicit.empty?
+
+        detected = detected_tooling.lint_commands
+        log_fallback(:linters, detected) unless detected.empty?
+        detected
+      end
+
+      def detected_tooling
+        @detected_tooling ||= Aidp::ToolingDetector.detect(@project_dir)
+      rescue => e
+        Aidp.log_warn("test_runner", "tooling_detection_failed", error: e.message)
+        Aidp::ToolingDetector::Result.new(test_commands: [], lint_commands: [])
+      end
+
+      def log_fallback(type, commands)
+        Aidp.log_info(
+          "test_runner",
+          "auto_detected_commands",
+          category: type,
+          commands: commands
+        )
+      rescue NameError
+        # Logging infrastructure not available in some tests
+      end
     end
   end
 end

data/lib/aidp/logger.rb

@@ -3,6 +3,7 @@
 require "logger"
 require "json"
 require "fileutils"
+require "pathname"
 
 module Aidp
   # Unified structured logger for all AIDP operations
@@ -84,12 +85,30 @@ module Aidp
     private
 
     def determine_log_level
-      # Priority: ENV > config > default
-      level_str = ENV["AIDP_LOG_LEVEL"] || @config[:level] || "info"
-      level_sym = level_str.to_sym
+      # Priority: explicit env override > DEBUG flags > config > default
+      level_str = if ENV["AIDP_LOG_LEVEL"]
+        ENV["AIDP_LOG_LEVEL"]
+      elsif debug_env_enabled?
+        "debug"
+      elsif @config[:level]
+        @config[:level]
+      else
+        "info"
+      end
+      level_sym = level_str.to_s.to_sym
       LEVELS.key?(level_sym) ? level_sym : :info
     end
 
+    def debug_env_enabled?
+      raw = ENV["AIDP_DEBUG"] || ENV["DEBUG"]
+      return false if raw.nil?
+
+      normalized = raw.to_s.strip.downcase
+      return true if %w[true on yes debug].include?(normalized)
+
+      /\A\d+\z/.match?(normalized) ? normalized.to_i.positive? : false
+    end
+
     def should_log?(level)
       LEVELS[level] >= LEVELS[@level]
     end
@@ -106,7 +125,7 @@ module Aidp
     end
 
     def setup_logger
-      info_path = File.join(@project_dir, INFO_LOG)
+      info_path = determine_log_file_path
       @logger = create_logger(info_path)
       # Emit instrumentation after logger is available (avoid recursive Aidp.log_* calls during bootstrap)
       return unless @instrument_internal
@@ -181,6 +200,17 @@ module Aidp
       JSON.generate(entry)
     end
 
+    def determine_log_file_path
+      custom = (ENV["AIDP_LOG_FILE"] || @config[:file]).to_s.strip
+      relative_path = custom.empty? ? INFO_LOG : custom
+
+      if Pathname.new(relative_path).absolute?
+        relative_path
+      else
+        File.join(@project_dir, relative_path)
+      end
+    end
+
     # Redaction patterns for common secrets
     REDACTION_PATTERNS = [
       # API keys and tokens (with capture groups)

data/lib/aidp/message_display.rb

@@ -25,8 +25,12 @@ module Aidp
 
     # Instance helper for displaying a colored message via TTY::Prompt
     def display_message(message, type: :info)
+      # 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)
@@ -41,7 +45,11 @@ module Aidp
     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))
+        # 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

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"