agent-harness 0.2.1

data/lib/agent_harness/orchestration/provider_manager.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  module Orchestration
+    # Manages provider instances and selection
+    #
+    # Handles provider lifecycle, health tracking, circuit breakers,
+    # and rate limiters. Provides intelligent provider selection based
+    # on availability and health.
+    class ProviderManager
+      attr_reader :current_provider, :provider_instances
+
+      # Create a new provider manager
+      #
+      # @param config [Configuration] the configuration
+      def initialize(config)
+        @config = config
+        @registry = Providers::Registry.instance
+        @provider_instances = {}
+        @current_provider = config.default_provider
+
+        @circuit_breakers = {}
+        @rate_limiters = {}
+        @health_monitor = HealthMonitor.new(config.orchestration_config.health_check_config)
+        @fallback_chains = {}
+
+        initialize_providers
+      end
+
+      # Select best available provider
+      #
+      # @param preferred [Symbol, nil] preferred provider name
+      # @return [Providers::Base] selected provider instance
+      # @raise [NoProvidersAvailableError] if no providers available
+      def select_provider(preferred = nil)
+        preferred ||= @current_provider
+
+        # Check circuit breaker
+        if circuit_open?(preferred)
+          return select_fallback(preferred, reason: :circuit_open)
+        end
+
+        # Check rate limit
+        if rate_limited?(preferred)
+          return select_fallback(preferred, reason: :rate_limited)
+        end
+
+        # Check health
+        unless healthy?(preferred)
+          return select_fallback(preferred, reason: :unhealthy)
+        end
+
+        get_provider(preferred)
+      end
+
+      # Get or create provider instance
+      #
+      # @param name [Symbol, String] the provider name
+      # @return [Providers::Base] the provider instance
+      def get_provider(name)
+        name = name.to_sym
+        @provider_instances[name] ||= create_provider(name)
+      end
+
+      # Switch to next available provider
+      #
+      # @param reason [Symbol, String] reason for switch
+      # @param context [Hash] additional context
+      # @return [Providers::Base, nil] new provider or nil if none available
+      def switch_provider(reason:, context: {})
+        old_provider = @current_provider
+
+        fallback = select_fallback(@current_provider, reason: reason)
+        return nil unless fallback
+
+        @current_provider = fallback.class.provider_name
+
+        AgentHarness.logger&.info(
+          "[AgentHarness] Provider switch: #{old_provider} -> #{@current_provider} (#{reason})"
+        )
+
+        @config.callbacks.emit(:provider_switch, {
+          from: old_provider,
+          to: @current_provider,
+          reason: reason,
+          context: context
+        })
+
+        fallback
+      end
+
+      # Record success for provider
+      #
+      # @param provider_name [Symbol, String] the provider name
+      # @return [void]
+      def record_success(provider_name)
+        provider_name = provider_name.to_sym
+        @health_monitor.record_success(provider_name)
+        @circuit_breakers[provider_name]&.record_success
+      end
+
+      # Record failure for provider
+      #
+      # @param provider_name [Symbol, String] the provider name
+      # @return [void]
+      def record_failure(provider_name)
+        provider_name = provider_name.to_sym
+        @health_monitor.record_failure(provider_name)
+        @circuit_breakers[provider_name]&.record_failure
+      end
+
+      # Mark provider as rate limited
+      #
+      # @param provider_name [Symbol, String] the provider name
+      # @param reset_at [Time, nil] when the limit resets
+      # @return [void]
+      def mark_rate_limited(provider_name, reset_at: nil)
+        provider_name = provider_name.to_sym
+        @rate_limiters[provider_name]&.mark_limited(reset_at: reset_at)
+      end
+
+      # Get available providers
+      #
+      # @return [Array<Symbol>] available provider names
+      def available_providers
+        @provider_instances.keys.select do |name|
+          !circuit_open?(name) && !rate_limited?(name) && healthy?(name)
+        end
+      end
+
+      # Get health status for all providers
+      #
+      # @return [Array<Hash>] health status for each provider
+      def health_status
+        @provider_instances.keys.map do |name|
+          {
+            provider: name,
+            healthy: healthy?(name),
+            circuit_open: circuit_open?(name),
+            rate_limited: rate_limited?(name),
+            metrics: @health_monitor.metrics_for(name)
+          }
+        end
+      end
+
+      # Reset all state
+      #
+      # @return [void]
+      def reset!
+        @circuit_breakers.each_value(&:reset!)
+        @rate_limiters.each_value(&:reset!)
+        @health_monitor.reset!
+        @current_provider = @config.default_provider
+      end
+
+      # Check if circuit is open for provider
+      #
+      # @param provider_name [Symbol, String] the provider name
+      # @return [Boolean] true if open
+      def circuit_open?(provider_name)
+        @circuit_breakers[provider_name.to_sym]&.open? || false
+      end
+
+      # Check if provider is rate limited
+      #
+      # @param provider_name [Symbol, String] the provider name
+      # @return [Boolean] true if limited
+      def rate_limited?(provider_name)
+        @rate_limiters[provider_name.to_sym]&.limited? || false
+      end
+
+      # Check if provider is healthy
+      #
+      # @param provider_name [Symbol, String] the provider name
+      # @return [Boolean] true if healthy
+      def healthy?(provider_name)
+        @health_monitor.healthy?(provider_name.to_sym)
+      end
+
+      private
+
+      def initialize_providers
+        @config.providers.each do |name, provider_config|
+          next unless provider_config.enabled
+
+          @circuit_breakers[name] = CircuitBreaker.new(
+            @config.orchestration_config.circuit_breaker_config
+          )
+
+          @rate_limiters[name] = RateLimiter.new(
+            @config.orchestration_config.rate_limit_config
+          )
+
+          @fallback_chains[name] = build_fallback_chain(name)
+        end
+      end
+
+      def create_provider(name)
+        klass = @registry.get(name)
+        config = @config.providers[name]
+
+        klass.new(
+          config: config,
+          executor: @config.command_executor,
+          logger: AgentHarness.logger
+        )
+      end
+
+      def select_fallback(provider_name, reason:)
+        chain = @fallback_chains[provider_name] || build_fallback_chain(provider_name)
+
+        chain.each do |fallback_name|
+          next if fallback_name == provider_name
+          next if circuit_open?(fallback_name)
+          next if rate_limited?(fallback_name)
+          next unless healthy?(fallback_name)
+
+          AgentHarness.logger&.debug(
+            "[AgentHarness::ProviderManager] Falling back from #{provider_name} to #{fallback_name} (#{reason})"
+          )
+
+          return get_provider(fallback_name)
+        end
+
+        # No fallback available
+        raise NoProvidersAvailableError.new(
+          "No providers available after #{provider_name} (#{reason})",
+          attempted_providers: chain,
+          errors: {provider_name => reason.to_s}
+        )
+      end
+
+      def build_fallback_chain(provider_name)
+        chain = [provider_name] + @config.fallback_providers
+        chain += @config.providers.keys
+        chain.uniq
+      end
+    end
+  end
+end

