aidp 0.28.0 → 0.30.0

data/lib/aidp/metadata/validator.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Aidp
+  module Metadata
+    # Validates tool metadata and detects issues
+    #
+    # Performs validation checks on tool metadata including:
+    # - Required field presence
+    # - Field type validation
+    # - Duplicate ID detection
+    # - Dependency resolution
+    # - Version format validation
+    #
+    # @example Validating a collection of tools
+    #   validator = Validator.new(tools)
+    #   results = validator.validate_all
+    #   results.each { |r| puts "#{r[:file]}: #{r[:errors].join(", ")}" }
+    class Validator
+      # Validation result structure
+      ValidationResult = Struct.new(:tool_id, :file_path, :valid, :errors, :warnings, keyword_init: true)
+
+      # Initialize validator with tool metadata collection
+      #
+      # @param tools [Array<ToolMetadata>] Tools to validate
+      def initialize(tools = [])
+        @tools = tools
+        @errors_by_id = {}
+        @warnings_by_id = {}
+      end
+
+      # Validate all tools
+      #
+      # @return [Array<ValidationResult>] Validation results for each tool
+      def validate_all
+        Aidp.log_debug("metadata", "Validating all tools", count: @tools.size)
+
+        results = @tools.map do |tool|
+          validate_tool(tool)
+        end
+
+        # Cross-tool validations
+        validate_duplicate_ids(results)
+        validate_dependencies(results)
+
+        Aidp.log_info(
+          "metadata",
+          "Validation complete",
+          total: results.size,
+          valid: results.count(&:valid),
+          invalid: results.count { |r| !r.valid }
+        )
+
+        results
+      end
+
+      # Validate a single tool
+      #
+      # @param tool [ToolMetadata] Tool to validate
+      # @return [ValidationResult] Validation result
+      def validate_tool(tool)
+        errors = []
+        warnings = []
+
+        # Tool metadata validates itself on initialization
+        # Here we add additional cross-cutting validations
+
+        # Check for empty arrays in key fields
+        if tool.applies_to.empty? && tool.work_unit_types.empty?
+          warnings << "No applies_to tags or work_unit_types specified (tool may not be discoverable)"
+        end
+
+        # Check for deprecated fields or patterns
+        validate_deprecated_patterns(tool, warnings)
+
+        # Check for experimental tools
+        if tool.experimental
+          warnings << "Tool is marked as experimental"
+        end
+
+        # Check content length
+        if tool.content.length < 100
+          warnings << "Tool content is very short (#{tool.content.length} characters)"
+        end
+
+        ValidationResult.new(
+          tool_id: tool.id,
+          file_path: tool.source_path,
+          valid: errors.empty?,
+          errors: errors,
+          warnings: warnings
+        )
+      rescue Aidp::Errors::ValidationError => e
+        # Catch validation errors from tool initialization
+        ValidationResult.new(
+          tool_id: tool&.id || "unknown",
+          file_path: tool&.source_path || "unknown",
+          valid: false,
+          errors: [e.message],
+          warnings: []
+        )
+      end
+
+      # Validate for duplicate IDs across tools
+      #
+      # @param results [Array<ValidationResult>] Validation results
+      def validate_duplicate_ids(results)
+        ids = @tools.map(&:id)
+        duplicates = ids.tally.select { |_, count| count > 1 }.keys
+
+        return if duplicates.empty?
+
+        duplicates.each do |dup_id|
+          matching_tools = @tools.select { |t| t.id == dup_id }
+          matching_tools.each do |tool|
+            result = results.find { |r| r.tool_id == tool.id && r.file_path == tool.source_path }
+            next unless result
+
+            paths = matching_tools.map(&:source_path).join(", ")
+            result.errors << "Duplicate ID '#{dup_id}' found in: #{paths}"
+            result.valid = false
+          end
+        end
+
+        Aidp.log_warn("metadata", "Duplicate IDs detected", duplicates: duplicates)
+      end
+
+      # Validate tool dependencies are satisfied
+      #
+      # @param results [Array<ValidationResult>] Validation results
+      def validate_dependencies(results)
+        available_ids = @tools.map(&:id).to_set
+
+        @tools.each do |tool|
+          next if tool.dependencies.empty?
+
+          tool.dependencies.each do |dep_id|
+            next if available_ids.include?(dep_id)
+
+            result = results.find { |r| r.tool_id == tool.id && r.file_path == tool.source_path }
+            next unless result
+
+            result.errors << "Missing dependency: '#{dep_id}'"
+            result.valid = false
+          end
+        end
+      end
+
+      # Check for deprecated patterns in tool metadata
+      #
+      # @param tool [ToolMetadata] Tool to check
+      # @param warnings [Array<String>] Warnings array to append to
+      def validate_deprecated_patterns(tool, warnings)
+        # Check for legacy field usage (this would be expanded based on actual deprecations)
+        # For now, this is a placeholder for future deprecation warnings
+      end
+
+      # Write validation errors to log file
+      #
+      # @param results [Array<ValidationResult>] Validation results
+      # @param log_path [String] Path to error log file
+      def write_error_log(results, log_path)
+        Aidp.log_debug("metadata", "Writing error log", path: log_path)
+
+        errors = results.reject(&:valid)
+        return if errors.empty?
+
+        File.open(log_path, "w") do |f|
+          f.puts "# Metadata Validation Errors"
+          f.puts "# Generated: #{Time.now.iso8601}"
+          f.puts
+
+          errors.each do |result|
+            f.puts "## #{result.tool_id} (#{result.file_path})"
+            f.puts
+            result.errors.each { |err| f.puts "- ERROR: #{err}" }
+            result.warnings.each { |warn| f.puts "- WARNING: #{warn}" }
+            f.puts
+          end
+        end
+
+        Aidp.log_info("metadata", "Wrote error log", path: log_path, error_count: errors.size)
+      end
+    end
+  end
+end

