aidp 0.23.0 → 0.24.0

data/lib/aidp/providers/anthropic.rb

@@ -44,6 +44,68 @@ module Aidp
         self.class.available?
       end
 
+      # ProviderAdapter interface methods
+
+      def capabilities
+        {
+          reasoning_tiers: ["mini", "standard", "thinking"],
+          context_window: 200_000,
+          supports_json_mode: true,
+          supports_tool_use: true,
+          supports_vision: false,
+          supports_file_upload: true,
+          streaming: true
+        }
+      end
+
+      def supports_dangerous_mode?
+        true
+      end
+
+      def dangerous_mode_flags
+        ["--dangerously-skip-permissions"]
+      end
+
+      def error_patterns
+        {
+          rate_limited: [
+            /rate.?limit/i,
+            /too.?many.?requests/i,
+            /429/,
+            /overloaded/i
+          ],
+          auth_expired: [
+            /oauth.*token.*expired/i,
+            /authentication.*error/i,
+            /invalid.*api.*key/i,
+            /unauthorized/i,
+            /401/
+          ],
+          quota_exceeded: [
+            /quota.*exceeded/i,
+            /usage.*limit/i,
+            /credit.*exhausted/i
+          ],
+          transient: [
+            /timeout/i,
+            /connection.*reset/i,
+            /temporary.*error/i,
+            /service.*unavailable/i,
+            /503/,
+            /502/,
+            /504/
+          ],
+          permanent: [
+            /invalid.*model/i,
+            /unsupported.*operation/i,
+            /not.*found/i,
+            /404/,
+            /bad.*request/i,
+            /400/
+          ]
+        }
+      end
+
       def send_message(prompt:, session: nil)
         raise "claude CLI not available" unless self.class.available?
 
@@ -156,6 +218,8 @@ module Aidp
             TIMEOUT_STATIC_ANALYSIS
           when /REFACTORING_RECOMMENDATIONS/
             TIMEOUT_REFACTORING_RECOMMENDATIONS
+          when /IMPLEMENTATION/
+            TIMEOUT_IMPLEMENTATION
           else
             nil # Use default
           end
@@ -163,16 +227,20 @@ module Aidp
       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?
-        # Check if harness context is available
-        return false unless @harness_context
+        # Use base class devcontainer detection
+        if in_devcontainer_or_codespace?
+          debug_log("🔓 Detected devcontainer/codespace environment - enabling full permissions", level: :info)
+          return true
+        end
 
-        # Get configuration from harness
-        config = @harness_context.config
-        return false unless config
+        # Fallback: Check harness context for Claude-specific configuration
+        if @harness_context&.config&.respond_to?(:should_use_full_permissions?)
+          return @harness_context.config.should_use_full_permissions?("claude")
+        end
 
-        # Use configuration method to determine if full permissions should be used
-        config.should_use_full_permissions?("claude")
+        false
       end
 
       # Parse stream-json output from Claude CLI

data/lib/aidp/providers/base.rb

@@ -2,6 +2,7 @@
 
 require "tty-prompt"
 require "tty-spinner"
+require_relative "adapter"
 
 module Aidp
   module Providers
@@ -9,6 +10,7 @@ module Aidp
 
     class Base
       include Aidp::MessageDisplay