data/lib/agent_harness/orchestration/rate_limiter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  module Orchestration
+    # Rate limiter for tracking and managing provider rate limits
+    #
+    # Tracks rate limit events and provides information about when
+    # providers are expected to be available again.
+    #
+    # @example
+    #   limiter = RateLimiter.new
+    #   limiter.mark_limited(reset_at: Time.now + 3600)
+    #   limiter.limited? # => true
+    class RateLimiter
+      attr_reader :limited_until, :limit_count
+
+      # Create a new rate limiter
+      #
+      # @param config [RateLimitConfig, nil] configuration object
+      # @param default_reset_time [Integer] default seconds until reset
+      def initialize(config = nil, default_reset_time: nil)
+        if config
+          @enabled = config.enabled
+          @default_reset_time = config.default_reset_time
+        else
+          @enabled = true
+          @default_reset_time = default_reset_time || 3600
+        end
+
+        reset!
+      end
+
+      # Check if currently rate limited
+      #
+      # @return [Boolean] true if rate limited
+      def limited?
+        return false unless @enabled
+        return false unless @limited_until
+
+        if Time.now >= @limited_until
+          clear_limit
+          false
+        else
+          true
+        end
+      end
+
+      # Mark as rate limited
+      #
+      # @param reset_at [Time, nil] when the limit resets
+      # @param reset_in [Integer, nil] seconds until reset
+      # @return [void]
+      def mark_limited(reset_at: nil, reset_in: nil)
+        @mutex.synchronize do
+          @limit_count += 1
+
+          @limited_until = if reset_at
+            reset_at
+          elsif reset_in
+            Time.now + reset_in
+          else
+            Time.now + @default_reset_time
+          end
+
+          AgentHarness.logger&.warn(
+            "[AgentHarness::RateLimiter] Rate limited until #{@limited_until}"
+          )
+        end
+      end
+
+      # Clear rate limit status
+      #
+      # @return [void]
+      def clear_limit
+        @mutex.synchronize do
+          @limited_until = nil
+        end
+      end
+
+      # Get time until limit resets
+      #
+      # @return [Integer, nil] seconds until reset, or nil if not limited
+      def time_until_reset
+        return nil unless @limited_until
+
+        remaining = @limited_until - Time.now
+        remaining.positive? ? remaining.to_i : 0
+      end
+
+      # Reset the rate limiter
+      #
+      # @return [void]
+      def reset!
+        @mutex = Mutex.new
+        @limited_until = nil
+        @limit_count = 0
+      end
+
+      # Get rate limiter status
+      #
+      # @return [Hash] status information
+      def status
+        {
+          limited: limited?,
+          limited_until: @limited_until,
+          time_until_reset: time_until_reset,
+          limit_count: @limit_count,
+          enabled: @enabled
+        }
+      end
+    end
+  end
+end

