aidp 0.16.0 → 0.17.0

data/lib/aidp/skills/registry.rb

@@ -8,10 +8,10 @@ module Aidp
     # lookup, filtering, and management capabilities.
     #
     # Skills are loaded from:
-    # 1. Built-in skills directory (project_root/skills/)
-    # 2. Custom skills directory (.aidp/skills/)
+    # 1. Template skills directory (gem templates/skills/) - built-in templates
+    # 2. Project skills directory (.aidp/skills/) - project-specific skills
     #
-    # Custom skills with matching IDs override built-in skills.
+    # Project skills with matching IDs override template skills.
     #
     # @example Basic usage
     #   registry = Registry.new(project_dir: "/path/to/project")
@@ -39,8 +39,8 @@ module Aidp
       # Load skills from all search paths
       #
       # Skills are loaded in order:
-      # 1. Built-in skills (project_root/skills/)
-      # 2. Custom skills (.aidp/skills/) - override built-in
+      # 1. Template skills (gem templates/skills/) - built-in templates
+      # 2. Project skills (.aidp/skills/) - override templates
       #
       # @return [Integer] Number of skills loaded
       def load_skills
@@ -48,13 +48,13 @@ module Aidp
 
         @skills = {}
 
-        # Load built-in skills first
-        builtin_skills = load_from_path(builtin_skills_path)
-        builtin_skills.each { |skill| register_skill(skill, source: :builtin) }
+        # Load template skills first
+        template_skills = load_from_path(template_skills_path)
+        template_skills.each { |skill| register_skill(skill, source: :template) }
 
-        # Load custom skills (override built-in if IDs match)
-        custom_skills = load_from_path(custom_skills_path)
-        custom_skills.each { |skill| register_skill(skill, source: :custom) }
+        # Load project skills (override templates if IDs match)
+        project_skills = load_from_path(project_skills_path)
+        project_skills.each { |skill| register_skill(skill, source: :project) }
 
         @loaded = true
 
@@ -139,13 +139,13 @@ module Aidp
 
       # Get skill IDs grouped by source
       #
-      # @return [Hash] Hash with :builtin and :custom arrays
+      # @return [Hash] Hash with :template and :project arrays
       def by_source
         load_skills unless loaded?
 
         {
-          builtin: @skills.values.select { |s| builtin_skill?(s) }.map(&:id),
-          custom: @skills.values.select { |s| custom_skill?(s) }.map(&:id)
+          template: @skills.values.select { |s| template_skill?(s) }.map(&:id),
+          project: @skills.values.select { |s| project_skill?(s) }.map(&:id)
         }
       end
 
@@ -186,34 +186,36 @@ module Aidp
         Loader.load_from_directory(path, provider: provider)
       end
 
-      # Get built-in skills path
+      # Get template skills path (from gem)
       #
-      # @return [String] Path to built-in skills directory
-      def builtin_skills_path
-        File.join(project_dir, "skills")
+      # @return [String] Path to template skills directory
+      def template_skills_path
+        # Get the gem root directory (go up from lib/aidp/skills/registry.rb)
+        gem_root = File.expand_path("../../../..", __dir__)
+        File.join(gem_root, "templates", "skills")
       end
 
-      # Get custom skills path
+      # Get project skills path
       #
-      # @return [String] Path to custom skills directory
-      def custom_skills_path
+      # @return [String] Path to project-specific skills directory
+      def project_skills_path
         File.join(project_dir, ".aidp", "skills")
       end
 
-      # Check if skill is from built-in directory
+      # Check if skill is from template directory
       #
       # @param skill [Skill] Skill to check
-      # @return [Boolean] True if built-in
-      def builtin_skill?(skill)
-        skill.source_path.start_with?(builtin_skills_path)
+      # @return [Boolean] True if template
+      def template_skill?(skill)
+        skill.source_path.start_with?(template_skills_path)
       end
 
