Add a command-line cline powered by deno

2025-12-21 04:41:16 -05:00 · 2024-11-20 23:21:38 -05:00
parent e55696e247
commit 1c471bd3cb
12 changed files with 1103 additions and 0 deletions
--- a/cli/core/StandaloneAgent.ts
+++ b/cli/core/StandaloneAgent.ts
@@ -0,0 +1,164 @@
+import { blue, red, yellow } from "../deps.ts";
+import { ApiHandler } from "../api/mod.ts";
+import { executeCommand, readFile, writeFile, searchFiles, listFiles, listCodeDefinitions } from "../tools/mod.ts";
+import type { Message, TextBlock, ToolResult } from "../types.d.ts";
+
+interface AgentConfig {
+  api: ApiHandler;
+  systemPrompt: string;
+  workingDir: string;
+}
+
+export class StandaloneAgent {
+  private api: ApiHandler;
+  private systemPrompt: string;
+  private workingDir: string;
+  private conversationHistory: Message[] = [];
+
+  constructor(config: AgentConfig) {
+    this.api = config.api;
+    this.systemPrompt = config.systemPrompt;
+    this.workingDir = config.workingDir;
+  }
+
+  async runTask(task: string): Promise<void> {
+    this.conversationHistory.push({
+      role: "user",
+      content: [{ type: "text", text: `<task>\n${task}\n</task>` }]
+    });
+
+    let isTaskComplete = false;
+    const encoder = new TextEncoder();
+    
+    while (!isTaskComplete) {
+      const stream = this.api.createMessage(this.systemPrompt, this.conversationHistory);
+      let assistantMessage = "";
+      
+      console.log(blue("Thinking..."));
+      for await (const chunk of stream) {
+        if (chunk.type === "text") {
+          assistantMessage += chunk.text;
+          await Deno.stdout.write(encoder.encode(chunk.text));
+        }
+      }
+
+      this.conversationHistory.push({
+        role: "assistant",
+        content: [{ type: "text", text: assistantMessage }]
+      });
+
+      const toolResults = await this.executeTools(assistantMessage);
+      
+      if (toolResults.length > 0) {
+        this.conversationHistory.push({
+          role: "user",
+          content: toolResults.map(result => ({
+            type: "text",
+            text: `[${result.tool}] Result:${result.output}`
+          })) as TextBlock[]
+        });
+      } else {
+        if (assistantMessage.includes("<attempt_completion>")) {
+          isTaskComplete = true;
+        } else {
+          this.conversationHistory.push({
+            role: "user",
+            content: [{
+              type: "text",
+              text: "You must either use available tools to accomplish the task or call attempt_completion when the task is complete."
+            }]
+          });
+        }
+      }
+    }
+  }
+
+  private async executeTools(message: string): Promise<ToolResult[]> {
+    const results: ToolResult[] = [];
+    const toolRegex = /<(\w+)>\s*([\s\S]*?)\s*<\/\1>/g;
+    let match;
+    
+    while ((match = toolRegex.exec(message)) !== null) {
+      const [_, toolName, paramsXml] = match;
+      const params: Record<string, string> = {};
+      const paramRegex = /<(\w+)>\s*([\s\S]*?)\s*<\/\1>/g;
+      let paramMatch;
+      
+      while ((paramMatch = paramRegex.exec(paramsXml)) !== null) {
+        const [__, paramName, paramValue] = paramMatch;
+        params[paramName] = paramValue.trim();
+      }
+
+      let output: string;
+      try {
+        console.log(yellow(`\nExecuting: ${this.getToolDescription(toolName, params)}`));
+        
+        switch (toolName) {
+          case "execute_command":
+            output = await executeCommand(params.command);
+            break;
+          case "read_file":
+            output = await readFile(this.workingDir, params.path);
+            break;
+          case "write_to_file":
+            output = await writeFile(this.workingDir, params.path, params.content);
+            break;
+          case "search_files":
+            output = await searchFiles(this.workingDir, params.path, params.regex, params.file_pattern);
+            break;
+          case "list_files":
+            output = await listFiles(this.workingDir, params.path, params.recursive === "true");
+            break;
+          case "list_code_definition_names":
+            output = await listCodeDefinitions(this.workingDir, params.path);
+            break;
+          case "attempt_completion":
+            return results;
+          default:
+            console.warn(red(`Unknown tool: ${toolName}`));
+            continue;
+        }
+
+        results.push({
+          tool: toolName,
+          params,
+          output: output || "(No output)"
+        });
+
+        break;
+      } catch (error) {
+        const errorMessage = `Error executing ${toolName}: ${error instanceof Error ? error.message : String(error)}`;
+        console.error(red(errorMessage));
+        results.push({
+          tool: toolName,
+          params,
+          output: errorMessage
+        });
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  private getToolDescription(toolName: string, params: Record<string, string>): string {
+    switch (toolName) {
+      case "execute_command":
+        return `Running command: ${params.command}`;
+      case "read_file":
+        return `Reading file: ${params.path}`;
+      case "write_to_file":
+        return `Writing to file: ${params.path}`;
+      case "search_files":
+        return `Searching for "${params.regex}" in ${params.path}`;
+      case "list_files":
+        return `Listing files in ${params.path}`;
+      case "list_code_definition_names":
+        return `Analyzing code in ${params.path}`;
+      case "attempt_completion":
+        return "Completing task";
+      default:
+        return toolName;
+    }
+  }
+}