aidp 0.28.0 → 0.29.0

data/lib/aidp/cli.rb

@@ -256,7 +256,7 @@ module Aidp
       # Determine if the invocation is a subcommand style call
       def subcommand?(args)
         return false if args.nil? || args.empty?
-        %w[status jobs kb harness providers checkpoint mcp issue config init watch ws work skill settings models].include?(args.first)
+        %w[status jobs kb harness providers checkpoint mcp issue config init watch ws work skill settings models tools].include?(args.first)
       end
 
       def run_subcommand(args)
@@ -279,6 +279,7 @@ module Aidp
         when "skill" then run_skill_command(args)
         when "settings" then run_settings_command(args)
         when "models" then run_models_command(args)
+        when "tools" then run_tools_command(args)
         else
           display_message("Unknown command: #{cmd}", type: :info)
           return 1
@@ -625,6 +626,12 @@ module Aidp
         models_cmd.run(args)
       end
 
+      def run_tools_command(args)
+        require_relative "cli/tools_command"
+        tools_cmd = Aidp::CLI::ToolsCommand.new(project_dir: Dir.pwd, prompt: create_prompt)
+        tools_cmd.run(args)
+      end
+
       def run_issue_command(args)
         require_relative "cli/issue_importer"
 

data/lib/aidp/config.rb

@@ -285,6 +285,15 @@ module Aidp
       symbolize_keys(agile_section)
     end
 
+    # Get tool metadata configuration
+    def self.tool_metadata_config(project_dir = Dir.pwd)
+      config = load_harness_config(project_dir)
+      tool_metadata_section = config[:tool_metadata] || config["tool_metadata"] || {}
+
+      # Convert string keys to symbols for consistency
+      symbolize_keys(tool_metadata_section)
+    end
+
     # Check if configuration file exists
     def self.config_exists?(project_dir = Dir.pwd)
       ConfigPaths.config_exists?(project_dir)

data/lib/aidp/execute/work_loop_runner.rb

@@ -308,7 +308,8 @@ module Aidp
             iteration: @iteration_count,
             project_dir: @project_dir,
             mode: :decide_whats_next,
-            model: model_name
+            model: model_name,
+            tier: @thinking_depth_manager.current_tier
           }
         )
 
@@ -340,7 +341,8 @@ module Aidp
             iteration: @iteration_count,
             project_dir: @project_dir,
             mode: :diagnose_failures,
-            model: model_name
+            model: model_name,
+            tier: @thinking_depth_manager.current_tier
           }
         )
 
@@ -761,7 +763,8 @@ module Aidp
               step_name: @step_name,
               iteration: @iteration_count,
               project_dir: @project_dir,
-              model: model_name
+              model: model_name,
+              tier: @thinking_depth_manager.current_tier
             }
           )
         end

data/lib/aidp/harness/capability_registry.rb

@@ -87,7 +87,7 @@ module Aidp
         providers_to_search.each do |provider_name|
           matching_models = []
           models_for_provider(provider_name).each do |model_name, model_data|
-            matching_models << model_name if model_data["tier"] == tier
+            matching_models << model_name if model_data["tier"] == tier.to_s
           end
           results[provider_name] = matching_models unless matching_models.empty?
         end
@@ -114,12 +114,12 @@ module Aidp
 
       # Check if a tier is valid
       def valid_tier?(tier)
-        VALID_TIERS.include?(tier)
+        VALID_TIERS.include?(tier.to_s)
       end
 
       # Get tier priority (0 = lowest, 4 = highest)
       def tier_priority(tier)
-        TIER_PRIORITY[tier]
+        TIER_PRIORITY[tier.to_s]
       end
 
       # Compare two tiers (returns -1, 0, 1 like <=>)
@@ -154,7 +154,7 @@ module Aidp
         models = models_for_provider(provider_name)
 
         # Find all models matching tier
