aidp 0.26.0 → 0.28.0

data/lib/aidp/providers/base.rb

@@ -37,7 +37,7 @@ module Aidp
       TIMEOUT_REFACTORING_RECOMMENDATIONS = 600 # 10 minutes - refactoring
       TIMEOUT_IMPLEMENTATION = 900 # 15 minutes - implementation (write files, run tests, fix issues)
 
-      attr_reader :activity_state, :last_activity_time, :start_time, :step_name
+      attr_reader :activity_state, :last_activity_time, :start_time, :step_name, :model
 
       def initialize(output: nil, prompt: TTY::Prompt.new)
         @activity_state = :idle
@@ -52,6 +52,7 @@ module Aidp
         @harness_context = nil
         @output = output
         @prompt = prompt
+        @model = nil
         @harness_metrics = {
           total_requests: 0,
           successful_requests: 0,
@@ -74,6 +75,12 @@ module Aidp
         name
       end
 
+      # Configure the provider with options
+      # @param config [Hash] Configuration options, may include :model
+      def configure(config)
+        @model = config[:model] if config[:model]
+      end
+
       def send_message(prompt:, session: nil)
         raise NotImplementedError, "#{self.class} must implement #send_message"
       end
@@ -324,6 +331,59 @@ module Aidp
         end
       end
 
+      # Helper method for registry-based model discovery
+      #
+      # Providers that use the model registry can call this method to discover models
+      # based on a model family pattern.
+      #
+      # @param model_pattern [Regexp] Pattern to match model families
+      # @param provider_name [String] Name of the provider
+      # @return [Array<Hash>] Array of discovered models
+      def self.discover_models_from_registry(model_pattern, provider_name)
+        require_relative "../harness/model_registry"
+        registry = Aidp::Harness::ModelRegistry.new
+
+        # Get all models from registry that match the pattern
+        models = registry.all_families.filter_map do |family|
+          next unless model_pattern.match?(family)
+
+          info = registry.get_model_info(family)
+          next unless info
+
+          {
+            name: family,
+            family: family,
+            tier: info["tier"],
+            capabilities: info["capabilities"] || [],
+            context_window: info["context_window"],
+            provider: provider_name
+          }
+        end
+
+        Aidp.log_info("#{provider_name}_provider", "using registry models", count: models.size)
+        models
+      rescue => e
+        Aidp.log_debug("#{provider_name}_provider", "discovery failed", error: e.message)
+        []
+      end
+
+      # Get firewall requirements for this provider
+      #
+      # Returns domains and IP ranges that need to be accessible for this provider
+      # to function properly. Used by devcontainer firewall configuration.
+      #
+      # @return [Hash] Firewall requirements with :domains and :ip_ranges keys
+      #   - domains: Array of domain strings
+      #   - ip_ranges: Array of CIDR strings
+      #
+      # Override in subclasses to provide provider-specific requirements
+      def self.firewall_requirements
+        {
+          domains: [],
+          ip_ranges: []
+        }
+      end
+
       protected
 
       # Log message to job if in background mode
@@ -371,8 +431,6 @@ module Aidp
         (success_rate * 50) + ((1 - rate_limit_ratio) * 30) + (response_time_score * 0.2)
       end
 
-      protected
-
       # Update spinner status with elapsed time
       # This is a shared method used by all providers to display progress
       def update_spinner_status(spinner, elapsed, provider_name)
@@ -419,6 +477,68 @@ module Aidp
         false # Base implementation returns false, subclasses should override
       end
 
+      # Calculate timeout for provider operations
+      #
+      # Priority order:
+      # 1. Quick mode (for testing)
+      # 2. Provider-specific environment variable override
+      # 3. Adaptive timeout based on step type
+      # 4. Default timeout
+      #
+      # Override provider_env_var to customize the environment variable name
+      def calculate_timeout
+        if ENV["AIDP_QUICK_MODE"]
+          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
+          return TIMEOUT_QUICK_MODE
+        end
+
+        provider_env_var = "AIDP_#{name.upcase}_TIMEOUT"
+        return ENV[provider_env_var].to_i if ENV[provider_env_var]
+
+        step_timeout = adaptive_timeout
+        if step_timeout
+          display_message("🧠 Using adaptive timeout: #{step_timeout} seconds", type: :info)
+          return step_timeout
+        end
+
+        # Default timeout
+        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
+        TIMEOUT_DEFAULT
+      end
+
+      # Get adaptive timeout based on step type
+      #
+      # This method returns different timeout values based on the type of operation
+      # being performed, as indicated by the AIDP_CURRENT_STEP environment variable.
+      # 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
+          else
+            nil # Return nil for unknown steps
+          end
+        end
+      end
+
       private
     end
   end

data/lib/aidp/providers/capability_registry.rb

@@ -16,7 +16,6 @@ module Aidp
         :supports_tool_use,    # Boolean: supports tool/function calling
         :supports_vision,      # Boolean: supports image/vision inputs
         :supports_file_upload, # Boolean: supports file uploads
-        :streaming,            # Boolean: supports streaming responses
         :supports_mcp,         # Boolean: supports Model Context Protocol
         :max_tokens,           # Maximum tokens per response
         :supports_dangerous_mode # Boolean: supports elevated permissions mode

data/lib/aidp/providers/codex.rb

@@ -10,10 +10,52 @@ module Aidp
     class Codex < Base
       include Aidp::DebugMixin
 
+      # Model name pattern for OpenAI models (since Codex uses OpenAI)
+      MODEL_PATTERN = /^gpt-[\d.o-]+(?:-turbo)?(?:-mini)?$/i
+      LONG_PROMPT_THRESHOLD = 8000
+      LONG_PROMPT_TIMEOUT = 900 # 15 minutes for large prompts
+
       def self.available?
         !!Aidp::Util.which("codex")
       end
 
+      # Check if this provider supports a given model family
+      #
+      # @param family_name [String] The model family name
+      # @return [Boolean] True if it matches OpenAI model pattern
+      def self.supports_model_family?(family_name)
+        MODEL_PATTERN.match?(family_name)
+      end
+
+      # Discover available models from registry
+      #
+      # Note: Codex CLI doesn't have a standard model listing command
+      # Returns registry-based models that match OpenAI patterns
+      #
+      # @return [Array<Hash>] Array of discovered models
+      def self.discover_models
+        return [] unless available?
+
+        discover_models_from_registry(MODEL_PATTERN, "codex")
+      end
+
+      # Get firewall requirements for Codex provider
+      # Codex uses OpenAI APIs
+      def self.firewall_requirements
+        {
+          domains: [
+            "api.openai.com",
+            "auth.openai.com",
+            "openai.com",
+            "chat.openai.com",
+            "chatgpt.com",
+            "cdn.openai.com",
+            "oaiusercontent.com"
+          ],
+          ip_ranges: []
+        }
+      end
+
       def name
         "codex"
       end
@@ -37,18 +79,13 @@ module Aidp
       def send_message(prompt:, session: nil)
         raise "codex CLI not available" unless self.class.available?
 
-        # Smart timeout calculation
+        # Smart timeout calculation (store prompt length for adaptive logic)
+        @current_codex_prompt_length = prompt.length
         timeout_seconds = calculate_timeout
 
         debug_provider("codex", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to codex (length: #{prompt.length})", level: :info)
 
-        # Check if streaming mode is enabled
-        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
-        if streaming_enabled
-          display_message("📺 Streaming mode enabled - output will appear in real-time", type: :info)
-        end
-
         # Set up activity monitoring
         setup_activity_monitoring("codex", method(:activity_callback))
         record_activity("Starting codex execution")
@@ -74,6 +111,11 @@ module Aidp
           # Use non-interactive mode (exec) for automation
           args = ["exec", prompt]
 
+          # Add model if configured
+          if @model && !@model.empty?
+            args += ["--model", @model]
+          end
+
           # Add session support if provided (codex may support session/thread continuation)
           if session && !session.empty?
             args += ["--session", session]
@@ -94,7 +136,7 @@ module Aidp
           end
 
           # Use debug_execute_command for better debugging
-          result = debug_execute_command("codex", args: args, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("codex", args: args, timeout: timeout_seconds)
 
           # Log the results
           debug_command("codex", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
@@ -116,6 +158,7 @@ module Aidp
           raise
         ensure
           cleanup_activity_display(activity_display_thread, spinner)
+          @current_codex_prompt_length = nil
         end
       end
 
@@ -128,9 +171,10 @@ module Aidp
           args += ["--session", session]
         end
 
-        # Add model selection
-        if model
-          args += ["--model", model]
+        # Add model selection (from parameter or configured model)
+        model_to_use = model || @model
+        if model_to_use
+          args += ["--model", model_to_use]
         end
 
         # Add approval flag - but warn about interactive behavior
@@ -161,22 +205,17 @@ module Aidp
 
       # Internal helper for send_with_options - executes with custom arguments
       def send_with_custom_args(prompt:, args:)
+        @current_codex_prompt_length = prompt.length
         timeout_seconds = calculate_timeout
 
         debug_provider("codex", "Starting execution", {timeout: timeout_seconds, args: args})
         debug_log("📝 Sending prompt to codex with custom args", level: :info)
 
-        # Check if streaming mode is enabled
-        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
-        if streaming_enabled
-          display_message("📺 Display streaming enabled - output buffering reduced (codex CLI does not support true streaming)", type: :info)
-        end
-
         setup_activity_monitoring("codex", method(:activity_callback))
         record_activity("Starting codex execution with custom args")
 
         begin
-          result = debug_execute_command("codex", args: args, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("codex", args: args, timeout: timeout_seconds)
           debug_command("codex", args: args, output: result.out, error: result.err, exit_code: result.exit_status)
 
           if result.exit_status == 0
@@ -191,58 +230,8 @@ module Aidp
           mark_failed("codex execution failed: #{e.message}")
           debug_error(e, {provider: "codex", prompt_length: prompt.length})
           raise
-        end
-      end
-
-      def calculate_timeout
-        # Priority order for timeout calculation:
-        # 1. Quick mode (for testing)
-        # 2. Environment variable override
-        # 3. Adaptive timeout based on step type
-        # 4. Default timeout
-
-        if ENV["AIDP_QUICK_MODE"]
-          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
-          return TIMEOUT_QUICK_MODE
-        end
-
-        if ENV["AIDP_CODEX_TIMEOUT"]
-          return ENV["AIDP_CODEX_TIMEOUT"].to_i
-        end
-
-        if adaptive_timeout
-          display_message("🧠 Using adaptive timeout: #{adaptive_timeout} seconds", type: :info)
-          return adaptive_timeout
-        end
-
-        # Default timeout
-        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
-        TIMEOUT_DEFAULT
-      end
-
-      def adaptive_timeout
-        @adaptive_timeout ||= begin
-          # Timeout recommendations based on step type patterns
-          step_name = ENV["AIDP_CURRENT_STEP"] || ""
-
-          case step_name
-          when /REPOSITORY_ANALYSIS/
-            TIMEOUT_REPOSITORY_ANALYSIS
-          when /ARCHITECTURE_ANALYSIS/
-            TIMEOUT_ARCHITECTURE_ANALYSIS
-          when /TEST_ANALYSIS/
-            TIMEOUT_TEST_ANALYSIS
-          when /FUNCTIONALITY_ANALYSIS/
-            TIMEOUT_FUNCTIONALITY_ANALYSIS
-          when /DOCUMENTATION_ANALYSIS/
-            TIMEOUT_DOCUMENTATION_ANALYSIS
-          when /STATIC_ANALYSIS/
-            TIMEOUT_STATIC_ANALYSIS
-          when /REFACTORING_RECOMMENDATIONS/
-            TIMEOUT_REFACTORING_RECOMMENDATIONS
-          else
-            nil # Use default
-          end
+        ensure
+          @current_codex_prompt_length = nil
         end
       end
 
@@ -257,6 +246,22 @@ module Aidp
           display_message("\n❌ Codex CLI failed: #{message}", type: :error)
         end
       end
+
+      def calculate_timeout
+        env_override = ENV["AIDP_CODEX_TIMEOUT"]
+        return env_override.to_i if env_override&.match?(/^\d+$/)
+
+        base_timeout = super
+
+        prompt_length = @current_codex_prompt_length
+        return base_timeout unless prompt_length && prompt_length >= LONG_PROMPT_THRESHOLD
+
+        extended_timeout = [base_timeout, LONG_PROMPT_TIMEOUT].max
+        if extended_timeout > base_timeout
+          display_message("⏱️  Codex prompt length #{prompt_length} detected - extending timeout to #{extended_timeout} seconds", type: :info)
+        end
+        extended_timeout
+      end
     end
   end
 end

data/lib/aidp/providers/cursor.rb

@@ -14,6 +14,92 @@ module Aidp
         !!Aidp::Util.which("cursor-agent")
       end
 
+      # Normalize Cursor's model name to family name
+      #
+      # Cursor may use different naming conventions (e.g., dots vs hyphens)
+      #
+      # @param provider_model_name [String] Cursor's model name
+      # @return [String] The normalized family name
+      def self.model_family(provider_model_name)
+        # Normalize cursor naming to standard family names
+        # cursor uses dots: "claude-3.5-sonnet" -> "claude-3-5-sonnet"
+        provider_model_name.gsub(/(\d)\.(\d)/, '\1-\2')
+      end
+
+      # Convert family name to Cursor's naming convention
+      #
+      # @param family_name [String] The model family name
+      # @return [String] Cursor's model name
+      def self.provider_model_name(family_name)
+        # Cursor uses dots for version numbers
+        # "claude-3-5-sonnet" -> "claude-3.5-sonnet"
+        family_name.gsub(/(\d)-(\d)/, '\1.\2')
+      end
+
+      # Check if this provider supports a given model family
+      #
+      # Cursor supports Claude, GPT, and Cursor-specific models
+      #
+      # @param family_name [String] The model family name
+      # @return [Boolean] True if likely supported
+      def self.supports_model_family?(family_name)
+        family_name.match?(/^(claude|gpt|cursor)-/)
+      end
+
+      # Get firewall requirements for Cursor provider
+      def self.firewall_requirements
+        {
+          domains: [
+            "cursor.com",
+            "www.cursor.com",
+            "downloads.cursor.com",
+            "api.cursor.sh",
+            "cursor.sh",
+            "app.cursor.sh",
+            "www.cursor.sh"
+          ],
+          ip_ranges: []
+        }
+      end
+
+      # Discover available models from Cursor
+      #
+      # Note: Cursor doesn't have a public model listing API
+      # Returns registry-based models that match Cursor patterns
+      #
+      # @return [Array<Hash>] Array of discovered models
+      def self.discover_models
+        return [] unless available?
+
+        begin
+          require_relative "../harness/model_registry"
+          registry = Aidp::Harness::ModelRegistry.new
+
+          # Get all models from registry that Cursor might support
+          models = registry.all_families.filter_map do |family|
+            next unless supports_model_family?(family)
+
+            info = registry.get_model_info(family)
+            next unless info
+
+            {
+              name: provider_model_name(family),
+              family: family,
+              tier: info["tier"],
+              capabilities: info["capabilities"] || [],
+              context_window: info["context_window"],
+              provider: "cursor"
+            }
+          end
+
+          Aidp.log_info("cursor_provider", "using registry models", count: models.size)
+          models
+        rescue => e
+          Aidp.log_debug("cursor_provider", "discovery failed", error: e.message)
+          []
+        end
+      end
+
       def name
         "cursor"
       end
@@ -40,12 +126,6 @@ module Aidp
         debug_provider("cursor", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to cursor-agent (length: #{prompt.length})", level: :info)
 
-        # Check if streaming mode is enabled
-        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
-        if streaming_enabled
-          display_message("📺 Display streaming enabled - output buffering reduced (cursor-agent does not support true streaming)", type: :info)
-        end
-
         # Set up activity monitoring
         setup_activity_monitoring("cursor-agent", method(:activity_callback))
         record_activity("Starting cursor-agent execution")
@@ -71,7 +151,7 @@ module Aidp
           # Use debug_execute_command for better debugging
           # Use -p mode (designed for non-interactive/script use)
           # No fallback to interactive modes - they would hang AIDP's automation workflow
-          result = debug_execute_command("cursor-agent", args: ["-p"], input: prompt, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("cursor-agent", args: ["-p"], input: prompt, timeout: timeout_seconds)
 
           # Log the results
           debug_command("cursor-agent", args: ["-p"], input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
@@ -98,58 +178,6 @@ module Aidp
 
       private
 
-      def calculate_timeout
-        # Priority order for timeout calculation:
-        # 1. Quick mode (for testing)
-        # 2. Environment variable override
-        # 3. Adaptive timeout based on step type
-        # 4. Default timeout
-
-        if ENV["AIDP_QUICK_MODE"]
-          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
-          return TIMEOUT_QUICK_MODE
-        end
-
-        if ENV["AIDP_CURSOR_TIMEOUT"]
-          return ENV["AIDP_CURSOR_TIMEOUT"].to_i
-        end
-
-        if adaptive_timeout
-          display_message("🧠 Using adaptive timeout: #{adaptive_timeout} seconds", type: :info)
-          return adaptive_timeout
-        end
-
-        # Default timeout
-        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
-        TIMEOUT_DEFAULT
-      end
-
-      def adaptive_timeout
-        @adaptive_timeout ||= begin
-          # Timeout recommendations based on step type patterns
-          step_name = ENV["AIDP_CURRENT_STEP"] || ""
-
-          case step_name
-          when /REPOSITORY_ANALYSIS/
-            TIMEOUT_REPOSITORY_ANALYSIS
-          when /ARCHITECTURE_ANALYSIS/
-            TIMEOUT_ARCHITECTURE_ANALYSIS
-          when /TEST_ANALYSIS/
-            TIMEOUT_TEST_ANALYSIS
-          when /FUNCTIONALITY_ANALYSIS/
-            TIMEOUT_FUNCTIONALITY_ANALYSIS
-          when /DOCUMENTATION_ANALYSIS/
-            TIMEOUT_DOCUMENTATION_ANALYSIS
-          when /STATIC_ANALYSIS/
-            TIMEOUT_STATIC_ANALYSIS
-          when /REFACTORING_RECOMMENDATIONS/
-            TIMEOUT_REFACTORING_RECOMMENDATIONS
-          else
-            nil # Use default
-          end
-        end
-      end
-
       def activity_callback(state, message, provider)
         # This is now handled by the animated display thread
         # Only print static messages for state changes