data/lib/aidp/providers/aider.rb

@@ -75,7 +75,7 @@ module Aidp
         end
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "aider CLI not available" unless self.class.available?
 
         # Smart timeout calculation (store prompt length for adaptive logic)

data/lib/aidp/providers/anthropic.rb

@@ -3,15 +3,23 @@
 require "json"
 require_relative "base"
 require_relative "../debug_mixin"
+require_relative "../harness/deprecation_cache"
 
 module Aidp
   module Providers
     class Anthropic < Base
       include Aidp::DebugMixin
 
+      attr_reader :model
+
       # Model name pattern for Anthropic Claude models
       MODEL_PATTERN = /^claude-[\d.-]+-(?:opus|sonnet|haiku)(?:-\d{8})?$/i
 
+      # Get deprecation cache instance (lazy loaded)
+      def self.deprecation_cache
+        @deprecation_cache ||= Aidp::Harness::DeprecationCache.new
+      end
+
       def self.available?
         !!Aidp::Util.which("claude")
       end
@@ -210,6 +218,56 @@ module Aidp
         ["--dangerously-skip-permissions"]
       end
 
+      # Classify provider error using string matching
+      #
+      # ZFC EXCEPTION: Cannot use AI to classify provider errors because:
+      # 1. The failing provider IS the AI we'd use for classification (circular dependency)
+      # 2. Provider may be rate-limited, down, or misconfigured
+      # 3. Error classification must work even when AI unavailable
+      #
+      # This is a legitimate exception to ZFC principles per LLM_STYLE_GUIDE:
+      # "Structural safety checks" are allowed in code when AI cannot be used.
+      #
+      # @param error_message [String] The error message to classify
+      # @return [Hash] Classification result with :type, :is_deprecation, :is_rate_limit, :confidence
+      def self.classify_provider_error(error_message)
+        msg_lower = error_message.downcase
+
+        # Use simple string.include? checks (not regex) to avoid ReDoS vulnerabilities
+        is_rate_limit = msg_lower.include?("rate limit") || msg_lower.include?("session limit")
+        is_deprecation = msg_lower.include?("deprecat") || msg_lower.include?("end-of-life")
+        is_auth_error = msg_lower.include?("auth") && (msg_lower.include?("expired") || msg_lower.include?("invalid"))
+
+        # Determine primary type
+        type = if is_rate_limit
+          "rate_limit"
+        elsif is_deprecation
+          "deprecation"
+        elsif is_auth_error
+          "auth_error"
+        else
+          "other"
+        end
+
+        Aidp.log_debug("anthropic", "Provider error classification",
+          type: type,
+          is_rate_limit: is_rate_limit,
+          is_deprecation: is_deprecation,
+          is_auth_error: is_auth_error)
+
+        {
+          type: type,
+          is_rate_limit: is_rate_limit,
+          is_deprecation: is_deprecation,
+          is_auth_error: is_auth_error,
+          confidence: 0.85, # Good confidence for clear error messages
+          reasoning: "Pattern-based classification (ZFC exception: circular dependency)"
+        }
+      end
+
+      # Error patterns for classify_error method (legacy support)
+      # NOTE: ZFC-based classification preferred - see classify_error_with_zfc
+      # These patterns serve as fallback when ZFC is unavailable
       def error_patterns
         {
           rate_limited: [
@@ -245,18 +303,76 @@ module Aidp
             /not.*found/i,
             /404/,
             /bad.*request/i,
-            /400/
+            /400/,
+            /model.*deprecated/i,
+            /end-of-life/i
           ]
         }
       end
 