-        tier_models = models.select { |_name, data| data["tier"] == tier }
+        tier_models = models.select { |_name, data| data["tier"] == tier.to_s }
         return nil if tier_models.empty?
 
         # Prefer newer models (higher in the list)

data/lib/aidp/harness/provider_manager.rb

@@ -1394,8 +1394,9 @@ module Aidp
 
       # Execute a prompt with a specific provider
       def execute_with_provider(provider_type, prompt, options = {})
-        # Extract model from options if provided
+        # Extract model and tier from options if provided
         model_name = options.delete(:model)
+        tier = options[:tier] # Keep tier in options for provider
 
         # Create provider factory instance
         provider_factory = ProviderFactory.new
@@ -1414,10 +1415,11 @@ module Aidp
         Aidp.logger.debug("provider_manager", "Executing with provider",
           provider: provider_type,
           model: model_name,
+          tier: tier,
           prompt_length: prompt.length)
 
-        # Execute the prompt with the provider
-        result = provider.send_message(prompt: prompt, session: nil)
+        # Execute the prompt with the provider (pass options including tier)
+        result = provider.send_message(prompt: prompt, session: nil, options: options)
 
         # Return structured result
         {

data/lib/aidp/harness/ruby_llm_registry.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Aidp
+  module Harness
+    # RubyLLMRegistry wraps the ruby_llm gem's model registry
+    # to provide AIDP-specific functionality while leveraging
+    # ruby_llm's comprehensive and actively maintained model database
+    class RubyLLMRegistry
+      class RegistryError < StandardError; end
+      class ModelNotFound < RegistryError; end
+
+      # Map AIDP provider names to RubyLLM provider names
+      # Some AIDP providers use different names than the upstream APIs
+      PROVIDER_NAME_MAPPING = {
+        "codex" => "openai",      # Codex is AIDP's OpenAI adapter
+        "anthropic" => "anthropic",
+        "gemini" => "gemini",     # Gemini provider name matches
+        "aider" => nil,           # Aider aggregates multiple providers
+        "cursor" => nil,          # Cursor has its own models
+        "openai" => "openai",
+        "google" => "gemini",     # Google's API uses gemini provider name
+        "azure" => "bedrock",     # Azure OpenAI uses bedrock in registry
+        "bedrock" => "bedrock",
+        "openrouter" => "openrouter"
+      }.freeze
+
+      # Tier classification based on model characteristics
+      # These are heuristics since ruby_llm doesn't classify tiers
+      TIER_CLASSIFICATION = {
+        # Mini tier: fast, cost-effective models
+        mini: ->(model) {
+          return true if model.id.to_s.match?(/haiku|mini|flash|small/i)
+
+          # Check pricing if available
+          if model.pricing
+            pricing_hash = model.pricing.to_h
+            input_cost = pricing_hash.dig(:text_tokens, :standard, :input_per_million)
+            return true if input_cost && input_cost < 1.0
+          end
+          false
+        },
+
+        # Advanced tier: high-capability, expensive models
+        advanced: ->(model) {
+          return true if model.id.to_s.match?(/opus|turbo|pro|preview|o1/i)
+
+          # Check pricing if available
+          if model.pricing
+            pricing_hash = model.pricing.to_h
+            input_cost = pricing_hash.dig(:text_tokens, :standard, :input_per_million)
+            return true if input_cost && input_cost > 10.0
+          end
+          false
+        },
+
+        # Standard tier: everything else (default)
+        standard: ->(model) { true }
+      }.freeze
+
+      def initialize
+        @models = RubyLLM::Models.instance.instance_variable_get(:@models)
+        @index_by_id = @models.to_h { |m| [m.id, m] }
+
+        # Build family index for mapping versioned names to families
+        @family_index = build_family_index
+
+        Aidp.log_info("ruby_llm_registry", "initialized", models: @models.size)
+      end
+
+      # Resolve a model name (family or versioned) to the canonical API model
+      #
+      # @param model_name [String] Model name (e.g., "claude-3-5-haiku" or "claude-3-5-haiku-20241022")
+      # @param provider [String, nil] Optional AIDP provider filter
+      # @return [String, nil] Canonical model ID for API calls, or nil if not found
+      def resolve_model(model_name, provider: nil)
+        # Map AIDP provider to registry provider if filtering
+        registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
+
+        # Try exact match first
+        model = @index_by_id[model_name]
+        return model.id if model && (registry_provider.nil? || model.provider.to_s == registry_provider)
+
+        # Try family mapping
+        family_models = @family_index[model_name]
+        if family_models
+          # Filter by provider if specified
+          family_models = family_models.select { |m| m.provider.to_s == registry_provider } if registry_provider
+
+          # Return the latest version (first non-"latest" model, or the latest one)
+          model = family_models.reject { |m| m.id.to_s.include?("-latest") }.first || family_models.first
+          return model.id if model
+        end
+
+        # Try fuzzy matching for common patterns
+        fuzzy_match = find_fuzzy_match(model_name, registry_provider)
+        return fuzzy_match.id if fuzzy_match
+
+        Aidp.log_warn("ruby_llm_registry", "model not found", model: model_name, provider: provider)
+        nil
+      end
+
+      # Get model information
+      #
+      # @param model_id [String] The model ID
+      # @return [Hash, nil] Model information hash or nil if not found
+      def get_model_info(model_id)
+        model = @index_by_id[model_id]
+        return nil unless model
+
+        {
+          id: model.id,
+          name: model.name || model.display_name,
+          provider: model.provider.to_s,
+          tier: classify_tier(model),
+          context_window: model.context_window,
+          capabilities: extract_capabilities(model),
+          pricing: model.pricing
+        }
+      end
+
+      # Get all models for a specific tier
+      #
+      # @param tier [String, Symbol] The tier name (mini, standard, advanced)
+      # @param provider [String, nil] Optional AIDP provider filter
+      # @return [Array<String>] List of model IDs for the tier
+      def models_for_tier(tier, provider: nil)
+        tier_sym = tier.to_sym
+        classifier = TIER_CLASSIFICATION[tier_sym]
+
+        unless classifier
+          Aidp.log_warn("ruby_llm_registry", "invalid tier", tier: tier)
+          return []
+        end
+
+        # Map AIDP provider to registry provider if filtering
+        registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
+        return [] if provider && registry_provider.nil?
+
+        models = @models.select do |model|
+          (registry_provider.nil? || model.provider.to_s == registry_provider) &&
+            classifier.call(model)
+        end
+
+        # For mini and standard tiers, exclude if advanced classification matches
+        if tier_sym == :mini
+          models.reject! { |m| TIER_CLASSIFICATION[:advanced].call(m) }
+        elsif tier_sym == :standard
+          models.reject! do |m|
+            TIER_CLASSIFICATION[:mini].call(m) || TIER_CLASSIFICATION[:advanced].call(m)
+          end
+        end
+
+        model_ids = models.map(&:id).uniq
+        Aidp.log_debug("ruby_llm_registry", "found models for tier",
+          tier: tier, provider: provider, count: model_ids.size)
+        model_ids
+      end
+
+      # Get all models for a provider
+      #
+      # @param provider [String] The AIDP provider name
+      # @return [Array<String>] List of model IDs
+      def models_for_provider(provider)
+        # Map AIDP provider name to RubyLLM provider name
+        registry_provider = PROVIDER_NAME_MAPPING[provider]
+
+        # Return empty if provider doesn't map to a registry provider
+        return [] if registry_provider.nil?
+
+        @models.select { |m| m.provider.to_s == registry_provider }.map(&:id)
+      end
+
+      # Classify a model's tier
+      #
+      # @param model [RubyLLM::Model::Info] The model info object
+      # @return [String] The tier name (mini, standard, advanced)
+      def classify_tier(model)
+        return "advanced" if TIER_CLASSIFICATION[:advanced].call(model)
+        return "mini" if TIER_CLASSIFICATION[:mini].call(model)
+        "standard"
+      end
+
+      # Refresh the model registry from ruby_llm
+      def refresh!
+        RubyLLM::Models.refresh!
+        @models = RubyLLM::Models.instance.instance_variable_get(:@models)
+        @index_by_id = @models.to_h { |m| [m.id, m] }
+        @family_index = build_family_index
+        Aidp.log_info("ruby_llm_registry", "refreshed", models: @models.size)
+      end
+
+      private
+
+      # Build an index mapping family names to model objects
+      # Family name is model ID with version suffix removed
+      def build_family_index
+        index = Hash.new { |h, k| h[k] = [] }
+
+        @models.each do |model|
+          # Remove date suffix (e.g., "claude-3-5-haiku-20241022" -> "claude-3-5-haiku")
+          family = model.id.to_s.sub(/-\d{8}$/, "").sub(/-latest$/, "")
+          index[family] << model unless family == model.id.to_s
+        end
+
+        index
+      end
+
+      # Find a model by fuzzy matching
+      def find_fuzzy_match(model_name, provider)
+        # Normalize the search term
+        normalized = model_name.downcase.gsub(/[^a-z0-9]/, "")
+
+        candidates = @models.select do |m|
+          next false if provider && m.provider.to_s != provider
+
+          # Check if model ID contains the search term
+          m.id.to_s.downcase.gsub(/[^a-z0-9]/, "").include?(normalized) ||
+            m.name.to_s.downcase.gsub(/[^a-z0-9]/, "").include?(normalized)
+        end
+
+        # Prefer shorter matches (more specific)
+        candidates.min_by { |m| m.id.to_s.length }
+      end
+
+      # Extract capabilities from model info
+      def extract_capabilities(model)
+        caps = []
+        caps << "chat" if model.capabilities.include?(:chat)
+        caps << "code" if model.capabilities.include?(:code) || model.id.to_s.include?("code")
+        caps << "vision" if model.capabilities.include?(:vision)
+        caps << "tool_use" if model.capabilities.include?(:function_calling) || model.capabilities.include?(:tools)
+        caps << "streaming" if model.capabilities.include?(:streaming)
+        caps
+      end
+    end
+  end
+end

data/lib/aidp/metadata/cache.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "../errors"
+require_relative "scanner"
+require_relative "compiler"
+
+module Aidp
+  module Metadata
+    # Manages cached tool directory with automatic invalidation
+    #
+    # Loads compiled tool directory from cache, checks for file changes,
+    # and regenerates cache when needed.
+    #
+    # @example Loading from cache
+    #   cache = Cache.new(
+    #     cache_path: ".aidp/cache/tool_directory.json",
+    #     directories: [".aidp/skills", ".aidp/templates"]
+    #   )
+    #   directory = cache.load
+    class Cache
+      # Default cache TTL (24 hours)
+      DEFAULT_TTL = 86400
+
+      # Initialize cache
+      #
+      # @param cache_path [String] Path to cache file
+      # @param directories [Array<String>] Directories to monitor
+      # @param ttl [Integer] Cache TTL in seconds (default: 24 hours)
+      # @param strict [Boolean] Whether to fail on validation errors
+      def initialize(cache_path:, directories: [], ttl: DEFAULT_TTL, strict: false)
+        @cache_path = cache_path
+        @directories = Array(directories)
+        @ttl = ttl
+        @strict = strict
+        @file_hashes_path = "#{cache_path}.hashes"
+      end
+
+      # Load tool directory from cache or regenerate
+      #
+      # @return [Hash] Tool directory structure
+      def load
+        Aidp.log_debug("metadata", "Loading cache", path: @cache_path)
+
+        if cache_valid?
+          Aidp.log_debug("metadata", "Using cached directory")
+          load_from_cache
+        else
+          Aidp.log_info("metadata", "Cache invalid, regenerating")
+          regenerate
+        end
+      end
+
+      # Regenerate cache from source files
+      #
+      # @return [Hash] Tool directory structure
+      def regenerate
+        Aidp.log_info("metadata", "Regenerating tool directory", directories: @directories)
+
+        # Compile directory
+        compiler = Compiler.new(directories: @directories, strict: @strict)
+        directory = compiler.compile(output_path: @cache_path)
+
+        # Save file hashes for change detection
+        save_file_hashes
+
+        directory
+      end
+
+      # Force reload cache
+      #
+      # @return [Hash] Tool directory structure
+      def reload
+        Aidp.log_info("metadata", "Force reloading cache")
+        regenerate
+      end
+
+      # Check if cache is valid
+      #
+      # @return [Boolean] True if cache exists and is not stale
+      def cache_valid?
+        return false unless File.exist?(@cache_path)
+        return false if cache_expired?
+        return false if files_changed?
+
+        true
+      end
+
+      # Check if cache has expired based on TTL
+      #
+      # @return [Boolean] True if cache is expired
+      def cache_expired?
+        return true unless File.exist?(@cache_path)
+
+        cache_age = Time.now - File.mtime(@cache_path)
+        expired = cache_age > @ttl
+
+        if expired
+          Aidp.log_debug(
+            "metadata",
+            "Cache expired",
+            age_seconds: cache_age.to_i,
+            ttl: @ttl
+          )
+        end
+
+        expired
+      end
+
+      # Check if source files have changed
+      #
+      # @return [Boolean] True if any source files have changed
+      def files_changed?
+        previous_hashes = load_file_hashes
+        current_hashes = compute_current_hashes
+
+        changed = previous_hashes != current_hashes
+
+        if changed
+          Aidp.log_debug(
+            "metadata",
+            "Source files changed",
+            previous_count: previous_hashes.size,
+            current_count: current_hashes.size
+          )
+        end
+
+        changed
+      end
+
+      # Load directory from cache file
+      #
+      # @return [Hash] Cached directory structure
+      # @raise [Aidp::Errors::ConfigurationError] if cache is invalid
+      def load_from_cache
+        content = File.read(@cache_path, encoding: "UTF-8")
+        directory = JSON.parse(content)
+
+        Aidp.log_debug(
+          "metadata",
+          "Loaded from cache",
+          tools: directory["statistics"]["total_tools"],
+          compiled_at: directory["compiled_at"]
+        )
+
+        directory
+      rescue JSON::ParserError => e
+        Aidp.log_error("metadata", "Invalid cache JSON", error: e.message)
+        raise Aidp::Errors::ConfigurationError, "Invalid tool directory cache: #{e.message}"
+      end
+
+      # Compute current file hashes for all source files
+      #
+      # @return [Hash<String, String>] Map of file_path => file_hash
+      def compute_current_hashes
+        hashes = {}
+
+        @directories.each do |dir|
+          next unless Dir.exist?(dir)
+
+          scanner = Scanner.new([dir])
+          md_files = scanner.find_markdown_files(dir)
+
+          md_files.each do |file_path|
+            content = File.read(file_path, encoding: "UTF-8")
+            hashes[file_path] = Parser.compute_file_hash(content)
+          end
+        end
+
+        hashes
+      end
+
+      # Load saved file hashes
+      #
+      # @return [Hash<String, String>] Saved file hashes
+      def load_file_hashes
+        return {} unless File.exist?(@file_hashes_path)
+
+        content = File.read(@file_hashes_path, encoding: "UTF-8")
+        JSON.parse(content)
+      rescue JSON::ParserError
+        Aidp.log_warn("metadata", "Invalid file hashes cache, regenerating")
+        {}
+      end
+
+      # Save current file hashes
+      def save_file_hashes
+        hashes = compute_current_hashes
+
+        # Ensure directory exists
+        dir = File.dirname(@file_hashes_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+        File.write(@file_hashes_path, JSON.pretty_generate(hashes))
+
+        Aidp.log_debug("metadata", "Saved file hashes", count: hashes.size, path: @file_hashes_path)
+      end
+    end
+  end
+end