aidp 0.28.0 → 0.29.0

data/lib/aidp/metadata/scanner.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "parser"
+
+module Aidp
+  module Metadata
+    # Scans directories for tool files and extracts metadata
+    #
+    # Recursively finds all .md files in configured directories,
+    # parses their metadata, and returns a collection of ToolMetadata objects.
+    #
+    # @example Scanning directories
+    #   scanner = Scanner.new([".aidp/skills", ".aidp/templates"])
+    #   tools = scanner.scan_all
+    class Scanner
+      # Initialize scanner with directory paths
+      #
+      # @param directories [Array<String>] Directories to scan
+      def initialize(directories = [])
+        @directories = Array(directories)
+      end
+
+      # Scan all configured directories
+      #
+      # @return [Array<ToolMetadata>] All discovered tool metadata
+      def scan_all
+        Aidp.log_debug("metadata", "Scanning directories", directories: @directories)
+
+        all_tools = []
+        @directories.each do |dir|
+          tools = scan_directory(dir)
+          all_tools.concat(tools)
+        end
+
+        Aidp.log_info(
+          "metadata",
+          "Scan complete",
+          directories: @directories.size,
+          tools_found: all_tools.size
+        )
+
+        all_tools
+      end
+
+      # Scan a single directory
+      #
+      # @param directory [String] Directory path to scan
+      # @param type [String, nil] Tool type filter or nil for all
+      # @return [Array<ToolMetadata>] Discovered tool metadata
+      def scan_directory(directory, type: nil)
+        unless Dir.exist?(directory)
+          Aidp.log_warn("metadata", "Directory not found", directory: directory)
+          return []
+        end
+
+        Aidp.log_debug("metadata", "Scanning directory", directory: directory, type: type)
+
+        tools = []
+        md_files = find_markdown_files(directory)
+
+        md_files.each do |file_path|
+          tool = Parser.parse_file(file_path, type: type)
+          tools << tool if type.nil? || tool.type == type
+        rescue Aidp::Errors::ValidationError => e
+          Aidp.log_warn(
+            "metadata",
+            "Failed to parse file",
+            file: file_path,
+            error: e.message
+          )
+        end
+
+        Aidp.log_debug(
+          "metadata",
+          "Directory scan complete",
+          directory: directory,
+          files_found: md_files.size,
+          tools_parsed: tools.size
+        )
+
+        tools
+      end
+
+      # Find all markdown files in directory recursively
+      #
+      # @param directory [String] Directory path
+      # @return [Array<String>] Paths to .md files
+      def find_markdown_files(directory)
+        pattern = File.join(directory, "**", "*.md")
+        files = Dir.glob(pattern)
+
+        Aidp.log_debug(
+          "metadata",
+          "Found markdown files",
+          directory: directory,
+          count: files.size
+        )
+
+        files
+      end
+
+      # Scan with file filtering
+      #
+      # @param directory [String] Directory path
+      # @param filter [Proc] Filter proc that receives file_path and returns boolean
+      # @return [Array<ToolMetadata>] Filtered tool metadata
+      def scan_with_filter(directory, &filter)
+        unless Dir.exist?(directory)
+          Aidp.log_warn("metadata", "Directory not found", directory: directory)
+          return []
+        end
+
+        tools = []
+        md_files = find_markdown_files(directory)
+
+        md_files.each do |file_path|
+          next unless filter.call(file_path)
+
+          begin
+            tool = Parser.parse_file(file_path)
+            tools << tool
+          rescue Aidp::Errors::ValidationError => e
+            Aidp.log_warn(
+              "metadata",
+              "Failed to parse file",
+              file: file_path,
+              error: e.message
+            )
+          end
+        end
+
+        tools
+      end
+
+      # Scan for changes since last scan
+      #
+      # Compares file hashes to detect changes
+      #
+      # @param directory [String] Directory path
+      # @param previous_hashes [Hash<String, String>] Map of file_path => file_hash
+      # @return [Hash] Hash with :added, :modified, :removed keys
+      def scan_changes(directory, previous_hashes = {})
+        Aidp.log_debug("metadata", "Scanning for changes", directory: directory)
+
+        current_files = find_markdown_files(directory)
+        current_hashes = {}
+
+        changes = {
+          added: [],
+          modified: [],
+          removed: [],
+          unchanged: []
+        }
+
+        # Check for added and modified files
+        current_files.each do |file_path|
+          content = File.read(file_path, encoding: "UTF-8")
+          file_hash = Parser.compute_file_hash(content)
+          current_hashes[file_path] = file_hash
+
+          if previous_hashes.key?(file_path)
+            if previous_hashes[file_path] != file_hash
+              changes[:modified] << file_path
+            else
+              changes[:unchanged] << file_path
+            end
+          else
+            changes[:added] << file_path
+          end
+        end
+
+        # Check for removed files
+        previous_hashes.keys.each do |file_path|
+          changes[:removed] << file_path unless current_hashes.key?(file_path)
+        end
+
+        Aidp.log_info(
+          "metadata",
+          "Change detection complete",
+          added: changes[:added].size,
+          modified: changes[:modified].size,
+          removed: changes[:removed].size,
+          unchanged: changes[:unchanged].size
+        )
+
+        changes
+      end
+    end
+  end
+end

