aidp 0.5.0 → 0.8.0

data/lib/aidp/provider_manager.rb

@@ -1,9 +1,138 @@
 # frozen_string_literal: true
 
+require_relative "harness/provider_factory"
+
 module Aidp
   class ProviderManager
     class << self
-      def get_provider(provider_type)
+      def get_provider(provider_type, options = {})
+        # Use harness factory if available
+        if options[:use_harness] != false
+          factory = get_harness_factory
+          return factory.create_provider(provider_type, options) if factory
+        end
+
+        # Fallback to legacy method
+        create_legacy_provider(provider_type)
+      end
+
+      def load_from_config(config = {}, options = {})
+        provider_type = config["provider"] || "cursor"
+        get_provider(provider_type, options)
+      end
+
+      # Get harness factory instance
+      def get_harness_factory
+        @harness_factory ||= begin
+          require_relative "harness/config_manager"
+          Aidp::Harness::ProviderFactory.new
+        rescue LoadError
+          nil
+        end
+      end
+
+      # Create provider using harness configuration
+      def create_harness_provider(provider_name, options = {})
+        factory = get_harness_factory
+        raise "Harness factory not available" unless factory
+
+        factory.create_provider(provider_name, options)
+      end
+
+      # Get all configured providers
+      def get_all_providers(options = {})
+        factory = get_harness_factory
+        return [] unless factory
+
+        factory.create_all_providers(options)
+      end
+
+      # Get providers by priority
+      def get_providers_by_priority(options = {})
+        factory = get_harness_factory
+        return [] unless factory
+
+        factory.create_providers_by_priority(options)
+      end
+
+      # Get enabled providers
+      def get_enabled_providers(options = {})
+        factory = get_harness_factory
+        return [] unless factory
+
+        enabled_names = factory.get_enabled_providers(options)
+        factory.create_providers(enabled_names, options)
+      end
+
+      # Check if provider is configured
+      def provider_configured?(provider_name, options = {})
+        factory = get_harness_factory
+        return false unless factory
+
+        factory.get_configured_providers(options).include?(provider_name.to_s)
+      end
+
+      # Check if provider is enabled
+      def provider_enabled?(provider_name, options = {})
+        factory = get_harness_factory
+        return false unless factory
+
+        factory.get_enabled_providers(options).include?(provider_name.to_s)
+      end
+
+      # Get provider capabilities
+      def get_provider_capabilities(provider_name, options = {})
+        factory = get_harness_factory
+        return [] unless factory
+
+        factory.get_provider_capabilities(provider_name, options)
+      end
+
+      # Check if provider supports feature
+      def provider_supports_feature?(provider_name, feature, options = {})
+        factory = get_harness_factory
+        return false unless factory
+
+        factory.provider_supports_feature?(provider_name, feature, options)
+      end
+
+      # Get provider models
+      def get_provider_models(provider_name, options = {})
+        factory = get_harness_factory
+        return [] unless factory
+
+        factory.get_provider_models(provider_name, options)
+      end
+
+      # Validate provider configuration
+      def validate_provider_config(provider_name, options = {})
+        factory = get_harness_factory
+        return ["Harness factory not available"] unless factory
+
+        factory.validate_provider_config(provider_name, options)
+      end
+
+      # Validate all provider configurations
+      def validate_all_provider_configs(options = {})
+        factory = get_harness_factory
+        return {} unless factory
+
+        factory.validate_all_provider_configs(options)
+      end
+
+      # Clear provider cache
+      def clear_cache
+        @harness_factory&.clear_cache
+      end
+
+      # Reload configuration
+      def reload_config
+        @harness_factory&.reload_config
+      end
+
+      private
+
+      def create_legacy_provider(provider_type)
         case provider_type
         when "cursor"
           Aidp::Providers::Cursor.new
@@ -12,14 +141,9 @@ module Aidp
         when "gemini"
           Aidp::Providers::Gemini.new
         when "macos_ui"
-          Aidp::Providers::MacosUI.new
+          Aidp::Providers::MacOSUI.new
         end
       end
-
-      def load_from_config(config = {})
-        provider_type = config["provider"] || "cursor"
-        get_provider(provider_type)
-      end
     end
   end
 end

data/lib/aidp/providers/anthropic.rb

@@ -1,113 +1,50 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../debug_mixin"
 
 module Aidp
   module Providers
     class Anthropic < Base
+      include Aidp::DebugMixin
+
       def self.available?
         !!Aidp::Util.which("claude")
       end
 
-      def name = "anthropic"
+      def name
+        "anthropic"
+      end
+
+      def available?
+        self.class.available?
+      end
 
       def send(prompt:, session: nil)
         raise "claude CLI not available" unless self.class.available?
 
-        require "open3"
-
-        # Use Claude CLI for non-interactive mode
-        cmd = ["claude", "--print"]
-
-        puts "📝 Sending prompt to claude..."
-
         # Smart timeout calculation
         timeout_seconds = calculate_timeout
 
