Refactor session management and improve settings handling with synchronous file operations

PrashamTrivedi · PrashamTrivedi · commit f24caf5d1226 · 2025-01-24T19:14:40.000+05:30
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -1,3 +1,9 @@
 {
-    "deno.enable": true
+    "deno.enable": true,
+    // "github.copilot.chat.codeGeneration.instructions": [
+    //     {
+    //         "text": "Act as an expert architect engineer and provide direction to your editor engineer. Study the change request and the current code. Describe how to modify the code to complete the request. The editor engineer will rely solely on your instructions, so make them unambiguous and complete. Explain all needed code changes clearly and completely, but concisely. Just show the changes needed.DO NOT show the entire updated function/file/etc!"
+    //     }
+    // ],
+    "github.copilot.editor.enableCodeActions": true,
 }
diff --git a/src/commands/history.ts b/src/commands/history.ts
@@ -2,14 +2,20 @@ import {parseArgs} from "jsr:@std/cli/parse-args"
 import {PromptDatabase, type PromptEntry} from "../modules/db/database.ts"
 import {HistoryViewer} from "../modules/cli/history_viewer.ts"
 import {log} from "../config/logging.ts"
+import {parseFlagForHelp} from "../utils/functions.ts"
 
 export async function handleHistory(args: string[]) {
 
     const db = new PromptDatabase()
-    const flags = parseArgs(args, {
+    const commandFlags = {
         string: ["view", "limit"],
         default: {limit: "10"},
-    })
+    }
+    const flags = parseArgs(args, commandFlags)
+    if (flags._[1] === 'help') {
+        console.log(parseFlagForHelp(commandFlags))
+        return
+    }
 
     try {
         if (flags.view) {
diff --git a/src/commands/settings.ts b/src/commands/settings.ts
@@ -1,34 +1,41 @@
-import { parseArgs } from "jsr:@std/cli/parse-args";
-import { loadUserSettings, saveUserSettings } from "../config/settings.ts";
+import {parseArgs} from "jsr:@std/cli/parse-args"
+import {loadUserSettings, saveUserSettings} from "../config/settings.ts"
+import {parseFlagForHelp} from "../utils/functions.ts"
 
 export async function handleSettings(args: string[]): Promise<void> {
-    const flags = parseArgs(args, {
+    const settingsFlags = {
         string: ["set-name", "add-command", "remove-command"],
         boolean: ["list"],
-    });
+    }
+    const flags = parseArgs(args, settingsFlags)
 
-    const settings = await loadUserSettings();
+    if (flags._[1] === "help") {
+        console.log(parseFlagForHelp(settingsFlags))
+        return
+    }
+    const settings = await loadUserSettings()
 
     if (flags["set-name"]) {
-        settings.userName = flags["set-name"];
+        settings.userName = flags["set-name"]
     }
     else if (flags["add-command"]) {
-        const [name, description, helpCmd, ...helpFlags] = flags["add-command"].split(",");
+        const addCommandValue = flags["add-command"] as string;
+        const [name, description, helpCmd, ...helpFlags] = addCommandValue.split(",")
         settings.customCommands.push({
             name,
             description,
             helpCommand: helpCmd,
             helpFlags: helpFlags
-        });
+        })
     }
     else if (flags["remove-command"]) {
-        const index = settings.customCommands.findIndex(cmd => cmd.name === flags["remove-command"]);
-        if (index >= 0) settings.customCommands.splice(index, 1);
+        const index = settings.customCommands.findIndex(cmd => cmd.name === flags["remove-command"])
+        if (index >= 0) settings.customCommands.splice(index, 1)
     }
     else if (flags.list) {
-        console.log(JSON.stringify(settings, null, 2));
-        return;
+        console.log(JSON.stringify(settings, null, 2))
+        return
     }
 
-    await saveUserSettings(settings);
+    await saveUserSettings(settings)
 }
diff --git a/src/config/constants.ts b/src/config/constants.ts
@@ -1,7 +1,7 @@
 import {join} from "jsr:@std/path"
 import Anthropic from "npm:@anthropic-ai/sdk"
 import {homedir} from "node:os"
-import { loadUserSettings } from "./settings.ts";
+import {loadUserSettings} from "./settings.ts"
 
 export const EDITOR_DIR = join(homedir(), ".ComputerUseAgent", "editor_dir")
 export const SESSIONS_DIR = join(homedir(), ".ComputerUseAgent", "sessions")
@@ -150,18 +150,16 @@ export const CLIPBOARD_TOOLS: Anthropic.Beta.BetaTool[] = [
     }
 ]
 
