aidp 0.28.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 931d08a58cf52b7acc999d7e3320181c29710c50922463f4fb5c4e0a76c02e04
-  data.tar.gz: 1971534889d0fde6daa6d8da6f345ffac4a698f827a205e445f75e7fa26d38da
+  metadata.gz: 00cbc8656c3ce1550f5246837062879c70a0206fa62c00a7bef6cd20979b9be5
+  data.tar.gz: 353616de5a90d4cf722673040d6e7fba09d60ff63618a3c135688202694e3075
 SHA512:
-  metadata.gz: b87667e112faeb9818187eb97e281539e936ad213dcd49867781b37ff57ae9c827308cb9d4f7bdf707e48133fc3efcc79d1815d5a9b12cb3b395aad5d0e432cf
-  data.tar.gz: 5b9fa041a4e680115248fad3fad2ccd7c8ab9cc956a471051b2e2945b1d2277cfea2af7f1d3f105dd36e8e9be1f149f42fb91080496f055deb0c26e8daef1427
+  metadata.gz: 65109acb0af57d4fefccbefa626f928cec5faaa3eedb5dfe4c0141521e03d95c8f7ca2dac8455baebdf6c14d0cbcd6cd81557a0bf4b2f0cdadb62547f60b414d
+  data.tar.gz: ea289ac3406776ccc1c602795fe6fa0a54c09fe8b3729b7e0f3b0151ba2782613cc2fee68b1111f9f6b81c78efeb7d31e77ab233ea49fba48e6d5585505e60f8

data/lib/aidp/cli/models_command.rb

@@ -4,28 +4,28 @@ require "tty-table"
 require "tty-prompt"
 require "tty-spinner"
 require_relative "../harness/model_registry"
-require_relative "../harness/model_discovery_service"
+require_relative "../harness/ruby_llm_registry"
 
 module Aidp
   class CLI
     # Command handler for `aidp models` subcommand group
     #
-    # Provides commands for viewing and discovering AI models:
+    # Provides commands for viewing AI models from the RubyLLM registry:
     #   - list: Show all available models with tier information
-    #   - discover: Discover models from configured providers
-    #   - refresh: Refresh the model cache
+    #   - discover: Discover models from RubyLLM registry for a provider
+    #   - validate: Validate model configuration
     #
     # Usage:
     #   aidp models list [--provider=<name>] [--tier=<tier>]
     #   aidp models discover [--provider=<name>]
-    #   aidp models refresh [--provider=<name>]
+    #   aidp models validate
     class ModelsCommand
       include Aidp::MessageDisplay
 
-      def initialize(prompt: TTY::Prompt.new, registry: nil, discovery_service: nil)
+      def initialize(prompt: TTY::Prompt.new, registry: nil, ruby_llm_registry: nil)
         @prompt = prompt
         @registry = registry
-        @discovery_service = discovery_service
+        @ruby_llm_registry = ruby_llm_registry
       end
 
       # Main entry point for models subcommand
@@ -39,9 +39,6 @@ module Aidp
         when "discover"
           args.shift
           run_discover_command(args)
-        when "refresh"
-          args.shift
-          run_refresh_command(args)
         when "validate"
           args.shift
           run_validate_command(args)
@@ -58,16 +55,15 @@ module Aidp
         @registry ||= Aidp::Harness::ModelRegistry.new
       end
 
-      def discovery_service
-        @discovery_service ||= Aidp::Harness::ModelDiscoveryService.new
+      def ruby_llm_registry
+        @ruby_llm_registry ||= Aidp::Harness::RubyLLMRegistry.new
       end
 
       def display_help
         display_message("\nUsage: aidp models <subcommand> [options]", type: :info)
         display_message("\nSubcommands:", type: :info)
         display_message("  list              List all available models with tier information", type: :info)
-        display_message("  discover          Discover models from configured providers", type: :info)
-        display_message("  refresh           Refresh the model discovery cache", type: :info)
+        display_message("  discover          Discover models from RubyLLM registry for a provider", type: :info)
         display_message("  validate          Validate model configuration for all tiers", type: :info)
         display_message("\nOptions:", type: :info)
         display_message("  --provider=<name> Filter/target specific provider", type: :info)
