aidp 0.26.0 → 0.27.0

data/lib/aidp/providers/cursor.rb

@@ -14,6 +14,76 @@ module Aidp
         !!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
+
+      # 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
@@ -40,12 +110,6 @@ module Aidp
         debug_provider("cursor", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to cursor-agent (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 (cursor-agent does not support true streaming)", type: :info)
-        end
-
         # Set up activity monitoring
         setup_activity_monitoring("cursor-agent", method(:activity_callback))
         record_activity("Starting cursor-agent execution")
@@ -71,7 +135,7 @@ module Aidp
           # 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, streaming: streaming_enabled)
+          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)
@@ -98,58 +162,6 @@ 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
-
-        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_CURSOR_TIMEOUT"]
-          return ENV["AIDP_CURSOR_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

data/lib/aidp/providers/gemini.rb

@@ -8,10 +8,53 @@ module Aidp
     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
+
       def name
         "gemini"
       end
@@ -29,16 +72,9 @@ module Aidp
         debug_provider("gemini", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to gemini...", 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 (gemini CLI does not support true streaming)", type: :info)
-        end
-
         begin
           command_args = ["--prompt", prompt]
-          # Use debug_execute_command with streaming support
-          result = debug_execute_command("gemini", args: command_args, timeout: timeout_seconds, streaming: streaming_enabled)
+          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)
@@ -56,58 +92,6 @@ module Aidp
       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_GEMINI_TIMEOUT"]
-          return ENV["AIDP_GEMINI_TIMEOUT"].to_i
-        end
-
-        # Adaptive timeout based on step type
-        step_timeout = get_adaptive_timeout
-        if step_timeout
-          display_message("🧠 Using adaptive timeout: #{step_timeout} seconds", type: :info)
-          return step_timeout
-        end
-
-        # Default timeout
-        display_message("📋 Using default timeout: #{TIMEOUT_DEFAULT / 60} minutes", type: :info)
-        TIMEOUT_DEFAULT
-      end
-
-      def get_adaptive_timeout
-        # 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
   end
 end

data/lib/aidp/providers/github_copilot.rb

@@ -43,12 +43,6 @@ module Aidp
         debug_provider("copilot", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to copilot (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 (copilot CLI does not support true streaming)", type: :info)
-        end
-
         # Set up activity monitoring
         setup_activity_monitoring("copilot", method(:activity_callback))
         record_activity("Starting copilot execution")
@@ -80,7 +74,7 @@ module Aidp
           end
 
           # Use debug_execute_command for better debugging (no input since prompt is in args)
-          result = debug_execute_command("copilot", args: args, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("copilot", args: args, timeout: timeout_seconds)
 
           # Log the results
           debug_command("copilot", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
@@ -178,17 +172,11 @@ module Aidp
         debug_provider("copilot", "Starting execution", {timeout: timeout_seconds, args: args})
         debug_log("📝 Sending prompt to copilot with custom args", 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 (copilot CLI does not support true streaming)", type: :info)
-        end
-
         setup_activity_monitoring("copilot", method(:activity_callback))
         record_activity("Starting copilot execution with custom args")
 
         begin
-          result = debug_execute_command("copilot", args: args, timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("copilot", args: args, timeout: timeout_seconds)
           debug_command("copilot", args: args, output: result.out, error: result.err, exit_code: result.exit_status)
 
           if result.exit_status == 0
@@ -206,58 +194,6 @@ module Aidp
         end
       end
 
-      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_GITHUB_COPILOT_TIMEOUT"]
-          return ENV["AIDP_GITHUB_COPILOT_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)
         # Handle activity state changes
         case state

data/lib/aidp/providers/kilocode.rb

@@ -10,10 +10,33 @@ module Aidp
     class Kilocode < Base
       include Aidp::DebugMixin
 
+      # Model name pattern for OpenAI models (since Kilocode uses OpenAI)
+      MODEL_PATTERN = /^gpt-[\d.o-]+(?:-turbo)?(?:-mini)?$/i
+
       def self.available?
         !!Aidp::Util.which("kilocode")
       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: Kilocode 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, "kilocode")
+      end
+
       def name
         "kilocode"
       end
@@ -31,12 +54,6 @@ module Aidp
         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)
@@ -85,7 +102,7 @@ module Aidp
           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)
+          result = debug_execute_command("kilocode", args: args, input: prompt, timeout: timeout_seconds, env: env_vars)
 
           # Log the results
           debug_command("kilocode", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
@@ -112,58 +129,6 @@ 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
-
-        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
@@ -176,27 +141,6 @@ module Aidp
           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/providers/opencode.rb

@@ -10,10 +10,33 @@ module Aidp
     class Opencode < Base
       include Aidp::DebugMixin
 
+      # Model name pattern for OpenAI models (since OpenCode uses OpenAI)
+      MODEL_PATTERN = /^gpt-[\d.o-]+(?:-turbo)?(?:-mini)?$/i
+
       def self.available?
         !!Aidp::Util.which("opencode")
       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: OpenCode 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, "opencode")
+      end
+
       def name
         "opencode"
       end
@@ -31,12 +54,6 @@ module Aidp
         debug_provider("opencode", "Starting execution", {timeout: timeout_seconds})
         debug_log("📝 Sending prompt to opencode (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 (opencode does not support true streaming)", 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)
@@ -67,7 +84,7 @@ module Aidp
           # Use debug_execute_command for better debugging
           # opencode run command with prompt and model
           model = ENV["OPENCODE_MODEL"] || "github-copilot/claude-3.5-sonnet"
-          result = debug_execute_command("opencode", args: ["run", "-m", model, prompt], timeout: timeout_seconds, streaming: streaming_enabled)
+          result = debug_execute_command("opencode", args: ["run", "-m", model, prompt], timeout: timeout_seconds)
 
           # Log the results
           debug_command("opencode", args: ["run", "-m", model, prompt], input: nil, output: result.out, error: result.err, exit_code: result.exit_status)
@@ -94,58 +111,6 @@ 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
-
-        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_OPENCODE_TIMEOUT"]
-          return ENV["AIDP_OPENCODE_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
@@ -158,27 +123,6 @@ module Aidp
           display_message("❌ opencode 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, "opencode")
-      end
-
-      def mark_completed
-        @activity_state = :completed
-        @activity_callback&.call(:completed, "Execution completed", "opencode")
-      end
-
-      def mark_failed(reason)
-        @activity_state = :failed
-        @activity_callback&.call(:failed, reason, "opencode")
-      end
     end
   end
 end