data/lib/agent_harness/providers/adapter.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  module Providers
+    # Interface that all providers must implement
+    #
+    # This module defines the contract that provider implementations must follow.
+    # Include this module in provider classes to ensure they implement the required interface.
+    #
+    # @example Implementing a provider
+    #   class MyProvider < AgentHarness::Providers::Base
+    #     include AgentHarness::Providers::Adapter
+    #
+    #     def self.provider_name
+    #       :my_provider
+    #     end
+    #   end
+    module Adapter
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Class methods that all providers must implement
+      module ClassMethods
+        # Human-readable provider name
+        #
+        # @return [Symbol] unique identifier for this provider
+        def provider_name
+          raise NotImplementedError, "#{self} must implement .provider_name"
+        end
+
+        # Check if provider CLI is available on the system
+        #
+        # @return [Boolean] true if the CLI is installed and accessible
+        def available?
+          raise NotImplementedError, "#{self} must implement .available?"
+        end
+
+        # CLI binary name
+        #
+        # @return [String] the name of the CLI binary
+        def binary_name
+          raise NotImplementedError, "#{self} must implement .binary_name"
+        end
+
+        # Required domains for firewall configuration
+        #
+        # @return [Hash] with :domains and :ip_ranges arrays
+        def firewall_requirements
+          {domains: [], ip_ranges: []}
+        end
+
+        # Paths to instruction files (e.g., CLAUDE.md, .cursorrules)
+        #
+        # @return [Array<Hash>] instruction file configurations
+        def instruction_file_paths
+          []
+        end
+
+        # Discover available models
+        #
+        # @return [Array<Hash>] list of available models
+        def discover_models
+          []
+        end
+      end
+
+      # Instance methods
+
+      # Send a message/prompt to the provider
+      #
+      # @param prompt [String] the prompt to send
+      # @param options [Hash] provider-specific options
+      # @option options [String] :model model to use
+      # @option options [Integer] :timeout timeout in seconds
+      # @option options [String] :session session identifier
+      # @option options [Boolean] :dangerous_mode skip permission checks
+      # @return [Response] response object with output and metadata
+      def send_message(prompt:, **options)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # Provider capabilities
+      #
+      # @return [Hash] capability flags
+      def capabilities
+        {
+          streaming: false,
+          file_upload: false,
+          vision: false,
+          tool_use: false,
+          json_mode: false,
+          mcp: false,
+          dangerous_mode: false
+        }
+      end
+
+      # Error patterns for classification
+      #
+      # @return [Hash<Symbol, Array<Regexp>>] error patterns by category
+      def error_patterns
+        {}
+      end
+
+      # Check if provider supports MCP
+      #
+      # @return [Boolean] true if MCP is supported
+      def supports_mcp?
+        capabilities[:mcp]
+      end
+
+      # Fetch configured MCP servers
+      #
+      # @return [Array<Hash>] MCP server configurations
+      def fetch_mcp_servers
+        []
+      end
+
+      # Check if provider supports dangerous mode
+      #
+      # @return [Boolean] true if dangerous mode is supported
+      def supports_dangerous_mode?
+        capabilities[:dangerous_mode]
+      end
+
+      # Get dangerous mode flags
+      #
+      # @return [Array<String>] CLI flags for dangerous mode
+      def dangerous_mode_flags
+        []
+      end
+
+      # Check if provider supports session continuation
+      #
+      # @return [Boolean] true if sessions are supported
+      def supports_sessions?
+        false
+      end
+
+      # Get session flags for continuation
+      #
+      # @param session_id [String] the session ID
+      # @return [Array<String>] CLI flags for session continuation
+      def session_flags(session_id)
+        []
+      end
+
+      # Validate provider configuration
+      #
+      # @return [Hash] with :valid, :errors keys
+      def validate_config
+        {valid: true, errors: []}
+      end
+
+      # Health check
+      #
+      # @return [Hash] with :healthy, :message keys
+      def health_status
+        {healthy: true, message: "OK"}
+      end
+    end
+  end
+end

