aidp 0.22.0 → 0.24.0

data/lib/aidp/harness/provider_manager.rb

@@ -2,6 +2,7 @@
 
 require "tty-prompt"
 require_relative "provider_factory"
+require_relative "provider_metrics"
 require_relative "../rescue_logging"
 require_relative "../concurrency"
 
@@ -40,6 +41,20 @@ module Aidp
         @unavailable_cache = {}
         @binary_check_cache = {}
         @binary_check_ttl = 300 # seconds
+
+        # Initialize persistence
+        project_dir = if configuration.respond_to?(:project_dir)
+          configuration.project_dir
+        elsif configuration.respond_to?(:root_dir)
+          configuration.root_dir
+        else
+          Dir.pwd
+        end
+        @metrics_persistence = ProviderMetrics.new(project_dir)
+
+        # Load persisted metrics
+        load_persisted_metrics
+
         initialize_fallback_chains
         initialize_provider_health
         initialize_model_configs
@@ -932,6 +947,9 @@ module Aidp
         # Update provider health
         update_provider_health(provider_name, "rate_limited")
 
+        # Persist rate limit info to disk
+        save_persisted_rate_limits
+
         # Switch to next provider if current one is rate limited
         if provider_name == current_provider
           switch_provider("rate_limit", {provider: provider_name})
@@ -996,6 +1014,9 @@ module Aidp
           metrics[:last_error_time] = Time.now
           update_provider_health(provider_name, "error", {error: error})
         end
+
+        # Persist metrics to disk
+        save_persisted_metrics
       end
 
       # Record model metrics
@@ -1611,6 +1632,49 @@ module Aidp
         # Most models reset rate limits every hour
         Time.now + (60 * 60)
       end
+
+      # Load persisted metrics from disk
+      def load_persisted_metrics
+        return unless @metrics_persistence
+
+        # Load provider metrics
+        persisted_metrics = @metrics_persistence.load_metrics
+        @provider_metrics.merge!(persisted_metrics) if persisted_metrics.is_a?(Hash)
+
+        # Load rate limit info
+        persisted_rate_limits = @metrics_persistence.load_rate_limits
+        @rate_limit_info.merge!(persisted_rate_limits) if persisted_rate_limits.is_a?(Hash)
+
+        # Clean up expired rate limits
+        cleanup_expired_rate_limits
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "load_persisted_metrics", fallback: nil)
+      end
+
+      # Save persisted metrics to disk
+      def save_persisted_metrics
+        return unless @metrics_persistence
+        @metrics_persistence.save_metrics(@provider_metrics)
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "save_persisted_metrics", fallback: nil)
+      end
+
+      # Save persisted rate limits to disk
+      def save_persisted_rate_limits
+        return unless @metrics_persistence
+        @metrics_persistence.save_rate_limits(@rate_limit_info)
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "save_persisted_rate_limits", fallback: nil)
+      end
+
+      # Clean up expired rate limits from memory
+      def cleanup_expired_rate_limits
+        now = Time.now
+        @rate_limit_info.delete_if do |_provider, info|
+          reset_time = info[:reset_time]
+          reset_time && now >= reset_time
+        end
+      end
     end
   end
 end