@@ -76,9 +72,7 @@ module Aidp
         display_message("  aidp models list", type: :info)
         display_message("  aidp models list --tier=mini", type: :info)
         display_message("  aidp models list --provider=anthropic", type: :info)
-        display_message("  aidp models discover", type: :info)
         display_message("  aidp models discover --provider=anthropic", type: :info)
-        display_message("  aidp models refresh", type: :info)
         display_message("  aidp models validate", type: :info)
       end
 
@@ -86,42 +80,35 @@ module Aidp
         options = parse_list_options(args)
 
         begin
-          # Get all model families from registry
-          families = registry.all_families
-
-          # Apply tier filter if specified
-          if options[:tier]
-            families = families.select { |family|
-              info = registry.get_model_info(family)
-              info && info["tier"] == options[:tier]
-            }
+          # Get models from RubyLLM registry
+          all_model_ids = if options[:provider]
+            ruby_llm_registry.models_for_provider(options[:provider])
+          else
+            # Get all models by iterating known providers
+            known_providers = %w[anthropic openai google azure bedrock openrouter]
+            known_providers.flat_map { |p| ruby_llm_registry.models_for_provider(p) }.uniq
           end
 
           # Build table rows
           rows = []
-          families.each do |family|
-            info = registry.get_model_info(family)
+          all_model_ids.each do |model_id|
+            info = ruby_llm_registry.get_model_info(model_id)
             next unless info
 
-            # Get providers that support this family
-            providers = find_providers_for_family(family)
+            # Map advanced -> pro for display consistency
+            display_tier = (info[:tier] == "advanced") ? "pro" : info[:tier]
 
-            # Apply provider filter if specified
-            next if options[:provider] && !providers.include?(options[:provider])
-
-            # Add a row for each provider that supports this family
-            if providers.empty?
-              # No provider support - show as registry-only
-              rows << build_table_row(nil, family, info, "registry")
-            else
-              providers.each do |provider_name|
-                rows << build_table_row(provider_name, family, info, "registry")
-              end
+            # Apply tier filter if specified (handle pro/advanced mapping)
+            if options[:tier]
+              filter_tier = (options[:tier] == "pro") ? "advanced" : options[:tier]
+              next unless info[:tier] == filter_tier
             end
+
+            rows << build_table_row(info[:provider], model_id, info, display_tier)
           end
 
           # Sort rows by tier, then provider, then model name
-          tier_order = {"mini" => 0, "standard" => 1, "advanced" => 2}
+          tier_order = {"mini" => 0, "standard" => 1, "pro" => 2, "advanced" => 2}
           rows.sort_by! { |r| [tier_order[r[2]] || 3, r[0] || "", r[1]] }
 
           # Display table
@@ -156,6 +143,7 @@ module Aidp
 
       def parse_list_options(args)
         options = {}
+        valid_tiers = %w[mini standard pro advanced]
 
         args.each do |arg|
           case arg
@@ -163,8 +151,8 @@ module Aidp
             options[:provider] = Regexp.last_match(1)
           when /^--tier=(.+)$/
             tier = Regexp.last_match(1)
-            unless Aidp::Harness::ModelRegistry::VALID_TIERS.include?(tier)
-              display_message("Invalid tier: #{tier}. Valid tiers: #{Aidp::Harness::ModelRegistry::VALID_TIERS.join(", ")}", type: :error)
+            unless valid_tiers.include?(tier)
+              display_message("Invalid tier: #{tier}. Valid tiers: #{valid_tiers.join(", ")}", type: :error)
               exit 1
             end
             options[:tier] = tier
@@ -177,18 +165,17 @@ module Aidp
         options
       end
 