-      def send_message(prompt:, session: nil)
+      # Check if a model is deprecated and return replacement
+      # @param model_name [String] The model name to check
+      # @return [String, nil] Replacement model name if deprecated, nil otherwise
+      def self.check_model_deprecation(model_name)
+        deprecation_cache.replacement_for(provider: "anthropic", model_id: model_name)
+      end
+
+      # Find replacement model for deprecated one using RubyLLM registry
+      # @param deprecated_model [String] The deprecated model name
+      # @param provider_name [String] Provider name for registry lookup
+      # @return [String, nil] Latest model in the same family, or configured replacement
+      def self.find_replacement_model(deprecated_model, provider_name: "anthropic")
+        # First check the deprecation cache for explicit replacement
+        replacement = deprecation_cache.replacement_for(provider: provider_name, model_id: deprecated_model)
+        return replacement if replacement
+
+        # Try to find latest model in same family using registry
+        require_relative "../harness/ruby_llm_registry" unless defined?(Aidp::Harness::RubyLLMRegistry)
+
+        begin
+          registry = Aidp::Harness::RubyLLMRegistry.new
+
+          # Search for non-deprecated models in the same family
+          # Prefer models without "latest" suffix, sorted by ID (newer dates first)
+          models = registry.models_for_provider(provider_name)
+          candidates = models.select { |m| m.include?("sonnet") && !deprecation_cache.deprecated?(provider: provider_name, model_id: m) }
+
+          # Prioritize: versioned models over -latest, newer versions first
+          versioned = candidates.reject { |m| m.end_with?("-latest") }.sort.reverse
+          latest_models = candidates.select { |m| m.end_with?("-latest") }
+
+          replacement = versioned.first || latest_models.first
+
+          if replacement
+            Aidp.log_info("anthropic", "Found replacement model",
+              deprecated: deprecated_model,
+              replacement: replacement)
+          end
+
+          replacement
+        rescue => e
+          Aidp.log_error("anthropic", "Failed to find replacement model",
+            deprecated: deprecated_model,
+            error: e.message)
+          nil
+        end
+      end
+
+      def send_message(prompt:, session: nil, options: {})
         raise "claude CLI not available" unless self.class.available?
 
