aidp 0.28.0 → 0.30.0

data/lib/aidp/providers/kilocode.rb

@@ -56,7 +56,7 @@ module Aidp
         "Kilocode"
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "kilocode not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/providers/opencode.rb

@@ -56,7 +56,7 @@ module Aidp
         "OpenCode"
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "opencode not available" unless self.class.available?
 
         # Smart timeout calculation

data/lib/aidp/setup/wizard.rb

@@ -59,9 +59,6 @@ module Aidp
         configure_modes
         configure_devcontainer
 
-        # Finalize any background model discovery
-        finalize_background_discovery
-
         yaml_content = generate_yaml
         display_preview(yaml_content)
         display_diff(yaml_content) if @existing_config.any?
@@ -355,110 +352,14 @@ module Aidp
         end
       end
 
-      # Trigger background model discovery for a provider
-      # Runs asynchronously and caches results without blocking the wizard
-      def trigger_background_discovery(provider_name)
-        return unless provider_available_for_discovery?(provider_name)
-
-        # Store reference to display notification later
-        @discovery_threads ||= []
-
-        thread = Thread.new do
-          discover_and_cache_models(provider_name)
-        rescue => e
-          Aidp.log_debug("setup_wizard", "background discovery failed",
-            provider: provider_name, error: e.message)
-        end
-
-        @discovery_threads << {thread: thread, provider: provider_name}
-      end
-
-      # Check if provider CLI is available for discovery
-      def provider_available_for_discovery?(provider_name)
-        provider_class = get_provider_class(provider_name)
-        return false unless provider_class
-
-        provider_class.respond_to?(:available?) && provider_class.available?
-      rescue => e
-        Aidp.log_debug("setup_wizard", "provider availability check failed",
-          provider: provider_name, error: e.message)
-        false
-      end
-
-      # Perform model discovery and cache results
-      def discover_and_cache_models(provider_name)
-        require_relative "../harness/model_discovery_service"
-
-        service = Aidp::Harness::ModelDiscoveryService.new
-        models = service.discover_models(provider_name, use_cache: false)
-
-        if models.any?
-          Aidp.log_info("setup_wizard", "discovered models in background",
-            provider: provider_name, count: models.size)
-        end
-
-        models
-      rescue => e
-        Aidp.log_debug("setup_wizard", "background discovery failed",
-          provider: provider_name, error: e.message)
-        []
-      end
-
-      # Get provider class for discovery
-      def get_provider_class(provider_name)
-        class_name = "Aidp::Providers::#{provider_name.capitalize}"
-        Object.const_get(class_name)
-      rescue NameError
-        nil
-      end
-
-      # Wait for background discovery to complete and show notifications
-      #
-      # @param timeout [Numeric] Maximum seconds to wait per thread (default: 5)
-      def finalize_background_discovery(timeout: 5)
-        return unless @discovery_threads&.any?
-
-        @discovery_threads.each do |entry|
-          thread = entry[:thread]
-          provider = entry[:provider]
-
-          # Wait up to timeout seconds for discovery to complete
-          thread.join(timeout)
-
-          if thread.alive?
-            Aidp.log_debug("setup_wizard", "discovery timeout, killing thread",
-              provider: provider)
-            # Kill thread to prevent hanging
-            thread.kill
-            thread.join(0.1) # Brief wait for cleanup
-          else
-            # Discovery completed - show notification
-            begin
-              require_relative "../harness/model_cache"
-              cache = Aidp::Harness::ModelCache.new
-              cached_models = cache.get_cached_models(provider)
-
-              if cached_models&.any?
-                prompt.say("  💾 Discovered #{cached_models.size} model#{"s" unless cached_models.size == 1} for #{provider}")
-              end
-            rescue => e
-              Aidp.log_debug("setup_wizard", "failed to check cached models",
-                provider: provider, error: e.message)
-            end
-          end
-        end
-
-        @discovery_threads = []
-      end
-
       def discover_models_for_providers(providers)
