aidp 0.16.0 → 0.17.1

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)
+          @prompt = prompt
+        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

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Aidp
+  module Skills
+    module Wizard
+      # Writes skills to the filesystem
+      #
+      # Handles creating directories, writing SKILL.md files, and creating backups.
+      #
+      # @example Writing a new skill
+      #   writer = Writer.new(project_dir: "/path/to/project")
+      #   writer.write(skill, content: "...", dry_run: false)
+      #
+      # @example Dry-run mode
+      #   writer.write(skill, content: "...", dry_run: true)  # Returns path without writing
+      class Writer
+        attr_reader :project_dir
+
+        # Initialize writer
+        #
+        # @param project_dir [String] Root directory of the project
+        def initialize(project_dir:)
+          @project_dir = project_dir
+        end
+
+        # Write a skill to disk
+        #
+        # @param skill [Skill] Skill object
+        # @param content [String] Complete SKILL.md content
+        # @param dry_run [Boolean] If true, don't actually write
+        # @param backup [Boolean] If true, create backup of existing file
+        # @return [String] Path to written file
+        def write(skill, content:, dry_run: false, backup: true)
+          skill_path = path_for_skill(skill.id)
+          skill_dir = File.dirname(skill_path)
+
+          if dry_run
+            Aidp.log_debug("wizard", "Dry-run mode, would write to", path: skill_path)
+            return skill_path
+          end
+
+          # Create backup if file exists and backup is requested
+          create_backup(skill_path) if backup && File.exist?(skill_path)
+
+          # Create directory if it doesn't exist
+          FileUtils.mkdir_p(skill_dir) unless Dir.exist?(skill_dir)
+
+          # Write file
+          File.write(skill_path, content)
+
+          Aidp.log_info(
+            "wizard",
+            "Wrote skill",
+            skill_id: skill.id,
+            path: skill_path,
+            size: content.bytesize
+          )
+
+          skill_path
+        end
+
+        # Get the path where a skill would be written
+        #
+        # @param skill_id [String] Skill identifier
+        # @return [String] Full path to SKILL.md file
+        def path_for_skill(skill_id)
+          File.join(project_dir, ".aidp", "skills", skill_id, "SKILL.md")
+        end
+
+        # Check if a skill already exists
+        #
+        # @param skill_id [String] Skill identifier
+        # @return [Boolean] True if skill file exists
+        def exists?(skill_id)
+          File.exist?(path_for_skill(skill_id))
+        end
+
+        private
+
+        # Create a backup of an existing file
+        #
+        # @param file_path [String] Path to file to backup
+        def create_backup(file_path)
+          backup_path = "#{file_path}.backup"
+          timestamp_backup_path = "#{file_path}.#{Time.now.strftime("%Y%m%d_%H%M%S")}.backup"
+
+          # Create timestamped backup
+          FileUtils.cp(file_path, timestamp_backup_path)
+
+          # Also create/update .backup for convenience
+          FileUtils.cp(file_path, backup_path)
+
+          Aidp.log_debug(
+            "wizard",
+            "Created backup",
+            original: file_path,
+            backup: timestamp_backup_path
+          )
+        end
+      end
+    end
+  end
+end

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.16.0"
+  VERSION = "0.17.1"
 end

data/lib/aidp/watch/plan_generator.rb

@@ -67,7 +67,7 @@ module Aidp
 
       def generate_with_provider(provider, issue)
         payload = build_prompt(issue)
-        response = provider.send(prompt: payload)
+        response = provider.send_message(prompt: payload)
         parsed = parse_structured_response(response)
 
         return parsed if parsed

data/lib/aidp/watch/repository_client.rb

@@ -11,6 +11,16 @@ module Aidp
     # (works for private repositories) and falls back to public REST endpoints
     # when the CLI is unavailable.
     class RepositoryClient
+      # Binary availability checker for testing
+      class BinaryChecker
+        def gh_cli_available?
+          _stdout, _stderr, status = Open3.capture3("gh", "--version")
+          status.success?
+        rescue Errno::ENOENT
+          false
+        end
+      end
+
       attr_reader :owner, :repo
 
       def self.parse_issues_url(issues_url)
@@ -24,10 +34,11 @@ module Aidp
         end
       end
 
-      def initialize(owner:, repo:, gh_available: nil)
+      def initialize(owner:, repo:, gh_available: nil, binary_checker: BinaryChecker.new)
         @owner = owner
         @repo = repo
-        @gh_available = gh_available.nil? ? gh_cli_available? : gh_available
+        @binary_checker = binary_checker
+        @gh_available = gh_available.nil? ? @binary_checker.gh_cli_available? : gh_available
       end
 
       def gh_available?
@@ -56,13 +67,6 @@ module Aidp
 
       private
 
-      def gh_cli_available?
-        _stdout, _stderr, status = Open3.capture3("gh", "--version")
-        status.success?
-      rescue Errno::ENOENT
-        false
-      end
-
       def list_issues_via_gh(labels:, state:)
         json_fields = %w[number title labels updatedAt state url assignees]
         cmd = ["gh", "issue", "list", "--repo", full_repo, "--state", state, "--json", json_fields.join(",")]