aidp 0.23.0 → 0.24.0

data/lib/aidp/harness/configuration.rb

@@ -7,6 +7,8 @@ module Aidp
   module Harness
     # Handles loading and validation of harness configuration from aidp.yml
     class Configuration
+      attr_reader :project_dir
+
       def initialize(project_dir)
         @project_dir = project_dir
         @config = Aidp::Config.load_harness_config(project_dir)
@@ -600,7 +602,16 @@ module Aidp
 
       # Get devcontainer configuration
       def devcontainer_config
-        @config[:devcontainer] || default_devcontainer_config
+        return @devcontainer_config if defined?(@devcontainer_config)
+
+        raw_config = @config[:devcontainer] || @config["devcontainer"]
+        base = deep_dup(default_devcontainer_config)
+
+        @devcontainer_config = if raw_config.is_a?(Hash)
+          deep_merge_hashes(base, deep_symbolize_keys(raw_config))
+        else
+          base
+        end
       end
 
       # Check if devcontainer features are enabled
@@ -629,7 +640,10 @@ module Aidp
 
       # Get devcontainer permissions config
       def devcontainer_permissions
-        devcontainer_config[:permissions] || {}
+        permissions = devcontainer_config[:permissions]
+        return {} unless permissions.is_a?(Hash)
+
+        permissions.transform_keys { |key| key.to_sym }
       end
 
       # Check if dangerous filesystem operations are allowed in devcontainer
@@ -639,7 +653,15 @@ module Aidp
 
       # Get list of providers that should skip permission checks in devcontainer
       def devcontainer_skip_permission_checks
-        devcontainer_permissions[:skip_permission_checks] || []
+        permissions = devcontainer_config[:permissions]
+        list = nil
+
+        if permissions.is_a?(Hash)
+          list = permissions[:skip_permission_checks] || permissions["skip_permission_checks"]
+        end
+
+        list = default_skip_permission_checks if list.nil?
+        Array(list).map(&:to_s)
       end
 
       # Check if a specific provider should skip permission checks in devcontainer
@@ -843,7 +865,7 @@ module Aidp
               max_backoff_seconds: 1800,
               next: {
                 success: :agentic,
-                failure: :decide_whats_next,
+                failure: :diagnose_failures,
                 else: :decide_whats_next
               }
             },
@@ -856,7 +878,7 @@ module Aidp
               max_backoff_seconds: 1800,
               next: {
                 success: :agentic,
-                failure: :decide_whats_next,
+                failure: :diagnose_failures,
                 else: :decide_whats_next
               }
             },
@@ -1055,7 +1077,7 @@ module Aidp
           force_detection: nil,
           permissions: {
             dangerous_filesystem_ops: false,
-            skip_permission_checks: []
+            skip_permission_checks: ["claude"]
           },
           settings: {
             timeout_multiplier: 1.0,
@@ -1065,6 +1087,47 @@ module Aidp
         }
       end
 
+      def default_skip_permission_checks
+        Array(default_devcontainer_config.dig(:permissions, :skip_permission_checks)).map(&:to_s)
+      end
+
+      def deep_symbolize_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, val), memo|
+            memo[key.to_sym] = deep_symbolize_keys(val)
+          end
+        when Array
+          value.map { |item| deep_symbolize_keys(item) }
+        else
+          value
+        end
+      end
+
+      def deep_merge_hashes(base, overrides)
+        overrides.each do |key, value|
+          base[key] = if base[key].is_a?(Hash) && value.is_a?(Hash)
+            deep_merge_hashes(base[key], value)
+          else
+            value
+          end
+        end
+        base
+      end
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, val), memo|
+            memo[key] = deep_dup(val)
+          end
+        when Array
+          value.map { |item| deep_dup(item) }
+        else
+          value
+        end
+      end
+
       # Custom error class for configuration issues
       class ConfigurationError < StandardError; end
     end

data/lib/aidp/harness/error_handler.rb

@@ -3,6 +3,7 @@
 require "net/http"
 require_relative "../debug_mixin"
 require_relative "../concurrency"
+require_relative "../providers/error_taxonomy"
 
 module Aidp
   module Harness
@@ -252,9 +253,10 @@ module Aidp
       # Check if we should retry based on error type and strategy
       def should_retry?(error_info, strategy)
         return false unless strategy[:enabled]
