aidp 0.34.1 → 0.39.3

data/lib/aidp/providers/github_copilot.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-require_relative "base"
-require_relative "../util"
-require_relative "../debug_mixin"
-
-module Aidp
-  module Providers
-    class GithubCopilot < Base
-      include Aidp::DebugMixin
-
-      def self.available?
-        !!Aidp::Util.which("copilot")
-      end
-
-      # Get firewall requirements for GitHub Copilot provider
-      def self.firewall_requirements
-        {
-          domains: [
-            "copilot-proxy.githubusercontent.com",
-            "api.githubcopilot.com",
-            "copilot-telemetry.githubusercontent.com",
-            "default.exp-tas.com",
-            "copilot-completions.githubusercontent.com",
-            "business.githubcopilot.com",
-            "enterprise.githubcopilot.com",
-            "individual.githubcopilot.com"
-          ],
-          ip_ranges: []
-        }
-      end
-
-      def name
-        "github_copilot"
-      end
-
-      def display_name
-        "GitHub Copilot 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("copilot", ["--version"], timeout: 10)
-          result.exit_status == 0
-        rescue
-          false
-        end
-      end
-
-      def send_message(prompt:, session: nil, options: {})
-        raise "copilot CLI not available" unless self.class.available?
-
-        # Smart timeout calculation
-        timeout_seconds = calculate_timeout
-
-        debug_provider("copilot", "Starting execution", {timeout: timeout_seconds})
-        debug_log("📝 Sending prompt to copilot (length: #{prompt.length})", level: :info)
-
-        # Set up activity monitoring
-        setup_activity_monitoring("copilot", method(:activity_callback))
-        record_activity("Starting copilot 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, "🤖 GitHub Copilot CLI")
-          end
-        end
-
-        begin
-          # Use non-interactive mode for automation
-          args = ["-p", prompt, "--allow-all-tools"]
-
-          # Add session support if provided
-          if session && !session.empty?
-            args += ["--resume", session]
-          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)
-
-          # Log the results
-          debug_command("copilot", args: args, input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
-
-          # Detect authorization/access errors
-          auth_error = result.err.to_s =~ /not authorized|requires an enterprise|access denied|permission denied|not enabled/i
-          if auth_error
-            spinner.error("✗")
-            mark_failed("copilot authorization error: #{result.err}")
-            @unavailable = true
-            debug_error(StandardError.new("copilot authorization error"), {exit_code: result.exit_status, stderr: result.err})
-            raise Aidp::Providers::ProviderUnavailableError.new("copilot authorization error: #{result.err}")
-          end
-
-          if result.exit_status == 0
-            spinner.success("✓")
-            mark_completed
-            result.out
-          else
-            spinner.error("✗")
-            mark_failed("copilot failed with exit code #{result.exit_status}")
-            debug_error(StandardError.new("copilot failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "copilot failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue Aidp::Providers::ProviderUnavailableError
-          raise
-        rescue => e
-          spinner&.error("✗")
-          mark_failed("copilot execution failed: #{e.message}")
-          debug_error(e, {provider: "github_copilot", prompt_length: prompt.length})
-          raise
-        ensure
-          cleanup_activity_display(activity_display_thread, spinner)
-        end
-      end
-
-      # Enhanced send method with additional options
-      def send_with_options(prompt:, session: nil, tools: nil, log_level: nil, config_file: nil, directories: nil)
-        args = ["-p", prompt]
-
-        # Add session support
-        if session && !session.empty?
-          args += ["--resume", session]
-        end
-
-        # Add tool permissions
-        if tools && !tools.empty?
-          if tools.include?("all")
-            args += ["--allow-all-tools"]
-          else
-            tools.each do |tool|
-              args += ["--allow-tool", tool]
-            end
-          end
-        else
-          # Default to allowing all tools for automation
-          args += ["--allow-all-tools"]
-        end
-
-        # Add logging level
-        if log_level
-          args += ["--log-level", log_level]
-        end
-
-        # Add allowed directories
-        if directories && !directories.empty?
-          directories.each do |dir|
-            args += ["--add-dir", dir]
-          end
-        end
-
-        # Use the enhanced version of send
-        send_with_custom_args(prompt: prompt, args: args)
-      end
-
-      # Override health check for GitHub Copilot specific considerations
-      def harness_healthy?
-        return false unless super
-
-        # Additional health checks specific to GitHub Copilot CLI
-        # Check if we can access GitHub (basic connectivity test)
-        begin
-          result = Aidp::Util.execute_command("copilot", ["--help"], timeout: 5)
-          result.exit_status == 0
-        rescue
-          false
-        end
-      end
-
-      private
-
-      def send_with_custom_args(prompt:, args:)
-        timeout_seconds = calculate_timeout
-
-        debug_provider("copilot", "Starting execution", {timeout: timeout_seconds, args: args})
-        debug_log("📝 Sending prompt to copilot with custom args", level: :info)
-
-        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)
-          debug_command("copilot", 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("copilot failed with exit code #{result.exit_status}")
-            debug_error(StandardError.new("copilot failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "copilot failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue => e
-          mark_failed("copilot execution failed: #{e.message}")
-          debug_error(e, {provider: "github_copilot", prompt_length: prompt.length})
-          raise
-        end
-      end
-
-      def activity_callback(state, message, provider)
-        # Handle activity state changes
-        case state
-        when :stuck
-          display_message("\n⚠️  GitHub Copilot CLI appears stuck: #{message}", type: :warning)
-        when :completed
-          display_message("\n✅ GitHub Copilot CLI completed: #{message}", type: :success)
-        when :failed
-          display_message("\n❌ GitHub Copilot CLI failed: #{message}", type: :error)
-        end
-      end
-    end
-  end
-end

data/lib/aidp/providers/kilocode.rb

@@ -1,157 +0,0 @@
-# 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
-
-      # 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
-
-      # Get firewall requirements for Kilocode provider
-      def self.firewall_requirements
-        {
-          domains: [
-            "kilocode.ai",
-            "api.kilocode.ai"
-          ],
-          ip_ranges: []
-        }
-      end
-
-      def name
-        "kilocode"
-      end
-
-      def display_name
-        "Kilocode"
-      end
-
-      def send_message(prompt:, session: nil, options: {})
-        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 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, 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 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
-    end
-  end
-end

data/lib/aidp/providers/opencode.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require "timeout"
-require_relative "base"
-require_relative "../util"
-require_relative "../debug_mixin"
-
-module Aidp
-  module Providers
-    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
-
-      # Get firewall requirements for OpenCode provider
-      def self.firewall_requirements
-        {
-          domains: [
-            "api.opencode.ai",
-            "auth.opencode.ai"
-          ],
-          ip_ranges: []
-        }
-      end
-
-      def name
-        "opencode"
-      end
-
-      def display_name
-        "OpenCode"
-      end
-
-      def send_message(prompt:, session: nil, options: {})
-        raise "opencode not available" unless self.class.available?
-
-        # Smart timeout calculation
-        timeout_seconds = calculate_timeout
-
-        debug_provider("opencode", "Starting execution", {timeout: timeout_seconds})
-        debug_log("📝 Sending prompt to opencode (length: #{prompt.length})", level: :info)
-
-        # 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("opencode", method(:activity_callback))
-        record_activity("Starting opencode 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, "🔄 opencode")
-          end
-        end
-
-        begin
-          # 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)
-
-          # Log the results
-          debug_command("opencode", args: ["run", "-m", model, prompt], input: nil, 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("opencode failed with exit code #{result.exit_status}")
-            debug_error(StandardError.new("opencode failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "opencode failed with exit code #{result.exit_status}: #{result.err}"
-          end
-        rescue => e
-          spinner&.error("✗")
-          mark_failed("opencode execution failed: #{e.message}")
-          debug_error(e, {provider: "opencode", 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 :starting
-          display_message("🚀 Starting opencode execution...", type: :info)
-        when :completed
-          display_message("✅ opencode execution completed", type: :success)
-        when :failed
-          display_message("❌ opencode execution failed: #{message}", type: :error)
-        end
-      end
-    end
-  end
-end