@dedesfr/prompter 0.1.0

package/docs/product-spec.md

@@ -0,0 +1,151 @@
+Product Specification Document
+
+### 1. Executive Summary
+- Product name and tagline: **Prompter CLI** — “Enhance prompts directly in your AI coding workflow.”
+- Core value proposition: Turn rough ideas into **structured, professional prompt specifications** and install tool-specific slash-command workflows in local repos.
+- Primary target users: Developers/teams using AI coding assistants who want standardized prompt enhancement workflows.
+- Key differentiators: **Multi-tool workflow generation**, **local-first** (filesystem-only), and **managed template updates** using embedded markers.
+
+### 2. Product Overview
+- **Problem Statement:** AI prompt quality is inconsistent; teams need a repeatable way to transform rough ideas into high-quality specs and make them available as slash commands in their tools.
+- **Solution:** A CLI that initializes a project with Prompter context, generates slash-command workflow files for supported AI tools, and helps list enhanced prompts.
+- **Success Metrics:**
+  - Successful initialization rate (`prompter init` completes).
+  - Number of workflow files created/updated.
+  - Number of enhanced prompts listed (`prompter list` output count).
+- **Scope:**
+  - **Included:** CLI commands (`init`, `update`, `list`), file templates for workflows, project context file, and detection of enhanced prompts.
+  - **Excluded:** Actual prompt enhancement execution (done by the AI tool), remote services, authentication, telemetry.
+
+### 3. User Personas
+- **Primary: AI-Enabled Developer**
+  - Goals: Quickly bootstrap AI prompt workflows; keep workflows up to date.
+  - Pain points: Inconsistent prompt specs; manual setup across tools.
+- **Secondary: Team Lead/Architect**
+  - Goals: Standardize AI prompt practices across team repos.
+  - Pain points: Tool fragmentation and drift in prompt instructions.
+- **Use Case Scenarios:**
+  - New repo bootstrap → run `prompter init` to scaffold workflows.
+  - Existing repo update → run `prompter update` to refresh managed sections.
+  - Review prompt history → run `prompter list` to see enhanced specs.
+
+### 4. Feature Specifications
+
+**Feature Name:** CLI Initialization
+- **Description:** Creates `prompter/` directory, `prompter/project.md`, optional `AGENTS.md`, and tool-specific workflow files.
+- **User Flow:**
+  1. User runs `prompter init`.
+  2. CLI checks if `prompter/` exists; if so, exits with warning.
+  3. User selects tools (interactive checkbox) or passes `--tools`.
+  4. CLI writes templates and workflow files.
+  5. CLI prints next steps.
+- **Acceptance Criteria:**
+  - `prompter/` directory created with `project.md`.
+  - `AGENTS.md` created only if missing.
+  - Tool workflow files created under tool-specific paths.
+  - Success message printed.
+- **Priority:** Critical
+- **Dependencies:** `src/commands/init.ts`, `src/core/config.ts`, templates in `src/core/templates/*`, configurators in `src/core/configurators/slash/*`.
+
+**Feature Name:** Workflow Update
+- **Description:** Updates managed template sections in existing workflow files for all supported tools.
+- **User Flow:**
+  1. User runs `prompter update`.
+  2. CLI checks for `prompter/`; if missing, exits with error.
+  3. For each tool configurator, updates files containing managed markers.
+  4. Outputs updated count.
+- **Acceptance Criteria:**
+  - If `prompter/` absent, prints error and sets exit code.
+  - If managed markers missing, logs failure for that file.
+  - Updates only managed section between markers.
+- **Priority:** High
+- **Dependencies:** `src/commands/update.ts`, `src/core/configurators/slash/base.ts`, `src/core/config.ts`.
+
+**Feature Name:** Enhanced Prompt Listing
+- **Description:** Lists existing enhanced prompts under `prompter/<slug>/enhanced-prompt.md`.
+- **User Flow:**
+  1. User runs `prompter list` (or `--json`).
+  2. CLI scans `prompter/` for directories containing `enhanced-prompt.md`.
+  3. Outputs list and optional JSON structure.
+- **Acceptance Criteria:**
+  - JSON output when `--json` used.
+  - Empty state messaging when no prompts found.
+  - Sorted list by slug.
+- **Priority:** Medium
+- **Dependencies:** `src/commands/list.ts`, `src/core/config.ts`.
+
+**Feature Name:** Tool-Specific Workflow Generation
+- **Description:** Creates or updates slash-command files for supported AI tools.
+- **User Flow:**
+  1. CLI picks tool configurator based on user selection.
+  2. Writes file with frontmatter (if applicable) and managed markers.
+- **Acceptance Criteria:**
+  - Files created under correct tool paths.
+  - Body contains managed markers from `PROMPTER_MARKERS`.
+- **Priority:** High
+- **Dependencies:** `src/core/configurators/slash/*`, `src/core/templates/slash-command-templates.ts`.
+
+### 5. Technical Architecture
+- **System Overview:** Local CLI that reads/writes repository files and generates prompt templates. No server-side components.
+- **Technology Stack:**
+  - **Language:** TypeScript → compiled to Node.js ES Modules (`src/` → `dist/`).
+  - **Runtime:** Node.js >= 20 (`package.json`).
+  - **Libraries:** `commander`, `@inquirer/prompts`, `chalk`.
+- **Data Models:**
+  - `EnhancedPrompt` (in-memory): `{ id, path, createdAt }` in `src/commands/list.ts`.
+  - `ToolChoice` and `SUPPORTED_TOOLS` in `src/core/config.ts`.
+- **APIs & Integrations:** No network APIs. Integrates with tool-specific file conventions.
+- **Infrastructure:** Local filesystem only. CLI entry is `bin/prompter.js` which loads `dist/cli/index.js`.
+
+**Architecture Diagram (Mermaid):**
+```mermaid
+flowchart TD
+  CLI[prompter CLI] -->|init| FS[(Local Filesystem)]
+  CLI -->|update| FS
+  CLI -->|list| FS
+  FS -->|workflow files| Tools[AI Tools: Claude/Codex/etc.]
+  Templates[Templates] --> CLI
+```
+
+### 6. Non-Functional Requirements
+- **Performance:** Fast file IO; scans only `prompter/` directory.
+- **Security:** No authentication; operates on local filesystem; no data transmission.
+- **Scalability:** Handles many prompt folders; linear scan in `prompter/`.
+- **Reliability:** Uses guarded checks for existing directories; safe updates via marker boundaries.
+- **Compliance:** None specified. ⚠️ ASSUMPTION: Local-only operation minimizes compliance needs.
+
+### 7. User Interface Specifications
+- **Navigation Structure:** CLI commands:
+  - `prompter init`
+  - `prompter update`
+  - `prompter list`
+- **Key Screens/Pages:** Terminal output with colored status messages (`chalk`).
+- **Design Patterns:**
+  - Interactive selection via checkbox prompt.
+  - Managed template sections via markers: `<!-- prompter-managed-start -->` and `<!-- prompter-managed-end -->`.
+- **Responsive Behavior:** N/A (CLI).
+
+### 8. Integration Requirements
+- **Third-Party Services:** None.
+- **APIs Consumed:** None.
+- **APIs Provided:** CLI commands only.
+- **Webhooks/Events:** None.
+
+### 9. Data Specifications
+- **Data Models:**
+  - `prompter/project.md` — project context template.
+  - Workflow files per tool, e.g., `.codex/prompts/prompter-enhance.md`.
+- **Data Flow:** User input → CLI templates → filesystem output → AI tool reads workflow file.
+- **Storage Requirements:** Low; markdown text files only.
+- **Data Privacy:** No PII processing; files are local. ⚠️ ASSUMPTION: Enhanced prompts may include sensitive text, handled by repo policies.
+
+### 10. Current Limitations & Technical Debt
+- No validation of `--tools` inputs; invalid tool IDs are ignored silently (no error path in `src/commands/init.ts`).
+- `prompter update` updates all known tools, even if not used in the project.
+- No tests present (no `test/` files found).
+- Update requires markers; files without them error (`src/core/configurators/slash/base.ts`).
+
+### 11. Assumptions & Inferences
+- ⚠️ ASSUMPTION: Prompter is intended to be used as a **global CLI** (`npm install -g`), inferred from README and `package.json` `bin` mapping.
+- ⚠️ ASSUMPTION: Enhanced prompts are generated by the AI assistant following the workflow, not by this CLI.
+- ⚠️ ASSUMPTION: Users will maintain versioned workflow files in their repos and accept managed updates.

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "@dedesfr/prompter",
+    "version": "0.1.0",
+    "description": "Enhance prompts directly in your AI coding workflow",
+    "type": "module",
+    "main": "dist/index.js",
+    "bin": {
+        "prompter": "./bin/prompter.js"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/Dedesfr/Prompter.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Dedesfr/Prompter/issues"
+    },
+    "homepage": "https://github.com/Dedesfr/Prompter#readme",
+    "scripts": {
+        "build": "node build.js",
+        "dev": "tsc --watch",
+        "dev:cli": "pnpm build && node bin/prompter.js",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "prepublishOnly": "pnpm run build"
+    },
+    "keywords": [
+        "prompt",
+        "ai",
+        "cli",
+        "workflow",
+        "specification",
+        "prompt-engineering",
+        "ai-assistant"
+    ],
+    "author": "Dedesfr",
+    "license": "MIT",
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "dependencies": {
+        "chalk": "^5.3.0",
+        "commander": "^12.1.0",
+        "@inquirer/prompts": "^7.2.3"
+    },
+    "devDependencies": {
+        "@types/node": "^22.10.7",
+        "typescript": "^5.7.3",
+        "vitest": "^2.1.8"
+    }
+}

