Enhance logging and user settings management; add editor command configuration and tool configuration validation

PrashamTrivedi · PrashamTrivedi · commit 9e0af9e69365 · 2025-02-09T13:58:21.000+05:30
diff --git a/config/examples/tool_config.json b/config/examples/tool_config.json
@@ -0,0 +1,46 @@
+{
+  "tools": [
+    {
+      "toolName": "generateText",
+      "command": "python generate.py --prompt '{{prompt}}'",
+      "output": "string",
+      "description": "Generate text using AI",
+      "enabled": true,
+      "inputs": [
+        {
+          "name": "prompt",
+          "type": "string",
+          "description": "Input prompt",
+          "required": true
+        }
+      ]
+    },
+    {
+      "toolName": "multipleGenerate",
+      "command": "python generate.py --prompt '{{prompt}}' --dir '{{currentDirectory}}' --count {{numberOfGenerations}}",
+      "output": "string",
+      "description": "Generate multiple texts",
+      "enabled": true,
+      "inputs": [
+        {
+          "name": "prompt",
+          "type": "string",
+          "description": "Input prompt",
+          "required": true
+        },
+        {
+          "name": "currentDirectory",
+          "type": "string",
+          "description": "Output directory",
+          "required": true
+        },
+        {
+          "name": "numberOfGenerations",
+          "type": "number",
+          "description": "Number of texts to generate",
+          "required": true
+        }
+      ]
+    }
+  ]
+}
diff --git a/src/commands/editor.ts b/src/commands/editor.ts
@@ -0,0 +1,21 @@
+import { loadUserSettings } from "../config/settings.ts";
+import { log } from "../config/logging.ts";
+import { DEFAULT_EDITOR } from "../config/constants.ts";
+
+export async function openInEditor(filePath: string): Promise<void> {
+  const settings = await loadUserSettings();
+  const editorCmd = settings.editorCommand || DEFAULT_EDITOR;
+  
+  try {
+    const process = new Deno.Command(editorCmd, {
+      args: [filePath],
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    
+    await process.output();
+  } catch (error) {
+    log.error(`Failed to open editor: ${error}`);
+  }
+}
diff --git a/src/commands/settings.ts b/src/commands/settings.ts
@@ -1,11 +1,13 @@
 import {parseArgs} from "jsr:@std/cli/parse-args"
 import {loadUserSettings, saveUserSettings} from "../config/settings.ts"
 import {parseFlagForHelp, getCommandHelp} from "../utils/functions.ts"
+import {DEFAULT_TOOLS_CONFIG_PATH} from "../config/constants.ts"
 
 export async function handleSettings(args: string[]): Promise<void> {
     const settingsFlags = {
-        string: ["set-name", "add-command", "remove-command", "set-jina-key", "set-config"],
+        string: ["set-name", "add-command", "remove-command", "set-jina-key", "set-config", "set-editor"],
         boolean: ["list"],
+
     }
     const flags = parseArgs(args, settingsFlags)
 
@@ -64,6 +66,10 @@ export async function handleSettings(args: string[]): Promise<void> {
         console.log(JSON.stringify(settings, null, 2))
         return
     }
+    else if (flags["set-editor"]) {
+        settings.editorCommand = flags["set-editor"]
+        console.log(`Editor command set to: ${flags["set-editor"]}`)
+    }
 
     await saveUserSettings(settings)
 }
diff --git a/src/config/constants.ts b/src/config/constants.ts
@@ -7,6 +7,9 @@ export const EDITOR_DIR = join(homedir(), ".ComputerUseAgent", "editor_dir")
 export const SESSIONS_DIR = join(homedir(), ".ComputerUseAgent", "sessions")
 export const LOGS_DIR = join(homedir(), ".ComputerUseAgent", "logs")
 export const DEFAULT_TOOLS_CONFIG_PATH = join(homedir(), ".ComputerUseAgent", "settings.json")
+export const MEMORY_PATH = "/root/memory.json"
+
+export const DEFAULT_EDITOR = Deno.env.get("EDITOR") ?? "nano";
 
 export const EDITOR_SYSTEM_PROMPT = Deno.env.get("EDITOR_SYSTEM_PROMPT") ??
     `You are a helpful assistant that helps users edit and work with text files.
diff --git a/src/config/settings.ts b/src/config/settings.ts
@@ -1,12 +1,14 @@
 import {join} from "jsr:@std/path"
 import {homedir} from "node:os"
 import {UserSettings} from "../types/interfaces.ts"
+import {DEFAULT_EDITOR} from "./constants.ts"
 
 const DEFAULT_SETTINGS: UserSettings = {
     userName: "User",
     customCommands: [],
     jinaApiKey: undefined,
-    toolConfigPath: join(homedir(), ".ComputerUseAgent", "tools.json")
+    toolConfigPath: join(homedir(), ".ComputerUseAgent", "tools.json"),
+    editorCommand: "nano"
 }
 
 const SETTINGS_PATH = join(homedir(), ".ComputerUseAgent", "settings.json")
diff --git a/src/config/tool_config.ts b/src/config/tool_config.ts
@@ -1,14 +1,28 @@
 import {ToolConfig} from "../types/interfaces.ts"
 
 export class ToolConfigManager {
+    validateToolConfig(config: ToolConfig[]): boolean {
+        return config.every(tool => {
+            return tool.toolName &&
+                   tool.command &&
+                   Array.isArray(tool.inputs) &&
+                   tool.inputs.every(input => input.name && input.type);
+        });
+    }
+
     loadConfig(configPath: string): ToolConfig[] {
         try {
-            const configText = Deno.readTextFileSync(configPath)
-            const config = JSON.parse(configText)
-            return Array.isArray(config) ? config : config.tools || []
+            const configText = Deno.readTextFileSync(configPath);
+            const config = JSON.parse(configText);
+            const tools = Array.isArray(config) ? config : config.tools || [];
+            
+            if (!this.validateToolConfig(tools)) {
+                throw new Error("Invalid tool configuration format");
+            }
+            return tools;
         } catch (error) {
-            console.warn(`Could not load config from ${configPath}: ${error}`)
-            return []
+            console.warn(`Could not load config from ${configPath}: ${error}`);
+            return [];
         }
     }
 }
diff --git a/src/main.ts b/src/main.ts
@@ -6,13 +6,15 @@ import {format} from "jsr:@std/datetime"
 import {crypto} from "jsr:@std/crypto"
 
 import {setupLogging, log} from "./config/logging.ts"
-import {EDITOR_DIR, SESSIONS_DIR} from "./config/constants.ts"
+import {EDITOR_DIR, SESSIONS_DIR, DEFAULT_TOOLS_CONFIG_PATH, MEMORY_PATH} from "./config/constants.ts"
 import {EditorSession} from "./modules/editor/editor_session.ts"
 import {BashSession} from "./modules/bash/bash_session.ts"
 import {HybridSession} from "./modules/hybrid/hybrid_session.ts"
 import {parseFlagForHelp} from "./utils/functions.ts"
 import {handleHistory} from "./commands/history.ts"
 import {handleSettings} from "./commands/settings.ts"
+import {loadUserSettings} from "./config/settings.ts"
+import {openInEditor} from "./commands/editor.ts"
 
 async function main() {
   await setupLogging()
@@ -40,6 +42,21 @@ async function main() {
   } else if (flags._[0] === "help") {
     console.log(parseFlagForHelp(argParseConfig))
     return
+  } else if (flags._[0] === "edit") {
+    const settings = loadUserSettings()
+    switch (flags._[1]) {
+      case "tools":
+        log.info(`Opening tools config file: ${settings.toolConfigPath}`)
+        await openInEditor(settings.toolConfigPath || DEFAULT_TOOLS_CONFIG_PATH)
+        return
+      case "memory":
+        log.info(`Opening memory file: ${MEMORY_PATH}`)
+        await openInEditor(MEMORY_PATH)
+        return
+      default:
+        console.log("Usage: edit [tools|memory]")
+    }
+    return
   }
 
   if (mode === "editor") {
diff --git a/src/modules/bash/handlers.ts b/src/modules/bash/handlers.ts
@@ -12,6 +12,7 @@ export class BashHandlers {
     async handleBashCommand(
         toolCall: Record<string, any>,
     ): Promise<Record<string, any>> {
+        log.info(`I am running command: ${toolCall.command}`)
         try {
             const command = toolCall.command as string
             const restart = toolCall.restart ?? false
diff --git a/src/modules/clipboard/clipboard.ts b/src/modules/clipboard/clipboard.ts
@@ -39,6 +39,7 @@ export class ClipboardManager {
 
     async readClipboard(): Promise<string> {
         try {
+            log.info(`Reading clipboard`)
             const os = Deno.build.os
             const isWsl = Deno.env.get("WSL_DISTRO_NAME") !== undefined
 
diff --git a/src/modules/db/database.ts b/src/modules/db/database.ts
@@ -68,7 +68,6 @@ export class PromptDatabase {
                 cost: data.cost
             }
         )
-        log.debug({number})
         return number
     }
 
diff --git a/src/modules/editor/handlers.ts b/src/modules/editor/handlers.ts
@@ -1,15 +1,16 @@
-import { ensureFileSync } from "jsr:@std/fs";
-import { log } from "../../config/logging.ts";
-import { ToolCall } from "../../types/interfaces.ts";
+import {ensureFileSync} from "jsr:@std/fs"
+import {log} from "../../config/logging.ts"
+import {ToolCall} from "../../types/interfaces.ts"
 
 export class EditorHandlers {
   async handleView(path: string): Promise<Record<string, string>> {
     try {
-      const content = await Deno.readTextFile(path);
-      return { content };
+      log.info(`Viewing file at path: ${path}`)
+      const content = await Deno.readTextFile(path)
+      return {content}
     } catch (error) {
-      log.error(`Error viewing file: ${error}`);
-      return { error: `File ${path} does not exist` };
+      log.error(`Error viewing file: ${error}`)
+      return {error: `File ${path} does not exist`}
     }
   }
 
@@ -18,12 +19,13 @@ export class EditorHandlers {
     toolCall: ToolCall["input"],
   ): Promise<Record<string, string>> {
     try {
-      ensureFileSync(path);
-      await Deno.writeTextFile(path, toolCall.file_text || "");
-      return { content: `File created at ${path}` };
+      log.info(`Creating file at path: ${path}`)
+      ensureFileSync(path)
+      await Deno.writeTextFile(path, toolCall.file_text || "")
+      return {content: `File created at ${path}`}
     } catch (error) {
-      log.error(`Error creating file: ${error}`);
-      return { error: String(error) };
+      log.error(`Error creating file: ${error}`)
+      return {error: String(error)}
     }
   }
 
@@ -32,19 +34,20 @@ export class EditorHandlers {
     toolCall: ToolCall["input"],
   ): Promise<Record<string, string>> {
     try {
-      const content = await Deno.readTextFile(path);
+      log.info(`Replacing string in file at path: ${path}`)
+      const content = await Deno.readTextFile(path)
       if (!toolCall.old_str || !content.includes(toolCall.old_str)) {
-        return { error: "old_str not found in file" };
+        return {error: "old_str not found in file"}
       }
       const newContent = content.replace(
         toolCall.old_str,
         toolCall.new_str || "",
-      );
-      await Deno.writeTextFile(path, newContent);
-      return { content: "File updated successfully" };
+      )
+      await Deno.writeTextFile(path, newContent)
+      return {content: "File updated successfully"}
     } catch (error) {
-      log.error(`Error replacing string: ${error}`);
-      return { error: String(error) };
+      log.error(`Error replacing string: ${error}`)
+      return {error: String(error)}
     }
   }
 
@@ -53,17 +56,18 @@ export class EditorHandlers {
     toolCall: ToolCall["input"],
   ): Promise<Record<string, string>> {
     try {
-      const content = await Deno.readTextFile(path);
-      const lines = content.split("\n");
+      log.info(`Inserting content in file at path: ${path}`)
+      const content = await Deno.readTextFile(path)
+      const lines = content.split("\n")
       if (!toolCall.insert_line || toolCall.insert_line > lines.length) {
-        return { error: "insert_line beyond file length" };
+        return {error: "insert_line beyond file length"}
       }
-      lines.splice(toolCall.insert_line, 0, toolCall.new_str || "");
-      await Deno.writeTextFile(path, lines.join("\n"));
-      return { content: "Content inserted successfully" };
+      lines.splice(toolCall.insert_line, 0, toolCall.new_str || "")
+      await Deno.writeTextFile(path, lines.join("\n"))
+      return {content: "Content inserted successfully"}
     } catch (error) {
-      log.error(`Error inserting content: ${error}`);
-      return { error: String(error) };
+      log.error(`Error inserting content: ${error}`)
+      return {error: String(error)}
     }
   }
 
@@ -72,7 +76,7 @@ export class EditorHandlers {
   ): Promise<Record<string, string>> {
     try {
       if (!toolCall.command || !toolCall.path) {
-        return { error: "Missing required fields" };
+        return {error: "Missing required fields"}
       }
 
       const handlers: Record<
@@ -86,17 +90,17 @@ export class EditorHandlers {
         create: (path, input) => this.handleCreate(path, input),
         str_replace: (path, input) => this.handleStrReplace(path, input),
         insert: (path, input) => this.handleInsert(path, input),
-      };
+      }
 
-      const handler = handlers[toolCall.command];
+      const handler = handlers[toolCall.command]
       if (!handler) {
-        return { error: `Unknown command ${toolCall.command}` };
+        return {error: `Unknown command ${toolCall.command}`}
       }
 
-      return await handler(toolCall.path, toolCall);
+      return await handler(toolCall.path, toolCall)
     } catch (error) {
-      log.error(`Error in handleTextEditorTool: ${error}`);
-      return { error: String(error) };
+      log.error(`Error in handleTextEditorTool: ${error}`)
+      return {error: String(error)}
     }
   }
 }
diff --git a/src/modules/hybrid/hybrid_session.ts b/src/modules/hybrid/hybrid_session.ts
@@ -56,7 +56,7 @@ export class HybridSession extends BaseSession {
                 )
 
                 this.messages.push({role: "assistant", content: responseContent})
-
+                
                 if (response.stop_reason !== "tool_use") {
                     console.log(response.content.find((block) => block.type === "text")?.text ?? "")
                     break
diff --git a/src/modules/memory/memory_manager.ts b/src/modules/memory/memory_manager.ts
@@ -1,12 +1,11 @@
 import {Memory, MemoryFile} from "../../types/interfaces.ts"
 import {log} from "../../config/logging.ts"
+import {MEMORY_PATH} from "../../config/constants.ts"
 
 export class MemoryManager {
-    private memoryPath = "/root/memory.json";
-
     private async readMemoryFile(): Promise<MemoryFile> {
         try {
-            const content = await Deno.readTextFile(this.memoryPath)
+            const content = await Deno.readTextFile(MEMORY_PATH)
             return JSON.parse(content)
         } catch {
             return {memories: []}
@@ -15,7 +14,7 @@ export class MemoryManager {
 
     private async writeMemoryFile(data: MemoryFile): Promise<void> {
         console.log(`Writing memory file: ${JSON.stringify(data, null, 2)}`)
-        await Deno.writeTextFile(this.memoryPath, JSON.stringify(data, null, 2))
+        await Deno.writeTextFile(MEMORY_PATH, JSON.stringify(data, null, 2))
     }
 
     async addMemory(content: string): Promise<Memory> {
@@ -33,11 +32,13 @@ export class MemoryManager {
     }
 
     async getMemories(): Promise<Memory[]> {
+        log.info(`Getting memories`)
         const memoryFile = await this.readMemoryFile()
         return memoryFile.memories
     }
 
     async clearMemories(): Promise<void> {
+        log.info(`Clearing memories`)
         await this.writeMemoryFile({memories: []})
     }
 }
diff --git a/src/types/interfaces.ts b/src/types/interfaces.ts
diff --git a/src/utils/dynamic_tool_handler.ts b/src/utils/dynamic_tool_handler.ts
diff --git a/src/utils/tool_handler.ts b/src/utils/tool_handler.ts

Original file line number	Diff line number	Diff line change
`@@ -68,7 +68,6 @@ export class PromptDatabase {`
`68`	`68`	`cost: data.cost`
`69`	`69`	`}`
`70`	`70`	`)`
`71`		`- log.debug({number})`
`72`	`71`	`return number`
`73`	`72`	`}`
`74`	`73`