aidp 0.26.0 → 0.27.0

data/lib/aidp/harness/model_registry.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module Aidp
+  module Harness
+    # ModelRegistry manages the static registry of known model families and their tier classifications
+    #
+    # The registry uses model families (e.g., "claude-3-5-sonnet") rather than specific versioned
+    # model IDs (e.g., "claude-3-5-sonnet-20241022"). This design provides:
+    #   - No version tracking burden - registry tracks families, not every dated version
+    #   - Future-proofing - new model versions automatically inherit family tier
+    #   - Provider autonomy - each provider handles version-specific naming
+    #
+    # Usage:
+    #   registry = ModelRegistry.new
+    #   registry.get_model_info("claude-3-5-sonnet")
+    #   # => { name: "Claude 3.5 Sonnet", tier: "standard", ... }
+    #
+    #   registry.models_for_tier("standard")
+    #   # => ["claude-3-5-sonnet", "gpt-4-turbo", ...]
+    #
+    #   registry.match_to_family("claude-3-5-sonnet-20241022")
+    #   # => "claude-3-5-sonnet"
+    class ModelRegistry
+      class RegistryError < StandardError; end
+      class InvalidRegistrySchema < RegistryError; end
+      class ModelNotFound < RegistryError; end
+
+      VALID_TIERS = %w[mini standard advanced].freeze
+      VALID_CAPABILITIES = %w[chat code vision tool_use streaming json_mode].freeze
+      VALID_SPEEDS = %w[very_fast fast medium slow].freeze
+
+      attr_reader :registry_data
+
+      def initialize(registry_path: nil)
+        @registry_path = registry_path || default_registry_path
+        @registry_data = load_static_registry
+        validate_registry_schema
+        Aidp.log_debug("model_registry", "initialized", models: @registry_data["model_families"].keys.size)
+      end
+
+      # Get complete model information for a family
+      #
+      # @param family_name [String] The model family name (e.g., "claude-3-5-sonnet")
+      # @return [Hash, nil] Model metadata hash or nil if not found
+      def get_model_info(family_name)
+        info = @registry_data["model_families"][family_name]
+        return nil unless info
+
+        info.merge("family" => family_name)
+      end
+
+      # Get all model families for a specific tier
+      #
+      # @param tier [String, Symbol] The tier name (mini, standard, advanced)
+      # @return [Array<String>] List of model family names for the tier
+      def models_for_tier(tier)
+        tier_str = tier.to_s
+        unless VALID_TIERS.include?(tier_str)
+          Aidp.log_warn("model_registry", "invalid tier requested", tier: tier_str, valid: VALID_TIERS)
+          return []
+        end
+
+        families = @registry_data["model_families"].select { |_family, info|
+          info["tier"] == tier_str
+        }.keys
+
+        Aidp.log_debug("model_registry", "found models for tier", tier: tier_str, count: families.size)
+        families
+      end
+
+      # Classify a model family's tier
+      #
+      # @param family_name [String] The model family name
+      # @return [String, nil] The tier name or nil if not found
+      def classify_model_tier(family_name)
+        info = get_model_info(family_name)
+        tier = info&.fetch("tier", nil)
+        Aidp.log_debug("model_registry", "classified tier", family: family_name, tier: tier)
+        tier
+      end
+
+      # Match a versioned model name to its family using pattern matching
+      #
+      # This method attempts to normalize versioned model names (e.g., "claude-3-5-sonnet-20241022")
+      # to their family name (e.g., "claude-3-5-sonnet") by testing against version_pattern regexes.
+      #
+      # @param versioned_name [String] The versioned model name
+      # @return [String, nil] The family name if matched, nil otherwise
+      def match_to_family(versioned_name)
+        @registry_data["model_families"].each do |family, info|
+          pattern = info["version_pattern"]
+          next unless pattern
+
+          begin
+            regex = Regexp.new("^#{pattern}$")
+            if regex.match?(versioned_name)
+              Aidp.log_debug("model_registry", "matched to family", versioned: versioned_name, family: family)
+              return family
+            end
+          rescue RegexpError => e
+            Aidp.log_error("model_registry", "invalid pattern", family: family, pattern: pattern, error: e.message)
+          end
+        end
+
+        # If no pattern matches, check if the versioned_name is itself a family
+        if @registry_data["model_families"].key?(versioned_name)
+          Aidp.log_debug("model_registry", "exact family match", name: versioned_name)
+          return versioned_name
+        end
+
+        Aidp.log_debug("model_registry", "no family match", versioned: versioned_name)
+        nil
+      end
+
+      # Get all registered model families
+      #
+      # @return [Array<String>] List of all model family names
+      def all_families
+        @registry_data["model_families"].keys
+      end
+
+      # Check if a model family exists in the registry
+      #
+      # @param family_name [String] The model family name
+      # @return [Boolean] True if the family exists
+      def family_exists?(family_name)
+        @registry_data["model_families"].key?(family_name)
+      end
+
+      # Get all tiers that have at least one model
+      #
+      # @return [Array<String>] List of tier names
+      def available_tiers
+        @registry_data["model_families"].values.map { |info| info["tier"] }.uniq.sort
+      end
+
+      private
+
+      def default_registry_path
+        Pathname.new(__dir__).parent.join("data", "model_registry.yml")
+      end
+
+      def load_static_registry
+        unless File.exist?(@registry_path)
+          raise RegistryError, "Model registry file not found at #{@registry_path}"
+        end
+
+        data = YAML.load_file(@registry_path)
+        unless data.is_a?(Hash) && data.key?("model_families")
+          raise InvalidRegistrySchema, "Registry must contain 'model_families' key"
+        end
+
+        Aidp.log_info("model_registry", "loaded registry", path: @registry_path, families: data["model_families"].size)
+        data
+      rescue Psych::SyntaxError => e
+        raise InvalidRegistrySchema, "Invalid YAML in registry file: #{e.message}"
+      end
+
+      def validate_registry_schema
+        @registry_data["model_families"].each do |family, info|
+          validate_model_entry(family, info)
+        end
+      end
+
+      def validate_model_entry(family, info)
+        # Required fields
+        unless info["tier"]
+          raise InvalidRegistrySchema, "Model family '#{family}' missing required 'tier' field"
+        end
+        unless VALID_TIERS.include?(info["tier"])
+          raise InvalidRegistrySchema, "Model family '#{family}' has invalid tier '#{info["tier"]}'. Valid: #{VALID_TIERS.join(", ")}"
+        end
+
+        # Optional but validated if present
+        if info["capabilities"]
+          unless info["capabilities"].is_a?(Array)
+            raise InvalidRegistrySchema, "Model family '#{family}' capabilities must be an array"
+          end
+          invalid_caps = info["capabilities"] - VALID_CAPABILITIES
+          unless invalid_caps.empty?
+            Aidp.log_warn("model_registry", "unknown capabilities", family: family, unknown: invalid_caps)
+          end
+        end
+
+        if info["speed"] && !VALID_SPEEDS.include?(info["speed"])
+          Aidp.log_warn("model_registry", "invalid speed", family: family, speed: info["speed"], valid: VALID_SPEEDS)
+        end
+
+        # Validate numeric fields if present
+        %w[context_window max_output cost_per_1m_input cost_per_1m_output].each do |field|
+          if info[field] && !info[field].is_a?(Numeric)
+            raise InvalidRegistrySchema, "Model family '#{family}' field '#{field}' must be numeric"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/runner.rb