-      # Check if skill is from custom directory
+      # Check if skill is from project directory
       #
       # @param skill [Skill] Skill to check
-      # @return [Boolean] True if custom
-      def custom_skill?(skill)
-        skill.source_path.start_with?(custom_skills_path)
+      # @return [Boolean] True if project
+      def project_skill?(skill)
+        skill.source_path.start_with?(project_skills_path)
       end
     end
   end

data/lib/aidp/skills/router.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Aidp
+  module Skills
+    # Routes file paths and tasks to appropriate skills based on routing rules
+    #
+    # The Router reads routing configuration from aidp.yml and matches:
+    # - File paths against glob patterns (path_rules)
+    # - Task descriptions against keywords (task_rules)
+    # - Combined path + task rules (combined_rules)
+    #
+    # @example Basic usage
+    #   router = Router.new(project_dir: Dir.pwd)
+    #   skill_id = router.route_by_path("app/controllers/users_controller.rb")
+    #   # => "rails_expert"
+    #
+    # @example Task-based routing
+    #   router = Router.new(project_dir: Dir.pwd)
+    #   skill_id = router.route_by_task("Add API endpoint")
+    #   # => "backend_developer"
+    #
+    # @example Combined routing
+    #   router = Router.new(project_dir: Dir.pwd)
+    #   skill_id = router.route(path: "lib/cli.rb", task: "Add command")
+    #   # => "cli_expert"
+    class Router
+      attr_reader :config, :project_dir
+
+      # Initialize router with project directory
+      #
+      # @param project_dir [String] Path to project directory
+      def initialize(project_dir:)
+        @project_dir = project_dir
+        @config = load_config
+      end
+
+      # Route based on both path and task (highest priority)
+      #
+      # @param path [String, nil] File path to route
+      # @param task [String, nil] Task description to route
+      # @return [String, nil] Matched skill ID or nil
+      def route(path: nil, task: nil)
+        # Priority 1: Combined rules (path AND task)
+        if path && task
+          combined_match = match_combined_rules(path, task)
+          return combined_match if combined_match
+        end
+
+        # Priority 2: Path rules
+        path_match = route_by_path(path) if path
+        return path_match if path_match
+
+        # Priority 3: Task rules
+        task_match = route_by_task(task) if task
+        return task_match if task_match
+
+        # Priority 4: Default skill
+        config.dig("skills", "routing", "default")
+      end
+
+      # Route based on file path
+      #
+      # @param path [String] File path to match against patterns
+      # @return [String, nil] Matched skill ID or nil
+      def route_by_path(path)
+        return nil unless path
+
+        path_rules = config.dig("skills", "routing", "path_rules") || {}
+
+        path_rules.each do |skill_id, patterns|
+          patterns = [patterns] unless patterns.is_a?(Array)
+          patterns.each do |pattern|
+            return skill_id if File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+        end
+
+        nil
+      end
+
+      # Route based on task description
+      #
+      # @param task [String] Task description to match against keywords
+      # @return [String, nil] Matched skill ID or nil
+      def route_by_task(task)
+        return nil unless task
+
+        task_rules = config.dig("skills", "routing", "task_rules") || {}
+        task_lower = task.downcase
+
+        task_rules.each do |skill_id, keywords|
+          keywords = [keywords] unless keywords.is_a?(Array)
+          keywords.each do |keyword|
+            return skill_id if task_lower.include?(keyword.downcase)
+          end
+        end
+
+        nil
+      end
+
+      # Check if routing is enabled
+      #
+      # @return [Boolean] true if routing is configured
+      def routing_enabled?
+        config.dig("skills", "routing", "enabled") == true
+      end
+
+      # Get default skill
+      #
+      # @return [String, nil] Default skill ID or nil
+      def default_skill
+        config.dig("skills", "routing", "default")
+      end
+
+      # Get all routing rules
+      #
+      # @return [Hash] Hash containing path_rules, task_rules, and combined_rules
+      def rules
+        {
+          path_rules: config.dig("skills", "routing", "path_rules") || {},
+          task_rules: config.dig("skills", "routing", "task_rules") || {},
+          combined_rules: config.dig("skills", "routing", "combined_rules") || {}
+        }
+      end
+
+      private
+
+      # Match combined rules (path AND task must both match)
+      #
+      # @param path [String] File path
+      # @param task [String] Task description
+      # @return [String, nil] Matched skill ID or nil
+      def match_combined_rules(path, task)
+        combined_rules = config.dig("skills", "routing", "combined_rules") || {}
+        task_lower = task.downcase
+
+        combined_rules.each do |skill_id, rule|
+          path_patterns = rule["paths"] || []
+          task_keywords = rule["tasks"] || []
+
+          path_patterns = [path_patterns] unless path_patterns.is_a?(Array)
+          task_keywords = [task_keywords] unless task_keywords.is_a?(Array)
+
+          # Check if path matches any pattern
+          path_match = path_patterns.any? do |pattern|
+            File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
+
+          # Check if task matches any keyword
+          task_match = task_keywords.any? do |keyword|
+            task_lower.include?(keyword.downcase)
+          end
+
+          return skill_id if path_match && task_match
+        end
+
+        nil
+      end
+
+      # Load routing configuration from aidp.yml
+      #
+      # @return [Hash] Configuration hash
+      def load_config
+        config_path = File.join(project_dir, ".aidp", "aidp.yml")
+
+        if File.exist?(config_path)
+          YAML.safe_load_file(config_path, permitted_classes: [Date, Time, Symbol], aliases: true) || {}
+        else
+          {}
+        end
+      rescue => e
+        Aidp.log_error("skills", "Failed to load routing config", error: e.message)
+        {}
+      end
+    end
+  end
+end