-        return false if error_info[:error_type] == :rate_limit
-        return false if error_info[:error_type] == :authentication
-        return false if error_info[:error_type] == :permission_denied
+
+        # Use ErrorTaxonomy to determine if error is retryable
+        error_type = error_info[:error_type]
+        return false unless Aidp::Providers::ErrorTaxonomy.retryable?(error_type)
 
         # Check circuit breaker
         circuit_breaker_key = "#{error_info[:provider]}:#{error_info[:model]}"
@@ -337,7 +339,62 @@ module Aidp
 
       def initialize_retry_strategies
         @retry_strategies = {
-          # Network errors - retry with exponential backoff
+          # Transient errors - retry with exponential backoff
+          transient: {
+            name: "transient",
+            enabled: true,
+            max_retries: 3,
+            backoff_strategy: :exponential,
+            base_delay: 1.0,
+            max_delay: 30.0,
+            jitter: true
+          },
+
+          # Rate limited errors - no retry, immediate switch
+          rate_limited: {
+            name: "rate_limited",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Authentication expired - no retry, switch provider
+          auth_expired: {
+            name: "auth_expired",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Quota exceeded - no retry, switch provider
+          quota_exceeded: {
+            name: "quota_exceeded",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Permanent errors - no retry, escalate
+          permanent: {
+            name: "permanent",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Legacy aliases for backward compatibility
           network_error: {
             name: "network_error",
             enabled: true,
@@ -347,8 +404,6 @@ module Aidp
             max_delay: 30.0,
             jitter: true
           },
-
-          # Server errors - retry with linear backoff
           server_error: {
             name: "server_error",
             enabled: true,
@@ -358,8 +413,6 @@ module Aidp
             max_delay: 10.0,
             jitter: true
           },
-
-          # Timeout errors - retry with exponential backoff
           timeout: {
             name: "timeout",
             enabled: true,
@@ -369,8 +422,6 @@ module Aidp
             max_delay: 15.0,
             jitter: true
           },
-
-          # Rate limit errors - no retry, immediate switch
           rate_limit: {
             name: "rate_limit",
             enabled: false,
@@ -380,8 +431,6 @@ module Aidp
             max_delay: 0.0,
             jitter: false
           },
-
-          # Authentication errors - no retry, escalate
           authentication: {
             name: "authentication",
             enabled: false,
@@ -391,8 +440,6 @@ module Aidp
             max_delay: 0.0,
             jitter: false
           },
-
-          # Permission denied - no retry, escalate
           permission_denied: {
             name: "permission_denied",
             enabled: false,
@@ -586,41 +633,36 @@ module Aidp
         private
 
         def classify_error_type(error)
-          return :unknown if error.nil?
+          return :transient if error.nil?
+
+          # Use standardized error taxonomy for classification
+          message = error.message.to_s
 
+          # First, use ErrorTaxonomy to classify by message
+          category = Aidp::Providers::ErrorTaxonomy.classify_message(message)
+
+          # Override with more specific classification based on error type
           case error
           when Timeout::Error
-            :timeout
+            :transient
           when Net::HTTPError
             case error.response.code.to_i
             when 429
-              :rate_limit
+              :rate_limited
             when 401, 403
-              :authentication
+              :auth_expired
             when 500..599
-              :server_error
+              :transient
+            when 400
+              :permanent
             else
-              :network_error
+              :transient
             end
           when SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-            :network_error
-          when StandardError
-            # Check error message for common patterns
-            message = error.message.downcase
-
-            if message.include?("rate limit") || message.include?("quota")
-              :rate_limit
-            elsif message.include?("timeout")
-              :timeout
-            elsif message.include?("auth") || message.include?("permission")
-              :authentication
-            elsif message.include?("server") || message.include?("internal")
-              :server_error
-            else
-              :default
-            end
+            :transient
           else
-            :default
+            # Use message-based classification from ErrorTaxonomy
+            category
           end
         end
       end
@@ -629,22 +671,41 @@ module Aidp
         def create_recovery_plan(error_info, _context = {})
           error_type = error_info[:error_type]
 
+          # Use ErrorTaxonomy to determine recovery strategy
           case error_type
-          when :rate_limit
+          when :rate_limited
             {
               action: :switch_provider,
               reason: "Rate limit reached, switching provider",
               priority: :high
             }
-          when :authentication, :permission_denied
-            # Previously we escalated immediately. Instead, attempt a provider switch
-            # so workflows can continue with alternate providers (e.g., Gemini, Cursor)
-            # while the user resolves credentials for the failing provider.
+          when :auth_expired
+            # Attempt a provider switch so workflows can continue with alternate providers
+            # while the user resolves credentials for the failing provider
             {
               action: :switch_provider,
-              reason: "Authentication/permission issue – switching provider to continue",
+              reason: "Authentication expired – switching provider to continue",
               priority: :critical
             }
+          when :quota_exceeded
+            {
+              action: :switch_provider,
+              reason: "Quota exceeded, switching provider",
+              priority: :high
+            }
+          when :transient
+            {
+              action: :switch_model,
+              reason: "Transient error, trying alternate model",
+              priority: :medium
+            }
+          when :permanent
+            {
+              action: :escalate,
+              reason: "Permanent error, requires manual intervention",
+              priority: :critical
+            }
+          # Legacy error type mappings for backward compatibility
           when :timeout
             {
               action: :switch_model,
@@ -655,7 +716,7 @@ module Aidp
             {
               action: :switch_provider,
               reason: "Network error, switching provider",
-              priority: :high
+              priority: :medium
             }
           when :server_error
             {
@@ -663,6 +724,18 @@ module Aidp
               reason: "Server error, switching provider",
               priority: :medium
             }
+          when :authentication, :permission_denied
+            {
+              action: :switch_provider,
+              reason: "Authentication/permission issue – switching provider to continue",
+              priority: :critical
+            }
+          when :rate_limit
+            {
+              action: :switch_provider,
+              reason: "Rate limit reached, switching provider",
+              priority: :high
+            }
           else
             {
               action: :switch_provider,

data/lib/aidp/harness/provider_manager.rb

@@ -2,6 +2,7 @@
 
 require "tty-prompt"
 require_relative "provider_factory"
+require_relative "provider_metrics"
 require_relative "../rescue_logging"
 require_relative "../concurrency"
 
@@ -40,6 +41,20 @@ module Aidp
         @unavailable_cache = {}
         @binary_check_cache = {}
         @binary_check_ttl = 300 # seconds
+
+        # Initialize persistence
+        project_dir = if configuration.respond_to?(:project_dir)
+          configuration.project_dir
+        elsif configuration.respond_to?(:root_dir)
+          configuration.root_dir
+        else
+          Dir.pwd
+        end
+        @metrics_persistence = ProviderMetrics.new(project_dir)
+
+        # Load persisted metrics
+        load_persisted_metrics
+
         initialize_fallback_chains
         initialize_provider_health
         initialize_model_configs
@@ -932,6 +947,9 @@ module Aidp
         # Update provider health
         update_provider_health(provider_name, "rate_limited")
 
+        # Persist rate limit info to disk
+        save_persisted_rate_limits
+
         # Switch to next provider if current one is rate limited
         if provider_name == current_provider
           switch_provider("rate_limit", {provider: provider_name})
@@ -996,6 +1014,9 @@ module Aidp
           metrics[:last_error_time] = Time.now
           update_provider_health(provider_name, "error", {error: error})
         end
+
+        # Persist metrics to disk
+        save_persisted_metrics
       end
 
       # Record model metrics
@@ -1611,6 +1632,49 @@ module Aidp
         # Most models reset rate limits every hour
         Time.now + (60 * 60)
       end
+
+      # Load persisted metrics from disk
+      def load_persisted_metrics
+        return unless @metrics_persistence
+
+        # Load provider metrics
+        persisted_metrics = @metrics_persistence.load_metrics
+        @provider_metrics.merge!(persisted_metrics) if persisted_metrics.is_a?(Hash)
+
+        # Load rate limit info
+        persisted_rate_limits = @metrics_persistence.load_rate_limits
+        @rate_limit_info.merge!(persisted_rate_limits) if persisted_rate_limits.is_a?(Hash)
+
+        # Clean up expired rate limits
+        cleanup_expired_rate_limits
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "load_persisted_metrics", fallback: nil)
+      end
+
+      # Save persisted metrics to disk
+      def save_persisted_metrics
+        return unless @metrics_persistence
+        @metrics_persistence.save_metrics(@provider_metrics)
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "save_persisted_metrics", fallback: nil)
+      end
+
+      # Save persisted rate limits to disk
+      def save_persisted_rate_limits
+        return unless @metrics_persistence
+        @metrics_persistence.save_rate_limits(@rate_limit_info)
+      rescue => e
+        log_rescue(e, component: "provider_manager", action: "save_persisted_rate_limits", fallback: nil)
+      end
+
+      # Clean up expired rate limits from memory
+      def cleanup_expired_rate_limits
+        now = Time.now
+        @rate_limit_info.delete_if do |_provider, info|
+          reset_time = info[:reset_time]
+          reset_time && now >= reset_time
+        end
+      end
     end
   end
 end

data/lib/aidp/harness/provider_metrics.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "../rescue_logging"
+
+module Aidp
+  module Harness
+    # Persists provider metrics and rate limit information to disk
+    # Enables the provider dashboard to display real-time state
+    class ProviderMetrics
+      include Aidp::RescueLogging
+
+      attr_reader :project_dir, :metrics_file, :rate_limit_file
+
+      def initialize(project_dir)
+        @project_dir = project_dir
+        @metrics_file = File.join(project_dir, ".aidp", "provider_metrics.yml")
+        @rate_limit_file = File.join(project_dir, ".aidp", "provider_rate_limits.yml")
+        ensure_directory
+      end
+
+      # Save provider metrics to disk
+      def save_metrics(metrics_hash)
+        return if metrics_hash.nil? || metrics_hash.empty?
+
+        # Convert Time objects to ISO8601 strings for YAML serialization
+        serializable_metrics = serialize_metrics(metrics_hash)
+
+        File.write(@metrics_file, YAML.dump(serializable_metrics))
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "save_metrics", fallback: nil)
+      end
+
+      # Load provider metrics from disk
+      def load_metrics
+        return {} unless File.exist?(@metrics_file)
+
+        data = YAML.safe_load_file(@metrics_file, permitted_classes: [Time, Date, Symbol], aliases: true)
+        return {} unless data.is_a?(Hash)
+
+        # Convert ISO8601 strings back to Time objects
+        deserialize_metrics(data)
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "load_metrics", fallback: {})
+        {}
+      end
+
+      # Save rate limit information to disk
+      def save_rate_limits(rate_limit_hash)
+        return if rate_limit_hash.nil? || rate_limit_hash.empty?
+
+        # Convert Time objects to ISO8601 strings for YAML serialization
+        serializable_rate_limits = serialize_rate_limits(rate_limit_hash)
+
+        File.write(@rate_limit_file, YAML.dump(serializable_rate_limits))
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "save_rate_limits", fallback: nil)
+      end
+
+      # Load rate limit information from disk
+      def load_rate_limits
+        return {} unless File.exist?(@rate_limit_file)
+
+        data = YAML.safe_load_file(@rate_limit_file, permitted_classes: [Time, Date, Symbol], aliases: true)
+        return {} unless data.is_a?(Hash)
+
+        # Convert ISO8601 strings back to Time objects
+        deserialize_rate_limits(data)
+      rescue => e
+        log_rescue(e, component: "provider_metrics", action: "load_rate_limits", fallback: {})
+        {}
+      end
+
+      # Clear all persisted metrics
+      def clear
+        File.delete(@metrics_file) if File.exist?(@metrics_file)
+        File.delete(@rate_limit_file) if File.exist?(@rate_limit_file)
+      end
+
+      private
+
+      def ensure_directory
+        aidp_dir = File.join(@project_dir, ".aidp")
+        FileUtils.mkdir_p(aidp_dir) unless File.directory?(aidp_dir)
+      end
+
+      def serialize_metrics(metrics_hash)
+        metrics_hash.transform_values do |provider_metrics|
+          next provider_metrics unless provider_metrics.is_a?(Hash)
+
+          provider_metrics.transform_values do |value|
+            value.is_a?(Time) ? value.iso8601 : value
+          end
+        end
+      end
+
+      def deserialize_metrics(metrics_hash)
+        metrics_hash.transform_values do |provider_metrics|
+          next provider_metrics unless provider_metrics.is_a?(Hash)
+
+          provider_metrics.transform_keys(&:to_sym).transform_values do |value|
+            parse_time_if_string(value)
+          end
+        end
+      end
+
+      def serialize_rate_limits(rate_limit_hash)
+        rate_limit_hash.transform_values do |limit_info|
+          next limit_info unless limit_info.is_a?(Hash)
+
+          limit_info.transform_values do |value|
+            value.is_a?(Time) ? value.iso8601 : value
+          end
+        end
+      end
+
+      def deserialize_rate_limits(rate_limit_hash)
+        rate_limit_hash.transform_values do |limit_info|
+          next limit_info unless limit_info.is_a?(Hash)
+
+          limit_info.transform_keys(&:to_sym).transform_values do |value|
+            parse_time_if_string(value)
+          end
+        end
+      end
+
+      def parse_time_if_string(value)
+        return value unless value.is_a?(String)
+
+        # Try to parse ISO8601 timestamp
+        Time.parse(value)
+      rescue ArgumentError
+        value
+      end
+    end
+  end
+end