@@ -11,6 +11,7 @@ require_relative "error_handler"
 require_relative "status_display"
 require_relative "completion_checker"
 require_relative "../concurrency"
+require_relative "../errors"
 
 module Aidp
   module Harness
@@ -135,6 +136,10 @@ module Aidp
               end
             end
           end
+        rescue Aidp::Errors::ConfigurationError
+          # Configuration errors should crash immediately (crash-early principle)
+          # Re-raise without catching
+          raise
         rescue => e
           @state = STATES[:error]
           @last_error = e

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -2,12 +2,15 @@
 
 require_relative "capability_registry"
 require_relative "configuration"
+require_relative "../message_display"
 
 module Aidp
   module Harness
     # Manages thinking depth tier selection and escalation
     # Integrates with CapabilityRegistry and Configuration to select appropriate models
     class ThinkingDepthManager
+      include Aidp::MessageDisplay
+
       attr_reader :configuration, :registry
 
       def initialize(configuration, registry: nil, root_dir: nil)
@@ -150,11 +153,48 @@ module Aidp
         tier ||= current_tier
         validate_tier!(tier)
 
-        # If provider specified, try to find model for that provider
+        # First, try to get models from user's configuration for this tier
+        configured_models = configuration.models_for_tier(tier)
+
+        if configured_models.any?
+          # If provider specified, try to find model for that provider in config
+          if provider
+            matching_model = configured_models.find { |m| m[:provider] == provider }
+            if matching_model
+              Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
+                tier: tier,
+                provider: provider,
+                model: matching_model[:model])
+              return [matching_model[:provider], matching_model[:model], {}]
+            end
+
+            # If provider doesn't support tier and switching allowed, try other providers in config
+            unless configuration.allow_provider_switch_for_tier?
+              Aidp.log_warn("thinking_depth_manager", "Provider lacks tier in config, switching disabled",
+                tier: tier,
+                provider: provider)
+              return nil
+            end
+          end
+
+          # Try any configured model for this tier (prioritize first in list)
+          first_model = configured_models.first
+          if first_model
+            Aidp.log_info("thinking_depth_manager", "Selected model from user config",
+              tier: tier,
+              original_provider: provider,
+              selected_provider: first_model[:provider],
+              model: first_model[:model])
+            return [first_model[:provider], first_model[:model], {}]
+          end
+        end
+
+        # Fall back to catalog-based selection if no models in user config
+        # If provider specified, try to find model for that provider in catalog
         if provider
           model_name, model_data = @registry.best_model_for_tier(tier, provider)
           if model_name
