aidp 0.16.0 → 0.17.1

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

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "pastel"
+require_relative "builder"
+
+module Aidp
+  module Skills
+    module Wizard
+      # Generates and displays diffs between skills
+      #
+      # Shows differences between an original skill and a modified version,
+      # or between a project skill and its template.
+      #
+      # @example Showing a diff
+      #   differ = Differ.new
+      #   diff = differ.diff(original_skill, modified_skill)
+      #   differ.display(diff)
+      class Differ
+        attr_reader :pastel
+
+        def initialize
+          @pastel = Pastel.new
+        end
+
+        # Generate a diff between two skills
+        #
+        # @param original [Skill, String] Original skill or content
+        # @param modified [Skill, String] Modified skill or content
+        # @return [Hash] Diff information
+        def diff(original, modified)
+          original_content = skill_to_content(original)
+          modified_content = skill_to_content(modified)
+
+          {
+            original: original_content,
+            modified: modified_content,
+            lines: generate_line_diff(original_content, modified_content),
+            has_changes: original_content != modified_content
+          }
+        end
+
+        # Display a diff to the terminal
+        #
+        # @param diff [Hash] Diff information from #diff
+        # @param output [IO] Output stream (default: $stdout)
+        def display(diff, output: $stdout)
+          unless diff[:has_changes]
+            output.puts pastel.dim("No differences found")
+            return
+          end
+
+          output.puts pastel.bold("\n" + "=" * 60)
+          output.puts pastel.bold("Skill Diff")
+          output.puts pastel.bold("=" * 60)
+
+          diff[:lines].each do |line_info|
+            case line_info[:type]
+            when :context
+              output.puts pastel.dim("  #{line_info[:line]}")
+            when :add
+              output.puts pastel.green("+ #{line_info[:line]}")
+            when :remove
+              output.puts pastel.red("- #{line_info[:line]}")
+            end
+          end
+
+          output.puts pastel.bold("=" * 60 + "\n")
+        end
+
+        # Generate a unified diff string
+        #
+        # @param original [Skill, String] Original skill or content
+        # @param modified [Skill, String] Modified skill or content
+        # @return [String] Unified diff format
+        def unified_diff(original, modified)
+          original_content = skill_to_content(original)
+          modified_content = skill_to_content(modified)
+
+          original_lines = original_content.lines
+          modified_lines = modified_content.lines
+
+          diff_lines = []
+          diff_lines << "--- original"
+          diff_lines << "+++ modified"
+
+          # Simple line-by-line diff (not optimal but functional)
+          max_lines = [original_lines.size, modified_lines.size].max
+
+          (0...max_lines).each do |i|
+            orig_line = original_lines[i]
+            mod_line = modified_lines[i]
+
+            if orig_line && !mod_line
+              diff_lines << "-#{orig_line}"
+            elsif !orig_line && mod_line
+              diff_lines << "+#{mod_line}"
+            elsif orig_line != mod_line
+              diff_lines << "-#{orig_line}"
+              diff_lines << "+#{mod_line}"
+            else
+              diff_lines << " #{orig_line}"
+            end
+          end
+
+          diff_lines.join
+        end
+
+        # Compare a project skill with its template
+        #
+        # @param project_skill [Skill] Project skill
+        # @param template_skill [Skill] Template skill
+        # @return [Hash] Comparison information
+        def compare_with_template(project_skill, template_skill)
+          {
+            skill_id: project_skill.id,
+            overrides: detect_overrides(project_skill, template_skill),
+            additions: detect_additions(project_skill, template_skill),
+            diff: diff(template_skill, project_skill)
+          }
+        end
+
+        private
+
+        # Convert skill or string to content
+        #
+        # @param skill_or_content [Skill, String] Skill object or content string
+        # @return [String] Content string
+        def skill_to_content(skill_or_content)
+          if skill_or_content.is_a?(String)
+            skill_or_content
+          elsif skill_or_content.respond_to?(:content)
+            # Build full SKILL.md content
+            builder = Builder.new
+            builder.to_skill_md(skill_or_content)
+          else
+            skill_or_content.to_s
+          end
+        end
+
+        # Generate line-by-line diff
+        #
+        # @param original [String] Original content
+        # @param modified [String] Modified content
+        # @return [Array<Hash>] Array of line diff information
+        def generate_line_diff(original, modified)
+          original_lines = original.lines.map(&:chomp)
+          modified_lines = modified.lines.map(&:chomp)
+
+          lines = []
+          i = 0
+          j = 0
+
+          while i < original_lines.size || j < modified_lines.size
+            if i >= original_lines.size
+              # Only modified lines remain
+              lines << {type: :add, line: modified_lines[j]}
+              j += 1
+            elsif j >= modified_lines.size
+              # Only original lines remain
+              lines << {type: :remove, line: original_lines[i]}
+              i += 1
+            elsif original_lines[i] == modified_lines[j]
+              # Lines match
+              lines << {type: :context, line: original_lines[i]}
+              i += 1
+              j += 1
+            else
+              # Lines differ - show removal then addition
+              lines << {type: :remove, line: original_lines[i]}
+              lines << {type: :add, line: modified_lines[j]}
+              i += 1
+              j += 1
+            end
+          end
+
+          lines
+        end
+
+        # Detect field overrides between project and template
+        #
+        # @param project_skill [Skill] Project skill
+        # @param template_skill [Skill] Template skill
+        # @return [Hash] Hash of overridden fields
+        def detect_overrides(project_skill, template_skill)
+          overrides = {}
+
+          # Check metadata fields
+          if project_skill.name != template_skill.name
+            overrides[:name] = {template: template_skill.name, project: project_skill.name}
+          end
+
+          if project_skill.description != template_skill.description
+            overrides[:description] = {template: template_skill.description, project: project_skill.description}
+          end
+
+          if project_skill.version != template_skill.version
+            overrides[:version] = {template: template_skill.version, project: project_skill.version}
+          end
+
+          if project_skill.content != template_skill.content
+            overrides[:content] = {template: "...", project: "..."}
+          end
+
+          overrides
+        end
+
+        # Detect additions in project skill compared to template
+        #
+        # @param project_skill [Skill] Project skill
+        # @param template_skill [Skill] Template skill
+        # @return [Hash] Hash of added items
+        def detect_additions(project_skill, template_skill)
+          additions = {}
+
+          # Check for added expertise
+          new_expertise = project_skill.expertise - template_skill.expertise
+          additions[:expertise] = new_expertise if new_expertise.any?
+
+          # Check for added keywords
+          new_keywords = project_skill.keywords - template_skill.keywords
+          additions[:keywords] = new_keywords if new_keywords.any?
+
+          # Check for added when_to_use
+          new_when_to_use = project_skill.when_to_use - template_skill.when_to_use
+          additions[:when_to_use] = new_when_to_use if new_when_to_use.any?
+
+          additions
+        end
+      end
+    end
+  end
+end