ace-support-models 0.9.0

data/lib/ace/support/models/molecules/model_searcher.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Models
+      module Molecules
+        # Searches for models with fuzzy matching
+        class ModelSearcher
+          # Initialize searcher
+          # @param cache_manager [CacheManager, nil] Cache manager instance
+          def initialize(cache_manager: nil)
+            @cache_manager = cache_manager || CacheManager.new
+          end
+
+          # Search for models matching query
+          # @param query [String, nil] Search query (nil = match all)
+          # @param provider [String, nil] Limit to specific provider
+          # @param limit [Integer] Max results
+          # @param filters [Hash, nil] Additional filters (key-value pairs)
+          # @param with_total [Boolean] Return hash with models and total count
+          # @return [Array<Models::ModelInfo>, Hash] Matching models or {models:, total:}
+          #
+          # Memory optimization: Defers ModelInfo instantiation until after pagination.
+          # This avoids materializing thousands of objects for large caches with broad queries.
+          def search(query = nil, provider: nil, limit: 20, filters: nil, with_total: false)
+            data = load_data
+            results = []
+
+            providers_to_search = provider ? [provider] : data.keys
+
+            # Phase 1: Collect lightweight hashes with scores (no ModelInfo instantiation)
+            providers_to_search.each do |provider_id|
+              provider_data = data[provider_id]
+              next unless provider_data
+
+              (provider_data["models"] || {}).each do |model_id, model_data|
+                # If no query provided, match all (score = 1)
+                score = query ? match_score(query, model_id, model_data["name"]) : 1
+                if score > 0
+                  results << {
+                    data: model_data,
+                    provider_id: provider_id,
+                    score: score
+                  }
+                end
+              end
+            end
+
+            # Phase 2: Sort by score (still lightweight hashes)
+            sorted = results.sort_by { |r| -r[:score] }
+
+            # Phase 3: Apply filters if provided (requires ModelInfo for capability checks)
+            if filters
+              # Must instantiate to filter, but filter early before limit
+              models = sorted.map { |r| Models::ModelInfo.from_hash(r[:data], provider_id: r[:provider_id]) }
+              models = Atoms::ModelFilter.apply(models, filters)
+              total = models.size
+              limited = models.first(limit)
+            else
+              # No filters: instantiate only the limited set
+              total = sorted.size
+              limited = sorted.first(limit).map do |r|
+                Models::ModelInfo.from_hash(r[:data], provider_id: r[:provider_id])
+              end
+            end
+
+            if with_total
+              {models: limited, total: total}
+            else
+              limited
+            end
+          end
+
+          # List all models
+          # @param provider [String, nil] Limit to specific provider
+          # @return [Array<Models::ModelInfo>] All models
+          def all(provider: nil)
+            data = load_data
+            models = []
+
+            providers_to_search = provider ? [provider] : data.keys
+
+            providers_to_search.each do |provider_id|
+              provider_data = data[provider_id]
+              next unless provider_data
+
+              (provider_data["models"] || {}).each do |_model_id, model_data|
+                models << Models::ModelInfo.from_hash(model_data, provider_id: provider_id)
+              end
+            end
+
+            models.sort_by(&:full_id)
+          end
+
+          # Count models
+          # @param provider [String, nil] Limit to specific provider
+          # @return [Integer] Model count
+          def count(provider: nil)
+            data = load_data
+            total = 0
+
+            providers_to_search = provider ? [provider] : data.keys
+
+            providers_to_search.each do |provider_id|
+              provider_data = data[provider_id]
+              next unless provider_data
+
+              total += (provider_data["models"] || {}).size
+            end
+
+            total
+          end
+
+          # Get stats about the data
+          # @return [Hash] Stats
+          def stats
+            data = load_data
+            provider_count = data.size
+            model_count = 0
+            models_by_provider = {}
+
+            data.each do |provider_id, provider_data|
+              count = (provider_data["models"] || {}).size
+              models_by_provider[provider_id] = count
+              model_count += count
+            end
+
+            {
+              providers: provider_count,
+              models: model_count,
+              models_by_provider: models_by_provider.sort_by { |_, v| -v }.to_h
+            }
+          end
+
+          private
+
+          def load_data
+            data = @cache_manager.read
+            raise CacheError, "No cache data. Run 'ace-models sync' first." unless data
+
+            data
+          end
+
+          def match_score(query, model_id, model_name)
+            query_down = query.downcase
+            id_down = model_id.downcase
+            name_down = (model_name || "").downcase
+
+            score = 0
+
+            # Exact match
+            return 100 if id_down == query_down || name_down == query_down
+
+            # Starts with
+            score += 50 if id_down.start_with?(query_down) || name_down.start_with?(query_down)
+
+            # Contains
+            score += 25 if id_down.include?(query_down) || name_down.include?(query_down)
+
+            # Word match
+            query_words = query_down.split(/[-_\s]/)
+            id_words = id_down.split(/[-_\s]/)
+            name_words = name_down.split(/[-_\s]/)
+
+            query_words.each do |qw|
+              score += 10 if id_words.any? { |w| w.start_with?(qw) }
+              score += 10 if name_words.any? { |w| w.start_with?(qw) }
+            end
+
+            score
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/molecules/model_validator.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Models
+      module Molecules
+        # Validates model names against cached data
+        class ModelValidator
+          MAX_SUGGESTIONS = 5
+          # Maximum string length for Levenshtein distance calculation.
+          # Prevents O(n*m) memory/time blowups on pathological inputs.
+          MAX_LEVENSHTEIN_LENGTH = 500
+
+          # Initialize validator
+          # @param cache_manager [CacheManager, nil] Cache manager instance
+          def initialize(cache_manager: nil)
+            @cache_manager = cache_manager || CacheManager.new
+          end
+
+          # Validate a model exists
+          # @param model_id [String] Model ID (provider:model or just model)
+          # @return [Models::ModelInfo] Model info if valid
+          # @raise [ProviderNotFoundError] if provider doesn't exist
+          # @raise [ModelNotFoundError] if model doesn't exist
+          # @raise [ValidationError] if model_id format is invalid
+          def validate(model_id)
+            validate_format!(model_id)
+            data = load_data
+            provider_id, model_name = parse_model_id(model_id)
+
+            # Check provider exists
+            provider_data = data[provider_id]
+            raise ProviderNotFoundError, provider_id unless provider_data
+
+            # Check model exists
+            model_data = provider_data.dig("models", model_name)
+            unless model_data
+              suggestions = find_suggestions(provider_data["models"]&.keys || [], model_name)
+              raise ModelNotFoundError.new("#{provider_id}:#{model_name}", suggestions: suggestions)
+            end
+
+            Models::ModelInfo.from_hash(model_data, provider_id: provider_id)
+          end
+
+          # Check if model is valid (no exception)
+          # @param model_id [String] Model ID
+          # @return [Boolean]
+          def valid?(model_id)
+            validate(model_id)
+            true
+          rescue ModelNotFoundError, ProviderNotFoundError
+            false
+          end
+
+          # Get model info (returns nil instead of raising)
+          # @param model_id [String] Model ID
+          # @return [Models::ModelInfo, nil]
+          def get(model_id)
+            validate(model_id)
+          rescue ModelNotFoundError, ProviderNotFoundError
+            nil
+          end
+
+          # List all providers
+          # @return [Array<String>] Provider IDs
+          def providers
+            load_data.keys.sort
+          end
+
+          # List models for a provider
+          # @param provider_id [String] Provider ID
+          # @return [Array<String>] Model IDs
+          def models_for(provider_id)
+            data = load_data
+            provider_data = data[provider_id]
+            return [] unless provider_data
+
+            (provider_data["models"]&.keys || []).sort
+          end
+
+          private
+
+          def load_data
+            data = @cache_manager.read
+            raise CacheError, "No cache data. Run 'ace-models sync' first." unless data
+
+            data
+          end
+
+          # Validate model_id format before cache lookup
+          # @raise [ValidationError] if format is invalid
+          def validate_format!(model_id)
+            raise ValidationError, "Model ID cannot be nil" if model_id.nil?
+            raise ValidationError, "Model ID cannot be empty" if model_id.strip.empty?
+            raise ValidationError, "Model ID is too short" if model_id.length < 2
+
+            # If contains colon, validate both parts are present
+            if model_id.include?(":")
+              parts = model_id.split(":", 2)
+              raise ValidationError, "Provider cannot be empty in 'provider:model' format" if parts[0].strip.empty?
+              raise ValidationError, "Model name cannot be empty in 'provider:model' format" if parts[1].nil? || parts[1].strip.empty?
+            end
+          end
+
+          def parse_model_id(model_id)
+            if model_id.include?(":")
+              parts = model_id.split(":", 2)
+              [parts[0], parts[1]]
+            else
+              # Try to find provider by model name
+              data = load_data
+              data.each do |provider_id, provider_data|
+                if provider_data.dig("models", model_id)
+                  return [provider_id, model_id]
+                end
+              end
+              # Default to treating as unknown provider
+              raise ValidationError, "Model ID must be in format 'provider:model' (e.g., 'openai:gpt-4o')"
+            end
+          end
+
+          def find_suggestions(model_names, target)
+            return [] if model_names.empty?
+
+            # Pre-filter by length before expensive levenshtein
+            # Skip names that differ by more than 3 characters in length
+            candidates = model_names.select do |name|
+              (name.length - target.length).abs <= 3
+            end
+
+            # Simple prefix/substring matching for suggestions
+            suggestions = candidates.select do |name|
+              name.include?(target) || target.include?(name) ||
+                levenshtein_distance(name, target) <= 3
+            end
+
+            suggestions.first(MAX_SUGGESTIONS)
+          end
+
+          # Simple Levenshtein distance for fuzzy matching
+          # @param s1 [String] First string
+          # @param s2 [String] Second string
+          # @return [Integer] Edit distance, or Float::INFINITY if inputs exceed MAX_LEVENSHTEIN_LENGTH
+          def levenshtein_distance(s1, s2)
+            # Guard against pathological inputs that would cause O(n*m) blowups
+            if s1.length > MAX_LEVENSHTEIN_LENGTH || s2.length > MAX_LEVENSHTEIN_LENGTH
+              return Float::INFINITY
+            end
+
+            m = s1.length
+            n = s2.length
+            return n if m.zero?
+            return m if n.zero?
+
+            d = Array.new(m + 1) { Array.new(n + 1) }
+
+            (0..m).each { |i| d[i][0] = i }
+            (0..n).each { |j| d[0][j] = j }
+
+            (1..m).each do |i|
+              (1..n).each do |j|
+                cost = (s1[i - 1] == s2[j - 1]) ? 0 : 1
+                d[i][j] = [
+                  d[i - 1][j] + 1,
+                  d[i][j - 1] + 1,
+                  d[i - 1][j - 1] + cost
+                ].min
+              end
+            end
+
+            d[m][n]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/molecules/provider_sync_diff.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Ace
+  module Support
+    module Models
+      module Molecules
+        # Generates diff between current provider configs and models.dev data
+        # Shows added, removed, and deprecated models for each provider
+        class ProviderSyncDiff
+          # Model change types
+          ADDED = :added
+          REMOVED = :removed
+          UNCHANGED = :unchanged
+          DEPRECATED = :deprecated
+
+          attr_reader :cache_manager
+
+          # Initialize diff generator
+          # @param cache_manager [CacheManager, nil] Cache manager for models.dev data
+          def initialize(cache_manager: nil)
+            @cache_manager = cache_manager || CacheManager.new
+          end
+
+          # Generate diff for all providers
+          # @param current_configs [Hash<String, Hash>] Provider name => config hash
+          # @param provider_filter [String, nil] Limit to specific provider
+          # @param since_date [Date, nil] Only show models released after this date
+          # @param show_all [Boolean] Show all models regardless of date (ignores since_date)
+          # @return [Hash] Diff results by provider
+          def generate(current_configs, provider_filter: nil, since_date: nil, show_all: false)
+            models_dev_data = load_models_dev_data
+            results = {}
+
+            current_configs.each do |provider_name, config|
+              # Skip if filtering and this isn't the target provider
+              next if provider_filter && provider_name != provider_filter
+
+              # Determine the models.dev ID to use (may be mapped via models_dev_id field)
+              models_dev_id = Atoms::ProviderConfigReader.extract_models_dev_id(config)
+
+              # Find matching provider in models.dev
+              provider_data = find_provider(models_dev_data, models_dev_id)
+
+              if provider_data.nil?
+                # Generate hint for unmapped providers
+                hint = suggest_models_dev_id(models_dev_data, provider_name)
+                results[provider_name] = {
+                  status: :not_found,
+                  message: "Provider not found in models.dev",
+                  hint: hint
+                }
+                next
+              end
+
+              # Determine the date to filter by
+              filter_date = determine_filter_date(config, since_date, show_all)
+
+              # Generate diff for this provider
+              results[provider_name] = diff_provider(config, provider_data, since_date: filter_date, provider_name: provider_name)
+              results[provider_name][:last_synced] = Atoms::ProviderConfigReader.extract_last_synced(config)
+              results[provider_name][:models_dev_id] = models_dev_id if models_dev_id != provider_name
+            end
+
+            results
+          end
+
+          # Generate diff for a single provider
+          # @param config [Hash] Current provider config
+          # @param provider_data [Hash] models.dev provider data
+          # @param since_date [Date, nil] Only include models released after this date
+          # @param provider_name [String, nil] Provider name for canonicalization (e.g., "openrouter")
+          # @return [Hash] Diff result
+          def diff_provider(config, provider_data, since_date: nil, provider_name: nil)
+            current_models = Set.new(Atoms::ProviderConfigReader.extract_models(config))
+            models_dev_models = extract_models_dev_models(provider_data)
+
+            # Build a set of canonical model names from models.dev for efficient lookup
+            models_dev_canonical = Set.new(models_dev_models.keys)
+
+            # Build a mapping of canonical names to original names for current models
+            # This handles cases like "model:nitro" -> "model"
+            current_canonical_to_original = {}
+            current_models.each do |model_id|
+              canonical = Atoms::ModelNameCanonicalizer.canonicalize(model_id, provider: provider_name)
+              current_canonical_to_original[canonical] ||= []
+              current_canonical_to_original[canonical] << model_id
+            end
+
+            added = []
+            added_with_dates = {}
+            removed = []
+            unchanged = []
+            deprecated = []
+
+            # Check models.dev models against current config
+            # Use canonical names for matching
+            models_dev_models.each do |model_id, model_data|
+              # Check if any current model (or its canonical form) matches this models.dev model
+              has_match = current_canonical_to_original.key?(model_id)
+
+              if has_match
+                if model_data[:status] == "deprecated"
+                  deprecated << model_id
+                else
+                  unchanged << model_id
+                end
+              else
+                if model_data[:status] == "deprecated"
+                  # Don't suggest adding deprecated models
+                  next
+                end
+
+                # Filter by release date if specified
+                if since_date && model_data[:release_date]
+                  next if model_data[:release_date] <= since_date
+                end
+
+                added << model_id
+                added_with_dates[model_id] = model_data[:release_date]
+              end
+            end
+
+            # Check for removed models (in config but not in models.dev)
+            # Use canonical names to avoid false positives for suffixed models
+            current_models.each do |model_id|
+              canonical = Atoms::ModelNameCanonicalizer.canonicalize(model_id, provider: provider_name)
+              unless models_dev_canonical.include?(canonical)
+                removed << model_id
+              end
+            end
+
+            {
+              status: :ok,
+              added: added.sort,
+              added_with_dates: added_with_dates,
+              removed: removed.sort,
+              unchanged: unchanged.sort,
+              deprecated: deprecated.sort,
+              models_dev_count: models_dev_models.size,
+              current_count: current_models.size,
+              filtered_by_date: !since_date.nil?
+            }
+          end
+
+          # Calculate summary statistics
+          # @param results [Hash] Diff results by provider
+          # @return [Hash] Summary stats
+          def summary(results)
+            total_added = 0
+            total_removed = 0
+            total_unchanged = 0
+            total_deprecated = 0
+            providers_synced = 0
+            providers_skipped = 0
+
+            results.each do |_provider, result|
+              if result[:status] == :ok
+                providers_synced += 1
+                total_added += result[:added].size
+                total_removed += result[:removed].size
+                total_unchanged += result[:unchanged].size
+                total_deprecated += result[:deprecated].size
+              else
+                providers_skipped += 1
+              end
+            end
+
+            {
+              added: total_added,
+              removed: total_removed,
+              unchanged: total_unchanged,
+              deprecated: total_deprecated,
+              providers_synced: providers_synced,
+              providers_skipped: providers_skipped
+            }
+          end
+
+          # Check if there are any changes
+          # @param results [Hash] Diff results
+          # @return [Boolean] true if any changes detected
+          def any_changes?(results)
+            results.any? do |_provider, result|
+              next false unless result[:status] == :ok
+
+              result[:added].any? || result[:removed].any?
+            end
+          end
+
+          private
+
+          def load_models_dev_data
+            data = cache_manager.read
+            raise CacheError, "No models.dev cache found. Run 'ace-models sync' first." unless data
+
+            data
+          end
+
+          def find_provider(models_dev_data, provider_name)
+            return nil unless provider_name
+
+            # Try exact match first
+            return models_dev_data[provider_name] if models_dev_data.key?(provider_name)
+
+            # Try case-insensitive match
+            models_dev_data.each do |id, data|
+              return data if id.downcase == provider_name.downcase
+            end
+
+            # Try matching by provider name field
+            models_dev_data.each do |_id, data|
+              name = data["name"] || data["id"]
+              return data if name&.downcase == provider_name.downcase
+            end
+
+            nil
+          end
+
+          def extract_models_dev_models(provider_data)
+            models = provider_data["models"] || {}
+            result = {}
+
+            models.each do |model_id, model_data|
+              release_date = parse_date(model_data["release_date"])
+              result[model_id] = {
+                status: model_data["status"],
+                name: model_data["name"] || model_id,
+                release_date: release_date
+              }
+            end
+
+            result
+          end
+
+          def parse_date(value)
+            return nil unless value
+
+            case value
+            when Date
+              value
+            when String
+              Date.parse(value)
+            end
+          rescue ArgumentError
+            nil
+          end
+
+          def determine_filter_date(config, explicit_since_date, show_all)
+            return nil if show_all
+
+            # Use explicit --since date if provided
+            return explicit_since_date if explicit_since_date
+
+            # Otherwise use last_synced from config
+            Atoms::ProviderConfigReader.extract_last_synced(config)
+          end
+
+          def suggest_models_dev_id(models_dev_data, provider_name)
+            # Try to find a provider that might match
+            provider_lower = provider_name.downcase
+
+            # Common mappings
+            common_mappings = {
+              "claude" => "anthropic",
+              "gpt" => "openai",
+              "gemini" => "google",
+              "llama" => "meta"
+            }
+
+            # Check common mappings first
+            common_mappings.each do |key, value|
+              if provider_lower.include?(key) && models_dev_data.key?(value)
+                return "Add 'models_dev_id: #{value}' to provider config"
+              end
+            end
+
+            # Try fuzzy matching on provider names
+            models_dev_data.each do |id, _data|
+              if id.downcase.include?(provider_lower) || provider_lower.include?(id.downcase)
+                return "Add 'models_dev_id: #{id}' to provider config"
+              end
+            end
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end