-        require_relative "../harness/model_discovery_service"
+        require_relative "../harness/ruby_llm_registry"
 
-        service = Aidp::Harness::ModelDiscoveryService.new
+        registry = Aidp::Harness::RubyLLMRegistry.new
         all_models = {}
 
         providers.each do |provider|
-          models = service.discover_models(provider, use_cache: true)
+          models = discover_models_from_registry(provider, registry)
           all_models[provider] = models if models.any?
         rescue => e
           Aidp.log_debug("setup_wizard", "discovery failed", provider: provider, error: e.message)
@@ -468,6 +369,30 @@ module Aidp
         all_models
       end
 
+      # Discover models for a provider from RubyLLM registry
+      #
+      # @param provider [String] Provider name (e.g., "anthropic")
+      # @param registry [RubyLLMRegistry] Registry instance
+      # @return [Array<Hash>] Models with tier classification
+      def discover_models_from_registry(provider, registry)
+        model_ids = registry.models_for_provider(provider)
+
+        # Convert to model info hashes with tier classification
+        model_ids.map do |model_id|
+          info = registry.get_model_info(model_id)
+          {
+            name: model_id,
+            tier: info[:tier],
+            context_window: info[:context_window],
+            capabilities: info[:capabilities]
+          }
+        end
+      rescue => e
+        Aidp.log_error("setup_wizard", "failed to discover models from registry",
+          provider: provider, error: e.message)
+        []
+      end
+
       def display_discovered_models(discovered_models)
         discovered_models.each do |provider, models|
           prompt.say("\n✓ Found #{models.size} models for #{provider}:")
@@ -510,13 +435,19 @@ module Aidp
       def find_model_for_tier(models, target_tier)
         return nil unless models
 
-        models.find { |m| m[:tier] == target_tier }
+        # Map pro -> advanced for registry compatibility
+        registry_tier = (target_tier == "pro") ? "advanced" : target_tier
+
+        models.find { |m| m[:tier] == registry_tier }
       end
 
       def find_models_for_tier(models, target_tier)
         return [] unless models
 
-        models.select { |m| m[:tier] == target_tier }
+        # Map pro -> advanced for registry compatibility
+        registry_tier = (target_tier == "pro") ? "advanced" : target_tier
+
+        models.select { |m| m[:tier] == registry_tier }
       end
 
       def display_provider_tier_preview(provider_configs)
@@ -1717,9 +1648,6 @@ module Aidp
         # Enhance messaging with display name when available
         display_name = discover_available_providers.invert.fetch(provider_name, provider_name)
         prompt.say("  • #{action_word.capitalize} provider '#{display_name}' (#{provider_name}) with billing type '#{provider_type}' and model family '#{model_family}'")
-
-        # Trigger background model discovery for newly added/updated provider
-        trigger_background_discovery(provider_name) unless @dry_run
       end
 
       def edit_or_remove_provider(provider_name, primary_provider, fallbacks)

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.28.0"
+  VERSION = "0.30.0"
 end

data/lib/aidp.rb

@@ -49,6 +49,15 @@ require_relative "aidp/analyze/seams"
 require_relative "aidp/analyze/tree_sitter_scan"
 require_relative "aidp/analyze/kb_inspector"
 
+# Metadata system
+require_relative "aidp/metadata/tool_metadata"
+require_relative "aidp/metadata/validator"
+require_relative "aidp/metadata/parser"
+require_relative "aidp/metadata/scanner"
+require_relative "aidp/metadata/compiler"
+require_relative "aidp/metadata/query"
+require_relative "aidp/metadata/cache"
+
 # Workflows
 require_relative "aidp/workflows/definitions"
 require_relative "aidp/workflows/selector"
@@ -83,6 +92,8 @@ require_relative "aidp/harness/config_schema"
 require_relative "aidp/harness/config_validator"
 require_relative "aidp/harness/config_loader"
 require_relative "aidp/harness/config_manager"
