dartmind 17.0.0

package/dist/cli/commands/SlashCommands.js

@@ -0,0 +1,959 @@
+// packages/core/src/cli/commands/SlashCommands.ts
+// Complete slash command registry for Claude Code parity - FlutterAI V12.2
+// Total: 27 commands (16 new + 11 from V12.1)
+import chalk from 'chalk';
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${(ms / 60000).toFixed(1)}m`;
+}
+function formatCost(cost) {
+    return `$${cost.toFixed(4)}`;
+}
+function formatTokens(tokens) {
+    if (tokens < 1000)
+        return tokens.toString();
+    return `${(tokens / 1000).toFixed(1)}K`;
+}
+// =============================================================================
+// SESSION COMMANDS
+// =============================================================================
+export const helpCommand = {
+    name: 'help',
+    aliases: ['h', '?'],
+    description: 'Show available commands',
+    usage: '/help [command]',
+    category: 'info',
+    execute: async (args, context) => {
+        if (args.length > 0) {
+            const cmdName = args[0].toLowerCase();
+            const cmd = resolveCommand(cmdName);
+            if (cmd) {
+                const message = `
+${chalk.bold(cmd.name)}
+${chalk.gray(cmd.description)}
+
+${chalk.cyan('Usage:')} ${cmd.usage}
+${chalk.cyan('Aliases:')} ${cmd.aliases.length > 0 ? cmd.aliases.join(', ') : 'none'}
+${chalk.cyan('Category:')} ${cmd.category}
+`;
+                return { success: true, message, shouldContinue: true };
+            }
+            return { success: false, message: `Unknown command: ${cmdName}`, shouldContinue: true };
+        }
+        const categories = {};
+        for (const cmd of Object.values(COMMAND_REGISTRY)) {
+            if (!categories[cmd.category])
+                categories[cmd.category] = [];
+            categories[cmd.category].push(cmd);
+        }
+        let message = `\n${chalk.bold('FlutterAI Commands')}\n\n`;
+        const categoryLabels = {
+            session: '📁 Session',
+            mode: '🔐 Mode',
+            tools: '🔧 Tools',
+            info: 'ℹ️  Info',
+            flutter: '🦋 Flutter',
+            config: '⚙️  Config',
+        };
+        for (const [cat, cmds] of Object.entries(categories)) {
+            message += `${chalk.bold(categoryLabels[cat] || cat)}\n`;
+            for (const cmd of cmds) {
+                const aliasStr = cmd.aliases.length > 0 ? chalk.gray(` (${cmd.aliases.join(', ')})`) : '';
+                message += `  ${chalk.cyan(cmd.name.padEnd(12))}${aliasStr} ${cmd.description}\n`;
+            }
+            message += '\n';
+        }
+        message += chalk.gray('Type /help <command> for detailed usage.\n');
+        return { success: true, message, shouldContinue: true };
+    },
+};
+export const exitCommand = {
+    name: 'exit',
+    aliases: ['quit', 'q'],
+    description: 'Exit the chat',
+    usage: '/exit',
+    category: 'session',
+    execute: async () => ({
+        success: true,
+        message: chalk.yellow('Goodbye! Session saved.'),
+        shouldContinue: false,
+    }),
+};
+export const clearCommand = {
+    name: 'clear',
+    aliases: ['cls'],
+    description: 'Clear conversation history',
+    usage: '/clear',
+    category: 'session',
+    execute: async (args, context) => {
+        context.sessionManager?.clearMessages();
+        return {
+            success: true,
+            message: chalk.green('Conversation cleared.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const resetCommand = {
+    name: 'reset',
+    aliases: [],
+    description: 'Reset session (clear history + checkpoints)',
+    usage: '/reset',
+    category: 'session',
+    execute: async (args, context) => {
+        context.sessionManager?.clearMessages();
+        // Also clear checkpoints
+        const session = context.sessionManager?.getCurrentSession();
+        if (session) {
+            session.checkpoints = [];
+        }
+        return {
+            success: true,
+            message: chalk.green('Session reset. History and checkpoints cleared.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const resumeCommand = {
+    name: 'resume',
+    aliases: [],
+    description: 'Resume a previous session',
+    usage: '/resume [session-id or index]',
+    category: 'session',
+    execute: async (args, context) => {
+        if (args.length === 0) {
+            const sessions = await context.sessionManager?.listRecent(10);
+            if (!sessions || sessions.length === 0) {
+                return { success: true, message: 'No previous sessions found.', shouldContinue: true };
+            }
+            const list = sessions
+                .map((s, i) => {
+                const name = s.name || s.id.substring(0, 8);
+                const date = new Date(s.updatedAt).toLocaleString();
+                const msgs = s.messageCount;
+                const cost = formatCost(s.totalCost);
+                return `  ${chalk.cyan((i + 1).toString().padStart(2))}. ${name.padEnd(20)} ${chalk.gray(date)} ${msgs} msgs ${cost}`;
+            })
+                .join('\n');
+            return {
+                success: true,
+                message: `\n${chalk.bold('Recent Sessions:')}\n\n${list}\n\nUse ${chalk.cyan('/resume <number>')} to resume.`,
+                shouldContinue: true,
+            };
+        }
+        const session = await context.sessionManager?.load(args[0]);
+        if (!session) {
+            return { success: false, message: chalk.red(`Session not found: ${args[0]}`), shouldContinue: true };
+        }
+        return {
+            success: true,
+            message: chalk.green(`Resumed session: ${session.name || session.id.substring(0, 8)} (${session.messages.length} messages)`),
+            shouldContinue: true,
+            data: { session },
+        };
+    },
+};
+export const renameCommand = {
+    name: 'rename',
+    aliases: [],
+    description: 'Rename current session',
+    usage: '/rename <new-name>',
+    category: 'session',
+    execute: async (args, context) => {
+        if (args.length === 0) {
+            return { success: false, message: 'Usage: /rename <new-name>', shouldContinue: true };
+        }
+        const newName = args.join(' ');
+        const sessionId = context.sessionManager?.getSessionId();
+        if (!sessionId) {
+            return { success: false, message: 'No active session.', shouldContinue: true };
+        }
+        await context.sessionManager?.rename(sessionId, newName);
+        return {
+            success: true,
+            message: chalk.green(`Session renamed to: ${newName}`),
+            shouldContinue: true,
+        };
+    },
+};
+export const rewindCommand = {
+    name: 'rewind',
+    aliases: ['undo'],
+    description: 'Rewind to a previous checkpoint',
+    usage: '/rewind [steps]',
+    category: 'session',
+    execute: async (args, context) => {
+        const steps = parseInt(args[0]) || 1;
+        const result = await context.sessionManager?.rewindSteps(steps);
+        if (!result?.success) {
+            return { success: false, message: chalk.red(result?.error || 'Rewind failed'), shouldContinue: true };
+        }
+        return {
+            success: true,
+            message: chalk.green(`Rewound ${steps} step(s). ${result.filesReverted} file(s) reverted.`),
+            shouldContinue: true,
+        };
+    },
+};
+export const exportCommand = {
+    name: 'export',
+    aliases: [],
+    description: 'Export conversation',
+    usage: '/export [markdown|json] [filename]',
+    category: 'session',
+    execute: async (args, context) => {
+        const format = (args[0] || 'markdown');
+        const sessionId = context.sessionManager?.getSessionId();
+        if (!sessionId) {
+            return { success: false, message: 'No active session.', shouldContinue: true };
+        }
+        const filename = args[1] || `flutterai-${sessionId.substring(0, 8)}-${Date.now()}.${format === 'json' ? 'json' : 'md'}`;
+        const content = await context.sessionManager?.export(sessionId, format);
+        const fs = await import('fs/promises');
+        await fs.writeFile(filename, content);
+        return {
+            success: true,
+            message: chalk.green(`Exported to: ${filename}`),
+            shouldContinue: true,
+        };
+    },
+};
+// =============================================================================
+// MODE COMMANDS
+// =============================================================================
+export const planCommand = {
+    name: 'plan',
+    aliases: [],
+    description: 'Enter plan mode (read-only analysis)',
+    usage: '/plan',
+    category: 'mode',
+    execute: async (args, context) => {
+        context.planMode?.setMode('plan');
+        return {
+            success: true,
+            message: chalk.yellow('📋 Plan mode enabled. Read-only analysis - no changes will be made.\nUse /execute to return to normal mode.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const executeCommand = {
+    name: 'execute',
+    aliases: ['exec'],
+    description: 'Exit plan mode, enable execution',
+    usage: '/execute',
+    category: 'mode',
+    execute: async (args, context) => {
+        context.planMode?.setMode('default');
+        return {
+            success: true,
+            message: chalk.green('🚀 Execution mode enabled. Changes will be applied.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const acceptCommand = {
+    name: 'accept',
+    aliases: ['auto'],
+    description: 'Auto-accept file edits',
+    usage: '/accept',
+    category: 'mode',
+    execute: async (args, context) => {
+        context.planMode?.setMode('accept');
+        return {
+            success: true,
+            message: chalk.yellow('⚡ Auto-accept mode. File edits will be applied without confirmation.\nBash commands still require approval.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const defaultCommand = {
+    name: 'default',
+    aliases: [],
+    description: 'Return to default permission mode',
+    usage: '/default',
+    category: 'mode',
+    execute: async (args, context) => {
+        context.planMode?.setMode('default');
+        return {
+            success: true,
+            message: chalk.green('🔐 Default mode. Write operations require confirmation.'),
+            shouldContinue: true,
+        };
+    },
+};
+// =============================================================================
+// TOOLS COMMANDS
+// =============================================================================
+export const toolsCommand = {
+    name: 'tools',
+    aliases: [],
+    description: 'List available tools',
+    usage: '/tools [category]',
+    category: 'tools',
+    execute: async (args, context) => {
+        const allTools = context.engine?.getAvailableTools() || [];
+        const category = args[0]?.toLowerCase();
+        let filtered = allTools;
+        if (category) {
+            filtered = allTools.filter((t) => t.name.toLowerCase().includes(category) ||
+                t.description?.toLowerCase().includes(category));
+        }
+        if (filtered.length === 0) {
+            return { success: true, message: `No tools found${category ? ` matching "${category}"` : ''}.`, shouldContinue: true };
+        }
+        const nativeTools = filtered.filter((t) => !t.name.startsWith('mcp__'));
+        const mcpTools = filtered.filter((t) => t.name.startsWith('mcp__'));
+        let message = `\n${chalk.bold('Available Tools')} (${filtered.length})\n\n`;
+        if (nativeTools.length > 0) {
+            message += `${chalk.cyan('Native Tools:')}\n`;
+            for (const tool of nativeTools) {
+                message += `  ${chalk.green(tool.name.padEnd(20))} ${(tool.description || '').substring(0, 50)}...\n`;
+            }
+            message += '\n';
+        }
+        if (mcpTools.length > 0) {
+            message += `${chalk.cyan('MCP Tools:')}\n`;
+            for (const tool of mcpTools.slice(0, 20)) {
+                const name = tool.name.replace('mcp__flutter__', '');
+                message += `  ${chalk.blue(name.padEnd(20))} ${(tool.description || '').substring(0, 50)}...\n`;
+            }
+            if (mcpTools.length > 20) {
+                message += chalk.gray(`  ... and ${mcpTools.length - 20} more\n`);
+            }
+        }
+        return { success: true, message, shouldContinue: true };
+    },
+};
+export const compactCommand = {
+    name: 'compact',
+    aliases: [],
+    description: 'Compact conversation to reduce tokens',
+    usage: '/compact',
+    category: 'tools',
+    execute: async (args, context) => {
+        const before = context.engine?.getContextTokens?.() || 0;
+        await context.engine?.compactContext?.();
+        const after = context.engine?.getContextTokens?.() || 0;
+        const saved = before - after;
+        const percent = before > 0 ? ((saved / before) * 100).toFixed(1) : 0;
+        return {
+            success: true,
+            message: chalk.green(`Context compacted. Saved ${formatTokens(saved)} tokens (${percent}%)`),
+            shouldContinue: true,
+        };
+    },
+};
+export const contextCommand = {
+    name: 'context',
+    aliases: ['ctx'],
+    description: 'Visualize current context usage',
+    usage: '/context',
+    category: 'tools',
+    execute: async (args, context) => {
+        const tokens = context.engine?.getContextTokens?.() || 0;
+        const maxTokens = 128000;
+        const percent = (tokens / maxTokens) * 100;
+        const barLength = 30;
+        const filledLength = Math.round((percent / 100) * barLength);
+        const bar = chalk.green('█'.repeat(filledLength)) + chalk.gray('░'.repeat(barLength - filledLength));
+        const color = percent > 75 ? chalk.red : percent > 50 ? chalk.yellow : chalk.green;
+        const message = `
+${chalk.bold('Context Usage')}
+
+${bar} ${color(percent.toFixed(1) + '%')}
+
+Tokens: ${formatTokens(tokens)} / ${formatTokens(maxTokens)}
+Messages: ${context.sessionManager?.getMessages()?.length || 0}
+Checkpoints: ${context.sessionManager?.listCheckpoints()?.length || 0}
+
+${percent > 75 ? chalk.yellow('⚠️  Consider using /compact to reduce context size.') : ''}
+`;
+        return { success: true, message, shouldContinue: true };
+    },
+};
+export const tasksCommand = {
+    name: 'tasks',
+    aliases: [],
+    description: 'Manage background tasks',
+    usage: '/tasks [list|cancel <id>]',
+    category: 'tools',
+    execute: async (args, context) => {
+        const operation = args[0] || 'list';
+        if (operation === 'list') {
+            const tasks = context.engine?.getBackgroundTasks?.() || [];
+            if (tasks.length === 0) {
+                return { success: true, message: 'No background tasks running.', shouldContinue: true };
+            }
+            const list = tasks
+                .map((t) => `  ${chalk.cyan(t.id.substring(0, 8))} ${t.description} [${t.status}]`)
+                .join('\n');
+            return { success: true, message: `\n${chalk.bold('Background Tasks:')}\n\n${list}`, shouldContinue: true };
+        }
+        if (operation === 'cancel') {
+            const taskId = args[1];
+            if (!taskId) {
+                return { success: false, message: 'Usage: /tasks cancel <task-id>', shouldContinue: true };
+            }
+            await context.engine?.cancelBackgroundTask?.(taskId);
+            return { success: true, message: chalk.green(`Cancelled task: ${taskId}`), shouldContinue: true };
+        }
+        return { success: false, message: 'Usage: /tasks [list|cancel <id>]', shouldContinue: true };
+    },
+};
+export const todosCommand = {
+    name: 'todos',
+    aliases: ['todo'],
+    description: 'View and manage todo list',
+    usage: '/todos [add <item>|done <id>|clear]',
+    category: 'tools',
+    execute: async (args, context) => {
+        const { executeTodoWrite } = await import('../../tools/NativeTools.js');
+        if (args.length === 0) {
+            const result = await executeTodoWrite({ operation: 'list' });
+            return { success: true, message: result.output || 'No todos.', shouldContinue: true };
+        }
+        const operation = args[0];
+        switch (operation) {
+            case 'add':
+                const content = args.slice(1).join(' ');
+                if (!content) {
+                    return { success: false, message: 'Usage: /todos add <item>', shouldContinue: true };
+                }
+                await executeTodoWrite({ operation: 'add', content });
+                return { success: true, message: chalk.green(`Added: ${content}`), shouldContinue: true };
+            case 'done':
+                const id = parseInt(args[1]);
+                if (isNaN(id)) {
+                    return { success: false, message: 'Usage: /todos done <id>', shouldContinue: true };
+                }
+                await executeTodoWrite({ operation: 'complete', id });
+                return { success: true, message: chalk.green(`Completed todo #${id}`), shouldContinue: true };
+            case 'clear':
+                await executeTodoWrite({ operation: 'clear' });
+                return { success: true, message: chalk.yellow('Todo list cleared.'), shouldContinue: true };
+            default:
+                return { success: false, message: 'Usage: /todos [add <item>|done <id>|clear]', shouldContinue: true };
+        }
+    },
+};
+// =============================================================================
+// INFO COMMANDS
+// =============================================================================
+export const costCommand = {
+    name: 'cost',
+    aliases: [],
+    description: 'Show session cost breakdown',
+    usage: '/cost',
+    category: 'info',
+    execute: async (args, context) => {
+        const session = context.sessionManager?.getCurrentSession();
+        if (!session) {
+            return { success: true, message: 'No active session.', shouldContinue: true };
+        }
+        const meta = session.metadata;
+        const inputCost = (meta.inputTokens / 1000000) * 3; // Sonnet input rate
+        const outputCost = (meta.outputTokens / 1000000) * 15; // Sonnet output rate
+        const message = `
+${chalk.bold('Session Cost Breakdown')}
+
+  Input tokens:  ${formatTokens(meta.inputTokens).padEnd(10)} ${chalk.yellow(formatCost(inputCost))}
+  Output tokens: ${formatTokens(meta.outputTokens).padEnd(10)} ${chalk.yellow(formatCost(outputCost))}
+  Tool calls:    ${meta.toolCallCount}
+
+  ${chalk.bold('Total Cost:')} ${chalk.green(formatCost(meta.totalCost))}
+`;
+        return { success: true, message, shouldContinue: true };
+    },
+};
+export const statusCommand = {
+    name: 'status',
+    aliases: [],
+    description: 'Show system status',
+    usage: '/status',
+    category: 'info',
+    execute: async (args, context) => {
+        const session = context.sessionManager?.getCurrentSession();
+        const mode = context.planMode?.getMode() || 'default';
+        const modeSymbol = context.planMode?.getModeSymbol() || '🔐';
+        const message = `
+${chalk.bold('FlutterAI Status')}
+
+  Version:     12.2.0
+  Mode:        ${modeSymbol} ${mode}
+  Session:     ${session?.name || session?.id?.substring(0, 8) || 'None'}
+  Project:     ${session?.projectPath || process.cwd()}
+  Model:       ${session?.metadata?.model || 'claude-sonnet-4'}
+  Messages:    ${session?.messages?.length || 0}
+  Cost:        ${formatCost(session?.metadata?.totalCost || 0)}
+  MCP:         ${context.engine?.isMCPConnected?.() ? chalk.green('Connected') : chalk.yellow('Disconnected')}
+`;
+        return { success: true, message, shouldContinue: true };
+    },
+};
+export const modelCommand = {
+    name: 'model',
+    aliases: [],
+    description: 'Switch Claude model',
+    usage: '/model [haiku|sonnet|opus]',
+    category: 'info',
+    execute: async (args, context) => {
+        const modelMap = {
+            haiku: 'claude-3-5-haiku-20241022',
+            sonnet: 'claude-sonnet-4-20250514',
+            opus: 'claude-opus-4-20250514',
+        };
+        if (args.length === 0) {
+            const current = context.engine?.getCurrentModel?.() || 'unknown';
+            const models = Object.entries(modelMap)
+                .map(([alias, id]) => `  ${chalk.cyan(alias.padEnd(8))} ${id}`)
+                .join('\n');
+            return {
+                success: true,
+                message: `Current model: ${chalk.green(current)}\n\nAvailable:\n${models}`,
+                shouldContinue: true,
+            };
+        }
+        const requested = args[0].toLowerCase();
+        const modelId = modelMap[requested] || requested;
+        context.engine?.setModel?.(modelId);
+        return {
+            success: true,
+            message: chalk.green(`Switched to ${modelId}`),
+            shouldContinue: true,
+        };
+    },
+};
+export const doctorCommand = {
+    name: 'doctor',
+    aliases: [],
+    description: 'Run health diagnostics',
+    usage: '/doctor',
+    category: 'info',
+    execute: async (args, context) => {
+        const checks = [];
+        // Check API connection
+        checks.push({
+            name: 'API Connection',
+            status: true, // Would actually test
+            note: 'claude-sonnet-4',
+        });
+        // Check MCP
+        checks.push({
+            name: 'MCP Server',
+            status: context.engine?.isMCPConnected?.() ?? false,
+        });
+        // Check project
+        const fs = await import('fs/promises');
+        const hasPubspec = await fs.access('pubspec.yaml').then(() => true).catch(() => false);
+        checks.push({
+            name: 'Flutter Project',
+            status: hasPubspec,
+            note: hasPubspec ? 'pubspec.yaml found' : 'Not a Flutter project',
+        });
+        // Check memory file
+        const memoryPaths = await context.memoryManager?.getMemoryFilePaths?.() || [];
+        checks.push({
+            name: 'Memory Files',
+            status: memoryPaths.length > 0,
+            note: memoryPaths.length > 0 ? `${memoryPaths.length} file(s)` : 'None found',
+        });
+        const allPassed = checks.every((c) => c.status);
+        const message = `
+${chalk.bold('FlutterAI Doctor')}
+
+${checks.map((c) => {
+            const icon = c.status ? chalk.green('✓') : chalk.red('✗');
+            const note = c.note ? chalk.gray(` (${c.note})`) : '';
+            return `  ${icon} ${c.name}${note}`;
+        }).join('\n')}
+
+${allPassed ? chalk.green('All checks passed!') : chalk.yellow('Some issues detected.')}
+`;
+        return { success: true, message, shouldContinue: true };
+    },
+};
+export const usageCommand = {
+    name: 'usage',
+    aliases: [],
+    description: 'Show rate limit usage',
+    usage: '/usage',
+    category: 'info',
+    execute: async (args, context) => {
+        // Would integrate with actual rate limit tracking
+        return {
+            success: true,
+            message: `
+${chalk.bold('API Usage')}
+
+  Requests today: ~50
+  Rate limit: 4000/min
+  Status: ${chalk.green('OK')}
+`,
+            shouldContinue: true,
+        };
+    },
+};
+export const statsCommand = {
+    name: 'stats',
+    aliases: [],
+    description: 'Show usage analytics',
+    usage: '/stats [day|week|month]',
+    category: 'info',
+    execute: async (args, context) => {
+        const period = args[0] || 'day';
+        const sessions = await context.sessionManager?.listRecent(100) || [];
+        const now = new Date();
+        const cutoff = new Date();
+        if (period === 'week')
+            cutoff.setDate(now.getDate() - 7);
+        else if (period === 'month')
+            cutoff.setDate(now.getDate() - 30);
+        else
+            cutoff.setDate(now.getDate() - 1);
+        const filtered = sessions.filter((s) => new Date(s.updatedAt) > cutoff);
+        const totalCost = filtered.reduce((sum, s) => sum + (s.totalCost || 0), 0);
+        const totalMessages = filtered.reduce((sum, s) => sum + (s.messageCount || 0), 0);
+        return {
+            success: true,
+            message: `
+${chalk.bold(`Stats (${period})`)}
+
+  Sessions: ${filtered.length}
+  Messages: ${totalMessages}
+  Total Cost: ${formatCost(totalCost)}
+`,
+            shouldContinue: true,
+        };
+    },
+};
+// =============================================================================
+// FLUTTER-SPECIFIC COMMANDS
+// =============================================================================
+export const gatesCommand = {
+    name: 'gates',
+    aliases: [],
+    description: 'Run safety gates (FlutterAI)',
+    usage: '/gates [file]',
+    category: 'flutter',
+    execute: async (args, context) => {
+        const target = args[0] || '.';
+        const result = await context.engine?.runSafetyGates?.(target);
+        return {
+            success: true,
+            message: result || chalk.green('Safety gates passed.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const healCommand = {
+    name: 'heal',
+    aliases: [],
+    description: 'Run self-healing agent (FlutterAI)',
+    usage: '/heal [file]',
+    category: 'flutter',
+    execute: async (args, context) => {
+        const target = args[0];
+        const result = await context.engine?.runSelfHealing?.(target);
+        return {
+            success: true,
+            message: result || chalk.green('Healing complete.'),
+            shouldContinue: true,
+        };
+    },
+};
+export const productionCommand = {
+    name: 'production',
+    aliases: ['prod'],
+    description: 'Check production readiness (FlutterAI)',
+    usage: '/production',
+    category: 'flutter',
+    execute: async (args, context) => {
+        const result = await context.engine?.checkProductionReadiness?.();
+        return {
+            success: true,
+            message: result || 'Production check complete.',
+            shouldContinue: true,
+        };
+    },
+};
+// =============================================================================
+// CONFIG COMMANDS
+// =============================================================================
+export const configCommand = {
+    name: 'config',
+    aliases: ['settings'],
+    description: 'View or modify configuration',
+    usage: '/config [key] [value]',
+    category: 'config',
+    execute: async (args, context) => {
+        if (args.length === 0) {
+            const config = context.configManager?.getAll?.() || {};
+            const formatted = Object.entries(config)
+                .filter(([k]) => !k.includes('Key') && !k.includes('secret'))
+                .map(([k, v]) => `  ${chalk.cyan(k)}: ${chalk.yellow(JSON.stringify(v))}`)
+                .join('\n');
+            return {
+                success: true,
+                message: `\n${chalk.bold('Configuration:')}\n\n${formatted}\n`,
+                shouldContinue: true,
+            };
+        }
+        if (args.length === 1) {
+            const value = context.configManager?.get?.(args[0]);
+            return {
+                success: true,
+                message: `${args[0]}: ${chalk.yellow(JSON.stringify(value))}`,
+                shouldContinue: true,
+            };
+        }
+        const [key, ...valueParts] = args;
+        const value = valueParts.join(' ');
+        try {
+            context.configManager?.set?.(key, JSON.parse(value));
+        }
+        catch {
+            context.configManager?.set?.(key, value);
+        }
+        return {
+            success: true,
+            message: chalk.green(`Set ${key} = ${value}`),
+            shouldContinue: true,
+        };
+    },
+};
+export const memoryCommand = {
+    name: 'memory',
+    aliases: [],
+    description: 'Manage FLUTTERAI.md memory',
+    usage: '/memory [show|edit|init|clear]',
+    category: 'config',
+    execute: async (args, context) => {
+        const operation = args[0] || 'show';
+        switch (operation) {
+            case 'show':
+                const memory = await context.memoryManager?.getMemoryContent?.();
+                if (!memory?.rawContent) {
+                    return {
+                        success: true,
+                        message: chalk.gray('No memory file found. Use /memory init to create one.'),
+                        shouldContinue: true,
+                    };
+                }
+                return {
+                    success: true,
+                    message: `\n${chalk.bold('Memory Files:')}\n${memory.sources.join('\n')}\n\n${memory.rawContent.substring(0, 2000)}${memory.rawContent.length > 2000 ? '\n...[truncated]' : ''}`,
+                    shouldContinue: true,
+                };
+            case 'init':
+                const result = await context.memoryManager?.initializeProjectMemory?.();
+                return {
+                    success: true,
+                    message: chalk.green(result || 'Memory file created.'),
+                    shouldContinue: true,
+                };
+            case 'edit':
+                const path = context.memoryManager?.getProjectMemoryPath?.();
+                return {
+                    success: true,
+                    message: chalk.yellow(`Edit memory file at: ${path || 'FLUTTERAI.md'}`),
+                    shouldContinue: true,
+                };
+            case 'clear':
+                await context.memoryManager?.clearMemory?.('project');
+                return {
+                    success: true,
+                    message: chalk.green('Project memory cleared.'),
+                    shouldContinue: true,
+                };
+            default:
+                return { success: false, message: 'Usage: /memory [show|edit|init|clear]', shouldContinue: true };
+        }
+    },
+};
+export const themeCommand = {
+    name: 'theme',
+    aliases: [],
+    description: 'Change color theme',
+    usage: '/theme [dark|light|nord|dracula]',
+    category: 'config',
+    execute: async (args, context) => {
+        const themes = ['dark', 'light', 'nord', 'dracula'];
+        if (args.length === 0) {
+            const current = context.configManager?.get?.('theme') || 'dark';
+            return {
+                success: true,
+                message: `Current: ${chalk.cyan(current)}\nAvailable: ${themes.join(', ')}`,
+                shouldContinue: true,
+            };
+        }
+        const theme = args[0].toLowerCase();
+        if (!themes.includes(theme)) {
+            return { success: false, message: `Unknown theme: ${theme}`, shouldContinue: true };
+        }
+        context.configManager?.set?.('theme', theme);
+        context.ui?.applyTheme?.(theme);
+        return {
+            success: true,
+            message: chalk.green(`Theme changed to: ${theme}`),
+            shouldContinue: true,
+        };
+    },
+};
+export const vimCommand = {
+    name: 'vim',
+    aliases: [],
+    description: 'Toggle vim editing mode',
+    usage: '/vim [on|off]',
+    category: 'config',
+    execute: async (args, context) => {
+        const current = context.configManager?.get?.('vimMode') || false;
+        const newValue = args[0] === 'on' ? true : args[0] === 'off' ? false : !current;
+        context.configManager?.set?.('vimMode', newValue);
+        context.ui?.setVimMode?.(newValue);
+        return {
+            success: true,
+            message: chalk.green(`Vim mode: ${newValue ? 'enabled' : 'disabled'}`),
+            shouldContinue: true,
+        };
+    },
+};
+export const mcpCommand = {
+    name: 'mcp',
+    aliases: [],
+    description: 'Manage MCP servers',
+    usage: '/mcp [list|status|reload]',
+    category: 'config',
+    execute: async (args, context) => {
+        const operation = args[0] || 'status';
+        switch (operation) {
+            case 'list':
+            case 'status':
+                const connected = context.engine?.isMCPConnected?.() ?? false;
+                const tools = context.engine?.getMCPTools?.() || [];
+                return {
+                    success: true,
+                    message: `
+${chalk.bold('MCP Status')}
+
+  Server: ${connected ? chalk.green('Connected') : chalk.red('Disconnected')}
+  Tools:  ${tools.length}
+`,
+                    shouldContinue: true,
+                };
+            case 'reload':
+                await context.engine?.reconnectMCP?.();
+                return {
+                    success: true,
+                    message: chalk.green('MCP server reconnected.'),
+                    shouldContinue: true,
+                };
+            default:
+                return { success: false, message: 'Usage: /mcp [list|status|reload]', shouldContinue: true };
+        }
+    },
+};
+export const initCommand = {
+    name: 'init',
+    aliases: [],
+    description: 'Initialize FlutterAI in project',
+    usage: '/init',
+    category: 'config',
+    execute: async (args, context) => {
+        // Initialize memory file
+        const memResult = await context.memoryManager?.initializeProjectMemory?.();
+        // Create .fai directory
+        const fs = await import('fs/promises');
+        await fs.mkdir('.fai', { recursive: true });
+        return {
+            success: true,
+            message: chalk.green(`FlutterAI initialized.\n${memResult || ''}`),
+            shouldContinue: true,
+        };
+    },
+};
+// =============================================================================
+// COMMAND REGISTRY
+// =============================================================================
+export const COMMAND_REGISTRY = {
+    // Session commands
+    help: helpCommand,
+    exit: exitCommand,
+    clear: clearCommand,
+    reset: resetCommand,
+    resume: resumeCommand,
+    rename: renameCommand,
+    rewind: rewindCommand,
+    export: exportCommand,
+    // Mode commands
+    plan: planCommand,
+    execute: executeCommand,
+    accept: acceptCommand,
+    default: defaultCommand,
+    // Tools commands
+    tools: toolsCommand,
+    compact: compactCommand,
+    context: contextCommand,
+    tasks: tasksCommand,
+    todos: todosCommand,
+    // Info commands
+    cost: costCommand,
+    status: statusCommand,
+    model: modelCommand,
+    doctor: doctorCommand,
+    usage: usageCommand,
+    stats: statsCommand,
+    // Flutter commands
+    gates: gatesCommand,
+    heal: healCommand,
+    production: productionCommand,
+    // Config commands
+    config: configCommand,
+    memory: memoryCommand,
+    theme: themeCommand,
+    vim: vimCommand,
+    mcp: mcpCommand,
+    init: initCommand,
+};
+// =============================================================================
+// ALIAS MAP
+// =============================================================================
+export const ALIAS_MAP = {};
+for (const [name, cmd] of Object.entries(COMMAND_REGISTRY)) {
+    for (const alias of cmd.aliases) {
+        ALIAS_MAP[alias] = name;
+    }
+}
+// =============================================================================
+// COMMAND RESOLUTION
+// =============================================================================
+export function resolveCommand(input) {
+    const normalized = input.toLowerCase().replace(/^\//, '');
+    const name = ALIAS_MAP[normalized] || normalized;
+    return COMMAND_REGISTRY[name] || null;
+}
+export function parseCommandInput(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/')) {
+        return { command: null, args: [] };
+    }
+    const parts = trimmed.substring(1).split(/\s+/);
+    const cmdName = parts[0];
+    const args = parts.slice(1);
+    return {
+        command: resolveCommand(cmdName),
+        args,
+    };
+}
+export function getCommandNames() {
+    return Object.keys(COMMAND_REGISTRY);
+}
+export function getCommandCount() {
+    return Object.keys(COMMAND_REGISTRY).length;
+}
+//# sourceMappingURL=SlashCommands.js.map