+      include Aidp::Providers::Adapter
 
       # Activity indicator states
       ACTIVITY_STATES = {
@@ -33,6 +35,7 @@ module Aidp
       TIMEOUT_DOCUMENTATION_ANALYSIS = 300 # 5 minutes - documentation analysis
       TIMEOUT_STATIC_ANALYSIS = 450 # 7.5 minutes - static analysis
       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
 
@@ -299,7 +302,7 @@ module Aidp
           error_message = e.message
 
           # Check if error is rate limiting
-          if e.message.match?(/rate.?limit/i) || e.message.match?(/quota/i)
+          if e.message.match?(/rate.?limit/i) || e.message.match?(/quota/i) || e.message.match?(/session limit/i)
             rate_limited = true
           end
 
@@ -391,6 +394,31 @@ module Aidp
         spinner&.stop
       end
 
+      # Check if we should skip permissions based on devcontainer/codespace environment
+      # This enables providers to run with elevated permissions in safe development environments
+      # Returns true if running in a devcontainer or GitHub Codespace
+      def in_devcontainer_or_codespace?
+        ENV["REMOTE_CONTAINERS"] == "true" || ENV["CODESPACES"] == "true"
+      end
+
+      # Check if provider should skip sandbox permissions
+      # Providers can override this to add additional logic beyond environment detection
+      def should_skip_permissions?
+        # First, check for devcontainer/codespace environment (most reliable)
+        return true if in_devcontainer_or_codespace?
+
+        # Fallback: Check if harness context is available and has configuration
+        return false unless @harness_context
+
+        # Get configuration from harness
+        config = @harness_context.config
+        return false unless config
+
+        # Use configuration method to determine if full permissions should be used
+        # Provider subclasses should pass their provider name
+        false # Base implementation returns false, subclasses should override
+      end
+
       private
     end
   end

data/lib/aidp/providers/capability_registry.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Providers
+    # CapabilityRegistry maintains a queryable registry of provider capabilities
+    # and features. This enables runtime feature detection and provider selection
+    # based on required capabilities.
+    #
+    # @see https://github.com/viamin/aidp/issues/243
+    class CapabilityRegistry
+      # Standard capability keys
+      CAPABILITY_KEYS = [
+        :reasoning_tiers,      # Array of supported reasoning tiers (mini, standard, thinking, etc.)
+        :context_window,       # Maximum context window size in tokens
+        :supports_json_mode,   # Boolean: supports JSON mode output
+        :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
+      ].freeze
+
+      def initialize
+        @capabilities = {}
+        @providers = {}
+      end
+
+      # Register a provider and its capabilities
+      # @param provider [Aidp::Providers::Base] provider instance
+      # @return [void]
+      def register(provider)
+        provider_name = provider.name
+        @providers[provider_name] = provider
+
+        # Collect capabilities from provider
+        caps = provider.capabilities.dup
+        caps[:supports_mcp] = provider.supports_mcp?
+        caps[:supports_dangerous_mode] = provider.supports_dangerous_mode?
+
+        @capabilities[provider_name] = caps
+
+        Aidp.log_debug("CapabilityRegistry", "registered provider",
+          provider: provider_name,
+          capabilities: caps.keys)
+      end
+
+      # Unregister a provider
+      # @param provider_name [String] provider identifier
+      # @return [void]
+      def unregister(provider_name)
+        @capabilities.delete(provider_name)
+        @providers.delete(provider_name)
+      end
+
+      # Get capabilities for a specific provider
+      # @param provider_name [String] provider identifier
+      # @return [Hash, nil] capabilities hash or nil if not found
+      def capabilities_for(provider_name)
+        @capabilities[provider_name]
+      end
+
+      # Check if a provider has a specific capability
+      # @param provider_name [String] provider identifier
+      # @param capability [Symbol] capability key
+      # @param value [Object, nil] optional value to match
+      # @return [Boolean] true if provider has the capability
+      def has_capability?(provider_name, capability, value = nil)
+        caps = @capabilities[provider_name]
+        return false unless caps
+
+        if value.nil?
+          # Just check if capability exists and is truthy
+          caps.key?(capability) && caps[capability]
+        else
+          # Check if capability matches specific value
+          caps[capability] == value
+        end
+      end
+
+      # Find providers that match capability requirements
+      # @param requirements [Hash] capability requirements
+      # @return [Array<String>] array of matching provider names
+      # @example
+      #   registry.find_providers(supports_vision: true, min_context_window: 100_000)
+      def find_providers(**requirements)
+        matching = []
+
+        @capabilities.each do |provider_name, caps|
+          matches = requirements.all? do |key, required_value|
+            case key
+            when :min_context_window
+              caps[:context_window] && caps[:context_window] >= required_value
+            when :max_context_window
+              caps[:context_window] && caps[:context_window] <= required_value
+            when :reasoning_tier
+              caps[:reasoning_tiers]&.include?(required_value)
+            else
+              # Exact match for boolean and other values
+              caps[key] == required_value
+            end
+          end
+
+          matching << provider_name if matches
+        end
+
+        matching
+      end
+
+      # Get all registered providers
+      # @return [Array<String>] array of provider names
+      def registered_providers
+        @providers.keys
+      end
+
+      # Get detailed information about all registered providers
+      # @return [Hash] provider information indexed by provider name
+      def provider_info
+        info = {}
+
+        @providers.each do |provider_name, provider|
+          caps = @capabilities[provider_name] || {}
+
+          info[provider_name] = {
+            display_name: provider.display_name,
+            available: provider.available?,
+            capabilities: caps,
+            dangerous_mode_enabled: provider.dangerous_mode_enabled?,
+            health_status: provider.health_status
+          }
+        end
+
+        info
+      end
+
+      # Check capability compatibility between providers
+      # @param provider_name1 [String] first provider
+      # @param provider_name2 [String] second provider
+      # @return [Hash] compatibility report
+      def compatibility_report(provider_name1, provider_name2)
+        caps1 = @capabilities[provider_name1]
+        caps2 = @capabilities[provider_name2]
+
+        return {error: "Provider not found"} unless caps1 && caps2
+
+        common = {}
+        differences = {}
+
+        all_keys = (caps1.keys + caps2.keys).uniq
+
+        all_keys.each do |key|
+          val1 = caps1[key]
+          val2 = caps2[key]
+
+          if val1 == val2
+            common[key] = val1
+          else
+            differences[key] = {provider_name1 => val1, provider_name2 => val2}
+          end
+        end
+
+        {
+          common_capabilities: common,
+          differences: differences,
+          compatibility_score: common.size.to_f / all_keys.size
+        }
+      end
+
+      # Get capability statistics across all providers
+      # @return [Hash] statistics about capability support
+      def capability_statistics
+        stats = {}
+
+        CAPABILITY_KEYS.each do |key|
+          stats[key] = {
+            total_providers: @providers.size,
+            supporting_providers: 0,
+            providers: []
+          }
+        end
+
+        @capabilities.each do |provider_name, caps|
+          caps.each do |key, value|
+            next unless stats.key?(key)
+
+            if value.is_a?(TrueClass) || (value.is_a?(Array) && !value.empty?) || (value.is_a?(Integer) && value > 0)
+              stats[key][:supporting_providers] += 1
+              stats[key][:providers] << provider_name
+            end
+          end
+        end
+
+        stats
+      end
+
+      # Clear all registered providers
+      # @return [void]
+      def clear
+        @capabilities.clear
+        @providers.clear
+      end
+    end
+  end
+end

data/lib/aidp/providers/codex.rb

@@ -79,6 +79,20 @@ module Aidp
             args += ["--session", session]
           end
 
+          # In devcontainer, ensure sandbox mode and approval policy are set
+          # These are already set via environment variables in devcontainer.json
+          # but we verify and log them here for visibility
+          if in_devcontainer_or_codespace?
+            unless ENV["CODEX_SANDBOX_MODE"] == "danger-full-access"
+              ENV["CODEX_SANDBOX_MODE"] = "danger-full-access"
+              debug_log("🔓 Set CODEX_SANDBOX_MODE=danger-full-access for devcontainer", level: :info)
+            end
+            unless ENV["CODEX_APPROVAL_POLICY"] == "never"
+              ENV["CODEX_APPROVAL_POLICY"] = "never"
+              debug_log("🔓 Set CODEX_APPROVAL_POLICY=never for devcontainer", level: :info)
+            end
+          end
+
           # Use debug_execute_command for better debugging
           result = debug_execute_command("codex", args: args, timeout: timeout_seconds, streaming: streaming_enabled)
 

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