-        Open3.popen3(*cmd) do |stdin, stdout, stderr, wait|
-          # Send the prompt to stdin
-          stdin.puts prompt
-          stdin.close
-
-          # Start stuck detection thread
-          stuck_detection_thread = Thread.new do
-            loop do
-              sleep 10 # Check every 10 seconds
-
-              if stuck?
-                puts "⚠️  claude appears stuck (no activity for #{stuck_timeout} seconds)"
-                puts "   You can:"
-                puts "   1. Wait longer (press Enter)"
-                puts "   2. Abort (Ctrl+C)"
-
-                # Give user a chance to respond
-                begin
-                  Timeout.timeout(30) do
-                    gets
-                    puts "🔄 Continuing to wait..."
-                  end
-                rescue Timeout::Error
-                  puts "⏰ No response received, continuing to wait..."
-                rescue Interrupt
-                  puts "🛑 Aborting claude..."
-                  Process.kill("TERM", wait.pid)
-                  raise Interrupt, "User aborted claude execution"
-                end
-              end
-
-              # Stop checking if the process is done
-              break if wait.value
-            rescue
-              break
-            end
-          end
+        debug_provider("claude", "Starting execution", {timeout: timeout_seconds})
+        debug_log("📝 Sending prompt to claude...", level: :info)
+
+        begin
+          # Use debug_execute_command for better debugging
+          result = debug_execute_command("claude", args: ["--print"], input: prompt, timeout: timeout_seconds)
 
-          # Wait for completion with timeout
-          begin
-            Timeout.timeout(timeout_seconds) do
-              result = wait.value
-
-              # Stop stuck detection thread
-              stuck_detection_thread&.kill
-
-              if result.success?
-                output = stdout.read
-                puts "✅ Claude analysis completed"
-                mark_completed
-                return output.empty? ? :ok : output
-              else
-                error_output = stderr.read
-                mark_failed("claude failed with exit code #{result.exitstatus}: #{error_output}")
-                raise "claude failed with exit code #{result.exitstatus}: #{error_output}"
-              end
-            end
-          rescue Timeout::Error
-            # Stop stuck detection thread
-            stuck_detection_thread&.kill
-
-            # Kill the process if it's taking too long
-            begin
-              Process.kill("TERM", wait.pid)
-            rescue
-              nil
-            end
-
-            mark_failed("claude timed out after #{timeout_seconds} seconds")
-            raise Timeout::Error, "claude timed out after #{timeout_seconds} seconds"
-          rescue Interrupt
-            # Stop stuck detection thread
-            stuck_detection_thread&.kill
-
-            # Kill the process
-            begin
-              Process.kill("TERM", wait.pid)
-            rescue
-              nil
-            end
-
-            mark_failed("claude execution was interrupted")
-            raise
+          # Log the results
+          debug_command("claude", args: ["--print"], input: prompt, output: result.out, error: result.err, exit_code: result.exit_status)
+
+          if result.exit_status == 0
+            result.out
+          else
+            debug_error(StandardError.new("claude failed"), {exit_code: result.exit_status, stderr: result.err})
+            raise "claude failed with exit code #{result.exit_status}: #{result.err}"
           end
+        rescue => e
+          debug_error(e, {provider: "claude", prompt_length: prompt.length})
+          raise
         end
       end
 
@@ -142,25 +79,7 @@ module Aidp
       end
 
       def get_adaptive_timeout
-        # Try to get timeout recommendations from metrics storage
-        begin
-          require_relative "../analyze/metrics_storage"
-          storage = Aidp::Analyze::MetricsStorage.new(Dir.pwd)
-          recommendations = storage.calculate_timeout_recommendations
-
-          # Get current step name from environment or context
-          step_name = ENV["AIDP_CURRENT_STEP"] || "unknown"
-
-          if recommendations[step_name]
-            recommended = recommendations[step_name][:recommended_timeout]
-            # Add 20% buffer for safety
-            return (recommended * 1.2).ceil
-          end
-        rescue => e
-          puts "⚠️  Could not get adaptive timeout: #{e.message}" if ENV["AIDP_DEBUG"]
-        end
-
-        # Fallback timeouts based on step type patterns
+        # Timeout recommendations based on step type patterns
         step_name = ENV["AIDP_CURRENT_STEP"] || ""
 
         case step_name

data/lib/aidp/providers/base.rb

@@ -27,6 +27,17 @@ module Aidp
         @output_count = 0
         @last_output_time = Time.now
         @job_context = nil
+        @harness_context = nil
+        @harness_metrics = {
+          total_requests: 0,
+          successful_requests: 0,
+          failed_requests: 0,
+          rate_limited_requests: 0,
+          total_tokens_used: 0,
+          total_cost: 0.0,
+          average_response_time: 0.0,
+          last_request_time: nil
+        }
       end
 
       def name
@@ -135,6 +146,141 @@ module Aidp
       # Get stuck timeout for this provider
       attr_reader :stuck_timeout
 
