Transitioned to plugin infra and added File Operations as well

Author: zabirauf

app/commands/agents.ts renamed to app/commandPlugins/AgentCommandPlugins.ts

@@ -1,7 +1,8 @@
 import { LLMMessage, LLMModel, callLLMChatCompletion } from "~/utils/llmUtils";
 import { Config } from "~/utils/config";
+import { CommandPlugin } from "./CommandPlugin";
 
-export interface Agent {
+interface Agent {
   name: string;
   task: string;
   messages: LLMMessage[];
@@ -11,7 +12,7 @@ export interface Agent {
 let nextkey = 0;
 const agents: {[key: string]: Agent} = {};
 
-export async function startAgent(
+async function startAgent(
   name: string,
   task: string,
   prompt: string,
@@ -25,7 +26,7 @@ export async function startAgent(
     return `Agent ${name} created with key ${key}. First response: ${agentResponse}`;
 }
 
-export async function createAgent(
+async function createAgent(
   name: string,
   task: string,
   prompt: string,
@@ -51,7 +52,7 @@ export async function createAgent(
   return { key, agentReply };
 }
 
-export async function messageAgent(
+async function messageAgent(
   key: string,
   message: string
 ): Promise<string> {
@@ -67,15 +68,54 @@ export async function messageAgent(
   return agentReply;
 }
 
-export function listAgents(): [string, string][] {
+function listAgents(): [string, string][] {
   return Object.keys(agents).map((key: string) => [key, agents[key].task]);
 }
 
-export function deleteAgent(key: string): boolean {
+function deleteAgent(key: string): boolean {
   if (agents[key]) {
     delete agents[key];
     return true;
   }
 
   return false;
 }
+
+const AgentCommandPlugins: CommandPlugin[] = [
+  {
+    command: "start_agent",
+    name: "Start GPT Agent",
+    arguments: {
+      name: "name",
+      task: "short_task_desc",
+      prompt: "prompt"
+    },
+    execute: (args) => startAgent(args["name"], args["task"], args["prompt"])
+  },
+  {
+    command: "message_agent",
+    name: "Message GPT Agent",
+    arguments: {
+      key: "key",
+      message: "message"
+    },
+    execute: (args) => messageAgent(args["key"], args["message"])
+  },
+  {
+    command: "list_agents",
+    name: "List GPT Agents",
+    arguments: {},
+    execute: async (args) => JSON.stringify(listAgents())
+  },
+  {
+    command: "delete_agent",
+    name: "Delete GPT Agent",
+    arguments: {
+      key: "key"
+    },
+    execute: async (args) => deleteAgent(args["key"])
+        ? `Agent ${args["key"]} deleted.`
+        : `Agent ${args["key"]} does not exist.`
+  }
+];
+export default AgentCommandPlugins;

app/commandPlugins/CommandPlugin.ts

@@ -0,0 +1,8 @@
+
+export type CommandExecArgs = { [key: string]: string };
+export interface CommandPlugin {
+    command: string;
+    name: string;
+    arguments: CommandExecArgs;
+    execute: (args: CommandExecArgs) => Promise<string>;
+}

app/commandPlugins/FileOperationCommandPlugins.ts

@@ -0,0 +1,118 @@
+import { CommandPlugin } from "./CommandPlugin";
+
+let directoryHandle: FileSystemDirectoryHandle | null = null;
+
+async function getDirectoryHandle() {
+  if (!directoryHandle) {
+    if (window.showDirectoryPicker) {
+      directoryHandle = await window.showDirectoryPicker();
+    } else {
+      //TODO: Create in-memory directory/file system
+    }
+  }
+
+  return directoryHandle!;
+}
+
+async function readFile(fileName: string) {
+  try {
+    const dh = await getDirectoryHandle();
+    const fileHandle = await dh.getFileHandle(fileName, { create: false });
+    if (!fileHandle) {
+      return "Error: Unable to read file";
+    }
+
+    const file = await fileHandle.getFile();
+    return await file.text();
+  } catch (error) {
+    console.error("Error reading from file", error);
+    return `Error: ${error}`;
+  }
+}
+
+async function writeToFile(fileName: string, text: string) {
+  try {
+    const dh = await getDirectoryHandle();
+    const fileHandle = await dh.getFileHandle(fileName, { create: true });
+    if (!fileHandle) {
+      return "Error: Unable to create a file";
+    }
+
+    const file = await fileHandle.createWritable();
+    await file.write(text);
+    await file.close();
+    return "File written to successfully";
+  } catch (error) {
+    console.error("Error writing to file", error);
+    return `Error: ${error}`;
+  }
+}
+
+async function appendToFile(fileName: string, text: string) {
+  try {
+    const dh = await getDirectoryHandle();
+    const fileHandle = await dh.getFileHandle(fileName, { create: true });
+    if (!fileHandle) {
+      return "Error: Unable to append to a file";
+    }
+
+    const file = await fileHandle.createWritable({ keepExistingData: true });
+    let offset = (await fileHandle.getFile()).size;
+    await file.write({ type: "seek", position: offset });
+    await file.write(text);
+    await file.close();
+    return "Text appended successfully";
+  } catch (error) {
+    console.error("Error appending to file", error);
+    return `Error: ${error}`;
+  }
+}
+
+async function deleteFile(fileName: string) {
+  try {
+    const dh = await getDirectoryHandle();
+    await dh.removeEntry(fileName);
+    return "File deleted successfully";
+  } catch (error) {
+    console.error("Error deleting file", error);
+    return `Error: ${error}`;
+  }
+}
+
+const FileOperationCommandPlugins: CommandPlugin[] = [
+  {
+    command: "write_to_file",
+    name: "Write to file",
+    arguments: {
+      file: "file",
+      text: "text",
+    },
+    execute: (args) => writeToFile(args["file"], args["text"]),
+  },
+  {
+    command: "read_file",
+    name: "Read file",
+    arguments: {
+      file: "file",
+    },
+    execute: (args) => readFile(args["file"]),
+  },
+  {
+    command: "append_to_file",
+    name: "Append to file",
+    arguments: {
+      file: "file",
+      text: "text",
+    },
+    execute: (args) => appendToFile(args["file"], args["text"]),
+  },
+  {
+    command: "delete_file",
+    name: "Delete file",
+    arguments: {
+      file: "file",
+    },
+    execute: (args) => deleteFile(args["file"]),
+  },
+];
+export default FileOperationCommandPlugins;

app/commandPlugins/MemoryCommandPlugins.ts

@@ -0,0 +1,62 @@
+import { CommandPlugin } from "./CommandPlugin";
+
+const permanentMemory: string[] = [];
+
+function commitMemory(val: string) {
+  permanentMemory.push(val);
+
+  return `Committing memory with string "${val}"`;
+}
+function getMemory(index: number) {
+  if (index >= permanentMemory.length) {
+    return "Invalid key, cannot retrieve memory.";
+  }
+  return permanentMemory[index];
+}
+
+function deleteMemory(index: number) {
+  if (index >= permanentMemory.length) {
+    return "Invalid key, cannot delete memory.";
+  }
+
+  permanentMemory.splice(index, 1);
+  return `Deleting memory with key ${index}.`;
+}
+
+function overwriteMemory(index: number, val: string) {
+  if (index >= permanentMemory.length) {
+    return "Invalid key, cannote overwrite memory.";
+  }
+
+  permanentMemory[index] = val;
+  return `Overwriting memory with key ${index} and string "${val}".`;
+}
+
+const MemoryCommandPlugins: CommandPlugin[] = [
+  {
+    command: "memory_add",
+    name: "Memory Add",
+    arguments: {
+      string: "string",
+    },
+    execute: async (args) => commitMemory(args["string"]),
+  },
+  {
+    command: "memory_del",
+    name: "Memory Delete",
+    arguments: {
+        key: "key"
+    },
+    execute: async (args) => deleteMemory(parseInt(args["key"]))
+  },
+  {
+    command: "memory_ovr",
+    name: "Memory Overwrite",
+    arguments: {
+        key: "key",
+        string: "string"
+    },
+    execute: async (args) => overwriteMemory(parseInt(args["key"]), args["string"])
+  },
+];
+export default MemoryCommandPlugins;

app/commandPlugins/index.ts

@@ -0,0 +1,25 @@
+import AgentCommandPlugins from "./AgentCommandPlugins";
+import MemoryCommandPlugins from "./MemoryCommandPlugins";
+import FileOperationCommandPlugins from "./FileOperationCommandPlugins";
+
+export const CommandPlugins = [
+  ...MemoryCommandPlugins,
+  ...AgentCommandPlugins,
+  ...FileOperationCommandPlugins
+];
+
+export async function executeCommand(
+  command: string,
+  args: { [key: string]: string }
+): Promise<string> {
+  try {
+    const commandPlugin = CommandPlugins.filter(({command: cmd}) => cmd == command)[0];
+    if (commandPlugin) {
+      return await commandPlugin.execute(args);
+    } else {
+        return `Unknown command ${command}`;
+    }
+  } catch (error) {
+    return `Error: ${error}`;
+  }
+}