-export async function getSystemContext(basePrompt: string): Promise<string> {
-    const settings = await loadUserSettings();
-    const customCommandsContext = settings.customCommands.length > 0 
+export function getSystemContext(basePrompt: string): string {
+    const settings = loadUserSettings()
+    const customCommandsContext = settings.customCommands.length > 0
         ? "\nCustom Commands:\n" + settings.customCommands
-            .map(cmd => `- ${cmd.name}: ${cmd.description}${
-                cmd.helpCommand ? `\n  Help: ${cmd.helpCommand}` : ''
-            }${
-                cmd.helpFlags ? `\n  Flags: ${cmd.helpFlags.join(', ')}` : ''
-            }`).join('\n')
-        : '';
+            .map(cmd => `- ${cmd.name}: ${cmd.description}${cmd.helpCommand ? `\n  Help: ${cmd.helpCommand}` : ''
+                }${cmd.helpFlags ? `\n  Flags: ${cmd.helpFlags.join(', ')}` : ''
+                }`).join('\n')
+        : ''
 
     return `${basePrompt}
 User Context:
-- Name: ${settings.userName}${customCommandsContext}`;
+- Name: ${settings.userName}${customCommandsContext}`
 }
diff --git a/src/config/settings.ts b/src/config/settings.ts
@@ -1,23 +1,23 @@
-import { join } from "jsr:@std/path";
-import { homedir } from "node:os";
-import { UserSettings } from "../types/interfaces.ts";
+import {join} from "jsr:@std/path"
+import {homedir} from "node:os"
+import {UserSettings} from "../types/interfaces.ts"
 
 const DEFAULT_SETTINGS: UserSettings = {
     userName: "User",
     customCommands: []
-};
+}
 
-const SETTINGS_PATH = join(homedir(), ".ComputerUseAgent", "settings.json");
+const SETTINGS_PATH = join(homedir(), ".ComputerUseAgent", "settings.json")
 
-export async function loadUserSettings(): Promise<UserSettings> {
+export function loadUserSettings(): UserSettings {
     try {
-        const content = await Deno.readTextFile(SETTINGS_PATH);
-        return { ...DEFAULT_SETTINGS, ...JSON.parse(content) };
+        const content = Deno.readTextFileSync(SETTINGS_PATH)
+        return {...DEFAULT_SETTINGS, ...JSON.parse(content)}
     } catch {
-        return DEFAULT_SETTINGS;
+        return DEFAULT_SETTINGS
     }
 }
 
-export async function saveUserSettings(settings: UserSettings): Promise<void> {
-    await Deno.writeTextFile(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+export function saveUserSettings(settings: UserSettings) {
+    Deno.writeTextFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2))
 }
diff --git a/src/main.ts b/src/main.ts
@@ -10,35 +10,36 @@ import {EDITOR_DIR, SESSIONS_DIR} 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 {determineIntent} from "./utils/intent.ts"
+import {parseFlagForHelp} from "./utils/functions.ts"
 import {handleHistory} from "./commands/history.ts"
-import { handleSettings } from "./commands/settings.ts"
+import {handleSettings} from "./commands/settings.ts"
 
 async function main() {
   await setupLogging()
   await ensureDir(EDITOR_DIR)
   await ensureDir(SESSIONS_DIR)
 
-  const flags = parseArgs(Deno.args, {
+  const argParseConfig = {
     string: ["mode"],
     boolean: ["no-agi"],
     default: {"no-agi": false},
-  })
+  }
+  const flags = parseArgs(Deno.args, argParseConfig)
 
   const prompt = flags._.join(" ")
   const sessionId = `${format(new Date(), "yyyyMMdd-HHmmss")}-${crypto.randomUUID().slice(0, 6)}`
 
   const mode = flags.mode
-  log.debug(`Mode selected: ${mode}`)
 
   if (flags._[0] === "history") {
-    await handleHistory(flags._.map(arg => String(arg)))
+    await handleHistory(Deno.args)
+    return
+  } else if (flags._[0] === "settings") {
+    await handleSettings(Deno.args)
+    return
+  } else if (flags._[0] === "help") {
+    console.log(parseFlagForHelp(argParseConfig))
     return
-  }
-
-  if (flags._[0] === "settings") {
-    await handleSettings(flags._.slice(1));
-    return;
   }
 
   if (mode === "editor") {
diff --git a/src/modules/bash/bash_session.ts b/src/modules/bash/bash_session.ts
@@ -1,14 +1,14 @@
-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 {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"
 
 export class BashSession extends BaseSession {
-    private toolHandler: ToolHandler;
+    private toolHandler: ToolHandler
 
     constructor(sessionId?: string, noAgi = false) {
-        super(sessionId);
-        this.toolHandler = new ToolHandler(noAgi);
+        super(sessionId)
+        this.toolHandler = new ToolHandler(noAgi)
     }
 
     async processBashCommand(bashPrompt: string): Promise<void> {
@@ -46,7 +46,7 @@ System Context:
                     tools: [{type: "bash_20241022", name: "bash"}
                         , ...MEMORY_TOOLS
                     ],
-                    system: systemContext,
+                    system: this.getSystemPrompt(systemContext),
                     betas: ["computer-use-2024-10-22"],
                 })
 
@@ -65,17 +65,17 @@ System Context:
                     break
                 }
 
-                const toolResults = await this.toolHandler.processToolCalls(response.content);
+                const toolResults = await this.toolHandler.processToolCalls(response.content)
 
                 if (toolResults.length) {
                     this.messages.push({
                         role: "user",
                         content: [toolResults[0].output],
-                    });
+                    })
 
                     if (toolResults[0].output.is_error) {
-                        log.error(`Error: ${toolResults[0].output.content[0].text}`);
-                        break;
+                        log.error(`Error: ${toolResults[0].output.content[0].text}`)
+                        break
                     }
                 }
             }
diff --git a/src/modules/hybrid/hybrid_session.ts b/src/modules/hybrid/hybrid_session.ts
@@ -42,7 +42,7 @@ export class HybridSession extends BaseSession {
                         ...MEMORY_TOOLS,
                         ...CLIPBOARD_TOOLS,
                     ],
-                    system: `${COMBINED_SYSTEM_PROMPT}\nSystem Context: ${JSON.stringify(systemInfo)}`,
+                    system: this.getSystemPrompt(`${COMBINED_SYSTEM_PROMPT}\nSystem Context: ${JSON.stringify(systemInfo)}`),
                     betas: ["computer-use-2024-10-22"],
                 })
 
diff --git a/src/utils/functions.ts b/src/utils/functions.ts
@@ -0,0 +1,72 @@
+import {ParseOptions} from "jsr:@std/cli/parse-args"
+import {log} from "../config/logging.ts"
+
+export function parseFlagForHelp(options: ParseOptions): string {
+    const helpSections: string[] = []
+
+    // Add usage section
+    helpSections.push(
+        "Usage:",
+        "  ComputerUseAgent [options] <command> [arguments]",
+        "",
+        "Commands:",
+        "  history    Show command history",
+        "  settings   Manage settings",
+        "  help       Show this help message",
+        "",
+        "Options:"
+    )
+
+    // Handle boolean flags
+    if (options.boolean) {
+        const booleans = Array.isArray(options.boolean) ? options.boolean : [options.boolean]
+        if (booleans.length > 0 && typeof booleans[0] !== 'boolean') {
+            helpSections.push(...booleans.map((flag: string) =>
+                `  --${flag}${' '.repeat(20 - flag.length)}Enable ${flag} flag${options.default?.[flag] !== undefined ? `, (Default: ${options.default[flag]})` : ''}`
+            ))
+        }
+    }
+
+    // Handle string flags
+    if (options.string) {
+        const strings = Array.isArray(options.string) ? options.string : [options.string]
+        if (strings.length > 0) {
+            helpSections.push(...strings.map((flag: string) =>
+                `  --${flag}=<value>${' '.repeat(16 - flag.length)}Set ${flag} value${options.default?.[flag] ? `, (Default: ${options.default[flag]})` : ''}`
+            ))
+        }
+    }
+
+    // Handle collectable flags
+    if (options.collect) {
+        const collectables = Array.isArray(options.collect) ? options.collect : [options.collect]
+        if (collectables.length > 0) {
+            helpSections.push(
+                "",
+                "Repeatable options:",
+                ...collectables.map((flag: string) =>
+                    `  --${flag}=<value>${' '.repeat(16 - flag.length)}Add ${flag} value (can be used multiple times)`
+                )
+            )
+        }
+    }
+
+    // Handle negatable flags
+    if (options.negatable) {
+        const negatables = Array.isArray(options.negatable) ? options.negatable : [options.negatable]
+        if (negatables.length > 0) {
+            helpSections.push(
+                "",
+                "Toggleable options:",
+                ...negatables.map((flag: string) =>
+                    `  --[no-]${flag}${' '.repeat(17 - flag.length)}Enable/disable ${flag}`
+                )
+            )
+        }
+    }
+
+
+
+    log.debug({sections: helpSections.length})
+    return helpSections.join('\n')
+}
diff --git a/src/utils/session.ts b/src/utils/session.ts
@@ -3,7 +3,7 @@ import {format} from "jsr:@std/datetime"
 import {crypto} from "jsr:@std/crypto"
 import {log} from "../config/logging.ts"
 import {PromptDatabase} from "../modules/db/database.ts"
-import { getSystemContext } from "../config/constants.ts";
+import {getSystemContext} from "../config/constants.ts"
 
 export class SessionLogger {
   private sessionId: string
@@ -30,7 +30,7 @@ export class SessionLogger {
     const totalOutputCost = (this.totalOutputTokens / 1_000_000) *
       costPerMillionOutputTokens
     const totalCost = totalInputCost + totalOutputCost
-    
+
     this.logger.info(`Session ${this.sessionId} costs:
       Input tokens: ${this.totalInputTokens}
       Output tokens: ${this.totalOutputTokens}
@@ -93,7 +93,7 @@ export class BaseSession {
     })
   }
 
-  protected async getSystemPrompt(basePrompt: string): Promise<string> {
-    return await getSystemContext(basePrompt);
+  protected getSystemPrompt(basePrompt: string): string {
+    return getSystemContext(basePrompt)
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,9 @@`
`1`	`1`	`{`
`2`		`- "deno.enable": true`
	`2`	`+ "deno.enable": true,`
	`3`	`+ // "github.copilot.chat.codeGeneration.instructions": [`
	`4`	`+ // {`
	`5`	`+ // "text": "Act as an expert architect engineer and provide direction to your editor engineer. Study the change request and the current code. Describe how to modify the code to complete the request. The editor engineer will rely solely on your instructions, so make them unambiguous and complete. Explain all needed code changes clearly and completely, but concisely. Just show the changes needed.DO NOT show the entire updated function/file/etc!"`
	`6`	`+ // }`
	`7`	`+ // ],`
	`8`	`+ "github.copilot.editor.enableCodeActions": true,`
`3`	`9`	`}`