aidp 0.29.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00cbc8656c3ce1550f5246837062879c70a0206fa62c00a7bef6cd20979b9be5
-  data.tar.gz: 353616de5a90d4cf722673040d6e7fba09d60ff63618a3c135688202694e3075
+  metadata.gz: de5176199a74d1e4992451708e3830fff889cffd526c8bc0887a0aa73a4946a9
+  data.tar.gz: 399593a4d2b8d6991d37d22f383c3cd816b5b276b42e1aa45b0a2df064a470da
 SHA512:
-  metadata.gz: 65109acb0af57d4fefccbefa626f928cec5faaa3eedb5dfe4c0141521e03d95c8f7ca2dac8455baebdf6c14d0cbcd6cd81557a0bf4b2f0cdadb62547f60b414d
-  data.tar.gz: ea289ac3406776ccc1c602795fe6fa0a54c09fe8b3729b7e0f3b0151ba2782613cc2fee68b1111f9f6b81c78efeb7d31e77ab233ea49fba48e6d5585505e60f8
+  metadata.gz: 1d290891c58232da0b32ca1a8560ba211f5a5805c8aa7b24d78f1536cd4e32750ca9ee11dbb8c1b25f018ed50082c5fd52e9412f7b871981f0ff8eacef6f5e15
+  data.tar.gz: c10ee2a196880353991978cdf7a92775e13828b82452ba323c152853740a402a07bad29dad8984da1f9f0e2f650e5075bde9308ac8cc326b89de72af66652b2a

data/lib/aidp/config.rb

@@ -111,11 +111,10 @@ module Aidp
           model_family: "claude",
           max_tokens: 100_000,
           default_flags: ["--dangerously-skip-permissions"],