data/lib/aidp/harness/provider_metrics.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "../rescue_logging"
+
+module Aidp
+  module Harness
+    # Persists provider metrics and rate limit information to disk
+    # Enables the provider dashboard to display real-time state
+    class ProviderMetrics
+      include Aidp::RescueLogging
+
+      attr_reader :project_dir, :metrics_file, :rate_limit_file
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @metrics_file = File.join(project_dir, ".aidp", "provider_metrics.yml")
+        @rate_limit_file = File.join(project_dir, ".aidp", "provider_rate_limits.yml")
+        ensure_directory
+      end
+
+      # Save provider metrics to disk
+      def save_metrics(metrics_hash)
+        return if metrics_hash.nil? || metrics_hash.empty?
+
+        # Convert Time objects to ISO8601 strings for YAML serialization
+        serializable_metrics = serialize_metrics(metrics_hash)
+
+        File.write(@metrics_file, YAML.dump(serializable_metrics))
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "save_metrics", fallback: nil)
+      end
+
+      # Load provider metrics from disk
+      def load_metrics
+        return {} unless File.exist?(@metrics_file)
+
+        data = YAML.safe_load_file(@metrics_file, permitted_classes: [Time, Date, Symbol], aliases: true)
+        return {} unless data.is_a?(Hash)
+
+        # Convert ISO8601 strings back to Time objects
+        deserialize_metrics(data)
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "load_metrics", fallback: {})
+        {}
+      end
+
+      # Save rate limit information to disk
+      def save_rate_limits(rate_limit_hash)
+        return if rate_limit_hash.nil? || rate_limit_hash.empty?
+
+        # Convert Time objects to ISO8601 strings for YAML serialization
+        serializable_rate_limits = serialize_rate_limits(rate_limit_hash)
+
+        File.write(@rate_limit_file, YAML.dump(serializable_rate_limits))
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "save_rate_limits", fallback: nil)
+      end
+
+      # Load rate limit information from disk
+      def load_rate_limits
+        return {} unless File.exist?(@rate_limit_file)
+
+        data = YAML.safe_load_file(@rate_limit_file, permitted_classes: [Time, Date, Symbol], aliases: true)
+        return {} unless data.is_a?(Hash)
+
+        # Convert ISO8601 strings back to Time objects
+        deserialize_rate_limits(data)
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "load_rate_limits", fallback: {})
+        {}
+      end
+
+      # Clear all persisted metrics
+      def clear
+        File.delete(@metrics_file) if File.exist?(@metrics_file)
+        File.delete(@rate_limit_file) if File.exist?(@rate_limit_file)
+      end
+
+      private
+
+      def ensure_directory
+        aidp_dir = File.join(@project_dir, ".aidp")
+        FileUtils.mkdir_p(aidp_dir) unless File.directory?(aidp_dir)
+      end
+
+      def serialize_metrics(metrics_hash)
+        metrics_hash.transform_values do |provider_metrics|
+          next provider_metrics unless provider_metrics.is_a?(Hash)
+
+          provider_metrics.transform_values do |value|
+            value.is_a?(Time) ? value.iso8601 : value
+          end
+        end
+      end
+
+      def deserialize_metrics(metrics_hash)
+        metrics_hash.transform_values do |provider_metrics|
+          next provider_metrics unless provider_metrics.is_a?(Hash)
+
+          provider_metrics.transform_keys(&:to_sym).transform_values do |value|
+            parse_time_if_string(value)
+          end
+        end
+      end
+
+      def serialize_rate_limits(rate_limit_hash)
+        rate_limit_hash.transform_values do |limit_info|
+          next limit_info unless limit_info.is_a?(Hash)
+
+          limit_info.transform_values do |value|
+            value.is_a?(Time) ? value.iso8601 : value
+          end
+        end
+      end
+
+      def deserialize_rate_limits(rate_limit_hash)
+        rate_limit_hash.transform_values do |limit_info|
+          next limit_info unless limit_info.is_a?(Hash)
+
+          limit_info.transform_keys(&:to_sym).transform_values do |value|
+            parse_time_if_string(value)
+          end
+        end
+      end
+
+      def parse_time_if_string(value)
+        return value unless value.is_a?(String)
+
+        # Try to parse ISO8601 timestamp
+        Time.parse(value)
+      rescue ArgumentError
+        value
+      end
+    end
+  end
+end

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"
@@ -27,11 +27,12 @@ module Aidp
         waiting_for_rate_limit: "waiting_for_rate_limit",
         stopped: "stopped",
         completed: "completed",
-        error: "error"
+        error: "error",
+        needs_clarification: "needs_clarification"
       }.freeze
 
       # Public accessors for testing and integration
-      attr_reader :current_provider, :current_step, :user_input, :execution_log, :provider_manager
+      attr_reader :current_provider, :current_step, :user_input, :execution_log, :provider_manager, :clarification_questions
 
       def initialize(project_dir, mode = :analyze, options = {})
         @project_dir = project_dir
@@ -43,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
@@ -113,26 +118,56 @@ 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
 
-        {status: @state, message: get_completion_message}
+        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
 
       # Pause the harness execution
@@ -180,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
@@ -248,12 +283,23 @@ module Aidp
       end
 
       def handle_user_feedback_request(result)
-        @state = STATES[:waiting_for_user]
-        log_execution("Waiting for user feedback")
-
         # Extract questions from result
         questions = @condition_detector.extract_questions(result)
 
+        # Check if we're in watch mode (non-interactive)
+        if @options[:workflow_type] == :watch_mode
+          # Store questions for later retrieval and set state to needs_clarification
+          @clarification_questions = questions
+          @state = STATES[:needs_clarification]
+          log_execution("Clarification needed in watch mode", {question_count: questions.size})
+          # Don't continue - exit the loop so we can return this status
+          return
+        end
+
+        # Interactive mode: collect feedback from user
+        @state = STATES[:waiting_for_user]
+        log_execution("Waiting for user feedback")
+
         # Collect user input
         user_responses = @user_interface.collect_feedback(questions)
 
@@ -267,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
@@ -299,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
@@ -360,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)
@@ -386,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,
@@ -394,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
 
@@ -405,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