+      # Harness integration methods
+
+      # Set harness context for provider
+      def set_harness_context(harness_runner)
+        @harness_context = harness_runner
+      end
+
+      # Check if provider is operating in harness mode
+      def harness_mode?
+        !@harness_context.nil?
+      end
+
+      # Get harness metrics
+      def harness_metrics
+        @harness_metrics.dup
+      end
+
+      # Record harness request metrics
+      def record_harness_request(success:, tokens_used: 0, cost: 0.0, response_time: 0.0, rate_limited: false)
+        @harness_metrics[:total_requests] += 1
+        @harness_metrics[:last_request_time] = Time.now
+
+        if success
+          @harness_metrics[:successful_requests] += 1
+        else
+          @harness_metrics[:failed_requests] += 1
+        end
+
+        if rate_limited
+          @harness_metrics[:rate_limited_requests] += 1
+        end
+
+        @harness_metrics[:total_tokens_used] += tokens_used
+        @harness_metrics[:total_cost] += cost
+
+        # Update average response time
+        total_time = @harness_metrics[:average_response_time] * (@harness_metrics[:total_requests] - 1) + response_time
+        @harness_metrics[:average_response_time] = total_time / @harness_metrics[:total_requests]
+
+        # Notify harness context if available
+        @harness_context&.record_provider_metrics(name, @harness_metrics)
+      end
+
+      # Get provider health status for harness
+      def harness_health_status
+        {
+          provider: name,
+          activity_state: @activity_state,
+          stuck: stuck?,
+          success_rate: calculate_success_rate,
+          average_response_time: @harness_metrics[:average_response_time],
+          total_requests: @harness_metrics[:total_requests],
+          rate_limit_ratio: calculate_rate_limit_ratio,
+          last_activity: @last_activity_time,
+          health_score: calculate_health_score
+        }
+      end
+
+      # Check if provider is healthy for harness use
+      def harness_healthy?
+        return false if stuck?
+        return false if @harness_metrics[:total_requests] > 0 && calculate_success_rate < 0.5
+        return false if calculate_rate_limit_ratio > 0.3
+
+        true
+      end
+
+      # Get provider configuration for harness
+      def harness_config
+        {
+          name: name,
+          supports_activity_monitoring: supports_activity_monitoring?,
+          default_timeout: @stuck_timeout,
+          available: available?,
+          health_status: harness_health_status
+        }
+      end
+
+      # Check if provider is available (override in subclasses)
+      def available?
+        true # Default to true, override in subclasses
+      end
+
+      # Enhanced send method that integrates with harness
+      def send_with_harness(prompt:, session: nil, _options: {})
+        start_time = Time.now
+        success = false
+        rate_limited = false
+        tokens_used = 0
+        cost = 0.0
+        error_message = nil
+
+        begin
+          # Call the original send method
+          result = send(prompt: prompt, session: session)
+          success = true
+
+          # Extract token usage and cost if available
+          if result.is_a?(Hash) && result[:token_usage]
+            tokens_used = result[:token_usage][:total] || 0
+            cost = result[:token_usage][:cost] || 0.0
+          end
+
+          # Check for rate limiting in result
+          if result.is_a?(Hash) && result[:rate_limited]
+            rate_limited = true
+          end
+
+          result
+        rescue => e
+          error_message = e.message
+
+          # Check if error is rate limiting
+          if e.message.match?(/rate.?limit/i) || e.message.match?(/quota/i)
+            rate_limited = true
+          end
+
+          raise e
+        ensure
+          response_time = Time.now - start_time
+          record_harness_request(
+            success: success,
+            tokens_used: tokens_used,
+            cost: cost,
+            response_time: response_time,
+            rate_limited: rate_limited
+          )
+
+          # Log to harness context if available
+          if @harness_context && error_message
+            @harness_context.record_provider_error(name, error_message, rate_limited)
+          end
+        end
+      end
+
       protected
 
       # Log message to job if in background mode
@@ -157,6 +303,30 @@ module Aidp
           metadata
         )
       end
+
+      # Calculate success rate for harness metrics
+      def calculate_success_rate
+        return 1.0 if @harness_metrics[:total_requests] == 0
+        @harness_metrics[:successful_requests].to_f / @harness_metrics[:total_requests]
+      end
+
+      # Calculate rate limit ratio for harness metrics
+      def calculate_rate_limit_ratio
+        return 0.0 if @harness_metrics[:total_requests] == 0
+        @harness_metrics[:rate_limited_requests].to_f / @harness_metrics[:total_requests]
+      end
+
+      # Calculate overall health score for harness
+      def calculate_health_score
+        return 100.0 if @harness_metrics[:total_requests] == 0
+
+        success_rate = calculate_success_rate
+        rate_limit_ratio = calculate_rate_limit_ratio
+        response_time_score = [100 - (@harness_metrics[:average_response_time] * 10), 0].max
+
+        # Weighted health score
+        (success_rate * 50) + ((1 - rate_limit_ratio) * 30) + (response_time_score * 0.2)
+      end
     end
   end
 end