clavix 3.2.2 → 3.3.1

package/dist/cli/commands/config.d.ts

@@ -12,17 +12,19 @@ export default class Config extends Command {
     };
     run(): Promise<void>;
     private showInteractiveMenu;
+    private manageProviders;
+    private addProviders;
+    private removeProviders;
+    private replaceProviders;
     private getConfig;
     private setConfig;
     private editConfig;
     private resetConfig;
-    private changeAgent;
     private editPreferences;
     private loadConfig;
     private saveConfig;
     private displayConfig;
     private getNestedValue;
     private setNestedValue;
-    private getDefaultConfig;
 }
 //# sourceMappingURL=config.d.ts.map

package/dist/cli/commands/config.js

@@ -4,13 +4,14 @@ import fs from 'fs-extra';
 import * as path from 'path';
 import inquirer from 'inquirer';
 import { AgentManager } from '../../core/agent-manager.js';
+import { DEFAULT_CONFIG, isLegacyConfig, migrateConfig } from '../../types/config.js';
+import { loadCommandTemplates } from '../../utils/template-loader.js';
 export default class Config extends Command {
     static description = 'Manage Clavix configuration';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> get agent',
-        '<%= config.bin %> <%= command.id %> set agent cursor',
-        '<%= config.bin %> <%= command.id %> edit',
+        '<%= config.bin %> <%= command.id %> get providers',
+        '<%= config.bin %> <%= command.id %> set preferences.verboseLogging true',
     ];
     static args = {
         action: Args.string({
@@ -71,39 +72,246 @@ export default class Config extends Command {
         }
     }
     async showInteractiveMenu(configPath) {
-        const config = this.loadConfig(configPath);
-        this.log(chalk.bold.cyan('⚙️  Clavix Configuration\n'));
-        this.displayConfig(config);
-        const { action } = await inquirer.prompt([
+        let continueMenu = true;
+        while (continueMenu) {
+            const config = this.loadConfig(configPath);
+            this.log(chalk.bold.cyan('\n⚙️  Clavix Configuration\n'));
+            this.displayConfig(config);
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        { name: 'View current configuration', value: 'view' },
+                        { name: 'Manage providers (add/remove)', value: 'providers' },
+                        { name: 'Edit preferences', value: 'edit-preferences' },
+                        { name: 'Reset to defaults', value: 'reset' },
+                        { name: 'Exit', value: 'exit' },
+                    ],
+                },
+            ]);
+            switch (action) {
+                case 'view':
+                    // Already displayed above
+                    break;
+                case 'providers':
+                    await this.manageProviders(config, configPath);
+                    break;
+                case 'edit-preferences':
+                    await this.editPreferences(configPath, config);
+                    break;
+                case 'reset':
+                    await this.resetConfig(configPath);
+                    break;
+                case 'exit':
+                    continueMenu = false;
+                    break;
+            }
+        }
+    }
+    async manageProviders(config, configPath) {
+        const agentManager = new AgentManager();
+        while (true) {
+            // Show current providers
+            this.log(chalk.cyan('\n📦 Current Providers:'));
+            if (config.providers.length === 0) {
+                this.log(chalk.gray('  (none configured)'));
+            }
+            else {
+                for (const providerName of config.providers) {
+                    const adapter = agentManager.getAdapter(providerName);
+                    const displayName = adapter?.displayName || providerName;
+                    this.log(chalk.gray(`  • ${displayName}`));
+                }
+            }
+            // Submenu
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        { name: 'Add provider', value: 'add' },
+                        { name: 'Remove provider', value: 'remove' },
+                        { name: 'Replace all providers', value: 'replace' },
+                        { name: 'Back to main menu', value: 'back' },
+                    ],
+                },
+            ]);
+            if (action === 'back')
+                break;
+            switch (action) {
+                case 'add':
+                    await this.addProviders(config, configPath);
+                    break;
+                case 'remove':
+                    await this.removeProviders(config, configPath);
+                    break;
+                case 'replace':
+                    await this.replaceProviders(config, configPath);
+                    break;
+            }
+            // Reload config after modifications
+            config = this.loadConfig(configPath);
+        }
+    }
+    async addProviders(config, configPath) {
+        const agentManager = new AgentManager();
+        const allProviders = agentManager.getAdapters();
+        // Show only non-selected providers
+        const availableToAdd = allProviders.filter((a) => !config.providers.includes(a.name));
+        if (availableToAdd.length === 0) {
+            this.log(chalk.yellow('\n✓ All providers already added!'));
+            return;
+        }
+        // Multi-select checkbox
+        const { newProviders } = await inquirer.prompt([
             {
-                type: 'list',
-                name: 'action',
-                message: 'What would you like to do?',
-                choices: [
-                    { name: 'View current configuration', value: 'view' },
-                    { name: 'Change agent', value: 'change-agent' },
-                    { name: 'Edit preferences', value: 'edit-preferences' },
-                    { name: 'Reset to defaults', value: 'reset' },
-                    { name: 'Exit', value: 'exit' },
-                ],
+                type: 'checkbox',
+                name: 'newProviders',
+                message: 'Select providers to add:',
+                choices: availableToAdd.map((adapter) => ({
+                    name: `${adapter.displayName} (${adapter.directory})`,
+                    value: adapter.name,
+                })),
             },
         ]);
-        switch (action) {
-            case 'view':
-                // Already displayed above
-                break;
-            case 'change-agent':
-                await this.changeAgent(configPath, config);
-                break;
-            case 'edit-preferences':
-                await this.editPreferences(configPath, config);
-                break;
-            case 'reset':
-                await this.resetConfig(configPath);
-                break;
-            case 'exit':
-                return;
+        if (newProviders.length === 0) {
+            this.log(chalk.gray('No providers selected'));
+            return;
         }
+        // Add to config
+        config.providers.push(...newProviders);
+        this.saveConfig(configPath, config);
+        this.log(chalk.gray('\n🔧 Generating commands for new providers...'));
+        // Generate commands for new providers
+        for (const providerName of newProviders) {
+            const adapter = agentManager.getAdapter(providerName);
+            if (!adapter)
+                continue;
+            const templates = await loadCommandTemplates(adapter);
+            await adapter.generateCommands(templates);
+            this.log(chalk.green(`  ✓ Generated ${templates.length} command(s) for ${adapter.displayName}`));
+        }
+        this.log(chalk.green('\n✅ Providers added successfully!'));
+    }
+    async removeProviders(config, configPath) {
+        if (config.providers.length === 0) {
+            this.log(chalk.yellow('\n⚠ No providers configured!'));
+            return;
+        }
+        const agentManager = new AgentManager();
+        // Multi-select from current providers
+        const { providersToRemove } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'providersToRemove',
+                message: 'Select providers to remove:',
+                choices: config.providers.map((name) => {
+                    const adapter = agentManager.getAdapter(name);
+                    return {
+                        name: `${adapter?.displayName || name} (${adapter?.directory || 'unknown'})`,
+                        value: name,
+                    };
+                }),
+                validate: (answer) => {
+                    if (answer.length === config.providers.length) {
+                        return 'You must keep at least one provider. Use "Reset to defaults" to reconfigure completely.';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        if (providersToRemove.length === 0) {
+            this.log(chalk.gray('No providers selected'));
+            return;
+        }
+        // Confirm cleanup
+        const { cleanup } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'cleanup',
+                message: 'Remove command files for these providers?',
+                default: true,
+            },
+        ]);
+        // Remove from config
+        config.providers = config.providers.filter((p) => !providersToRemove.includes(p));
+        this.saveConfig(configPath, config);
+        // Clean up command files
+        if (cleanup) {
+            this.log(chalk.gray('\n🗑️  Cleaning up command files...'));
+            for (const providerName of providersToRemove) {
+                const adapter = agentManager.getAdapter(providerName);
+                if (adapter) {
+                    const removed = await adapter.removeAllCommands();
+                    this.log(chalk.gray(`  ✓ Removed ${removed} command(s) from ${adapter.displayName}`));
+                }
+            }
+        }
+        this.log(chalk.green('\n✅ Providers removed successfully!'));
+    }
+    async replaceProviders(config, configPath) {
+        const agentManager = new AgentManager();
+        // Use shared provider selector
+        const { selectProviders } = await import('../../utils/provider-selector.js');
+        const newProviders = await selectProviders(agentManager, config.providers);
+        if (newProviders.length === 0) {
+            this.log(chalk.gray('No providers selected'));
+            return;
+        }
+        // Find deselected providers
+        const deselected = config.providers.filter((p) => !newProviders.includes(p));
+        // Handle cleanup if providers were deselected
+        if (deselected.length > 0) {
+            this.log(chalk.yellow('\n⚠ Previously configured but not selected:'));
+            for (const providerName of deselected) {
+                const adapter = agentManager.getAdapter(providerName);
+                const displayName = adapter?.displayName || providerName;
+                const directory = adapter?.directory || 'unknown';
+                this.log(chalk.gray(`  • ${displayName} (${directory})`));
+            }
+            const { cleanupAction } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'cleanupAction',
+                    message: 'What would you like to do with these providers?',
+                    choices: [
+                        { name: 'Clean up (remove all command files)', value: 'cleanup' },
+                        { name: 'Skip (leave as-is)', value: 'skip' },
+                    ],
+                },
+            ]);
+            if (cleanupAction === 'cleanup') {
+                this.log(chalk.gray('\n🗑️  Cleaning up deselected providers...'));
+                for (const providerName of deselected) {
+                    const adapter = agentManager.getAdapter(providerName);
+                    if (adapter) {
+                        const removed = await adapter.removeAllCommands();
+                        this.log(chalk.gray(`  ✓ Removed ${removed} command(s) from ${adapter.displayName}`));
+                    }
+                }
+            }
+        }
+        // Update config
+        config.providers = newProviders;
+        this.saveConfig(configPath, config);
+        // Prompt to run update
+        const { runUpdate } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'runUpdate',
+                message: 'Run update to regenerate all commands?',
+                default: true,
+            },
+        ]);
+        if (runUpdate) {
+            this.log(chalk.gray('\n🔧 Regenerating commands for all providers...\n'));
+            const Update = (await import('./update.js')).default;
+            await Update.run([]);
+        }
+        this.log(chalk.green('\n✅ Providers replaced successfully!'));
     }
     async getConfig(configPath, key) {
         const config = this.loadConfig(configPath);
@@ -153,57 +361,33 @@ export default class Config extends Command {
             return;
         }
         const config = this.loadConfig(configPath);
-        const defaultConfig = this.getDefaultConfig(config.agent);
+        const defaultConfig = {
+            ...DEFAULT_CONFIG,
+            providers: config.providers, // Keep existing providers
+        };
         this.saveConfig(configPath, defaultConfig);
-        this.log(chalk.green('✅ Configuration reset to defaults'));
-    }
-    async changeAgent(configPath, config) {
-        const agentManager = new AgentManager();
-        const availableAgents = await agentManager.detectAgents();
-        if (availableAgents.length === 0) {
-            this.error('No supported agents detected in this project');
-        }
-        const { newAgent } = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'newAgent',
-                message: 'Select agent:',
-                choices: availableAgents.map(agent => ({
-                    name: agent.displayName,
-                    value: agent.name,
-                })),
-                default: config.agent,
-            },
-        ]);
-        if (newAgent === config.agent) {
-            this.log(chalk.gray('No changes made'));
-            return;
-        }
-        config.agent = newAgent;
-        this.saveConfig(configPath, config);
-        this.log(chalk.green(`✅ Agent changed to ${newAgent}`));
-        this.log(chalk.yellow('\n⚠️  Run ') + chalk.cyan('clavix update') + chalk.yellow(' to update slash commands'));
+        this.log(chalk.green('✅ Configuration reset to defaults (providers preserved)'));
     }
     async editPreferences(configPath, config) {
-        const preferences = config.preferences || {};
+        const preferences = config.preferences || DEFAULT_CONFIG.preferences;
         const answers = await inquirer.prompt([
             {
                 type: 'confirm',
                 name: 'autoOpenOutputs',
                 message: 'Auto-open generated outputs?',
-                default: preferences.autoOpenOutputs || false,
+                default: preferences.autoOpenOutputs,
             },
             {
                 type: 'confirm',
                 name: 'verboseLogging',
                 message: 'Enable verbose logging?',
-                default: preferences.verboseLogging || false,
+                default: preferences.verboseLogging,
             },
             {
                 type: 'confirm',
                 name: 'preserveSessions',
                 message: 'Preserve completed sessions?',
-                default: preferences.preserveSessions !== false, // Default to true
+                default: preferences.preserveSessions,
             },
         ]);
         config.preferences = answers;
@@ -212,7 +396,15 @@ export default class Config extends Command {
     }
     loadConfig(configPath) {
         try {
-            return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            const rawConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            // Check if legacy config and migrate
+            if (isLegacyConfig(rawConfig)) {
+                this.warn(chalk.yellow('Detected legacy config format. Migrating to new format...'));
+                const migratedConfig = migrateConfig(rawConfig);
+                this.saveConfig(configPath, migratedConfig);
+                return migratedConfig;
+            }
+            return rawConfig;
         }
         catch (error) {
             this.error(chalk.red(`Failed to load configuration: ${error.message}`));
@@ -228,17 +420,17 @@ export default class Config extends Command {
     }
     displayConfig(config) {
         this.log(`  ${chalk.gray('Version:')} ${config.version}`);
-        this.log(`  ${chalk.gray('Agent:')} ${chalk.cyan(config.agent)}`);
+        this.log(`  ${chalk.gray('Providers:')} ${config.providers.map(p => chalk.cyan(p)).join(', ') || chalk.gray('(none)')}`);
         if (config.preferences) {
             this.log(`\n  ${chalk.bold('Preferences:')}`);
             this.log(`    ${chalk.gray('Auto-open outputs:')} ${config.preferences.autoOpenOutputs ? chalk.green('yes') : chalk.gray('no')}`);
             this.log(`    ${chalk.gray('Verbose logging:')} ${config.preferences.verboseLogging ? chalk.green('yes') : chalk.gray('no')}`);
-            this.log(`    ${chalk.gray('Preserve sessions:')} ${config.preferences.preserveSessions !== false ? chalk.green('yes') : chalk.gray('no')}`);
+            this.log(`    ${chalk.gray('Preserve sessions:')} ${config.preferences.preserveSessions ? chalk.green('yes') : chalk.gray('no')}`);
         }
         if (config.outputs) {
             this.log(`\n  ${chalk.bold('Outputs:')}`);
-            this.log(`    ${chalk.gray('Path:')} ${config.outputs.path || '.clavix/outputs'}`);
-            this.log(`    ${chalk.gray('Format:')} ${config.outputs.format || 'markdown'}`);
+            this.log(`    ${chalk.gray('Path:')} ${config.outputs.path}`);
+            this.log(`    ${chalk.gray('Format:')} ${config.outputs.format}`);
         }
         this.log('');
     }
@@ -260,26 +452,5 @@ export default class Config extends Command {
         }, obj);
         target[lastKey] = value;
     }
-    getDefaultConfig(agent) {
-        return {
-            version: '1.0.0',
-            agent,
-            templates: {
-                prdQuestions: 'default',
-                fullPrd: 'default',
-                quickPrd: 'default',
-            },
-            outputs: {
-                path: '.clavix/outputs',
-                format: 'markdown',
-            },
-            preferences: {
-                autoOpenOutputs: false,
-                verboseLogging: false,
-                preserveSessions: true,
-            },
-            experimental: {},
-        };
-    }
 }
 //# sourceMappingURL=config.js.map

