closed-loop-cli 1.0.0

package/src/orchestrator/task-agent.ts

@@ -0,0 +1,461 @@
+import Anthropic from '@anthropic-ai/sdk';
+import * as dotenv from 'dotenv';
+import * as fileTools from '../tools/file-tools';
+import * as shellTools from '../tools/shell-tools';
+import * as rulez from './rulez';
+import * as searchTools from '../tools/search-tools';
+import { Spinner } from '../tools/tui-tools';
+import * as fs from 'fs';
+import * as path from 'path';
+import { updateEvolutionState } from './state-manager';
+import { EventStream } from './event-stream';
+
+// Load environment variables
+dotenv.config();
+
+// Initialize Anthropic client
+const apiKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || '';
+const baseURL = process.env.ANTHROPIC_BASE_URL || undefined;
+
+if (!apiKey) {
+  console.warn('\x1b[33m%s\x1b[0m', 'Warning: ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN is not set in environment.');
+}
+
+const anthropic = new Anthropic({
+  apiKey: apiKey,
+  baseURL: baseURL,
+});
+
+// Select main model
+const defaultModel = process.env.ANTHROPIC_MODEL || 'mimo-v2.5-pro[1m]';
+
+// Define tools schemas for Anthropic API
+const toolsList: Anthropic.Tool[] = [
+  {
+    name: 'readFile',
+    description: 'Reads the full contents of a file inside the workspace.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'The relative or absolute path of the file to read.' }
+      },
+      required: ['path']
+    }
+  },
+  {
+    name: 'writeFile',
+    description: 'Creates a new file or overwrites an existing file with the specified content.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'The relative path of the file to create or overwrite.' },
+        content: { type: 'string', description: 'The text content to write to the file.' }
+      },
+      required: ['path', 'content']
+    }
+  },
+  {
+    name: 'editFile',
+    description: 'Edits an existing file by replacing a unique, exact block of text with a new block of text.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'The relative path of the file to edit.' },
+        targetContent: { type: 'string', description: 'The exact lines of code/text to be replaced. Must be unique within the file.' },
+        replacementContent: { type: 'string', description: 'The new lines of code/text to replace the targetContent.' }
+      },
+      required: ['path', 'targetContent', 'replacementContent']
+    }
+  },
+  {
+    name: 'listDir',
+    description: 'Lists files and folders in a workspace directory.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'The directory path to list. Defaults to \'.\' (workspace root).' }
+      }
+    }
+  },
+  {
+    name: 'grepSearch',
+    description: 'Performs a case-insensitive search for a text pattern/query in the workspace code files.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'The text string or regex pattern to search for.' },
+        path: { type: 'string', description: 'The directory path to search within. Defaults to \'.\'.' }
+      },
+      required: ['pattern']
+    }
+  },
+  {
+    name: 'runCommand',
+    description: 'Runs a terminal command in the workspace. Use this to compile code, run tests, or lint files.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'The exact command string to execute in the terminal.' }
+      },
+      required: ['command']
+    }
+  },
+  {
+    name: 'searchWeb',
+    description: 'Searches the web using DuckDuckGo to find answers or information on APIs, libraries, and debugging solutions.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'The search query string.' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'searchCodeIndex',
+    description: 'Searches the compiled local AST code index (code-index.json) for matching class, function, interface, or method names.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'The keyword or name pattern to search for in the codebase index.' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'askUser',
+    description: 'Pauses the execution loop and asks the user for clarification, feedback, credentials, or review. Use when you need input to make a decision.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        question: { type: 'string', description: 'The query, question, or review message to print for the user.' }
+      },
+      required: ['question']
+    }
+  }
+];
+
+export interface TaskAgentResult {
+  result: string;
+  inputTokens: number;
+  outputTokens: number;
+  timeSeconds: number;
+}
+
+export interface AgentOptions {
+  model?: string;
+  systemPrompt?: string;
+  maxSteps?: number;
+  role?: 'architect' | 'coder' | 'debugger' | 'gatekeeper';
+  effort?: 'standard' | 'ultracode';
+  history?: Anthropic.MessageParam[];
+}
+
+export async function runTaskAgent(task: string, options: AgentOptions = {}): Promise<TaskAgentResult> {
+  const modelName = options.model || defaultModel;
+  const effort = options.effort || 'standard';
+  const maxSteps = options.maxSteps || (effort === 'ultracode' ? 45 : 25);
+
+  let filteredTools = toolsList;
+  if (options.role) {
+    switch (options.role) {
+      case 'architect':
+        filteredTools = toolsList.filter(t => ['readFile', 'listDir', 'grepSearch', 'searchWeb', 'searchCodeIndex', 'askUser'].includes(t.name));
+        break;
+      case 'coder':
+        filteredTools = toolsList.filter(t => ['readFile', 'writeFile', 'editFile', 'listDir', 'searchCodeIndex', 'askUser'].includes(t.name));
+        break;
+      case 'coder_codeact' as any:
+        filteredTools = toolsList.filter(t => ['readFile', 'writeFile', 'editFile', 'listDir', 'runCommand', 'searchCodeIndex', 'askUser'].includes(t.name));
+        break;
+      case 'debugger':
+      case 'gatekeeper':
+        filteredTools = toolsList.filter(t => ['readFile', 'listDir', 'runCommand', 'searchCodeIndex', 'askUser'].includes(t.name));
+        break;
+    }
+  }
+  
+  // Load system prompt from external text file if not overridden by options
+  let systemPrompt = options.systemPrompt || '';
+  if (!systemPrompt) {
+    let promptPath = path.join(__dirname, 'system-prompt.txt');
+    if (!fs.existsSync(promptPath)) {
+      promptPath = path.join(process.cwd(), 'src/orchestrator/system-prompt.txt');
+    }
+    if (fs.existsSync(promptPath)) {
+      systemPrompt = fs.readFileSync(promptPath, 'utf-8');
+    } else {
+      // Fallback
+      systemPrompt = `You are an elite coding agent designed to operate inside a codebase workspace.
+Your primary objective is to fulfill the user's coding tasks accurately and cleanly.
+
+You have access to a set of local tools to read, write, edit files and execute terminal commands.
+Always prefer editing precise parts of files using editFile instead of overwriting the whole file with writeFile unless it is a new file.
+When running commands, verify compilation and test outcomes. If a test fails, you must attempt to fix the issues (Self-Healing).
+
+Be concise and professional. Formulate plans before making changes.`;
+    }
+  }
+
+  if (effort === 'ultracode') {
+    const ultracodePrompt = `\n\n---
+ULTRACODE MAXIMUM EFFORT PROTOCOL ENFORCED:
+1. Spend extra reasoning tokens/steps to thoroughly evaluate alternative systems architectures and anticipate regression errors across the codebase.
+2. In any task involving scripting, tools, or creating new files, you MUST determine and specify a precise, workspace-relative or absolute destination filepath (e.g. 'src/tools/math-helper.ts') and never leave it vague or ambiguous.
+3. Validate that your proposed code modifications do not introduce unexpected side-effects or compromise codebase safety boundaries.
+---`;
+    systemPrompt += ultracodePrompt;
+  }
+
+  // Inject OS environment awareness to guide command execution safely
+  const osType = process.platform === 'win32' ? 'Windows (win32)' : process.platform;
+  const shellType = process.platform === 'win32' ? 'PowerShell or Command Prompt (cmd.exe)' : 'Bash or Sh';
+  const osContext = `\n\n---
+CURRENT ENVIRONMENT & OS SAFETY GUIDELINES:
+- Operating System: ${osType}
+- Active Terminal Shell: ${shellType}
+${process.platform === 'win32' ? `
+IMPORTANT: You are running on Windows. Unix terminal commands such as 'cat', 'ls', 'grep', 'rm -rf', and pipes like '| head' or '| grep' are NOT supported natively.
+- Use Windows/PowerShell equivalent commands (e.g., 'Get-Content' instead of 'cat', 'dir' or 'Get-ChildItem' instead of 'ls', and Node scripts or PowerShell commands for string filtering).
+- Keep commands compatible with Windows environment syntax.` : `
+- Use Unix terminal commands natively compatible with the active shell.`}
+---`;
+
+  systemPrompt = systemPrompt + osContext;
+
+  console.log(`\x1b[36m[TaskAgent]\x1b[0m Starting task with model: \x1b[32m${modelName}\x1b[0m`);
+  console.log(`\x1b[36m[TaskAgent]\x1b[0m Task: "${task}"\n`);
+
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const startTime = Date.now();
+
+  // Start message history
+  const messages: Anthropic.MessageParam[] = options.history || [];
+  if (task) {
+    messages.push({ role: 'user', content: task });
+  }
+
+  let step = 0;
+  while (step < maxSteps) {
+    step++;
+    const spinner = new Spinner(`TaskAgent - Step ${step}/${maxSteps}: Thinking...`);
+    spinner.start();
+
+    try {
+      const response = await anthropic.messages.create({
+        model: modelName,
+        max_tokens: 4000,
+        system: systemPrompt,
+        messages: messages,
+        tools: filteredTools,
+      });
+      if (response.usage) {
+        inputTokens += response.usage.input_tokens || 0;
+        outputTokens += response.usage.output_tokens || 0;
+      }
+      spinner.stop(true, `TaskAgent - Step ${step}/${maxSteps}: Thought completed.`);
+
+      // Find text content if any
+      const textBlock = response.content.find(block => block.type === 'text') as Anthropic.TextBlock | undefined;
+      if (textBlock && textBlock.text) {
+        console.log('\x1b[34m┌── Agent Thought ───────────────────────────────────────────────────────────────┐\x1b[0m');
+        textBlock.text.split('\n').forEach(line => {
+          console.log(`\x1b[34m│\x1b[0m ${line}`);
+        });
+        console.log('\x1b[34m└────────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
+      }
+
+      // Add response to message history
+      messages.push({
+        role: 'assistant',
+        content: response.content
+      });
+
+      // Find tool calls
+      const toolCalls = response.content.filter(block => block.type === 'tool_use') as Anthropic.ToolUseBlock[];
+
+      if (toolCalls.length === 0) {
+        // No tools used, agent finished
+        console.log(`\x1b[32m[TaskAgent] Completed. No further tool calls needed.\x1b[0m`);
+        const timeSeconds = (Date.now() - startTime) / 1000;
+        recordTokens(inputTokens, outputTokens);
+        return {
+          result: textBlock ? textBlock.text : 'Task completed successfully.',
+          inputTokens,
+          outputTokens,
+          timeSeconds
+        };
+      }
+
+      const toolResults: Anthropic.ToolResultBlockParam[] = [];
+
+      for (const call of toolCalls) {
+        const { name, id, input } = call;
+        console.log('\x1b[33m┌── Tool Call Interception ──────────────────────────────────────────────────────┐\x1b[0m');
+        console.log(`\x1b[33m│\x1b[0m Tool:  \x1b[1m${name}\x1b[0m`);
+        console.log(`\x1b[33m│\x1b[0m Input: ${JSON.stringify(input)}`);
+
+        EventStream.getInstance().publish(
+          'agent',
+          'action',
+          name,
+          JSON.stringify(input)
+        );
+
+        let outputContent = '';
+        let isError = false;
+
+        try {
+          const args = input as any;
+          switch (name) {
+            case 'readFile':
+              outputContent = fileTools.readFile(args.path);
+              break;
+            case 'writeFile': {
+              const policy = rulez.checkFileEdit(args.path, args.content);
+              if (!policy.allowed) {
+                outputContent = policy.message;
+                isError = true;
+              } else {
+                fileTools.writeFile(args.path, args.content);
+                outputContent = `Successfully wrote to file ${args.path}`;
+              }
+              break;
+            }
+            case 'editFile': {
+              const policy = rulez.checkFileEdit(args.path, args.replacementContent);
+              if (!policy.allowed) {
+                outputContent = policy.message;
+                isError = true;
+              } else {
+                fileTools.editFile(args.path, args.targetContent, args.replacementContent);
+                outputContent = `Successfully edited file ${args.path}`;
+              }
+              break;
+            }
+            case 'listDir':
+              const files = fileTools.listDir(args.path || '.');
+              outputContent = JSON.stringify(files, null, 2);
+              break;
+            case 'grepSearch':
+              const matches = fileTools.grepSearch(args.pattern, args.path || '.');
+              outputContent = JSON.stringify(matches, null, 2);
+              break;
+            case 'runCommand': {
+              console.log(`\x1b[33m│\x1b[0m \x1b[31m[Security Warning]\x1b[0m Agent wants to run: "\x1b[31m${args.command}\x1b[0m"`);
+              const policy = rulez.checkCommand(args.command);
+              if (!policy.allowed) {
+                console.log(`\x1b[33m│\x1b[0m \x1b[31m[RuleZ Blocked]\x1b[0m ${policy.message}`);
+                outputContent = `Exit Code: ${policy.exitCode}\nError: ${policy.message}`;
+                isError = true;
+              } else {
+                // Run the command
+                const cmdRes = await shellTools.runCommand(args.command);
+                outputContent = `Exit Code: ${cmdRes.exitCode}\nStdout:\n${cmdRes.stdout}\nStderr:\n${cmdRes.stderr}`;
+                if (cmdRes.error) {
+                  outputContent += `\nExecution Error: ${cmdRes.error}`;
+                }
+                if (cmdRes.exitCode !== 0) {
+                  isError = true;
+                }
+              }
+              break;
+            }
+            case 'searchWeb':
+              outputContent = await searchTools.searchWeb(args.query);
+              break;
+            case 'searchCodeIndex': {
+              const { queryCodeIndex } = require('../tools/indexer');
+              outputContent = queryCodeIndex(args.query);
+              break;
+            }
+            case 'askUser': {
+              const rl = require('readline').createInterface({
+                input: process.stdin,
+                output: process.stdout
+              });
+              
+              console.log(`\n\x1b[33;1m🤖 Agent Question: ${args.question}\x1b[0m`);
+              
+              const answer: string = await new Promise((resolvePrompt) => {
+                rl.question('\x1b[32;1mUser Response > \x1b[0m', (inputStr: string) => {
+                  rl.close();
+                  resolvePrompt(inputStr);
+                });
+              });
+              
+              outputContent = answer;
+              break;
+            }
+            default:
+              outputContent = `Error: Tool '${name}' is not recognized.`;
+              isError = true;
+          }
+        } catch (err: any) {
+          outputContent = `Error executing tool '${name}': ${err.message}`;
+          isError = true;
+        }
+
+        EventStream.getInstance().publish(
+          'environment',
+          'observation',
+          name + 'Observation',
+          outputContent,
+          { isError }
+        );
+
+        console.log(`\x1b[33m│\x1b[0m Status: ${isError ? '\x1b[31mFailed ❌' : '\x1b[32mSucceeded ✅'}\x1b[0m (Output length: ${outputContent.length} chars)`);
+        console.log('\x1b[33m└────────────────────────────────────────────────────────────────────────────────┘\x1b[0m\n');
+
+        toolResults.push({
+          type: 'tool_result',
+          tool_use_id: id,
+          content: [{ type: 'text', text: outputContent }],
+          is_error: isError
+        });
+      }
+
+      // Add tool results to message history
+      messages.push({
+        role: 'user',
+        content: toolResults
+      });
+
+    } catch (apiError: any) {
+      spinner.stop(false, `TaskAgent - Step ${step}/${maxSteps}: API call failed.`);
+      console.error(`\x1b[31m[API Error]\x1b[0m Error communicating with Anthropic API: ${apiError.message}`);
+      if (apiError.stack) {
+        console.error(apiError.stack);
+      }
+      throw apiError;
+    }
+  }
+
+  const timeSeconds = (Date.now() - startTime) / 1000;
+  recordTokens(inputTokens, outputTokens);
+  throw new Error(`Agent reached maximum steps (${maxSteps}) without finishing. Used tokens: Input=${inputTokens}, Output=${outputTokens}, Time=${timeSeconds}s`);
+}
+
+function recordTokens(input: number, output: number) {
+  try {
+    const tokenPath = path.join(process.cwd(), 'session-tokens.json');
+    let data = { inputTokens: 0, outputTokens: 0 };
+    if (fs.existsSync(tokenPath)) {
+      try {
+        data = JSON.parse(fs.readFileSync(tokenPath, 'utf-8'));
+      } catch (e) {}
+    }
+    data.inputTokens = (data.inputTokens || 0) + input;
+    data.outputTokens = (data.outputTokens || 0) + output;
+    fs.writeFileSync(tokenPath, JSON.stringify(data, null, 2), 'utf-8');
+
+    updateEvolutionState({
+      tokensUsed: {
+        input: data.inputTokens,
+        output: data.outputTokens,
+        total: data.inputTokens + data.outputTokens
+      }
+    });
+  } catch (err) {}
+}