data/lib/aidp/metadata/tool_metadata.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Aidp
+  module Metadata
+    # Base class for tool metadata (skills, personas, templates)
+    #
+    # Represents metadata extracted from YAML frontmatter in .md files.
+    # Provides validation and query capabilities for the tool directory.
+    #
+    # @example Creating tool metadata
+    #   metadata = ToolMetadata.new(
+    #     type: "skill",
+    #     id: "ruby_rspec_tdd",
+    #     title: "Ruby RSpec TDD Implementer",
+    #     summary: "Expert in Test-Driven Development",
+    #     version: "1.0.0",
+    #     applies_to: ["ruby", "testing"],
+    #     work_unit_types: ["implementation", "testing"],
+    #     priority: 10,
+    #     content: "You are a TDD expert...",
+    #     source_path: "/path/to/SKILL.md"
+    #   )
+    class ToolMetadata
+      attr_reader :type, :id, :title, :summary, :version,
+        :applies_to, :work_unit_types, :priority,
+        :capabilities, :dependencies, :experimental,
+        :content, :source_path, :file_hash
+
+      # Valid tool types
+      VALID_TYPES = %w[skill persona template].freeze
+
+      # Default priority (medium)
+      DEFAULT_PRIORITY = 5
+
+      # Initialize new tool metadata
+      #
+      # @param type [String] Tool type: "skill", "persona", or "template"
+      # @param id [String] Unique identifier (lowercase, alphanumeric, underscores)
+      # @param title [String] Human-readable title
+      # @param summary [String] Brief one-line summary
+      # @param version [String] Semantic version (e.g., "1.0.0")
+      # @param applies_to [Array<String>] Tags indicating applicability
+      # @param work_unit_types [Array<String>] Work unit types this tool supports
+      # @param priority [Integer] Priority for ranking (1-10, default 5)
+      # @param capabilities [Array<String>] Capabilities provided by this tool
+      # @param dependencies [Array<String>] IDs of required tools
+      # @param experimental [Boolean] Whether this is experimental
+      # @param content [String] The tool content (markdown)
+      # @param source_path [String] Path to source .md file
+      # @param file_hash [String] SHA256 hash of source file for cache invalidation
+      def initialize(
+        type:,
+        id:,
+        title:,
+        summary:,
+        version:,
+        content:,
+        source_path:,
+        file_hash:,
+        applies_to: [],
+        work_unit_types: [],
+        priority: DEFAULT_PRIORITY,
+        capabilities: [],
+        dependencies: [],
+        experimental: false
+      )
+        @type = type
+        @id = id
+        @title = title
+        @summary = summary
+        @version = version
+        @applies_to = Array(applies_to)
+        @work_unit_types = Array(work_unit_types)
+        @priority = priority
+        @capabilities = Array(capabilities)
+        @dependencies = Array(dependencies)
+        @experimental = experimental
+        @content = content
+        @source_path = source_path
+        @file_hash = file_hash
+
+        validate!
+      end
+
+      # Check if this tool applies to given tags
+      #
+      # @param tags [Array<String>] Tags to check against
+      # @return [Boolean] True if any tag matches applies_to
+      def applies_to?(tags)
+        return true if applies_to.empty?
+        tags = Array(tags).map(&:downcase)
+        applies_to.map(&:downcase).any? { |tag| tags.include?(tag) }
+      end
+
+      # Check if this tool supports a given work unit type
+      #
+      # @param type [String] Work unit type (e.g., "implementation", "analysis")
+      # @return [Boolean] True if type is supported
+      def supports_work_unit?(type)
+        return true if work_unit_types.empty?
+        work_unit_types.map(&:downcase).include?(type.to_s.downcase)
+      end
+
+      # Get a summary of this tool for display
+      #
+      # @return [Hash] Summary with key metadata
+      def summary_hash
+        {
+          type: type,
+          id: id,
+          title: title,
+          summary: summary,
+          version: version,
+          priority: priority,
+          tags: applies_to,
+          experimental: experimental
+        }
+      end
+
+      # Get full details of this tool for display
+      #
+      # @return [Hash] Detailed tool information
+      def details
+        {
+          type: type,
+          id: id,
+          title: title,
+          summary: summary,
+          version: version,
+          applies_to: applies_to,
+          work_unit_types: work_unit_types,
+          priority: priority,
+          capabilities: capabilities,
+          dependencies: dependencies,
+          experimental: experimental,
+          source: source_path,
+          file_hash: file_hash,
+          content_length: content.length
+        }
+      end
+
+      # Convert to hash for serialization
+      #
+      # @return [Hash] Metadata as hash (for JSON)
+      def to_h
+        {
+          type: type,
+          id: id,
+          title: title,
+          summary: summary,
+          version: version,
+          applies_to: applies_to,
+          work_unit_types: work_unit_types,
+          priority: priority,
+          capabilities: capabilities,
+          dependencies: dependencies,
+          experimental: experimental,
+          source_path: source_path,
+          file_hash: file_hash
+        }
+      end
+
+      # Return string representation
+      #
+      # @return [String] Tool representation
+      def to_s
+        "#{type.capitalize}[#{id}](#{title} v#{version})"
+      end
+
+      # Return inspection string
+      #
+      # @return [String] Detailed inspection
+      def inspect
+        "#<Aidp::Metadata::ToolMetadata type=#{type} id=#{id} title=\"#{title}\" " \
+          "version=#{version} source=#{source_path}>"
+      end
+
+      private
+
+      # Validate required fields and types
+      #
+      # @raise [Aidp::Errors::ValidationError] if validation fails
+      def validate!
+        validate_required_fields!
+        validate_types!
+        validate_formats!
+        validate_ranges!
+      end
+
+      # Validate required fields are present
+      def validate_required_fields!
+        raise Aidp::Errors::ValidationError, "type is required" if type.nil? || type.strip.empty?
+        raise Aidp::Errors::ValidationError, "id is required" if id.nil? || id.strip.empty?
+        raise Aidp::Errors::ValidationError, "title is required" if title.nil? || title.strip.empty?
+        raise Aidp::Errors::ValidationError, "summary is required" if summary.nil? || summary.strip.empty?
+        raise Aidp::Errors::ValidationError, "version is required" if version.nil? || version.strip.empty?
+        raise Aidp::Errors::ValidationError, "content is required" if content.nil? || content.strip.empty?
+        raise Aidp::Errors::ValidationError, "source_path is required" if source_path.nil? || source_path.strip.empty?
+        raise Aidp::Errors::ValidationError, "file_hash is required" if file_hash.nil? || file_hash.strip.empty?
+      end
+
+      # Validate field types
+      def validate_types!
+        unless VALID_TYPES.include?(type)
+          raise Aidp::Errors::ValidationError, "type must be one of: #{VALID_TYPES.join(", ")}"
+        end
+
+        unless priority.is_a?(Integer)
+          raise Aidp::Errors::ValidationError, "priority must be an integer"
+        end
+
+        unless [true, false].include?(experimental)
+          raise Aidp::Errors::ValidationError, "experimental must be boolean"
+        end
+      end
+
+      # Validate field formats
+      def validate_formats!
+        # Validate version format (simple semantic version check)
+        unless version.match?(/^\d+\.\d+\.\d+/)
+          raise Aidp::Errors::ValidationError, "version must be in format X.Y.Z (e.g., 1.0.0)"
+        end
+
+        # Validate id format (lowercase, alphanumeric, underscores only)
+        unless id.match?(/^[a-z0-9_]+$/)
+          raise Aidp::Errors::ValidationError, "id must be lowercase alphanumeric with underscores only"
+        end
+
+        # Validate file_hash format (SHA256 hex)
+        unless file_hash.match?(/^[a-f0-9]{64}$/)
+          raise Aidp::Errors::ValidationError, "file_hash must be a valid SHA256 hex string"
+        end
+      end
+
+      # Validate value ranges
+      def validate_ranges!
+        unless priority.between?(1, 10)
+          raise Aidp::Errors::ValidationError, "priority must be between 1 and 10"
+        end
+      end
+    end
+  end
+end

