Refactor user settings and session management; remove custom commands handling and update system prompt logic

Author: PrashamTrivedi

src/commands/settings.ts

@@ -1,13 +1,11 @@
 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"
+import {parseFlagForHelp} from "../utils/functions.ts"
 
 export async function handleSettings(args: string[]): Promise<void> {
     const settingsFlags = {
-        string: ["set-name", "add-command", "remove-command", "set-jina-key", "set-config", "set-editor"],
+        string: ["set-name", "set-jina-key", "set-config", "set-editor"],
         boolean: ["list"],
-
     }
     const flags = parseArgs(args, settingsFlags)
 
@@ -28,40 +26,6 @@ export async function handleSettings(args: string[]): Promise<void> {
         settings.jinaApiKey = flags["set-jina-key"]
         console.log("Jina API key has been set")
     }
-    else if (flags["add-command"]) {
-        const commandNameFromArg = flags["add-command"] as string
-        let commandName = commandNameFromArg
-        let commandDescription = ""
-        if (commandNameFromArg.includes(",")) {
-            const commandSplit = commandNameFromArg.split(",")
-            commandName = commandSplit[0]
-            commandDescription = commandSplit[1]
-        }
-        const helpInfo = await getCommandHelp(commandName)
-        console.log(`Got help info for ${commandName}}`)
-
-        const existingCommandIndex = settings.customCommands.findIndex(cmd => cmd.name === commandName)
-        if (existingCommandIndex >= 0) {
-            settings.customCommands[existingCommandIndex] = {
-                name: commandName,
-                description: commandDescription || helpInfo.description,
-                helpText: helpInfo.helpText,
-            }
-        } else {
-            settings.customCommands.push({
-                name: commandName,
-                description: commandDescription || helpInfo.description,
-                helpText: helpInfo.helpText,
-            })
-        }
-        console.log(`Added command ${commandName} with help information`)
-    }
-    else if (flags["remove-command"]) {
-        const commandNameFromArg = flags["remove-command"] as string
-        const index = settings.customCommands.findIndex(cmd => cmd.name === commandNameFromArg)
-        console.log(`Removing command ${flags["remove-command"]} at index ${index}`)
-        if (index >= 0) settings.customCommands.splice(index, 1)
-    }
     else if (flags.list) {
         console.log(JSON.stringify(settings, null, 2))
         return

src/config/constants.ts

@@ -87,16 +87,99 @@ ${isJinaAvailable() ? `
     - Arguments: {searchTerm: string}
 ` : ''}
 
+
+
+Your capabilities include:
+
+1. File System Access:
+   - Full access to read and edit files
+   - All paths should be relative to current directory
+   - Use './' or '.' for current directory references
+   - Use relative paths for subdirectories
+
+2. Command Execution:
+   - Can execute shell commands in the current environment
+   - Ensure commands are compatible with the system
+   - Can navigate and manipulate the file system
+
+3. Memory Management:
+   - Access to system memory via /root/memory.json
+   - Can add, retrieve, and clear memories
+   - Use memory for context persistence
+
+4. Clipboard Access:
+    - Can read content from the system clipboard
+${isJinaAvailable() ? `
+5. Jina API Integration:
+    - Can read and parse content from a URL
+    - Can search content using Jina Search API
+    - Can search with grounding using Jina Grounding API
+` : ''}
+
 Before taking any action, follow these steps:
 
 
 Some tips:
 - For any non file operations, use the BASH_TOOL
 - If you need to locate the file, use BASH_TOOL to find the file path
-- EDITOR_TOOL works best when you have the exact file path to work with
+- EDITOR_TOOL works best when you have the exact file path to work with.
 - Best way to write or update a file is to use EDITOR_TOOL.
 - If an information is needed to be stored for future reference, use MEMORY_TOOLS.
+- If you need to read content from a URL, search online use JINA_TOOLS.
+`
+
+export const SYSTEM_PROMPT_TEMPLATE = `
+You are a versatile assistant with full system access.
+You are currently operating in \${Deno.cwd()} directory.
+
+You have access to following tools and capabilities:
+
+- BASH_TOOL:
+    - Name: "bash"
+    - Description: Execute shell commands
+    - Arguments:
+        - command: string (required) - The shell command to execute
+        - restart: boolean (optional) - Restart shell session if true
+        - Example: {command: "ls -la", restart: false}
+
+- EDITOR_TOOL:
+    - Name: "str_replace_editor"
+    - Description: File manipulation operations
+    - Commands:
+        - view:
+            - path: string (required)
+        - create:
+            -path: string (required)
+            - file_text: string (required)
+        - str_replace:
+            - path: string (required)
+            - old_str: string (required)
+            - new_str: string (required)
+        - insert:
+            - path: string (required)
+            - insert_line: number (required)
+            - new_str: string (required)
+- MEMORY_TOOLS:
+    - Name: "add_memory"
+    - Arguments: {content: string}
+    - Name: "get_memories"
+    - Arguments: none
+    - Name: "clear_memories"
+    - Arguments: none
+- CLIPBOARD_TOOLS:
+    - Name: "read_clipboard"
+    - Arguments: none
+\${isJinaAvailable() ? \`
+- JINA_TOOLS:
+    - Name: "readPage"
+    - Arguments: {url: string}
+    - Name: "search"
+    - Arguments: {searchTerm: string}
+    - Name: "searchGrounding"
+    - Arguments: {searchTerm: string}
+\` : ''}
 
+\${additionalTools}
 
 Your capabilities include:
 
@@ -118,17 +201,26 @@ Your capabilities include:
 
 4. Clipboard Access:
     - Can read content from the system clipboard
-${isJinaAvailable() ? `
+\${isJinaAvailable() ? \`
 5. Jina API Integration:
     - Can read and parse content from a URL
     - Can search content using Jina Search API
     - Can search with grounding using Jina Grounding API
-` : ''}
+\` : ''}
 
-Always present your solution in this order:
-1. Understanding of the request
-2. Step-by-step plan
-3. Detailed execution of each step`
+Before taking any action, follow these steps:
+
+Some tips:
+- For any non file operations, use the BASH_TOOL
+- If you need to locate the file, use BASH_TOOL to find the file path
+- EDITOR_TOOL works best when you have the exact file path to work with.
+- Best way to write or update a file is to use EDITOR_TOOL.
+- If an information is needed to be stored for future reference, use MEMORY_TOOLS.
+- If you need to read content from a URL, search online use JINA_TOOLS.
+
+\${userContext}
+\${additionalInstructions ?? ''}
+`
 
 export const API_CONFIG = {
     MODEL: "claude-3-5-sonnet-20241022",
@@ -230,18 +322,41 @@ export const JINA_TOOLS: Anthropic.Beta.BetaTool[] = [
     },
 ]
 
-// Remove ALL_TOOLS export and definition
+interface SchemaProperty {
+    type: string
+    description?: string
+}
 
-export function getSystemContext(basePrompt: string): string {
+export function getSystemContext(
+    additionalTools: Anthropic.Beta.Messages.BetaTool[] = [],
+    additionalInstructions?: string
+): string {
     const settings = loadUserSettings()
-    const customCommandsContext = settings.customCommands.length > 0
-        ? "\nAvailable Commands:\n" + settings.customCommands
-            .map(cmd => `- ${cmd.name}: ${cmd.description}${cmd.helpCommand ? `\n  Help: ${cmd.helpCommand}` : ''
-                }${cmd.helpText ? `\n  Flags: ${cmd.helpText}` : ''
-                }`).join('\n')
-        : ''
-
-    return `${basePrompt}
+
+    const toolsString = additionalTools.map(tool => {
+        const schema = tool.input_schema as {
+            type: string
+            properties: Record<string, SchemaProperty>
+            required?: string[]
+        }
+        return `
+- ${tool.name.toUpperCase()}:
+    - Name: "${tool.name}"
+    - Description: ${tool.description}
+    - Arguments: ${Object.entries(schema.properties)
+                .map(([name, prop]) => `
+        - ${name}: ${prop.type}${schema.required?.includes(name) ? ' (required)' : ''} - ${prop.description || ''}`)
+                .join('')}
+`
+    }).join('\n')
+
+    const userContext = `
 User Context:
-- Name: ${settings.userName}${customCommandsContext}`
+- Name: ${settings.userName}
+`
+
+    return SYSTEM_PROMPT_TEMPLATE
+        .replace('${additionalTools}', toolsString)
+        .replace('${userContext}', userContext)
+        .replace('${additionalInstructions ?? \'\'}', additionalInstructions ?? '')
 }

src/config/settings.ts

@@ -1,11 +1,9 @@
 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"),
     editorCommand: "nano"

src/modules/bash/bash_session.ts

@@ -2,6 +2,7 @@ import {BaseSession} from "../../utils/session.ts"
 import {BASH_SYSTEM_PROMPT, API_CONFIG, MEMORY_TOOLS} from "../../config/constants.ts"
 import {log} from "../../config/logging.ts"
 import {ToolHandler} from "../../utils/tool_handler.ts"
+import Anthropic from "anthropic";
 
 export class BashSession extends BaseSession {
     private toolHandler: ToolHandler
@@ -47,7 +48,7 @@ System Context:
                     tools: [{type: "bash_20241022", name: "bash"}
                         , ...MEMORY_TOOLS
                     ],
-                    system: this.getSystemPrompt(systemContext),
+                    system: this.getSystemPrompt(),
                     betas: ["computer-use-2024-10-22"],
                 })
 

src/modules/hybrid/hybrid_session.ts

@@ -1,13 +1,16 @@
 import {BaseSession} from "../../utils/session.ts"
-import {COMBINED_SYSTEM_PROMPT, API_CONFIG} from "../../config/constants.ts"
+import {API_CONFIG} from "../../config/constants.ts"
 import {log} from "../../config/logging.ts"
 import {ToolHandler} from "../../utils/tool_handler.ts"
 import {getConfigFileLocation} from "../../config/settings.ts"
 import {ToolConfigManager} from "../../config/tool_config.ts"
 import generatePlan from "../planner/planner.ts"
+import {ToolCall} from "../../types/interfaces.ts"
+import Anthropic from "anthropic"
 
 export class HybridSession extends BaseSession {
     private toolHandler: ToolHandler
+    private cachedSystemPrompt: string = ""
 
     constructor(sessionId: string, noAgi = false) {
         super(sessionId)
@@ -26,6 +29,9 @@ export class HybridSession extends BaseSession {
                 cwd: Deno.cwd(),
             }
 
+            // Cache the system prompt
+            this.cachedSystemPrompt = this.getSystemPrompt(this.toolHandler.getDynamicTools())
+
             // Generate execution plan
             const plan = await generatePlan(JSON.stringify(systemInfo), this.toolHandler.getAllTools(), prompt)
             log.info(`Plan: ${JSON.stringify(plan)}`)
@@ -54,7 +60,7 @@ export class HybridSession extends BaseSession {
                                 {type: "text_editor_20241022", name: "str_replace_editor"},
                                 ...tools
                             ],
-                            system: this.getSystemPrompt(`${COMBINED_SYSTEM_PROMPT}\nSystem Context: ${JSON.stringify(systemInfo)}`),
+                            system: this.cachedSystemPrompt,
                             betas: ["computer-use-2024-10-22"],
                         })
 
@@ -78,7 +84,7 @@ export class HybridSession extends BaseSession {
                             break
                         }
 
-                        const toolResults = await this.toolHandler.processToolCalls(response.content)
+                        const toolResults = await this.toolHandler.processToolCalls(response.content as Anthropic.Beta.BetaToolUseBlock[])
                         if (toolResults?.length) {
                             this.messages.push({
                                 role: "user",
@@ -90,7 +96,6 @@ export class HybridSession extends BaseSession {
                                 stepError = error
                                 break
                             }
-                            // Add tool result to step result
                             stepResult += toolResults[0].output.content[0].text + "\n"
                         }
                     }
@@ -111,7 +116,7 @@ export class HybridSession extends BaseSession {
             }
 
             this.logger.logTotalCost()
-            await this.logInteraction('hybrid', prompt, "completed")
+            await this.logInteraction('hybrid', `${this.cachedSystemPrompt}\n${prompt}`, "completed")
         } catch (error) {
             log.error(`Error in hybrid process: ${error instanceof Error ? error.message : String(error)}`)
             if (error instanceof Error && error.stack) {

src/types/interfaces.ts

@@ -41,12 +41,6 @@ export interface MemoryFile {
 
 export interface UserSettings {
   userName: string
-  customCommands: {
-    name: string
-    description: string
-    helpCommand?: string
-    helpText?: string
-  }[]
   jinaApiKey?: string
   toolConfigPath: string
   editorCommand: string
@@ -76,3 +70,18 @@ export interface PlanStep {
 export interface Plan {
   planSteps: PlanStep[]
 }
+
+export interface FileTool {
+  command: 'view' | 'create' | 'str_replace' | 'insert' | 'undo_edit'
+  path: string
+  file_text?: string
+  old_str?: string
+  new_str?: string
+  insert_line?: number
+  view_range?: number[]
+}
+
+export interface BashTools {
+  command?: string
+  restart?: boolean
+}

src/utils/session.ts

@@ -1,4 +1,4 @@
-import {Anthropic} from 'anthropic'
+import Anthropic from "anthropic"
 import {format} from "jsr:@std/datetime"
 import {crypto} from "jsr:@std/crypto"
 import {log} from "../config/logging.ts"
@@ -94,7 +94,10 @@ export class BaseSession {
     })
   }
 
-  protected getSystemPrompt(basePrompt: string): string {
-    return getSystemContext(basePrompt)
+  protected getSystemPrompt(
+    additionalTools: Anthropic.Beta.Messages.BetaTool[] = [],
+    additionalInstructions?: string
+  ): string {
+    return getSystemContext(additionalTools, additionalInstructions)
   }
 }