@dedesfr/prompter 0.8.23 → 0.9.0

package/src/commands/init.ts

@@ -3,94 +3,59 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 import { checkbox, Separator } from '@inquirer/prompts';
-import { PROMPTER_DIR, SUPPORTED_TOOLS, AVAILABLE_PROMPTS, PrompterConfig } from '../core/config.js';
+import { PROMPTER_DIR, SUPPORTED_TOOLS, PrompterConfig } from '../core/config.js';
 import { projectTemplate, agentsTemplate, claudeTemplate } from '../core/templates/index.js';
-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;
 }
 
 export class InitCommand {
-    private getCategorizedPromptChoices(currentPrompts: string[]): any[] {
+    private truncateDescription(desc: string, max = 72): string {
+        return desc.length > max ? desc.slice(0, max - 1) + '…' : desc;
+    }
+
+    private getCategorizedSkillChoices(availableSkills: SkillMetadata[], currentSkillNames: string[]): any[] {
         const categories = [
             {
-                name: '📋 Product Planning & Strategy',
-                prompts: ['product-brief', 'prd-generator', 'prd-agent-generator']
-            },
-            {
-                name: '📐 Specification & Documentation',
-                prompts: ['fsd-generator', 'tdd-generator', 'tdd-lite-generator', 'erd-generator', 'api-contract-generator']
+                name: '📋 Planning & Strategy',
+                skills: ['project-orchestrator', 'feature-planner', 'prd-generator', 'prd-agent-generator', 'product-brief']
             },
             {
-                name: '🎯 Agile & Project Management',
-                prompts: ['epic-single', 'epic-generator', 'story-single', 'story-generator']
+                name: '🎯 Agile & Backlog',
+                skills: ['epic-single', 'epic-generator', 'story-single', 'story-generator']
             },
             {
-                name: '✅ Testing & Quality Assurance',
-                prompts: ['qa-test-scenario']
+                name: '📐 Specification & Architecture',
+                skills: ['fsd-generator', 'tdd-generator', 'tdd-lite-generator', 'erd-generator', 'api-contract-generator']
             },
             {
                 name: '🎨 Design & UI/UX',
-                prompts: ['design-system', 'wireframe-generator']
-            },
-            {
-                name: '⚙️ Development Workflow',
-                prompts: ['proposal', 'apply', 'archive']
+                skills: ['ui-ux-pro', 'design-system-generator', 'design-system', 'wireframe-generator', 'design-md', 'frontend-design']
             },
             {
-                name: '📝 Content & Documentation',
-                prompts: ['ai-humanizer', 'document-explainer', 'skill-creator']
-            }
-        ];
-
-        const choices: any[] = [];
-
-        for (const category of categories) {
-            choices.push(new Separator(chalk.bold.cyan(category.name)));
-            
-            for (const promptValue of category.prompts) {
-                const prompt = AVAILABLE_PROMPTS.find(p => p.value === promptValue);
-                if (prompt) {
-                    choices.push({
-                        name: `  ${prompt.name} ${chalk.gray('- ' + prompt.description)}`,
-                        value: prompt.value,
-                        checked: currentPrompts.includes(prompt.value)
-                    });
-                }
-            }
-        }
-
-        return choices;
-    }
-
-    private getCategorizedSkillChoices(availableSkills: SkillMetadata[], currentSkillNames: string[]): any[] {
-        const categories = [
-            {
-                name: '📋 Planning & Strategy',
-                skills: ['project-orchestrator', 'feature-planner', 'prompter-workflow', 'prompter-specs']
+                name: '⚙️ Development & Code Review',
+                skills: ['code-review', 'laravel-code-review', 'mcp-builder', 'skill-creator']
             },
             {
-                name: '🎨 Design & UI/UX',
-                skills: ['ui-ux-pro', 'design-system-generator', 'design-md', 'frontend-design']
+                name: '✅ Testing & QA',
+                skills: ['qa-test-scenario']
             },
             {
-                name: '⚙️ Development & Code Review',
-                skills: ['code-review', 'laravel-code-review', 'mcp-builder']
+                name: '⚡ Prompter Workflow',
+                skills: ['prompter-workflow', 'prompter-specs', 'proposal', 'apply', 'archive']
             },
             {
                 name: '📝 Documentation',
-                skills: ['doc-builder', 'document-translator', 'ai-context-generator', 'meeting-notes', 'sph-generator']
+                skills: ['doc-builder', 'document-translator', 'document-explainer', 'ai-context-generator', 'meeting-notes', 'sph-generator']
             },
             {
                 name: '✨ Content & Productivity',
-                skills: ['gamma-builder', 'enhance-prompt']
+                skills: ['enhance', 'enhance-prompt', 'ai-humanizer', 'gamma-builder', 'cerebro']
             }
         ];
 
@@ -108,7 +73,7 @@ export class InitCommand {
             for (const skill of skillsInCategory) {
                 categorized.add(skill.name);
                 choices.push({
-                    name: `  ${skill.name}`,
+                    name: `  ${skill.name} ${chalk.gray('- ' + this.truncateDescription(skill.description))}`,
                     value: skill.name,
                     checked: currentSkillNames.includes(skill.name)
                 });
@@ -121,7 +86,7 @@ export class InitCommand {
             choices.push(new Separator(chalk.bold.cyan('🔧 Other')));
             for (const skill of uncategorized) {
                 choices.push({
-                    name: `  ${skill.name}`,
+                    name: `  ${skill.name} ${chalk.gray('- ' + this.truncateDescription(skill.description))}`,
                     value: skill.name,
                     checked: currentSkillNames.includes(skill.name)
                 });
@@ -198,30 +163,6 @@ export class InitCommand {
             selectedTools = currentTools;
         }
 
-        // Select prompts
-        let selectedPrompts: string[] = [];
-
-        if (options.prompts && options.prompts.length > 0) {
-            // Handle comma-separated values in a single string or array of strings
-            selectedPrompts = options.prompts.flatMap(prompt => prompt.split(',').map(p => p.trim()));
-        } else if (!options.noInteractive) {
-            try {
-                // 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),
-                    pageSize: 20
-                });
-            } catch (error) {
-                // User cancelled
-                console.log(chalk.yellow(isReInitialization ? '\nRe-configuration cancelled.' : '\nInitialization cancelled.'));
-                return;
-            }
-        }
-
         // Select skills — resolve from the package directory, not the user's project
         // dist/commands/init.js → go up two levels to reach the package root
         const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
@@ -317,13 +258,6 @@ export class InitCommand {
         const toolsToRemove = currentTools.filter(t => !selectedTools.includes(t));
         const toolsToKeep = selectedTools.filter(t => currentTools.includes(t));
 
-        // Handle prompt changes
-        const prompterPathForDetection = path.join(projectPath, PROMPTER_DIR);
-        const currentPrompts = await this.detectInstalledPrompts(prompterPathForDetection);
-        const promptsToAdd = selectedPrompts.filter(p => !currentPrompts.includes(p));
-        const promptsToRemove = currentPrompts.filter(p => !selectedPrompts.includes(p));
-        const promptsToKeep = selectedPrompts.filter(p => currentPrompts.includes(p));
-
         // Remove old tool files
         if (toolsToRemove.length > 0) {
             console.log(chalk.blue('\n🗑️  Removing workflow files...\n'));
@@ -342,75 +276,6 @@ export class InitCommand {
             }
         }
 
-        // Remove unchecked prompts
-        if (promptsToRemove.length > 0) {
-            console.log(chalk.blue('\n🗑️  Removing prompt templates...\n'));
-            
-            // Remove from prompter/ folder
-            const removedPrompts = await this.removePrompts(prompterPath, promptsToRemove);
-            for (const promptName of removedPrompts) {
-                console.log(chalk.yellow('✓') + ` Removed ${chalk.cyan(promptName)}`);
-            }
-            
-            // Remove workflow files from all configured tools
-            await this.removeWorkflowFilesForPrompts(projectPath, currentTools, promptsToRemove);
-        }
-
-        // Generate workflow files for new tools
-        if (toolsToAdd.length > 0) {
-            console.log(chalk.blue('\n📝 Creating workflow files...\n'));
-
-            // Convert selected prompt values to SlashCommandIds
-            const slashCommandIds: SlashCommandId[] = selectedPrompts as SlashCommandId[];
-
-            for (const toolId of toolsToAdd) {
-                const configurator = registry.get(toolId);
-                if (configurator) {
-                    try {
-                        // Pass selected prompts to only generate those workflow files
-                        // Pass empty array if no prompts selected to generate nothing
-                        const files = await configurator.generateAll(projectPath, slashCommandIds);
-                        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}`);
-                    }
-                }
-            }
-        }
-
-        // Add missing workflow files for existing tools
-        if (isReInitialization && toolsToKeep.length > 0) {
-            const missingFiles: string[] = [];
-            
-            // Convert selected prompt values to SlashCommandIds
-            const slashCommandIds: SlashCommandId[] = selectedPrompts as SlashCommandId[];
-            
-            for (const toolId of toolsToKeep) {
-                const configurator = registry.get(toolId);
-                if (configurator) {
-                    try {
-                        // Pass selected prompts to only generate those workflow files
-                        // Pass empty array if no prompts selected to generate nothing
-                        const files = await configurator.generateAll(projectPath, slashCommandIds);
-                        for (const file of files) {
-                            missingFiles.push(file);
-                        }
-                    } catch (error) {
-                        // Ignore errors for kept tools
-                    }
-                }
-            }
-            
-            if (missingFiles.length > 0) {
-                console.log(chalk.blue('\n📝 Adding missing workflow files...\n'));
-                for (const file of missingFiles) {
-                    console.log(chalk.green('✓') + ` Created ${chalk.cyan(file)}`);
-                }
-            }
-        }
-
         // Show kept tools
         if (isReInitialization && toolsToKeep.length > 0 && (toolsToAdd.length > 0 || toolsToRemove.length > 0)) {
             console.log(chalk.blue('\n✨ Keeping existing tools:\n'));
@@ -422,31 +287,13 @@ export class InitCommand {
             }
         }
 
-        // Install new prompts
-        if (promptsToAdd.length > 0) {
-            console.log(chalk.blue('\n📋 Installing prompt templates...\n'));
-            const installedPrompts = await this.installPrompts(projectPath, prompterPath, promptsToAdd);
-            for (const promptName of installedPrompts) {
-                console.log(chalk.green('✓') + ` Installed ${chalk.cyan(promptName)}`);
-            }
-        }
-
-        // Update existing prompts in prompter/core/
-        if (isReInitialization && promptsToKeep.length > 0) {
-            console.log(chalk.blue('\n🔄 Updating existing prompt templates...\n'));
-            const updatedPrompts = await this.installPrompts(projectPath, prompterPath, promptsToKeep);
-            for (const promptName of updatedPrompts) {
-                console.log(chalk.green('✓') + ` Updated ${chalk.cyan(promptName)}`);
-            }
-        }
-
         // --- 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 || skillChanges.added.length > 0 || skillChanges.removed.length > 0) {
+            if (toolsToAdd.length > 0 || toolsToRemove.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 => {
@@ -460,18 +307,6 @@ export class InitCommand {
                         return tool ? tool.name : t;
                     }).join(', '));
                 }
-                if (promptsToAdd.length > 0) {
-                    console.log(chalk.green('  Prompts Added: ') + promptsToAdd.map(p => {
-                        const prompt = AVAILABLE_PROMPTS.find(ap => ap.value === p);
-                        return prompt ? prompt.name : p;
-                    }).join(', '));
-                }
-                if (promptsToRemove.length > 0) {
-                    console.log(chalk.yellow('  Prompts Removed: ') + promptsToRemove.map(p => {
-                        const prompt = AVAILABLE_PROMPTS.find(ap => ap.value === p);
-                        return prompt ? prompt.name : p;
-                    }).join(', '));
-                }
                 if (skillChanges.added.length > 0) {
                     console.log(chalk.green('  Skills Added: ') + skillChanges.added.join(', '));
                 }
@@ -484,9 +319,6 @@ export class InitCommand {
             }
         } else {
             console.log(chalk.green('\n✅ Prompter initialized successfully!\n'));
-            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`));
             }
@@ -508,19 +340,12 @@ export class InitCommand {
         const allConfigurators = registry.getAll();
 
         for (const configurator of allConfigurators) {
-            const targets = configurator.getTargets();
-            let hasFiles = false;
-
-            for (const target of targets) {
-                const filePath = path.join(projectPath, target.path);
-                if (await this.fileExists(filePath)) {
-                    hasFiles = true;
-                    break;
-                }
-            }
-
-            if (hasFiles) {
-                configuredTools.push(configurator.toolId);
+            const skillsRoot = path.join(projectPath, configurator.getSkillsRootDir());
+            try {
+                const stat = await fs.stat(skillsRoot);
+                if (stat.isDirectory()) configuredTools.push(configurator.toolId);
+            } catch {
+                // directory doesn't exist — tool not configured
             }
         }
 
@@ -528,138 +353,11 @@ export class InitCommand {
     }
 
     private async removeToolFiles(projectPath: string, configurator: any): Promise<string[]> {
-        const removedFiles: string[] = [];
-        const targets = configurator.getTargets();
-
-        for (const target of targets) {
-            const filePath = path.join(projectPath, target.path);
-            if (await this.fileExists(filePath)) {
-                await fs.unlink(filePath);
-                removedFiles.push(target.path);
-
-                // Remove empty parent directories
-                await this.removeEmptyDirs(path.dirname(filePath), projectPath);
-            }
-        }
-
-        return removedFiles;
+        await configurator.removeAllDeployedSkills(projectPath);
+        return [configurator.getSkillsRootDir() + '/'];
     }
 
-    private async removeEmptyDirs(dirPath: string, projectPath: string): Promise<void> {
-        // Don't remove the project directory itself
-        if (dirPath === projectPath || dirPath === path.dirname(projectPath)) {
-            return;
-        }
 
-        try {
-            const files = await fs.readdir(dirPath);
-            if (files.length === 0) {
-                await fs.rmdir(dirPath);
-                // Recursively check parent
-                await this.removeEmptyDirs(path.dirname(dirPath), projectPath);
-            }
-        } catch {
-            // Directory doesn't exist or can't be removed, ignore
-        }
-    }
-
-    private async detectInstalledPrompts(prompterPath: string): Promise<string[]> {
-        const installedPrompts: string[] = [];
-        const corePath = path.join(prompterPath, 'core');
-        
-        for (const prompt of AVAILABLE_PROMPTS) {
-            const promptFilePath = path.join(corePath, prompt.sourceFile);
-            if (await this.fileExists(promptFilePath)) {
-                installedPrompts.push(prompt.value);
-            }
-        }
-        
-        return installedPrompts;
-    }
-
-    private async installPrompts(projectPath: string, prompterPath: string, selectedPrompts: string[]): Promise<string[]> {
-        const installedPrompts: string[] = [];
-        const corePath = path.join(prompterPath, 'core');
-        
-        // Ensure core directory exists
-        await fs.mkdir(corePath, { recursive: true });
-        
-        for (const promptId of selectedPrompts) {
-            const prompt = AVAILABLE_PROMPTS.find(p => p.value === promptId);
-            if (!prompt) continue;
-            
-            const destPath = path.join(corePath, prompt.sourceFile);
-            
-            try {
-                // Get template content from embedded templates
-                const content = PROMPT_TEMPLATES[promptId];
-                
-                if (!content) {
-                    console.log(chalk.yellow(`  Warning: Template not found for ${prompt.name}`));
-                    continue;
-                }
-                
-                // Write the prompt file from embedded template (overwrites if exists)
-                await fs.writeFile(destPath, content, 'utf-8');
-                installedPrompts.push(prompt.name);
-            } catch (error) {
-                console.log(chalk.red(`  Error installing ${prompt.name}: ${error}`));
-            }
-        }
-        
-        return installedPrompts;
-    }
-
-    private async removePrompts(prompterPath: string, promptsToRemove: string[]): Promise<string[]> {
-        const removedPrompts: string[] = [];
-        const corePath = path.join(prompterPath, 'core');
-        
-        for (const promptId of promptsToRemove) {
-            const prompt = AVAILABLE_PROMPTS.find(p => p.value === promptId);
-            if (!prompt) continue;
-            
-            const filePath = path.join(corePath, prompt.sourceFile);
-            
-            try {
-                if (await this.fileExists(filePath)) {
-                    await fs.unlink(filePath);
-                    removedPrompts.push(prompt.name);
-                }
-            } catch (error) {
-                console.log(chalk.red(`  Error removing ${prompt.name}: ${error}`));
-            }
-        }
-        
-        return removedPrompts;
-    }
-
-    private async removeWorkflowFilesForPrompts(projectPath: string, toolIds: string[], promptIds: string[]): Promise<void> {
-        const slashCommandIds: SlashCommandId[] = promptIds as SlashCommandId[];
-        
-        for (const toolId of toolIds) {
-            const configurator = registry.get(toolId);
-            if (!configurator) continue;
-            
-            // Get targets for the prompts to remove
-            const targets = configurator.getTargets(slashCommandIds);
-            
-            for (const target of targets) {
-                const filePath = path.join(projectPath, target.path);
-                
-                try {
-                    if (await this.fileExists(filePath)) {
-                        await fs.unlink(filePath);
-                        console.log(chalk.yellow('✓') + ` Removed ${chalk.cyan(target.path)}`);
-                        
-                        // Remove empty parent directories
-                        await this.removeEmptyDirs(path.dirname(filePath), projectPath);
-                    }
-                } catch (error) {
-                    // Silently ignore errors for workflow file removal
-                }
-            }
-        }
-    }
 
     private async ensureRootClaudeFile(projectPath: string): Promise<void> {
         const rootClaudePath = path.join(projectPath, 'CLAUDE.md');

package/src/commands/update.ts

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { promises as fs } from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 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';
@@ -32,17 +33,21 @@ export class UpdateCommand {
 
         let updatedCount = 0;
 
-        // Update existing workflow files for configured tools only
+        // Clean up legacy slash command files and update skills for each tool
+        const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+        const availableSkills = await discoverSkills(path.join(packageDir, 'skills'));
+
         for (const toolId of configuredTools) {
             const configurator = registry.get(toolId);
             if (!configurator) continue;
 
             try {
-                // Only update existing files, don't create new ones
-                const updatedFiles = await configurator.updateExisting(projectPath);
-                for (const file of updatedFiles) {
-                    console.log(chalk.green('✓') + ` Updated ${chalk.cyan(file)}`);
-                    updatedCount++;
+                if (availableSkills.length > 0) {
+                    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 ${configurator.toolId}: ${error}`);
@@ -57,27 +62,6 @@ 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'));
@@ -100,19 +84,12 @@ export class UpdateCommand {
         const allConfigurators = registry.getAll();
 
         for (const configurator of allConfigurators) {
-            const targets = configurator.getTargets();
-            let hasFiles = false;
-
-            for (const target of targets) {
-                const filePath = path.join(projectPath, target.path);
-                if (await this.fileExists(filePath)) {
-                    hasFiles = true;
-                    break;
-                }
-            }
-
-            if (hasFiles) {
-                configuredTools.push(configurator.toolId);
+            const skillsRoot = path.join(projectPath, configurator.getSkillsRootDir());
+            try {
+                const stat = await fs.stat(skillsRoot);
+                if (stat.isDirectory()) configuredTools.push(configurator.toolId);
+            } catch {
+                // directory doesn't exist — tool not configured
             }
         }
 
@@ -123,26 +100,22 @@ export class UpdateCommand {
         const updatedPrompts: string[] = [];
         const corePath = path.join(prompterPath, 'core');
 
-        // Check if core directory exists
         if (!await this.fileExists(corePath)) {
             return updatedPrompts;
         }
 
-        // Update each existing prompt file
         for (const prompt of AVAILABLE_PROMPTS) {
             const promptFilePath = path.join(corePath, prompt.sourceFile);
-            
-            // Only update if file exists
+
             if (await this.fileExists(promptFilePath)) {
                 try {
                     const content = PROMPT_TEMPLATES[prompt.value];
-                    
+
                     if (!content) {
                         console.log(chalk.yellow(`  Warning: Template not found for ${prompt.name}`));
                         continue;
                     }
-                    
-                    // Update the prompt file
+
                     await fs.writeFile(promptFilePath, content, 'utf-8');
                     updatedPrompts.push(prompt.sourceFile);
                 } catch (error) {

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

@@ -1,69 +1,9 @@
-import { SlashCommandConfigurator } from './base.js';
-import { SlashCommandId } from '../../templates/index.js';
+import { ToolConfigurator } from './base.js';
 
-const FILE_PATHS: Record<SlashCommandId, string> = {
-    enhance: '.agent/workflows/prompter-enhance.md',
-    'prd-generator': '.agent/workflows/prd-generator.md',
-    'prd-agent-generator': '.agent/workflows/prd-agent-generator.md',
-    'product-brief': '.agent/workflows/product-brief.md',
-    'epic-single': '.agent/workflows/epic-single.md',
-    'epic-generator': '.agent/workflows/epic-generator.md',
-    'story-single': '.agent/workflows/story-single.md',
-    'story-generator': '.agent/workflows/story-generator.md',
-    'qa-test-scenario': '.agent/workflows/qa-test-scenario.md',
-    'skill-creator': '.agent/workflows/skill-creator.md',
-    'ai-humanizer': '.agent/workflows/ai-humanizer.md',
-    'api-contract-generator': '.agent/workflows/api-contract-generator.md',
-    'apply': '.agent/workflows/apply.md',
-    'archive': '.agent/workflows/archive.md',
-    'design-system': '.agent/workflows/design-system.md',
-    'erd-generator': '.agent/workflows/erd-generator.md',
-    'fsd-generator': '.agent/workflows/fsd-generator.md',
-    'proposal': '.agent/workflows/proposal.md',
-    'tdd-generator': '.agent/workflows/tdd-generator.md',
-    'tdd-lite-generator': '.agent/workflows/tdd-lite-generator.md',
-    'wireframe-generator': '.agent/workflows/wireframe-generator.md',
-    'document-explainer': '.agent/workflows/document-explainer.md'
-};
-
-const DESCRIPTIONS: Record<SlashCommandId, string> = {
-    enhance: 'Enhance a rough prompt into a professional specification',
-    'prd-generator': 'Generate a comprehensive Product Requirements Document (PRD)',
-    'prd-agent-generator': 'Generate a PRD with autonomous assumptions (non-interactive mode)',
-    'product-brief': 'Generate an executive-level product brief (1-page summary)',
-    'epic-single': 'Generate a single well-defined Jira Epic',
-    'epic-generator': 'Generate a comprehensive set of EPICs from documentation',
-    'story-single': 'Generate a single Jira User Story from requirements',
-    'story-generator': 'Generate comprehensive user stories from EPICs and FSD',
-    'qa-test-scenario': 'Generate focused QA test scenarios from PRD',
-    'skill-creator': 'Create a modular skill package that extends AI agent capabilities',
-    'ai-humanizer': 'Humanize and proofread AI-generated content for natural, publication-ready output',
-    'api-contract-generator': 'Generate OpenAPI specification from FSD and ERD',
-    'apply': 'Implement and apply an approved change proposal',
-    'archive': 'Archive a completed change and update specs',
-    'design-system': 'Generate comprehensive design system documentation for components and tokens',
-    'erd-generator': 'Generate Entity Relationship Diagram from FSD',
-    'fsd-generator': 'Generate Functional Specification Document from PRD',
-    'proposal': 'Create a new change proposal with spec deltas',
-    'tdd-generator': 'Generate comprehensive Technical Design Document',
-    'tdd-lite-generator': 'Generate lean Technical Design Document (TDD-Lite)',
-    'wireframe-generator': 'Generate UI/UX wireframes from technical specs',
-    'document-explainer': 'Analyze and explain complex documents into clear, actionable insights'
-};
-
-export class AntigravityConfigurator extends SlashCommandConfigurator {
+export class AntigravityConfigurator extends ToolConfigurator {
     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---`;
-    }
-
     protected getSkillTargetDir(skillName: string): string {
         return `.agent/skills/${skillName}`;
     }