data/lib/agent_harness/providers/aider.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module AgentHarness
+  module Providers
+    # Aider AI coding assistant provider
+    #
+    # Provides integration with the Aider CLI tool.
+    class Aider < Base
+      class << self
+        def provider_name
+          :aider
+        end
+
+        def binary_name
+          "aider"
+        end
+
+        def available?
+          executor = AgentHarness.configuration.command_executor
+          !!executor.which(binary_name)
+        end
+
+        def firewall_requirements
+          {
+            domains: [
+              "api.openai.com",
+              "api.anthropic.com"
+            ],
+            ip_ranges: []
+          }
+        end
+
+        def instruction_file_paths
+          [
+            {
+              path: ".aider.conf.yml",
+              description: "Aider configuration file",
+              symlink: false
+            }
+          ]
+        end
+
+        def discover_models
+          return [] unless available?
+
+          # Aider supports multiple model providers
+          [
+            {name: "gpt-4o", family: "gpt-4o", tier: "standard", provider: "aider"},
+            {name: "claude-3-5-sonnet", family: "claude-3-5-sonnet", tier: "standard", provider: "aider"}
+          ]
+        end
+      end
+
+      def name
+        "aider"
+      end
+
+      def display_name
+        "Aider"
+      end
+
+      def capabilities
+        {
+          streaming: true,
+          file_upload: true,
+          vision: false,
+          tool_use: true,
+          json_mode: false,
+          mcp: false,
+          dangerous_mode: false
+        }
+      end
+
+      def supports_sessions?
+        true
+      end
+
+      def session_flags(session_id)
+        return [] unless session_id && !session_id.empty?
+        ["--restore-chat-history", session_id]
+      end
+
+      protected
+
+      def build_command(prompt, options)
+        cmd = [self.class.binary_name]
+
+        # Run in non-interactive mode
+        cmd << "--yes"
+
+        if @config.model && !@config.model.empty?
+          cmd += ["--model", @config.model]
+        end
+
+        if options[:session]
+          cmd += session_flags(options[:session])
+        end
+
+        cmd += ["--message", prompt]
+
+        cmd
+      end
+
+      def default_timeout
+        600 # Aider can take longer
+      end
+    end
+  end
+end