aidp 0.23.0 → 0.25.0

data/lib/aidp/providers/error_taxonomy.rb

@@ -0,0 +1,195 @@
+# 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

@@ -36,11 +36,12 @@ module Aidp
         end
 
         begin
+          command_args = ["--prompt", prompt]
           # Use debug_execute_command with streaming support
-          result = debug_execute_command("gemini", args: ["--print"], input: prompt, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("gemini", args: command_args, timeout: timeout_seconds, streaming: streaming_enabled)
 
           # Log the results
-          debug_command("gemini", args: ["--print"], input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
+          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

data/lib/aidp/providers/kilocode.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "base"
+require_relative "../util"
+require_relative "../debug_mixin"
+
+module Aidp
+  module Providers
+    class Kilocode < Base
+      include Aidp::DebugMixin
+
+      def self.available?
+        !!Aidp::Util.which("kilocode")
+      end
+
+      def name
+        "kilocode"
+      end
+
+      def display_name
+        "Kilocode"
+      end
+
+      def send_message(prompt:, session: nil)
+        raise "kilocode not available" unless self.class.available?
+
+        # Smart timeout calculation
+        timeout_seconds = calculate_timeout
+
+        debug_provider("kilocode", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to kilocode (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", type: :info)
+        end
+
+        # Check if prompt is too large and warn
+        if prompt.length > 3000
+          debug_log("⚠️  Large prompt detected (#{prompt.length} chars) - this may cause rate limiting", level: :warn)
+        end
+
+        # Set up activity monitoring
+        setup_activity_monitoring("kilocode", method(:activity_callback))
+        record_activity("Starting kilocode 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, "🔄 kilocode")
+          end
+        end
+
+        begin
+          # Build kilocode command arguments
+          args = ["--auto"]
+
+          # Add model if specified
+          model = ENV["KILOCODE_MODEL"]
+          if model
+            args.concat(["-m", model])
+          end
+
+          # Add workspace detection if needed
+          if Dir.exist?(".git") && ENV["KILOCODE_WORKSPACE"]
+            args.concat(["--workspace", ENV["KILOCODE_WORKSPACE"]])
+          end
+
+          # Set authentication via environment variable
+          env_vars = {}
+          if ENV["KILOCODE_TOKEN"]
+            env_vars["KILOCODE_TOKEN"] = ENV["KILOCODE_TOKEN"]
+          end
+
+          # Use debug_execute_command for better debugging
+          result = debug_execute_command("kilocode", args: args, input: prompt, timeout: timeout_seconds, streaming: streaming_enabled, env: env_vars)
+
+          # Log the results
+          debug_command("kilocode", 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("kilocode failed with exit code #{result.exit_status}")
+            debug_error(StandardError.new("kilocode failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "kilocode failed with exit code #{result.exit_status}: #{result.err}"
+          end
+        rescue => e
+          spinner&.error("✗")
+          mark_failed("kilocode execution failed: #{e.message}")
+          debug_error(e, {provider: "kilocode", prompt_length: prompt.length})
+          raise
+        ensure
+          cleanup_activity_display(activity_display_thread, spinner)
+        end
+      end
+
+      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_KILOCODE_TIMEOUT"]
+          return ENV["AIDP_KILOCODE_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
+        case state
+        when :starting
+          display_message("🚀 Starting kilocode execution...", type: :info)
+        when :completed
+          display_message("✅ kilocode execution completed", type: :success)
+        when :failed
+          display_message("❌ kilocode execution failed: #{message}", type: :error)
+        end
+      end
+
+      def setup_activity_monitoring(provider_name, callback)
+        @activity_callback = callback
+        @activity_state = :starting
+        @activity_start_time = Time.now
+      end
+
+      def record_activity(message)
+        @activity_state = :running
+        @activity_callback&.call(:running, message, "kilocode")
+      end
+
+      def mark_completed
+        @activity_state = :completed
+        @activity_callback&.call(:completed, "Execution completed", "kilocode")
+      end
+
+      def mark_failed(reason)
+        @activity_state = :failed
+        @activity_callback&.call(:failed, reason, "kilocode")
+      end
+    end
+  end
+end

data/lib/aidp/setup/provider_registry.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Setup
+    # Centralized registry for provider metadata including billing types and model families.
+    # This module provides a single source of truth for provider configuration options.
+    module ProviderRegistry
+      # Billing type options for providers
+      BILLING_TYPES = [
+        {
+          label: "Subscription / flat-rate",
+          value: "subscription",
+          description: "Monthly or annual subscription with unlimited usage"
+        },
+        {
+          label: "Usage-based / metered (API)",
+          value: "usage_based",
+          description: "Pay per API call or token usage"
+        },
+        {
+          label: "Passthrough / local (no billing)",
+          value: "passthrough",
+          description: "Local execution or proxy without direct billing"
+        }
+      ].freeze
+
+      # Model family options for providers
+      MODEL_FAMILIES = [
+        {
+          label: "Auto (let provider decide)",
+          value: "auto",
+          description: "Use provider's default model selection"
+        },
+        {
+          label: "OpenAI o-series (reasoning models)",
+          value: "openai_o",
+          description: "Advanced reasoning capabilities, slower but more thorough"
+        },
+        {
+          label: "Anthropic Claude (balanced)",
+          value: "claude",
+          description: "Balanced performance for general-purpose tasks"
+        },
+        {
+          label: "Google Gemini (multimodal)",
+          value: "gemini",
+          description: "Google's multimodal AI with strong reasoning and vision capabilities"
+        },
+        {
+          label: "Meta Llama (open-source)",
+          value: "llama",
+          description: "Meta's open-source model family, suitable for self-hosting"
+        },
+        {
+          label: "DeepSeek (efficient reasoning)",
+          value: "deepseek",
+          description: "Cost-efficient reasoning models with strong performance"
+        },
+        {
+          label: "Mistral (European/open)",
+          value: "mistral",
+          description: "European provider with open-source focus"
+        },
+        {
+          label: "Local LLM (self-hosted)",
+          value: "local",
+          description: "Self-hosted or local model execution"
+        }
+      ].freeze
+
+      # Returns array of [label, value] pairs for billing types
+      def self.billing_type_choices
+        BILLING_TYPES.map { |bt| [bt[:label], bt[:value]] }
+      end
+
+      # Returns array of [label, value] pairs for model families
+      def self.model_family_choices
+        MODEL_FAMILIES.map { |mf| [mf[:label], mf[:value]] }
+      end
+
+      # Finds label for a given billing type value
+      def self.billing_type_label(value)
+        BILLING_TYPES.find { |bt| bt[:value] == value }&.dig(:label) || value
+      end
+
+      # Finds label for a given model family value
+      def self.model_family_label(value)
+        MODEL_FAMILIES.find { |mf| mf[:value] == value }&.dig(:label) || value
+      end
+
+      # Finds description for a given billing type value
+      def self.billing_type_description(value)
+        BILLING_TYPES.find { |bt| bt[:value] == value }&.dig(:description)
+      end
+
+      # Finds description for a given model family value
+      def self.model_family_description(value)
+        MODEL_FAMILIES.find { |mf| mf[:value] == value }&.dig(:description)
+      end
+
+      # Validates if a billing type value is valid
+      def self.valid_billing_type?(value)
+        BILLING_TYPES.any? { |bt| bt[:value] == value }
+      end
+
+      # Validates if a model family value is valid
+      def self.valid_model_family?(value)
+        MODEL_FAMILIES.any? { |mf| mf[:value] == value }
+      end
+
+      # Returns all valid billing type values
+      def self.billing_type_values
+        BILLING_TYPES.map { |bt| bt[:value] }
+      end
+
+      # Returns all valid model family values
+      def self.model_family_values
+        MODEL_FAMILIES.map { |mf| mf[:value] }
+      end
+    end
+  end
+end