-      def build_table_row(provider_name, family, info, source)
-        capabilities = (info["capabilities"] || []).join(",")
-        context = format_context_window(info["context_window"])
-        speed = info["speed"] || "unknown"
+      def build_table_row(provider_name, model_id, info, display_tier)
+        capabilities = (info[:capabilities] || []).join(",")
+        context = format_context_window(info[:context_window])
 
         [
           provider_name || "-",
-          family,
-          info["tier"] || "unknown",
+          model_id,
+          display_tier || "unknown",
           capabilities.empty? ? "-" : capabilities,
           context,
-          speed
+          "-" # Speed not available in registry
         ]
       end
 
@@ -213,8 +200,8 @@ module Aidp
 
       def build_footer(count)
         tips = [
-          "💡 Showing #{count} model#{"s" unless count == 1} from the static registry",
-          "💡 Model families are provider-agnostic (e.g., 'claude-3-5-sonnet' works across providers)"
+          "💡 Showing #{count} model#{"s" unless count == 1} from RubyLLM registry",
+          "💡 Registry updated regularly via ruby_llm gem updates"
         ]
         tips.join("\n")
       end
@@ -249,81 +236,56 @@ module Aidp
       def run_discover_command(args)
         options = parse_discover_options(args)
 
-        begin
-          display_message("\n🔍 Discovering models from configured providers...\n", type: :highlight)
-
-          spinner = TTY::Spinner.new("[:spinner] Querying provider APIs...", format: :dots)
-          spinner.auto_spin
-
-          # Discover models
-          results = if options[:provider]
-            {options[:provider] => discovery_service.discover_models(options[:provider], use_cache: false)}
-          else
-            discovery_service.discover_all_models(use_cache: false)
-          end
+        unless options[:provider]
+          display_message("\n⚠️  Please specify a provider with --provider=<name>", type: :warning)
+          display_message("Example: aidp models discover --provider=anthropic\n", type: :info)
+          return 1
+        end
 
-          spinner.success("✓")
+        begin
+          display_message("\n🔍 Discovering models for #{options[:provider]} from RubyLLM registry...\n", type: :highlight)
 
-          # Display results
-          total_models = 0
-          results.each do |provider, models|
-            next if models.empty?
-
-            total_models += models.size
-            display_message("\n✓ Found #{models.size} models for #{provider}:", type: :success)
-
-            # Group by tier
-            by_tier = models.group_by { |m| m[:tier] }
-            %w[mini standard advanced].each do |tier|
-              tier_models = by_tier[tier] || []
-              next if tier_models.empty?
-
-              display_message("  #{tier.capitalize} tier:", type: :info)
-              tier_models.each do |model|
-                display_message("    - #{model[:name]}", type: :info)
-              end
-            end
-          end
+          # Get models from registry
+          model_ids = ruby_llm_registry.models_for_provider(options[:provider])
 
-          if total_models == 0
-            display_message("\n⚠️  No models discovered. Ensure provider CLIs are installed and configured.", type: :warning)
+          if model_ids.empty?
+            display_message("\n⚠️  No models found for provider '#{options[:provider]}'.", type: :warning)
+            display_message("Provider may not be supported or name may be incorrect.\n", type: :info)
             return 1
           end
 
-          display_message("\n✅ Discovered #{total_models} total model#{"s" unless total_models == 1}", type: :success)
-          display_message("💾 Models cached for 24 hours\n", type: :info)
-          0
-        rescue => e
-          display_message("Error discovering models: #{e.message}", type: :error)
-          Aidp.log_error("models_command", "discovery error", error: e.message, backtrace: e.backtrace.first(5))
-          1
-        end
-      end
+          # Group by tier
+          models_by_tier = Hash.new { |h, k| h[k] = [] }
+          model_ids.each do |model_id|
+            info = ruby_llm_registry.get_model_info(model_id)
+            next unless info
 
-      def run_refresh_command(args)
-        options = parse_refresh_options(args)
+            # Map advanced -> pro for display
+            tier = (info[:tier] == "advanced") ? "pro" : info[:tier]
+            models_by_tier[tier] << model_id
+          end
 
-        begin
-          display_message("\n♻️  Refreshing model cache...\n", type: :highlight)
+          # Display results
+          display_message("\n✓ Found #{model_ids.size} models for #{options[:provider]}:", type: :success)
 
