aidp 0.26.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

@@ -9,10 +9,155 @@ module Aidp
     class Anthropic < Base
       include Aidp::DebugMixin
 
+      # Model name pattern for Anthropic Claude models
+      MODEL_PATTERN = /^claude-[\d.-]+-(?:opus|sonnet|haiku)(?:-\d{8})?$/i
+
       def self.available?
         !!Aidp::Util.which("claude")
       end
 
+      # Normalize a provider-specific model name to its model family
+      #
+      # Anthropic uses date-versioned models (e.g., "claude-3-5-sonnet-20241022").
+      # This method strips the date suffix to get the family name.
+      #
+      # @param provider_model_name [String] The versioned model name
+      # @return [String] The model family name (e.g., "claude-3-5-sonnet")
+      def self.model_family(provider_model_name)
+        # Strip date suffix: "claude-3-5-sonnet-20241022" → "claude-3-5-sonnet"
+        provider_model_name.sub(/-\d{8}$/, "")
+      end
+
+      # Convert a model family name to the provider's preferred model name
+      #
+      # Returns the family name as-is. Users can configure specific versions in aidp.yml.
+      #
+      # @param family_name [String] The model family name
+      # @return [String] The model name (same as family for flexibility)
+      def self.provider_model_name(family_name)
+        family_name
+      end
+
+      # Check if this provider supports a given model family
+      #
+      # @param family_name [String] The model family name
+      # @return [Boolean] True if it matches Claude model pattern
+      def self.supports_model_family?(family_name)
+        MODEL_PATTERN.match?(family_name)
+      end
+
+      # Discover available models from Claude CLI
+      #
+      # @return [Array<Hash>] Array of discovered models
+      def self.discover_models
+        return [] unless available?
+
+        begin
+          require "open3"
+          output, _, status = Open3.capture3("claude", "models", "list", {timeout: 10})
+          return [] unless status.success?
+
+          parse_models_list(output)
+        rescue => e
+          Aidp.log_debug("anthropic_provider", "discovery failed", error: e.message)
+          []
+        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
+
+        def parse_models_list(output)
+          return [] if output.nil? || output.empty?
+
+          models = []
+          lines = output.lines.map(&:strip)
+
+          # Skip header and separator lines
+          lines.reject! { |line| line.empty? || line.match?(/^[-=]+$/) || line.match?(/^(Model|Name)/i) }
+
+          lines.each do |line|
+            model_info = parse_model_line(line)
+            models << model_info if model_info
+          end
+
+          Aidp.log_info("anthropic_provider", "discovered models", count: models.size)
+          models
+        end
+
+        def parse_model_line(line)
+          # Format 1: Simple list of model names
+          if line.match?(/^claude-\d/)
+            model_name = line.split.first
+            return build_model_info(model_name)
+          end
+
+          # Format 2: Table format with columns
+          parts = line.split(/\s{2,}/)
+          if parts.size >= 1 && parts[0].match?(/^claude/)
+            model_name = parts[0]
+            model_name = "#{model_name}-#{parts[1]}" if parts.size > 1 && parts[1].match?(/^\d{8}$/)
+            return build_model_info(model_name)
+          end
+
+          # Format 3: JSON-like or key-value pairs
+          if line.match?(/name:\s*(.+)/)
+            model_name = $1.strip
+            return build_model_info(model_name)
+          end
+
+          nil
+        end
+
+        def build_model_info(model_name)
+          family = model_family(model_name)
+          tier = classify_tier(model_name)
+
+          {
+            name: model_name,
+            family: family,
+            tier: tier,
+            capabilities: extract_capabilities(model_name),
+            context_window: infer_context_window(family),
+            provider: "anthropic"
+          }
+        end
+
+        def classify_tier(model_name)
+          name_lower = model_name.downcase
+          return "advanced" if name_lower.include?("opus")
+          return "mini" if name_lower.include?("haiku")
+          return "standard" if name_lower.include?("sonnet")
+          "standard"
+        end
+
+        def extract_capabilities(model_name)
+          capabilities = ["chat", "code"]
+          name_lower = model_name.downcase
+          capabilities << "vision" unless name_lower.include?("haiku")
+          capabilities
+        end
+
+        def infer_context_window(family)
+          family.match?(/claude-3/) ? 200_000 : nil
+        end
+      end
+
+      # Public instance methods (called from workflows and harness)
+      public
+
       def name
         "anthropic"
       end
@@ -53,8 +198,7 @@ module Aidp
           supports_json_mode: true,
           supports_tool_use: true,
           supports_vision: false,
-          supports_file_upload: true,
-          streaming: true
+          supports_file_upload: true
         }
       end
 