package/src/cli/index.ts

@@ -0,0 +1,40 @@
+import { Command } from 'commander';
+import { InitCommand } from '../commands/init.js';
+import { UpdateCommand } from '../commands/update.js';
+import { ListCommand } from '../commands/list.js';
+
+const program = new Command();
+
+program
+    .name('prompter')
+    .description('Enhance prompts directly in your AI coding workflow')
+    .version('0.1.0');
+
+program
+    .command('init')
+    .description('Initialize Prompter in your project')
+    .option('--tools <tools...>', 'Specify AI tools to configure (antigravity, claude, codex, github-copilot, opencode, kilocode)')
+    .option('--no-interactive', 'Run without interactive prompts')
+    .action(async (options) => {
+        const initCommand = new InitCommand();
+        await initCommand.execute(options);
+    });
+
+program
+    .command('update')
+    .description('Update Prompter workflow files to latest version')
+    .action(async () => {
+        const updateCommand = new UpdateCommand();
+        await updateCommand.execute();
+    });
+
+program
+    .command('list')
+    .description('List all enhanced prompts')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+        const listCommand = new ListCommand();
+        await listCommand.execute(options);
+    });
+
+program.parse();

package/src/commands/init.ts

@@ -0,0 +1,103 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { checkbox } from '@inquirer/prompts';
+import { PROMPTER_DIR, SUPPORTED_TOOLS, PrompterConfig } from '../core/config.js';
+import { projectTemplate, agentsTemplate } from '../core/templates/index.js';
+import { registry } from '../core/configurators/slash/index.js';
+
+interface InitOptions {
+    tools?: string[];
+    noInteractive?: boolean;
+}
+
+export class InitCommand {
+    async execute(options: InitOptions = {}): Promise<void> {
+        const projectPath = process.cwd();
+
+        console.log(chalk.blue('\n🚀 Initializing Prompter...\n'));
+
+        // Check if already initialized
+        if (await PrompterConfig.prompterDirExists(projectPath)) {
+            console.log(chalk.yellow('⚠️  Prompter is already initialized in this project.'));
+            console.log(chalk.gray('   Use `prompter update` to refresh workflow files.\n'));
+            return;
+        }
+
+        // Select tools
+        let selectedTools: string[] = [];
+
+        if (options.tools && options.tools.length > 0) {
+            selectedTools = options.tools;
+        } else if (!options.noInteractive) {
+            try {
+                selectedTools = await checkbox({
+                    message: 'Select AI tools to configure:',
+                    choices: SUPPORTED_TOOLS.map(tool => ({
+                        name: tool.name,
+                        value: tool.value,
+                        checked: tool.value === 'antigravity' // Default check Antigravity
+                    }))
+                });
+            } catch (error) {
+                // User cancelled
+                console.log(chalk.yellow('\nInitialization cancelled.'));
+                return;
+            }
+        }
+
+        // Create prompter directory
+        const prompterPath = await PrompterConfig.ensurePrompterDir(projectPath);
+        console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/')}`);
+
+        // Create project.md
+        const projectMdPath = path.join(prompterPath, 'project.md');
+        await fs.writeFile(projectMdPath, projectTemplate, 'utf-8');
+        console.log(chalk.green('✓') + ` Created ${chalk.cyan(PROMPTER_DIR + '/project.md')}`);
+
+        // Create AGENTS.md for universal support
+        const agentsMdPath = path.join(projectPath, 'AGENTS.md');
+        const agentsExists = await this.fileExists(agentsMdPath);
+        if (!agentsExists) {
+            await fs.writeFile(agentsMdPath, agentsTemplate, 'utf-8');
+            console.log(chalk.green('✓') + ` Created ${chalk.cyan('AGENTS.md')}`);
+        } else {
+            console.log(chalk.gray('  AGENTS.md already exists, skipping'));
+        }
+
+        // Generate workflow files for selected tools
+        if (selectedTools.length > 0) {
+            console.log(chalk.blue('\n📝 Creating workflow files...\n'));
+
+            for (const toolId of selectedTools) {
+                const configurator = registry.get(toolId);
+                if (configurator) {
+                    try {
+                        const files = await configurator.generateAll(projectPath);
+                        for (const file of files) {
+                            console.log(chalk.green('✓') + ` Created ${chalk.cyan(file)}`);
+                        }
+                    } catch (error) {
+                        console.log(chalk.red('✗') + ` Failed to create files for ${toolId}: ${error}`);
+                    }
+                }
+            }
+        }
+
+        // Success message
+        console.log(chalk.green('\n✅ Prompter initialized successfully!\n'));
+        console.log(chalk.blue('Next steps:'));
+        console.log(chalk.gray('  1. Edit prompter/project.md to describe your project'));
+        console.log(chalk.gray('  2. Use /prompter-enhance to transform prompts'));
+        console.log(chalk.gray('  3. Run `prompter list` to see enhanced prompts\n'));
+    }
+
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}

