@dedesfr/prompter 0.7.9 → 0.8.0

package/src/commands/init.ts

@@ -7,10 +7,12 @@ import { projectTemplate, agentsTemplate, claudeTemplate } from '../core/templat
 import { PROMPT_TEMPLATES } from '../core/prompt-templates.js';
 import { registry } from '../core/configurators/slash/index.js';
 import { SlashCommandId } from '../core/templates/index.js';
+import { discoverSkills, SkillMetadata } from '../core/skill-discovery.js';
 
 interface InitOptions {
     tools?: string[];
     prompts?: string[];
+    skills?: string[];
     noInteractive?: boolean;
 }
 
@@ -145,7 +147,7 @@ export class InitCommand {
                 // Detect currently installed prompts (use path.join to get prompter path)
                 const prompterPathForDetection = path.join(projectPath, PROMPTER_DIR);
                 const currentPrompts = await this.detectInstalledPrompts(prompterPathForDetection);
-                
+
                 selectedPrompts = await checkbox({
                     message: 'Select prompt templates to install:',
                     choices: this.getCategorizedPromptChoices(currentPrompts),
@@ -158,6 +160,34 @@ export class InitCommand {
             }
         }
 
+        // Select skills
+        const availableSkills = await discoverSkills(path.join(projectPath, 'skills'));
+        let selectedSkills: SkillMetadata[] = [];
+
+        if (options.skills && options.skills.length > 0) {
+            const requestedNames = options.skills.flatMap(s => s.split(',').map(s => s.trim()));
+            selectedSkills = availableSkills.filter(s => requestedNames.includes(s.name));
+        } else if (!options.noInteractive && availableSkills.length > 0) {
+            try {
+                const prompterPathForDetection = path.join(projectPath, PROMPTER_DIR);
+                const currentSkillNames = await this.detectInstalledSkills(prompterPathForDetection);
+
+                const selectedSkillNames = await checkbox({
+                    message: 'Select skills to install:',
+                    choices: availableSkills.map(skill => ({
+                        name: `  ${skill.name}`,
+                        value: skill.name,
+                        checked: currentSkillNames.includes(skill.name)
+                    }))
+                });
+                selectedSkills = availableSkills.filter(s => selectedSkillNames.includes(s.name));
+            } catch (error) {
+                // User cancelled
+                console.log(chalk.yellow(isReInitialization ? '\nRe-configuration cancelled.' : '\nInitialization cancelled.'));
+                return;
+            }
+        }
+
         // Create or ensure prompter directory
         const prompterPath = await PrompterConfig.ensurePrompterDir(projectPath);
         if (!isReInitialization) {
@@ -349,10 +379,13 @@ export class InitCommand {
             }
         }
 
+        // --- Skills setup ---
+        const skillChanges = await this.setupSkills(projectPath, prompterPath, selectedTools, selectedSkills);
+
         // Success message
         if (isReInitialization) {
             console.log(chalk.green('\n✅ Prompter tools updated successfully!\n'));
-            if (toolsToAdd.length > 0 || toolsToRemove.length > 0 || promptsToAdd.length > 0 || promptsToRemove.length > 0) {
+            if (toolsToAdd.length > 0 || toolsToRemove.length > 0 || promptsToAdd.length > 0 || promptsToRemove.length > 0 || skillChanges.added.length > 0 || skillChanges.removed.length > 0) {
                 console.log(chalk.blue('Summary:'));
                 if (toolsToAdd.length > 0) {
                     console.log(chalk.green('  Tools Added: ') + toolsToAdd.map(t => {
@@ -378,6 +411,12 @@ export class InitCommand {
                         return prompt ? prompt.name : p;
                     }).join(', '));
                 }
+                if (skillChanges.added.length > 0) {
+                    console.log(chalk.green('  Skills Added: ') + skillChanges.added.join(', '));
+                }
+                if (skillChanges.removed.length > 0) {
+                    console.log(chalk.yellow('  Skills Removed: ') + skillChanges.removed.join(', '));
+                }
                 console.log();
             } else {
                 console.log(chalk.gray('  No changes made.\n'));
@@ -387,6 +426,9 @@ export class InitCommand {
             if (promptsToAdd.length > 0) {
                 console.log(chalk.gray(`Installed ${promptsToAdd.length} prompt template(s).\n`));
             }
+            if (skillChanges.added.length > 0) {
+                console.log(chalk.gray(`Installed ${skillChanges.added.length} skill(s).\n`));
+            }
             console.log(chalk.gray('Run `prompter guide` for next steps.\n'));
         }
     }
@@ -604,6 +646,144 @@ Use \`@/prompter/CLAUDE.md\` to learn:
         }
     }
 
+    private async setupSkills(
+        projectPath: string,
+        prompterPath: string,
+        selectedTools: string[],
+        selectedSkills: SkillMetadata[]
+    ): Promise<{ added: string[]; removed: string[] }> {
+        const result = { added: [] as string[], removed: [] as string[] };
+
+        const installedSkillNames = await this.detectInstalledSkills(prompterPath);
+        const selectedSkillNames = selectedSkills.map(s => s.name);
+
+        const skillsToAdd = selectedSkills.filter(s => !installedSkillNames.includes(s.name));
+        const skillsToRemove = installedSkillNames.filter(n => !selectedSkillNames.includes(n));
+        const skillsToKeep = selectedSkills.filter(s => installedSkillNames.includes(s.name));
+
+        const skillsTargetDir = path.join(prompterPath, 'skills');
+
+        // Remove deselected skills
+        if (skillsToRemove.length > 0) {
+            console.log(chalk.blue('\n🗑️  Removing skills...\n'));
+
+            for (const skillName of skillsToRemove) {
+                const staleDir = path.join(skillsTargetDir, skillName);
+                try {
+                    await fs.rm(staleDir, { recursive: true, force: true });
+                    console.log(chalk.yellow('✓') + ` Removed skill ${chalk.cyan(skillName)}`);
+                    result.removed.push(skillName);
+                } catch {
+                    // ignore
+                }
+
+                for (const toolId of selectedTools) {
+                    const configurator = registry.get(toolId);
+                    if (!configurator) continue;
+                    const removed = await configurator.removeSkillFiles(projectPath, [skillName]);
+                    for (const file of removed) {
+                        console.log(chalk.yellow('✓') + ` Removed ${chalk.cyan(file)}`);
+                    }
+                }
+            }
+        }
+
+        // Install new skills
+        if (skillsToAdd.length > 0) {
+            console.log(chalk.blue('\n🧩 Installing skills...\n'));
+            await fs.mkdir(skillsTargetDir, { recursive: true });
+
+            for (const skill of skillsToAdd) {
+                const targetDir = path.join(skillsTargetDir, skill.name);
+                try {
+                    await this.copyDirectory(skill.sourcePath, targetDir);
+                    console.log(chalk.green('✓') + ` Installed skill ${chalk.cyan(skill.name)}`);
+                    result.added.push(skill.name);
+                } catch (error) {
+                    console.log(chalk.red('✗') + ` Failed to install skill ${skill.name}: ${error}`);
+                }
+            }
+
+            if (selectedTools.length > 0) {
+                console.log(chalk.blue('\n📝 Creating skill workflow files...\n'));
+                for (const toolId of selectedTools) {
+                    const configurator = registry.get(toolId);
+                    if (!configurator) continue;
+                    try {
+                        const files = await configurator.generateSkills(projectPath, skillsToAdd);
+                        for (const file of files) {
+                            console.log(chalk.green('✓') + ` Created ${chalk.cyan(file)}`);
+                        }
+                    } catch (error) {
+                        console.log(chalk.red('✗') + ` Failed to create skill files for ${toolId}: ${error}`);
+                    }
+                }
+            }
+        }
+
+        // Update kept skills
+        if (skillsToKeep.length > 0) {
+            await fs.mkdir(skillsTargetDir, { recursive: true });
+
+            for (const skill of skillsToKeep) {
+                const targetDir = path.join(skillsTargetDir, skill.name);
+                try {
+                    await this.copyDirectory(skill.sourcePath, targetDir);
+                } catch {
+                    // ignore update errors
+                }
+            }
+
+            for (const toolId of selectedTools) {
+                const configurator = registry.get(toolId);
+                if (!configurator) continue;
+                try {
+                    await configurator.generateSkills(projectPath, skillsToKeep);
+                } catch {
+                    // ignore
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private async detectInstalledSkills(prompterPath: string): Promise<string[]> {
+        const skillsDir = path.join(prompterPath, 'skills');
+        const names: string[] = [];
+
+        try {
+            const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) continue;
+                const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+                if (await this.fileExists(skillMdPath)) {
+                    names.push(entry.name);
+                }
+            }
+        } catch {
+            // skills directory doesn't exist yet
+        }
+
+        return names;
+    }
+
+    private async copyDirectory(src: string, dest: string): Promise<void> {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+
+            if (entry.isDirectory()) {
+                await this.copyDirectory(srcPath, destPath);
+            } else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+
     private async ensureRootAgentsFile(projectPath: string): Promise<void> {
         const rootAgentsPath = path.join(projectPath, 'AGENTS.md');
         const instructionsBlock = `<!-- PROMPTER:START -->

package/src/commands/update.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import { PrompterConfig, AVAILABLE_PROMPTS, PROMPTER_DIR } from '../core/config.js';
 import { registry } from '../core/configurators/slash/index.js';
 import { PROMPT_TEMPLATES } from '../core/prompt-templates.js';
+import { discoverSkills } from '../core/skill-discovery.js';
 
 export class UpdateCommand {
     async execute(): Promise<void> {
@@ -56,6 +57,27 @@ export class UpdateCommand {
             updatedCount++;
         }
 
+        // Update existing skill workflow files
+        const skillsDir = path.join(projectPath, 'skills');
+        const availableSkills = await discoverSkills(skillsDir);
+
+        if (availableSkills.length > 0) {
+            for (const toolId of configuredTools) {
+                const configurator = registry.get(toolId);
+                if (!configurator) continue;
+
+                try {
+                    const updatedSkillFiles = await configurator.updateExistingSkills(projectPath, availableSkills);
+                    for (const file of updatedSkillFiles) {
+                        console.log(chalk.green('✓') + ` Updated ${chalk.cyan(file)}`);
+                        updatedCount++;
+                    }
+                } catch (error) {
+                    console.log(chalk.red('✗') + ` Failed to update skills for ${configurator.toolId}: ${error}`);
+                }
+            }
+        }
+
         if (updatedCount === 0) {
             console.log(chalk.yellow('⚠️  No workflow files found to update.'));
             console.log(chalk.gray('   Run `prompter init` to create them.\n'));

package/src/core/configurators/slash/antigravity.ts

@@ -63,4 +63,8 @@ export class AntigravityConfigurator extends SlashCommandConfigurator {
         const description = DESCRIPTIONS[id];
         return `---\ndescription: ${description}\n---`;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.agent/skills/${skillName}`;
+    }
 }

package/src/core/configurators/slash/base.ts

@@ -2,6 +2,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { SlashCommandId, TemplateManager } from '../../templates/index.js';
 import { PROMPTER_MARKERS } from '../../config.js';
+import { SkillMetadata } from '../../skill-discovery.js';
 
 export interface SlashCommandTarget {
     id: SlashCommandId;
@@ -9,6 +10,12 @@ export interface SlashCommandTarget {
     kind: 'slash';
 }
 
+export interface SkillTarget {
+    name: string;
+    path: string;
+    kind: 'skill';
+}
+
 const ALL_COMMANDS: SlashCommandId[] = ['enhance', 'prd-generator', 'prd-agent-generator', 'product-brief', 'epic-single', 'epic-generator', 'story-single', 'story-generator', 'qa-test-scenario', 'skill-creator', 'ai-humanizer', 'api-contract-generator', 'apply', 'archive', 'design-system', 'erd-generator', 'fsd-generator', 'proposal', 'tdd-generator', 'tdd-lite-generator', 'wireframe-generator', 'document-explainer'];
 
 export abstract class SlashCommandConfigurator {
@@ -77,10 +84,98 @@ export abstract class SlashCommandConfigurator {
     protected abstract getRelativePath(id: SlashCommandId): string;
     protected abstract getFrontmatter(id: SlashCommandId): string | undefined;
 
+    /**
+     * Returns the relative directory path where the skill's full directory
+     * will be placed inside the tool's config dir.
+     * e.g. `.claude/skills/laravel-code-review`
+     */
+    protected abstract getSkillTargetDir(skillName: string): string;
+
     protected getBody(id: SlashCommandId): string {
         return TemplateManager.getSlashCommandBody(id).trim();
     }
 
+    // --- Skill directory management ---
+
+    getSkillTargets(skills: SkillMetadata[]): SkillTarget[] {
+        return skills.map(skill => ({
+            name: skill.name,
+            path: this.getSkillTargetDir(skill.name),
+            kind: 'skill'
+        }));
+    }
+
+    async generateSkills(projectPath: string, skills: SkillMetadata[]): Promise<string[]> {
+        const created: string[] = [];
+
+        for (const skill of skills) {
+            const targetDir = path.join(projectPath, this.getSkillTargetDir(skill.name));
+            await this.copyDir(skill.sourcePath, targetDir);
+            created.push(this.getSkillTargetDir(skill.name));
+        }
+
+        return created;
+    }
+
+    async updateExistingSkills(projectPath: string, skills: SkillMetadata[]): Promise<string[]> {
+        const updated: string[] = [];
+
+        for (const skill of skills) {
+            const relativeDir = this.getSkillTargetDir(skill.name);
+            const targetDir = path.join(projectPath, relativeDir);
+
+            if (await this.dirExists(targetDir)) {
+                await this.copyDir(skill.sourcePath, targetDir);
+                updated.push(relativeDir);
+            }
+        }
+
+        return updated;
+    }
+
+    async removeSkillFiles(projectPath: string, skillNames: string[]): Promise<string[]> {
+        const removed: string[] = [];
+
+        for (const name of skillNames) {
+            const relativeDir = this.getSkillTargetDir(name);
+            const targetDir = path.join(projectPath, relativeDir);
+
+            if (await this.dirExists(targetDir)) {
+                await fs.rm(targetDir, { recursive: true, force: true });
+                removed.push(relativeDir);
+            }
+        }
+
+        return removed;
+    }
+
+    private async copyDir(src: string, dest: string): Promise<void> {
+        await fs.mkdir(dest, { recursive: true });
+        const entries = await fs.readdir(src, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+
+            if (entry.isDirectory()) {
+                await this.copyDir(srcPath, destPath);
+            } else {
+                await fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
+
+    private async dirExists(dirPath: string): Promise<boolean> {
+        try {
+            const stat = await fs.stat(dirPath);
+            return stat.isDirectory();
+        } catch {
+            return false;
+        }
+    }
+
+    // --- Shared helpers ---
+
     protected async updateBody(filePath: string, body: string): Promise<void> {
         const content = await fs.readFile(filePath, 'utf-8');
         const startIndex = content.indexOf(PROMPTER_MARKERS.start);

package/src/core/configurators/slash/claude.ts

@@ -63,4 +63,8 @@ export class ClaudeConfigurator extends SlashCommandConfigurator {
         // Claude Code uses the filename as the command name
         return undefined;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.claude/skills/${skillName}`;
+    }
 }

package/src/core/configurators/slash/codex.ts

@@ -63,4 +63,8 @@ export class CodexConfigurator extends SlashCommandConfigurator {
         const description = DESCRIPTIONS[id];
         return `---\ndescription: ${description}\n---`;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.codex/skills/${skillName}`;
+    }
 }

package/src/core/configurators/slash/droid.ts

@@ -37,4 +37,8 @@ export class DroidConfigurator extends SlashCommandConfigurator {
     protected getFrontmatter(id: SlashCommandId): string | undefined {
         return undefined;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.factory/skills/${skillName}`;
+    }
 }

package/src/core/configurators/slash/forge.ts

@@ -37,4 +37,8 @@ export class ForgeConfigurator extends SlashCommandConfigurator {
     protected getFrontmatter(id: SlashCommandId): string | undefined {
         return undefined;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.forge/skills/${skillName}`;
+    }
 }

package/src/core/configurators/slash/github-copilot.ts

@@ -99,6 +99,10 @@ export class GithubCopilotConfigurator extends SlashCommandConfigurator {
         return createdOrUpdated;
     }
 
+    protected getSkillTargetDir(skillName: string): string {
+        return `.github/skills/${skillName}`;
+    }
+
     private async checkFileExists(filePath: string): Promise<boolean> {
         try {
             await fs.access(filePath);

package/src/core/configurators/slash/kilocode.ts

@@ -63,4 +63,8 @@ export class KiloCodeConfigurator extends SlashCommandConfigurator {
         const description = DESCRIPTIONS[id];
         return `---\ndescription: ${description}\n---`;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.kilocode/skills/${skillName}`;
+    }
 }

package/src/core/configurators/slash/opencode.ts

@@ -63,4 +63,8 @@ export class OpenCodeConfigurator extends SlashCommandConfigurator {
         const description = DESCRIPTIONS[id];
         return `---\nagent: build\ndescription: ${description}\n---`;
     }
+
+    protected getSkillTargetDir(skillName: string): string {
+        return `.opencode/skills/${skillName}`;
+    }
 }

package/src/core/skill-discovery.ts

@@ -0,0 +1,68 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import yaml from 'yaml';
+
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    sourcePath: string;
+    body: string;
+}
+
+/**
+ * Discover skills in a directory by scanning for subdirectories containing SKILL.md files.
+ * Parses YAML frontmatter (name, description) and extracts the markdown body.
+ */
+export async function discoverSkills(skillsDir: string): Promise<SkillMetadata[]> {
+    const skills: SkillMetadata[] = [];
+
+    let entries: import('fs').Dirent[];
+    try {
+        entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    } catch {
+        return skills;
+    }
+
+    for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const skillDir = path.join(skillsDir, entry.name);
+        const skillMdPath = path.join(skillDir, 'SKILL.md');
+
+        try {
+            const content = await fs.readFile(skillMdPath, 'utf-8');
+            const parsed = parseSkillMd(content);
+
+            if (parsed) {
+                skills.push({
+                    name: parsed.name,
+                    description: parsed.description,
+                    sourcePath: skillDir,
+                    body: parsed.body
+                });
+            }
+        } catch {
+            // SKILL.md not found or unreadable, skip this directory
+        }
+    }
+
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function parseSkillMd(content: string): { name: string; description: string; body: string } | null {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!match) return null;
+
+    try {
+        const meta = yaml.parse(match[1]);
+        if (!meta.name || !meta.description) return null;
+
+        return {
+            name: String(meta.name),
+            description: String(meta.description),
+            body: match[2].trim()
+        };
+    } catch {
+        return null;
+    }
+}

package/.claude/settings.local.json

@@ -1,7 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx tsc:*)"
-    ]
-  }
-}

