aidp 0.34.1 → 0.39.3

data/lib/aidp/providers/cursor.rb

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-require_relative "base"
-require_relative "../util"
-require_relative "../debug_mixin"
-
-module Aidp
-  module Providers
-    class Cursor < Base
-      include Aidp::DebugMixin
-
-      def self.available?
-        !!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",
-            # Authentication (Auth0)
-            "auth.cursor.sh",
-            "auth0.com",
-            "*.auth0.com",
-            "a0core.net",
-            "*.a0core.net"
-          ],
-          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
-
-      def display_name
-        "Cursor AI"
-      end
-
-      def supports_mcp?
-        true
-      end
-
-      def fetch_mcp_servers
-        # Try cursor-agent CLI first, then fallback to config file
-        fetch_mcp_servers_cli || fetch_mcp_servers_config
-      end
-
-      def send_message(prompt:, session: nil, options: {})
-        raise "cursor-agent not available" unless self.class.available?
-
-        # Smart timeout calculation
-        timeout_seconds = calculate_timeout
-
-        debug_provider("cursor", "Starting execution", {timeout: timeout_seconds})
-        debug_log("📝 Sending prompt to cursor-agent (length: #{prompt.length})", level: :info)
-
-        # Set up activity monitoring
-        setup_activity_monitoring("cursor-agent", method(:activity_callback))
-        record_activity("Starting cursor-agent 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, "🔄 cursor-agent")
-          end
-        end
-
-        begin
-          # 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)
-
-          # Log the results
-          debug_command("cursor-agent", args: ["-p"], 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("cursor-agent failed with exit code #{result.exit_status}")
-            debug_error(StandardError.new("cursor-agent failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "cursor-agent failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue => e
-          spinner&.error("✗")
-          mark_failed("cursor-agent execution failed: #{e.message}")
-          debug_error(e, {provider: "cursor", prompt_length: prompt.length})
-          raise
-        ensure
-          cleanup_activity_display(activity_display_thread, spinner)
-        end
-      end
-
-      private
-
-      def activity_callback(state, message, provider)
-        # This is now handled by the animated display thread
-        # Only print static messages for state changes
-        case state
-        when :stuck
-          display_message("\n⚠️  cursor appears stuck: #{message}", type: :warning)
-        when :completed
-          display_message("\n✅ cursor completed: #{message}", type: :success)
-        when :failed
-          display_message("\n❌ cursor failed: #{message}", type: :error)
-        end
-      end
-
-      # Try to get MCP servers via cursor-agent CLI
-      def fetch_mcp_servers_cli
-        return nil unless self.class.available?
-
-        begin
-          # Try cursor-agent mcp list (if such command exists)
-          result = debug_execute_command("cursor-agent", args: ["mcp", "list"], timeout: 5)
-          return nil unless result.exit_status == 0
-
-          parse_mcp_servers_output(result.out)
-        rescue => e
-          debug_log("Failed to fetch MCP servers via CLI: #{e.message}", level: :debug)
-          nil
-        end
-      end
-
-      # Fallback to reading Cursor's config file
-      def fetch_mcp_servers_config
-        cursor_config_path = File.expand_path("~/.cursor/mcp.json")
-        return [] unless File.exist?(cursor_config_path)
-
-        begin
-          require "json"
-          config_content = File.read(cursor_config_path)
-          config = JSON.parse(config_content)
-
-          servers = []
-          mcp_servers = config["mcpServers"] || {}
-
-          mcp_servers.each do |name, server_config|
-            # Build command description
-            command_parts = [server_config["command"]]
-            command_parts.concat(server_config["args"]) if server_config["args"]
-            command_description = command_parts.join(" ")
-
-            servers << {
-              name: name,
-              status: "configured",
-              description: command_description,
-              enabled: true,
-              source: "cursor_config",
-              env_vars: server_config["env"] || {}
-            }
-          end
-
-          servers
-        rescue JSON::ParserError => e
-          debug_log("Failed to parse Cursor MCP configuration: #{e.message}", level: :debug)
-          []
-        rescue => e
-          debug_log("Failed to parse Cursor MCP configuration: #{e.message}", level: :debug)
-          []
-        end
-      end
-
-      # Parse MCP server output from CLI commands
-      def parse_mcp_servers_output(output)
-        servers = []
-        return servers unless output
-
-        lines = output.lines
-        lines.reject! { |line| /checking mcp server health/i.match?(line) }
-
-        lines.each do |line|
-          line = line.strip
-          next if line.empty?
-
-          # Try to parse cursor-agent format: "name: status"
-          if line =~ /^([^:]+):\s*(.+)$/
-            name = Regexp.last_match(1).strip
-            status = Regexp.last_match(2).strip
-
-            servers << {
-              name: name,
-              status: status,
-              description: "MCP server managed by cursor-agent",
-              enabled: status == "ready" || status == "connected",
-              source: "cursor_cli"
-            }
-            next
-          end
-
-          # Also try to parse extended format: "name: command - ✓ Connected" (for future compatibility)
-          if line =~ /^([^:]+):\s*(.+?)\s*-\s*(✓|✗)\s*(.+)$/
-            name = Regexp.last_match(1).strip
-            command = Regexp.last_match(2).strip
-            status_symbol = Regexp.last_match(3)
-            status_text = Regexp.last_match(4).strip
-
-            servers << {
-              name: name,
-              status: (status_symbol == "✓") ? "connected" : "error",
-              description: command,
-              enabled: status_symbol == "✓",
-              error: (status_symbol == "✗") ? status_text : nil,
-              source: "cursor_cli"
-            }
-          end
-        end
-
-        servers
-      end
-    end
-  end
-end

data/lib/aidp/providers/error_taxonomy.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module Aidp
-  module Providers
-    # ErrorTaxonomy defines the five standardized error categories that all providers
-    # use for consistent error handling, retry logic, and escalation.
-    #
-    # Categories:
-    # - rate_limited: Provider is rate-limiting requests (switch provider immediately)
-    # - auth_expired: Authentication credentials are invalid or expired (escalate or switch)
-    # - quota_exceeded: Usage quota has been exceeded (switch provider)
-    # - transient: Temporary error that may resolve on retry (retry with backoff)
-    # - permanent: Permanent error that won't resolve with retry (escalate or abort)
-    #
-    # @see https://github.com/viamin/aidp/issues/243
-    module ErrorTaxonomy
-      # Error category constants
-      RATE_LIMITED = :rate_limited
-      AUTH_EXPIRED = :auth_expired
-      QUOTA_EXCEEDED = :quota_exceeded
-      TRANSIENT = :transient
-      PERMANENT = :permanent
-
-      # All valid error categories
-      CATEGORIES = [
-        RATE_LIMITED,
-        AUTH_EXPIRED,
-        QUOTA_EXCEEDED,
-        TRANSIENT,
-        PERMANENT
-      ].freeze
-
-      # Default error patterns for common error messages
-      # Providers can override these with provider-specific patterns
-      DEFAULT_PATTERNS = {
-        rate_limited: [
-          /rate.?limit/i,
-          /too.?many.?requests/i,
-          /429/,
-          /throttl(ed|ing)/i,
-          /request.?limit/i,
-          /requests.?per.?minute/i,
-          /rpm.?exceeded/i
-        ],
-        auth_expired: [
-          /auth(entication|orization).?(fail(ed|ure)|error)/i,
-          /invalid.?(api.?key|token|credential)/i,
-          /expired.?(api.?key|token|credential)/i,
-          /unauthorized/i,
-          /401/,
-          /403/,
-          /permission.?denied/i,
-          /access.?denied/i
-        ],
-        quota_exceeded: [
-          /quota.?(exceed(ed)?|limit|exhausted)/i,
-          /usage.?limit/i,
-          /billing.?limit/i,
-          /credit.?limit/i,
-          /insufficient.?quota/i,
-          /usage.?cap/i
-        ],
-        transient: [
-          /timeout/i,
-          /timed?.?out/i,
-          /connection.?(reset|refused|lost|closed)/i,
-          /temporary.?error/i,
-          /try.?again/i,
-          /service.?unavailable/i,
-          /503/,
-          /502/,
-          /504/,
-          /gateway.?timeout/i,
-          /network.?error/i,
-          /socket.?error/i,
-          /connection.?error/i,
-          /broken.?pipe/i,
-          /host.?unreachable/i
-        ],
-        permanent: [
-          /invalid.?(model|parameter|request|input)/i,
-          /unsupported.?(operation|feature|model)/i,
-          /not.?found/i,
-          /404/,
-          /bad.?request/i,
-          /400/,
-          /malformed/i,
-          /syntax.?error/i,
-          /validation.?error/i,
-          /model.?not.?available/i,
-          /model.?deprecated/i
-        ]
-      }.freeze
-
-      # Retry policy for each category
-      RETRY_POLICIES = {
-        rate_limited: {
-          retry: false,
-          switch_provider: true,
-          escalate: false,
-          backoff_strategy: :none
-        },
-        auth_expired: {
-          retry: false,
-          switch_provider: true,
-          escalate: true,
-          backoff_strategy: :none
-        },
-        quota_exceeded: {
-          retry: false,
-          switch_provider: true,
-          escalate: false,
-          backoff_strategy: :none
-        },
-        transient: {
-          retry: true,
-          switch_provider: false,
-          escalate: false,
-          backoff_strategy: :exponential
-        },
-        permanent: {
-          retry: false,
-          switch_provider: false,
-          escalate: true,
-          backoff_strategy: :none
-        }
-      }.freeze
-
-      # Check if a category is valid
-      # @param category [Symbol] category to check
-      # @return [Boolean] true if valid
-      def self.valid_category?(category)
-        CATEGORIES.include?(category)
-      end
-
-      # Get retry policy for a category
-      # @param category [Symbol] error category
-      # @return [Hash] retry policy configuration
-      def self.retry_policy(category)
-        RETRY_POLICIES[category] || RETRY_POLICIES[:transient]
-      end
-
-      # Classify an error message using default patterns
-      # @param message [String] error message
-      # @return [Symbol] error category
-      def self.classify_message(message)
-        return :transient if message.nil? || message.empty?
-
-        message_lower = message.downcase
-
-        # Check each category's patterns
-        DEFAULT_PATTERNS.each do |category, patterns|
-          patterns.each do |pattern|
-            return category if message_lower.match?(pattern)
-          end
-        end
-
-        # Default to transient for unknown errors
-        :transient
-      end
-
-      # Check if an error category is retryable
-      # @param category [Symbol] error category
-      # @return [Boolean] true if should retry
-      def self.retryable?(category)
-        policy = retry_policy(category)
-        policy[:retry] == true
-      end
-
-      # Check if an error category should trigger provider switch
-      # @param category [Symbol] error category
-      # @return [Boolean] true if should switch provider
-      def self.should_switch_provider?(category)
-        policy = retry_policy(category)
-        policy[:switch_provider] == true
-      end
-
-      # Check if an error category should be escalated
-      # @param category [Symbol] error category
-      # @return [Boolean] true if should escalate
-      def self.should_escalate?(category)
-        policy = retry_policy(category)
-        policy[:escalate] == true
-      end
-
-      # Get backoff strategy for a category
-      # @param category [Symbol] error category
-      # @return [Symbol] backoff strategy (:none, :linear, :exponential)
-      def self.backoff_strategy(category)
-        policy = retry_policy(category)
-        policy[:backoff_strategy] || :none
-      end
-    end
-  end
-end

data/lib/aidp/providers/gemini.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "../debug_mixin"
-
-module Aidp
-  module Providers
-    class Gemini < Base
-      include Aidp::DebugMixin
-
-      # Model name pattern for Gemini models
-      MODEL_PATTERN = /^gemini-[\d.]+-(?:pro|flash|ultra)(?:-\d+)?$/i
-
-      def self.available?
-        !!Aidp::Util.which("gemini")
-      end
-
-      # Normalize a provider-specific model name to its model family
-      #
-      # Gemini may use version suffixes (e.g., "gemini-1.5-pro-001").
-      # This method strips version suffixes to get the family name.
-      #
-      # @param provider_model_name [String] The model name
-      # @return [String] The model family name
-      def self.model_family(provider_model_name)
-        # Strip version suffix: "gemini-1.5-pro-001" → "gemini-1.5-pro"
-        provider_model_name.sub(/-\d+$/, "")
-      end
-
-      # Convert a model family name to the provider's preferred model name
-      #
-      # @param family_name [String] The model family name
-      # @return [String] The provider-specific model name (same as family)
-      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 Gemini model pattern
-      def self.supports_model_family?(family_name)
-        MODEL_PATTERN.match?(family_name)
-      end
-
-      # Discover available models from Gemini
-      #
-      # Note: Gemini CLI doesn't have a standard model listing command
-      # Returns registry-based models that match Gemini patterns
-      #
-      # @return [Array<Hash>] Array of discovered models
-      def self.discover_models
-        return [] unless available?
-
-        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
-
-      def display_name
-        "Google Gemini"
-      end
-
-      def send_message(prompt:, session: nil, options: {})
-        raise "gemini CLI not available" unless self.class.available?
-
-        # Smart timeout calculation
-        timeout_seconds = calculate_timeout
-
-        debug_provider("gemini", "Starting execution", {timeout: timeout_seconds})
-        debug_log("📝 Sending prompt to gemini...", level: :info)
-
-        begin
-          command_args = ["--prompt", prompt]
-          result = debug_execute_command("gemini", args: command_args, timeout: timeout_seconds)
-
-          # Log the results
-          debug_command("gemini", args: command_args, input: nil, output: result.out, error: result.err, exit_code: result.exit_status)
-
-          if result.exit_status == 0
-            result.out
-          else
-            debug_error(StandardError.new("gemini failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "gemini failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue => e
-          debug_error(e, {provider: "gemini", prompt_length: prompt.length})
-          raise
-        end
-      end
-
-      private
-    end
-  end
-end