package/src/commands/list.ts

@@ -0,0 +1,84 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { PROMPTER_DIR, PrompterConfig } from '../core/config.js';
+
+interface ListOptions {
+    json?: boolean;
+}
+
+interface EnhancedPrompt {
+    id: string;
+    path: string;
+    createdAt?: string;
+}
+
+export class ListCommand {
+    async execute(options: ListOptions = {}): Promise<void> {
+        const projectPath = process.cwd();
+
+        // Check if initialized
+        if (!await PrompterConfig.prompterDirExists(projectPath)) {
+            if (options.json) {
+                console.log(JSON.stringify({ error: 'Prompter not initialized', prompts: [] }));
+            } else {
+                console.log(chalk.red('❌ Prompter is not initialized in this project.'));
+                console.log(chalk.gray('   Run `prompter init` first.\n'));
+            }
+            process.exitCode = 1;
+            return;
+        }
+
+        const prompterPath = path.join(projectPath, PROMPTER_DIR);
+        const prompts = await this.scanPrompts(prompterPath);
+
+        if (options.json) {
+            console.log(JSON.stringify(prompts, null, 2));
+            return;
+        }
+
+        if (prompts.length === 0) {
+            console.log(chalk.yellow('\n📭 No enhanced prompts found.\n'));
+            console.log(chalk.gray('Use /prompter-enhance to create one.\n'));
+            return;
+        }
+
+        console.log(chalk.blue(`\n📋 Enhanced Prompts (${prompts.length}):\n`));
+
+        for (const prompt of prompts) {
+            console.log(chalk.green('  •') + ` ${chalk.cyan(prompt.id)}`);
+            console.log(chalk.gray(`    ${prompt.path}`));
+        }
+
+        console.log();
+    }
+
+    private async scanPrompts(prompterPath: string): Promise<EnhancedPrompt[]> {
+        const prompts: EnhancedPrompt[] = [];
+
+        try {
+            const entries = await fs.readdir(prompterPath, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+                const enhancedPromptPath = path.join(prompterPath, entry.name, 'enhanced-prompt.md');
+
+                try {
+                    const stats = await fs.stat(enhancedPromptPath);
+                    prompts.push({
+                        id: entry.name,
+                        path: path.join(PROMPTER_DIR, entry.name, 'enhanced-prompt.md'),
+                        createdAt: stats.birthtime.toISOString()
+                    });
+                } catch {
+                    // No enhanced-prompt.md in this directory, skip
+                }
+            }
+        } catch (error) {
+            // Directory doesn't exist or can't be read
+        }
+
+        return prompts.sort((a, b) => a.id.localeCompare(b.id));
+    }
+}

