aidp 0.16.0 → 0.17.0

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

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

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "tty-prompt"
+
+module Aidp
+  module Skills
+    module Wizard
+      # Interactive prompter for the skill wizard
+      #
+      # Uses TTY::Prompt to gather user input through guided questions.
+      #
+      # @example Basic usage
+      #   prompter = Prompter.new
+      #   responses = prompter.gather_responses(template_library)
+      class Prompter
+        attr_reader :prompt
+
+        def initialize
+          @prompt = TTY::Prompt.new
+        end
+
+        # Gather all responses for creating a skill
+        #
+        # @param template_library [TemplateLibrary] Library for template selection
+        # @param options [Hash] Options for the wizard
+        # @option options [String] :id Pre-filled skill ID
+        # @option options [String] :name Pre-filled skill name
+        # @option options [Boolean] :minimal Skip optional sections
+        # @option options [String] :from_template Template ID to inherit from
+        # @option options [String] :clone Skill ID to clone
+        # @return [Hash] Complete set of responses
+        def gather_responses(template_library, options: {})
+          responses = {}
+
+          # Step 1: Template selection
+          if options[:from_template]
+            responses[:base_skill] = template_library.find(options[:from_template])
+            unless responses[:base_skill]
+              raise Aidp::Errors::ValidationError, "Template not found: #{options[:from_template]}"
+            end
+          elsif options[:clone]
+            responses[:base_skill] = template_library.find(options[:clone])
+            unless responses[:base_skill]
+              raise Aidp::Errors::ValidationError, "Skill not found: #{options[:clone]}"
+            end
+          elsif !options[:minimal]
+            responses[:base_skill] = prompt_template_selection(template_library)
+          end
+
+          # Step 2: Identity & Metadata
+          responses.merge!(prompt_identity(options))
+
+          # Step 3: Expertise & Keywords
+          responses.merge!(prompt_expertise) unless options[:minimal]
+
+          # Step 4: When to use
+          responses.merge!(prompt_when_to_use) unless options[:minimal]
+
+          # Step 5: Compatible providers
+          responses[:compatible_providers] = prompt_providers unless options[:minimal]
+
+          # Step 6: Content
+          responses[:content] = prompt_content(responses[:name], responses[:base_skill])
+
+          responses
+        end
+
+        private
+
+        # Prompt for template selection
+        #
+        # @param template_library [TemplateLibrary] Available templates
+        # @return [Skill, nil] Selected base skill or nil
+        def prompt_template_selection(template_library)
+          prompt.say("\n" + "=" * 60)
+          prompt.say("Create New Skill")
+          prompt.say("=" * 60 + "\n")
+
+          choice = prompt.select("How would you like to create your skill?") do |menu|
+            menu.choice "Start from scratch", :from_scratch
+            menu.choice "Inherit from a template", :inherit
+            menu.choice "Clone an existing skill", :clone
+          end
+
+          case choice
+          when :from_scratch
+            nil
+          when :inherit, :clone
+            select_base_skill(template_library)
+          end
+        end
+
+        # Select a base skill from templates
+        #
+        # @param template_library [TemplateLibrary] Available templates
+        # @return [Skill, nil] Selected skill
+        def select_base_skill(template_library)
+          skills = template_library.skill_list
+
+          if skills.empty?
+            prompt.warn("No templates available")
+            return nil
+          end
+
+          choices = skills.map do |skill_info|
+            source_label = (skill_info[:source] == :template) ? "(template)" : "(project)"
+            {
+              name: "#{skill_info[:name]} #{source_label} - #{skill_info[:description]}",
+              value: skill_info[:id]
+            }
+          end
+
+          selected_id = prompt.select("Select a base skill:", choices, per_page: 10)
+          template_library.find(selected_id)
+        end
+
+        # Prompt for identity and metadata
+        #
+        # @param options [Hash] Pre-filled values
+        # @return [Hash] Identity responses
+        def prompt_identity(options)
+          responses = {}
+
+          # Name
+          default_name = options[:name]
+          responses[:name] = prompt.ask("Skill Name:", default: default_name) do |q|
+            q.required true
+            q.modify :strip
+          end
+
+          # ID (auto-suggest from name)
+          suggested_id = options[:id] || slugify(responses[:name])
+          responses[:id] = prompt.ask("Skill ID:", default: suggested_id) do |q|
+            q.required true
+            q.modify :strip, :down
+            q.validate(/\A[a-z0-9_]+\z/, "ID must be lowercase alphanumeric with underscores only")
+          end
+
+          # Description
+          responses[:description] = prompt.ask("Description (one-line summary):") do |q|
+            q.required true
+            q.modify :strip
+          end
+
+          # Version
+          responses[:version] = prompt.ask("Version:", default: "1.0.0") do |q|
+            q.validate(/\A\d+\.\d+\.\d+\z/, "Must be semantic version (X.Y.Z)")
+          end
+
+          responses
+        end
+
+        # Prompt for expertise and keywords
+        #
+        # @return [Hash] Expertise responses
+        def prompt_expertise
+          responses = {}
+
+          # Expertise areas
+          prompt.say("\nExpertise Areas:")
+          prompt.say("(Enter expertise areas, one per line. Leave blank and press Enter when done)")
+
+          expertise = []
+          loop do
+            area = prompt.ask("  Area #{expertise.size + 1}:", required: false) do |q|
+              q.modify :strip
+            end
+            break if area.nil? || area.empty?
+            expertise << area
+          end
+          responses[:expertise] = expertise
+
+          # Keywords
+          keywords_input = prompt.ask("\nKeywords (comma-separated):", required: false) do |q|
+            q.modify :strip
+          end
+          responses[:keywords] = keywords_input ? keywords_input.split(",").map(&:strip).reject(&:empty?) : []
+
+          responses
+        end
+
+        # Prompt for when to use guidance
+        #
+        # @return [Hash] When to use responses
+        def prompt_when_to_use
+          responses = {}
+
+          # When to use
+          prompt.say("\nWhen to Use This Skill:")
+          prompt.say("(Enter use cases, one per line. Leave blank and press Enter when done)")
+
+          when_to_use = []
+          loop do
+            use_case = prompt.ask("  Use case #{when_to_use.size + 1}:", required: false) do |q|
+              q.modify :strip
+            end
+            break if use_case.nil? || use_case.empty?
+            when_to_use << use_case
+          end
+          responses[:when_to_use] = when_to_use
+
+          # When NOT to use
+          prompt.say("\nWhen NOT to Use This Skill:")
+          prompt.say("(Leave blank and press Enter when done)")
+
+          when_not_to_use = []
+          loop do
+            use_case = prompt.ask("  Avoid when #{when_not_to_use.size + 1}:", required: false) do |q|
+              q.modify :strip
+            end
+            break if use_case.nil? || use_case.empty?
+            when_not_to_use << use_case
+          end
+          responses[:when_not_to_use] = when_not_to_use
+
+          responses
+        end
+
+        # Prompt for compatible providers
+        #
+        # @return [Array<String>] Selected providers
+        def prompt_providers
+          choices = [
+            {name: "All providers (default)", value: []},
+            {name: "Anthropic only", value: ["anthropic"]},
+            {name: "OpenAI only", value: ["openai"]},
+            {name: "Codex only", value: ["codex"]},
+            {name: "Cursor only", value: ["cursor"]},
+            {name: "Custom selection", value: :custom}
+          ]
+
+          selection = prompt.select("\nCompatible AI Providers:", choices)
+
+          if selection == :custom
+            prompt.multi_select("Select providers:") do |menu|
+              menu.choice "Anthropic", "anthropic"
+              menu.choice "OpenAI", "openai"
+              menu.choice "Codex", "codex"
+              menu.choice "Cursor", "cursor"
+            end
+          else
+            selection
+          end
+        end
+
+        # Prompt for skill content
+        #
+        # @param skill_name [String] Name of the skill
+        # @param base_skill [Skill, nil] Base skill if inheriting
+        # @return [String] Markdown content
+        def prompt_content(skill_name, base_skill)
+          if base_skill
+            prompt.say("\nContent will be inherited from: #{base_skill.name}")
+            if prompt.yes?("Would you like to customize the content?")
+              prompt_custom_content(skill_name)
+            else
+              base_skill.content
+            end
+          else
+            prompt_custom_content(skill_name)
+          end
+        end
+
+        # Prompt for custom content
+        #
+        # @param skill_name [String] Name of the skill
+        # @return [String] Markdown content
+        def prompt_custom_content(skill_name)
+          prompt.say("\nContent:")
+          lines = prompt.multiline("Enter the skill content (markdown):")
+
+          if lines.empty?
+            # Provide a minimal template
+            generate_default_content(skill_name)
+          else
+            lines.join("\n")
+          end
+        end
+
+        # Generate default content template
+        #
+        # @param skill_name [String] Name of the skill
+        # @return [String] Default markdown content
+        def generate_default_content(skill_name)
+          <<~MARKDOWN
+            # #{skill_name}
+
+            You are a **#{skill_name}**, an expert in [describe expertise area].
+
+            ## Your Core Capabilities
+
+            - [Capability 1]
+            - [Capability 2]
+            - [Capability 3]
+
+            ## Your Approach
+
+            [Describe your philosophy and approach to tasks]
+          MARKDOWN
+        end
+
+        # Convert a name to a slug (for ID suggestion)
+        #
+        # @param name [String] Human-readable name
+        # @return [String] Slugified ID
+        def slugify(name)
+          name.to_s
+            .downcase
+            .gsub(/[^a-z0-9\s_-]/, "")
+            .gsub(/\s+/, "_")
+            .gsub(/-+/, "_").squeeze("_")
+            .gsub(/\A_|_\z/, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative "../loader"
+
+module Aidp
+  module Skills
+    module Wizard
+      # Manages skill templates for the wizard
+      #
+      # Loads and provides access to template skills from the gem's templates/skills/ directory
+      # and existing project skills from .aidp/skills/ for cloning.
+      #
+      # @example Loading templates
+      #   library = TemplateLibrary.new(project_dir: "/path/to/project")
+      #   templates = library.templates
+      #   template = library.find("base_developer")
+      class TemplateLibrary
+        attr_reader :project_dir
+
+        # Initialize template library
+        #
+        # @param project_dir [String] Root directory of the project
+        def initialize(project_dir:)
+          @project_dir = project_dir
+          @templates = nil
+          @project_skills = nil
+        end
+
+        # Get all available templates
+        #
+        # @return [Array<Skill>] Array of template skills
+        def templates
+          load_templates unless loaded?
+          @templates
+        end
+
+        # Get all project skills (for cloning)
+        #
+        # @return [Array<Skill>] Array of project-specific skills
+        def project_skills
+          load_project_skills unless project_skills_loaded?
+          @project_skills
+        end
+
+        # Get all skills (templates + project skills)
+        #
+        # @return [Array<Skill>] Combined array of all skills
+        def all
+          templates + project_skills
+        end
+
+        # Find a template or project skill by ID
+        #
+        # @param skill_id [String] Skill identifier
+        # @return [Skill, nil] Found skill or nil
+        def find(skill_id)
+          all.find { |skill| skill.id == skill_id.to_s }
+        end
+
+        # Check if a skill ID exists
+        #
+        # @param skill_id [String] Skill identifier
+        # @return [Boolean] True if skill exists
+        def exists?(skill_id)
+          !find(skill_id).nil?
+        end
+
+        # Get template names for display
+        #
+        # @return [Array<Hash>] Array of {id, name, description} hashes
+        def template_list
+          templates.map do |skill|
+            {
+              id: skill.id,
+              name: skill.name,
+              description: skill.description,
+              source: :template
+            }
+          end
+        end
+
+        # Get project skill names for display
+        #
+        # @return [Array<Hash>] Array of {id, name, description} hashes
+        def project_skill_list
+          project_skills.map do |skill|
+            {
+              id: skill.id,
+              name: skill.name,
+              description: skill.description,
+              source: :project
+            }
+          end
+        end
+
+        # Get combined list for selection
+        #
+        # @return [Array<Hash>] Array of {id, name, description, source} hashes
+        def skill_list
+          template_list + project_skill_list
+        end
+
+        private
+
+        # Load templates from gem directory
+        def load_templates
+          @templates = Loader.load_from_directory(templates_path)
+          Aidp.log_debug(
+            "wizard",
+            "Loaded templates",
+            count: @templates.size,
+            path: templates_path
+          )
+        end
+
+        # Load project skills
+        def load_project_skills
+          @project_skills = if Dir.exist?(project_skills_path)
+            Loader.load_from_directory(project_skills_path)
+          else
+            []
+          end
+
+          Aidp.log_debug(
+            "wizard",
+            "Loaded project skills",
+            count: @project_skills.size,
+            path: project_skills_path
+          )
+        end
+
+        # Check if templates are loaded
+        #
+        # @return [Boolean] True if loaded
+        def loaded?
+          !@templates.nil?
+        end
+
+        # Check if project skills are loaded
+        #
+        # @return [Boolean] True if loaded
+        def project_skills_loaded?
+          !@project_skills.nil?
+        end
+
+        # Get path to templates directory
+        #
+        # @return [String] Path to templates/skills directory
+        def templates_path
+          # Get the gem root directory (go up 4 levels from lib/aidp/skills/wizard/template_library.rb)
+          gem_root = File.expand_path("../../../..", __dir__)
+          File.join(gem_root, "templates", "skills")
+        end
+
+        # Get path to project skills directory
+        #
+        # @return [String] Path to .aidp/skills directory
+        def project_skills_path
+          File.join(project_dir, ".aidp", "skills")
+        end
+      end
+    end
+  end
+end