data/lib/aidp/skills/wizard/builder.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../skill"
+
+module Aidp
+  module Skills
+    module Wizard
+      # Builds Skill objects from wizard responses
+      #
+      # Takes user input from the wizard and constructs a valid Skill object.
+      # Handles template inheritance by merging metadata and content.
+      #
+      # @example Building a new skill
+      #   builder = Builder.new
+      #   responses = { id: "my_skill", name: "My Skill", ... }
+      #   skill = builder.build(responses)
+      #
+      # @example Building from a template
+      #   builder = Builder.new(base_skill: template)
+      #   responses = { id: "my_skill", ... }
+      #   skill = builder.build(responses)  # Inherits from template
+      class Builder
+        attr_reader :base_skill
+
+        # Initialize builder
+        #
+        # @param base_skill [Skill, nil] Optional base skill for inheritance
+        def initialize(base_skill: nil)
+          @base_skill = base_skill
+        end
+
+        # Build a Skill from wizard responses
+        #
+        # @param responses [Hash] Wizard responses
+        # @option responses [String] :id Skill ID
+        # @option responses [String] :name Skill name
+        # @option responses [String] :description Description
+        # @option responses [String] :version Version (default: "1.0.0")
+        # @option responses [Array<String>] :expertise Expertise areas
+        # @option responses [Array<String>] :keywords Keywords
+        # @option responses [Array<String>] :when_to_use When to use
+        # @option responses [Array<String>] :when_not_to_use When not to use
+        # @option responses [Array<String>] :compatible_providers Compatible providers
+        # @option responses [String] :content Markdown content
+        # @return [Skill] Built skill
+        def build(responses)
+          # Merge with base skill if provided
+          merged = if base_skill
+            merge_with_base(responses)
+          else
+            responses
+          end
+
+          # Create skill with merged attributes
+          # Note: source_path will be set by Writer when saved
+          Skill.new(
+            id: merged[:id],
+            name: merged[:name],
+            description: merged[:description],
+            version: merged[:version] || "1.0.0",
+            expertise: Array(merged[:expertise]),
+            keywords: Array(merged[:keywords]),
+            when_to_use: Array(merged[:when_to_use]),
+            when_not_to_use: Array(merged[:when_not_to_use]),
+            compatible_providers: Array(merged[:compatible_providers]),
+            content: merged[:content],
+            source_path: merged[:source_path] || "<pending>"
+          )
+        end
+
+        # Generate YAML frontmatter + content for writing
+        #
+        # @param skill [Skill] Skill to serialize
+        # @return [String] Complete SKILL.md content
+        def to_skill_md(skill)
+          frontmatter = build_frontmatter(skill)
+          "#{frontmatter}\n#{skill.content}"
+        end
+
+        private
+
+        # Merge responses with base skill
+        #
+        # @param responses [Hash] User responses
+        # @return [Hash] Merged attributes
+        def merge_with_base(responses)
+          {
+            id: responses[:id],
+            name: responses[:name] || base_skill.name,
+            description: responses[:description] || base_skill.description,
+            version: responses[:version] || "1.0.0",
+            expertise: merge_arrays(base_skill.expertise, responses[:expertise]),
+            keywords: merge_arrays(base_skill.keywords, responses[:keywords]),
+            when_to_use: merge_arrays(base_skill.when_to_use, responses[:when_to_use]),
+            when_not_to_use: merge_arrays(base_skill.when_not_to_use, responses[:when_not_to_use]),
+            compatible_providers: responses[:compatible_providers] || base_skill.compatible_providers,
+            content: responses[:content] || base_skill.content,
+            source_path: responses[:source_path]
+          }
+        end
+
+        # Merge arrays (base + new, deduplicated)
+        #
+        # @param base [Array] Base array
+        # @param new_items [Array, nil] New items
+        # @return [Array] Merged and deduplicated array
+        def merge_arrays(base, new_items)
+          return base if new_items.nil? || new_items.empty?
+          (base + Array(new_items)).uniq
+        end
+
+        # Build YAML frontmatter
+        #
+        # @param skill [Skill] Skill object
+        # @return [String] YAML frontmatter block
+        def build_frontmatter(skill)
+          data = {
+            "id" => skill.id,
+            "name" => skill.name,
+            "description" => skill.description,
+            "version" => skill.version
+          }
+
+          # Add optional arrays if not empty
+          data["expertise"] = skill.expertise unless skill.expertise.empty?
+          data["keywords"] = skill.keywords unless skill.keywords.empty?
+          data["when_to_use"] = skill.when_to_use unless skill.when_to_use.empty?
+          data["when_not_to_use"] = skill.when_not_to_use unless skill.when_not_to_use.empty?
+          data["compatible_providers"] = skill.compatible_providers unless skill.compatible_providers.empty?
+
+          # Generate YAML
+          yaml_content = data.to_yaml
+          # Remove the leading "---\n" that to_yaml adds, we'll add our own delimiters
+          yaml_content = yaml_content.sub(/\A---\n/, "")
+
+          "---\n#{yaml_content}---"
+        end
+      end
+    end
+  end
+end