-          spinner = TTY::Spinner.new("[:spinner] Clearing cache and re-discovering...", format: :dots)
-          spinner.auto_spin
+          %w[mini standard pro].each do |tier|
+            tier_models = models_by_tier[tier]
+            next if tier_models.empty?
 
-          if options[:provider]
-            discovery_service.refresh_cache(options[:provider])
-            spinner.success("✓")
-            display_message("\n✅ Refreshed cache for #{options[:provider]}", type: :success)
-          else
-            discovery_service.refresh_all_caches
-            spinner.success("✓")
-            display_message("\n✅ Refreshed cache for all providers", type: :success)
+            display_message("\n  #{tier.capitalize} tier (#{tier_models.size} model#{"s" unless tier_models.size == 1}):", type: :info)
+            tier_models.first(5).each do |model|
+              display_message("    - #{model}", type: :info)
+            end
+            if tier_models.size > 5
+              display_message("    ... and #{tier_models.size - 5} more", type: :info)
+            end
           end
 
-          display_message("💡 Run 'aidp models discover' to see the updated models\n", type: :info)
+          display_message("\n💡 Use 'aidp models list --provider=#{options[:provider]}' to see full details\n", type: :info)
           0
         rescue => e
-          display_message("Error refreshing cache: #{e.message}", type: :error)
-          Aidp.log_error("models_command", "refresh error", error: e.message, backtrace: e.backtrace.first(5))
+          display_message("Error discovering models: #{e.message}", type: :error)
+          Aidp.log_error("models_command", "discovery error", error: e.message, backtrace: e.backtrace.first(5))
           1
         end
       end
@@ -344,10 +306,6 @@ module Aidp
         options
       end
 
-      def parse_refresh_options(args)
-        parse_discover_options(args)
-      end
-
       def run_validate_command(args)
         parse_validate_options(args)
 

