closed-loop-cli 1.0.0

package/src/orchestrator/telegram-bot.ts

@@ -0,0 +1,358 @@
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { getEvolutionState } from './state-manager';
+
+async function callTelegramApi(token: string, method: string, payload: any): Promise<any> {
+  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: any = null;
+
+async function handleTelegramCommand(token: string, message: any, activeChats: Set<number>) {
+  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 = 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: any) {
+      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: any) {
+        console.error('[Telegram Bot] Failed to send log chunk:', err.message);
+      }
+    };
+
+    const handleData = async (data: string) => {
+      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 = 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'
+      });
+    });
+  }
+}
+
+export 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<number>();
+
+  // 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: any) {
+        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 = 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/src/tests/dynamic/dependencies.test.ts

@@ -0,0 +1,48 @@
+import { generateCodeIndex, getDependents } from '../../tools/indexer';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export async function run() {
+  console.log("   --> Running Dependency Graph tests...");
+  
+  const workspaceRoot = process.cwd();
+  
+  // 1. Rebuild Index
+  const index = 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 = 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/src/tests/dynamic/dummy.test.ts

@@ -0,0 +1,4 @@
+// Dummy dynamic test file
+export async function run() {
+  console.log("   --> Dynamic dummy test execution successful!");
+}

package/src/tests/dynamic/fuzzy-patch.test.ts

@@ -0,0 +1,42 @@
+import { editFile, writeFile, readFile } from '../../tools/file-tools';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export 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;
+}`;
+  
+  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 {
+    editFile(testFile, targetWithDifferentSpacing, replacement);
+    
+    const resultingCode = 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/src/tests/dynamic/indexer.test.ts

@@ -0,0 +1,31 @@
+import { generateCodeIndex, queryCodeIndex } from '../../tools/indexer';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export async function run() {
+  console.log("   --> Running indexer tests...");
+  
+  // 1. Generate code index
+  const workspaceRoot = process.cwd();
+  const index = 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 = 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/src/tests/dynamic/openhands.test.ts

@@ -0,0 +1,59 @@
+import { EventStream } from '../../orchestrator/event-stream';
+import { MicroagentRegistry } from '../../orchestrator/microagent-registry';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export async function run() {
+  console.log("   --> Running OpenHands (EventStream & Microagents) tests...");
+
+  // 1. Test EventStream
+  const stream = 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 = 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!");
+}

package/src/tests/dynamic/skills.test.ts

@@ -0,0 +1,63 @@
+import { extractAndSaveSkill, getSkillsSummary } from '../../tools/skills';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export async function run() {
+  console.log("   --> Running Skill Registry tests...");
+  
+  const workspaceRoot = process.cwd();
+  const skillsDir = path.join(workspaceRoot, 'docs', 'skills');
+  const testSkillFile = path.join(skillsDir, 'test-reusable-skill.json');
+  
+  // Clean up previous test files if any
+  if (fs.existsSync(testSkillFile)) {
+    fs.unlinkSync(testSkillFile);
+  }
+
+  // 1. Mock inputs
+  const mockTask = "Add a checkFileExists utility inside file-tools.ts";
+  const mockDiff = `diff --git a/src/tools/file-tools.ts b/src/tools/file-tools.ts
+index e69de29..b2a8d11 100644
+--- a/src/tools/file-tools.ts
++++ b/src/tools/file-tools.ts
+@@ -1 +1,5 @@
++export function checkFileExists(path: string): boolean {
++  return fs.existsSync(path);
++}
+`;
+
+  // 2. Extract and Save
+  await extractAndSaveSkill(mockTask, mockDiff);
+  
+  // Find any generated json files
+  if (!fs.existsSync(skillsDir)) {
+    throw new Error("skills directory was not created!");
+  }
+  
+  const files = fs.readdirSync(skillsDir).filter(f => f.endsWith('.json'));
+  if (files.length === 0) {
+    throw new Error("No playbooks were written by extractAndSaveSkill!");
+  }
+  
+  console.log(`   --> Created playbooks: ${files.join(', ')}`);
+  
+  // 3. Summarize
+  const summaries = getSkillsSummary();
+  console.log("   --> Playbook summaries:\n", summaries);
+  
+  if (summaries === 'No custom development skills recorded yet.') {
+    throw new Error("getSkillsSummary returned default empty statement despite files present.");
+  }
+  
+  // Clean up mock output to keep it clean, but wait, keeping it is also fine since git ignores or tracks.
+  // Actually, let's keep one test playbook for verification and delete any temporary ones if needed.
+  // Let's delete the temporary test file.
+  const testFiles = files.filter(f => f.includes('reusable-skill') || f.includes('exists'));
+  for (const f of testFiles) {
+    try {
+      fs.unlinkSync(path.join(skillsDir, f));
+    } catch(e) {}
+  }
+  
+  console.log("   --> Skill Registry tests passed!");
+}