data/lib/aidp/skills/wizard/controller.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative "template_library"
+require_relative "prompter"
+require_relative "builder"
+require_relative "writer"
+
+module Aidp
+  module Skills
+    module Wizard
+      # Controller orchestrating the skill creation wizard
+      #
+      # Coordinates the wizard flow: template selection, prompting, building,
+      # preview, and writing the skill.
+      #
+      # @example Creating a new skill
+      #   controller = Controller.new(project_dir: "/path/to/project")
+      #   controller.run
+      #
+      # @example With options
+      #   controller = Controller.new(
+      #     project_dir: "/path/to/project",
+      #     options: { id: "my_skill", dry_run: true }
+      #   )
+      #   controller.run
+      class Controller
+        attr_reader :project_dir, :options, :template_library, :prompter, :writer
+
+        # Initialize controller
+        #
+        # @param project_dir [String] Root directory of the project
+        # @param options [Hash] Wizard options
+        # @option options [String] :id Pre-filled skill ID
+        # @option options [String] :name Pre-filled skill name
+        # @option options [Boolean] :dry_run Don't write files
+        # @option options [Boolean] :minimal Skip optional sections
+        # @option options [Boolean] :open_editor Open in $EDITOR (future)
+        def initialize(project_dir:, options: {})
+          @project_dir = project_dir
+          @options = options
+          @template_library = TemplateLibrary.new(project_dir: project_dir)
+          @prompter = Prompter.new
+          @writer = Writer.new(project_dir: project_dir)
+        end
+
+        # Run the wizard
+        #
+        # @return [String, nil] Path to created skill file, or nil if cancelled/dry-run
+        def run
+          Aidp.log_info("wizard", "Starting skill creation wizard", options: options)
+
+          # Gather user responses
+          responses = prompter.gather_responses(template_library, options: options)
+
+          # Build skill from responses
+          base_skill = responses.delete(:base_skill)
+          builder = Builder.new(base_skill: base_skill)
+          skill = builder.build(responses)
+
+          # Generate SKILL.md content
+          skill_md_content = builder.to_skill_md(skill)
+
+          # Preview
+          show_preview(skill, skill_md_content) unless options[:minimal]
+
+          # Confirm
+          unless options[:dry_run] || options[:yes] || confirm_save(skill)
+            prompter.prompt.warn("Cancelled")
+            return nil
+          end
+
+          # Write to disk
+          path = writer.write(
+            skill,
+            content: skill_md_content,
+            dry_run: options[:dry_run],
+            backup: true
+          )
+
+          # Show success message
+          show_success(skill, path) unless options[:dry_run]
+
+          path
+        rescue Interrupt
+          prompter.prompt.warn("\nWizard cancelled")
+          nil
+        rescue => e
+          Aidp.log_error("wizard", "Wizard failed", error: e.message, backtrace: e.backtrace.first(5))
+          prompter.prompt.error("Error: #{e.message}")
+          nil
+        end
+
+        private
+
+        # Show preview of the skill
+        #
+        # @param skill [Skill] Built skill
+        # @param content [String] SKILL.md content
+        def show_preview(skill, content)
+          prompter.prompt.say("\n" + "=" * 60)
+          prompter.prompt.say("Skill Preview: #{skill.id} v#{skill.version}")
+          prompter.prompt.say("=" * 60 + "\n")
+
+          # Show first 20 lines of content
+          lines = content.lines
+          preview_lines = lines.first(20)
+          prompter.prompt.say(preview_lines.join)
+
+          if lines.size > 20
+            prompter.prompt.say("\n... (#{lines.size - 20} more lines)")
+          end
+
+          prompter.prompt.say("\n" + "=" * 60 + "\n")
+        end
+
+        # Confirm before saving
+        #
+        # @param skill [Skill] Skill to save
+        # @return [Boolean] True if user confirms
+        def confirm_save(skill)
+          if writer.exists?(skill.id)
+            prompter.prompt.warn("Warning: Skill '#{skill.id}' already exists and will be overwritten (backup will be created)")
+          end
+
+          prompter.prompt.yes?("Save this skill?")
+        end
+
+        # Show success message
+        #
+        # @param skill [Skill] Created skill
+        # @param path [String] Path to file
+        def show_success(skill, path)
+          prompter.prompt.say("\n✅ Skill created successfully!\n")
+          prompter.prompt.say("   ID:      #{skill.id}")
+          prompter.prompt.say("   Version: #{skill.version}")
+          prompter.prompt.say("   File:    #{path}")
+          prompter.prompt.say("\nNext steps:")
+          prompter.prompt.say("  • Review: aidp skill preview #{skill.id}")
+          prompter.prompt.say("  • Edit:   aidp skill edit #{skill.id}")
+          prompter.prompt.say("  • Use:    Reference in your workflow steps\n")
+        end
+      end
+    end
+  end
+end