aidp 0.23.0 → 0.24.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/providers/adapter.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Providers
+    # ProviderAdapter defines the standardized interface that all provider implementations
+    # must conform to. This ensures consistent behavior across different AI model providers
+    # while allowing for provider-specific implementations.
+    #
+    # Design Philosophy:
+    # - Adapters are stateless; delegate throttling, retries, and escalation to coordinator
+    # - Store provider-specific regex matchers adjacent to adapters for maintainability
+    # - Single semantic flags map to provider-specific equivalents
+    #
+    # @see https://github.com/viamin/aidp/issues/243
+    module Adapter
+      # Core interface methods that all providers must implement
+
+      # Provider identifier (e.g., "anthropic", "cursor", "gemini")
+      # @return [String] unique lowercase identifier for this provider
+      def name
+        raise NotImplementedError, "#{self.class} must implement #name"
+      end
+
+      # Human-friendly display name for UI
+      # @return [String] display name (e.g., "Anthropic Claude", "Cursor AI")
+      def display_name
+        name
+      end
+
+      # Send a message to the provider and get a response
+      # @param prompt [String] the prompt to send
+      # @param session [String, nil] optional session identifier for context
+      # @param options [Hash] additional options for the request
+      # @return [Hash, String] provider response
+      def send_message(prompt:, session: nil, **options)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # Capability declaration methods
+
+      # Check if the provider supports Model Context Protocol
+      # @return [Boolean] true if MCP is supported
+      def supports_mcp?
+        false
+      end
+
+      # Fetch MCP servers configured for this provider
+      # @return [Array<Hash>] array of MCP server configurations
+      def fetch_mcp_servers
+        []
+      end
+
+      # Check if the provider is available on this system
+      # @return [Boolean] true if provider CLI or API is accessible
+      def available?
+        true
+      end
+
+      # Declare provider capabilities
+      # @return [Hash] capabilities hash with feature flags
+      # @example
+      #   {
+      #     reasoning_tiers: ["mini", "standard", "thinking"],
+      #     context_window: 200_000,
+      #     supports_json_mode: true,
+      #     supports_tool_use: true,
+      #     supports_vision: false,
+      #     supports_file_upload: true,
+      #     streaming: true
+      #   }
+      def capabilities
+        {
+          reasoning_tiers: [],
+          context_window: 100_000,
+          supports_json_mode: false,
+          supports_tool_use: false,
+          supports_vision: false,
+          supports_file_upload: false,
+          streaming: false
+        }
+      end
+
+      # Dangerous permissions abstraction
+
+      # Check if the provider supports dangerous/elevated permissions mode
+      # @return [Boolean] true if dangerous mode is supported
+      def supports_dangerous_mode?
+        false
+      end
+
+      # Get the provider-specific flag(s) for enabling dangerous mode
+      # Maps the semantic `dangerous: true` flag to provider-specific equivalents
+      # @return [Array<String>] provider-specific CLI flags
+      # @example Anthropic
+      #   ["--dangerously-skip-permissions"]
+      # @example Gemini (hypothetical)
+      #   ["--yolo"]
+      def dangerous_mode_flags
+        []
+      end
+
+      # Check if dangerous mode is currently enabled
+      # @return [Boolean] true if dangerous mode is active
+      def dangerous_mode_enabled?
+        @dangerous_mode_enabled ||= false
+      end
+
+      # Enable or disable dangerous mode
+      # @param enabled [Boolean] whether to enable dangerous mode
+      # @return [void]
+      def dangerous_mode=(enabled)
+        @dangerous_mode_enabled = enabled
+      end
+
+      # Error classification and handling
+
+      # Get error classification regex patterns for this provider
+      # @return [Hash<Symbol, Array<Regexp>>] mapping of error categories to regex patterns
+      # @example
+      #   {
+      #     rate_limited: [/rate.?limit/i, /quota.*exceeded/i],
+      #     auth_expired: [/authentication.*failed/i, /invalid.*api.*key/i],
+      #     quota_exceeded: [/quota.*exceeded/i, /usage.*limit/i],
+      #     transient: [/timeout/i, /connection.*reset/i, /temporary.*error/i],
+      #     permanent: [/invalid.*model/i, /unsupported.*operation/i]
+      #   }
+      def error_patterns
+        {}
+      end
+
+      # Classify an error into the standardized error taxonomy
+      # @param error [StandardError] the error to classify
+      # @return [Symbol] error category (:rate_limited, :auth_expired, :quota_exceeded, :transient, :permanent)
+      def classify_error(error)
+        message = error.message.to_s
+
+        # First check provider-specific patterns
+        error_patterns.each do |category, patterns|
+          patterns.each do |pattern|
+            return category if message.match?(pattern)
+          end
+        end
+
+        # Fall back to ErrorTaxonomy for classification
+        require_relative "error_taxonomy"
+        Aidp::Providers::ErrorTaxonomy.classify_message(message)
+      end
+
+      # Get normalized error metadata
+      # @param error [StandardError] the error to process
+      # @return [Hash] normalized error information
+      def error_metadata(error)
+        {
+          provider: name,
+          error_category: classify_error(error),
+          error_class: error.class.name,
+          message: redact_secrets(error.message),
+          timestamp: Time.now.iso8601,
+          retryable: retryable_error?(error)
+        }
+      end
+
+      # Check if an error is retryable
+      # @param error [StandardError] the error to check
+      # @return [Boolean] true if the error should be retried
+      def retryable_error?(error)
+        category = classify_error(error)
+        [:transient].include?(category)
+      end
+
+      # Logging and metrics
+
+      # Get logging metadata for this provider
+      # @return [Hash] metadata for structured logging
+      def logging_metadata
+        {
+          provider: name,
+          display_name: display_name,
+          supports_mcp: supports_mcp?,
+          available: available?,
+          dangerous_mode: dangerous_mode_enabled?
+        }
+      end
+
+      # Redact secrets from log messages
+      # @param message [String] message potentially containing secrets
+      # @return [String] message with secrets redacted
+      def redact_secrets(message)
+        # Redact common secret patterns
+        message = message.gsub(/api[_-]?key[:\s=]+[^\s&]+/i, "api_key=[REDACTED]")
+        message = message.gsub(/token[:\s=]+[^\s&]+/i, "token=[REDACTED]")
+        message = message.gsub(/password[:\s=]+[^\s&]+/i, "password=[REDACTED]")
+        message = message.gsub(/bearer\s+[^\s&]+/i, "bearer [REDACTED]")
+        message.gsub(/sk-[a-zA-Z0-9_-]{20,}/i, "sk-[REDACTED]")
+      end
+
+      # Configuration validation
+
+      # Validate provider configuration
+      # @param config [Hash] configuration to validate
+      # @return [Hash] validation result with :valid, :errors, :warnings keys
+      def validate_config(config)
+        errors = []
+        warnings = []
+
+        # Validate required fields
+        unless config[:type]
+          errors << "Provider type is required"
+        end
+
+        unless ["usage_based", "subscription", "passthrough"].include?(config[:type])
+          errors << "Provider type must be one of: usage_based, subscription, passthrough"
+        end
+
+        # Validate models if present
+        if config[:models] && !config[:models].is_a?(Array)
+          errors << "Models must be an array"
+        end
+
+        {
+          valid: errors.empty?,
+          errors: errors,
+          warnings: warnings
+        }
+      end
+
+      # Provider health and status
+
+      # Check provider health
+      # @return [Hash] health status information
+      def health_status
+        {
+          provider: name,
+          available: available?,
+          healthy: available?,
+          timestamp: Time.now.iso8601
+        }
+      end
+    end
+  end
+end