@dedesfr/prompter 0.7.9 → 0.8.1

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 -->