data/lib/aidp/cli/tools_command.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+require "tty-table"
+require_relative "../config"
+require_relative "../metadata/cache"
+require_relative "../metadata/query"
+require_relative "../metadata/validator"
+
+module Aidp
+  class CLI
+    # CLI commands for managing tool metadata
+    #
+    # Provides commands for:
+    # - aidp tools lint - Validate all metadata
+    # - aidp tools info <id> - Display tool details
+    # - aidp tools reload - Force cache regeneration
+    # - aidp tools list - List all tools
+    class ToolsCommand
+      # Initialize tools command
+      #
+      # @param project_dir [String] Project directory path
+      # @param prompt [TTY::Prompt] TTY prompt instance
+      def initialize(project_dir: Dir.pwd, prompt: TTY::Prompt.new)
+        @project_dir = project_dir
+        @prompt = prompt
+      end
+
+      # Run tools command
+      #
+      # @param args [Array<String>] Command arguments
+      # @return [Integer] Exit code
+      def run(args)
+        subcommand = args.shift
+
+        case subcommand
+        when "lint"
+          run_lint
+        when "info"
+          tool_id = args.shift
+          unless tool_id
+            @prompt.say("Error: tool ID required")
+            @prompt.say("Usage: aidp tools info <tool_id>")
+            return 1
+          end
+          run_info(tool_id)
+        when "reload"
+          run_reload
+        when "list"
+          run_list
+        when nil, "help", "--help", "-h"
+          show_help
+          0
+        else
+          @prompt.say("Unknown subcommand: #{subcommand}")
+          show_help
+          1
+        end
+      end
+
+      # Show help message
+      def show_help
+        @prompt.say("\nAIDP Tools Management")
+        @prompt.say("\nUsage:")
+        @prompt.say("  aidp tools lint           Validate all tool metadata")
+        @prompt.say("  aidp tools info <id>      Show detailed tool information")
+        @prompt.say("  aidp tools reload         Force regenerate tool directory cache")
+        @prompt.say("  aidp tools list           List all available tools")
+        @prompt.say("\nExamples:")
+        @prompt.say("  aidp tools lint")
+        @prompt.say("  aidp tools info ruby_rspec_tdd")
+        @prompt.say("  aidp tools reload")
+      end
+
+      # Run lint command
+      def run_lint
+        Aidp.log_info("tools", "Running tool metadata lint")
+
+        @prompt.say("\nValidating tool metadata...")
+
+        cache = create_cache
+        query = Metadata::Query.new(cache: cache)
+
+        begin
+          query.directory
+        rescue => e
+          @prompt.error("Failed to load tool directory: #{e.message}")
+          Aidp.log_error("tools", "Lint failed", error: e.message)
+          return 1
+        end
+
+        # Reload to get fresh validation
+        tools = load_all_tools
+
+        validator = Metadata::Validator.new(tools)
+        results = validator.validate_all
+
+        # Display results
+        display_lint_results(results)
+
+        # Write error log if there are errors
+        invalid_results = results.reject(&:valid)
+        if invalid_results.any?
+          log_path = File.join(@project_dir, ".aidp", "logs", "metadata_errors.log")
+          validator.write_error_log(results, log_path)
+          @prompt.warn("\nError log written to: #{log_path}")
+        end
+
+        invalid_results.empty? ? 0 : 1
+      end
+
+      # Run info command
+      #
+      # @param tool_id [String] Tool ID
+      def run_info(tool_id)
+        Aidp.log_info("tools", "Showing tool info", tool_id: tool_id)
+
+        cache = create_cache
+        query = Metadata::Query.new(cache: cache)
+
+        tool = query.find_by_id(tool_id)
+
+        unless tool
+          @prompt.error("Tool not found: #{tool_id}")
+          return 1
+        end
+
+        display_tool_details(tool)
+
+        0
+      end
+
+      # Run reload command
+      def run_reload
+        Aidp.log_info("tools", "Reloading tool directory")
+
+        @prompt.say("\nRegenerating tool directory cache...")
+
+        cache = create_cache
+
+        begin
+          cache.reload
+          @prompt.ok("Tool directory cache regenerated successfully")
+        rescue => e
+          @prompt.error("Failed to reload cache: #{e.message}")
+          Aidp.log_error("tools", "Reload failed", error: e.message)
+          return 1
+        end
+
+        0
+      end
+
+      # Run list command
+      def run_list
+        Aidp.log_info("tools", "Listing all tools")
+
+        cache = create_cache
+        query = Metadata::Query.new(cache: cache)
+
+        query.directory
+        stats = query.statistics
+
+        @prompt.say("\nTool Directory Statistics:")
+        @prompt.say("  Total tools: #{stats["total_tools"]}")
+        @prompt.say("  By type:")
+        stats["by_type"].each do |type, count|
+          @prompt.say("    #{type}: #{count}")
+        end
+
+        @prompt.say("\nAll Tools:")
+
+        # Group by type
+        %w[skill persona template].each do |type|
+          tools = query.find_by_type(type)
+          next if tools.empty?
+
+          @prompt.say("\n#{type.capitalize}s (#{tools.size}):")
+          display_tools_table(tools)
+        end
+
+        0
+      end
+
+      private
+
+      # Create metadata cache instance
+      #
+      # @return [Metadata::Cache] Cache instance
+      def create_cache
+        tool_config = Aidp::Config.tool_metadata_config(@project_dir)
+
+        directories = tool_config[:directories] || default_directories
+        cache_file = tool_config[:cache_file] || default_cache_file
+        strict = tool_config[:strict] || false
+
+        Metadata::Cache.new(
+          cache_path: cache_file,
+          directories: directories,
+          strict: strict
+        )
+      end
+
+      # Get default directories to scan
+      #
+      # @return [Array<String>] Default directories
+      def default_directories
+        [
+          File.join(@project_dir, ".aidp", "skills"),
+          File.join(@project_dir, ".aidp", "personas"),
+          File.join(@project_dir, ".aidp", "templates"),
+          # Also include gem templates
+          File.expand_path("../../templates/skills", __dir__),
+          File.expand_path("../../templates", __dir__)
+        ].select { |dir| Dir.exist?(dir) }
+      end
+
+      # Get default cache file path
+      #
+      # @return [String] Cache file path
+      def default_cache_file
+        File.join(@project_dir, ".aidp", "cache", "tool_directory.json")
+      end
+
+      # Load all tools from directories
+      #
+      # @return [Array<Metadata::ToolMetadata>] All tools
+      def load_all_tools
+        directories = default_directories
+        scanner = Metadata::Scanner.new(directories)
+        scanner.scan_all
+      end
+
+      # Display lint results
+      #
+      # @param results [Array<Metadata::Validator::ValidationResult>] Results
+      def display_lint_results(results)
+        valid_count = results.count(&:valid)
+        invalid_count = results.count { |r| !r.valid }
+        warning_count = results.sum { |r| r.warnings.size }
+
+        @prompt.say("\nValidation Results:")
+        @prompt.say("  Total tools: #{results.size}")
+        @prompt.ok("  Valid: #{valid_count}") if valid_count > 0
+        @prompt.error("  Invalid: #{invalid_count}") if invalid_count > 0
+        @prompt.warn("  Warnings: #{warning_count}") if warning_count > 0
+
+        # Show errors
+        invalid_results = results.reject(&:valid)
+        if invalid_results.any?
+          @prompt.say("\nErrors:")
+          invalid_results.each do |result|
+            @prompt.error("\n  #{result.tool_id} (#{result.file_path}):")
+            result.errors.each { |err| @prompt.say("    - #{err}") }
+          end
+        end
+
+        # Show warnings
+        warnings = results.select { |r| r.warnings.any? }
+        if warnings.any?
+          @prompt.say("\nWarnings:")
+          warnings.each do |result|
+            @prompt.warn("\n  #{result.tool_id} (#{result.file_path}):")
+            result.warnings.each { |warn| @prompt.say("    - #{warn}") }
+          end
+        end
+
+        if invalid_count.zero? && warning_count.zero?
+          @prompt.ok("\nAll tools validated successfully!")
+        end
+      end
+
+      # Display tool details
+      #
+      # @param tool [Hash] Tool metadata
+      def display_tool_details(tool)
+        @prompt.say("\nTool: #{tool["title"]}")
+        @prompt.say("=" * 60)
+        @prompt.say("ID:          #{tool["id"]}")
+        @prompt.say("Type:        #{tool["type"]}")
+        @prompt.say("Version:     #{tool["version"]}")
+        @prompt.say("Summary:     #{tool["summary"]}")
+        @prompt.say("Priority:    #{tool["priority"]}")
+        @prompt.say("Experimental: #{tool["experimental"]}")
+
+        if tool["applies_to"]&.any?
+          @prompt.say("\nApplies To:")
+          tool["applies_to"].each { |tag| @prompt.say("  - #{tag}") }
+        end
+
+        if tool["work_unit_types"]&.any?
+          @prompt.say("\nWork Unit Types:")
+          tool["work_unit_types"].each { |wut| @prompt.say("  - #{wut}") }
+        end
+
+        if tool["capabilities"]&.any?
+          @prompt.say("\nCapabilities:")
+          tool["capabilities"].each { |cap| @prompt.say("  - #{cap}") }
+        end
+
+        if tool["dependencies"]&.any?
+          @prompt.say("\nDependencies:")
+          tool["dependencies"].each { |dep| @prompt.say("  - #{dep}") }
+        end
+
+        @prompt.say("\nSource: #{tool["source_path"]}")
+      end
+
+      # Display tools in a table
+      #
+      # @param tools [Array<Hash>] Tools to display
+      def display_tools_table(tools)
+        return if tools.empty?
+
+        rows = tools.map do |tool|
+          [
+            tool["id"],
+            tool["title"],
+            tool["version"],
+            tool["priority"],
+            (tool["applies_to"] || []).join(", ")
+          ]
+        end
+
+        table = TTY::Table.new(
+          header: ["ID", "Title", "Version", "Priority", "Tags"],
+          rows: rows
+        )
+
+        @prompt.say(table.render(:unicode))
+      end
+    end
+  end
+end