package/dist/cli/commands/init.js

@@ -38,115 +38,67 @@ export default class Init extends Command {
                     return;
                 }
             }
-            // Select providers (multi-select)
+            // Load existing config if re-initializing
             const agentManager = new AgentManager();
+            let existingProviders = [];
+            if (await FileSystem.exists('.clavix/config.json')) {
+                try {
+                    const configContent = await FileSystem.readFile('.clavix/config.json');
+                    const config = JSON5.parse(configContent);
+                    existingProviders = config.providers || [];
+                }
+                catch (error) {
+                    // Ignore parse errors, will use empty array
+                }
+            }
+            // Select providers using shared utility
             console.log(chalk.gray('Select AI development tools to support:\n'));
             console.log(chalk.gray('(Space to select, Enter to confirm)\n'));
-            const { selectedProviders } = await inquirer.prompt([
-                {
-                    type: 'checkbox',
-                    name: 'selectedProviders',
-                    message: 'Which AI tools are you using?',
-                    choices: [
-                        // CLI Tools
-                        {
-                            name: 'Amp (.agents/commands/)',
-                            value: 'amp',
-                        },
-                        {
-                            name: 'Augment CLI (.augment/commands/clavix/)',
-                            value: 'augment',
-                        },
-                        {
-                            name: 'Codex CLI (~/.codex/prompts)',
-                            value: 'codex',
-                        },
-                        {
-                            name: 'CodeBuddy (.codebuddy/commands/)',
-                            value: 'codebuddy',
-                        },
-                        {
-                            name: 'Crush CLI (.crush/commands/clavix/)',
-                            value: 'crush',
-                        },
-                        {
-                            name: 'Claude Code (.claude/commands/clavix/)',
-                            value: 'claude-code',
-                        },
-                        {
-                            name: 'Droid CLI (.factory/commands/)',
-                            value: 'droid',
-                        },
-                        {
-                            name: 'Gemini CLI (.gemini/commands/clavix/)',
-                            value: 'gemini',
-                        },
-                        {
-                            name: 'LLXPRT (.llxprt/commands/clavix/)',
-                            value: 'llxprt',
-                        },
-                        {
-                            name: 'OpenCode (.opencode/command/)',
-                            value: 'opencode',
-                        },
-                        {
-                            name: 'Qwen Code (.qwen/commands/clavix/)',
-                            value: 'qwen',
-                        },
-                        new inquirer.Separator(),
-                        // IDE & IDE Extensions
-                        {
-                            name: 'Cursor (.cursor/commands/)',
-                            value: 'cursor',
-                        },
-                        {
-                            name: 'Windsurf (.windsurf/workflows/)',
-                            value: 'windsurf',
-                        },
-                        {
-                            name: 'Kilocode (.kilocode/workflows/)',
-                            value: 'kilocode',
-                        },
-                        {
-                            name: 'Roocode (.roo/commands/)',
-                            value: 'roocode',
-                        },
-                        {
-                            name: 'Cline (.clinerules/workflows/)',
-                            value: 'cline',
-                        },
-                        new inquirer.Separator(),
-                        // Universal Adapters
-                        {
-                            name: 'Agents (AGENTS.md - Universal - for tools without slash commands)',
-                            value: 'agents-md',
-                        },
-                        {
-                            name: 'GitHub Copilot (.github/copilot-instructions.md)',
-                            value: 'copilot-instructions',
-                        },
-                        {
-                            name: 'Warp (WARP.md - optimized for Warp)',
-                            value: 'warp-md',
-                        },
-                        {
-                            name: 'Octofriend (OCTO.md - optimized for Octofriend)',
-                            value: 'octo-md',
-                        },
-                        new inquirer.Separator(),
-                    ],
-                    validate: (answer) => {
-                        if (answer.length === 0) {
-                            return 'You must select at least one provider.';
-                        }
-                        return true;
-                    },
-                },
-            ]);
+            const { selectProviders } = await import('../../utils/provider-selector.js');
+            const selectedProviders = await selectProviders(agentManager, existingProviders);
             if (!selectedProviders || selectedProviders.length === 0) {
                 console.log(chalk.red('\n✗ No providers selected\n'));
                 return;
             }