package/src/commands/update.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import { PrompterConfig } from '../core/config.js';
+import { registry } from '../core/configurators/slash/index.js';
+
+export class UpdateCommand {
+    async execute(): Promise<void> {
+        const projectPath = process.cwd();
+
+        console.log(chalk.blue('\n🔄 Updating Prompter workflow files...\n'));
+
+        // Check if initialized
+        if (!await PrompterConfig.prompterDirExists(projectPath)) {
+            console.log(chalk.red('❌ Prompter is not initialized in this project.'));
+            console.log(chalk.gray('   Run `prompter init` first.\n'));
+            process.exitCode = 1;
+            return;
+        }
+
+        let updatedCount = 0;
+
+        // Update workflow files for all tools
+        for (const configurator of registry.getAvailable()) {
+            try {
+                const files = await configurator.updateExisting(projectPath);
+                for (const file of files) {
+                    console.log(chalk.green('✓') + ` Updated ${chalk.cyan(file)}`);
+                    updatedCount++;
+                }
+            } catch (error) {
+                console.log(chalk.red('✗') + ` Failed to update ${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'));
+        } else {
+            console.log(chalk.green(`\n✅ Updated ${updatedCount} file(s).\n`));
+        }
+    }
+}

package/src/core/config.ts

@@ -0,0 +1,43 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export const PROMPTER_DIR = 'prompter';
+
+export const PROMPTER_MARKERS = {
+    start: '<!-- prompter-managed-start -->',
+    end: '<!-- prompter-managed-end -->'
+};
+
+export interface ToolChoice {
+    name: string;
+    value: string;
+    available: boolean;
+    successLabel: string;
+}
+
+export const SUPPORTED_TOOLS: ToolChoice[] = [
+    { name: 'Antigravity', value: 'antigravity', available: true, successLabel: 'Antigravity' },
+    { name: 'Claude Code', value: 'claude', available: true, successLabel: 'Claude Code' },
+    { name: 'Codex', value: 'codex', available: true, successLabel: 'Codex' },
+    { name: 'GitHub Copilot', value: 'github-copilot', available: true, successLabel: 'GitHub Copilot' },
+    { name: 'OpenCode', value: 'opencode', available: true, successLabel: 'OpenCode' },
+    { name: 'Kilo Code', value: 'kilocode', available: true, successLabel: 'Kilo Code' }
+];
+
+export class PrompterConfig {
+    static async ensurePrompterDir(projectPath: string): Promise<string> {
+        const prompterPath = path.join(projectPath, PROMPTER_DIR);
+        await fs.mkdir(prompterPath, { recursive: true });
+        return prompterPath;
+    }
+
+    static async prompterDirExists(projectPath: string): Promise<boolean> {
+        try {
+            const prompterPath = path.join(projectPath, PROMPTER_DIR);
+            await fs.access(prompterPath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+import { SlashCommandConfigurator } from './base.js';
+import { SlashCommandId } from '../../templates/index.js';
+
+const FILE_PATHS: Record<SlashCommandId, string> = {
+    enhance: '.agent/workflows/prompter-enhance.md'
+};
+
+const DESCRIPTIONS: Record<SlashCommandId, string> = {
+    enhance: 'Enhance a rough prompt into a professional specification'
+};
+
+export class AntigravityConfigurator extends SlashCommandConfigurator {
+    readonly toolId = 'antigravity';
+    readonly isAvailable = true;
+
+    protected getRelativePath(id: SlashCommandId): string {
+        return FILE_PATHS[id];
+    }
+
+    protected getFrontmatter(id: SlashCommandId): string | undefined {
+        const description = DESCRIPTIONS[id];
+        return `---\ndescription: ${description}\n---`;
+    }
+}

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

@@ -0,0 +1,101 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { SlashCommandId, TemplateManager } from '../../templates/index.js';
+import { PROMPTER_MARKERS } from '../../config.js';
+
+export interface SlashCommandTarget {
+    id: SlashCommandId;
+    path: string;
+    kind: 'slash';
+}
+
+const ALL_COMMANDS: SlashCommandId[] = ['enhance'];
+
+export abstract class SlashCommandConfigurator {
+    abstract readonly toolId: string;
+    abstract readonly isAvailable: boolean;
+
+    getTargets(): SlashCommandTarget[] {
+        return ALL_COMMANDS.map((id) => ({
+            id,
+            path: this.getRelativePath(id),
+            kind: 'slash'
+        }));
+    }
+
+    async generateAll(projectPath: string): Promise<string[]> {
+        const createdOrUpdated: string[] = [];
+
+        for (const target of this.getTargets()) {
+            const body = this.getBody(target.id);
+            const filePath = path.join(projectPath, target.path);
+
+            // Ensure directory exists
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+
+            if (await this.fileExists(filePath)) {
+                await this.updateBody(filePath, body);
+            } else {
+                const frontmatter = this.getFrontmatter(target.id);
+                const sections: string[] = [];
+                if (frontmatter) {
+                    sections.push(frontmatter.trim());
+                }
+                sections.push(`${PROMPTER_MARKERS.start}\n${body}\n${PROMPTER_MARKERS.end}`);
+                const content = sections.join('\n') + '\n';
+                await fs.writeFile(filePath, content, 'utf-8');
+            }
+
+            createdOrUpdated.push(target.path);
+        }
+
+        return createdOrUpdated;
+    }
+
+    async updateExisting(projectPath: string): Promise<string[]> {
+        const updated: string[] = [];
+
+        for (const target of this.getTargets()) {
+            const filePath = path.join(projectPath, target.path);
+            if (await this.fileExists(filePath)) {
+                const body = this.getBody(target.id);
+                await this.updateBody(filePath, body);
+                updated.push(target.path);
+            }
+        }
+
+        return updated;
+    }
+
+    protected abstract getRelativePath(id: SlashCommandId): string;
+    protected abstract getFrontmatter(id: SlashCommandId): string | undefined;
+
+    protected getBody(id: SlashCommandId): string {
+        return TemplateManager.getSlashCommandBody(id).trim();
+    }
+
+    protected async updateBody(filePath: string, body: string): Promise<void> {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const startIndex = content.indexOf(PROMPTER_MARKERS.start);
+        const endIndex = content.indexOf(PROMPTER_MARKERS.end);
+
+        if (startIndex === -1 || endIndex === -1 || endIndex <= startIndex) {
+            throw new Error(`Missing Prompter markers in ${filePath}`);
+        }
+
+        const before = content.slice(0, startIndex + PROMPTER_MARKERS.start.length);
+        const after = content.slice(endIndex);
+        const updatedContent = `${before}\n${body}\n${after}`;
+
+        await fs.writeFile(filePath, updatedContent, 'utf-8');
+    }
+
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            await fs.access(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+import { SlashCommandConfigurator } from './base.js';
+import { SlashCommandId } from '../../templates/index.js';
+
+const FILE_PATHS: Record<SlashCommandId, string> = {
+    enhance: '.claude/commands/prompter/enhance.md'
+};
+
+const DESCRIPTIONS: Record<SlashCommandId, string> = {
+    enhance: 'Enhance a rough prompt into a professional specification'
+};
+
+export class ClaudeConfigurator extends SlashCommandConfigurator {
+    readonly toolId = 'claude';
+    readonly isAvailable = true;
+
+    protected getRelativePath(id: SlashCommandId): string {
+        return FILE_PATHS[id];
+    }
+
+    protected getFrontmatter(id: SlashCommandId): string | undefined {
+        // Claude Code uses the filename as the command name
+        return undefined;
+    }
+}