dartmind 17.0.0

package/dist/cli/InteractiveModeV12.js

@@ -0,0 +1,1019 @@
+// packages/core/src/cli/InteractiveModeV12.ts
+// FlutterAI V15 Interactive Mode - Full Claude Code Parity with JARVIS
+import Anthropic from '@anthropic-ai/sdk';
+import { EventEmitter } from 'events';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { TerminalUI, Colors } from './ui/TerminalUI.js';
+import { StreamingHandler } from './ui/StreamingHandler.js';
+import { MCPBridge } from './mcp/MCPBridge.js';
+import { IntentClassifier } from './agents/IntentClassifier.js';
+import { TokenOptimizer } from './optimization/TokenOptimizer.js';
+import { RLHFManager } from '../rlhf/index.js';
+// V15 Imports
+import { sessionManager } from '../session/SessionManager.js';
+import { planModeController } from '../modes/PlanMode.js';
+import { memoryFileManager } from '../memory/MemoryFile.js';
+import { keyboardShortcuts } from './KeyboardShortcuts.js';
+import { parseCommandInput, } from './commands/SlashCommands.js';
+import { ALL_NATIVE_TOOLS, executeTool, checkpointManager, } from '../tools/NativeTools.js';
+import { getConfig } from '../config/ConfigManager.js';
+import { MAX_CONVERSATION_HISTORY, CONVERSATION_TRIM_TARGET, } from '../constants/limits.js';
+// V15: JARVIS Personality & LightweightClassifier
+import { jarvis } from '../personality/JarvisLite.js';
+import { LightweightClassifier, } from './agents/LightweightClassifier.js';
+// V15: Centralized System Prompts
+import { buildInteractivePrompt } from '../prompts/SystemPrompts.js';
+// V15.1: Safety Gates (Armor Layer)
+import { SecurityGate } from '../gates/SecurityGate.js';
+// =============================================================================
+// INTERACTIVE MODE V12
+// =============================================================================
+export class InteractiveModeV12 extends EventEmitter {
+    ui;
+    anthropic;
+    streaming;
+    mcpBridge;
+    intentClassifier;
+    tokenOptimizer;
+    rlhf;
+    config;
+    // V15: JARVIS/LightweightClassifier
+    missionClassifier;
+    currentMission = null;
+    // Session state
+    session = null;
+    conversationHistory = [];
+    totalCost = 0;
+    totalTokens = { input: 0, output: 0 };
+    isRunning = false;
+    isProcessing = false;
+    // V15 state
+    todos = [];
+    verbose = false;
+    currentModel;
+    inputBuffer = '';
+    isMultilineMode = false;
+    multilineBuffer = [];
+    rewindCheckpoints = [];
+    cachedMemoryContext = null;
+    // V15.1: Synaptic Bridge - Personality State
+    personalityState = {
+        mode: 'build', // Default mode
+        intensity: 1, // Concise by default
+        expertise: 'intermediate',
+    };
+    // V15.1: Safety Gates (Armor Layer)
+    securityGate;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.currentModel = config.model;
+        this.verbose = config.verbose || false;
+        this.ui = new TerminalUI();
+        this.anthropic = new Anthropic({ apiKey: config.apiKey });
+        this.streaming = new StreamingHandler(this.anthropic);
+        this.mcpBridge = new MCPBridge();
+        this.intentClassifier = new IntentClassifier();
+        this.missionClassifier = new LightweightClassifier(); // V15
+        this.tokenOptimizer = new TokenOptimizer();
+        this.rlhf = new RLHFManager(config.projectRoot);
+        this.securityGate = new SecurityGate(); // V15.1: Safety Gates
+        // Set up dangerous mode if requested
+        if (config.dangerouslySkipPermissions) {
+            planModeController.setMode('bypass');
+        }
+    }
+    // ===========================================================================
+    // INITIALIZATION
+    // ===========================================================================
+    async start() {
+        this.isRunning = true;
+        // Initialize all components
+        await this.initialize();
+        // Render UI
+        this.ui.clearScreen();
+        this.renderBanner();
+        this.renderStatusBar();
+        console.log('Type your message and press Enter. Use /help for commands.\n');
+        // Set up event handlers
+        this.setupEventHandlers();
+        this.setupKeyboardShortcuts();
+        // Start prompting
+        this.prompt();
+        // Keep process alive
+        await this.waitForExit();
+    }
+    /**
+     * Run a single prompt and exit (non-interactive mode for -p flag)
+     */
+    async runSinglePrompt(prompt) {
+        // Initialize components without UI chrome
+        await this.initializeMinimal();
+        // Process the message
+        await this.handleMessage(prompt);
+        // Clean up
+        this.mcpBridge.shutdown();
+    }
+    async initializeMinimal() {
+        try {
+            // Initialize session manager
+            await sessionManager.initialize();
+            // Create session
+            this.session = await sessionManager.create(this.config.projectRoot, this.currentModel);
+            // Initialize MCP bridge
+            await this.mcpBridge.initialize();
+            // Set memory context
+            memoryFileManager.setProjectPath(this.config.projectRoot);
+            try {
+                this.cachedMemoryContext = await memoryFileManager.getContextForPrompt(2000);
+            }
+            catch {
+                this.cachedMemoryContext = null;
+            }
+        }
+        catch (error) {
+            console.error('Initialization error:', error);
+        }
+    }
+    async initialize() {
+        this.ui.startSpinner('Initializing DartMind V17...', 'dots');
+        try {
+            // Initialize session manager
+            await sessionManager.initialize();
+            // Resume or create session
+            if (this.config.resumeSession) {
+                this.session = await sessionManager.load(this.config.resumeSession);
+                if (this.session) {
+                    // Restore conversation history
+                    this.conversationHistory = this.session.messages.map((m) => ({
+                        role: m.role,
+                        content: m.content,
+                    }));
+                    this.totalCost = this.session.metadata.totalCost;
+                    this.totalTokens = {
+                        input: this.session.metadata.inputTokens,
+                        output: this.session.metadata.outputTokens,
+                    };
+                }
+            }
+            if (!this.session) {
+                this.session = await sessionManager.create(this.config.projectRoot, this.currentModel);
+            }
+            // Initialize RLHF
+            await this.rlhf.initialize();
+            // Initialize memory file manager
+            memoryFileManager.setProjectPath(this.config.projectRoot);
+            // Pre-cache memory context
+            try {
+                this.cachedMemoryContext = await memoryFileManager.getContextForPrompt(2000);
+            }
+            catch {
+                this.cachedMemoryContext = null;
+            }
+            // Initialize MCP Bridge (non-blocking)
+            this.mcpBridge.initialize().catch(() => {
+                // MCP server not available, continue without it
+            });
+            // Verify API connection
+            await this.verifyConnection();
+            this.ui.stopSpinner('Ready!', true);
+            // Show session info if resumed
+            if (this.config.resumeSession && this.session) {
+                console.log(`${Colors.dim}Resumed session: ${this.session.id} (${this.session.messages.length} messages)${Colors.reset}`);
+            }
+        }
+        catch (error) {
+            this.ui.stopSpinner('Initialization failed', false);
+            throw error;
+        }
+    }
+    async verifyConnection() {
+        try {
+            await this.anthropic.messages.create({
+                model: this.currentModel,
+                max_tokens: 10,
+                messages: [{ role: 'user', content: 'Hi' }],
+            });
+        }
+        catch (error) {
+            throw new Error(`API connection failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // ===========================================================================
+    // EVENT HANDLERS
+    // ===========================================================================
+    setupEventHandlers() {
+        // Enable keypress events
+        readline.emitKeypressEvents(process.stdin);
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.on('keypress', (ch, key) => {
+            if (!key)
+                return;
+            // Parse key event for keyboard shortcuts
+            const keyEvent = {
+                key: key.name || ch || '',
+                ctrl: key.ctrl || false,
+                alt: key.meta || false,
+                shift: key.shift || false,
+                meta: key.meta || false,
+                raw: Buffer.from(ch || ''),
+            };
+            // Check for shortcut handling
+            if (keyboardShortcuts.handleKeypress(keyEvent)) {
+                return;
+            }
+            // Handle Ctrl+C
+            if (key.ctrl && key.name === 'c') {
+                if (this.isProcessing) {
+                    this.streaming.abort();
+                    this.isProcessing = false;
+                    console.log('\n\nGeneration cancelled.');
+                    this.prompt();
+                }
+                else {
+                    this.exit();
+                }
+                return;
+            }
+            // Handle Ctrl+D
+            if (key.ctrl && key.name === 'd') {
+                this.exit();
+                return;
+            }
+            // Handle multi-line input (Alt+Enter or Shift+Enter)
+            if ((key.meta || key.shift) && key.name === 'return') {
+                this.multilineBuffer.push(this.inputBuffer);
+                this.inputBuffer = '';
+                console.log();
+                this.renderMultilinePrompt();
+                return;
+            }
+            // Handle Enter
+            if (key.name === 'return') {
+                const fullInput = this.isMultilineMode
+                    ? [...this.multilineBuffer, this.inputBuffer].join('\n')
+                    : this.inputBuffer;
+                this.inputBuffer = '';
+                this.multilineBuffer = [];
+                this.isMultilineMode = false;
+                console.log();
+                this.handleInput(fullInput);
+                return;
+            }
+            // Handle backspace
+            if (key.name === 'backspace') {
+                if (this.inputBuffer.length > 0) {
+                    this.inputBuffer = this.inputBuffer.slice(0, -1);
+                    process.stdout.write('\b \b');
+                }
+                return;
+            }
+            // Regular character input
+            if (ch && !key.ctrl && !key.meta) {
+                this.inputBuffer += ch;
+                process.stdout.write(ch);
+            }
+        });
+    }
+    setupKeyboardShortcuts() {
+        // Cancel operation
+        keyboardShortcuts.onCancel(() => {
+            if (this.isProcessing) {
+                this.streaming.abort();
+                this.isProcessing = false;
+                console.log('\n\nGeneration cancelled.');
+                this.prompt();
+            }
+        });
+        // Exit
+        keyboardShortcuts.onExit(() => {
+            this.exit();
+        });
+        // Clear screen
+        keyboardShortcuts.onClearScreen(() => {
+            this.ui.clearScreen();
+            this.renderBanner();
+            this.renderStatusBar();
+            this.prompt();
+        });
+        // Cycle permission mode
+        keyboardShortcuts.onCyclePermission(() => {
+            const newMode = planModeController.cycleMode();
+            console.log(`\n${Colors.cyan}Mode changed to: ${newMode.toUpperCase()}${Colors.reset}`);
+            this.renderStatusBar();
+            this.prompt();
+        });
+        // Switch model
+        keyboardShortcuts.onSwitchModel(async () => {
+            await this.handleModelSwitch();
+        });
+        // Rewind (double-tap Escape)
+        keyboardShortcuts.onRewind(async () => {
+            await this.handleRewind();
+        });
+        // Toggle verbose
+        keyboardShortcuts.onToggleVerbose(() => {
+            this.verbose = !this.verbose;
+            console.log(`\n${Colors.cyan}Verbose mode: ${this.verbose ? 'ON' : 'OFF'}${Colors.reset}`);
+            this.prompt();
+        });
+        // Background task
+        keyboardShortcuts.onBackgroundTask(() => {
+            console.log(`\n${Colors.yellow}Background tasks not yet implemented${Colors.reset}`);
+            this.prompt();
+        });
+        // Vim mode changes
+        keyboardShortcuts.on('vim-mode-change', ({ enabled, state }) => {
+            console.log(`\n${Colors.cyan}Vim mode: ${enabled ? state.toUpperCase() : 'OFF'}${Colors.reset}`);
+            this.prompt();
+        });
+    }
+    // ===========================================================================
+    // INPUT HANDLING
+    // ===========================================================================
+    async handleInput(input) {
+        if (this.isProcessing) {
+            console.log('Please wait for the current request to complete.');
+            this.prompt();
+            return;
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            this.prompt();
+            return;
+        }
+        if (trimmed.startsWith('/')) {
+            await this.handleSlashCommand(trimmed);
+        }
+        else {
+            await this.handleMessage(trimmed);
+        }
+        if (this.isRunning) {
+            this.prompt();
+        }
+    }
+    async handleSlashCommand(input) {
+        const { command: resolved, args } = parseCommandInput(input);
+        if (!resolved) {
+            const cmdName = input.split(/\s+/)[0];
+            console.log(`Unknown command: ${cmdName}. Type /help for available commands.\n`);
+            return;
+        }
+        // Build command context
+        const context = {
+            engine: this,
+            sessionManager,
+            configManager: getConfig(this.config.projectRoot),
+            memoryManager: memoryFileManager,
+            planMode: planModeController,
+            ui: this.ui,
+        };
+        try {
+            const result = await resolved.execute(args, context);
+            if (result.message) {
+                console.log(result.message);
+            }
+            // Handle special actions based on shouldContinue
+            if (!result.shouldContinue) {
+                this.exit();
+            }
+        }
+        catch (error) {
+            console.error(`Command failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async handleMessage(input) {
+        this.isProcessing = true;
+        this.renderUserMessage(input);
+        // Create rewind checkpoint
+        this.rewindCheckpoints.push({
+            id: `cp_${Date.now()}`,
+            description: `Before: ${input.substring(0, 50)}...`,
+            timestamp: Date.now(),
+            messageIndex: this.conversationHistory.length,
+        });
+        // Keep only last 10 checkpoints
+        if (this.rewindCheckpoints.length > 10) {
+            this.rewindCheckpoints.shift();
+        }
+        try {
+            // V15: Classify with LightweightClassifier for mission HUD
+            this.currentMission = this.missionClassifier.classify(input);
+            // V15.1: Synaptic Bridge - Update personality from user input
+            this.updatePersonalityFromIntent(input);
+            // Classify intent (for tool suggestions)
+            const intent = await this.intentClassifier.classify(input);
+            // V15: Display mission HUD
+            if (!this.config.dangerouslySkipPermissions) {
+                this.displayMissionHUD(this.currentMission);
+            }
+            // Build thinking HUD
+            const hud = {
+                intent: this.currentMission.displayName,
+                confidence: Math.round(this.currentMission.confidence * 100),
+                toolChain: this.currentMission.suggestedTools,
+                evaluations: {
+                    Package: 'pending',
+                    Policy: 'pending',
+                    Security: 'pending',
+                    Performance: 'pending',
+                    'Dart Analysis': 'pending',
+                },
+            };
+            // Show thinking HUD for complex queries
+            if (intent.requiresTools && this.currentMission.confidence > 0.7) {
+                this.ui.renderThinkingHUD(hud);
+            }
+            // Build optimized context
+            const rlhfContext = await this.rlhf.buildRLHFContext(input);
+            const optimizedContext = await this.tokenOptimizer.optimize({
+                conversation: this.conversationHistory,
+                rlhfContext,
+                projectContext: this.cachedMemoryContext || await this.getProjectContext(),
+            });
+            // Get tools based on plan mode
+            const allTools = this.getAvailableTools(intent.suggestedTools);
+            // Add user message to history
+            this.conversationHistory.push({ role: 'user', content: input });
+            // Stream response
+            this.renderStreamingStart();
+            const streamOptions = {
+                model: this.currentModel,
+                maxTokens: this.config.maxTokens,
+                system: this.buildSystemPrompt(optimizedContext),
+                tools: allTools.length > 0 ? allTools : undefined,
+                toolExecutor: allTools.length > 0
+                    ? async (name, toolInput) => this.executeToolWithUI(name, toolInput, hud)
+                    : undefined,
+            };
+            const streamCallbacks = {
+                onToken: (token) => {
+                    process.stdout.write(token);
+                },
+                onToolStart: (toolName) => {
+                    this.ui.renderToolStart(toolName);
+                },
+                onToolEnd: (toolName, result, success) => {
+                    const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+                    this.ui.renderToolResult(success, resultStr.substring(0, 200));
+                },
+                onComplete: (fullResponse, usage) => {
+                    this.finishStreaming();
+                    this.updateUsage(usage);
+                    this.renderStatusBar();
+                },
+                onError: (error) => {
+                    console.error(`\nError: ${error.message}\n`);
+                },
+            };
+            let { response, toolResults, toolUseBlocks } = await this.streaming.streamMessage(this.conversationHistory, streamOptions, streamCallbacks);
+            // P0 FIX: Handle tool results - continue agent loop after tool execution
+            let finalResponse = response;
+            // Loop until no more tool calls (agent loop continuation)
+            while (toolResults.length > 0) {
+                // Build assistant message content with both text and tool_use blocks
+                const assistantContent = [];
+                if (response) {
+                    assistantContent.push({ type: 'text', text: response });
+                }
+                for (const block of toolUseBlocks) {
+                    assistantContent.push({
+                        type: 'tool_use',
+                        id: block.id,
+                        name: block.name,
+                        input: block.input,
+                    });
+                }
+                // Add assistant message with tool_use blocks to history
+                this.conversationHistory.push({ role: 'assistant', content: assistantContent });
+                // Build tool_result content blocks
+                const toolResultContent = toolResults.map(result => ({
+                    type: 'tool_result',
+                    tool_use_id: result.toolUseId,
+                    content: typeof result.result === 'string' ? result.result : JSON.stringify(result.result),
+                    is_error: result.isError,
+                }));
+                // Add tool results as user message
+                this.conversationHistory.push({ role: 'user', content: toolResultContent });
+                // Continue the conversation
+                const continued = await this.streaming.streamMessage(this.conversationHistory, streamOptions, streamCallbacks);
+                response = continued.response;
+                toolResults = continued.toolResults;
+                toolUseBlocks = continued.toolUseBlocks;
+                finalResponse = response;
+            }
+            // Add final assistant response to history (only if no tool calls in final response)
+            if (finalResponse) {
+                this.conversationHistory.push({ role: 'assistant', content: finalResponse });
+            }
+            // Prune old messages to prevent unbounded token growth
+            this.pruneConversationHistory();
+            // Save to session
+            if (this.session) {
+                sessionManager.addMessage({
+                    role: 'user',
+                    content: input,
+                });
+                sessionManager.addMessage({
+                    role: 'assistant',
+                    content: response,
+                });
+                this.session.metadata.totalCost = this.totalCost;
+                this.session.metadata.inputTokens = this.totalTokens.input;
+                this.session.metadata.outputTokens = this.totalTokens.output;
+                await sessionManager.save(this.session);
+            }
+        }
+        catch (error) {
+            console.error(`\nFailed to get response: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+        finally {
+            this.isProcessing = false;
+        }
+    }
+    // ===========================================================================
+    // TOOL EXECUTION
+    // ===========================================================================
+    getAvailableTools(suggestedTools) {
+        // Get native tools (filtered by plan mode)
+        const nativeTools = planModeController.getAvailableTools(ALL_NATIVE_TOOLS);
+        // Get MCP tools if available
+        const mcpTools = this.mcpBridge.isReady()
+            ? this.mcpBridge.getToolsForClaude(suggestedTools)
+            : [];
+        // Format for Claude API
+        const formatted = [
+            ...nativeTools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.input_schema,
+            })),
+            ...mcpTools,
+        ];
+        return formatted;
+    }
+    async executeToolWithUI(toolName, input, hud) {
+        // Check permission
+        const permission = planModeController.canExecuteTool(toolName);
+        if (!permission.allowed) {
+            return { error: permission.reason };
+        }
+        // Show confirmation if required
+        if (permission.requiresConfirmation && !this.config.dangerouslySkipPermissions) {
+            const confirmed = await this.showConfirmation(toolName, input);
+            if (!confirmed) {
+                return { error: 'Tool execution denied by user' };
+            }
+        }
+        // Execute native tool or MCP tool
+        const isNativeTool = ALL_NATIVE_TOOLS.some((t) => t.name === toolName);
+        // JARVIS: Announce tool start
+        const toolContext = this.getToolContext(toolName, input);
+        console.log(jarvis.announceToolStart(toolName, toolContext));
+        if (isNativeTool) {
+            // Create file checkpoint for write operations
+            if ((toolName === 'Write' || toolName === 'Edit') && input.file_path) {
+                await checkpointManager.createCheckpoint(input.file_path);
+            }
+            const result = await executeTool(toolName, input);
+            // JARVIS: Announce tool result
+            if (result.success) {
+                console.log(jarvis.announceToolComplete(toolName));
+                // V15.1: Safety Gates - Run security check on Dart files after write/edit
+                if ((toolName === 'Write' || toolName === 'Edit') && input.file_path) {
+                    const filePath = input.file_path;
+                    if (filePath.endsWith('.dart')) {
+                        await this.runSecurityCheck(filePath, result.output, hud);
+                    }
+                }
+            }
+            else {
+                console.log(jarvis.announceToolError(toolName, result.error || 'Unknown error'));
+            }
+            return result.success ? result.output : { error: result.error };
+        }
+        else {
+            // MCP tool
+            const actualToolName = toolName.replace('mcp__flutter__', '');
+            const result = await this.mcpBridge.executeTool(actualToolName, input);
+            // JARVIS: Announce MCP tool result
+            if (result.success) {
+                console.log(jarvis.announceToolComplete(toolName));
+            }
+            else {
+                console.log(jarvis.announceToolError(toolName, result.error || 'Unknown error'));
+            }
+            // Update HUD gate status
+            const gateMap = {
+                verify_package: 'Package',
+                check_policy: 'Policy',
+                security_scan: 'Security',
+                analyze_performance: 'Performance',
+                analyze_dart: 'Dart Analysis',
+            };
+            const gate = gateMap[actualToolName];
+            if (gate && gate in hud.evaluations) {
+                hud.evaluations[gate] = result.success ? 'pass' : 'fail';
+            }
+            return result.success ? result.result : { error: result.error };
+        }
+    }
+    getToolContext(toolName, input) {
+        // Return a brief context string for tool announcements
+        if (input.file_path)
+            return String(input.file_path).split('/').pop() || '';
+        if (input.pattern)
+            return String(input.pattern);
+        if (input.command)
+            return String(input.command).substring(0, 30);
+        if (input.query)
+            return String(input.query).substring(0, 30);
+        if (input.path)
+            return String(input.path).split('/').pop() || '';
+        return '';
+    }
+    async showConfirmation(toolName, input) {
+        console.log();
+        console.log(`${Colors.yellow}${Colors.bold}Permission Required${Colors.reset}`);
+        console.log(`${Colors.dim}Tool: ${Colors.reset}${toolName}`);
+        console.log(`${Colors.dim}Input: ${Colors.reset}${JSON.stringify(input).substring(0, 100)}...`);
+        console.log();
+        process.stdout.write(`${Colors.cyan}Allow? [y/N]: ${Colors.reset}`);
+        return new Promise((resolve) => {
+            const handler = (ch) => {
+                process.stdin.removeListener('keypress', handler);
+                if (ch === 'y' || ch === 'Y') {
+                    console.log('Yes');
+                    resolve(true);
+                }
+                else {
+                    console.log('No');
+                    resolve(false);
+                }
+            };
+            process.stdin.once('keypress', handler);
+        });
+    }
+    // ===========================================================================
+    // V15: MISSION HUD
+    // ===========================================================================
+    displayMissionHUD(mission) {
+        const width = 55;
+        const line = '━'.repeat(width);
+        console.log('');
+        console.log(`${Colors.cyan}${Colors.bold}${mission.emoji} MISSION: ${mission.displayName}${Colors.reset}`);
+        console.log(`${Colors.dim}${line}${Colors.reset}`);
+        // Confidence bar
+        const barLength = Math.round(mission.confidence * 10);
+        const filledBar = '▓'.repeat(barLength);
+        const emptyBar = '░'.repeat(10 - barLength);
+        const confidencePercent = Math.round(mission.confidence * 100);
+        console.log(`${Colors.dim}Confidence: ${Colors.reset}${Colors.green}${filledBar}${Colors.reset}${Colors.dim}${emptyBar} ${confidencePercent}%${Colors.reset}`);
+        // Plan (compact)
+        if (mission.suggestedPlan.length > 0 && this.verbose) {
+            console.log(`${Colors.dim}Plan: ${mission.suggestedPlan.slice(0, 3).join(' → ')}${Colors.reset}`);
+        }
+        // Tools
+        console.log(`${Colors.dim}Tools: ${mission.suggestedTools.join(' → ')}${Colors.reset}`);
+        console.log(`${Colors.dim}${line}${Colors.reset}`);
+        console.log('');
+    }
+    // ===========================================================================
+    // MODEL SWITCHING
+    // ===========================================================================
+    async handleModelSwitch() {
+        const models = [
+            { id: 'claude-sonnet-4-20250514', name: 'Sonnet 4', tier: 'fast' },
+            { id: 'claude-opus-4-20250514', name: 'Opus 4', tier: 'powerful' },
+            { id: 'claude-3-5-haiku-20241022', name: 'Haiku 3.5', tier: 'instant' },
+        ];
+        console.log(`\n${Colors.cyan}${Colors.bold}Select Model${Colors.reset}`);
+        models.forEach((m, i) => {
+            const current = m.id === this.currentModel ? ` ${Colors.green}(current)${Colors.reset}` : '';
+            console.log(`  ${i + 1}. ${m.name} - ${Colors.dim}${m.tier}${Colors.reset}${current}`);
+        });
+        console.log();
+        process.stdout.write(`${Colors.cyan}Enter number [1-${models.length}]: ${Colors.reset}`);
+        return new Promise((resolve) => {
+            const handler = (ch) => {
+                process.stdin.removeListener('keypress', handler);
+                const num = parseInt(ch);
+                if (num >= 1 && num <= models.length) {
+                    this.currentModel = models[num - 1].id;
+                    console.log(`\n${Colors.green}Switched to ${models[num - 1].name}${Colors.reset}`);
+                }
+                else {
+                    console.log(`\n${Colors.dim}Cancelled${Colors.reset}`);
+                }
+                this.prompt();
+                resolve();
+            };
+            process.stdin.once('keypress', handler);
+        });
+    }
+    // ===========================================================================
+    // REWIND
+    // ===========================================================================
+    async handleRewind() {
+        if (this.rewindCheckpoints.length === 0) {
+            console.log(`\n${Colors.yellow}No checkpoints available${Colors.reset}`);
+            this.prompt();
+            return;
+        }
+        console.log(`\n${Colors.cyan}${Colors.bold}Rewind to Checkpoint${Colors.reset}`);
+        this.rewindCheckpoints.slice(-5).reverse().forEach((cp, i) => {
+            console.log(`  ${i + 1}. ${cp.description} ${Colors.dim}(${new Date(cp.timestamp).toLocaleTimeString()})${Colors.reset}`);
+        });
+        console.log();
+        process.stdout.write(`${Colors.cyan}Enter number [1-${Math.min(5, this.rewindCheckpoints.length)}] or 0 to cancel: ${Colors.reset}`);
+        return new Promise((resolve) => {
+            const handler = (ch) => {
+                process.stdin.removeListener('keypress', handler);
+                const num = parseInt(ch);
+                const checkpoints = this.rewindCheckpoints.slice(-5).reverse();
+                if (num >= 1 && num <= checkpoints.length) {
+                    const cp = checkpoints[num - 1];
+                    // Restore conversation to checkpoint
+                    this.conversationHistory = this.conversationHistory.slice(0, cp.messageIndex);
+                    console.log(`\n${Colors.green}Rewound to: ${cp.description}${Colors.reset}`);
+                }
+                else {
+                    console.log(`\n${Colors.dim}Cancelled${Colors.reset}`);
+                }
+                this.prompt();
+                resolve();
+            };
+            process.stdin.once('keypress', handler);
+        });
+    }
+    // ===========================================================================
+    // SYSTEM PROMPT
+    // ===========================================================================
+    buildSystemPrompt(context) {
+        const todoContext = this.todos.length > 0
+            ? this.todos.map((t) => `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '>' : ' '}] ${t.content}`).join('\n')
+            : undefined;
+        // V15.1: Synaptic Bridge - Determine personality context
+        let personality = { ...this.personalityState };
+        // Override mode if in plan mode (read-only)
+        if (planModeController.isPlanMode()) {
+            personality.mode = 'plan';
+        }
+        // Use centralized prompt builder with personality context
+        return buildInteractivePrompt({
+            personality,
+            memoryContext: this.cachedMemoryContext || undefined,
+            todoContext,
+            projectContext: context,
+        });
+    }
+    /**
+     * V15.1: Synaptic Bridge - Update personality from detected intent
+     */
+    updatePersonalityFromIntent(message) {
+        // Use JarvisLite to classify intent
+        const classification = jarvis.classifyIntent(message);
+        // Map mission type to operating mode
+        const missionToMode = {
+            'bug_fix': 'debug',
+            'architecture': 'plan',
+            'code_refactor': 'build',
+            'widget_generation': 'build',
+            'testing': 'build',
+            'security': 'debug',
+            'performance': 'debug',
+            'documentation': 'ship',
+            'analysis': 'plan',
+            'general': 'build',
+        };
+        // Update mode if high confidence
+        if (classification.confidence > 0.7) {
+            const newMode = missionToMode[classification.mission] || 'build';
+            if (newMode !== this.personalityState.mode) {
+                this.personalityState.mode = newMode;
+            }
+        }
+        // Detect frustration from message
+        const frustrationSignals = /damn|shit|wtf|broken|not working|still|again|why|help/i;
+        if (frustrationSignals.test(message)) {
+            this.personalityState.frustration = 0.7;
+            // Increase intensity for frustrated users
+            this.personalityState.intensity = Math.min(3, (this.personalityState.intensity + 1));
+        }
+        else {
+            this.personalityState.frustration = 0;
+        }
+        // Detect expertise level from language
+        const expertSignals = /implement|refactor|architecture|pattern|async|stream|bloc|riverpod|inject/i;
+        const beginnerSignals = /how do|what is|can you|please|help me|i don't understand/i;
+        if (expertSignals.test(message)) {
+            this.personalityState.expertise = 'expert';
+            this.personalityState.intensity = Math.max(0, (this.personalityState.intensity - 1));
+        }
+        else if (beginnerSignals.test(message)) {
+            this.personalityState.expertise = 'beginner';
+            this.personalityState.intensity = Math.min(3, (this.personalityState.intensity + 1));
+        }
+    }
+    /**
+     * V15.1: Safety Gates - Run security check on a file after write/edit
+     */
+    async runSecurityCheck(filePath, content, hud) {
+        try {
+            // Announce gate start
+            console.log(jarvis.announceGateStart('security'));
+            const startTime = Date.now();
+            const issues = await this.securityGate.auditFile(content, filePath);
+            const duration = Date.now() - startTime;
+            if (issues.length === 0) {
+                // Gate passed
+                console.log(jarvis.announceGatePass('security', duration));
+                hud.evaluations.Security = 'pass';
+            }
+            else {
+                // Gate found issues
+                const criticalCount = issues.filter(i => i.severity === 'critical').length;
+                const errorCount = issues.filter(i => i.severity === 'error').length;
+                const warningCount = issues.filter(i => i.severity === 'warning').length;
+                if (criticalCount > 0) {
+                    console.log(jarvis.announceGateFail('security', `${criticalCount} critical issues`));
+                    hud.evaluations.Security = 'fail';
+                    // Display critical issues
+                    for (const issue of issues.filter(i => i.severity === 'critical')) {
+                        console.log(`    ${Colors.red}⚠ ${issue.code}: ${issue.message}${Colors.reset}`);
+                        if (issue.line) {
+                            console.log(`      ${Colors.dim}Line ${issue.line}${Colors.reset}`);
+                        }
+                    }
+                }
+                else if (errorCount > 0) {
+                    console.log(jarvis.announceGateFail('security', `${errorCount} errors`));
+                    hud.evaluations.Security = 'fail';
+                }
+                else {
+                    // Only warnings
+                    console.log(jarvis.announceGatePass('security', duration));
+                    hud.evaluations.Security = 'pass';
+                    if (warningCount > 0) {
+                        console.log(`    ${Colors.yellow}${warningCount} warnings${Colors.reset}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail the operation, just log the error
+            console.log(`    ${Colors.dim}Security check skipped: ${error instanceof Error ? error.message : 'unknown error'}${Colors.reset}`);
+        }
+    }
+    // ===========================================================================
+    // UI RENDERING
+    // ===========================================================================
+    renderBanner() {
+        const banner = `
+${Colors.cyan}${Colors.bold}
+    ██████╗  █████╗ ██████╗ ████████╗███╗   ███╗██╗███╗   ██╗██████╗
+    ██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝████╗ ████║██║████╗  ██║██╔══██╗
+    ██║  ██║███████║██████╔╝   ██║   ██╔████╔██║██║██╔██╗ ██║██║  ██║
+    ██║  ██║██╔══██║██╔══██╗   ██║   ██║╚██╔╝██║██║██║╚██╗██║██║  ██║
+    ██████╔╝██║  ██║██║  ██║   ██║   ██║ ╚═╝ ██║██║██║ ╚████║██████╔╝
+    ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═════╝
+${Colors.reset}
+${Colors.dim}                      V17.0 - AI Flutter Developer${Colors.reset}
+`;
+        console.log(banner);
+    }
+    renderStatusBar() {
+        const costPercent = (this.totalCost / this.config.budget) * 100;
+        const costColor = costPercent > 80 ? Colors.red : costPercent > 50 ? Colors.yellow : Colors.green;
+        const modeLabel = planModeController.getModeLabel();
+        const modeSymbol = planModeController.getModeSymbol();
+        const modelShort = this.currentModel.replace('claude-', '').replace(/-\d{8}$/, '');
+        const sessionId = this.session?.id.substring(0, 8) || 'none';
+        console.log(`${Colors.bgBlack}${Colors.white}` +
+            ` ${modeSymbol} ${modeLabel} ` +
+            `${Colors.dim}|${Colors.reset}${Colors.bgBlack} ` +
+            `${Colors.purple}${modelShort}${Colors.reset}${Colors.bgBlack} ` +
+            `${Colors.dim}|${Colors.reset}${Colors.bgBlack} ` +
+            `${costColor}$${this.totalCost.toFixed(4)}${Colors.reset}${Colors.bgBlack}` +
+            `/${Colors.dim}$${this.config.budget.toFixed(2)}${Colors.reset}${Colors.bgBlack} ` +
+            `${Colors.dim}|${Colors.reset}${Colors.bgBlack} ` +
+            `${Colors.gray}session:${sessionId}${Colors.reset}${Colors.bgBlack} ` +
+            `${Colors.reset}`);
+        console.log();
+    }
+    renderUserMessage(message) {
+        console.log();
+        console.log(`${Colors.blue}${Colors.bold}You${Colors.reset}`);
+        console.log(`${Colors.white}${message}${Colors.reset}`);
+        console.log();
+    }
+    renderStreamingStart() {
+        process.stdout.write(`${Colors.purple}${Colors.bold}FlutterAI${Colors.reset}\n`);
+    }
+    finishStreaming() {
+        console.log();
+        console.log();
+    }
+    renderMultilinePrompt() {
+        process.stdout.write(`${Colors.dim}...${Colors.reset} `);
+    }
+    prompt() {
+        const modeIndicator = planModeController.isPlanMode()
+            ? `${Colors.yellow}[PLAN]${Colors.reset} `
+            : planModeController.isAcceptMode()
+                ? `${Colors.green}[AUTO]${Colors.reset} `
+                : '';
+        process.stdout.write(`\n${modeIndicator}${Colors.cyan}>${Colors.reset} `);
+    }
+    // ===========================================================================
+    // UTILITIES
+    // ===========================================================================
+    /**
+     * Prune conversation history when it exceeds limits.
+     * Keeps the first 2 messages (initial context) and the most recent messages.
+     * This prevents unbounded token growth while preserving important context.
+     */
+    pruneConversationHistory() {
+        if (this.conversationHistory.length <= MAX_CONVERSATION_HISTORY) {
+            return;
+        }
+        // Calculate how many messages to remove
+        const targetLength = CONVERSATION_TRIM_TARGET;
+        const keepFromStart = 2; // Keep initial context
+        const keepFromEnd = targetLength - keepFromStart;
+        // Preserve start and end messages
+        const startMessages = this.conversationHistory.slice(0, keepFromStart);
+        const endMessages = this.conversationHistory.slice(-keepFromEnd);
+        // Create summary marker for removed messages
+        const removedCount = this.conversationHistory.length - keepFromStart - keepFromEnd;
+        const summaryMessage = {
+            role: 'user',
+            content: `[${removedCount} earlier messages summarized: conversation continued from previous context]`,
+        };
+        // Rebuild history
+        this.conversationHistory = [...startMessages, summaryMessage, ...endMessages];
+        if (this.verbose) {
+            console.log(`${Colors.dim}[Pruned ${removedCount} old messages to maintain context limit]${Colors.reset}`);
+        }
+    }
+    updateUsage(usage) {
+        this.totalTokens.input += usage.input;
+        this.totalTokens.output += usage.output;
+        // Calculate cost (Claude pricing)
+        const inputCost = (usage.input / 1_000_000) * 3.0;
+        const outputCost = (usage.output / 1_000_000) * 15.0;
+        this.totalCost += inputCost + outputCost;
+    }
+    async getProjectContext() {
+        const msgCount = this.conversationHistory.length;
+        const mcpStatus = this.mcpBridge.isReady() ? 'connected' : 'unavailable';
+        // V16: Include ACTUAL pubspec.yaml contents to prevent hallucination
+        let pubspecInfo = '';
+        const pubspecPath = path.join(this.config.projectRoot, 'pubspec.yaml');
+        try {
+            if (fs.existsSync(pubspecPath)) {
+                const pubspecContent = fs.readFileSync(pubspecPath, 'utf-8');
+                pubspecInfo = `\n\n## ACTUAL pubspec.yaml (DO NOT HALLUCINATE - USE THESE EXACT DEPENDENCIES):\n\`\`\`yaml\n${pubspecContent}\n\`\`\``;
+            }
+        }
+        catch {
+            // Ignore errors reading pubspec
+        }
+        return `Flutter project at ${this.config.projectRoot}. ${msgCount} messages. MCP: ${mcpStatus}.${pubspecInfo}`;
+    }
+    async waitForExit() {
+        return new Promise((resolve) => {
+            const checkExit = setInterval(() => {
+                if (!this.isRunning) {
+                    clearInterval(checkExit);
+                    resolve();
+                }
+            }, 100);
+        });
+    }
+    exit() {
+        console.log('\nGoodbye!\n');
+        this.isRunning = false;
+        this.ui.cleanup();
+        this.mcpBridge.shutdown();
+        process.exit(0);
+    }
+    // ===========================================================================
+    // PUBLIC API
+    // ===========================================================================
+    getSession() {
+        return this.session;
+    }
+    getTodos() {
+        return this.todos;
+    }
+    setTodos(todos) {
+        this.todos = todos;
+    }
+}
+export default InteractiveModeV12;
+//# sourceMappingURL=InteractiveModeV12.js.map