ace-support-models 0.9.0

data/lib/ace/support/models/cli/commands/cache/status.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module Cache
+            # Show cache info (freshness, age, counts)
+            class Status < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Show cache info (freshness, age, counts)"
+
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              def call(**options)
+                status_data = Organisms::SyncOrchestrator.new.status
+
+                if options[:json]
+                  puts JSON.pretty_generate(status_data)
+                  return
+                end
+
+                unless status_data[:cached]
+                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models cache sync' first.")
+                end
+
+                puts "Cache Status:"
+                puts "  Cached: Yes"
+                puts "  Fresh: #{status_data[:fresh] ? "Yes" : "No (stale)"}"
+                puts "  Last sync: #{status_data[:last_sync_at]}"
+                puts
+
+                if status_data[:stats]
+                  puts "Statistics:"
+                  puts "  Providers: #{status_data[:stats][:provider_count]}"
+                  puts "  Models: #{status_data[:stats][:model_count]}"
+                  puts
+                  puts "Top providers by model count:"
+                  status_data[:stats][:top_providers].each do |provider, count|
+                    puts "  #{provider}: #{count}"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/cache/sync.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module Cache
+            # Fetch models from models.dev API
+            class Sync < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Fetch models from models.dev API"
+
+              option :force, type: :boolean, aliases: ["-f"], desc: "Force sync even if cache is fresh"
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              example [
+                "           # Sync cache",
+                "--force    # Force sync even if cache is fresh",
+                "--json     # Output as JSON"
+              ]
+
+              def call(**options)
+                result = Organisms::SyncOrchestrator.new.sync(force: options[:force])
+
+                if options[:json]
+                  puts JSON.pretty_generate(result)
+                  return
+                end
+
+                case result[:status]
+                when :success
+                  puts result[:message]
+                  puts "Duration: #{result[:duration]}s"
+                when :skipped
+                  puts result[:message]
+                  puts "Last synced: #{result[:last_sync_at]}"
+                when :error
+                  raise Ace::Support::Cli::Error.new(result[:message])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/info.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          # Top-level shortcut for models info
+          class InfoShortcut < Ace::Support::Cli::Command
+            include Ace::Support::Cli::Base
+
+            desc "Show model info (shortcut for: models info)"
+
+            argument :model_id, required: true, desc: "Model ID (provider:model)"
+            option :full, type: :boolean, desc: "Show complete details"
+            option :json, type: :boolean, desc: "Output as JSON"
+
+            example [
+              "openai:gpt-4o            # Brief info",
+              "openai:gpt-4o --full     # Full details"
+            ]
+
+            def call(model_id:, **options)
+              ModelsSubcommands::Info.new.call(model_id: model_id, **options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/models/cost.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module ModelsSubcommands
+            # Show pricing for a model
+            class Cost < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Show pricing for a model"
+
+              argument :model_id, required: true, desc: "Model ID (provider:model)"
+              option :input, type: :integer, aliases: ["-i"], default: 1000, desc: "Input tokens"
+              option :output, type: :integer, aliases: ["-o"], default: 500, desc: "Output tokens"
+              option :reasoning, type: :integer, aliases: ["-r"], default: 0, desc: "Reasoning tokens"
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              example [
+                "openai:gpt-4o                    # Default token counts",
+                "openai:gpt-4o -i 5000 -o 2000    # Custom token counts",
+                "anthropic:claude-3-opus --json   # JSON output"
+              ]
+
+              def call(model_id:, **options)
+                calculator = Molecules::CostCalculator.new
+                result = calculator.calculate(
+                  model_id,
+                  input_tokens: options[:input],
+                  output_tokens: options[:output],
+                  reasoning_tokens: options[:reasoning]
+                )
+
+                if options[:json]
+                  puts JSON.pretty_generate(result)
+                else
+                  puts calculator.format(result)
+                end
+              rescue ProviderNotFoundError, ModelNotFoundError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              rescue CacheError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/models/info.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module ModelsSubcommands
+            # Show model information
+            class Info < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Show model information (brief by default)"
+
+              argument :model_id, required: true, desc: "Model ID (provider:model)"
+              option :full, type: :boolean, desc: "Show complete details"
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              example [
+                "openai:gpt-4o            # Brief info (default)",
+                "openai:gpt-4o --full     # Full details",
+                "anthropic:claude-3-opus --json  # JSON output"
+              ]
+
+              def call(model_id:, **options)
+                model = Molecules::ModelValidator.new.validate(model_id)
+
+                if options[:json]
+                  puts JSON.pretty_generate(model.to_h)
+                elsif options[:full]
+                  puts format_model_info_full(model)
+                else
+                  puts format_model_info_brief(model)
+                end
+              rescue ProviderNotFoundError => e
+                raise Ace::Support::Cli::Error.new("Model '#{e.model_id || model_id}' not found in provider '#{e.provider_id}'")
+              rescue ModelNotFoundError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              rescue CacheError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              end
+
+              private
+
+              def format_model_info_brief(model)
+                lines = []
+                lines << "#{model.name} (#{model.full_id})"
+                lines << "  Provider: #{model.provider_id}"
+                lines << "  Status: #{model.status || "active"}"
+                lines << "  Context: #{format_number(model.context_limit)} tokens"
+                lines << "  Output: #{format_number(model.output_limit)} tokens"
+
+                pricing = model.pricing
+                if pricing&.available?
+                  lines << "  Pricing: $#{sprintf("%.2f", pricing.input)}/M input, $#{sprintf("%.2f", pricing.output)}/M output"
+                end
+
+                caps = model.capabilities
+                enabled = []
+                enabled << "reasoning" if caps[:reasoning]
+                enabled << "tools" if caps[:tool_call]
+                enabled << "structured" if caps[:structured_output]
+                lines << "  Capabilities: #{enabled.any? ? enabled.join(", ") : "none"}"
+
+                lines << ""
+                lines << "Use --full for complete details"
+
+                lines.join("\n")
+              end
+
+              def format_model_info_full(model)
+                lines = []
+                lines << "Model: #{model.name} (#{model.full_id})"
+                lines << "Provider: #{model.provider_id}"
+                lines << "Status: #{model.status || "active"}"
+                lines << ""
+
+                lines << "Capabilities:"
+                caps = model.capabilities
+                lines << "  Reasoning: #{caps[:reasoning] ? "Yes" : "No"}"
+                lines << "  Tool Call: #{caps[:tool_call] ? "Yes" : "No"}"
+                lines << "  Structured Output: #{caps[:structured_output] ? "Yes" : "No"}"
+                lines << "  Attachment: #{caps[:attachment] ? "Yes" : "No"}"
+                lines << "  Temperature: #{caps[:temperature] ? "Yes" : "No"}"
+                lines << ""
+
+                lines << "Modalities:"
+                lines << "  Input: #{model.modalities[:input]&.join(", ") || "none"}"
+                lines << "  Output: #{model.modalities[:output]&.join(", ") || "none"}"
+                lines << ""
+
+                lines << "Limits:"
+                lines << "  Context: #{format_number(model.context_limit)} tokens"
+                lines << "  Output: #{format_number(model.output_limit)} tokens"
+                lines << ""
+
+                pricing = model.pricing
+                if pricing&.available?
+                  lines << "Pricing (per million tokens):"
+                  lines << "  Input: #{format_price(pricing.input)}"
+                  lines << "  Output: #{format_price(pricing.output)}"
+                  lines << "  Cache Read: #{format_price(pricing.cache_read)}" if pricing.cache_read
+                  lines << "  Cache Write: #{format_price(pricing.cache_write)}" if pricing.cache_write
+                  lines << "  Reasoning: #{format_price(pricing.reasoning)}" if pricing.reasoning
+                  lines << ""
+                end
+
+                lines << "Metadata:"
+                lines << "  Knowledge: #{model.knowledge_date || "unknown"}"
+                lines << "  Released: #{model.release_date || "unknown"}"
+                lines << "  Updated: #{model.last_updated || "unknown"}"
+                lines << "  Open Weights: #{model.open_weights ? "Yes" : "No"}"
+
+                lines.join("\n")
+              end
+
+              def format_number(num)
+                return "unknown" unless num
+
+                num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+              end
+
+              def format_price(price)
+                return "N/A" unless price
+
+                "$#{sprintf("%.2f", price)}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/models/search.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          # Note: Using Models_ prefix to avoid conflict with outer Models module
+          module ModelsSubcommands
+            # Search for models
+            class Search < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Search for models (query optional with filters)"
+
+              argument :query, required: false, desc: "Search query"
+              option :provider, type: :string, aliases: ["-p"], desc: "Limit to provider"
+              option :limit, type: :integer, aliases: ["-l"], default: 20, desc: "Max results"
+              option :filter, type: :array, aliases: ["-f"], desc: "Filter by key:value (repeatable)"
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              example [
+                "gpt-4                     # Search by name",
+                "opus -p anthropic         # Search within a provider",
+                "-f reasoning:true         # Filter by capability",
+                "-f tool_call:true -f min_context:100000  # Multiple filters",
+                "gpt -l 5                  # Limit results"
+              ]
+
+              def call(query: nil, **options)
+                # Validate filters before searching
+                filter_errors = Atoms::ModelFilter.validate(options[:filter])
+                unless filter_errors.empty?
+                  filter_errors.each { |e| warn "Error: #{e}" }
+                  raise Ace::Support::Cli::Error.new("Invalid model search filters")
+                end
+
+                searcher = Molecules::ModelSearcher.new
+                filters = parse_filters(options[:filter])
+                limit = options[:limit] || 20
+
+                # Single search with total count for efficient pagination
+                result = searcher.search(
+                  query,
+                  provider: options[:provider],
+                  limit: limit,
+                  filters: filters.empty? ? nil : filters,
+                  with_total: true
+                )
+
+                models = result[:models]
+                total_models_count = result[:total]
+
+                if models.empty?
+                  if options[:json]
+                    puts "[]"
+                  else
+                    message = query ? "No models found matching '#{query}'" : "No models found"
+                    message += " with filters: #{options[:filter].join(", ")}" if options[:filter]&.any?
+                    puts message
+                  end
+                  return
+                end
+
+                if options[:json]
+                  json_result = {
+                    models: models.map(&:to_h),
+                    showing: models.size,
+                    total: total_models_count
+                  }
+                  puts JSON.pretty_generate(json_result)
+                else
+                  if models.size < total_models_count
+                    puts "Showing #{models.size} of #{total_models_count} results:"
+                  else
+                    puts "Found #{models.size} model(s):"
+                  end
+                  models.each do |model|
+                    status = model.deprecated? ? " (deprecated)" : ""
+                    puts "  #{model.full_id}#{status}"
+                    puts "    #{model.name}"
+                  end
+                end
+              rescue CacheError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              end
+
+              private
+
+              def parse_filters(filter_array)
+                Atoms::ModelFilter.parse_all(filter_array)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/providers/list.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module Providers
+            # List all providers with model counts
+            class List < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "List all providers with model counts"
+
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              def call(**options)
+                cache_manager = Molecules::CacheManager.new
+
+                unless cache_manager.cached?
+                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models cache sync' first.")
+                end
+
+                providers = cache_manager.list_providers
+
+                if options[:json]
+                  puts JSON.pretty_generate(providers)
+                  return
+                end
+
+                puts "Providers (#{providers.size}):"
+                providers.sort_by { |p| -p[:model_count] }.each do |provider|
+                  puts "  #{provider[:id]}: #{provider[:model_count]} models"
+                end
+              rescue CacheError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/providers/show.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module Providers
+            # Show provider details and models
+            class Show < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Show provider details and models"
+
+              argument :provider_id, required: true, desc: "Provider ID"
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              def call(provider_id:, **options)
+                cache_manager = Molecules::CacheManager.new
+
+                unless cache_manager.cached?
+                  raise Ace::Support::Cli::Error.new("No cache data. Run 'ace-models cache sync' first.")
+                end
+
+                provider_data = cache_manager.get_provider(provider_id)
+
+                unless provider_data
+                  raise Ace::Support::Cli::Error.new("Provider '#{provider_id}' not found")
+                end
+
+                if options[:json]
+                  puts JSON.pretty_generate(provider_data)
+                  return
+                end
+
+                puts "Provider: #{provider_id}"
+                puts "Models (#{provider_data[:models].size}):"
+                provider_data[:models].each do |model|
+                  status = model[:deprecated] ? " (deprecated)" : ""
+                  puts "  #{model[:id]}#{status}"
+                  puts "    #{model[:name]}"
+                end
+              rescue CacheError => e
+                raise Ace::Support::Cli::Error.new(e.message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/providers/sync.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          module Providers
+            # Sync provider YAML configs with models.dev
+            class Sync < Ace::Support::Cli::Command
+              include Ace::Support::Cli::Base
+
+              desc "Sync provider YAML configs with models.dev"
+
+              option :apply, type: :boolean, desc: "Apply changes to config files (default: dry-run)"
+              option :commit, type: :boolean, desc: "Commit changes via ace-git-commit"
+              option :provider, type: :string, aliases: ["-p"], desc: "Sync specific provider only"
+              option :config_dir, type: :string, desc: "Target config directory"
+              option :all, type: :boolean, desc: "Show all models regardless of release date"
+              option :since, type: :string, desc: "Show models released after DATE (YYYY-MM-DD)"
+              option :json, type: :boolean, desc: "Output as JSON"
+
+              example [
+                "                          # Dry-run: see what would change",
+                "-p openai                 # Sync specific provider only",
+                "--since 2024-01-01        # Show models released after a date",
+                "--all                     # Show all models (ignore release date filter)",
+                "--apply                   # Apply changes to config files",
+                "--apply --commit          # Apply and commit changes"
+              ]
+
+              def call(**options)
+                orchestrator = Organisms::ProviderSyncOrchestrator.new
+
+                result = orchestrator.sync(
+                  config_dir: options[:config_dir],
+                  provider: options[:provider],
+                  apply: options[:apply],
+                  commit: options[:commit],
+                  show_all: options[:all],
+                  since: options[:since]
+                )
+
+                if result[:status] == :error
+                  raise Ace::Support::Cli::Error.new(result[:message])
+                end
+
+                if options[:json]
+                  puts JSON.pretty_generate(result)
+                else
+                  puts orchestrator.format_result(result)
+                end
+              rescue CacheError => e
+                raise Ace::Support::Cli::Error.new("#{e.message}. Run 'ace-models cache sync' first to download model data.")
+              rescue ConfigError => e
+                raise Ace::Support::Cli::Error.new("Config error: #{e.message}")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/search.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          # Top-level shortcut for models search
+          class SearchShortcut < Ace::Support::Cli::Command
+            include Ace::Support::Cli::Base
+
+            desc "Search models (shortcut for: models search)"
+
+            argument :query, required: false, desc: "Search query"
+            option :provider, type: :string, aliases: ["-p"], desc: "Limit to provider"
+            option :limit, type: :integer, aliases: ["-l"], default: 20, desc: "Max results"
+            option :filter, type: :array, aliases: ["-f"], desc: "Filter by key:value (repeatable)"
+            option :json, type: :boolean, desc: "Output as JSON"
+
+            example [
+              "gpt-4                     # Search by name",
+              "opus -p anthropic         # Search within a provider"
+            ]
+
+            def call(query: nil, **options)
+              ModelsSubcommands::Search.new.call(query: query, **options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/support/models/cli/commands/sync_shortcut.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module Support
+    module Models
+      module CLI
+        module Commands
+          # Top-level shortcut for cache sync
+          class SyncShortcut < Ace::Support::Cli::Command
+            include Ace::Support::Cli::Base
+
+            desc "Sync from models.dev (shortcut for: cache sync)"
+
+            option :force, type: :boolean, aliases: ["-f"], desc: "Force sync even if cache is fresh"
+            option :json, type: :boolean, desc: "Output as JSON"
+
+            example [
+              "          # Sync cache",
+              "--force   # Force sync even if cache is fresh"
+            ]
+
+            def call(**options)
+              Cache::Sync.new.call(**options)
+            end
+          end
+        end
+      end
+    end
+  end
+end