+            // Handle deselected providers (cleanup prompt)
+            const deselectedProviders = existingProviders.filter((p) => !selectedProviders.includes(p));
+            if (deselectedProviders.length > 0) {
+                console.log(chalk.yellow('\n⚠ Previously configured but not selected:'));
+                for (const providerName of deselectedProviders) {
+                    const adapter = agentManager.getAdapter(providerName);
+                    const displayName = adapter?.displayName || providerName;
+                    const directory = adapter?.directory || 'unknown';
+                    console.log(chalk.gray(`  • ${displayName} (${directory})`));
+                }
+                const { cleanupAction } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'cleanupAction',
+                        message: 'What would you like to do with these providers?',
+                        choices: [
+                            { name: 'Clean up (remove all command files)', value: 'cleanup' },
+                            { name: 'Keep (also update their commands)', value: 'update' },
+                            { name: 'Skip (leave as-is)', value: 'skip' },
+                        ],
+                    },
+                ]);
+                if (cleanupAction === 'cleanup') {
+                    console.log(chalk.gray('\n🗑️  Cleaning up deselected providers...'));
+                    for (const providerName of deselectedProviders) {
+                        const adapter = agentManager.getAdapter(providerName);
+                        if (adapter) {
+                            const removed = await adapter.removeAllCommands();
+                            console.log(chalk.gray(`  ✓ Removed ${removed} command(s) from ${adapter.displayName}`));
+                        }
+                    }
+                }
+                else if (cleanupAction === 'update') {
+                    // Add them back to selection
+                    selectedProviders.push(...deselectedProviders);
+                    console.log(chalk.gray('\n✓ Keeping all providers\n'));
+                }
+                // If 'skip': do nothing
+            }
             // Create .clavix directory structure
             console.log(chalk.cyan('\n📁 Creating directory structure...'));
             await this.createDirectoryStructure();
