dartmind 17.0.0

package/dist/core/SuperEngine.js

@@ -0,0 +1,953 @@
+/**
+ * FlutterAI Super Engine v8 - Main Engine
+ *
+ * The complete orchestrator that integrates:
+ * - Persona Analysis (honest, critical)
+ * - File Operations (atomic, with backup)
+ * - Terminal UI (Claude Code style)
+ * - State Management (persistent)
+ * - Permission Control
+ * - AI Code Generation
+ */
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import Anthropic from '@anthropic-ai/sdk';
+import { EventEmitter } from 'events';
+import { TerminalUI, Colors, Icons } from '../ui/TerminalUI.js';
+import { StateManager } from '../state/StateManager.js';
+import { PermissionManager } from '../permissions/PermissionManager.js';
+import { FileOperationsEngine } from './FileOperations.js';
+import { PersonaEngine } from '../personas/PersonaEngine.js';
+import { ConsolidatedPersonaEngine } from '../personas/ConsolidatedPersonaEngine.js';
+import { ConfigManager } from '../config/ConfigManager.js';
+import { ClaudeCodeEngine } from '../agentic/ClaudeCodeEngine.js';
+import { CostTracker } from '../context/CostTracker.js';
+import { modelRouter } from '../routing/ModelRouter.js';
+import { personalityEngine } from '../personality/PersonalityEngine.js';
+const C = Colors;
+// ============================================================================
+// Super Engine Class
+// ============================================================================
+export class SuperEngine extends EventEmitter {
+    ui;
+    state;
+    permissions;
+    fileOps;
+    personas;
+    consolidatedPersonas = null;
+    configManager;
+    client = null;
+    // New v8 components
+    claudeCodeEngine = null;
+    costTracker;
+    useToolMode;
+    projectPath;
+    model;
+    maxTokens;
+    isRunning = false;
+    constructor(config) {
+        super();
+        this.projectPath = path.resolve(config.projectPath);
+        this.model = config.model || 'claude-sonnet-4-20250514';
+        this.maxTokens = config.maxTokens || 4096;
+        this.useToolMode = config.useToolMode ?? true; // Default to tool mode
+        // Initialize components
+        this.ui = new TerminalUI();
+        this.state = new StateManager(this.projectPath);
+        this.permissions = new PermissionManager(this.projectPath, this.ui);
+        this.fileOps = new FileOperationsEngine(this.projectPath);
+        this.personas = new PersonaEngine(this.projectPath);
+        this.configManager = new ConfigManager(this.projectPath);
+        // Initialize new v8 components
+        this.costTracker = new CostTracker({ storageDir: '.fai/costs' });
+        // Initialize Anthropic client
+        const apiKey = this.configManager.getApiKey('anthropic');
+        if (apiKey) {
+            this.client = new Anthropic({ apiKey });
+            // Initialize consolidated persona engine (75% fewer API calls)
+            this.consolidatedPersonas = new ConsolidatedPersonaEngine(this.client);
+            // Initialize Claude Code engine for tool mode with FileOperations DI
+            if (this.useToolMode) {
+                this.claudeCodeEngine = new ClaudeCodeEngine({
+                    apiKey,
+                    model: this.model,
+                    maxTokens: this.maxTokens,
+                    projectRoot: this.projectPath,
+                    fileOperations: this.fileOps // Wire FileOperations to tools
+                });
+            }
+        }
+    }
+    // ==========================================================================
+    // INITIALIZATION
+    // ==========================================================================
+    /**
+     * Initialize the engine
+     */
+    async initialize() {
+        await this.fileOps.initialize();
+        await this.detectProject();
+    }
+    /**
+     * Detect and load project info
+     */
+    async detectProject() {
+        const pubspecPath = path.join(this.projectPath, 'pubspec.yaml');
+        if (!fsSync.existsSync(pubspecPath)) {
+            return;
+        }
+        try {
+            const pubspecContent = await fs.readFile(pubspecPath, 'utf-8');
+            const nameMatch = pubspecContent.match(/^name:\s*(.+)$/m);
+            const versionMatch = pubspecContent.match(/^version:\s*(.+)$/m);
+            // Find Dart files
+            const dartFiles = await this.findDartFiles(this.projectPath);
+            this.state.setProject({
+                path: this.projectPath,
+                name: nameMatch?.[1]?.trim() || path.basename(this.projectPath),
+                pubspecPath,
+                dependencies: this.parseDependencies(pubspecContent, 'dependencies'),
+                devDependencies: this.parseDependencies(pubspecContent, 'dev_dependencies'),
+                dartFiles,
+            });
+        }
+        catch (error) {
+            // Ignore errors
+        }
+    }
+    parseDependencies(pubspec, section) {
+        const deps = {};
+        const regex = new RegExp(`${section}:\\s*([\\s\\S]*?)(?=\\n\\w|$)`, 'm');
+        const match = pubspec.match(regex);
+        if (match) {
+            const lines = match[1].split('\n');
+            for (const line of lines) {
+                const depMatch = line.match(/^\s+(\w+):\s*(.+)$/);
+                if (depMatch) {
+                    deps[depMatch[1]] = depMatch[2].trim();
+                }
+            }
+        }
+        return deps;
+    }
+    async findDartFiles(dir, maxFiles = 100) {
+        const files = [];
+        const walk = async (d) => {
+            if (files.length >= maxFiles)
+                return;
+            try {
+                const entries = await fs.readdir(d, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (files.length >= maxFiles)
+                        break;
+                    if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'build') {
+                        continue;
+                    }
+                    const fullPath = path.join(d, entry.name);
+                    if (entry.isDirectory()) {
+                        await walk(fullPath);
+                    }
+                    else if (entry.name.endsWith('.dart')) {
+                        files.push(path.relative(this.projectPath, fullPath));
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        };
+        await walk(dir);
+        return files;
+    }
+    // ==========================================================================
+    // INTERACTIVE MODE
+    // ==========================================================================
+    /**
+     * Start interactive chat mode
+     */
+    async startInteractiveMode() {
+        if (this.isRunning) {
+            this.ui.warning('Interactive mode is already running');
+            return;
+        }
+        this.isRunning = true;
+        this.ui.showBanner();
+        // Show personality banner
+        console.log(personalityEngine.sessionStart(50.00));
+        // Show connection status
+        if (this.client) {
+            this.ui.success('Connected to Claude API');
+        }
+        else {
+            this.ui.warning('No API key configured. Run: /config apikey YOUR_KEY');
+        }
+        // Show project status
+        const project = this.state.getProject();
+        if (project) {
+            this.ui.info(`Project: ${project.name} (${project.dartFiles.length} Dart files)`);
+        }
+        else {
+            this.ui.warning('No Flutter project detected in current directory');
+        }
+        // Show help hint
+        console.log(`\n${C.dim}Type your message or use commands:${C.reset}`);
+        console.log(`${C.cyan}/help${C.reset} - Show all commands`);
+        console.log(`${C.cyan}/quit${C.reset} - Exit FlutterAI\n`);
+        // Main loop
+        await this.runMainLoop();
+    }
+    /**
+     * Main REPL loop
+     */
+    async runMainLoop() {
+        while (this.isRunning) {
+            const input = await this.ui.prompt(`\n${C.green}${Icons.user} You${C.reset} ${C.dim}›${C.reset} `);
+            const trimmed = input.trim();
+            if (!trimmed)
+                continue;
+            // Handle commands
+            if (trimmed.startsWith('/')) {
+                const shouldContinue = await this.handleCommand(trimmed);
+                if (!shouldContinue)
+                    break;
+                continue;
+            }
+            // Handle chat message
+            await this.processUserMessage(trimmed);
+        }
+        // Cleanup
+        await this.state.cleanup();
+        // Show personality session end
+        console.log(personalityEngine.sessionEnd());
+        this.ui.success('Thanks for using FlutterAI! Happy coding!');
+    }
+    // ==========================================================================
+    // COMMAND HANDLING
+    // ==========================================================================
+    /**
+     * Handle slash commands
+     * Returns false if should exit
+     */
+    async handleCommand(input) {
+        const [cmd, ...args] = input.slice(1).split(/\s+/);
+        const arg = args.join(' ');
+        switch (cmd.toLowerCase()) {
+            case 'help':
+            case 'h':
+            case '?':
+                this.showHelp();
+                break;
+            case 'clear':
+            case 'c':
+                this.ui.clear();
+                this.state.clearConversation();
+                this.ui.showBanner();
+                this.ui.success('Conversation cleared');
+                break;
+            case 'check':
+                await this.runCheck();
+                break;
+            case 'persona':
+                if (arg) {
+                    await this.runPersonaCheck(arg);
+                }
+                else {
+                    this.ui.warning('Usage: /persona <file_path>');
+                }
+                break;
+            case 'status':
+            case 's':
+                this.showStatus();
+                break;
+            case 'files':
+            case 'ls':
+                this.listFiles();
+                break;
+            case 'read':
+            case 'r':
+                if (arg) {
+                    await this.readFile(arg);
+                }
+                else {
+                    this.ui.warning('Usage: /read <file_path>');
+                }
+                break;
+            case 'undo':
+                await this.handleUndo(args[0] ? parseInt(args[0]) : 1);
+                break;
+            case 'history':
+                this.showHistory();
+                break;
+            case 'permissions':
+                await this.showPermissions();
+                break;
+            case 'config':
+                if (args[0] === 'apikey' && args[1]) {
+                    this.configManager.setApiKey('anthropic', args[1]);
+                    this.client = new Anthropic({ apiKey: args[1] });
+                    // Initialize consolidated persona engine
+                    this.consolidatedPersonas = new ConsolidatedPersonaEngine(this.client);
+                    // Also update Claude Code engine with FileOperations DI
+                    this.claudeCodeEngine = new ClaudeCodeEngine({
+                        apiKey: args[1],
+                        model: this.model,
+                        maxTokens: this.maxTokens,
+                        projectRoot: this.projectPath,
+                        fileOperations: this.fileOps
+                    });
+                    this.ui.success('API key configured');
+                }
+                else {
+                    this.ui.warning('Usage: /config apikey YOUR_KEY');
+                }
+                break;
+            case 'mode':
+                if (args[0] === 'tools' || args[0] === 'tool') {
+                    this.useToolMode = true;
+                    this.ui.success('Switched to tool mode (Claude Code-style)');
+                }
+                else if (args[0] === 'classic') {
+                    this.useToolMode = false;
+                    this.ui.success('Switched to classic mode (simple generation)');
+                }
+                else {
+                    this.ui.info(`Current mode: ${this.useToolMode ? 'tools' : 'classic'}`);
+                    this.ui.info('Usage: /mode [tools|classic]');
+                }
+                break;
+            case 'tools':
+                this.showTools();
+                break;
+            case 'cost':
+                this.showCost();
+                break;
+            case 'quit':
+            case 'exit':
+            case 'q':
+                this.isRunning = false;
+                return false;
+            case 'model':
+            case 'm':
+                const modelArg = arg?.toLowerCase();
+                if (modelArg === 'haiku' || modelArg === 'sonnet' || modelArg === 'opus') {
+                    modelRouter.setPreference(modelArg);
+                    this.ui.success(`Model preference set to: ${modelArg}`);
+                }
+                else if (modelArg === 'auto') {
+                    modelRouter.setPreference(null);
+                    this.ui.success('Model preference set to: auto (intelligent routing)');
+                }
+                else {
+                    console.log('Usage: /model <haiku|sonnet|opus|auto>');
+                    console.log('  haiku  - Fastest, cheapest (simple tasks)');
+                    console.log('  sonnet - Balanced (default for complex tasks)');
+                    console.log('  opus   - Most capable (when you need the best)');
+                    console.log('  auto   - Intelligent routing based on request');
+                    console.log(`\nCurrent: ${modelRouter.getPreference() || 'auto'}`);
+                }
+                break;
+            case 'personality':
+            case 'sass':
+                const sassArg = arg?.toLowerCase();
+                if (sassArg === 'max' || sassArg === 'maximum') {
+                    personalityEngine.setMode('victory');
+                    console.log('😈 Sass level: MAXIMUM. You asked for this.');
+                }
+                else if (sassArg === 'min' || sassArg === 'minimal') {
+                    personalityEngine.setMode('teaching');
+                    console.log('😇 Sass level: Minimal. I\'ll be on my best behavior. Probably.');
+                }
+                else if (sassArg === 'off') {
+                    personalityEngine.setMode('crisis');
+                    console.log('😐 Sass level: Off. This feels wrong, but okay.');
+                }
+                else {
+                    console.log('Usage: /personality <max|min|off>');
+                    console.log('  max - Full sass mode (recommended)');
+                    console.log('  min - Gentle mode (for sensitive developers)');
+                    console.log('  off - Professional mode (boring)');
+                    console.log(`\nCurrent mode: ${personalityEngine.getMode()}`);
+                }
+                break;
+            default:
+                this.ui.warning(`Unknown command: /${cmd}`);
+                this.ui.info('Type /help for available commands');
+        }
+        return true;
+    }
+    /**
+     * Show help
+     */
+    showHelp() {
+        const help = `
+${C.bold}${C.cyan}Commands:${C.reset}
+
+  ${C.cyan}/help${C.reset}, ${C.cyan}/?${C.reset}           Show this help message
+  ${C.cyan}/clear${C.reset}, ${C.cyan}/c${C.reset}         Clear conversation history
+  ${C.cyan}/check${C.reset}             Run safety checks on project
+  ${C.cyan}/persona <file>${C.reset}    Run all personas on a file
+  ${C.cyan}/status${C.reset}, ${C.cyan}/s${C.reset}        Show project status
+  ${C.cyan}/files${C.reset}, ${C.cyan}/ls${C.reset}        List project files
+  ${C.cyan}/read <file>${C.reset}       Read a file's contents
+  ${C.cyan}/undo [n]${C.reset}          Undo last n operations
+  ${C.cyan}/history${C.reset}           Show command history
+  ${C.cyan}/permissions${C.reset}       Show/manage permissions
+  ${C.cyan}/config apikey KEY${C.reset} Set API key
+  ${C.cyan}/mode [tools|classic]${C.reset} Switch execution mode
+  ${C.cyan}/model [tier]${C.reset}      Set model (haiku/sonnet/opus/auto)
+  ${C.cyan}/personality${C.reset}       Set sass level (max/min/off)
+  ${C.cyan}/tools${C.reset}             Show available tools
+  ${C.cyan}/cost${C.reset}              Show API usage and costs
+  ${C.cyan}/quit${C.reset}, ${C.cyan}/q${C.reset}          Exit FlutterAI
+
+${C.bold}${C.cyan}Modes:${C.reset}
+
+  ${Icons.bullet} ${C.green}tools${C.reset} - Claude Code-style with bash, read, edit, glob, grep, git
+  ${Icons.bullet} ${C.yellow}classic${C.reset} - Simple generation with persona review
+
+${C.bold}${C.cyan}Tips:${C.reset}
+
+  ${Icons.bullet} Type naturally to chat with FlutterAI
+  ${Icons.bullet} In tool mode, FlutterAI can read/write files and run commands
+  ${Icons.bullet} Ask to create widgets, screens, or features
+  ${Icons.bullet} Request code reviews with persona analysis
+`;
+        console.log(help);
+    }
+    /**
+     * Show available tools
+     */
+    showTools() {
+        const tools = [
+            { name: 'bash', desc: 'Execute shell commands (flutter, dart, git, etc.)' },
+            { name: 'read', desc: 'Read file contents with line numbers' },
+            { name: 'write', desc: 'Create or overwrite files' },
+            { name: 'edit', desc: 'Make surgical edits to existing files' },
+            { name: 'glob', desc: 'Find files by pattern (e.g., **/*.dart)' },
+            { name: 'grep', desc: 'Search file contents with regex' },
+            { name: 'git', desc: 'Git operations (status, diff, log, commit)' }
+        ];
+        console.log(`\n${C.bold}Available Tools:${C.reset}`);
+        console.log(`${C.dim}${'─'.repeat(50)}${C.reset}`);
+        for (const tool of tools) {
+            console.log(`  ${C.cyan}${tool.name.padEnd(10)}${C.reset} ${tool.desc}`);
+        }
+        console.log(`\n${C.dim}Mode: ${this.useToolMode ? 'tools (active)' : 'classic'}${C.reset}`);
+    }
+    /**
+     * Show cost tracking
+     */
+    showCost() {
+        const session = this.costTracker.getSessionSummary();
+        const daily = this.costTracker.getPeriodUsage('daily');
+        console.log(`\n${C.bold}API Usage & Costs:${C.reset}`);
+        console.log(`${C.dim}${'─'.repeat(50)}${C.reset}`);
+        console.log(`\n${C.cyan}This Session:${C.reset}`);
+        console.log(`  Input tokens:  ${this.costTracker.formatTokens(session.totalInputTokens)}`);
+        console.log(`  Output tokens: ${this.costTracker.formatTokens(session.totalOutputTokens)}`);
+        console.log(`  Cost:          ${this.costTracker.formatCost(session.totalCost)}`);
+        console.log(`  Operations:    ${session.operationCount}`);
+        console.log(`\n${C.cyan}Today (24h):${C.reset}`);
+        console.log(`  Total cost:    ${this.costTracker.formatCost(daily.totalCost)}`);
+        console.log(`  Operations:    ${daily.recordCount}`);
+    }
+    // ==========================================================================
+    // MESSAGE PROCESSING
+    // ==========================================================================
+    /**
+     * Process user chat message
+     */
+    async processUserMessage(message) {
+        if (!this.client) {
+            this.ui.error('No API key configured. Run: /config apikey YOUR_KEY');
+            return;
+        }
+        // Detect user frustration and adjust personality
+        const { trigger, frustration } = personalityEngine.processInput(message);
+        if (frustration > 0.7) {
+            console.log('\n😤 *Deep breath* I can see you\'re frustrated. Let\'s work through this together.\n');
+        }
+        else if (trigger) {
+            console.log(`${trigger.prefix} ${trigger.responseSuffix || ''}`);
+        }
+        // Add to state
+        this.state.addMessage('user', message);
+        this.state.addToHistory(message);
+        try {
+            // Use tool mode if enabled and available
+            if (this.useToolMode && this.claudeCodeEngine) {
+                await this.processWithToolMode(message);
+                return;
+            }
+            // Fallback to classic mode
+            await this.processClassicMode(message);
+        }
+        catch (error) {
+            this.ui.stopSpinner(false, 'Error');
+            const err = error;
+            if (err.status === 400 && err.message?.includes('credit')) {
+                this.ui.error('Insufficient API credits. Add credits at: https://console.anthropic.com/settings/billing');
+            }
+            else if (err.status === 401) {
+                this.ui.error('Invalid API key. Run: /config apikey YOUR_KEY');
+            }
+            else {
+                this.ui.error(`Error: ${err.message || String(error)}`);
+            }
+        }
+    }
+    /**
+     * Process message with Claude Code-style tool use (streaming)
+     */
+    async processWithToolMode(message) {
+        console.log(`\n${C.cyan}${Icons.ai} FlutterAI${C.reset} ${C.dim}›${C.reset} `);
+        let fullResponse = '';
+        const toolsUsed = [];
+        try {
+            for await (const event of this.claudeCodeEngine.runStream(message)) {
+                switch (event.type) {
+                    case 'text':
+                        process.stdout.write(event.data);
+                        fullResponse += event.data;
+                        break;
+                    case 'tool_start':
+                        console.log(`\n${C.dim}${Icons.execute} Using tool: ${event.data.name}${C.reset}`);
+                        toolsUsed.push(event.data.name);
+                        break;
+                    case 'tool_end':
+                        const status = event.data.success ? C.green + '✓' : C.red + '✗';
+                        console.log(`${C.dim}${status} ${event.data.name} completed${C.reset}`);
+                        if (event.data.output && event.data.output.length > 0) {
+                            const preview = event.data.output.substring(0, 200);
+                            console.log(`${C.dim}  ${preview}${event.data.output.length > 200 ? '...' : ''}${C.reset}`);
+                        }
+                        break;
+                    case 'done':
+                        break;
+                }
+            }
+            console.log(''); // New line after response
+            // Track cost
+            const usage = this.claudeCodeEngine.getUsage();
+            this.costTracker.record(this.model, usage.inputTokens, usage.outputTokens, 'chat');
+            // Show cost summary
+            console.log(`${C.dim}${this.costTracker.getUsageDisplay()}${C.reset}`);
+            // Add to state
+            if (fullResponse) {
+                this.state.addMessage('assistant', fullResponse);
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Process message with classic mode (no tools)
+     */
+    async processClassicMode(message) {
+        // Generate response
+        this.ui.startSpinner('Thinking');
+        const response = await this.generateResponse(message);
+        this.ui.stopSpinner(true, 'Generated');
+        // Handle files if present
+        if (response.files && response.files.length > 0) {
+            // Show generated files
+            for (const file of response.files) {
+                this.ui.showFileOperation(file.operation, file.path, file.content);
+            }
+            // Run persona analysis
+            this.ui.startSpinner('Running persona analysis');
+            const personaResults = await this.runPersonaAnalysisOnFiles(response.files);
+            this.ui.stopSpinner(true, 'Analysis complete');
+            // Show persona results
+            for (const result of personaResults) {
+                this.ui.showPersonaResult(result);
+            }
+            // Check if approved
+            const allApproved = this.checkPersonaApproval(personaResults);
+            if (allApproved) {
+                // Request permission to write
+                const canWrite = await this.permissions.canWriteFiles(response.files.map((f) => ({ path: f.path, operation: f.operation })), `Write ${response.files.length} file(s) to project`);
+                if (canWrite) {
+                    // Write files
+                    this.ui.startSpinner('Writing files');
+                    const writeResult = await this.fileOps.writeFiles(response.files.map((f) => ({ path: f.path, content: f.content })));
+                    if (writeResult.success) {
+                        this.ui.stopSpinner(true, `${writeResult.filesWritten} file(s) written successfully`);
+                    }
+                    else {
+                        this.ui.stopSpinner(false, `Failed: ${writeResult.error}`);
+                    }
+                }
+                else {
+                    this.ui.warning('File write cancelled by user');
+                }
+            }
+            else {
+                this.ui.warning('Persona analysis found issues. Please address concerns before writing.');
+            }
+        }
+        // Show message response
+        if (response.message) {
+            this.ui.showChatMessage('assistant', response.message);
+            this.state.addMessage('assistant', response.message);
+        }
+    }
+    /**
+     * Generate AI response
+     */
+    async generateResponse(userMessage) {
+        if (!this.client) {
+            return { error: 'No API client' };
+        }
+        const systemPrompt = this.buildSystemPrompt();
+        const messages = this.state.getConversationContext().map((m) => ({
+            role: m.role,
+            content: m.content,
+        }));
+        // Route to appropriate model based on request complexity
+        const routing = modelRouter.route(userMessage, { projectType: 'flutter' });
+        console.log(`${C.dim}🎯 Model: ${routing.tier} (${routing.reason})${C.reset}`);
+        const response = await this.client.messages.create({
+            model: routing.model, // Use routed model instead of this.model
+            max_tokens: this.maxTokens,
+            system: [
+                {
+                    type: "text",
+                    text: systemPrompt,
+                    cache_control: { type: "ephemeral" }
+                }
+            ],
+            messages,
+        });
+        // Log savings from model routing
+        const savings = modelRouter.calculateSavings(routing.tier, response.usage.input_tokens);
+        if (savings.savingsPercent > 0) {
+            console.log(`${C.dim}💰 Saved ${savings.savingsPercent.toFixed(0)}% by using ${routing.tier}${C.reset}`);
+        }
+        const content = response.content[0];
+        if (content.type !== 'text') {
+            return { error: 'Unexpected response type' };
+        }
+        // Parse response for file blocks
+        const files = this.parseFilesFromResponse(content.text);
+        const message = this.cleanMessageFromResponse(content.text);
+        return { message, files: files.length > 0 ? files : undefined };
+    }
+    /**
+     * Build system prompt with project context
+     */
+    buildSystemPrompt() {
+        let prompt = `You are FlutterAI, an expert Flutter and Dart development assistant.
+
+Your capabilities:
+- Generate production-quality Flutter code
+- Follow Flutter best practices and clean architecture
+- Create widgets, screens, features, and complete apps
+- Debug and fix Dart code issues
+- Optimize performance and suggest improvements
+
+When generating code files, use this format:
+\`\`\`dart:path/to/file.dart
+// Code content here
+\`\`\`
+
+Guidelines:
+- Use const constructors where possible
+- Follow Material 3 design guidelines
+- Handle null safety properly
+- Add helpful comments for complex logic
+- Include necessary imports`;
+        const project = this.state.getProject();
+        if (project) {
+            prompt += `
+
+Current Project: ${project.name}
+Path: ${project.path}
+Dart Files: ${project.dartFiles.length}
+
+Some project files:
+${project.dartFiles.slice(0, 10).map((f) => `- ${f}`).join('\n')}`;
+        }
+        return prompt;
+    }
+    /**
+     * Parse file blocks from response
+     */
+    parseFilesFromResponse(text) {
+        const files = [];
+        const fileBlockRegex = /```(?:dart)?:([^\n]+)\n([\s\S]*?)```/g;
+        let match;
+        while ((match = fileBlockRegex.exec(text)) !== null) {
+            const filePath = match[1].trim();
+            const content = match[2].trim();
+            const fullPath = path.join(this.projectPath, filePath);
+            const exists = fsSync.existsSync(fullPath);
+            files.push({
+                path: filePath,
+                content,
+                operation: exists ? 'modify' : 'create',
+                exists,
+            });
+        }
+        return files;
+    }
+    /**
+     * Remove file blocks from message
+     */
+    cleanMessageFromResponse(text) {
+        return text
+            .replace(/```(?:dart)?:[^\n]+\n[\s\S]*?```/g, '')
+            .trim();
+    }
+    // ==========================================================================
+    // PERSONA ANALYSIS
+    // ==========================================================================
+    /**
+     * Run all personas on generated files
+     * Uses consolidated engine (1 API call) when available, falls back to original (4 calls)
+     */
+    async runPersonaAnalysisOnFiles(files) {
+        const allCode = files.map((f) => `// File: ${f.path}\n${f.content}`).join('\n\n');
+        // Use consolidated engine if available (75% fewer API calls)
+        if (this.consolidatedPersonas) {
+            const consolidated = await this.consolidatedPersonas.analyze(allCode, {
+                filename: files.map(f => f.path).join(', ')
+            });
+            // Log token savings
+            if (consolidated.tokensSaved > 0) {
+                console.log(`${C.dim}💰 Persona consolidation saved ~${consolidated.tokensSaved} tokens${C.reset}`);
+            }
+            // Convert to PersonaAnalysis format for compatibility with existing UI
+            return this.convertConsolidatedToPersonaAnalysis(consolidated);
+        }
+        // Fallback to original engine (4 separate API calls)
+        return this.personas.runAllPersonas(allCode, {
+            projectPath: this.projectPath,
+            isNewFile: files.some((f) => !f.exists),
+        });
+    }
+    /**
+     * Convert consolidated analysis to PersonaAnalysis[] for UI compatibility
+     */
+    convertConsolidatedToPersonaAnalysis(consolidated) {
+        // Group findings by persona/perspective
+        const byPerspective = new Map();
+        for (const finding of consolidated.findings) {
+            const key = finding.personaName;
+            if (!byPerspective.has(key)) {
+                byPerspective.set(key, {
+                    persona: key,
+                    approved: true,
+                    verdict: 'Pending',
+                    findings: [],
+                    recommendations: [],
+                    checksPerformed: ['Consolidated analysis']
+                });
+            }
+            const analysis = byPerspective.get(key);
+            // Map 'suggestion' to 'info' since PersonaAnalysis doesn't have 'suggestion'
+            const severity = finding.severity === 'suggestion' ? 'info' : finding.severity;
+            analysis.findings.push({
+                severity: severity,
+                type: finding.category,
+                message: finding.message,
+                line: finding.line,
+                suggestion: finding.suggestion
+            });
+            // Mark as not approved if any critical findings
+            if (finding.severity === 'critical') {
+                analysis.approved = false;
+                analysis.verdict = 'Not Approved - Critical issues found';
+            }
+        }
+        // Update verdicts for approved analyses
+        for (const analysis of byPerspective.values()) {
+            if (analysis.approved && analysis.verdict === 'Pending') {
+                analysis.verdict = analysis.findings.length > 0
+                    ? 'Approved with suggestions'
+                    : 'Approved';
+            }
+        }
+        // If no findings, return a single approval
+        if (byPerspective.size === 0) {
+            return [{
+                    persona: 'Consolidated Analysis',
+                    approved: true,
+                    verdict: 'Approved - No issues found',
+                    findings: [],
+                    recommendations: [],
+                    checksPerformed: ['Consolidated analysis']
+                }];
+        }
+        return Array.from(byPerspective.values());
+    }
+    /**
+     * Check if all personas approve
+     */
+    checkPersonaApproval(results) {
+        // Security must approve
+        const securityResult = results.find((r) => r.persona === 'Security Auditor');
+        if (securityResult && !securityResult.approved) {
+            return false;
+        }
+        // Count critical issues across all personas
+        const criticalCount = results.reduce((sum, r) => sum + r.findings.filter((f) => f.severity === 'critical').length, 0);
+        return criticalCount === 0;
+    }
+    /**
+     * Run persona check on a specific file
+     */
+    async runPersonaCheck(filePath) {
+        const fullPath = path.join(this.projectPath, filePath);
+        if (!fsSync.existsSync(fullPath)) {
+            this.ui.error(`File not found: ${filePath}`);
+            return;
+        }
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            this.ui.startSpinner('Running persona analysis');
+            const results = await this.personas.runAllPersonas(content, {
+                filePath,
+                projectPath: this.projectPath,
+            });
+            this.ui.stopSpinner(true, 'Analysis complete');
+            for (const result of results) {
+                this.ui.showPersonaResult(result);
+            }
+        }
+        catch (error) {
+            this.ui.error(`Error reading file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // ==========================================================================
+    // UTILITY COMMANDS
+    // ==========================================================================
+    /**
+     * Run project checks
+     */
+    async runCheck() {
+        const project = this.state.getProject();
+        if (!project) {
+            this.ui.warning('No Flutter project detected');
+            return;
+        }
+        this.ui.info(`Checking project: ${project.name}`);
+        this.ui.info(`Dart files: ${project.dartFiles.length}`);
+        this.ui.info(`Dependencies: ${Object.keys(project.dependencies).length}`);
+        // Would integrate with SafetyPipeline here
+        this.ui.success('Project structure looks good');
+    }
+    /**
+     * Show status
+     */
+    showStatus() {
+        const project = this.state.getProject();
+        const session = this.costTracker.getSessionSummary();
+        console.log(`\n${C.bold}Session Status:${C.reset}`);
+        console.log(`${C.dim}${'─'.repeat(40)}${C.reset}`);
+        if (project) {
+            console.log(`${Icons.folder} Project: ${C.cyan}${project.name}${C.reset}`);
+            console.log(`${Icons.file} Files: ${project.dartFiles.length} Dart files`);
+        }
+        else {
+            console.log(`${C.yellow}No project loaded${C.reset}`);
+        }
+        console.log(`${Icons.ai} API: ${this.client ? `${C.green}Connected${C.reset}` : `${C.red}Not configured${C.reset}`}`);
+        console.log(`${Icons.execute} Mode: ${this.useToolMode ? `${C.green}tools${C.reset}` : `${C.yellow}classic${C.reset}`}`);
+        console.log(`${Icons.think} Messages: ${this.state.getMessageCount()}`);
+        console.log(`${Icons.warning} Cost: ${this.costTracker.formatCost(session.totalCost)}`);
+        console.log(`${C.dim}${'─'.repeat(40)}${C.reset}\n`);
+    }
+    /**
+     * List project files
+     */
+    listFiles() {
+        const project = this.state.getProject();
+        if (!project) {
+            this.ui.warning('No Flutter project detected');
+            return;
+        }
+        console.log(`\n${C.bold}Project Files:${C.reset}`);
+        console.log(`${C.dim}${'─'.repeat(40)}${C.reset}`);
+        for (const file of project.dartFiles.slice(0, 25)) {
+            console.log(`  ${C.cyan}${file}${C.reset}`);
+        }
+        if (project.dartFiles.length > 25) {
+            console.log(`  ${C.dim}... and ${project.dartFiles.length - 25} more${C.reset}`);
+        }
+    }
+    /**
+     * Read and display a file
+     */
+    async readFile(filePath) {
+        const fullPath = path.join(this.projectPath, filePath);
+        if (!fsSync.existsSync(fullPath)) {
+            this.ui.error(`File not found: ${filePath}`);
+            return;
+        }
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            this.ui.showFileOperation('modify', filePath, content);
+        }
+        catch (error) {
+            this.ui.error(`Error reading file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Handle undo
+     */
+    async handleUndo(count) {
+        const undone = await this.fileOps.undoLast(count);
+        if (undone > 0) {
+            this.ui.success(`Undone ${undone} operation(s)`);
+        }
+        else {
+            this.ui.warning('Nothing to undo');
+        }
+    }
+    /**
+     * Show command history
+     */
+    showHistory() {
+        const history = this.state.getHistory();
+        if (history.length === 0) {
+            this.ui.info('No command history');
+            return;
+        }
+        console.log(`\n${C.bold}Command History:${C.reset}`);
+        console.log(`${C.dim}${'─'.repeat(40)}${C.reset}`);
+        history.slice(-20).forEach((cmd, i) => {
+            console.log(`  ${C.dim}${i + 1}.${C.reset} ${cmd}`);
+        });
+    }
+    /**
+     * Show permissions
+     */
+    async showPermissions() {
+        const config = this.permissions.getConfig();
+        this.ui.showTable({
+            title: 'Permission Settings',
+            headers: ['Action', 'Level'],
+            rows: Object.entries(config).map(([action, level]) => [
+                action,
+                level === 'allow' ? `${C.green}${level}${C.reset}` :
+                    level === 'deny' ? `${C.red}${level}${C.reset}` :
+                        `${C.yellow}${level}${C.reset}`,
+            ]),
+        });
+    }
+    // ==========================================================================
+    // CLEANUP
+    // ==========================================================================
+    /**
+     * Stop the engine
+     */
+    async stop() {
+        this.isRunning = false;
+        await this.state.cleanup();
+    }
+}
+export default SuperEngine;
+//# sourceMappingURL=SuperEngine.js.map