-            Aidp.log_debug("thinking_depth_manager", "Selected model",
+            Aidp.log_debug("thinking_depth_manager", "Selected model from catalog",
               tier: tier,
               provider: provider,
               model: model_name)
@@ -163,20 +203,24 @@ module Aidp
 
           # If provider doesn't support tier and switching allowed, try others
           unless configuration.allow_provider_switch_for_tier?
-            Aidp.log_warn("thinking_depth_manager", "Provider lacks tier, switching disabled",
+            Aidp.log_warn("thinking_depth_manager", "Provider lacks tier in catalog, switching disabled",
               tier: tier,
               provider: provider)
             return nil
           end
         end
 
-        # Try all providers
+        # Try all providers in catalog
+        if provider && !configuration.allow_provider_switch_for_tier?
+          return nil
+        end
+
         providers_to_try = provider ? [@registry.provider_names - [provider]].flatten : @registry.provider_names
 
         providers_to_try.each do |prov_name|
           model_name, model_data = @registry.best_model_for_tier(tier, prov_name)
           if model_name
-            Aidp.log_info("thinking_depth_manager", "Selected model from alternate provider",
+            Aidp.log_info("thinking_depth_manager", "Selected model from catalog (alternate provider)",
               tier: tier,
               original_provider: provider,
               selected_provider: prov_name,
@@ -185,10 +229,23 @@ module Aidp
           end
         end
 
-        Aidp.log_error("thinking_depth_manager", "No model found for tier",
+        # No model found for requested tier - try fallback to other tiers
+        Aidp.log_warn("thinking_depth_manager", "No model found for requested tier, trying fallback",
           tier: tier,
           provider: provider)
-        nil
+
+        result = try_fallback_tiers(tier, provider)
+
+        unless result
+          # Enhanced error message with discovery hints
+          display_enhanced_tier_error(tier, provider)
+
+          Aidp.log_error("thinking_depth_manager", "No model found for tier or fallback tiers",
+            tier: tier,
+            provider: provider)
+        end
+
+        result
       end
 
       # Get tier for a specific model
@@ -330,6 +387,165 @@ module Aidp
         # Keep history bounded
         @tier_history.shift if @tier_history.size > 100
       end
+
+      # Try to find a model in fallback tiers when requested tier has no models
+      # Tries lower tiers first (cheaper), then higher tiers
+      # Returns [provider_name, model_name, model_data] or nil
+      def try_fallback_tiers(requested_tier, provider)
+        # Generate fallback order: try lower tiers first, then higher
+        fallback_tiers = generate_fallback_tier_order(requested_tier)
+
+        fallback_tiers.each do |fallback_tier|
+          # First, try user's configuration for this fallback tier
+          configured_models = configuration.models_for_tier(fallback_tier)
+
+          if configured_models.any?
+            # Try specified provider first if given
+            if provider
+              matching_model = configured_models.find { |m| m[:provider] == provider }
+              if matching_model
+                Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from config)",
+                  requested_tier: requested_tier,
+                  fallback_tier: fallback_tier,
+                  provider: provider,
+                  model: matching_model[:model])
+                return [matching_model[:provider], matching_model[:model], {}]
+              end
+            end
+
+            # Try any configured model for this tier
+            first_model = configured_models.first
+            if first_model
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier and provider (from config)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                requested_provider: provider,
+                fallback_provider: first_model[:provider],
+                model: first_model[:model])
+              return [first_model[:provider], first_model[:model], {}]
+            end
+          end
+
+          # Fall back to catalog if no models in config
+          # Try specified provider first if given
+          if provider
+            model_name, model_data = @registry.best_model_for_tier(fallback_tier, provider)
+            if model_name
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier (from catalog)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, model_data]
+            end
+          end
+
+          # Try all available providers in catalog
+          @registry.provider_names.each do |prov_name|
+            next if prov_name == provider # Skip if already tried above
+
+            model_name, model_data = @registry.best_model_for_tier(fallback_tier, prov_name)
+            if model_name
+              Aidp.log_warn("thinking_depth_manager", "Falling back to different tier and provider (from catalog)",
+                requested_tier: requested_tier,
+                fallback_tier: fallback_tier,
+                requested_provider: provider,
+                fallback_provider: prov_name,
+                model: model_name)
+              return [prov_name, model_name, model_data]
+            end
+          end
+        end
+
+        nil
+      end
+
+      # Generate fallback tier order: lower tiers first (cheaper), then higher
+      # For example, if tier is "standard", try: mini, thinking, pro, max
+      def generate_fallback_tier_order(tier)
+        current_priority = @registry.tier_priority(tier) || 1
+        all_tiers = CapabilityRegistry::VALID_TIERS
+
+        # Split into lower and higher tiers
+        lower_tiers = all_tiers.select { |t| (@registry.tier_priority(t) || 0) < current_priority }.reverse
+        higher_tiers = all_tiers.select { |t| (@registry.tier_priority(t) || 0) > current_priority }
+
+        # Try lower tiers first (cost optimization), then higher tiers
+        lower_tiers + higher_tiers
+      end
+
+      # Display enhanced error message with discovery hints
+      def display_enhanced_tier_error(tier, provider)
+        return unless defined?(Aidp::MessageDisplay)
+
+        # Check if there are discovered models in cache
+        discovered_models = check_discovered_models(tier, provider)
+
+        if discovered_models&.any?
+          display_tier_error_with_suggestions(tier, provider, discovered_models)
+        else
+          display_tier_error_with_discovery_hint(tier, provider)
+        end
+      end
+
+      # Check cache for discovered models for this tier
+      def check_discovered_models(tier, provider)
+        require_relative "model_cache"
+        require_relative "model_registry"
+
+        cache = Aidp::Harness::ModelCache.new
+        registry = Aidp::Harness::ModelRegistry.new
+
+        # Get all cached models for the provider
+        cached_models = cache.get_cached_models(provider)
+        return nil unless cached_models&.any?
+
+        # Filter to models for the requested tier
+        tier_models = cached_models.select do |model|
+          family = model[:family] || model["family"]
+          model_info = registry.get_model_info(family)
+          model_info && model_info["tier"] == tier.to_s
+        end
+
+        tier_models.any? ? tier_models : nil
+      rescue => e
+        Aidp.log_debug("thinking_depth_manager", "failed to check cached models",
+          error: e.message)
+        nil
+      end
+
+      # Display error with model suggestions from cache
+      def display_tier_error_with_suggestions(tier, provider, models)
+        display_message("\n❌ No model configured for '#{tier}' tier", type: :error)
+        display_message("   Provider: #{provider}", type: :info) if provider
+
+        display_message("\n💡 Discovered models for this tier:", type: :highlight)
+        models.first(3).each do |model|
+          model_name = model[:name] || model["name"]
+          display_message("   - #{model_name}", type: :info)
+        end
+
+        display_message("\n   Add to aidp.yml:", type: :highlight)
+        display_message("   providers:", type: :info)
+        display_message("     #{provider}:", type: :info)
+        display_message("       thinking:", type: :info)
+        display_message("         tiers:", type: :info)
+        display_message("           #{tier}:", type: :info)
+        display_message("             models:", type: :info)
+        first_model = models.first[:name] || models.first["name"]
+        display_message("               - model: #{first_model}\n", type: :info)
+      end
+
+      # Display error with discovery hint
+      def display_tier_error_with_discovery_hint(tier, provider)
+        display_message("\n❌ No model configured for '#{tier}' tier", type: :error)
+        display_message("   Provider: #{provider}", type: :info) if provider
+
+        display_message("\n💡 Suggested actions:", type: :highlight)
+        display_message("   1. Run 'aidp models discover' to find available models", type: :info)
+        display_message("   2. Run 'aidp models list --tier=#{tier}' to see models for this tier", type: :info)
+        display_message("   3. Run 'aidp models validate' to check your configuration\n", type: :info)
+      end
     end
   end
 end

data/lib/aidp/message_display.rb

@@ -25,7 +25,6 @@ module Aidp
 
     # Instance helper for displaying a colored message via TTY::Prompt
     def display_message(message, type: :info)
-      return if suppress_display_message?(message)
       # Ensure message is UTF-8 encoded to handle emoji and special characters
       message_str = message.to_s
       message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -43,32 +42,9 @@ module Aidp
       end
     end
 
-    # Check if specific display message should be suppressed in test/CI environments
-    def suppress_display_message?(message)
-      return false unless in_test_environment?
-
-      message_str = message.to_s
-      # Only suppress specific automated status messages, not CLI output
-      message_str.include?("🔄 Provider switch:") ||
-        message_str.include?("🔄 Model switch:") ||
-        message_str.include?("🔴 Circuit breaker opened") ||
-        message_str.include?("🟢 Circuit breaker reset") ||
-        message_str.include?("❌ No providers available") ||
-        message_str.include?("❌ No models available") ||
-        message_str.include?("📊 Execution Summary") ||
-        message_str.include?("▶️  [") ||  # Workstream execution messages
-        message_str.include?("✅ [") ||    # Workstream success messages
-        message_str.include?("❌ [")       # Workstream failure messages
-    end
-
-    def in_test_environment?
-      ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
-    end
-
     module ClassMethods
       # Class-level display helper (uses fresh prompt to respect $stdout changes)
       def display_message(message, type: :info)
-        return if suppress_display_message?(message)
         # Ensure message is UTF-8 encoded to handle emoji and special characters
         message_str = message.to_s
         message_str = message_str.force_encoding("UTF-8") if message_str.encoding.name == "ASCII-8BIT"
@@ -78,28 +54,6 @@ module Aidp
 
       private
 
-      # Check if specific display message should be suppressed in test/CI environments
-      def suppress_display_message?(message)
-        return false unless in_test_environment?
-
-        message_str = message.to_s
-        # Only suppress specific automated status messages, not CLI output
-        message_str.include?("🔄 Provider switch:") ||
-          message_str.include?("🔄 Model switch:") ||
-          message_str.include?("🔴 Circuit breaker opened") ||
-          message_str.include?("🟢 Circuit breaker reset") ||
-          message_str.include?("❌ No providers available") ||
-          message_str.include?("❌ No models available") ||
-          message_str.include?("📊 Execution Summary") ||
-          message_str.include?("▶️  [") ||  # Workstream execution messages
-          message_str.include?("✅ [") ||    # Workstream success messages
-          message_str.include?("❌ [")       # Workstream failure messages
-      end
-
-      def in_test_environment?
-        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
-      end
-
       # Don't memoize - create fresh prompt each time to respect $stdout redirection in tests
       def class_message_display_prompt
         TTY::Prompt.new

data/lib/aidp/providers/adapter.rb

@@ -65,8 +65,7 @@ module Aidp
       #     supports_json_mode: true,
       #     supports_tool_use: true,
       #     supports_vision: false,
-      #     supports_file_upload: true,
-      #     streaming: true
+      #     supports_file_upload: true
       #   }
       def capabilities
         {
@@ -75,8 +74,7 @@ module Aidp
           supports_json_mode: false,
           supports_tool_use: false,
           supports_vision: false,
-          supports_file_upload: false,
-          streaming: false
+          supports_file_upload: false
         }
       end