ace-support-models 0.9.0

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Ace
+  module Support
+    module Models
+      module Molecules
+        # Manages local cache of API data
+        class CacheManager
+          API_CACHE_FILE = "api.json"
+          PREVIOUS_CACHE_FILE = "api.previous.json"
+          METADATA_FILE = "metadata.json"
+
+          attr_reader :cache_dir
+
+          # Initialize cache manager
+          # @param cache_dir [String, nil] Cache directory (default: from CachePathResolver)
+          def initialize(cache_dir: nil)
+            @cache_dir = cache_dir || Atoms::CachePathResolver.resolve
+          end
+
+          # Read current API cache
+          # @return [Hash, nil] Parsed API data or nil
+          def read
+            content = Atoms::FileReader.read(api_cache_path)
+            return nil unless content
+
+            Atoms::JsonParser.parse(content)
+          end
+
+          # Read previous API cache (for diff)
+          # @return [Hash, nil] Parsed previous API data or nil
+          def read_previous
+            content = Atoms::FileReader.read(previous_cache_path)
+            return nil unless content
+
+            Atoms::JsonParser.parse(content)
+          end
+
+          # Write API data to cache
+          # @param data [Hash] API data
+          # @return [Boolean] true on success
+          def write(data)
+            # Move current to previous first
+            if Atoms::FileReader.exist?(api_cache_path)
+              Atoms::FileWriter.rename(api_cache_path, previous_cache_path)
+            end
+
+            # Write new data
+            json = Atoms::JsonParser.to_json(data, pretty: false)
+            Atoms::FileWriter.write(api_cache_path, json)
+
+            # Update metadata
+            update_metadata
+
+            true
+          end
+
+          # Read cache metadata
+          # @return [Hash] Metadata hash
+          def metadata
+            content = Atoms::FileReader.read(metadata_path)
+            return default_metadata unless content
+
+            Atoms::JsonParser.parse(content)
+          rescue ApiError
+            default_metadata
+          end
+
+          # Check if cache exists
+          # @return [Boolean]
+          def exists?
+            Atoms::FileReader.exist?(api_cache_path)
+          end
+
+          # Alias for exists? for clearer CLI usage
+          # @return [Boolean]
+          def cached?
+            exists?
+          end
+
+          # List all providers with model counts
+          # @return [Array<Hash>] Provider info hashes
+          def list_providers
+            data = read
+            return [] unless data
+
+            normalize_providers(data).map do |provider_id, provider_data|
+              models = normalize_models(provider_data)
+              {
+                id: provider_id,
+                model_count: models.size
+              }
+            end
+          end
+
+          # Get provider details with models
+          # @param provider_id [String] Provider ID
+          # @return [Hash, nil] Provider data or nil if not found
+          def get_provider(provider_id)
+            data = read
+            return nil unless data
+
+            provider_data = normalize_providers(data)[provider_id]
+            return nil unless provider_data
+
+            models = normalize_models(provider_data).map do |model_id, model_data|
+              {
+                id: model_id,
+                name: model_data["name"] || model_id,
+                deprecated: model_data["deprecated"] == true
+              }
+            end
+
+            {
+              id: provider_id,
+              models: models.sort_by { |m| m[:id] }
+            }
+          end
+
+          # Check if cache is fresh (less than max_age old)
+          # @param max_age [Integer] Max age in seconds (default: 24 hours)
+          # @return [Boolean]
+          def fresh?(max_age: 86_400)
+            mtime = Atoms::FileReader.mtime(api_cache_path)
+            return false unless mtime
+
+            (Time.now - mtime) < max_age
+          end
+
+          # Get last sync time
+          # @return [Time, nil]
+          def last_sync_at
+            meta = metadata
+            return nil unless meta["last_sync_at"]
+
+            Time.parse(meta["last_sync_at"])
+          rescue ArgumentError
+            nil
+          end
+
+          # Clear cache
+          # @return [Hash] Result with status and deleted files
+          def clear
+            deleted_files = []
+            [api_cache_path, previous_cache_path, metadata_path].each do |path|
+              if Atoms::FileReader.exist?(path)
+                Atoms::FileWriter.delete(path)
+                deleted_files << File.basename(path)
+              end
+            end
+
+            {
+              status: :success,
+              deleted_files: deleted_files,
+              message: deleted_files.empty? ? "Cache was already empty" : "Deleted #{deleted_files.size} files"
+            }
+          end
+
+          private
+
+          def api_cache_path
+            File.join(cache_dir, API_CACHE_FILE)
+          end
+
+          def previous_cache_path
+            File.join(cache_dir, PREVIOUS_CACHE_FILE)
+          end
+
+          def metadata_path
+            File.join(cache_dir, METADATA_FILE)
+          end
+
+          def update_metadata
+            meta = {
+              "last_sync_at" => Time.now.utc.iso8601,
+              "version" => VERSION
+            }
+            json = Atoms::JsonParser.to_json(meta, pretty: true)
+            Atoms::FileWriter.write(metadata_path, json)
+          end
+
+          def default_metadata
+            {
+              "last_sync_at" => nil,
+              "version" => VERSION
+            }
+          end
+
+          def normalize_providers(data)
+            return {} unless data.is_a?(Hash)
+
+            wrapped = data["providers"]
+            return normalize_provider_collection(wrapped) unless wrapped.nil?
+
+            data
+          end
+
+          def normalize_provider_collection(providers)
+            case providers
+            when Hash
+              providers
+            when Array
+              providers.each_with_object({}) do |provider, acc|
+                next unless provider.is_a?(Hash)
+
+                provider_id = provider["id"]
+                acc[provider_id] = provider if provider_id
+              end
+            else
+              {}
+            end
+          end
+
+          def normalize_models(provider_data)
+            models = provider_data["models"]
+
+            case models
+            when Hash
+              models
+            when Array
+              models.each_with_object({}) do |model, acc|
+                next unless model.is_a?(Hash)
+
+                model_id = model["id"]
+                acc[model_id] = model if model_id
+              end
+            else
+              {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Ace
+  module Support
+    module Models
+      module Molecules
+        # Calculates query costs based on token usage
+        class CostCalculator
+          # Initialize calculator
+          # @param validator [ModelValidator, nil] Validator instance
+          def initialize(validator: nil)
+            @validator = validator || ModelValidator.new
+          end
+
+          # Calculate cost for a query
+          # @param model_id [String] Model ID
+          # @param input_tokens [Integer] Input token count
+          # @param output_tokens [Integer] Output token count
+          # @param reasoning_tokens [Integer] Reasoning token count
+          # @return [Hash] Cost breakdown
+          def calculate(model_id, input_tokens:, output_tokens:, reasoning_tokens: 0)
+            model = @validator.validate(model_id)
+            pricing = model.pricing
+
+            unless pricing.available?
+              return {
+                model_id: model.full_id,
+                model_name: model.name,
+                error: "No pricing data available for this model",
+                available: false
+              }
+            end
+
+            input_cost = calculate_component(input_tokens, pricing.input)
+            output_cost = calculate_component(output_tokens, pricing.output)
+            reasoning_cost = calculate_component(reasoning_tokens, pricing.reasoning)
+
+            total = input_cost + output_cost + reasoning_cost
+
+            {
+              model_id: model.full_id,
+              model_name: model.name,
+              available: true,
+              tokens: {
+                input: input_tokens,
+                output: output_tokens,
+                reasoning: reasoning_tokens,
+                total: input_tokens + output_tokens + reasoning_tokens
+              },
+              rates: {
+                input: pricing.input,
+                output: pricing.output,
+                reasoning: pricing.reasoning
+              },
+              costs: {
+                input: input_cost,
+                output: output_cost,
+                reasoning: reasoning_cost,
+                total: total
+              },
+              formatted: {
+                input: format_cost(input_cost),
+                output: format_cost(output_cost),
+                reasoning: format_cost(reasoning_cost),
+                total: format_cost(total)
+              }
+            }
+          end
+
+          # Format a cost breakdown as human-readable string
+          # @param result [Hash] Result from calculate
+          # @return [String] Formatted string
+          def format(result)
+            return result[:error] unless result[:available]
+
+            lines = []
+            lines << "Model: #{result[:model_name]} (#{result[:model_id]})"
+            lines << ""
+
+            tokens = result[:tokens]
+            result[:costs]
+            rates = result[:rates]
+
+            if tokens[:input] > 0
+              lines << "Input:     #{format_tokens(tokens[:input])} tokens × $#{rates[:input]}/M = #{result[:formatted][:input]}"
+            end
+
+            if tokens[:output] > 0
+              lines << "Output:    #{format_tokens(tokens[:output])} tokens × $#{rates[:output]}/M = #{result[:formatted][:output]}"
+            end
+
+            if tokens[:reasoning] > 0 && rates[:reasoning]
+              lines << "Reasoning: #{format_tokens(tokens[:reasoning])} tokens × $#{rates[:reasoning]}/M = #{result[:formatted][:reasoning]}"
+            end
+
+            lines << ""
+            lines << "Total: #{result[:formatted][:total]}"
+
+            lines.join("\n")
+          end
+
+          private
+
+          def calculate_component(tokens, rate)
+            return 0.0 unless rate && tokens > 0
+
+            (tokens / 1_000_000.0) * rate
+          end
+
+          def format_cost(cost)
+            return "$0.00" if cost.zero?
+
+            if cost < 0.01
+              "$#{sprintf("%.4f", cost)}"
+            elsif cost < 1
+              "$#{sprintf("%.3f", cost)}"
+            else
+              "$#{sprintf("%.2f", cost)}"
+            end
+          end
+
+          def format_tokens(count)
+            if count >= 1_000_000
+              "#{sprintf("%.1f", count / 1_000_000.0)}M"
+            elsif count >= 1_000
+              "#{sprintf("%.1f", count / 1_000.0)}K"
+            else
+              count.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Ace
+  module Support
+    module Models
+      module Molecules
+        # Generates diff between cached API versions
+        class DiffGenerator
+          TRACKED_FIELDS = %w[name cost limit status modalities].freeze
+
+          # Initialize diff generator
+          # @param cache_manager [CacheManager, nil] Cache manager instance
+          def initialize(cache_manager: nil)
+            @cache_manager = cache_manager || CacheManager.new
+          end
+
+          # Generate diff between current and previous cache
+          # @return [Models::DiffResult] Diff result
+          def generate
+            current = @cache_manager.read
+            previous = @cache_manager.read_previous
+
+            unless current
+              return Models::DiffResult.new(
+                current_sync_at: Time.now
+              )
+            end
+
+            unless previous
+              # No previous - everything is "new"
+              all_models = extract_all_models(current)
+              return Models::DiffResult.new(
+                added_models: all_models,
+                added_providers: current.keys,
+                current_sync_at: @cache_manager.last_sync_at
+              )
+            end
+
+            compare(previous, current)
+          end
+
+          private
+
+          def compare(previous, current)
+            added_models = []
+            removed_models = []
+            updated_models = []
+
+            prev_providers = Set.new(previous.keys)
+            curr_providers = Set.new(current.keys)
+
+            # New providers
+            added_providers = (curr_providers - prev_providers).to_a
+
+            # Removed providers
+            removed_providers = (prev_providers - curr_providers).to_a
+
+            # All models from removed providers are removed
+            removed_providers.each do |provider_id|
+              extract_provider_models(previous, provider_id).each do |model_id|
+                removed_models << model_id
+              end
+            end
+
+            # All models from new providers are added
+            added_providers.each do |provider_id|
+              extract_provider_models(current, provider_id).each do |model_id|
+                added_models << model_id
+              end
+            end
+
+            # Compare models in shared providers
+            (prev_providers & curr_providers).each do |provider_id|
+              prev_models = previous.dig(provider_id, "models") || {}
+              curr_models = current.dig(provider_id, "models") || {}
+
+              prev_model_ids = Set.new(prev_models.keys)
+              curr_model_ids = Set.new(curr_models.keys)
+
+              # Added models
+              (curr_model_ids - prev_model_ids).each do |model_id|
+                added_models << "#{provider_id}:#{model_id}"
+              end
+
+              # Removed models
+              (prev_model_ids - curr_model_ids).each do |model_id|
+                removed_models << "#{provider_id}:#{model_id}"
+              end
+
+              # Check for updates in shared models
+              (prev_model_ids & curr_model_ids).each do |model_id|
+                changes = detect_changes(prev_models[model_id], curr_models[model_id])
+                if changes.any?
+                  updated_models << Models::ModelUpdate.new(
+                    model_id: "#{provider_id}:#{model_id}",
+                    changes: changes
+                  )
+                end
+              end
+            end
+
+            Models::DiffResult.new(
+              added_models: added_models.sort,
+              removed_models: removed_models.sort,
+              updated_models: updated_models,
+              added_providers: added_providers.sort,
+              removed_providers: removed_providers.sort,
+              previous_sync_at: @cache_manager.metadata["last_sync_at"] ? Time.parse(@cache_manager.metadata["last_sync_at"]) : nil,
+              current_sync_at: @cache_manager.last_sync_at
+            )
+          end
+
+          def extract_all_models(data)
+            models = []
+            data.each do |provider_id, provider_data|
+              (provider_data["models"] || {}).each_key do |model_id|
+                models << "#{provider_id}:#{model_id}"
+              end
+            end
+            models.sort
+          end
+
+          def extract_provider_models(data, provider_id)
+            provider_data = data[provider_id]
+            return [] unless provider_data
+
+            (provider_data["models"] || {}).keys.map { |m| "#{provider_id}:#{m}" }
+          end
+
+          def detect_changes(prev_model, curr_model)
+            changes = {}
+
+            TRACKED_FIELDS.each do |field|
+              prev_val = prev_model[field]
+              curr_val = curr_model[field]
+
+              next if prev_val == curr_val
+
+              # Deep compare for nested objects
+              if prev_val.is_a?(Hash) && curr_val.is_a?(Hash)
+                nested = detect_nested_changes(prev_val, curr_val)
+                nested.each do |key, (old_v, new_v)|
+                  changes["#{field}.#{key}"] = [old_v, new_v]
+                end
+              else
+                changes[field] = [prev_val, curr_val]
+              end
+            end
+
+            changes
+          end
+
+          def detect_nested_changes(prev_hash, curr_hash)
+            changes = {}
+            all_keys = (prev_hash.keys + curr_hash.keys).uniq
+
+            all_keys.each do |key|
+              prev_val = prev_hash[key]
+              curr_val = curr_hash[key]
+              changes[key] = [prev_val, curr_val] unless prev_val == curr_val
+            end
+
+            changes
+          end
+        end
+      end
+    end
+  end
+end