aidp 0.27.0 → 0.28.0

data/lib/aidp/providers/aider.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "base"
+require_relative "../util"
+require_relative "../debug_mixin"
+
+module Aidp
+  module Providers
+    class Aider < Base
+      include Aidp::DebugMixin
+
+      # Model name pattern for Aider (supports various models via OpenRouter)
+      # Aider can use any model, but we'll match common patterns
+      MODEL_PATTERN = /^(gpt-|claude-|gemini-|deepseek-|qwen-|o1-)/i
+      LONG_PROMPT_THRESHOLD = 8000
+      LONG_PROMPT_TIMEOUT = 900 # 15 minutes for large prompts
+
+      def self.available?
+        !!Aidp::Util.which("aider")
+      end
+
+      # Check if this provider supports a given model family
+      #
+      # @param family_name [String] The model family name
+      # @return [Boolean] True if it matches common model patterns
+      def self.supports_model_family?(family_name)
+        MODEL_PATTERN.match?(family_name)
+      end
+
+      # Discover available models from registry
+      #
+      # Note: Aider uses its own configuration for models
+      # Returns registry-based models that match common patterns
+      #
+      # @return [Array<Hash>] Array of discovered models
+      def self.discover_models
+        return [] unless available?
+
+        discover_models_from_registry(MODEL_PATTERN, "aider")
+      end
+
+      # Get firewall requirements for Aider provider
+      # Aider uses aider.chat for updates, openrouter.ai for API access,
+      # and pypi.org for version checking
+      def self.firewall_requirements
+        {
+          domains: [
+            "aider.chat",
+            "openrouter.ai",
+            "api.openrouter.ai",
+            "pypi.org"
+          ],
+          ip_ranges: []
+        }
+      end
+
+      def name
+        "aider"
+      end
+
+      def display_name
+        "Aider"
+      end
+
+      def available?
+        return false unless self.class.available?
+
+        # Additional check to ensure the CLI is properly configured
+        begin
+          result = Aidp::Util.execute_command("aider", ["--version"], timeout: 10)
+          result.exit_status == 0
+        rescue
+          false
+        end
+      end
+
+      def send_message(prompt:, session: nil)
+        raise "aider CLI not available" unless self.class.available?
+
+        # Smart timeout calculation (store prompt length for adaptive logic)
+        @current_aider_prompt_length = prompt.length
+        timeout_seconds = calculate_timeout
+
+        debug_provider("aider", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to aider (length: #{prompt.length})", level: :info)
+
+        # Set up activity monitoring
+        setup_activity_monitoring("aider", method(:activity_callback))
+        record_activity("Starting aider execution")
+
+        # Create a spinner for activity display
+        spinner = TTY::Spinner.new("[:spinner] :title", format: :dots, hide_cursor: true)
+        spinner.auto_spin
+
+        activity_display_thread = Thread.new do
+          start_time = Time.now
+          loop do
+            sleep 0.5 # Update every 500ms to reduce spam
+            elapsed = Time.now - start_time
+
+            # Break if we've been running too long or state changed
+            break if elapsed > timeout_seconds || @activity_state == :completed || @activity_state == :failed
+
+            update_spinner_status(spinner, elapsed, "🤖 Aider")
+          end
+        end
+
+        begin
+          # Use non-interactive mode with --yes-always flag and --message
+          # --yes-always is equivalent to Claude's --dangerously-skip-permissions
+          args = ["--yes-always", "--message", prompt]
+
+          # Disable aider's auto-commits by default - let AIDP handle commits
+          # based on work_loop.version_control.behavior configuration
+          args += ["--no-auto-commits"]
+
+          # Add model if configured
+          if @model && !@model.empty?
+            args += ["--model", @model]
+          end
+
+          # Add session support if provided (aider supports chat history)
+          if session && !session.empty?
+            args += ["--restore-chat-history"]
+          end
+
+          # In devcontainer, aider should run in non-interactive mode
+          if in_devcontainer_or_codespace?
+            debug_log("🔓 Running aider in non-interactive mode with --yes-always (devcontainer)", level: :info)
+          end
+
+          # Use debug_execute_command for better debugging
+          result = debug_execute_command("aider", args: args, timeout: timeout_seconds)
+
+          # Log the results
+          debug_command("aider", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
+
+          if result.exit_status == 0
+            spinner.success("✓")
+            mark_completed
+            result.out
+          else
+            spinner.error("✗")
+            mark_failed("aider failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("aider failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "aider failed with exit code #{result.exit_status}: #{result.err}"
+          end
+        rescue => e
+          spinner&.error("✗")
+          mark_failed("aider execution failed: #{e.message}")
+          debug_error(e, {provider: "aider", prompt_length: prompt.length})
+          raise
+        ensure
+          cleanup_activity_display(activity_display_thread, spinner)
+          @current_aider_prompt_length = nil
+        end
+      end
+
+      # Enhanced send method with additional options
+      def send_with_options(prompt:, session: nil, model: nil, auto_commits: false)
+        args = ["--yes-always", "--message", prompt]
+
+        # Disable auto-commits by default (let AIDP handle commits)
+        # unless explicitly enabled via auto_commits parameter
+        args += if auto_commits
+          ["--auto-commits"]
+        else
+          ["--no-auto-commits"]
+        end
+
+        # Add session support
+        if session && !session.empty?
+          args += ["--restore-chat-history"]
+        end
+
+        # Add model selection (from parameter or configured model)
+        model_to_use = model || @model
+        if model_to_use
+          args += ["--model", model_to_use]
+        end
+
+        # Use the enhanced version of send
+        send_with_custom_args(prompt: prompt, args: args)
+      end
+
+      # Override health check for Aider specific considerations
+      def harness_healthy?
+        return false unless super
+
+        # Additional health checks specific to Aider
+        # Check if we can access the CLI (basic connectivity test)
+        begin
+          result = Aidp::Util.execute_command("aider", ["--help"], timeout: 5)
+          result.exit_status == 0
+        rescue
+          false
+        end
+      end
+
+      private
+
+      # Internal helper for send_with_options - executes with custom arguments
+      def send_with_custom_args(prompt:, args:)
+        @current_aider_prompt_length = prompt.length
+        timeout_seconds = calculate_timeout
+
+        debug_provider("aider", "Starting execution", {timeout: timeout_seconds, args: args})
+        debug_log("📝 Sending prompt to aider with custom args", level: :info)
+
+        setup_activity_monitoring("aider", method(:activity_callback))
+        record_activity("Starting aider execution with custom args")
+
+        begin
+          result = debug_execute_command("aider", args: args, timeout: timeout_seconds)
+          debug_command("aider", args: args, output: result.out, error: result.err, exit_code: result.exit_status)
+
+          if result.exit_status == 0
+            mark_completed
+            result.out
+          else
+            mark_failed("aider failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("aider failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "aider failed with exit code #{result.exit_status}: #{result.err}"
+          end
+        rescue => e
+          mark_failed("aider execution failed: #{e.message}")
+          debug_error(e, {provider: "aider", prompt_length: prompt.length})
+          raise
+        ensure
+          @current_aider_prompt_length = nil
+        end
+      end
+
+      def activity_callback(state, message, provider)
+        # Handle activity state changes
+        case state
+        when :stuck
+          display_message("\n⚠️  Aider appears stuck: #{message}", type: :warning)
+        when :completed
+          display_message("\n✅ Aider completed: #{message}", type: :success)
+        when :failed
+          display_message("\n❌ Aider failed: #{message}", type: :error)
+        end
+      end
+
+      def calculate_timeout
+        env_override = ENV["AIDP_AIDER_TIMEOUT"]
+        return env_override.to_i if env_override&.match?(/^\d+$/)
+
+        base_timeout = super
+
+        prompt_length = @current_aider_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("⏱️  Aider prompt length #{prompt_length} detected - extending timeout to #{extended_timeout} seconds", type: :info)
+        end
+        extended_timeout
+      end
+    end
+  end
+end

data/lib/aidp/providers/anthropic.rb

@@ -64,6 +64,18 @@ module Aidp
         end
       end
 
+      # Get firewall requirements for Anthropic provider
+      def self.firewall_requirements
+        {
+          domains: [
+            "api.anthropic.com",
+            "claude.ai",
+            "console.anthropic.com"
+          ],
+          ip_ranges: []
+        }
+      end
+
       class << self
         private
 
@@ -250,6 +262,11 @@ module Aidp
         # Build command arguments
         args = ["--print", "--output-format=text"]
 
+        # Add model if specified
+        if @model && !@model.empty?
+          args << "--model" << @model
+        end
+
         # Check if we should skip permissions (devcontainer support)
         if should_skip_permissions?
           args << "--dangerously-skip-permissions"
@@ -265,14 +282,26 @@ module Aidp
           if result.exit_status == 0
             result.out
           else
-            # Detect auth issues in stdout/stderr (Claude sometimes prints JSON with auth error to stdout)
+            # 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)
+              Aidp.log_debug("anthropic_provider", "rate_limit_detected",
+                exit_code: result.exit_status,
+                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
+            end
+
+            # Check for auth issues
             if combined.downcase.include?("oauth token has expired") || combined.downcase.include?("authentication_error")
               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 a recognizable error for classifier
               raise error_message
             end
 
@@ -287,6 +316,49 @@ module Aidp
 
       private
 
+      # Notify harness about rate limit detection
+      def notify_rate_limit(message)
+        return unless @harness_context
+
+        # Extract reset time from message (e.g., "resets 4am")
+        reset_time = extract_reset_time_from_message(message)
+
+        # Notify provider manager if available
+        if @harness_context.respond_to?(:provider_manager)
+          provider_manager = @harness_context.provider_manager
+          if provider_manager.respond_to?(:mark_rate_limited)
+            provider_manager.mark_rate_limited("anthropic", reset_time)
+            Aidp.log_debug("anthropic_provider", "notified_provider_manager",
+              reset_time: reset_time)
+          end
+        end
+      rescue => e
+        Aidp.log_debug("anthropic_provider", "notify_rate_limit_failed",
+          error: e.message)
+      end
+
+      # Extract reset time from rate limit message
+      def extract_reset_time_from_message(message)
+        # Handle expressions like "resets 4am" or "reset at 4:30pm"
+        time_of_day_match = message.match(/reset(?:s)?(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)/i)
+        if time_of_day_match
+          hour = time_of_day_match[1].to_i
+          minute = time_of_day_match[2] ? time_of_day_match[2].to_i : 0
+          meridiem = time_of_day_match[3].downcase
+
+          hour %= 12
+          hour += 12 if meridiem == "pm"
+
+          now = Time.now
+          reset_time = Time.new(now.year, now.month, now.day, hour, minute, 0, now.utc_offset)
+          reset_time += 86_400 if reset_time <= now
+          return reset_time
+        end
+
+        # Default to 1 hour from now if no specific time found
+        Time.now + 3600
+      end
+
       # Check if we should skip permissions based on devcontainer configuration
       # Overrides base class to add logging and Claude-specific config check
       def should_skip_permissions?

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
@@ -360,6 +367,23 @@ module Aidp
         []
       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

data/lib/aidp/providers/codex.rb

@@ -39,6 +39,23 @@ module Aidp
         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
@@ -94,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]
@@ -149,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

data/lib/aidp/providers/cursor.rb

@@ -46,6 +46,22 @@ module Aidp
         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

data/lib/aidp/providers/gemini.rb

@@ -55,6 +55,19 @@ module Aidp
         discover_models_from_registry(MODEL_PATTERN, "gemini")
       end
 
+      # Get firewall requirements for Gemini provider
+      def self.firewall_requirements
+        {
+          domains: [
+            "generativelanguage.googleapis.com",
+            "oauth2.googleapis.com",
+            "accounts.google.com",
+            "www.googleapis.com"
+          ],
+          ip_ranges: []
+        }
+      end
+
       def name
         "gemini"
       end

data/lib/aidp/providers/github_copilot.rb

@@ -14,6 +14,23 @@ module Aidp
         !!Aidp::Util.which("copilot")
       end
 
+      # Get firewall requirements for GitHub Copilot provider
+      def self.firewall_requirements
+        {
+          domains: [
+            "copilot-proxy.githubusercontent.com",
+            "api.githubcopilot.com",
+            "copilot-telemetry.githubusercontent.com",
+            "default.exp-tas.com",
+            "copilot-completions.githubusercontent.com",
+            "business.githubcopilot.com",
+            "enterprise.githubcopilot.com",
+            "individual.githubcopilot.com"
+          ],
+          ip_ranges: []
+        }
+      end
+
       def name
         "github_copilot"
       end

data/lib/aidp/providers/kilocode.rb

@@ -37,6 +37,17 @@ module Aidp
         discover_models_from_registry(MODEL_PATTERN, "kilocode")
       end
 
+      # Get firewall requirements for Kilocode provider
+      def self.firewall_requirements
+        {
+          domains: [
+            "kilocode.ai",
+            "api.kilocode.ai"
+          ],
+          ip_ranges: []
+        }
+      end
+
       def name
         "kilocode"
       end

data/lib/aidp/providers/opencode.rb

@@ -37,6 +37,17 @@ module Aidp
         discover_models_from_registry(MODEL_PATTERN, "opencode")
       end
 
+      # Get firewall requirements for OpenCode provider
+      def self.firewall_requirements
+        {
+          domains: [
+            "api.opencode.ai",
+            "auth.opencode.ai"
+          ],
+          ip_ranges: []
+        }
+      end
+
       def name
         "opencode"
       end