@@ -115,18 +259,12 @@ module Aidp
         debug_provider("claude", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to claude...", level: :info)
 
-        # Check if streaming mode is enabled
-        streaming_enabled = ENV["AIDP_STREAMING"] == "1" || ENV["DEBUG"] == "1"
-
-        # Build command arguments with proper streaming support
-        args = ["--print"]
-        if streaming_enabled
-          # Claude CLI requires --verbose when using --print with --output-format=stream-json
-          args += ["--verbose", "--output-format=stream-json", "--include-partial-messages"]
-          display_message("📺 True streaming enabled - real-time chunks from Claude API", type: :info)
-        else
-          # Use text format for non-streaming (default behavior)
-          args += ["--output-format=text"]
+        # 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)
@@ -136,28 +274,34 @@ module Aidp
         end
 
         begin
-          # Use debug_execute_command with streaming support
-          result = debug_execute_command("claude", args: args, input: prompt, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("claude", args: args, input: prompt, timeout: timeout_seconds)
 
           # Log the results
           debug_command("claude", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
 
           if result.exit_status == 0
-            # Handle different output formats
-            if streaming_enabled && args.include?("--output-format=stream-json")
-              # Parse stream-json output and extract final content
-              parse_stream_json_output(result.out)
-            else
-              # Return text output as-is
-              result.out
-            end
+            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. Run 'claude /login' or refresh credentials."
+              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
 
@@ -172,58 +316,47 @@ 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
+      # Notify harness about rate limit detection
+      def notify_rate_limit(message)
+        return unless @harness_context
 
-        if ENV["AIDP_QUICK_MODE"]
-          display_message("⚡ Quick mode enabled - #{TIMEOUT_QUICK_MODE / 60} minute timeout", type: :highlight)
-          return TIMEOUT_QUICK_MODE
-        end
+        # Extract reset time from message (e.g., "resets 4am")
+        reset_time = extract_reset_time_from_message(message)
 
-        if ENV["AIDP_ANTHROPIC_TIMEOUT"]
-          return ENV["AIDP_ANTHROPIC_TIMEOUT"].to_i
-        end
-
-        if adaptive_timeout
-          display_message("🧠 Using adaptive timeout: #{adaptive_timeout} seconds", type: :info)
-          return adaptive_timeout
+        # 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
-
-        # Default timeout
-        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
-        TIMEOUT_DEFAULT
+      rescue => e
+        Aidp.log_debug("anthropic_provider", "notify_rate_limit_failed",
+          error: e.message)
       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
-          when /IMPLEMENTATION/
-            TIMEOUT_IMPLEMENTATION
-          else
-            nil # Use default
-          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
@@ -243,54 +376,6 @@ module Aidp
         false
       end
 
-      # Parse stream-json output from Claude CLI
-      def parse_stream_json_output(output)
-        return output if output.nil? || output.empty?
-
-        # Stream-json output contains multiple JSON objects, one per line
-        # We want to extract the final content from the last complete message
-        lines = output.strip.split("\n")
-        content_parts = []
-
-        lines.each do |line|
-          next if line.strip.empty?
-
-          begin
-            json_obj = JSON.parse(line)
-
-            # Look for content in various possible structures
-            if json_obj["type"] == "content_block_delta" && json_obj["delta"] && json_obj["delta"]["text"]
-              content_parts << json_obj["delta"]["text"]
-            elsif json_obj["content"]&.is_a?(Array)
-              json_obj["content"].each do |content_item|
-                content_parts << content_item["text"] if content_item["text"]
-              end
-            elsif json_obj["message"] && json_obj["message"]["content"]
-              if json_obj["message"]["content"].is_a?(Array)
-                json_obj["message"]["content"].each do |content_item|
-                  content_parts << content_item["text"] if content_item["text"]
-                end
-              elsif json_obj["message"]["content"].is_a?(String)
-                content_parts << json_obj["message"]["content"]
-              end
-            end
-          rescue JSON::ParserError => e
-            debug_log("⚠️ Failed to parse JSON line: #{e.message}", level: :warn, data: {line: line})
-            # If JSON parsing fails, treat as plain text
-            content_parts << line
-          end
-        end
-
-        result = content_parts.join
-
-        # Fallback: if no content found in JSON, return original output
-        result.empty? ? output : result
-      rescue => e
-        debug_log("⚠️ Failed to parse stream-json output: #{e.message}", level: :warn)
-        # Return original output if parsing fails
-        output
-      end
-
       # Parse Claude MCP server list output
       def parse_claude_mcp_output(output)
         servers = []