-        # Smart timeout calculation
-        timeout_seconds = calculate_timeout
+        # Check if current model is deprecated and warn
+        if @model && (replacement = self.class.check_model_deprecation(@model))
+          Aidp.log_warn("anthropic", "Using deprecated model",
+            current: @model,
+            replacement: replacement)
+          debug_log("⚠️  Model #{@model} is deprecated. Consider upgrading to #{replacement}", level: :warn)
+        end
 
-        debug_provider("claude", "Starting execution", {timeout: timeout_seconds})
+        # Smart timeout calculation with tier awareness
+        timeout_seconds = calculate_timeout(options)
+
+        debug_provider("claude", "Starting execution", {timeout: timeout_seconds, tier: options[:tier]})
         debug_log("📝 Sending prompt to claude...", level: :info)
 
         # Build command arguments
@@ -285,15 +401,72 @@ module Aidp
             # Detect issues in stdout/stderr (Claude sometimes prints to stdout)
             combined = [result.out, result.err].compact.join("\n")
 
-            # Check for rate limit (Session limit reached)
-            if combined.match?(/session limit reached/i)
+            # Classify provider error using pattern matching
+            # ZFC EXCEPTION: Cannot use AI to classify provider's own errors (circular dependency)
+            error_classification = self.class.classify_provider_error(combined)
+
+            Aidp.log_debug("anthropic_provider", "error_classified",
+              exit_code: result.exit_status,
+              type: error_classification[:type],
+              confidence: error_classification[:confidence])            # Check for rate limit
+            if error_classification[:is_rate_limit]
               Aidp.log_debug("anthropic_provider", "rate_limit_detected",
                 exit_code: result.exit_status,
+                confidence: error_classification[:confidence],
                 message: combined)
               notify_rate_limit(combined)
               error_message = "Rate limit reached for Claude CLI.\n#{combined}"