-          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022", "claude-3-opus-20240229"],
+          models: ["claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022"],
           model_weights: {
             "claude-3-5-sonnet-20241022" => 3,
-            "claude-3-5-haiku-20241022" => 2,
-            "claude-3-opus-20240229" => 1
+            "claude-3-5-haiku-20241022" => 2
           },
           models_config: {
             "claude-3-5-sonnet-20241022" => {
@@ -127,11 +126,6 @@ module Aidp
               flags: ["--dangerously-skip-permissions"],
               max_tokens: 200_000,
               timeout: 180
-            },
-            "claude-3-opus-20240229" => {
-              flags: ["--dangerously-skip-permissions"],
-              max_tokens: 200_000,
-              timeout: 600
             }
           },
           auth: {

data/lib/aidp/harness/configuration.rb

@@ -1057,7 +1057,7 @@ module Aidp
       def default_thinking_config
         {
           default_tier: "mini",  # Use mini tier by default for cost optimization
-          max_tier: "max",
+          max_tier: "pro",       # Max tier rarely needed; pro is sufficient for most tasks
           allow_provider_switch: true,
           auto_escalate: true,
           escalation_threshold: 2,

data/lib/aidp/harness/deprecation_cache.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aidp
+  module Harness
+    # Manages a dynamic cache of deprecated models detected at runtime
+    # When deprecation errors are detected from provider APIs, models are
+    # added to this cache with metadata (replacement, detected date, etc.)
+    class DeprecationCache
+      class CacheError < StandardError; end
+
+      attr_reader :cache_path
+
+      def initialize(cache_path: nil, root_dir: nil)
+        @root_dir = root_dir || safe_root_dir
+        @cache_path = cache_path || default_cache_path
+        @cache_data = nil
+        ensure_cache_directory
+      end
+
+      # Add a deprecated model to the cache
+      # @param provider [String] Provider name (e.g., "anthropic")
+      # @param model_id [String] Deprecated model ID
+      # @param replacement [String, nil] Replacement model ID (if known)
+      # @param reason [String, nil] Deprecation reason/message
+      def add_deprecated_model(provider:, model_id:, replacement: nil, reason: nil)
+        load_cache unless @cache_data
+
+        @cache_data["providers"][provider] ||= {}
+        @cache_data["providers"][provider][model_id] = {
+          "deprecated_at" => Time.now.iso8601,
+          "replacement" => replacement,
+          "reason" => reason
+        }.compact
+
+        save_cache
+        Aidp.log_info("deprecation_cache", "Added deprecated model",
+          provider: provider, model: model_id, replacement: replacement)
+      end
+
+      # Check if a model is deprecated
+      # @param provider [String] Provider name
+      # @param model_id [String] Model ID to check
+      # @return [Boolean]
+      def deprecated?(provider:, model_id:)
+        load_cache unless @cache_data
+        @cache_data.dig("providers", provider, model_id) != nil
+      end
+
+      # Get replacement model for a deprecated model
+      # @param provider [String] Provider name
+      # @param model_id [String] Deprecated model ID
+      # @return [String, nil] Replacement model ID or nil
+      def replacement_for(provider:, model_id:)
+        load_cache unless @cache_data
+        @cache_data.dig("providers", provider, model_id, "replacement")
+      end
+
+      # Get all deprecated models for a provider
+      # @param provider [String] Provider name
+      # @return [Array<String>] List of deprecated model IDs
+      def deprecated_models(provider:)
+        load_cache unless @cache_data
+        (@cache_data.dig("providers", provider) || {}).keys
+      end
+
+      # Remove a model from the deprecated cache
+      # Useful if a model comes back or was incorrectly marked
+      # @param provider [String] Provider name
+      # @param model_id [String] Model ID to remove
+      def remove_deprecated_model(provider:, model_id:)
+        load_cache unless @cache_data
+        return unless @cache_data.dig("providers", provider, model_id)
+
+        @cache_data["providers"][provider].delete(model_id)
+        @cache_data["providers"].delete(provider) if @cache_data["providers"][provider].empty?
+
+        save_cache
+        Aidp.log_info("deprecation_cache", "Removed deprecated model",
+          provider: provider, model: model_id)
+      end
+
+      # Get full deprecation info for a model
+      # @param provider [String] Provider name
+      # @param model_id [String] Model ID
+      # @return [Hash, nil] Deprecation metadata or nil
+      def info(provider:, model_id:)
+        load_cache unless @cache_data
+        @cache_data.dig("providers", provider, model_id)
+      end
+
+      # Clear all cached deprecations
+      def clear!
+        @cache_data = default_cache_structure
+        save_cache
+        Aidp.log_info("deprecation_cache", "Cleared all deprecations")
+      end
+
+      # Get cache statistics
+      # @return [Hash] Statistics about cached deprecations
+      def stats
+        load_cache unless @cache_data
+        {
+          providers: @cache_data["providers"].keys.sort,
+          total_deprecated: @cache_data["providers"].sum { |_, models| models.size },
+          by_provider: @cache_data["providers"].transform_values(&:size)
+        }
+      end
+
+      private
+
+      # Get a safe root directory for the cache
+      # Uses Dir.pwd if writable, otherwise falls back to tmpdir
+      def safe_root_dir
+        pwd = Dir.pwd
+        aidp_dir = File.join(pwd, ".aidp")
+
+        # Try to create the directory to test writability
+        begin
+          FileUtils.mkdir_p(aidp_dir) unless File.exist?(aidp_dir)
+          pwd
+        rescue Errno::EACCES, Errno::EROFS, Errno::EPERM
+          # Permission denied or read-only filesystem - use temp directory
+          require "tmpdir"
+          Dir.tmpdir
+        end
+      end
+
+      def default_cache_path
+        File.join(@root_dir, ".aidp", "deprecated_models.json")
+      end
+
+      def ensure_cache_directory
+        dir = File.dirname(@cache_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      def load_cache
+        if File.exist?(@cache_path)
+          @cache_data = JSON.parse(File.read(@cache_path))
+          validate_cache_structure
+        else
+          @cache_data = default_cache_structure
+        end
+      rescue JSON::ParserError => e
+        Aidp.log_warn("deprecation_cache", "Invalid cache file, resetting",
+          error: e.message, path: @cache_path)
+        @cache_data = default_cache_structure
+      end
+
+      def save_cache
+        File.write(@cache_path, JSON.pretty_generate(@cache_data))
+      rescue => e
+        Aidp.log_error("deprecation_cache", "Failed to save cache",
+          error: e.message, path: @cache_path)
+        raise CacheError, "Failed to save deprecation cache: #{e.message}"
+      end
+
+      def default_cache_structure
+        {
+          "version" => "1.0",
+          "updated_at" => Time.now.iso8601,
+          "providers" => {}
+        }
+      end
+
+      def validate_cache_structure
+        unless @cache_data.is_a?(Hash) && @cache_data["providers"].is_a?(Hash)
+          Aidp.log_warn("deprecation_cache", "Invalid cache structure, resetting")
+          @cache_data = default_cache_structure
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/provider_manager.rb

@@ -1394,9 +1394,9 @@ module Aidp
 
       # Execute a prompt with a specific provider
       def execute_with_provider(provider_type, prompt, options = {})
-        # Extract model and tier from options if provided
+        # Extract model from options if provided
         model_name = options.delete(:model)
-        tier = options[:tier] # Keep tier in options for provider
+        retry_on_rate_limit = options.delete(:retry_on_rate_limit) != false # Default true
 
         # Create provider factory instance
         provider_factory = ProviderFactory.new
@@ -1415,11 +1415,10 @@ module Aidp
         Aidp.logger.debug("provider_manager", "Executing with provider",
           provider: provider_type,
           model: model_name,
-          tier: tier,
           prompt_length: prompt.length)
 
-        # Execute the prompt with the provider (pass options including tier)
-        result = provider.send_message(prompt: prompt, session: nil, options: options)
+        # Execute the prompt with the provider
+        result = provider.send_message(prompt: prompt, session: nil)
 
         # Return structured result
         {
@@ -1436,6 +1435,38 @@ module Aidp
         }
       rescue => e
         log_rescue(e, component: "provider_manager", action: "execute_with_provider", fallback: "error_result", provider: provider_type, model: model_name, prompt_length: prompt.length)
+
+        # Detect rate limit / quota errors and attempt fallback
+        error_message = e.message.to_s.downcase
+        is_rate_limit = error_message.include?("rate limit") ||
+          error_message.include?("quota") ||
+          error_message.include?("limit reached") ||
+          error_message.include?("resource exhausted") ||
+          error_message.include?("too many requests")
+
+        if is_rate_limit && retry_on_rate_limit
+          Aidp.logger.warn("provider_manager", "Rate limit detected, attempting fallback",
+            provider: provider_type,
+            model: model_name,
+            error: e.message)
+
+          # Attempt to switch to fallback provider
+          fallback_provider = switch_provider_for_error("rate_limit", {
+            original_provider: provider_type,
+            model: model_name,
+            error_message: e.message
+          })
+
+          if fallback_provider && fallback_provider != provider_type
+            Aidp.logger.info("provider_manager", "Retrying with fallback provider",
+              original: provider_type,
+              fallback: fallback_provider)
+
+            # Retry with fallback provider (disable retry to prevent infinite loop)
+            return execute_with_provider(fallback_provider, prompt, options.merge(retry_on_rate_limit: false))
+          end
+        end
+
         # Return error result
         {
           status: "error",

data/lib/aidp/harness/ruby_llm_registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ruby_llm"
+require_relative "deprecation_cache"
 
 module Aidp
   module Harness
@@ -26,6 +27,11 @@ module Aidp
         "openrouter" => "openrouter"
       }.freeze
 
+      # Get deprecation cache instance (lazy loaded)
+      def deprecation_cache
+        @deprecation_cache ||= Aidp::Harness::DeprecationCache.new
+      end
+
       # Tier classification based on model characteristics
       # These are heuristics since ruby_llm doesn't classify tiers
       TIER_CLASSIFICATION = {
@@ -59,7 +65,8 @@ module Aidp
         standard: ->(model) { true }
       }.freeze
 
-      def initialize
+      def initialize(deprecation_cache: nil)
+        @deprecation_cache = deprecation_cache
         @models = RubyLLM::Models.instance.instance_variable_get(:@models)
         @index_by_id = @models.to_h { |m| [m.id, m] }
 
@@ -73,11 +80,18 @@ module Aidp
       #
       # @param model_name [String] Model name (e.g., "claude-3-5-haiku" or "claude-3-5-haiku-20241022")
       # @param provider [String, nil] Optional AIDP provider filter
+      # @param skip_deprecated [Boolean] Skip deprecated models (default: true)
       # @return [String, nil] Canonical model ID for API calls, or nil if not found
-      def resolve_model(model_name, provider: nil)
+      def resolve_model(model_name, provider: nil, skip_deprecated: true)
         # Map AIDP provider to registry provider if filtering
         registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
 
+        # Check if model is deprecated
+        if skip_deprecated && model_deprecated?(model_name, registry_provider)
+          Aidp.log_warn("ruby_llm_registry", "skipping deprecated model", model: model_name, provider: provider)
+          return nil
+        end
+
         # Try exact match first
         model = @index_by_id[model_name]
         return model.id if model && (registry_provider.nil? || model.provider.to_s == registry_provider)
@@ -88,13 +102,20 @@ module Aidp
           # Filter by provider if specified
           family_models = family_models.select { |m| m.provider.to_s == registry_provider } if registry_provider
 
+          # Filter out deprecated models if requested
+          if skip_deprecated
+            family_models = family_models.reject do |m|
+              deprecation_cache.deprecated?(provider: registry_provider, model_id: m.id.to_s)
+            end
+          end
+
           # Return the latest version (first non-"latest" model, or the latest one)
           model = family_models.reject { |m| m.id.to_s.include?("-latest") }.first || family_models.first
           return model.id if model
         end
 
         # Try fuzzy matching for common patterns
-        fuzzy_match = find_fuzzy_match(model_name, registry_provider)
+        fuzzy_match = find_fuzzy_match(model_name, registry_provider, skip_deprecated: skip_deprecated)
         return fuzzy_match.id if fuzzy_match
 
         Aidp.log_warn("ruby_llm_registry", "model not found", model: model_name, provider: provider)
@@ -124,8 +145,9 @@ module Aidp
       #
       # @param tier [String, Symbol] The tier name (mini, standard, advanced)
       # @param provider [String, nil] Optional AIDP provider filter
+      # @param skip_deprecated [Boolean] Skip deprecated models (default: true)
       # @return [Array<String>] List of model IDs for the tier
-      def models_for_tier(tier, provider: nil)
+      def models_for_tier(tier, provider: nil, skip_deprecated: true)
         tier_sym = tier.to_sym
         classifier = TIER_CLASSIFICATION[tier_sym]
 
@@ -152,6 +174,11 @@ module Aidp
           end
         end
 
+        # Filter out deprecated models if requested
+        if skip_deprecated
+          models.reject! { |m| deprecation_cache.deprecated?(provider: registry_provider, model_id: m.id.to_s) }
+        end
+
         model_ids = models.map(&:id).uniq
         Aidp.log_debug("ruby_llm_registry", "found models for tier",
           tier: tier, provider: provider, count: model_ids.size)
@@ -191,6 +218,51 @@ module Aidp
         Aidp.log_info("ruby_llm_registry", "refreshed", models: @models.size)
       end
 
+      # Check if a model is deprecated
+      # @param model_id [String] The model ID to check
+      # @param provider [String, nil] The provider name (registry format)
+      # @return [Boolean] True if model is deprecated
+      def model_deprecated?(model_id, provider = nil)
+        return false unless provider
+
+        deprecation_cache.deprecated?(provider: provider, model_id: model_id.to_s)
+      end
+
+      # Find replacement for a deprecated model
+      # Returns the latest non-deprecated model in the same family/tier
+      # @param deprecated_model [String] The deprecated model ID
+      # @param provider [String, nil] The provider name (AIDP format)
+      # @return [String, nil] Replacement model ID or nil
+      def find_replacement_model(deprecated_model, provider: nil)
+        registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
+        return nil unless registry_provider
+
+        # Determine tier of deprecated model
+        deprecated_info = @index_by_id[deprecated_model]
+        return nil unless deprecated_info
+
+        tier = classify_tier(deprecated_info)
+
+        # Get all non-deprecated models for this tier and provider
+        candidates = models_for_tier(tier, provider: provider, skip_deprecated: true)
+
+        # Prefer models in the same family (e.g., both "sonnet")
+        family_keyword = extract_family_keyword(deprecated_model)
+        same_family = candidates.select { |m| m.to_s.include?(family_keyword) } if family_keyword
+
+        # Return first match from same family, or first candidate overall
+        replacement = same_family&.first || candidates.first
+
+        if replacement
+          Aidp.log_info("ruby_llm_registry", "found replacement",
+            deprecated: deprecated_model,
+            replacement: replacement,
+            tier: tier)
+        end
+
+        replacement
+      end
+
       private
 
       # Build an index mapping family names to model objects
@@ -208,13 +280,18 @@ module Aidp
       end
 
       # Find a model by fuzzy matching
-      def find_fuzzy_match(model_name, provider)
+      def find_fuzzy_match(model_name, provider, skip_deprecated: true)
         # Normalize the search term
         normalized = model_name.downcase.gsub(/[^a-z0-9]/, "")
 
         candidates = @models.select do |m|
           next false if provider && m.provider.to_s != provider
 
+          # Skip deprecated if requested
+          if skip_deprecated
+            next false if deprecation_cache.deprecated?(provider: provider, model_id: m.id.to_s)
+          end
+
           # Check if model ID contains the search term
           m.id.to_s.downcase.gsub(/[^a-z0-9]/, "").include?(normalized) ||
             m.name.to_s.downcase.gsub(/[^a-z0-9]/, "").include?(normalized)
@@ -224,6 +301,17 @@ module Aidp
         candidates.min_by { |m| m.id.to_s.length }
       end
 
+      # Extract family keyword from model ID (e.g., "sonnet", "haiku", "opus")
+      def extract_family_keyword(model_id)
+        case model_id.to_s
+        when /sonnet/i then "sonnet"
+        when /haiku/i then "haiku"
+        when /opus/i then "opus"
+        when /gpt-4/i then "gpt-4"
+        when /gpt-3/i then "gpt-3"
+        end
+      end
+
       # Extract capabilities from model info
       def extract_capabilities(model)
         caps = []

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -160,11 +160,53 @@ module Aidp
           if configured_models.any?
             # Use first configured model for this provider and tier
             model_name = configured_models.first
-            Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
-              tier: tier,
-              provider: provider,
-              model: model_name)
-            return [provider, model_name, {}]
+
+            # Check if model is deprecated and try to upgrade
+            require_relative "ruby_llm_registry" unless defined?(Aidp::Harness::RubyLLMRegistry)
+            llm_registry = Aidp::Harness::RubyLLMRegistry.new
+
+            if llm_registry.model_deprecated?(model_name, provider)
+              Aidp.log_warn("thinking_depth_manager", "Configured model is deprecated",
+                tier: tier,
+                provider: provider,
+                model: model_name)
+
+              # Try to find replacement
+              replacement = llm_registry.find_replacement_model(model_name, provider: provider)
+              if replacement
+                Aidp.log_info("thinking_depth_manager", "Auto-upgrading to non-deprecated model",
+                  tier: tier,
+                  provider: provider,
+                  old_model: model_name,
+                  new_model: replacement)
+                model_name = replacement
+              else
+                # Try next model in config list
+                non_deprecated = configured_models.find { |m| !llm_registry.model_deprecated?(m, provider) }
+                if non_deprecated
+                  Aidp.log_info("thinking_depth_manager", "Using alternate configured model",
+                    tier: tier,
+                    provider: provider,
+                    skipped: model_name,
+                    selected: non_deprecated)
+                  model_name = non_deprecated
+                else
+                  Aidp.log_warn("thinking_depth_manager", "All configured models deprecated, falling back to catalog",
+                    tier: tier,
+                    provider: provider)
+                  # Fall through to catalog selection
+                  model_name = nil
+                end
+              end
+            end
+
+            if model_name
+              Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
+                tier: tier,
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, {}]
+            end
           end
 
           # Provider specified but has no models for this tier in config