clavix 5.2.1 → 5.3.0

package/dist/cli/commands/config.js

@@ -1,447 +0,0 @@
-import { Command, Args } from '@oclif/core';
-import chalk from 'chalk';
-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 integrations',
-        '<%= config.bin %> <%= command.id %> set preferences.verboseLogging true',
-    ];
-    static args = {
-        action: Args.string({
-            description: 'Action to perform (get, set, edit, reset)',
-            options: ['get', 'set', 'edit', 'reset'],
-            required: false,
-        }),
-        key: Args.string({
-            description: 'Configuration key',
-            required: false,
-        }),
-        value: Args.string({
-            description: 'Configuration value (for set action)',
-            required: false,
-        }),
-    };
-    static flags = {};
-    async run() {
-        const { args } = await this.parse(Config);
-        const clavixDir = path.join(process.cwd(), '.clavix');
-        const configPath = path.join(clavixDir, 'config.json');
-        if (!fs.existsSync(clavixDir) || !fs.existsSync(configPath)) {
-            this.error(chalk.red('No .clavix directory found.') +
-                '\n' +
-                chalk.yellow('Run ') +
-                chalk.cyan('clavix init') +
-                chalk.yellow(' to initialize Clavix in this project.'));
-        }
-        // If no action specified, show interactive menu
-        if (!args.action) {
-            await this.showInteractiveMenu(configPath);
-            return;
-        }
-        switch (args.action) {
-            case 'get':
-                await this.getConfig(configPath, args.key);
-                break;
-            case 'set':
-                await this.setConfig(configPath, args.key, args.value);
-                break;
-            case 'edit':
-                await this.editConfig(configPath);
-                break;
-            case 'reset':
-                await this.resetConfig(configPath);
-                break;
-            default:
-                this.error(chalk.red(`Unknown action: ${args.action}`));
-        }
-    }
-    async showInteractiveMenu(configPath) {
-        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 integrations (add/remove)', value: 'integrations' },
-                        { 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 'integrations':
-                    await this.manageIntegrations(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 manageIntegrations(config, configPath) {
-        const agentManager = new AgentManager();
-        while (true) {
-            // Show current integrations
-            this.log(chalk.cyan('\n📦 Current Integrations:'));
-            if (config.integrations.length === 0) {
-                this.log(chalk.gray('  (none configured)'));
-            }
-            else {
-                for (const integrationName of config.integrations) {
-                    const adapter = agentManager.getAdapter(integrationName);
-                    const displayName = adapter?.displayName || integrationName;
-                    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 integration', value: 'add' },
-                        { name: 'Remove integration', value: 'remove' },
-                        { name: 'Replace all integrations', value: 'replace' },
-                        { name: 'Back to main menu', value: 'back' },
-                    ],
-                },
-            ]);
-            if (action === 'back')
-                break;
-            switch (action) {
-                case 'add':
-                    await this.addIntegrations(config, configPath);
-                    break;
-                case 'remove':
-                    await this.removeIntegrations(config, configPath);
-                    break;
-                case 'replace':
-                    await this.replaceIntegrations(config, configPath);
-                    break;
-            }
-            // Reload config after modifications
-            config = this.loadConfig(configPath);
-        }
-    }
-    async addIntegrations(config, configPath) {
-        const agentManager = new AgentManager();
-        const allIntegrations = agentManager.getAdapters();
-        // Show only non-selected providers
-        const availableToAdd = allIntegrations.filter((a) => !config.integrations.includes(a.name));
-        if (availableToAdd.length === 0) {
-            this.log(chalk.yellow('\n✓ All integrations already added!'));
-            return;
-        }
-        // Multi-select checkbox
-        const { newIntegrations } = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'newIntegrations',
-                message: 'Select providers to add:',
-                choices: availableToAdd.map((adapter) => ({
-                    name: `${adapter.displayName} (${adapter.directory})`,
-                    value: adapter.name,
-                })),
-            },
-        ]);
-        if (newIntegrations.length === 0) {
-            this.log(chalk.gray('No integrations selected'));
-            return;
-        }
-        // Add to config
-        config.integrations.push(...newIntegrations);
-        this.saveConfig(configPath, config);
-        this.log(chalk.gray('\n🔧 Generating commands for new integrations...'));
-        // Generate commands for new integrations
-        for (const integrationName of newIntegrations) {
-            const adapter = agentManager.getAdapter(integrationName);
-            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✅ Integrations added successfully!'));
-    }
-    async removeIntegrations(config, configPath) {
-        if (config.integrations.length === 0) {
-            this.log(chalk.yellow('\n⚠ No integrations configured!'));
-            return;
-        }
-        const agentManager = new AgentManager();
-        // Multi-select from current integrations
-        const { integrationsToRemove } = await inquirer.prompt([
-            {
-                type: 'checkbox',
-                name: 'integrationsToRemove',
-                message: 'Select providers to remove:',
-                choices: config.integrations.map((name) => {
-                    const adapter = agentManager.getAdapter(name);
-                    return {
-                        name: `${adapter?.displayName || name} (${adapter?.directory || 'unknown'})`,
-                        value: name,
-                    };
-                }),
-                validate: (answer) => {
-                    if (answer.length === config.integrations.length) {
-                        return 'You must keep at least one integration. Use "Reset to defaults" to reconfigure completely.';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        if (integrationsToRemove.length === 0) {
-            this.log(chalk.gray('No integrations selected'));
-            return;
-        }
-        // Confirm cleanup
-        const { cleanup } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'cleanup',
-                message: 'Remove command files for these integrations?',
-                default: true,
-            },
-        ]);
-        // Remove from config
-        config.integrations = config.integrations.filter((p) => !integrationsToRemove.includes(p));
-        this.saveConfig(configPath, config);
-        // Clean up command files
-        if (cleanup) {
-            this.log(chalk.gray('\n🗑️  Cleaning up command files...'));
-            for (const integrationName of integrationsToRemove) {
-                const adapter = agentManager.getAdapter(integrationName);
-                if (adapter) {
-                    const removed = await adapter.removeAllCommands();
-                    this.log(chalk.gray(`  ✓ Removed ${removed} command(s) from ${adapter.displayName}`));
-                }
-            }
-        }
-        this.log(chalk.green('\n✅ Integrations removed successfully!'));
-    }
-    async replaceIntegrations(config, configPath) {
-        const agentManager = new AgentManager();
-        // Use shared provider selector
-        const { selectIntegrations } = await import('../../utils/integration-selector.js');
-        const newIntegrations = await selectIntegrations(agentManager, config.integrations);
-        if (newIntegrations.length === 0) {
-            this.log(chalk.gray('No integrations selected'));
-            return;
-        }
-        // Find deselected integrations
-        const deselected = config.integrations.filter((p) => !newIntegrations.includes(p));
-        // Handle cleanup if providers were deselected
-        if (deselected.length > 0) {
-            this.log(chalk.yellow('\n⚠ Previously configured but not selected:'));
-            for (const integrationName of deselected) {
-                const adapter = agentManager.getAdapter(integrationName);
-                const displayName = adapter?.displayName || integrationName;
-                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 integrations?',
-                    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 integrations...'));
-                for (const integrationName of deselected) {
-                    const adapter = agentManager.getAdapter(integrationName);
-                    if (adapter) {
-                        const removed = await adapter.removeAllCommands();
-                        this.log(chalk.gray(`  ✓ Removed ${removed} command(s) from ${adapter.displayName}`));
-                    }
-                }
-            }
-        }
-        // Update config
-        config.integrations = newIntegrations;
-        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 integrations...\n'));
-            const Update = (await import('./update.js')).default;
-            await Update.run([]);
-        }
-        this.log(chalk.green('\n✅ Integrations replaced successfully!'));
-    }
-    async getConfig(configPath, key) {
-        const config = this.loadConfig(configPath);
-        if (!key) {
-            this.log(chalk.bold.cyan('⚙️  Current Configuration\n'));
-            this.displayConfig(config);
-            return;
-        }
-        const value = this.getNestedValue(config, key);
-        if (value === undefined) {
-            this.error(chalk.red(`Configuration key "${key}" not found`));
-        }
-        this.log(chalk.cyan(key) + chalk.gray(': ') + JSON.stringify(value, null, 2));
-    }
-    async setConfig(configPath, key, value) {
-        if (!key || value === undefined) {
-            this.error('Usage: clavix config set <key> <value>');
-        }
-        const config = this.loadConfig(configPath);
-        // Parse value as JSON if possible
-        let parsedValue;
-        try {
-            parsedValue = JSON.parse(value);
-        }
-        catch {
-            parsedValue = value;
-        }
-        this.setNestedValue(config, key, parsedValue);
-        this.saveConfig(configPath, config);
-        this.log(chalk.green(`✅ Set ${chalk.cyan(key)} to ${JSON.stringify(parsedValue)}`));
-    }
-    async editConfig(configPath) {
-        const config = this.loadConfig(configPath);
-        await this.editPreferences(configPath, config);
-    }
-    async resetConfig(configPath) {
-        const { confirm } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirm',
-                message: 'Are you sure you want to reset configuration to defaults?',
-                default: false,
-            },
-        ]);
-        if (!confirm) {
-            this.log(chalk.gray('Cancelled'));
-            return;
-        }
-        const config = this.loadConfig(configPath);
-        const defaultConfig = {
-            ...DEFAULT_CONFIG,
-            providers: config.integrations, // Keep existing integrations
-        };
-        this.saveConfig(configPath, defaultConfig);
-        this.log(chalk.green('✅ Configuration reset to defaults (integrations preserved)'));
-    }
-    async editPreferences(configPath, config) {
-        const preferences = config.preferences || DEFAULT_CONFIG.preferences;
-        const answers = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'autoOpenOutputs',
-                message: 'Auto-open generated outputs?',
-                default: preferences.autoOpenOutputs,
-            },
-            {
-                type: 'confirm',
-                name: 'verboseLogging',
-                message: 'Enable verbose logging?',
-                default: preferences.verboseLogging,
-            },
-            {
-                type: 'confirm',
-                name: 'preserveSessions',
-                message: 'Preserve completed sessions?',
-                default: preferences.preserveSessions,
-            },
-        ]);
-        config.preferences = answers;
-        this.saveConfig(configPath, config);
-        this.log(chalk.green('\n✅ Preferences updated'));
-    }
-    loadConfig(configPath) {
-        try {
-            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}`));
-        }
-    }
-    saveConfig(configPath, config) {
-        try {
-            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-        }
-        catch (error) {
-            this.error(chalk.red(`Failed to save configuration: ${error.message}`));
-        }
-    }
-    displayConfig(config) {
-        this.log(`  ${chalk.gray('Version:')} ${config.version}`);
-        this.log(`  ${chalk.gray('Integrations:')} ${config.integrations.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 ? chalk.green('yes') : chalk.gray('no')}`);
-        }
-        if (config.outputs) {
-            this.log(`\n  ${chalk.bold('Outputs:')}`);
-            this.log(`    ${chalk.gray('Path:')} ${config.outputs.path}`);
-            this.log(`    ${chalk.gray('Format:')} ${config.outputs.format}`);
-        }
-        this.log('');
-    }
-    getNestedValue(obj, path) {
-        return path.split('.').reduce((current, key) => {
-            if (current && typeof current === 'object' && key in current) {
-                return current[key];
-            }
-            return undefined;
-        }, obj);
-    }
-    setNestedValue(obj, path, value) {
-        const keys = path.split('.');
-        const lastKey = keys.pop();
-        const target = keys.reduce((current, key) => {
-            if (!current[key])
-                current[key] = {};
-            return current[key];
-        }, obj);
-        target[lastKey] = value;
-    }
-}
-//# sourceMappingURL=config.js.map

package/dist/templates/slash-commands/_components/agent-protocols/decision-rules.md

@@ -1,232 +0,0 @@
-## Agent Decision Rules
-
-These rules define deterministic agent behavior. Follow exactly - no interpretation needed.
-
-### Rule 1: Quality-Based Mode Decision
-
-```
-IF quality < 60%:
-  IF (completeness < 50%) OR (clarity < 50%) OR (actionability < 50%):
-    → ACTION: Strongly recommend comprehensive depth
-    → SAY: "Quality is [X]%. Comprehensive depth strongly recommended for: [low dimensions]"
-  ELSE:
-    → ACTION: Suggest comprehensive depth
-    → SAY: "Quality is [X]%. Consider comprehensive depth for better results."
-
-IF quality >= 60% AND quality < 80%:
-  → ACTION: Proceed with optimization
-  → SHOW: Improvement suggestions
-
-IF quality >= 80%:
-  → ACTION: Prompt is ready
-  → SAY: "Prompt quality is good ([X]%). Ready to execute."
-```
-
-### Rule 2: Intent Confidence Decision
-
-```
-IF confidence >= 85%:
-  → ACTION: Proceed with detected intent
-  → NO secondary intent shown
-
-IF confidence 70-84%:
-  → ACTION: Proceed, note secondary if >25%
-  → SHOW: "Primary: [intent] ([X]%). Also detected: [secondary] ([Y]%)"
-
-IF confidence 50-69%:
-  → ACTION: Ask user to confirm
-  → ASK: "Detected [intent] with [X]% confidence. Is this correct?"
-
-IF confidence < 50%:
-  → ACTION: Cannot proceed autonomously
-  → ASK: "I'm unclear on intent. Is this: [option A] | [option B] | [option C]?"
-```
-
-### Rule 3: Escalation Decision
-
-```
-IF escalation_score >= 75:
-  → ACTION: Strongly recommend comprehensive depth
-  → SHOW: Top 3 contributing factors
-
-IF escalation_score 60-74:
-  → ACTION: Recommend comprehensive depth
-  → SHOW: Primary contributing factor
-
-IF escalation_score 45-59:
-  → ACTION: Suggest comprehensive depth as option
-  → SAY: "Comprehensive depth available for more thorough analysis"
-
-IF escalation_score < 45:
-  → ACTION: Standard depth sufficient
-  → NO escalation mention
-```
-
-### Rule 4: Task Completion (Implementation Mode)
-
-```
-AFTER implementing task:
-  → EDIT tasks.md: Change - [ ] to - [x] for completed task
-  → Use Edit tool to update the checkbox
-
-IF edit succeeds:
-  → SHOW: Next task automatically
-  → CONTINUE with next task
-
-IF edit fails:
-  → SHOW error to user
-  → ASK: "Task completion failed: [error]. How to proceed?"
-```
-
-### Rule 5: Workflow State Check
-
-```
-BEFORE starting /clavix:implement:
-  → CHECK: .clavix-implement-config.json exists?
-
-  IF exists AND stats.remaining > 0:
-    → SAY: "Resuming implementation. Progress: [X]/[Y] tasks."
-    → CONTINUE from currentTask
-
-  IF exists AND stats.remaining == 0:
-    → SAY: "All tasks complete. Consider /clavix:archive"
-
-  IF not exists:
-    → CREATE config file and start implementation
-```
-
-### Rule 6: File Operations
-
-```
-BEFORE writing files:
-  → CHECK: Target directory exists
-  → IF not exists: Create directory first
-
-AFTER writing files:
-  → VERIFY: File was created successfully
-  → IF failed: Report error, suggest manual action
-```
-
-### Rule 7: Pattern Application Decision
-
-```
-WHEN applying patterns:
-  → ALWAYS show which patterns were applied
-  → LIST each pattern with its effect
-
-IF pattern not applicable to intent:
-  → SKIP silently (no output)
-
-IF pattern applicable but skipped:
-  → EXPLAIN: "Skipped [pattern] because [reason]"
-
-COMPREHENSIVE DEPTH ONLY:
-  → MUST include alternatives (2-3)
-  → MUST include validation checklist
-  → MUST include edge cases
-```
-
-### Rule 8: Mode Transition Decision
-
-```
-IF user requests standard depth but quality < 50%:
-  → ACTION: Warn and suggest comprehensive
-  → SAY: "Quality is [X]%. Standard depth may be insufficient."
-  → ALLOW: User can override and proceed
-
-IF user requests comprehensive depth but prompt is simple (quality > 85%):
-  → ACTION: Note efficiency
-  → SAY: "Prompt is already high quality. Standard depth would suffice."
-  → CONTINUE: With comprehensive analysis anyway
-
-IF strategic keywords detected (3+ architecture/security/scalability):
-  → ACTION: Suggest PRD mode
-  → SAY: "Detected strategic scope. Consider /clavix:prd for comprehensive planning."
-```
-
-### Rule 9: Output Validation Decision
-
-```
-BEFORE presenting optimized prompt:
-  → VERIFY: All 6 quality dimensions scored
-  → VERIFY: Intent detected with confidence shown
-  → VERIFY: Patterns applied are listed
-
-IF any verification fails:
-  → HALT: Do not present incomplete output
-  → ACTION: Complete missing analysis first
-
-AFTER optimization complete:
-  → MUST save prompt to .clavix/outputs/prompts/
-  → SHOW: "✓ Prompt saved: [filename]"
-```
-
-### Rule 10: Error Recovery Decision
-
-```
-IF pattern application fails:
-  → LOG: Which pattern failed
-  → CONTINUE: With remaining patterns
-  → REPORT: "Pattern [X] skipped due to error"
-
-IF file write fails:
-  → RETRY: Once with alternative path
-  → IF still fails: Report error with manual steps
-
-IF CLI command fails:
-  → SHOW: Command output and error
-  → SUGGEST: Alternative action
-  → NEVER: Silently ignore failures
-
-IF user prompt is empty/invalid:
-  → ASK: For valid input
-  → NEVER: Proceed with assumption
-```
-
-### Rule 11: Execution Verification (v4.6)
-
-```
-BEFORE completing response:
-  → INCLUDE verification block at end
-  → VERIFY all checkpoints met for current mode
-
-  IF any checkpoint failed:
-    → REPORT which checkpoint failed
-    → EXPLAIN why it failed
-    → SUGGEST recovery action
-
-  IF all checkpoints passed:
-    → SHOW verification block with all items checked
-```
-
-**Verification Block Template:**
-```
-## Clavix Execution Verification
-- [x] Intent detected: {type} ({confidence}%)
-- [x] Quality assessed: {overall}%
-- [x] {N} patterns applied
-- [x] Prompt saved: {filename}
-- [x] Mode: {fast|deep|prd|plan}
-```
-
----
-
-### Rule Summary Table
-
-| Condition | Action | User Communication |
-|-----------|--------|-------------------|
-| quality < 60% + critical dim < 50% | Recommend deep | "[X]%. Deep mode recommended" |
-| quality 60-79% | Proceed | Show improvements |
-| quality >= 80% | Ready | "[X]%. Ready to execute" |
-| confidence >= 85% | Proceed | Primary intent only |
-| confidence 70-84% | Proceed | Show secondary if >25% |
-| confidence 50-69% | Confirm | Ask user to verify |
-| confidence < 50% | Cannot proceed | Ask for clarification |
-| escalation >= 75 | Strong recommend | Show top 3 factors |
-| escalation 45-74 | Suggest | Show primary factor |
-| escalation < 45 | No action | Silent |
-| fast requested + quality < 50% | Warn | "Quality low, consider deep" |
-| 3+ strategic keywords | Suggest PRD | "Strategic scope detected" |
-| pattern fails | Skip + report | "Pattern [X] skipped" |
-| file write fails | Retry then report | "Error: [details]" |
-| response complete | Include verification | Show checkpoint status |