aidp 0.34.1 → 0.39.3

data/lib/aidp/providers/capability_registry.rb

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

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-require_relative "base"
-require_relative "../util"
-require_relative "../debug_mixin"
-
-module Aidp
-  module Providers
-    class Codex < Base
-      include Aidp::DebugMixin
-
-      # Model name pattern for OpenAI models (since Codex uses OpenAI)
-      MODEL_PATTERN = /^gpt-[\d.o-]+(?:-turbo)?(?:-mini)?$/i
-      LONG_PROMPT_THRESHOLD = 8000
-      LONG_PROMPT_TIMEOUT = 900 # 15 minutes for large prompts
-
-      def self.available?
-        !!Aidp::Util.which("codex")
-      end
-
-      # Check if this provider supports a given model family
-      #
-      # @param family_name [String] The model family name
-      # @return [Boolean] True if it matches OpenAI model pattern
-      def self.supports_model_family?(family_name)
-        MODEL_PATTERN.match?(family_name)
-      end
-
-      # Discover available models from registry
-      #
-      # Note: Codex CLI doesn't have a standard model listing command
-      # Returns registry-based models that match OpenAI patterns
-      #
-      # @return [Array<Hash>] Array of discovered models
-      def self.discover_models
-        return [] unless available?
-
-        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
-
-      def display_name
-        "Codex CLI"
-      end
-
-      def available?
-        return false unless self.class.available?
-
-        # Additional check to ensure the CLI is properly configured
-        begin
-          result = Aidp::Util.execute_command("codex", ["--version"], timeout: 10)
-          result.exit_status == 0
-        rescue
-          false
-        end
-      end
-
-      def send_message(prompt:, session: nil, options: {})
-        raise "codex CLI not available" unless self.class.available?
-
-        # Smart timeout calculation (store prompt length for adaptive logic)
-        @current_codex_prompt_length = prompt.length
-        timeout_seconds = calculate_timeout
-
-        debug_provider("codex", "Starting execution", {timeout: timeout_seconds})
-        debug_log("📝 Sending prompt to codex (length: #{prompt.length})", level: :info)
-
-        # Set up activity monitoring
-        setup_activity_monitoring("codex", method(:activity_callback))
-        record_activity("Starting codex 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, "🤖 Codex CLI")
-          end
-        end
-
-        begin
-          # 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]
-          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)
-
-          # Log the results
-          debug_command("codex", 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("codex failed with exit code #{result.exit_status}")
-            debug_error(StandardError.new("codex failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "codex failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue => e
-          spinner&.error("✗")
-          mark_failed("codex execution failed: #{e.message}")
-          debug_error(e, {provider: "codex", prompt_length: prompt.length})
-          raise
-        ensure
-          cleanup_activity_display(activity_display_thread, spinner)
-          @current_codex_prompt_length = nil
-        end
-      end
-
-      # Enhanced send method with additional options
-      def send_with_options(prompt:, session: nil, model: nil, ask_for_approval: false)
-        args = ["exec", prompt]
-
-        # Add session support
-        if session && !session.empty?
-          args += ["--session", session]
-        end
-
-        # 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
-        if ask_for_approval
-          debug_log("⚠️  WARNING: --ask-for-approval flag may cause interactive prompts that could hang AIDP", level: :warn)
-          args += ["--ask-for-approval"]
-        end
-
-        # Use the enhanced version of send
-        send_with_custom_args(prompt: prompt, args: args)
-      end
-
-      # Override health check for Codex specific considerations
-      def harness_healthy?
-        return false unless super
-
-        # Additional health checks specific to Codex CLI
-        # Check if we can access the CLI (basic connectivity test)
-        begin
-          result = Aidp::Util.execute_command("codex", ["--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_codex_prompt_length = prompt.length
-        timeout_seconds = calculate_timeout
-
-        debug_provider("codex", "Starting execution", {timeout: timeout_seconds, args: args})
-        debug_log("📝 Sending prompt to codex with custom args", level: :info)
-
-        setup_activity_monitoring("codex", method(:activity_callback))
-        record_activity("Starting codex execution with custom args")
-
-        begin
-          result = debug_execute_command("codex", args: args, timeout: timeout_seconds)
-          debug_command("codex", 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("codex failed with exit code #{result.exit_status}")
-            debug_error(StandardError.new("codex failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "codex failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue => e
-          mark_failed("codex execution failed: #{e.message}")
-          debug_error(e, {provider: "codex", prompt_length: prompt.length})
-          raise
-        ensure
-          @current_codex_prompt_length = nil
-        end
-      end
-
-      def activity_callback(state, message, provider)
-        # Handle activity state changes
-        case state
-        when :stuck
-          display_message("\n⚠️  Codex CLI appears stuck: #{message}", type: :warning)
-        when :completed
-          display_message("\n✅ Codex CLI completed: #{message}", type: :success)
-        when :failed
-          display_message("\n❌ Codex CLI failed: #{message}", type: :error)
-        end
-      end
-
-      def calculate_timeout
-        env_override = ENV["AIDP_CODEX_TIMEOUT"]
-        return env_override.to_i if env_override&.match?(/^\d+$/)
-
-        base_timeout = super
-
-        prompt_length = @current_codex_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("⏱️  Codex prompt length #{prompt_length} detected - extending timeout to #{extended_timeout} seconds", type: :info)
-        end
-        extended_timeout
-      end
-    end
-  end
-end