@@ -235,6 +187,11 @@ export default class Init extends Command {
                         }
                     }
                 }
+                // Remove all existing commands before regenerating (ensures clean state)
+                const removed = await adapter.removeAllCommands();
+                if (removed > 0) {
+                    console.log(chalk.gray(`    Removed ${removed} existing command(s)`));
+                }
                 // Generate slash commands
                 const generatedTemplates = await this.generateSlashCommands(adapter);
                 await this.handleLegacyCommands(adapter, generatedTemplates);
@@ -295,7 +252,7 @@ export default class Init extends Command {
             providers,
         };
         const configPath = '.clavix/config.json';
-        const configContent = JSON5.stringify(config, null, 2);
+        const configContent = JSON.stringify(config, null, 2);
         await FileSystem.writeFileAtomic(configPath, configContent);
     }
     async generateInstructions() {
@@ -357,6 +314,8 @@ Welcome to Clavix! This directory contains your local Clavix configuration and d
 
 If using Claude Code, Cursor, or Windsurf, the following slash commands are available:
 
+**Note:** Running \`clavix init\` or \`clavix update\` will regenerate all slash commands from templates. Any manual edits to generated commands will be lost. If you need custom commands, create new command files instead of modifying generated ones.
+
 ### Prompt Improvement
 - \`/clavix:fast [prompt]\` - Quick prompt improvements
 - \`/clavix:deep [prompt]\` - Comprehensive prompt analysis

package/dist/cli/commands/update.js

@@ -146,53 +146,25 @@ export default class Update extends Command {
     }
     async updateCommands(adapter, force) {
         this.log(chalk.cyan(`\n🔧 Updating slash commands for ${adapter.displayName}...`));
-        const commandsDir = adapter.getCommandPath();
-        const commandsPath = path.join(process.cwd(), commandsDir);
-        const extension = adapter.fileExtension;
-        // Dynamically scan template directory for all command templates
-        const templatesDir = path.join(__dirname, '..', '..', 'templates', 'slash-commands', adapter.name);
-        if (!fs.existsSync(templatesDir)) {
-            this.log(chalk.yellow(`  ⚠ Templates directory not found: ${templatesDir}`));
-            return 0;
+        // Remove all existing commands first (force regeneration)
+        const removed = await adapter.removeAllCommands();
+        if (removed > 0) {
+            this.log(chalk.gray(`  Removed ${removed} existing command(s)`));
         }
-        // Get all .md template files
-        const templateFiles = fs.readdirSync(templatesDir)
-            .filter(file => file.endsWith(extension))
-            .map(file => file.slice(0, -extension.length));
-        if (templateFiles.length === 0) {
+        // Load templates using the canonical template loader
+        const { loadCommandTemplates } = await import('../../utils/template-loader.js');
+        const templates = await loadCommandTemplates(adapter);
+        if (templates.length === 0) {
             this.log(chalk.yellow('  ⚠ No command templates found'));
             return 0;
         }
-        // Ensure commands directory exists
-        if (!fs.existsSync(commandsPath)) {
-            fs.mkdirpSync(commandsPath);
-            this.log(chalk.gray(`  ✓ Created commands directory: ${commandsDir}`));
-        }
-        let updated = 0;
-        for (const command of templateFiles) {
-            const filename = adapter.getTargetFilename(command);
-            const commandFile = path.join(commandsPath, filename);
-            const templatePath = path.join(templatesDir, `${command}${extension}`);
-            const newContent = fs.readFileSync(templatePath, 'utf-8');
-            if (fs.existsSync(commandFile)) {
-                const currentContent = fs.readFileSync(commandFile, 'utf-8');
-                if (force || currentContent !== newContent) {
-                    fs.writeFileSync(commandFile, newContent);
-                    this.log(chalk.gray(`  ✓ Updated ${filename}`));
-                    updated++;
-                }
-                else {
-                    this.log(chalk.gray(`  • ${filename} already up to date`));
-                }
-            }
-            else {
-                fs.writeFileSync(commandFile, newContent);
-                this.log(chalk.gray(`  ✓ Created ${filename}`));
-                updated++;
-            }
-        }
-        updated += await this.handleLegacyCommands(adapter, templateFiles, force);
-        return updated;
+        // Generate fresh commands from templates
+        await adapter.generateCommands(templates);
+        this.log(chalk.gray(`  ✓ Generated ${templates.length} command(s)`));
+        // Handle legacy commands (cleanup old naming patterns)
+        const commandNames = templates.map(t => t.name);
+        const legacyRemoved = await this.handleLegacyCommands(adapter, commandNames, force);
+        return removed + templates.length + legacyRemoved;
     }
     async handleLegacyCommands(adapter, commandNames, force) {
         if (commandNames.length === 0) {

package/dist/core/adapters/base-adapter.d.ts

@@ -21,6 +21,19 @@ export declare abstract class BaseAdapter implements AgentAdapter {
      * Checks if directory can be created and is writable
      */
     validate(): Promise<ValidationResult>;
+    /**
+     * Remove all existing Clavix-generated commands for this adapter
+     * Called before regenerating to ensure clean state
+     * @returns Number of files removed
+     */
+    removeAllCommands(): Promise<number>;
+    /**
+     * Determine if a file is a Clavix-generated command
+     * Override in adapters for provider-specific patterns
+     * @param filename The filename to check
+     * @returns true if this is a Clavix-generated command file
+     */
+    protected isClavixGeneratedCommand(filename: string): boolean;
     /**
      * Generate commands - default implementation
      * Creates command files in the provider's directory

package/dist/core/adapters/base-adapter.js

@@ -59,6 +59,43 @@ export class BaseAdapter {
             warnings: warnings.length > 0 ? warnings : undefined,
         };
     }
+    /**
+     * Remove all existing Clavix-generated commands for this adapter
+     * Called before regenerating to ensure clean state
+     * @returns Number of files removed
+     */
+    async removeAllCommands() {
+        const commandPath = this.getCommandPath();
+        // If directory doesn't exist, nothing to remove
+        if (!(await FileSystem.exists(commandPath))) {
+            return 0;
+        }
+        const files = await FileSystem.listFiles(commandPath);
+        const clavixCommands = files.filter((f) => this.isClavixGeneratedCommand(f));
+        let removed = 0;
+        for (const file of clavixCommands) {
+            const filePath = path.join(commandPath, file);
+            try {
+                await FileSystem.remove(filePath);
+                removed++;
+            }
+            catch (error) {
+                // Log warning but continue with other files
+                console.warn(`Failed to remove ${filePath}: ${error}`);
+            }
+        }
+        return removed;
+    }
+    /**
+     * Determine if a file is a Clavix-generated command
+     * Override in adapters for provider-specific patterns
+     * @param filename The filename to check
+     * @returns true if this is a Clavix-generated command file
+     */
+    isClavixGeneratedCommand(filename) {
+        // Default: match files with our extension
+        return filename.endsWith(this.fileExtension);
+    }
     /**
      * Generate commands - default implementation
      * Creates command files in the provider's directory

package/dist/core/adapters/claude-code-adapter.d.ts

@@ -20,6 +20,11 @@ export declare class ClaudeCodeAdapter extends BaseAdapter {
      * Get command path for Claude Code
      */
     getCommandPath(): string;
+    /**
+     * Determine if a file is a Clavix-generated command
+     * For Claude Code: Any .md file in .claude/commands/clavix/ is ours
+     */
+    protected isClavixGeneratedCommand(filename: string): boolean;
     /**
      * Inject documentation blocks into CLAUDE.md
      */

package/dist/core/adapters/claude-code-adapter.js

@@ -27,6 +27,15 @@ export class ClaudeCodeAdapter extends BaseAdapter {
     getCommandPath() {
         return this.directory;
     }
+    /**
+     * Determine if a file is a Clavix-generated command
+     * For Claude Code: Any .md file in .claude/commands/clavix/ is ours
+     */
+    isClavixGeneratedCommand(filename) {
+        // Only remove .md files (our slash commands)
+        // This is safe because we control the entire .claude/commands/clavix/ directory
+        return filename.endsWith('.md');
+    }
     // generateCommands is inherited from BaseAdapter
     /**
      * Inject documentation blocks into CLAUDE.md

package/dist/index 2.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { run, handle, settings } from '@oclif/core';
+// Disable debug mode (stack traces) unless explicitly requested via DEBUG env var
+if (!process.env.DEBUG) {
+    settings.debug = false;
+}
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    run().catch(handle);
+}
+// Export for testing
+export { run };
+//# sourceMappingURL=index.js.map

package/dist/index.d 2.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from '@oclif/core';
+export { run };
+//# sourceMappingURL=index.d.ts.map

package/dist/types/agent.d.ts

@@ -9,6 +9,7 @@ export interface AgentAdapter {
     features?: ProviderFeatures;
     detectProject(): Promise<boolean>;
     generateCommands(templates: CommandTemplate[]): Promise<void>;
+    removeAllCommands(): Promise<number>;
     injectDocumentation(blocks: ManagedBlock[]): Promise<void>;
     getCommandPath(): string;
     getTargetFilename(name: string): string;

package/dist/utils/provider-selector.d.ts

@@ -0,0 +1,8 @@
+import { AgentManager } from '../core/agent-manager.js';
+/**
+ * Interactive provider selection utility
+ * Displays multi-select checkbox for all available providers
+ * Used by both init and config commands
+ */
+export declare function selectProviders(agentManager: AgentManager, preSelected?: string[]): Promise<string[]>;
+//# sourceMappingURL=provider-selector.d.ts.map

package/dist/utils/provider-selector.js

@@ -0,0 +1,60 @@
+import inquirer from 'inquirer';
+/**
+ * Interactive provider selection utility
+ * Displays multi-select checkbox for all available providers
+ * Used by both init and config commands
+ */
+export async function selectProviders(agentManager, preSelected = []) {
+    const { selectedProviders } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedProviders',
+            message: 'Which AI tools are you using?',
+            choices: [
+                new inquirer.Separator('=== CLI Tools ==='),
+                { name: 'Amp (.agents/commands/)', value: 'amp' },
+                { name: 'Augment CLI (.augment/commands/clavix/)', value: 'augment' },
+                { name: 'Codex CLI (~/.codex/prompts)', value: 'codex' },
+                { name: 'Droid (.droid/clavix/)', value: 'droid' },
+                { name: 'Gemini CLI (.gemini/commands/clavix/)', value: 'gemini' },
+                { name: 'Kilocode (.kilo/clavix/)', value: 'kilocode' },
+                { name: 'LLXPRT CLI (.llxprt/clavix/)', value: 'llxprt' },
+                { name: 'OpenCode (.opencode/clavix/)', value: 'opencode' },
+                { name: 'Qwen (通义灵码) (~/.qwen/commands/clavix/)', value: 'qwen' },
+                { name: 'RooCode (.roo/clavix/)', value: 'roocode' },
+                new inquirer.Separator(),
+                new inquirer.Separator('=== IDE & IDE Extensions ==='),
+                { name: 'Claude Code (.claude/commands/clavix/)', value: 'claude-code' },
+                { name: 'Cline (.cline/workflows/)', value: 'cline' },
+                { name: 'CodeBuddy (.codebuddy/prompts/)', value: 'codebuddy' },
+                { name: 'Copilot Instructions (.github/copilot-instructions.md)', value: 'copilot-instructions' },
+                { name: 'Crush (crush://prompts)', value: 'crush' },
+                { name: 'Cursor (.cursor/commands/)', value: 'cursor' },
+                { name: 'Windsurf (.windsurf/rules/)', value: 'windsurf' },
+                new inquirer.Separator(),
+                new inquirer.Separator('=== Universal Adapters ==='),
+                { name: 'Agents (AGENTS.md - Universal)', value: 'agents-md' },
+                { name: 'Octo (OCTO.md - Universal)', value: 'octo-md' },
+                { name: 'Custom (custom/ directory)', value: 'custom' },
+            ].map((choice) => {
+                // Keep separators as-is
+                if (choice instanceof inquirer.Separator) {
+                    return choice;
+                }
+                // Add 'checked' property based on preSelected
+                return {
+                    ...choice,
+                    checked: preSelected.includes(choice.value),
+                };
+            }),
+            validate: (answer) => {
+                if (answer.length === 0) {
+                    return 'You must select at least one provider.';
+                }
+                return true;
+            },
+        },
+    ]);
+    return selectedProviders;
+}
+//# sourceMappingURL=provider-selector.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavix",
-  "version": "3.2.2",
+  "version": "3.3.1",
   "description": "Clavix Intelligence™ for AI coding. Automatically optimizes prompts with intent detection, quality assessment, and adaptive patterns—no framework to learn. Works with Claude Code, Cursor, Windsurf, and 19+ other AI coding tools.",
   "type": "module",
   "main": "dist/index.js",