camo-cli 2.0.1

package/dist/agent.js

@@ -0,0 +1,977 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+import { createPatch, parsePatch, applyPatch } from 'diff';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { JSDOM } from 'jsdom';
+import { Readability } from '@mozilla/readability';
+import TurndownService from 'turndown';
+import { config } from './config/store.js';
+import { PermissionManager } from './utils/PermissionManager.js';
+import { SessionManager } from './utils/SessionManager.js';
+import { DecisionLogger } from './utils/DecisionLogger.js';
+import { SHELL_TIMEOUT_MS } from './config/constants.js';
+import { runAgentLoop } from './core/AgentLoop.js';
+const execAsync = promisify(exec);
+// Context Helpers (Managed here but used in PermissionManager via pass-through)
+let lastUserMessage = '';
+let projectContextCache = '';
+// Singletons for MVP features
+const sessionManager = SessionManager.getInstance();
+const decisionLogger = DecisionLogger.getInstance();
+let criticAgent = null;
+let activePlan = [];
+// Helper to generate hash ID from title + scope
+function generateTaskId(title, scope = 'global') {
+    const input = title + ":" + scope;
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(16).substring(0, 6);
+}
+// Tool Output Buffer
+// Tool Output Buffer
+class ToolOutputBuffer {
+    constructor(callbacks, maxChars = 8000) {
+        this.buffer = '';
+        this.lineBuffer = '';
+        this.callbacks = callbacks;
+        this.maxChars = maxChars;
+    }
+    append(data) {
+        this.buffer += data;
+        this.lineBuffer += data;
+        let newlineIndex;
+        while ((newlineIndex = this.lineBuffer.indexOf('\n')) !== -1) {
+            const line = this.lineBuffer.substring(0, newlineIndex).trim();
+            this.lineBuffer = this.lineBuffer.substring(newlineIndex + 1);
+            if (line.length > 0) {
+                this.callbacks.onChunk(`\n[BUFFER_LINE]${line}[/BUFFER_LINE]\n`);
+            }
+        }
+    }
+    getOutput() {
+        // Flush remaining line buffer
+        if (this.lineBuffer.trim().length > 0) {
+            this.callbacks.onChunk(`\n[BUFFER_LINE]${this.lineBuffer.trim()}[/BUFFER_LINE]\n`);
+        }
+        if (this.buffer.length <= this.maxChars) {
+            return this.buffer;
+        }
+        const keep = Math.floor(this.maxChars * 0.4);
+        const head = this.buffer.substring(0, keep);
+        const tail = this.buffer.substring(this.buffer.length - keep);
+        const skipped = this.buffer.length - (keep * 2);
+        return `${head}\n... [Output truncated (${skipped} chars)] ...\n${tail}`;
+    }
+}
+export async function initializeAgentContext() {
+    try {
+        const contextParts = [];
+        const cwd = process.cwd();
+        // 1. Scan package.json
+        try {
+            const pkgPath = path.join(cwd, 'package.json');
+            const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(pkgContent);
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            const importantTech = Object.keys(deps).filter(d => ['react', 'vue', 'next', 'vite', 'typescript', 'tailwindcss', 'ink', 'zod', 'express', 'nest', 'ai-sdk'].some(t => d.includes(t)));
+            if (importantTech.length > 0) {
+                contextParts.push(`**PROJEKT TECH STACK**:\n- Dependencies: ${importantTech.join(', ')}`);
+            }
+        }
+        catch (e) { }
+        // 2. Scan Directory Structure (Depth 2)
+        try {
+            const getDirStructure = async (dir, depth) => {
+                if (depth > 2)
+                    return [];
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                const lines = [];
+                for (const entry of entries) {
+                    if (['node_modules', '.git', '.DS_Store', 'dist', 'build', '.next'].includes(entry.name))
+                        continue;
+                    if (entry.isDirectory()) {
+                        lines.push(`${'  '.repeat(2 - depth)}/${entry.name}`);
+                        const subLines = await getDirStructure(path.join(dir, entry.name), depth + 1);
+                        lines.push(...subLines);
+                    }
+                    else {
+                        lines.push(`${'  '.repeat(2 - depth)}${entry.name}`);
+                    }
+                }
+                return lines;
+            };
+            const structure = await getDirStructure(cwd, 1);
+            if (structure.length > 0) {
+                contextParts.push(`**DATEI STRUKTUR (Auszug)**:\n${structure.slice(0, 30).join('\n')}${structure.length > 30 ? '\n...(truncated)' : ''}`);
+            }
+        }
+        catch (e) { }
+        if (contextParts.length > 0) {
+            projectContextCache = `\n\n**AUTOMATISCHE PROJEKT ANALYSE**:\n${contextParts.join('\n\n')}\n`;
+        }
+    }
+    catch (error) { }
+}
+// Google tools with correct format
+// Google tools defined in src/tools/ToolDefinitions.ts
+// Tool implementations
+const toolImplementations = {
+    async readFile(args, callbacks) {
+        try {
+            const p = path.resolve(process.cwd(), args.path);
+            const content = await fs.readFile(p, 'utf-8');
+            const lines = content.split('\n');
+            callbacks.onChunk(`\n[TOOL_STATUS]Read ${lines.length} lines from ${args.path}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ content: content.slice(0, 8000) });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async writeFile(args, callbacks) {
+        const p = path.resolve(process.cwd(), args.path);
+        let diff = '';
+        try {
+            const existingContent = await fs.readFile(p, 'utf-8');
+            diff = createPatch(args.path, existingContent, args.content);
+        }
+        catch (e) {
+            diff = createPatch(args.path, '', args.content);
+        }
+        // Permission Check
+        const allowed = await PermissionManager.getInstance().validate('FILE_WRITE', {
+            path: args.path,
+            diff: diff
+        }, callbacks);
+        if (!allowed) {
+            return JSON.stringify({ error: 'User denied file write.' });
+        }
+        try {
+            await fs.writeFile(p, args.content, 'utf-8');
+            callbacks.onChunk(`\n[TOOL_STATUS][ok] File written: ${args.path}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ success: true, path: args.path });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async listFiles(args, callbacks) {
+        try {
+            const p = path.resolve(process.cwd(), args.path || '.');
+            const files = await fs.readdir(p);
+            const clean = files.filter(f => !['node_modules', '.git', '.DS_Store'].includes(f));
+            const output = clean.slice(0, 10).join(', ') + (clean.length > 10 ? '...' : '');
+            callbacks.onChunk(`\n[TOOL_STATUS]Files: ${output}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ files: clean });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async executeShellCommand(args, callbacks) {
+        // Permission Check
+        const allowed = await PermissionManager.getInstance().validate('SHELL', {
+            command: args.command
+        }, callbacks);
+        if (!allowed) {
+            return JSON.stringify({ error: 'User denied command execution.' });
+        }
+        // Execute with output display
+        try {
+            const { stdout, stderr } = await execAsync(args.command, {
+                cwd: process.cwd(),
+                timeout: SHELL_TIMEOUT_MS
+            });
+            const output = stdout + (stderr ? '\n' + stderr : '');
+            const preview = output.trim().slice(0, 200);
+            if (preview.length > 0) {
+                callbacks.onChunk(`\n[TOOL_STATUS]${preview}${output.length > 200 ? '...' : ''}[/TOOL_STATUS]\n`);
+            }
+            else {
+                callbacks.onChunk(`\n[TOOL_STATUS][ok] Command executed[/TOOL_STATUS]\n`);
+            }
+            return JSON.stringify({ exitCode: 0, output: output.slice(0, 2000) });
+        }
+        catch (e) {
+            const errorMsg = e.stderr || e.message;
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${errorMsg.slice(0, 200)}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ exitCode: e.code || 1, error: errorMsg });
+        }
+    },
+    async grep(args, callbacks) {
+        try {
+            const searchPath = args.path || '.';
+            const command = `grep -rIn "${args.pattern.replace(/"/g, '\\"')}" ${searchPath} | head -n 20`;
+            const { stdout } = await execAsync(command);
+            const output = stdout.trim();
+            if (!output) {
+                const findCmd = `find ${searchPath} -name "*${args.pattern}*" -not -path "*/node_modules/*" | head -n 5`;
+                const { stdout: findOut } = await execAsync(findCmd);
+                if (findOut.trim()) {
+                    const files = findOut.trim().split('\n');
+                    const msg = files.map(f => `[BUFFER_LINE]Found: ${f}[/BUFFER_LINE]`).join('\n');
+                    callbacks.onChunk(`\n${msg}\n`);
+                    return JSON.stringify({ files: files });
+                }
+                callbacks.onChunk(`\n[TOOL_STATUS]No matches found for "${args.pattern}"[/TOOL_STATUS]\n`);
+                return JSON.stringify({ results: [] });
+            }
+            callbacks.onChunk(`\n[BUFFER_LINE]${output.split('\n').slice(0, 3).join('\n')}[/BUFFER_LINE]\n[TOOL_STATUS]Grep complete (${output.split('\n').length} lines)[/TOOL_STATUS]\n`);
+            return JSON.stringify({ results: output });
+        }
+        catch (e) {
+            if (e.code === 1) {
+                callbacks.onChunk(`\n[TOOL_OUTPUT]No matches found[/TOOL_OUTPUT]\n`);
+                return JSON.stringify({ results: [] });
+            }
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async editFile(args, callbacks) {
+        const p = path.resolve(process.cwd(), args.path);
+        try {
+            // Read current file content
+            const originalContent = await fs.readFile(p, 'utf-8');
+            // Parse the unified diff
+            const patches = parsePatch(args.unifiedDiff);
+            if (patches.length === 0) {
+                callbacks.onChunk(`\n[TOOL_STATUS]Error: Invalid unified diff format[/TOOL_STATUS]\n`);
+                return JSON.stringify({ error: 'Invalid unified diff format' });
+            }
+            // Apply patch with strict matching (no fuzzy match)
+            const patchResult = applyPatch(originalContent, patches[0], { fuzzFactor: 0 });
+            if (patchResult === false) {
+                callbacks.onChunk(`\n[TOOL_STATUS]Error: Diff context mismatch. Re-read file with readFile first.[/TOOL_STATUS]\n`);
+                return JSON.stringify({
+                    error: 'Diff context mismatch. The file content does not match the expected context. Use readFile to get current state.'
+                });
+            }
+            const newContent = patchResult;
+            // Generate visual diff for HITL
+            const visualDiff = createPatch(args.path, originalContent, newContent);
+            // Permission Check with diff preview
+            const allowed = await PermissionManager.getInstance().validate('FILE_WRITE', {
+                path: args.path,
+                diff: visualDiff
+            }, callbacks);
+            if (!allowed)
+                return JSON.stringify({ error: 'Denied' });
+            // Apply changes
+            await fs.writeFile(p, newContent, 'utf-8');
+            callbacks.onChunk(`\n[TOOL_STATUS][ok] Patch applied to ${args.path}[/TOOL_STATUS]\n`);
+            // Auto-lint for TS/JS files
+            if (/\.(ts|tsx|js|jsx)$/.test(args.path)) {
+                const lintResult = await toolImplementations.autoLint({ path: args.path, fix: false }, callbacks);
+                const parsed = JSON.parse(lintResult);
+                if (!parsed.success && parsed.errors) {
+                    return JSON.stringify({
+                        success: true,
+                        path: args.path,
+                        lintErrors: parsed.errors
+                    });
+                }
+            }
+            return JSON.stringify({ success: true, path: args.path });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_STATUS]Error: ${e.message}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async ToDoWrite(args, callbacks) {
+        const { action, taskId, title, scope } = args;
+        if (action === 'create') {
+            if (!title)
+                return JSON.stringify({ error: 'Title required' });
+            const taskScope = scope || 'global';
+            const id = generateTaskId(title, taskScope);
+            activePlan.push({ id, title, scope: taskScope, status: 'pending' });
+            callbacks.onChunk(`\n[PLAN_DELTA]+ New Task: ${title} (${id}) [${taskScope}][/PLAN_DELTA]\n`);
+            return JSON.stringify({ success: true, id });
+        }
+        if (action === 'update') {
+            const task = activePlan.find(t => t.id === taskId);
+            if (!task)
+                return JSON.stringify({ error: 'Task not found' });
+            const running = activePlan.find(t => t.status === 'in_progress');
+            if (running && running.id !== taskId)
+                return JSON.stringify({ error: `Task ${running.id} is already in_progress` });
+            task.status = 'in_progress';
+            // Silent update for STATE SYNC (no chatty output if possible, but delta is useful for UI)
+            callbacks.onChunk(`\n[PLAN_DELTA]→ Started: ${task.title}[/PLAN_DELTA]\n`);
+            return JSON.stringify({ success: true });
+        }
+        if (action === 'complete') {
+            const task = activePlan.find(t => t.id === taskId);
+            if (!task)
+                return JSON.stringify({ error: 'Task not found' });
+            task.status = 'completed';
+            callbacks.onChunk(`\n[PLAN_DELTA]✓ Completed: ${task.title}[/PLAN_DELTA]\n`);
+            // Check if all tasks are done
+            const allDone = activePlan.every(t => t.status === 'completed' || t.status === 'failed');
+            if (allDone && activePlan.length > 0) {
+                const completed = activePlan.filter(t => t.status === 'completed');
+                const failed = activePlan.filter(t => t.status === 'failed');
+                let summary = `\n⏺ Plan Summary:\n`;
+                summary += `  ✓ ${completed.length} completed`;
+                if (failed.length > 0)
+                    summary += `, ✗ ${failed.length} failed`;
+                summary += `\n`;
+                completed.forEach(t => summary += `  • ${t.title}\n`);
+                callbacks.onChunk(summary);
+                // Clear plan for next task
+                activePlan.length = 0;
+            }
+            return JSON.stringify({ success: true });
+        }
+        if (action === 'fail') {
+            const task = activePlan.find(t => t.id === taskId);
+            if (!task)
+                return JSON.stringify({ error: 'Task not found' });
+            task.status = 'failed';
+            callbacks.onChunk(`\n[PLAN_DELTA][x] Failed: ${task.title}[/PLAN_DELTA]\n`);
+            return JSON.stringify({ success: true });
+        }
+        return JSON.stringify({ error: 'Invalid action' });
+    },
+    async webFetch(args, callbacks) {
+        const url = args.url;
+        const allowed = await PermissionManager.getInstance().validate('WEB_ACCESS', {
+            url: url,
+            userMessage: lastUserMessage,
+            projectContext: projectContextCache
+        }, callbacks);
+        if (!allowed) {
+            return JSON.stringify({ error: 'User denied web access.' });
+        }
+        try {
+            callbacks.onChunk(`\n[TOOL_STATUS]Fetching ${url}...[/TOOL_STATUS]`);
+            const response = await fetch(url);
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status} ${response.statusText}`);
+            const html = await response.text();
+            const doc = new JSDOM(html, { url });
+            const reader = new Readability(doc.window.document);
+            const article = reader.parse();
+            if (!article)
+                return JSON.stringify({ error: 'Failed to parse page content.' });
+            const turndownService = new TurndownService({ headingStyle: 'atx', codeBlockStyle: 'fenced' });
+            const markdown = turndownService.turndown(article.content || '');
+            callbacks.onChunk(`\n[TOOL_STATUS][ok] Fetched and converted to Markdown.[/TOOL_STATUS]\n`);
+            return JSON.stringify({ title: article.title, content: markdown.slice(0, 15000) });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async internal_thought(args, callbacks) {
+        callbacks.onChunk(`\n[INTERNAL_THOUGHT]${args.analysis}[/INTERNAL_THOUGHT]\n`);
+        return JSON.stringify({ acknowledged: true });
+    },
+    async listSymbols(args, callbacks) {
+        try {
+            const filePath = path.resolve(process.cwd(), args.path);
+            const sourceCode = await fs.readFile(filePath, 'utf-8');
+            const ts = await import('typescript');
+            const sourceFile = ts.createSourceFile(args.path, sourceCode, ts.ScriptTarget.Latest, true);
+            const symbols = [];
+            function visit(node) {
+                const filter = args.symbolType || 'all';
+                if ((filter === 'all' || filter === 'functions') && ts.isFunctionDeclaration(node) && node.name) {
+                    symbols.push({
+                        type: 'function',
+                        name: node.name.text,
+                        signature: node.getText().split('{')[0].trim(),
+                        line: sourceFile.getLineAndCharacterOfPosition(node.pos).line + 1
+                    });
+                }
+                if ((filter === 'all' || filter === 'classes') && ts.isClassDeclaration(node) && node.name) {
+                    symbols.push({
+                        type: 'class',
+                        name: node.name.text,
+                        methods: node.members.filter((m) => ts.isMethodDeclaration(m)).map((m) => m.name?.getText()),
+                        line: sourceFile.getLineAndCharacterOfPosition(node.pos).line + 1
+                    });
+                }
+                if ((filter === 'all' || filter === 'interfaces') && ts.isInterfaceDeclaration(node)) {
+                    symbols.push({
+                        type: 'interface',
+                        name: node.name.text,
+                        properties: node.members.map((m) => m.name?.getText()).filter(Boolean),
+                        line: sourceFile.getLineAndCharacterOfPosition(node.pos).line + 1
+                    });
+                }
+                ts.forEachChild(node, visit);
+            }
+            visit(sourceFile);
+            callbacks.onChunk(`\n[TOOL_STATUS]Found ${symbols.length} symbols in ${args.path}[/TOOL_STATUS]\n`);
+            return JSON.stringify({ symbols, count: symbols.length });
+        }
+        catch (e) {
+            callbacks.onChunk(`\n[TOOL_OUTPUT]Error: ${e.message}[/TOOL_OUTPUT]\n`);
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async autoLint(args, callbacks) {
+        try {
+            const util = await import('util');
+            const execAsync = util.promisify(exec);
+            const targetPath = path.resolve(process.cwd(), args.path);
+            const errors = [];
+            callbacks.onChunk(`\n[TOOL_STATUS]Linting ${args.path}...[/TOOL_STATUS]\n`);
+            // TypeScript check
+            try {
+                await execAsync(`npx tsc --noEmit ${targetPath}`, { cwd: process.cwd() });
+            }
+            catch (e) {
+                if (e.stderr)
+                    errors.push(`[TypeScript]\n${e.stderr.slice(0, 1000)}`);
+            }
+            // ESLint check
+            const eslintCmd = args.fix ? `npx eslint ${targetPath} --fix` : `npx eslint ${targetPath}`;
+            try {
+                await execAsync(eslintCmd, { cwd: process.cwd() });
+            }
+            catch (e) {
+                if (e.stdout)
+                    errors.push(`[ESLint]\n${e.stdout.slice(0, 1000)}`);
+            }
+            if (errors.length === 0) {
+                callbacks.onChunk(`\n[TOOL_STATUS][ok] No lint errors[/TOOL_STATUS]\n`);
+                return JSON.stringify({ success: true, errors: [] });
+            }
+            else {
+                const summary = errors.join('\n\n');
+                callbacks.onChunk(`\n[TOOL_OUTPUT]${summary.slice(0, 500)}[/TOOL_OUTPUT]\n`);
+                return JSON.stringify({ success: false, errors: summary });
+            }
+        }
+        catch (e) {
+            return JSON.stringify({ error: e.message });
+        }
+    },
+    async verifyChange(args, callbacks) {
+        try {
+            const util = await import('util');
+            const execAsync = util.promisify(exec);
+            const fileName = path.basename(args.changedFile, path.extname(args.changedFile));
+            callbacks.onChunk(`\n[TOOL_STATUS]Searching for tests for ${fileName}...[/TOOL_STATUS]\n`);
+            // Find test files
+            const patterns = args.testPattern
+                ? [args.testPattern]
+                : [`${fileName}.test.*`, `${fileName}.spec.*`, `__tests__/${fileName}*`];
+            const foundTests = [];
+            for (const pattern of patterns) {
+                try {
+                    const { stdout } = await execAsync(`find . -name "${pattern}" -not -path "*/node_modules/*"`);
+                    foundTests.push(...stdout.trim().split('\n').filter(f => f.length > 0));
+                }
+                catch (e) { /* Pattern not found */ }
+            }
+            if (foundTests.length === 0) {
+                callbacks.onChunk(`\n[TOOL_STATUS]No tests found for ${fileName}[/TOOL_STATUS]\n`);
+                return JSON.stringify({ testsFound: 0, message: 'No related tests' });
+            }
+            callbacks.onChunk(`\n[TOOL_STATUS]Found ${foundTests.length} test(s), running...[/TOOL_STATUS]\n`);
+            // Execute tests
+            const testResults = [];
+            for (const testFile of foundTests) {
+                try {
+                    const { stdout } = await execAsync(`npm test -- ${testFile}`, {
+                        cwd: process.cwd(),
+                        timeout: 30000
+                    });
+                    testResults.push({ file: testFile, status: 'PASS', output: stdout });
+                    callbacks.onChunk(`\n[TOOL_STATUS][ok] ${testFile} passed[/TOOL_STATUS]\n`);
+                }
+                catch (e) {
+                    testResults.push({ file: testFile, status: 'FAIL', output: e.stderr || e.stdout });
+                    callbacks.onChunk(`\n[TOOL_STATUS][x] ${testFile} failed[/TOOL_STATUS]\n`);
+                }
+            }
+            const passed = testResults.filter(r => r.status === 'PASS').length;
+            const failed = testResults.filter(r => r.status === 'FAIL').length;
+            return JSON.stringify({
+                testsFound: foundTests.length,
+                passed,
+                failed,
+                results: testResults
+            });
+        }
+        catch (e) {
+            return JSON.stringify({ error: e.message });
+        }
+    }
+};
+// Google-specific agent
+async function runGoogleAgent(userMessage, history, googleKey, callbacks) {
+    await runAgentLoop({
+        userMessage,
+        history,
+        googleKey,
+        activePlan,
+        projectContextCache,
+        sessionManager,
+        decisionLogger,
+        criticAgent
+    }, callbacks);
+    return; /*
+  
+    const MAX_LOOPS = 15;
+    let loopCount = 0;
+    let taskComplete = false;
+  
+    try {
+      const client = new GoogleGenerativeAI(googleKey);
+      const model = client.getGenerativeModel({
+        model: 'gemini-2.0-flash',
+        tools: [{ functionDeclarations: googleToolDefinitions as any }]
+      });
+  
+      let planContext = "";
+      if (activePlan.length > 0) {
+        planContext = `\n**AKTUELLER PLAN**:\n${activePlan.map(t => `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '/' : ' '}] ${t.title} (${t.id})`).join('\n')}\n`;
+      }
+  
+      const contents: any[] = history.map(msg => ({
+        role: msg.role === 'user' ? 'user' : 'model',
+        parts: [{ text: msg.content }]
+      })).concat([{
+        role: 'user',
+        parts: [{ text: userMessage + planContext }]
+      }]);
+  
+      const systemInstruction = ELITE_SYSTEM_PROMPT
+        .replace('{{PROJECT_CONTEXT}}', projectContextCache)
+        .replace('{{TASK_STATE}}', TaskState.getContextString());
+  
+      // Track tools used in this loop for critic validation
+      const toolsUsedInLoop: string[] = [];
+  
+      // Recursive Agentic Loop (n0 Pattern) - wrapped in try-catch
+      try {
+        while (loopCount < MAX_LOOPS && !taskComplete) {
+          loopCount++;
+  
+          // Validate contents has at least one message
+          if (contents.length === 0) {
+            onChunk('\n[done]\n');
+            break;
+          }
+  
+          // Validate each content has non-empty parts
+          const validContents = contents.filter(c => {
+            if (!c.parts || c.parts.length === 0) return false;
+            if (c.parts[0]?.text === '' && !c.parts[0]?.functionResponse) return false;
+            return true;
+          });
+  
+          if (validContents.length === 0) {
+            onChunk('\n[done]\n');
+            break;
+          }
+  
+          let response;
+          try {
+            response = await model.generateContent({
+              contents: validContents,
+              systemInstruction: systemInstruction
+            });
+          } catch (e: any) {
+            // Handle empty model output or any API errors
+            if (e.message && (e.message.includes('empty') || e.message.includes('output text or tool calls'))) {
+              onChunk('\n[done]\n');
+              break;
+            }
+            // For other errors, show error and break
+            onChunk(`\n[error] ${e.message}\n`);
+            break;
+          }
+  
+          const responseText = response.response.text() || '';
+          const toolCalls = response.response.functionCalls?.();
+  
+          // Exit 1: Task complete marker - WITH SELF-REFLECTION
+          if (responseText.includes('[TASK_COMPLETE]')) {
+            const cleanText = responseText.replace('[TASK_COMPLETE]', '').trim();
+  
+            // SELF-REFLECTION: Validate completion
+            if (criticAgent && toolsUsedInLoop.length > 0) {
+              try {
+                const criticResult = await criticAgent.validate(
+                  lastUserMessage,
+                  cleanText || 'Task marked complete',
+                  toolsUsedInLoop
+                );
+  
+                // Log the verification
+                const session = sessionManager.getCurrentSession();
+                if (session) {
+                  await decisionLogger.logVerification(
+                    session.sessionId,
+                    'Task completion',
+                    'Critic validation',
+                    criticResult.isValid ? 'Valid' : `Invalid: ${criticResult.reasoning}`
+                  );
+                }
+  
+                // If critic says invalid, continue working
+                if (!criticResult.isValid) {
+                  onChunk(`\n[reflection] ${criticResult.reasoning}\n`);
+                  if (criticResult.suggestions && criticResult.suggestions.length > 0) {
+                    const suggestion = criticResult.suggestions[0];
+                    contents.push({ role: 'model', parts: [{ text: responseText }] });
+                    contents.push({
+                      role: 'user',
+                      parts: [{ text: `The task is not complete. ${suggestion}` }]
+                    });
+                    continue;
+                  }
+                }
+              } catch (e) {
+                // Critic failed, proceed anyway
+              }
+            }
+  
+            taskComplete = true;
+            if (cleanText.length > 0) {
+              onChunk(cleanText);
+            }
+            onChunk('\n[done]\n');
+            break;
+          }
+  
+          // Exit 2: Explicit user intervention request or plan ready
+          if (responseText.includes('[ASK_USER]') || responseText.includes('[PLAN_READY]')) {
+            const cleanText = responseText
+              .replace('[ASK_USER]', '')
+              .replace('[PLAN_READY]', '')
+              .trim();
+            if (cleanText.length > 0) {
+              onChunk(cleanText);
+            }
+            break;
+          }
+  
+          // No tool calls - output text and end
+          if (!toolCalls || toolCalls.length === 0) {
+            if (responseText.trim().length > 0) {
+              onChunk(responseText);
+            }
+            onChunk('\n[done]\n');
+            break;
+          }
+  
+          // Execute tools and collect results
+          const toolResults: any[] = [];
+  
+          for (const call of toolCalls) {
+            const toolName = call.name;
+            const toolArgs = call.args;
+  
+            if (toolName in toolImplementations) {
+              // Log decision for observability
+              const session = sessionManager.getCurrentSession();
+              if (session) {
+                await decisionLogger.logToolChoice(
+                  session.sessionId,
+                  `User: "${lastUserMessage}"`,
+                  toolName,
+                  `Chose ${toolName} to accomplish the task`,
+                  Object.keys(toolImplementations).filter(t => t !== toolName).slice(0, 3)
+                );
+              }
+  
+              // Display tool execution with bullet
+              let toolDisplay = `⏺ ${toolName}`;
+              const args = toolArgs as any;
+              if (args.path) toolDisplay += ` (${args.path})`;
+              if (args.pattern) toolDisplay += ` ("${args.pattern}")`;
+              if (args.command) toolDisplay += ` (${args.command.slice(0, 40)}${args.command.length > 40 ? '...' : ''})`;
+  
+              if (toolName !== 'ToDoWrite' && toolName !== 'internal_thought') {
+                onChunk(`\n${toolDisplay}\n`);
+              }
+  
+              // Execute and capture result
+              const result = await toolImplementations[toolName](toolArgs, callbacks);
+  
+              // Track tool usage for critic
+              toolsUsedInLoop.push(toolName);
+  
+              // Update session metadata
+              if (session) {
+                sessionManager.updateMetadata({
+                  toolsUsed: [...new Set([...(session.metadata.toolsUsed || []), toolName])]
+                });
+              }
+  
+              toolResults.push({
+                functionResponse: {
+                  name: toolName,
+                  response: { result: result }
+                }
+              });
+            }
+          }
+  
+          // Feed results back as observations
+          contents.push({ role: 'model', parts: [{ text: responseText }] });
+          contents.push({ role: 'user', parts: toolResults });
+        }
+  
+        // After loop ends: Show completion if tools were executed
+        if (toolsUsedInLoop.length > 0 && !taskComplete) {
+          onChunk('\n[done]\n');
+        }
+  
+        // Max loops reached - return control to user
+        if (loopCount >= MAX_LOOPS && !taskComplete) {
+          onChunk('\n[limit] Stopped after max iterations.\n');
+        }
+  
+      } catch (e: any) {
+        onChunk(`\n[error] ${e.message}\n`);
+      }
+  */
+}
+// Vercel SDK tools
+function createVercelTools() {
+    return {
+        readFile: tool({
+            description: 'Read file content',
+            parameters: z.object({ path: z.string() }),
+            execute: async ({ path: filePath }) => {
+                try {
+                    const p = path.resolve(process.cwd(), filePath);
+                    const content = await fs.readFile(p, 'utf-8');
+                    return { content: content.slice(0, 8000) };
+                }
+                catch (e) {
+                    return { error: e.message };
+                }
+            }
+        }),
+        writeFile: tool({
+            description: 'Write/Create file',
+            parameters: z.object({ path: z.string(), content: z.string() }),
+            execute: async ({ path: filePath }) => { return { success: true, path: filePath }; }
+        }),
+        listFiles: tool({
+            description: 'List files in directory',
+            parameters: z.object({ path: z.string().optional() }),
+            execute: async ({ path: dirPath }) => {
+                try {
+                    const p = path.resolve(process.cwd(), dirPath || '.');
+                    const files = await fs.readdir(p);
+                    const clean = files.filter(f => !['node_modules', '.git'].includes(f));
+                    return { files: clean };
+                }
+                catch (e) {
+                    return { error: e.message };
+                }
+            }
+        }),
+        executeShellCommand: tool({
+            description: 'Execute shell command',
+            parameters: z.object({ command: z.string() }),
+            execute: async ({ command }) => {
+                const { stdout, stderr } = await execAsync(command);
+                return { output: stdout || stderr };
+            }
+        }),
+        grep: tool({
+            description: 'Search for content in files OR filenames. Returns "File:Line:Preview".',
+            parameters: z.object({ pattern: z.string(), path: z.string().optional() }),
+            execute: async ({ pattern, path: searchPath }) => {
+                // Implementation for Vercel SDK (similar logic)
+                return { results: 'To be implemented for Vercel SDK fully if needed' };
+            }
+        }),
+        editFile: tool({
+            description: 'Apply unified diff patch',
+            parameters: z.object({ path: z.string(), unifiedDiff: z.string() }),
+            execute: async () => { return { success: true }; }
+        }),
+        addTask: tool({
+            description: 'Add a new task to the todo list',
+            parameters: z.object({ description: z.string() }),
+            execute: async () => { return { success: true }; }
+        }),
+        updateTask: tool({
+            description: 'Update task status',
+            parameters: z.object({
+                id: z.string(),
+                status: z.enum(['pending', 'in_progress', 'completed', 'failed'])
+            }),
+            execute: async () => { return { success: true }; }
+        }),
+        listTasks: tool({
+            description: 'List all tasks',
+            parameters: z.object({}),
+            execute: async () => { return { success: true }; }
+        }),
+        webFetch: tool({
+            description: 'Fetch content from a URL safely.',
+            parameters: z.object({ url: z.string() }),
+            execute: async () => { return { error: 'Not implemented for Vercel SDK yet' }; }
+        }),
+        internal_thought: tool({
+            description: 'Document internal reasoning',
+            parameters: z.object({ analysis: z.string() }),
+            execute: async () => { return { acknowledged: true }; }
+        })
+    };
+}
+// Initialize session and critic agent
+async function initializeSession(apiKey) {
+    // Create session if not exists
+    if (!sessionManager.getCurrentSession()) {
+        const sessionId = await sessionManager.createSession();
+        decisionLogger.clearDecisions();
+        await decisionLogger.logStrategy(sessionId, 'Session start', 'New session created', 'Starting fresh agent session');
+    }
+    // Initialize critic agent if not exists
+    // DISABLED: Critic was blocking agent execution
+    // if (!criticAgent && apiKey) {
+    //   criticAgent = new CriticAgent(apiKey);
+    // }
+}
+export async function runEliteAgent(userMessage, history, callbacks) {
+    const googleKey = config.get('googleApiKey');
+    let selectedModel = config.get('selectedModel') || 'gemini-3-flash-preview';
+    // Map aliases
+    if (selectedModel === 'gemini-3-flash' || selectedModel === 'gemini-3.0-flash') {
+        selectedModel = 'gemini-3-flash-preview';
+    }
+    else if (selectedModel === 'gemini-3.0-pro-preview') {
+        selectedModel = 'gemini-3-pro-preview';
+    }
+    const { onChunk } = callbacks;
+    lastUserMessage = userMessage;
+    // Initialize session
+    await initializeSession(googleKey);
+    // Add user message to session
+    sessionManager.addMessage({
+        role: 'user',
+        content: userMessage,
+        timestamp: Date.now()
+    });
+    if (!googleKey) {
+        onChunk('\n[error] No Google API key found. Please run setup.\n');
+        return;
+    }
+    // Use the AgentLoop for autonomous execution
+    try {
+        // Pass the selected model to the agent loop
+        // Note: AgentLoop needs to be updated to accept model param or read config
+        // For now, we'll patch AgentLoop next, but here we just call it.
+        // Wait, AgentLoop currently hardcodes 'gemini-2.0-flash'.
+        // We pass the config via context or modify AgentLoop.
+        // Let's modify AgentLoop signature or context to include 'model'.
+        // Since I can't change AgentLoop signature in this tool call, I will assume I'll update AgentLoop next.
+        // I will add 'model' to the context object passed to runAgentLoop.
+        // I need to check if runAgentLoop accepts extra context properties.
+        // It takes `AgentLoopContext`. I should update that interface first.
+        // Actually, runAgentLoop is imported. I should stick to the existing signature for now 
+        // and assume AgentLoop reads the config or I update AgentLoop to read `config.get('selectedModel')`.
+        await runGoogleAgent(userMessage, history, googleKey, callbacks);
+    }
+    catch (e) {
+        onChunk(`\n[error] ${e.message}\n`);
+    }
+}
+export async function compressContext(history, callbacks) {
+    const { onChunk } = callbacks;
+    onChunk('\n[SYSTEM] Compressing Context & Archiving Insights...\n');
+    const googleKey = config.get('googleApiKey');
+    let model;
+    try {
+        if (googleKey) {
+            const google = createGoogleGenerativeAI({ apiKey: googleKey });
+            // Use efficient model for compression
+            model = google('gemini-3-flash-preview');
+        }
+        else {
+            throw new Error('No API Key for compression');
+        }
+        const historyText = history.map(m => `${m.role.toUpperCase()}: ${m.content}`).join('\n');
+        const prompt = `
+        You are a Context Compressor.
+        Analyze the following conversation history.
+        
+        1. **Extract Important Insights**: Identify architecture decisions, file paths, user preferences, and key technical learnings.
+        2. **Summarize Context**: Create a concise summary of the conversation state so the agent can continue seamlessly.
+        
+        OUTPUT FORMAT (JSON):
+        {
+           "insights": "Markdown list of insights to save to long-term memory",
+           "summary": "Concise summary of the conversation history to serve as new start point"
+        }
+        
+        HISTORY:
+        ${historyText.slice(-20000)} 
+        `;
+        const { generateText } = await import('ai');
+        const result = await generateText({
+            model: model,
+            prompt: prompt
+        });
+        const text = result.text;
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            return "Context Reset. (Compression failed to parse)";
+        const data = JSON.parse(jsonMatch[0]);
+        if (data.insights) {
+            const memoryPath = path.resolve(process.cwd(), 'memory.md');
+            const entry = `\n## Archive [${new Date().toISOString()}]\n${data.insights}\n`;
+            await fs.appendFile(memoryPath, entry, 'utf-8');
+            onChunk(`\n[SYSTEM] Insights saved to memory.md\n`);
+        }
+        return `[CONTEXT_SUMMARY]: ${data.summary}`;
+    }
+    catch (e) {
+        onChunk(`\n[SYSTEM_ERROR] Compression failed: ${e.message}\n`);
+        return "Context Reset (Error during compression)";
+    }
+}
+// ===== SESSION MANAGEMENT EXPORTS =====
+export async function saveCurrentSession() {
+    await sessionManager.saveSession();
+}
+export async function resumeLastSession() {
+    const latestSession = await sessionManager.getLatestSession();
+    if (!latestSession)
+        return null;
+    await sessionManager.resumeSession(latestSession.sessionId);
+    return latestSession.messages;
+}
+export async function listAllSessions() {
+    return await sessionManager.listSessions();
+}
+export async function getSessionReport() {
+    const session = sessionManager.getCurrentSession();
+    if (!session)
+        return 'No active session';
+    const report = await decisionLogger.generateReport(session.sessionId);
+    return report;
+}
+export async function cleanupAgent() {
+    await sessionManager.cleanup();
+}
+export function getDecisionLog() {
+    return decisionLogger.getRecentDecisions(20);
+}