data/lib/aidp/metadata/validator.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Aidp
+  module Metadata
+    # Validates tool metadata and detects issues
+    #
+    # Performs validation checks on tool metadata including:
+    # - Required field presence
+    # - Field type validation
+    # - Duplicate ID detection
+    # - Dependency resolution
+    # - Version format validation
+    #
+    # @example Validating a collection of tools
+    #   validator = Validator.new(tools)
+    #   results = validator.validate_all
+    #   results.each { |r| puts "#{r[:file]}: #{r[:errors].join(", ")}" }
+    class Validator
+      # Validation result structure
+      ValidationResult = Struct.new(:tool_id, :file_path, :valid, :errors, :warnings, keyword_init: true)
+
+      # Initialize validator with tool metadata collection
+      #
+      # @param tools [Array<ToolMetadata>] Tools to validate
+      def initialize(tools = [])
+        @tools = tools
+        @errors_by_id = {}
+        @warnings_by_id = {}
+      end
+
+      # Validate all tools
+      #
+      # @return [Array<ValidationResult>] Validation results for each tool
+      def validate_all
+        Aidp.log_debug("metadata", "Validating all tools", count: @tools.size)
+
+        results = @tools.map do |tool|
+          validate_tool(tool)
+        end
+
+        # Cross-tool validations
+        validate_duplicate_ids(results)
+        validate_dependencies(results)
+
+        Aidp.log_info(
+          "metadata",
+          "Validation complete",
+          total: results.size,
+          valid: results.count(&:valid),
+          invalid: results.count { |r| !r.valid }
+        )
+
+        results
+      end
+
+      # Validate a single tool
+      #
+      # @param tool [ToolMetadata] Tool to validate
+      # @return [ValidationResult] Validation result
+      def validate_tool(tool)
+        errors = []
+        warnings = []
+
+        # Tool metadata validates itself on initialization
+        # Here we add additional cross-cutting validations
+
+        # Check for empty arrays in key fields
+        if tool.applies_to.empty? && tool.work_unit_types.empty?
+          warnings << "No applies_to tags or work_unit_types specified (tool may not be discoverable)"
+        end
+
+        # Check for deprecated fields or patterns
+        validate_deprecated_patterns(tool, warnings)
+
+        # Check for experimental tools
+        if tool.experimental
+          warnings << "Tool is marked as experimental"
+        end
+
+        # Check content length
+        if tool.content.length < 100
+          warnings << "Tool content is very short (#{tool.content.length} characters)"
+        end
+
+        ValidationResult.new(
+          tool_id: tool.id,
+          file_path: tool.source_path,
+          valid: errors.empty?,
+          errors: errors,
+          warnings: warnings
+        )
+      rescue Aidp::Errors::ValidationError => e
+        # Catch validation errors from tool initialization
+        ValidationResult.new(
+          tool_id: tool&.id || "unknown",
+          file_path: tool&.source_path || "unknown",
+          valid: false,
+          errors: [e.message],
+          warnings: []
+        )
+      end
+
+      # Validate for duplicate IDs across tools
+      #
+      # @param results [Array<ValidationResult>] Validation results
+      def validate_duplicate_ids(results)
+        ids = @tools.map(&:id)
+        duplicates = ids.tally.select { |_, count| count > 1 }.keys
+
+        return if duplicates.empty?
+
+        duplicates.each do |dup_id|
+          matching_tools = @tools.select { |t| t.id == dup_id }
+          matching_tools.each do |tool|
+            result = results.find { |r| r.tool_id == tool.id && r.file_path == tool.source_path }
+            next unless result
+
+            paths = matching_tools.map(&:source_path).join(", ")
+            result.errors << "Duplicate ID '#{dup_id}' found in: #{paths}"
+            result.valid = false
+          end
+        end
+
+        Aidp.log_warn("metadata", "Duplicate IDs detected", duplicates: duplicates)
+      end
+
+      # Validate tool dependencies are satisfied
+      #
+      # @param results [Array<ValidationResult>] Validation results
+      def validate_dependencies(results)
+        available_ids = @tools.map(&:id).to_set
+
+        @tools.each do |tool|
+          next if tool.dependencies.empty?
+
+          tool.dependencies.each do |dep_id|
+            next if available_ids.include?(dep_id)
+
+            result = results.find { |r| r.tool_id == tool.id && r.file_path == tool.source_path }
+            next unless result
+
+            result.errors << "Missing dependency: '#{dep_id}'"
+            result.valid = false
+          end
+        end
+      end
+
+      # Check for deprecated patterns in tool metadata
+      #
+      # @param tool [ToolMetadata] Tool to check
+      # @param warnings [Array<String>] Warnings array to append to
+      def validate_deprecated_patterns(tool, warnings)
+        # Check for legacy field usage (this would be expanded based on actual deprecations)
+        # For now, this is a placeholder for future deprecation warnings
+      end
+
+      # Write validation errors to log file
+      #
+      # @param results [Array<ValidationResult>] Validation results
+      # @param log_path [String] Path to error log file
+      def write_error_log(results, log_path)
+        Aidp.log_debug("metadata", "Writing error log", path: log_path)
+
+        errors = results.reject(&:valid)
+        return if errors.empty?
+
+        File.open(log_path, "w") do |f|
+          f.puts "# Metadata Validation Errors"
+          f.puts "# Generated: #{Time.now.iso8601}"
+          f.puts
+
+          errors.each do |result|
+            f.puts "## #{result.tool_id} (#{result.file_path})"
+            f.puts
+            result.errors.each { |err| f.puts "- ERROR: #{err}" }
+            result.warnings.each { |warn| f.puts "- WARNING: #{warn}" }
+            f.puts
+          end
+        end
+
+        Aidp.log_info("metadata", "Wrote error log", path: log_path, error_count: errors.size)
+      end
+    end
+  end
+end