+require_relative "aidp/harness/ruby_llm_registry"
+require_relative "aidp/harness/model_registry"
 require_relative "aidp/harness/condition_detector"
 require_relative "aidp/harness/user_interface"
 require_relative "aidp/harness/simple_user_interface"

data/templates/implementation/implement_features.md

@@ -23,7 +23,10 @@ You are a senior engineer writing **implementation guidance** for domain agents.
 
 ## Output
 
-- `docs/ImplementationGuide.md` with examples and a pattern-to-use-case matrix.
+- `docs/<FEATURE_NAME>_IMPLEMENTATION.md` with examples and a pattern-to-use-case matrix.
+  - Use a descriptive name based on the feature/issue (e.g., `METADATA_TOOL_DISCOVERY.md`, `WORKTREE_PR_CHANGE_REQUESTS.md`)
+  - Do NOT use generic names like `ImplementationGuide.md`, `IMPLEMENTATION_SUMMARY.md`, or `SESSION_SUMMARY.md`
+  - Do NOT create files at the project root
 
 ## Regeneration Policy
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -219,6 +219,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
 description: The AI-Dev-Pipeline (AIDP) CLI provides a powerful, markdown-driven workflow
   for software development. It supports in-depth project analysis to understand existing
   codebases and an execution mode to systematically implement new features.
@@ -269,6 +283,7 @@ files:
 - lib/aidp/cli/models_command.rb
 - lib/aidp/cli/providers_command.rb
 - lib/aidp/cli/terminal_io.rb
+- lib/aidp/cli/tools_command.rb
 - lib/aidp/concurrency.rb
 - lib/aidp/concurrency/backoff.rb
 - lib/aidp/concurrency/exec.rb
@@ -309,12 +324,12 @@ files:
 - lib/aidp/harness/config_schema.rb
 - lib/aidp/harness/config_validator.rb
 - lib/aidp/harness/configuration.rb
+- lib/aidp/harness/deprecation_cache.rb
 - lib/aidp/harness/enhanced_runner.rb
 - lib/aidp/harness/error_handler.rb
 - lib/aidp/harness/filter_strategy.rb
 - lib/aidp/harness/generic_filter_strategy.rb
 - lib/aidp/harness/model_cache.rb
-- lib/aidp/harness/model_discovery_service.rb
 - lib/aidp/harness/model_registry.rb
 - lib/aidp/harness/output_filter.rb
 - lib/aidp/harness/provider_config.rb
@@ -324,6 +339,7 @@ files:
 - lib/aidp/harness/provider_metrics.rb
 - lib/aidp/harness/provider_type_checker.rb
 - lib/aidp/harness/rspec_filter_strategy.rb
+- lib/aidp/harness/ruby_llm_registry.rb
 - lib/aidp/harness/runner.rb
 - lib/aidp/harness/simple_user_interface.rb
 - lib/aidp/harness/state/errors.rb
@@ -365,6 +381,13 @@ files:
 - lib/aidp/jobs/background_runner.rb
 - lib/aidp/logger.rb
 - lib/aidp/message_display.rb
+- lib/aidp/metadata/cache.rb
+- lib/aidp/metadata/compiler.rb
+- lib/aidp/metadata/parser.rb
+- lib/aidp/metadata/query.rb
+- lib/aidp/metadata/scanner.rb
+- lib/aidp/metadata/tool_metadata.rb
+- lib/aidp/metadata/validator.rb
 - lib/aidp/planning/analyzers/feedback_analyzer.rb
 - lib/aidp/planning/builders/agile_plan_builder.rb
 - lib/aidp/planning/builders/project_plan_builder.rb

data/lib/aidp/harness/model_discovery_service.rb