package/.github/prompts/prd-agent-generator.prompt.md

@@ -1,133 +0,0 @@
----
-description: Generate a PRD with autonomous assumptions (non-interactive mode)
----
-$ARGUMENTS
-<!-- prompter-managed-start -->
-# PRD Generator (Non-Interactive Mode)
-
-Create detailed Product Requirements Documents that are clear, actionable, and suitable for implementation based solely on the user's initial input.
-
----
-
-## The Job
-
-1. Receive a feature description from the user
-2. Analyze the input and make reasonable assumptions where details are missing
-3. Generate a structured PRD based on the input
-
----
-
-## Handling Ambiguity
-
-When the user's input lacks specific details:
-
-- **Make reasonable assumptions** based on common patterns and best practices
-- **Document assumptions** in the PRD under "Assumptions Made"
-- **Flag critical unknowns** in the "Open Questions" section
-- **Err on the side of MVP scope** when scope is unclear
-- **Default to standard patterns** (e.g., CRUD operations, standard UI components)
-
----
-
-## PRD Structure
-
-Generate the PRD with these sections:
-
-### 1. Introduction/Overview
-Brief description of the feature and the problem it solves.
-
-### 2. Assumptions Made
-List key assumptions made due to missing details in the original request:
-- "Assumed target users are [X] based on feature context"
-- "Assumed MVP scope since no specific scope mentioned"
-- "Assumed standard authentication is already in place"
-
-### 3. Goals
-Specific, measurable objectives (bullet list).
-
-### 4. User Stories
-Each story needs:
-- **Title:** Short descriptive name
-- **Description:** "As a [user], I want [feature] so that [benefit]"
-- **Acceptance Criteria:** Verifiable checklist of what "done" means
-
-Each story should be small enough to implement in one focused session.
-
-**Format:**
-```markdown
-### US-001: [Title]
-**Description:** As a [user], I want [feature] so that [benefit].
-
-**Acceptance Criteria:**
-- [ ] Specific verifiable criterion
-- [ ] Another criterion
-- [ ] Typecheck/lint passes
-- [ ] **[UI stories only]** Verify in browser using dev-browser skill
-```
-
-**Important:** 
-- Acceptance criteria must be verifiable, not vague. "Works correctly" is bad. "Button shows confirmation dialog before deleting" is good.
-- **For any story with UI changes:** Always include "Verify in browser using dev-browser skill" as acceptance criteria. This ensures visual verification of frontend work.
-
-### 5. Functional Requirements
-Numbered list of specific functionalities:
-- "FR-1: The system must allow users to..."
-- "FR-2: When a user clicks X, the system must..."
-
-Be explicit and unambiguous.
-
-### 6. Non-Goals (Out of Scope)
-What this feature will NOT include. Critical for managing scope.
-
-### 7. Design Considerations (Optional)
-- UI/UX requirements
-- Link to mockups if available
-- Relevant existing components to reuse
-
-### 8. Technical Considerations (Optional)
-- Known constraints or dependencies
-- Integration points with existing systems
-- Performance requirements
-
-### 9. Success Metrics
-How will success be measured?
-- "Reduce time to complete X by 50%"
-- "Increase conversion rate by 10%"
-
-### 10. Open Questions
-Remaining questions or areas needing clarification. This is where you document:
-- Critical unknowns that affect implementation
-- Areas where the original request was ambiguous
-- Decisions that may need stakeholder input
-
----
-
-## Writing for Junior Developers
-
-The PRD reader may be a junior developer or AI agent. Therefore:
-
-- Be explicit and unambiguous
-- Avoid jargon or explain it
-- Provide enough detail to understand purpose and core logic
-- Number requirements for easy reference
-- Use concrete examples where helpful
-
----
-
-## Output
-
-- **Format:** Markdown (`.md`)
-
----
-
-## WORKFLOW STEPS
-1. Read the user's input about the feature
-2. Generate a unique, URL-friendly slug from the feature name (lowercase, hyphen-separated)
-3. Create the directory `prompter/<slug>/` if it doesn't exist
-4. Generate the complete PRD following all requirements above
-5. Save the PRD to `prompter/<slug>/prd-agent.md`
-6. Report the saved file path
-
-## REFERENCE
-- Read `prompter/project.md` for project context if needed
-<!-- prompter-managed-end -->