data/lib/aidp/providers/aider.rb

@@ -75,7 +75,7 @@ module Aidp
         end
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "aider CLI not available" unless self.class.available?
 
         # Smart timeout calculation (store prompt length for adaptive logic)

data/lib/aidp/providers/anthropic.rb

@@ -9,6 +9,8 @@ module Aidp
     class Anthropic < Base
       include Aidp::DebugMixin
 
+      attr_reader :model
+
       # Model name pattern for Anthropic Claude models
       MODEL_PATTERN = /^claude-[\d.-]+-(?:opus|sonnet|haiku)(?:-\d{8})?$/i
 
@@ -250,13 +252,13 @@ module Aidp
         }
       end
 
-      def send_message(prompt:, session: nil)
+      def send_message(prompt:, session: nil, options: {})
         raise "claude CLI not available" unless self.class.available?
 
-        # Smart timeout calculation
-        timeout_seconds = calculate_timeout
+        # Smart timeout calculation with tier awareness
+        timeout_seconds = calculate_timeout(options)
 
-        debug_provider("claude", "Starting execution", {timeout: timeout_seconds})
+        debug_provider("claude", "Starting execution", {timeout: timeout_seconds, tier: options[:tier]})
         debug_log("📝 Sending prompt to claude...", level: :info)
 
         # Build command arguments