@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "model_cache"
-require_relative "model_registry"
-
-module Aidp
-  module Harness
-    # Service for discovering available models from providers
-    #
-    # Orchestrates model discovery across multiple providers:
-    # 1. Checks cache first (with TTL)
-    # 2. Falls back to dynamic discovery via provider.discover_models
-    # 3. Merges with static registry for comprehensive results
-    # 4. Caches results for future use
-    #
-    # Usage:
-    #   service = ModelDiscoveryService.new
-    #   models = service.discover_models("anthropic")
-    #   all_models = service.discover_all_models
-    class ModelDiscoveryService
-      attr_reader :cache, :registry
-
-      def initialize(cache: nil, registry: nil)
-        @cache = cache || ModelCache.new
-        @registry = registry || ModelRegistry.new
-        @provider_classes = discover_provider_classes
-        Aidp.log_debug("model_discovery_service", "initialized",
-          providers: @provider_classes.keys)
-      end
-
-      # Discover models for a specific provider
-      #
-      # @param provider [String] Provider name (e.g., "anthropic", "cursor")
-      # @param use_cache [Boolean] Whether to use cached results (default: true)
-      # @return [Array<Hash>] Discovered models
-      def discover_models(provider, use_cache: true)
-        Aidp.log_info("model_discovery_service", "discovering models",
-          provider: provider, use_cache: use_cache)
-
-        # Check cache first
-        if use_cache
-          cached = @cache.get_cached_models(provider)
-          if cached
-            Aidp.log_debug("model_discovery_service", "using cached models",
-              provider: provider, count: cached.size)
-            return cached
-          end
-        end
-
-        # Perform discovery
-        models = perform_discovery(provider)
-
-        # Cache the results
-        @cache.cache_models(provider, models) if models.any?
-
-        models
-      rescue => e
-        Aidp.log_error("model_discovery_service", "discovery failed",
-          provider: provider, error: e.message, backtrace: e.backtrace.first(3))
-        []
-      end
-
-      # Discover models from all available providers
-      #
-      # @param use_cache [Boolean] Whether to use cached results
-      # @return [Hash] Hash of provider => models array
-      def discover_all_models(use_cache: true)
-        results = {}
-
-        @provider_classes.each_key do |provider|
-          models = discover_models(provider, use_cache: use_cache)
-          results[provider] = models if models.any?
-        end
-
-        Aidp.log_info("model_discovery_service", "discovered all models",
-          providers: results.keys, total_models: results.values.flatten.size)
-        results
-      end
-
-      # Discover models concurrently from multiple providers
-      #
-      # @param providers [Array<String>] List of provider names
-      # @param use_cache [Boolean] Whether to use cached results
-      # @return [Hash] Hash of provider => models array
-      def discover_concurrent(providers, use_cache: true)
-        require "concurrent"
-
-        results = {}
-        mutex = Mutex.new
-
-        # Create a thread pool
-        pool = Concurrent::FixedThreadPool.new(providers.size)
-
-        # Submit discovery tasks
-        futures = providers.map do |provider|
-          Concurrent::Future.execute(executor: pool) do
-            models = discover_models(provider, use_cache: use_cache)
-            mutex.synchronize { results[provider] = models }
-          end
-        end
-
-        # Wait for all to complete
-        futures.each(&:wait)
-
-        pool.shutdown
-        pool.wait_for_termination(30)
-
-        Aidp.log_info("model_discovery_service", "concurrent discovery complete",
-          providers: results.keys, total_models: results.values.flatten.size)
-        results
-      rescue LoadError => e
-        # Fallback to sequential if concurrent gem not available
-        Aidp.log_warn("model_discovery_service", "concurrent gem not available, using sequential",
-          error: e.message)
-        providers.each_with_object({}) do |provider, hash|
-          hash[provider] = discover_models(provider, use_cache: use_cache)
-        end
-      rescue => e
-        Aidp.log_error("model_discovery_service", "concurrent discovery failed",
-          error: e.message)
-        {}
-      end
-
-      # Get all available models (discovery + static registry)
-      #
-      # Combines dynamically discovered models with static registry
-      #
-      # @param use_cache [Boolean] Whether to use cached results
-      # @return [Hash] Hash with :discovered and :registry keys
-      def all_available_models(use_cache: true)
-        discovered = discover_all_models(use_cache: use_cache)
-        registry_families = @registry.all_families
-
-        {
-          discovered: discovered,
-          registry: registry_families.map { |family| @registry.get_model_info(family) }.compact
-        }
-      end
-
-      # Find which providers support a given model family
-      #
-      # @param family_name [String] Model family name
-      # @return [Array<String>] List of provider names
-      def providers_supporting(family_name)
-        providers = []
-
-        @provider_classes.each do |provider_name, class_name|
-          provider_class = constantize_provider(class_name)
-          next unless provider_class
-
-          if provider_class.respond_to?(:supports_model_family?)
-            providers << provider_name if provider_class.supports_model_family?(family_name)
-          end
-        end
-
-        providers
-      end
-
-      # Refresh cache for all providers
-      def refresh_all_caches
-        @cache.invalidate_all
-        discover_all_models(use_cache: false)
-      end
-
-      # Refresh cache for specific provider
-      #
-      # @param provider [String] Provider name
-      def refresh_cache(provider)
-        @cache.invalidate(provider)
-        discover_models(provider, use_cache: false)
-      end
-
-      private
-
-      def perform_discovery(provider)
-        provider_class = get_provider_class(provider)
-        unless provider_class
-          Aidp.log_warn("model_discovery_service", "unknown provider",
-            provider: provider)
-          return []
-        end
-
-        unless provider_class.respond_to?(:available?) && provider_class.available?
-          Aidp.log_debug("model_discovery_service", "provider not available",
-            provider: provider)
-          return []
-        end
-
-        unless provider_class.respond_to?(:discover_models)
-          Aidp.log_warn("model_discovery_service", "provider missing discover_models",
-            provider: provider)
-          return []
-        end
-
-        models = provider_class.discover_models
-        Aidp.log_info("model_discovery_service", "discovered models",
-          provider: provider, count: models.size)
-        models
-      end
-
-      def get_provider_class(provider)
-        class_name = @provider_classes[provider]
-        return nil unless class_name
-
-        constantize_provider(class_name)
-      end
-
-      def constantize_provider(class_name)
-        # Safely constantize the provider class
-        parts = class_name.split("::")
-        parts.reduce(Object) { |mod, name| mod.const_get(name) }
-      rescue NameError => e
-        Aidp.log_debug("model_discovery_service", "provider class not found",
-          class: class_name, error: e.message)
-        nil
-      end
-
-      # Dynamically discover all provider classes from the providers directory
-      #
-      # @return [Hash] Hash of provider_name => class_name
-      def discover_provider_classes
-        providers_dir = File.join(__dir__, "../providers")
-        provider_files = Dir.glob("*.rb", base: providers_dir)
-
-        # Exclude base classes and utility files
-        excluded_files = ["base.rb", "adapter.rb", "error_taxonomy.rb", "capability_registry.rb"]
-        provider_files -= excluded_files
-
-        providers = {}
-
-        provider_files.each do |file|
-          provider_name = File.basename(file, ".rb")
-          # Convert to class name (e.g., "anthropic" -> "Anthropic", "github_copilot" -> "GithubCopilot")
-          class_name = provider_name.split("_").map(&:capitalize).join
-          full_class_name = "Aidp::Providers::#{class_name}"
-
-          # Try to load and verify the provider class exists
-          begin
-            require_relative "../providers/#{provider_name}"
-            provider_class = constantize_provider(full_class_name)
-            if provider_class&.respond_to?(:discover_models)
-              providers[provider_name] = full_class_name
-            end
-          rescue => e
-            # Skip providers that can't be loaded or don't implement discover_models
-            if ENV["DEBUG"]
-              Aidp.log_debug("model_discovery_service", "skipping provider",
-                provider: provider_name, reason: e.message)
-            end
-          end
-        end
-
-        Aidp.log_debug("model_discovery_service", "discovered provider classes",
-          count: providers.size, providers: providers.keys)
-        providers
-      end
-    end
-  end
-end