closed-loop-cli 1.0.0

package/dist/orchestrator/telegram-bot.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startTelegramBot = startTelegramBot;
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const state_manager_1 = require("./state-manager");
+async function callTelegramApi(token, method, payload) {
+    return new Promise((resolve, reject) => {
+        const url = `https://api.telegram.org/bot${token}/${method}`;
+        const data = JSON.stringify(payload);
+        const req = https.request(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(data),
+            },
+        }, (res) => {
+            let body = '';
+            res.on('data', chunk => body += chunk);
+            res.on('end', () => {
+                try {
+                    const response = JSON.parse(body);
+                    if (response.ok) {
+                        resolve(response.result);
+                    }
+                    else {
+                        reject(new Error(`Telegram API Error: ${response.description}`));
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(data);
+        req.end();
+    });
+}
+let runningProcess = null;
+async function handleTelegramCommand(token, message, activeChats) {
+    const chatId = message.chat.id;
+    const text = message.text?.trim() || '';
+    if (text.startsWith('/start') || text.startsWith('/help')) {
+        await callTelegramApi(token, 'sendMessage', {
+            chat_id: chatId,
+            text: `🤖 *Closed-Loop Agent ChatOps Console*\n\n` +
+                `*Commands:*\n` +
+                `/status - View metrics, cycles, token budget, and active task status\n` +
+                `/logs - View last 25 log lines of evolution.log\n` +
+                `/refactor <goal> - Run autonomous refactoring for goal\n` +
+                `/task <task> - Run custom evolution step for task\n` +
+                `/kill - Cancel any running task spawned by the bot`,
+            parse_mode: 'Markdown'
+        });
+        return;
+    }
+    if (text.startsWith('/status')) {
+        const state = (0, state_manager_1.getEvolutionState)();
+        const statusText = `📊 *Current Agent Status: ${state.status.toUpperCase()}*\n\n` +
+            `- *Cycle*: ${state.currentCycle} / ${state.maxCycles === 0 ? 'Infinite' : state.maxCycles}\n` +
+            `- *Token Budget*: ${state.tokenBudget} total\n` +
+            `- *Tokens Used*: ${state.tokensUsed.total} (Input: ${state.tokensUsed.input}, Output: ${state.tokensUsed.output})\n` +
+            `- *Last Updated*: ${state.lastUpdated}\n` +
+            `- *Current Task*: ${state.currentTask || 'None'}`;
+        await callTelegramApi(token, 'sendMessage', {
+            chat_id: chatId,
+            text: statusText,
+            parse_mode: 'Markdown'
+        });
+        return;
+    }
+    if (text.startsWith('/logs')) {
+        try {
+            const logPath = path.join(process.cwd(), 'evolution.log');
+            if (fs.existsSync(logPath)) {
+                const logContent = fs.readFileSync(logPath, 'utf-8');
+                const lines = logContent.split('\n');
+                const lastLines = lines.slice(-25).join('\n');
+                await callTelegramApi(token, 'sendMessage', {
+                    chat_id: chatId,
+                    text: `📝 *Last 25 log lines:*\n\`\`\`\n${lastLines || 'No logs yet.'}\n\`\`\``,
+                    parse_mode: 'Markdown'
+                });
+            }
+            else {
+                await callTelegramApi(token, 'sendMessage', {
+                    chat_id: chatId,
+                    text: `❌ Log file 'evolution.log' does not exist yet.`
+                });
+            }
+        }
+        catch (err) {
+            await callTelegramApi(token, 'sendMessage', {
+                chat_id: chatId,
+                text: `❌ Error reading log file: ${err.message}`
+            });
+        }
+        return;
+    }
+    if (text.startsWith('/kill')) {
+        if (runningProcess) {
+            runningProcess.kill();
+            runningProcess = null;
+            await callTelegramApi(token, 'sendMessage', {
+                chat_id: chatId,
+                text: `🛑 Active evolution task was manually terminated.`
+            });
+        }
+        else {
+            await callTelegramApi(token, 'sendMessage', {
+                chat_id: chatId,
+                text: `ℹ️ No active evolution task is running.`
+            });
+        }
+        return;
+    }
+    const isRefactor = text.startsWith('/refactor ');
+    const isTask = text.startsWith('/task ');
+    if (isRefactor || isTask) {
+        if (runningProcess) {
+            await callTelegramApi(token, 'sendMessage', {
+                chat_id: chatId,
+                text: `⚠️ An evolution task is already running. Use /kill to stop it first.`
+            });
+            return;
+        }
+        const commandArg = isRefactor ? text.substring(10).trim() : text.substring(6).trim();
+        if (!commandArg) {
+            await callTelegramApi(token, 'sendMessage', {
+                chat_id: chatId,
+                text: `❌ Command argument cannot be empty.`
+            });
+            return;
+        }
+        // Run the agent process
+        await callTelegramApi(token, 'sendMessage', {
+            chat_id: chatId,
+            text: `🚀 Starting task: "${commandArg}"\nWaiting for initialization...`
+        });
+        let currentStage = 'reflecting';
+        let outputBuffer = '';
+        let lastSendTime = Date.now();
+        const sendBufferedOutput = async () => {
+            if (!outputBuffer.trim())
+                return;
+            const cleanOutput = outputBuffer.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+            outputBuffer = '';
+            lastSendTime = Date.now();
+            const chunk = cleanOutput.length > 3900 ? cleanOutput.substring(cleanOutput.length - 3900) : cleanOutput;
+            try {
+                await callTelegramApi(token, 'sendMessage', {
+                    chat_id: chatId,
+                    text: `💻 *Process Logs:*\n\`\`\`\n${chunk}\n\`\`\``,
+                    parse_mode: 'Markdown'
+                });
+            }
+            catch (err) {
+                console.error('[Telegram Bot] Failed to send log chunk:', err.message);
+            }
+        };
+        const handleData = async (data) => {
+            outputBuffer += data;
+            let stageChanged = false;
+            let newStage = '';
+            let stageEmoji = '';
+            let stageLabel = '';
+            if (data.includes('AGP - Reflect') && currentStage !== 'reflecting') {
+                newStage = 'reflecting';
+                stageEmoji = '🔄';
+                stageLabel = 'Reflecting (Diagnosis)';
+                stageChanged = true;
+            }
+            else if (data.includes('AGP - Scan') && currentStage !== 'scanning') {
+                newStage = 'scanning';
+                stageEmoji = '🔍';
+                stageLabel = 'Scanning Codebase';
+                stageChanged = true;
+            }
+            else if ((data.includes('improve') || data.includes('Self-Modification Loop') || data.includes('TaskAgent')) && currentStage !== 'improving') {
+                newStage = 'improving';
+                stageEmoji = '🛠️';
+                stageLabel = 'Refactoring / Implementing';
+                stageChanged = true;
+            }
+            else if ((data.includes('AGP - Evaluate') || data.includes('evaluate') || data.includes('SAHOO')) && currentStage !== 'evaluating') {
+                newStage = 'evaluating';
+                stageEmoji = '🧪';
+                stageLabel = 'Evaluating & SAHOO Verification';
+                stageChanged = true;
+            }
+            else if (data.includes('AGP - Commit') && currentStage !== 'committing') {
+                newStage = 'committing';
+                stageEmoji = '💾';
+                stageLabel = 'Committing Changes';
+                stageChanged = true;
+            }
+            else if (data.includes('AGP - Rollback') && currentStage !== 'rolling_back') {
+                newStage = 'rolling_back';
+                stageEmoji = '⚠️';
+                stageLabel = 'Rolling Back Mutations';
+                stageChanged = true;
+            }
+            if (stageChanged) {
+                currentStage = newStage;
+                await sendBufferedOutput();
+                await callTelegramApi(token, 'sendMessage', {
+                    chat_id: chatId,
+                    text: `${stageEmoji} *Evolution Stage*: ${stageLabel}...`,
+                    parse_mode: 'Markdown'
+                });
+            }
+            else if (Date.now() - lastSendTime > 4000) {
+                await sendBufferedOutput();
+            }
+        };
+        const processArgs = ['dist/index.js'];
+        if (isRefactor) {
+            processArgs.push(`Refactor ${commandArg}`);
+        }
+        else {
+            processArgs.push(commandArg);
+        }
+        const child = (0, child_process_1.spawn)('node', processArgs, {
+            cwd: process.cwd(),
+            env: { ...process.env, FORCE_COLOR: '0' }
+        });
+        runningProcess = child;
+        child.stdout.on('data', (chunk) => {
+            handleData(chunk.toString());
+        });
+        child.stderr.on('data', (chunk) => {
+            handleData(chunk.toString());
+        });
+        child.on('close', async (code) => {
+            runningProcess = null;
+            await sendBufferedOutput();
+            if (code === 0) {
+                await callTelegramApi(token, 'sendMessage', {
+                    chat_id: chatId,
+                    text: `✅ *Evolution Step Completed Successfully!* (Exit Code: ${code})`,
+                    parse_mode: 'Markdown'
+                });
+            }
+            else {
+                await callTelegramApi(token, 'sendMessage', {
+                    chat_id: chatId,
+                    text: `❌ *Evolution Step Failed / Aborted!* (Exit Code: ${code})`,
+                    parse_mode: 'Markdown'
+                });
+            }
+        });
+        child.on('error', async (err) => {
+            runningProcess = null;
+            await callTelegramApi(token, 'sendMessage', {
+                chat_id: chatId,
+                text: `❌ *Subprocess Error:* ${err.message}`,
+                parse_mode: 'Markdown'
+            });
+        });
+    }
+}
+async function startTelegramBot() {
+    const token = process.env.TELEGRAM_BOT_TOKEN;
+    if (!token) {
+        console.log('\x1b[33m[Telegram Bot] Warning: TELEGRAM_BOT_TOKEN is not set in .env. Telegram ChatOps will be inactive.\x1b[0m');
+        return;
+    }
+    const allowedUserIdsStr = process.env.TELEGRAM_ALLOWED_USER_IDS || '';
+    const allowedUserIds = allowedUserIdsStr.split(',').map(s => s.trim()).filter(Boolean);
+    console.log(`\x1b[32m[Telegram Bot] Initializing Telegram ChatOps... Allowed User IDs: [${allowedUserIds.join(', ')}]\x1b[0m`);
+    let lastUpdateId = 0;
+    const activeChats = new Set();
+    // Start polling loop
+    (async () => {
+        while (true) {
+            try {
+                const updates = await callTelegramApi(token, 'getUpdates', {
+                    offset: lastUpdateId + 1,
+                    timeout: 20,
+                });
+                for (const update of updates) {
+                    lastUpdateId = Math.max(lastUpdateId, update.update_id);
+                    if (update.message) {
+                        const chatId = update.message.chat.id;
+                        const fromId = update.message.from?.id;
+                        const fromIdStr = fromId ? String(fromId) : '';
+                        if (!allowedUserIds.includes(fromIdStr)) {
+                            console.log(`[Telegram Bot] Blocked unauthorized message from user ID: ${fromIdStr}`);
+                            await callTelegramApi(token, 'sendMessage', {
+                                chat_id: chatId,
+                                text: `❌ *Unauthorized*\nYour User ID (${fromIdStr}) is not in the allowed list.`,
+                                parse_mode: 'Markdown'
+                            });
+                            continue;
+                        }
+                        activeChats.add(chatId);
+                        await handleTelegramCommand(token, update.message, activeChats);
+                    }
+                }
+            }
+            catch (err) {
+                console.error('[Telegram Bot] Error polling updates:', err.message);
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+    })();
+    // Start state monitoring / progress broadcasting
+    let lastStateStr = '';
+    setInterval(() => {
+        try {
+            const state = (0, state_manager_1.getEvolutionState)();
+            const stateStr = JSON.stringify({
+                status: state.status,
+                currentCycle: state.currentCycle,
+                tokensUsed: state.tokensUsed.total
+            });
+            if (lastStateStr && lastStateStr !== stateStr && activeChats.size > 0) {
+                const broadcastText = `📢 *Evolution State Update*\n\n` +
+                    `- *Status*: ${state.status.toUpperCase()}\n` +
+                    `- *Cycle*: ${state.currentCycle}\n` +
+                    `- *Tokens Used*: ${state.tokensUsed.total}`;
+                for (const chatId of activeChats) {
+                    callTelegramApi(token, 'sendMessage', {
+                        chat_id: chatId,
+                        text: broadcastText,
+                        parse_mode: 'Markdown'
+                    }).catch(err => {
+                        console.error(`[Telegram Bot] Failed to broadcast state to chat ${chatId}:`, err.message);
+                    });
+                }
+            }
+            lastStateStr = stateStr;
+        }
+        catch (e) {
+            // ignore
+        }
+    }, 5000);
+}

package/dist/orchestrator/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests/dynamic/dependencies.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const indexer_1 = require("../../tools/indexer");
+async function run() {
+    console.log("   --> Running Dependency Graph tests...");
+    const workspaceRoot = process.cwd();
+    // 1. Rebuild Index
+    const index = (0, indexer_1.generateCodeIndex)(workspaceRoot);
+    if (index.length === 0) {
+        throw new Error("Failed to index files!");
+    }
+    // Find a file to test dependencies on, e.g. shell-tools.ts
+    const shellToolsFile = 'src/tools/shell-tools.ts';
+    const dependents = (0, indexer_1.getDependents)(shellToolsFile, workspaceRoot);
+    console.log(`   --> Dependents of "${shellToolsFile}":\n`, dependents);
+    if (dependents.length === 0) {
+        throw new Error(`Expected at least one file to import "${shellToolsFile}" but found none!`);
+    }
+    // Check that key importing files are in the list
+    const hasTaskAgent = dependents.some(d => d.includes('task-agent.ts'));
+    const hasTests = dependents.some(d => d.includes('run-tests.ts'));
+    if (!hasTaskAgent && !hasTests) {
+        throw new Error(`Dependency check missed expected importers like task-agent.ts or run-tests.ts!`);
+    }
+    // 2. Check imports extraction
+    const taskAgentIndex = index.find(f => f.filePath === 'src/orchestrator/task-agent.ts');
+    if (!taskAgentIndex) {
+        throw new Error("Failed to find task-agent.ts index entry!");
+    }
+    console.log("   --> Imports of task-agent.ts:\n", taskAgentIndex.imports);
+    const importsShellTools = taskAgentIndex.imports.some(imp => imp.includes('shell-tools'));
+    if (!importsShellTools) {
+        throw new Error("Failed to extract shell-tools import from task-agent.ts!");
+    }
+    console.log("   --> Dependency Graph tests passed!");
+}

package/dist/tests/dynamic/dummy.test.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+// Dummy dynamic test file
+async function run() {
+    console.log("   --> Dynamic dummy test execution successful!");
+}

package/dist/tests/dynamic/fuzzy-patch.test.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const file_tools_1 = require("../../tools/file-tools");
+const fs = __importStar(require("fs"));
+async function run() {
+    console.log("   --> Running Fuzzy Patch tests...");
+    const testFile = 'temp-fuzzy-test.ts';
+    // Write source code with dynamic formatting
+    const originalCode = `function calculateTotal(a: number, b: number) {
+    const sum = a + b;
+    return sum;
+}`;
+    (0, file_tools_1.writeFile)(testFile, originalCode);
+    // Attempt fuzzy edit: target has different spaces and newlines
+    const targetWithDifferentSpacing = `const    sum    =    a    +    b;
+    return sum;`;
+    const replacement = `const sum = a + b;
+    console.log("Adding:", a, b);
+    return sum;`;
+    try {
+        (0, file_tools_1.editFile)(testFile, targetWithDifferentSpacing, replacement);
+        const resultingCode = (0, file_tools_1.readFile)(testFile);
+        console.log("   --> Output content after fuzzy edit:\n", resultingCode);
+        if (!resultingCode.includes('console.log("Adding:", a, b)')) {
+            throw new Error("Fuzzy patch was not applied successfully!");
+        }
+        console.log("   --> Fuzzy Patch tests passed!");
+    }
+    finally {
+        if (fs.existsSync(testFile)) {
+            fs.unlinkSync(testFile);
+        }
+    }
+}

package/dist/tests/dynamic/indexer.test.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const indexer_1 = require("../../tools/indexer");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function run() {
+    console.log("   --> Running indexer tests...");
+    // 1. Generate code index
+    const workspaceRoot = process.cwd();
+    const index = (0, indexer_1.generateCodeIndex)(workspaceRoot);
+    if (index.length === 0) {
+        throw new Error("Indexed file list should not be empty!");
+    }
+    // Verify code-index.json exists
+    const indexPath = path.join(workspaceRoot, 'code-index.json');
+    if (!fs.existsSync(indexPath)) {
+        throw new Error("code-index.json file was not created!");
+    }
+    // 2. Query index
+    const queryResult = (0, indexer_1.queryCodeIndex)("AutogenesisEngine");
+    console.log("   --> Query search 'AutogenesisEngine' result:\n", queryResult);
+    if (!queryResult.includes("AutogenesisEngine")) {
+        throw new Error("Indexer query failed to find 'AutogenesisEngine'");
+    }
+    console.log("   --> Indexer tests passed!");
+}

package/dist/tests/dynamic/openhands.test.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const event_stream_1 = require("../../orchestrator/event-stream");
+const microagent_registry_1 = require("../../orchestrator/microagent-registry");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function run() {
+    console.log("   --> Running OpenHands (EventStream & Microagents) tests...");
+    // 1. Test EventStream
+    const stream = event_stream_1.EventStream.getInstance();
+    stream.clear();
+    stream.publish('user', 'message', 'TestUserQuery', 'Hello agent');
+    stream.publish('agent', 'action', 'readFile', '{"path": "package.json"}');
+    stream.publish('environment', 'observation', 'readFileObservation', 'File content here');
+    const events = stream.getEvents();
+    if (events.length !== 3) {
+        throw new Error(`Expected 3 events in EventStream, got ${events.length}`);
+    }
+    if (events[0].source !== 'user' || events[0].name !== 'TestUserQuery') {
+        throw new Error(`EventStream mismatch on user query: ${JSON.stringify(events[0])}`);
+    }
+    if (events[1].source !== 'agent' || events[1].type !== 'action') {
+        throw new Error(`EventStream mismatch on agent action: ${JSON.stringify(events[1])}`);
+    }
+    // Verify file was written
+    const historyPath = path.join(process.cwd(), 'event-stream-history.json');
+    if (!fs.existsSync(historyPath)) {
+        throw new Error('event-stream-history.json was not created');
+    }
+    // 2. Test MicroagentRegistry
+    const registry = microagent_registry_1.MicroagentRegistry.getInstance();
+    registry.loadMicroagents();
+    const allAgents = registry.getMicroagents();
+    if (allAgents.length === 0) {
+        throw new Error('MicroagentRegistry failed to load microagents');
+    }
+    // Test triggers
+    const gitMatches = registry.findMatchingMicroagents('Please commit the changes and push');
+    const hasGitHelper = gitMatches.some(a => a.name === 'Git Helper');
+    if (!hasGitHelper) {
+        throw new Error('Expected Git Helper to match query containing "commit"');
+    }
+    const tsMatches = registry.findMatchingMicroagents('Refactor using typescript helper');
+    const hasTsExpert = tsMatches.some(a => a.name === 'TypeScript Expert');
+    if (!hasTsExpert) {
+        throw new Error('Expected TypeScript Expert to match query containing "typescript"');
+    }
+    console.log("   --> OpenHands (EventStream & Microagents) tests passed successfully!");
+}