-              debug_error(StandardError.new(error_message), {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
-              raise error_message
+              error = RuntimeError.new(error_message)
+              debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+              raise error
+            end
+
+            # Check for model deprecation
+            if error_classification[:is_deprecation]
+              deprecated_model = @model
+              Aidp.log_error("anthropic", "Model deprecation detected",
+                model: deprecated_model,
+                message: combined)
+
+              # Try to find replacement
+              replacement = deprecated_model ? self.class.find_replacement_model(deprecated_model) : nil
+
+              # Record deprecation in cache for future runs
+              if replacement
+                self.class.deprecation_cache.add_deprecated_model(
+                  provider: "anthropic",
+                  model_id: deprecated_model,
+                  replacement: replacement,
+                  reason: combined.lines.first&.strip || "Model deprecated"
+                )
+
+                Aidp.log_info("anthropic", "Auto-upgrading to non-deprecated model",
+                  old_model: deprecated_model,
+                  new_model: replacement)
+                debug_log("🔄 Upgrading from deprecated model #{deprecated_model} to #{replacement}", level: :info)
+
+                # Update model and retry
+                @model = replacement
+
+                # Retry with new model
+                debug_log("🔄 Retrying with upgraded model: #{replacement}", level: :info)
+                return send_message(prompt: prompt, session: session, options: options)
+              else
+                # Record deprecation even without replacement
+                if deprecated_model
+                  self.class.deprecation_cache.add_deprecated_model(
+                    provider: "anthropic",
+                    model_id: deprecated_model,
+                    replacement: nil,
+                    reason: combined.lines.first&.strip || "Model deprecated"
+                  )
+                end
+
+                error_message = "Model '#{deprecated_model}' is deprecated and no replacement found.\n#{combined}"
+                error = RuntimeError.new(error_message)
+                debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+                raise error
+              end
             end
 
             # Check for auth issues
@@ -301,12 +474,15 @@ module Aidp
               error_message = "Authentication error from Claude CLI: token expired or invalid.\n" \
                               "Run 'claude /login' or refresh credentials.\n" \
                               "Note: Model discovery requires valid authentication."
-              debug_error(StandardError.new(error_message), {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
-              raise error_message
+              error = RuntimeError.new(error_message)
+              debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+              raise error
             end
 
-            debug_error(StandardError.new("claude failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "claude failed with exit code #{result.exit_status}: #{result.err}"
+            error_message = "claude failed with exit code #{result.exit_status}: #{result.err}"
+            error = RuntimeError.new(error_message)
+            debug_error(error, {exit_code: result.exit_status, stderr: result.err})
+            raise error
           end
         rescue => e
           debug_error(e, {provider: "claude", prompt_length: prompt.length})

data/lib/aidp/providers/base.rb

@@ -37,6 +37,16 @@ module Aidp
       TIMEOUT_REFACTORING_RECOMMENDATIONS = 600 # 10 minutes - refactoring
       TIMEOUT_IMPLEMENTATION = 900 # 15 minutes - implementation (write files, run tests, fix issues)
 
+      # Tier-based timeout multipliers (applied on top of base timeouts)
+      # Higher tiers need more time for deeper reasoning
+      TIER_TIMEOUT_MULTIPLIERS = {
+        "mini" => 1.0,      # 5 minutes default (300s base)
+        "standard" => 2.0,  # 10 minutes default (600s base)
+        "thinking" => 6.0,  # 30 minutes default (1800s base)
+        "pro" => 6.0,       # 30 minutes default (1800s base)
+        "max" => 12.0       # 60 minutes default (3600s base)
+      }.freeze
+
       attr_reader :activity_state, :last_activity_time, :start_time, :step_name, :model
 
       def initialize(output: nil, prompt: TTY::Prompt.new)
@@ -78,10 +88,12 @@ module Aidp
       # Configure the provider with options
       # @param config [Hash] Configuration options, may include :model
       def configure(config)
-        @model = config[:model] if config[:model]
+        if config[:model]
+          @model = resolve_model_name(config[:model].to_s)
+        end
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise NotImplementedError, "#{self.class} must implement #send_message"
       end
 
@@ -482,11 +494,12 @@ module Aidp
       # Priority order:
       # 1. Quick mode (for testing)
       # 2. Provider-specific environment variable override
-      # 3. Adaptive timeout based on step type
-      # 4. Default timeout
+      # 3. Adaptive timeout based on step type and thinking tier
+      # 4. Default timeout (with tier multiplier)
       #
       # Override provider_env_var to customize the environment variable name
-      def calculate_timeout
+      # @param options [Hash] Options hash that may include :tier
+      def calculate_timeout(options = {})
         if ENV["AIDP_QUICK_MODE"]
           display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
           return TIMEOUT_QUICK_MODE
@@ -495,47 +508,104 @@ module Aidp
         provider_env_var = "AIDP_#{name.upcase}_TIMEOUT"
         return ENV[provider_env_var].to_i if ENV[provider_env_var]
 
-        step_timeout = adaptive_timeout
+        tier = options[:tier]&.to_s
+        step_timeout = adaptive_timeout(tier)
         if step_timeout
-          display_message("🧠 Using adaptive timeout: #{step_timeout} seconds", type: :info)
+          tier_label = tier ? " (tier: #{tier})" : ""
+          display_message("🧠 Using adaptive timeout: #{step_timeout} seconds#{tier_label}", type: :info)
           return step_timeout
         end
 
-        # Default timeout
-        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
-        TIMEOUT_DEFAULT
+        # Default timeout with tier multiplier
+        base_timeout = TIMEOUT_DEFAULT
+        final_timeout = apply_tier_multiplier(base_timeout, tier)
+        tier_label = tier ? " (tier: #{tier})" : ""
+        display_message("📋 Using default timeout: #{final_timeout / 60} minutes#{tier_label}", type: :info)
+        final_timeout
       end
 
-      # Get adaptive timeout based on step type
+      # Get adaptive timeout based on step type and thinking tier
       #
       # This method returns different timeout values based on the type of operation
-      # being performed, as indicated by the AIDP_CURRENT_STEP environment variable.
+      # being performed, as indicated by the AIDP_CURRENT_STEP environment variable,
+      # and applies a multiplier based on the thinking tier (mini/standard/thinking/pro/max).
       # Returns nil for unknown steps to allow calculate_timeout to use the default.
-      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
-          when /IMPLEMENTATION/
-            TIMEOUT_IMPLEMENTATION
+      #
+      # @param tier [String, nil] The thinking tier (mini, standard, thinking, pro, max)
+      def adaptive_timeout(tier = nil)
+        # Don't cache - tier may change between calls
+        step_name = ENV["AIDP_CURRENT_STEP"] || ""
+
+        base_timeout = 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
+        when /IMPLEMENTATION/
+          TIMEOUT_IMPLEMENTATION
+        else
+          nil # Return nil for unknown steps
+        end
+
+        return nil unless base_timeout
+
+        apply_tier_multiplier(base_timeout, tier)
+      end
+
+      # Apply tier-based multiplier to a base timeout
+      #
+      # @param base_timeout [Integer] The base timeout in seconds
+      # @param tier [String, nil] The thinking tier (mini, standard, thinking, pro, max)
+      # @return [Integer] The adjusted timeout with tier multiplier applied
+      def apply_tier_multiplier(base_timeout, tier)
+        return base_timeout unless tier
+
+        multiplier = TIER_TIMEOUT_MULTIPLIERS[tier.to_s] || 1.0
+        (base_timeout * multiplier).to_i
+      end
+
+      # Resolve a model name using the RubyLLM registry
+      #
+      # Attempts to resolve a model family name (e.g., "claude-3-5-haiku") to a
+      # versioned model name (e.g., "claude-3-5-haiku-20241022") using the RubyLLM
+      # registry. Falls back to using the name as-is if resolution fails.
+      #
+      # @param model_name [String] The model family name or versioned name
+      # @return [String] The resolved model name (versioned if found, original if not)
+      def resolve_model_name(model_name)
+        require_relative "../harness/ruby_llm_registry" unless defined?(Aidp::Harness::RubyLLMRegistry)
+
+        begin
+          registry = Aidp::Harness::RubyLLMRegistry.new
+          resolved = registry.resolve_model(model_name, provider: name)
+
+          if resolved
+            Aidp.log_debug(name, "Resolved model using registry",
+              requested: model_name,
+              resolved: resolved)
+            resolved
           else
-            nil # Return nil for unknown steps
+            # Fall back to using the name as-is
+            Aidp.log_warn(name, "Model not found in registry, using as-is",
+              model: model_name)
+            model_name
           end
+        rescue => e
+          # If registry fails, fall back to using the name as-is
+          Aidp.log_error(name, "Registry lookup failed, using model name as-is",
+            model: model_name,
+            error: e.message)
+          model_name
         end
       end
 

data/lib/aidp/providers/codex.rb

@@ -76,7 +76,7 @@ module Aidp
         end
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "codex CLI not available" unless self.class.available?
 
         # Smart timeout calculation (store prompt length for adaptive logic)

data/lib/aidp/providers/cursor.rb

@@ -117,7 +117,7 @@ module Aidp
         fetch_mcp_servers_cli || fetch_mcp_servers_config
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "cursor-agent not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/gemini.rb

@@ -76,7 +76,7 @@ module Aidp
         "Google Gemini"
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "gemini CLI not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/github_copilot.rb

@@ -51,7 +51,7 @@ module Aidp
         end
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "copilot CLI not available" unless self.class.available?
 
         # Smart timeout calculation