@travisennis/acai 0.0.5 → 0.0.7

package/dist/commands/init-command.js

@@ -1,38 +1,56 @@
 import { platform } from "node:os";
 import { stepCountIs, streamText } from "ai";
-import { inGitDirectory } from "../tools/git-utils.js";
-import { initTools } from "../tools/index.js";
-export const initCommand = ({ terminal, modelManager, tokenCounter, toolEvents, }) => {
+import style from "../terminal/style.js";
+import { initCliTools } from "../tools/index.js";
+import { Markdown, Spacer, Text } from "../tui/index.js";
+import { inGitDirectory } from "../utils/git.js";
+const initPrompt = `Please analyze this codebase and create a AGENTS.md file containing:
+1. An overview of the project including how the project is structured and the tech stack used.
+2. Build/lint/test commands - especially for running a single test
+3. Directions on how to run the app
+4. Custom tools defined in ./.acai/tools
+3. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.
+4. Commit format (does the repository use Conventional Commits?)
+5. Branch strategy
+6. PR requirements
+
+The file you create will be given to agentic coding agents (such as yourself) that operate in this repository. Make it about 50 lines long.
+
+If there's already a AGENTS.md, improve it.
+If there are Cursor rules (in .cursor/rules/ or .cursorrules), Copilot rules (in .github/copilot-instructions.md or .github/instructions/), or Windsurf rules (in .windsurf/rules), make sure to include them.
+
+Your current working directory is ${process.cwd()}
+Is directory a git repo: ${(await inGitDirectory()) ? "Yes" : "No"}
+Platform: ${platform()}`;
+export const initCommand = ({ modelManager, tokenCounter, workspace, }) => {
     return {
         command: "/init",
         description: "Creates the AGENTS.md file.",
         getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
+        async handle(_args, { tui, container, editor, }) {
+            container.addChild(new Text("Initializing project and creating AGENTS.md...", 1, 1));
+            tui.requestRender();
             const result = streamText({
                 model: modelManager.getModel("init-project"),
                 temperature: 0.5,
-                prompt: `Please analyze this codebase and create a AGENTS.md file containing:
-1. Build/lint/test commands - especially for running a single test
-2. Code style guidelines including imports, formatting, types, naming conventions, error handling, etc.
-
-The file you create will be given to agentic coding agents (such as yourself) that operate in this repository. Make it about 20 lines long.
-
-If there's already a AGENTS.md, improve it.
-If there are Cursor rules (in .cursor/rules/ or .cursorrules), Copilot rules (in .github/copilot-instructions.md), or Windsurf rules (in .windsurf/rules), make sure to include them.
-
-Your current working directory is ${process.cwd()}
-Is directory a git repo: ${(await inGitDirectory()) ? "Yes" : "No"}
-Platform: ${platform()}`,
+                prompt: initPrompt,
                 stopWhen: stepCountIs(40),
-                tools: await initTools({
-                    terminal,
-                    tokenCounter,
-                    events: toolEvents,
-                }),
+                tools: (await initCliTools({ tokenCounter, workspace })).toolDefs,
             });
+            container.addChild(new Spacer(1));
+            let output = "";
+            const t = new Markdown(output, { paddingX: 1, paddingY: 0 });
+            container.addChild(t);
             for await (const text of result.textStream) {
-                terminal.write(text);
+                output += text;
+                // Update the display with the latest output
+                t.setText(output);
+                tui.requestRender();
             }
+            container.addChild(new Spacer(1));
+            container.addChild(new Text(style.green("AGENTS.md file created successfully"), 1, 0));
+            tui.requestRender();
+            editor.setText("");
             return "continue";
         },
     };

package/dist/commands/last-log-command.d.ts

@@ -1,3 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare const lastLogCommand: ({ terminal }: CommandOptions) => ReplCommand;
+export declare const lastLogCommand: (_options: CommandOptions) => ReplCommand;
 //# sourceMappingURL=last-log-command.d.ts.map

package/dist/commands/last-log-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"last-log-command.d.ts","sourceRoot":"","sources":["../../source/commands/last-log-command.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAyC9D,eAAO,MAAM,cAAc,GAAI,cAAc,cAAc,KAAG,WAqC7D,CAAC"}
+{"version":3,"file":"last-log-command.d.ts","sourceRoot":"","sources":["../../source/commands/last-log-command.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAyC9D,eAAO,MAAM,cAAc,GAAI,UAAU,cAAc,KAAG,WAiEzD,CAAC"}

package/dist/commands/last-log-command.js

@@ -1,8 +1,8 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { config } from "../config.js";
-import { editor } from "../terminal/editor-prompt.js";
 import style from "../terminal/style.js";
+import { Text } from "../tui/index.js";
 import { glob } from "../utils/glob.js";
 const isoDateRegex = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)/;
 // Function to find the most recent log file
@@ -36,34 +36,34 @@ async function findMostRecentLog(logDir) {
     datedFiles.sort((a, b) => b.date.getTime() - a.date.getTime());
     return datedFiles[0]?.file ?? null; // The first file is the most recent
 }
-export const lastLogCommand = ({ terminal }) => {
+export const lastLogCommand = (_options) => {
     return {
         command: "/last-log",
         description: "Opens the most recent REPL audit log in the editor.",
         getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
+        async handle(_args, { tui, container, editor, }) {
             const logDir = config.app.ensurePathSync("audit");
             const mostRecentLog = await findMostRecentLog(logDir);
             if (!mostRecentLog) {
-                terminal.error(`No REPL audit logs found in '${logDir}'.`);
+                container.addChild(new Text(style.red(`No REPL audit logs found in '${logDir}'.`), 0, 1));
+                tui.requestRender();
+                editor.setText("");
                 return "continue";
             }
             try {
                 const content = await readFile(mostRecentLog, { encoding: "utf8" });
-                // Use the editor prompt to display the content (read-only)
-                await editor({
-                    message: `Viewing ${style.green(mostRecentLog)}`,
-                    postfix: ".json", // Set postfix for syntax highlighting if editor supports it
-                    default: content,
-                    // By not providing an onSubmit or similar handler to write the file,
-                    // and not calling writeFileSync after, this effectively becomes read-only.
-                    skipPrompt: true,
-                });
-                terminal.info("Closed log view");
+                // For TUI mode, we'll just display a message since we can't use the editor prompt
+                container.addChild(new Text(`Viewing most recent log: ${style.blue(mostRecentLog)}`, 1, 0));
+                container.addChild(new Text(`Content length: ${content.length} characters`, 2, 0));
+                container.addChild(new Text(style.dim("Note: Full log viewing not available in TUI mode"), 3, 0));
+                tui.requestRender();
+                editor.setText("");
                 return "continue";
             }
             catch (error) {
-                terminal.error(`Error reading or displaying log file ${mostRecentLog}: ${error}`);
+                container.addChild(new Text(style.red(`Error reading log file ${mostRecentLog}: ${error}`), 1, 0));
+                tui.requestRender();
+                editor.setText("");
                 return "continue";
             }
         },

package/dist/commands/list-directories-command.d.ts

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const listDirectoriesCommand: ({ workspace, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=list-directories-command.d.ts.map

package/dist/commands/list-directories-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-directories-command.d.ts","sourceRoot":"","sources":["../../source/commands/list-directories-command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,sBAAsB,GAAI,gBAEpC,cAAc,KAAG,WAkDnB,CAAC"}

package/dist/commands/list-directories-command.js

@@ -0,0 +1,35 @@
+import { Modal, Container as ModalContainer, ModalText } from "../tui/index.js";
+export const listDirectoriesCommand = ({ workspace, }) => {
+    return {
+        command: "/list-directories",
+        description: "List all allowed working directories",
+        getSubCommands: async () => {
+            return [];
+        },
+        async handle(_args, { tui, editor }) {
+            // Build modal content
+            const modalContent = new ModalContainer();
+            modalContent.addChild(new ModalText("Current working directories:", 0, 1));
+            if (workspace.allowedDirs.length === 0) {
+                modalContent.addChild(new ModalText("No directories configured. Using current directory only.", 0, 1));
+            }
+            else {
+                // Add each directory as a separate line
+                workspace.allowedDirs.forEach((dir) => {
+                    const isPrimary = dir === workspace.primaryDir;
+                    const prefix = isPrimary ? "● " : "  ";
+                    const indicator = isPrimary ? " (primary)" : "";
+                    modalContent.addChild(new ModalText(`${prefix}${dir}${indicator}`, 0, 0));
+                });
+            }
+            // Create and show modal
+            const modal = new Modal("Working Directories", modalContent, true, () => {
+                // Modal closed callback
+                editor.setText("");
+                tui.requestRender();
+            });
+            tui.showModal(modal);
+            return "continue";
+        },
+    };
+};

package/dist/commands/list-tools-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-tools-command.d.ts","sourceRoot":"","sources":["../../source/commands/list-tools-command.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAmErE"}
+{"version":3,"file":"list-tools-command.d.ts","sourceRoot":"","sources":["../../source/commands/list-tools-command.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAgIrE"}

package/dist/commands/list-tools-command.js

@@ -1,28 +1,33 @@
+import style from "../terminal/style.js";
 import { initAgents, initTools } from "../tools/index.js";
+import { Modal, Container as ModalContainer, ModalText, TableComponent, } from "../tui/index.js";
 export function listToolsCommand(options) {
     return {
         command: "/list-tools",
         description: "List all available static and dynamic tools.",
         aliases: ["/lt"],
         getSubCommands: async () => [],
-        async execute(_args) {
-            const { terminal } = options;
+        async handle(_args, { tui, editor }) {
             try {
+                // Get active tools from config
+                const projectConfig = await options.config.getConfig();
+                const activeTools = projectConfig.tools.activeTools;
                 const tools = await initTools({
-                    terminal: options.terminal,
                     tokenCounter: options.tokenCounter,
-                    events: new Map(),
+                    workspace: options.workspace,
+                    modelManager: options.modelManager,
+                    tokenTracker: options.tokenTracker,
                 });
                 const agentTools = await initAgents({
-                    terminal: options.terminal,
                     modelManager: options.modelManager,
                     tokenTracker: options.tokenTracker,
                     tokenCounter: options.tokenCounter,
-                    events: new Map(),
+                    workspace: options.workspace,
                 });
-                const toolNames = Object.keys({ ...tools, ...agentTools }).sort();
-                terminal.writeln("Available tools:");
-                terminal.lineBreak();
+                const toolNames = Object.keys({
+                    ...tools.toolDefs,
+                    ...agentTools.toolDefs,
+                }).sort();
                 // Separate static and dynamic tools
                 const staticTools = [];
                 const dynamicTools = [];
@@ -34,26 +39,61 @@ export function listToolsCommand(options) {
                         staticTools.push(toolName);
                     }
                 }
-                // Display static tools
-                if (staticTools.length > 0) {
-                    terminal.writeln("  Static tools:");
+                // Build modal content
+                const modalContent = new ModalContainer();
+                if (toolNames.length === 0) {
+                    modalContent.addChild(new ModalText("No tools available.", 0, 1));
+                }
+                else {
+                    // Create table data
+                    const tableData = [];
+                    // Add static tools
                     for (const toolName of staticTools) {
-                        terminal.writeln(`    ${toolName}`);
+                        const isActive = activeTools === undefined || activeTools.includes(toolName);
+                        tableData.push([
+                            toolName,
+                            "Static",
+                            isActive ? "Active" : "Inactive",
+                        ]);
                     }
-                }
-                // Display dynamic tools
-                if (dynamicTools.length > 0) {
-                    terminal.writeln("  Dynamic tools:");
+                    // Add dynamic tools
                     for (const toolName of dynamicTools) {
-                        terminal.writeln(`    ${toolName}`);
+                        const isActive = activeTools === undefined || activeTools.includes(toolName);
+                        tableData.push([
+                            toolName,
+                            "Dynamic",
+                            isActive ? "Active" : "Inactive",
+                        ]);
                     }
+                    modalContent.addChild(new TableComponent(tableData, {
+                        headers: ["Tool Name", "Type", "Status"],
+                        colWidths: [60, 20, 20],
+                    }));
+                    // Add summary
+                    modalContent.addChild(new ModalText("", 0, 1)); // Spacer
+                    const activeCount = activeTools === undefined
+                        ? toolNames.length
+                        : toolNames.filter((tool) => activeTools.includes(tool)).length;
+                    modalContent.addChild(new ModalText(`Total: ${staticTools.length} static, ${dynamicTools.length} dynamic, ${activeCount} active`, 0, 1));
                 }
-                // Display summary
-                terminal.writeln(`\n  Total: ${staticTools.length} static, ${dynamicTools.length} dynamic`);
+                // Create and show modal
+                const modal = new Modal("Available Tools", modalContent, true, () => {
+                    // Modal closed callback
+                    editor.setText("");
+                    tui.requestRender();
+                });
+                tui.showModal(modal);
                 return "continue";
             }
             catch (error) {
-                terminal.error(`Error listing tools: ${error.message}`);
+                // Show error in modal
+                const errorContent = new ModalContainer();
+                errorContent.addChild(new ModalText(style.red(`Error listing tools: ${error.message}`), 0, 1));
+                const errorModal = new Modal("Error", errorContent, true, () => {
+                    editor.setText("");
+                    tui.requestRender();
+                });
+                tui.showModal(errorModal);
                 return "continue";
             }
         },

package/dist/commands/manager.d.ts

@@ -1,3 +1,4 @@
+import type { Container, Editor, SlashCommand, TUI } from "../tui/index.ts";
 import type { CommandOptions } from "./types.ts";
 export declare class CommandManager {
     private commands;
@@ -5,20 +6,24 @@ export declare class CommandManager {
     private modelManager;
     private messageHistory;
     private tokenTracker;
-    private terminal;
     private config;
     private tokenCounter;
-    private toolEvents;
-    private toolExecutor?;
     private promptHistory;
+    private workspace;
     private initialized;
-    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, toolExecutor, promptHistory, }: CommandOptions);
+    constructor({ promptManager, modelManager, messageHistory, tokenTracker, config, tokenCounter, promptHistory, workspace, }: CommandOptions);
     initializeCommmands(): Promise<void>;
     private ensureInitialized;
+    getCompletions(): Promise<SlashCommand[]>;
     getCommands(): string[];
     getSubCommands(command: string): Promise<string[]>;
     handle({ userInput }: {
         userInput: string;
+    }, options: {
+        tui: TUI;
+        container: Container;
+        inputContainer: Container;
+        editor: Editor;
     }): Promise<{
         continue: boolean;
         break: boolean;

package/dist/commands/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../source/commands/manager.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,YAAY,CAAC;AAG9D,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,aAAa,CAAmB;IACxC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,WAAW,CAAU;gBAEjB,EACV,aAAa,EACb,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,aAAa,GACd,EAAE,cAAc;IAeX,mBAAmB;IA8EzB,OAAO,CAAC,iBAAiB;IAQzB,WAAW;IAKL,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKlD,MAAM,CAAC,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE;;;;CA6BlD"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../source/commands/manager.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAEV,SAAS,EACT,MAAM,EACN,YAAY,EACZ,GAAG,EACJ,MAAM,iBAAiB,CAAC;AA6BzB,OAAO,KAAK,EAAE,cAAc,EAAe,MAAM,YAAY,CAAC;AAG9D,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,aAAa,CAAmB;IACxC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,aAAa,CAAW;IAChC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,WAAW,CAAU;gBAEjB,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,aAAa,EACb,SAAS,GACV,EAAE,cAAc;IAaX,mBAAmB;IA0FzB,OAAO,CAAC,iBAAiB;IAQnB,cAAc,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAuB/C,WAAW;IAKL,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKlD,MAAM,CACV,EAAE,SAAS,EAAE,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,EACpC,OAAO,EAAE;QACP,GAAG,EAAE,GAAG,CAAC;QACT,SAAS,EAAE,SAAS,CAAC;QACrB,cAAc,EAAE,SAAS,CAAC;QAC1B,MAAM,EAAE,MAAM,CAAC;KAChB;;;;CA8BJ"}

package/dist/commands/manager.js

@@ -1,22 +1,29 @@
-import { applicationLogCommand } from "./application-log-command.js";
+import { addDirectoryCommand } from "./add-directory-command.js";
+// import { applicationLogCommand } from "./application-log-command.ts";
 import { clearCommand } from "./clear-command.js";
-import { compactCommand } from "./compact-command.js";
+// import { compactCommand } from "./compact-command.ts";
+import { contextCommand } from "./context-command.js";
 import { copyCommand } from "./copy-command.js";
-import { editCommand } from "./edit-command.js";
-import { editPromptCommand } from "./edit-prompt-command.js";
+// import { editCommand } from "./edit-command.ts";
+// import { editPromptCommand } from "./edit-prompt-command.ts";
 import { exitCommand } from "./exit-command.js";
-import { filesCommand } from "./files-command.js";
+// import { filesCommand } from "./files-command.ts";
 import { generateRulesCommand } from "./generate-rules-command.js";
+import { handoffCommand } from "./handoff-command.js";
 import { healthCommand } from "./health-command.js";
 import { helpCommand } from "./help-command.js";
+import { historyCommand } from "./history-command.js";
 import { initCommand } from "./init-command.js";
-import { lastLogCommand } from "./last-log-command.js";
+// import { lastLogCommand } from "./last-log-command.ts";
+import { listDirectoriesCommand } from "./list-directories-command.js";
 import { listToolsCommand } from "./list-tools-command.js";
 import { modelCommand } from "./model-command.js";
 import { pasteCommand } from "./paste-command.js";
-import { promptCommand } from "./prompt-command.js";
+import { pickupCommand } from "./pickup-command.js";
+import { loadPrompts, promptCommand } from "./prompt-command.js";
+import { removeDirectoryCommand } from "./remove-directory-command.js";
 import { resetCommand } from "./reset-command.js";
-import { rulesCommand } from "./rules-command.js";
+// import { rulesCommand } from "./rules-command.ts";
 import { saveCommand } from "./save-command.js";
 import { shellCommand } from "./shell-command.js";
 import { usageCommand } from "./usage-command.js";
@@ -26,25 +33,21 @@ export class CommandManager {
     modelManager;
     messageHistory;
     tokenTracker;
-    terminal;
     config;
     tokenCounter;
-    toolEvents;
-    toolExecutor;
     promptHistory;
+    workspace;
     initialized;
-    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, toolExecutor, promptHistory, }) {
+    constructor({ promptManager, modelManager, messageHistory, tokenTracker, config, tokenCounter, promptHistory, workspace, }) {
         this.commands = new Map();
         this.promptManager = promptManager;
         this.modelManager = modelManager;
-        this.terminal = terminal;
         this.messageHistory = messageHistory;
         this.tokenTracker = tokenTracker;
         this.config = config;
         this.tokenCounter = tokenCounter;
-        this.toolEvents = toolEvents;
-        this.toolExecutor = toolExecutor;
         this.promptHistory = promptHistory;
+        this.workspace = workspace;
         this.initialized = false;
     }
     async initializeCommmands() {
@@ -55,64 +58,68 @@ export class CommandManager {
         const options = {
             promptManager: this.promptManager,
             modelManager: this.modelManager,
-            terminal: this.terminal,
             messageHistory: this.messageHistory,
             tokenTracker: this.tokenTracker,
             config: this.config,
             tokenCounter: this.tokenCounter,
-            toolEvents: this.toolEvents,
-            toolExecutor: this.toolExecutor,
             promptHistory: this.promptHistory,
+            workspace: this.workspace,
         };
         // Register all commands
         const cmds = [
+            addDirectoryCommand(options),
             clearCommand(options),
-            compactCommand(options),
-            editCommand(options),
-            editPromptCommand(options),
+            // compactCommand(options),
+            contextCommand(options),
+            // editCommand(options),
+            // editPromptCommand(options),
             exitCommand(options),
-            filesCommand(options),
+            // filesCommand(options),
             healthCommand(options),
+            historyCommand(options),
             initCommand(options),
+            listDirectoriesCommand(options),
             pasteCommand(options),
+            pickupCommand(options),
             promptCommand(options),
+            removeDirectoryCommand(options),
             resetCommand(options),
             saveCommand(options),
-            rulesCommand(options),
+            // rulesCommand(options),
             modelCommand(options),
             usageCommand(options),
-            lastLogCommand(options),
+            // lastLogCommand(options),
             generateRulesCommand(options),
-            applicationLogCommand(options),
+            handoffCommand(options),
+            // applicationLogCommand(options),
             copyCommand(options),
             listToolsCommand(options),
             shellCommand(options),
         ];
         // Add help command with access to all commands
         const helpCmd = helpCommand(options, this.commands);
-        cmds.push({
-            ...helpCmd,
-            execute: () => helpCmd.execute([]),
-        });
+        cmds.push(helpCmd);
         // Register all commands
         for (const cmd of cmds) {
             this.commands.set(cmd.command, cmd);
-            const aliases = cmd.aliases ?? [];
-            for (const alias of aliases) {
-                this.commands.set(alias, cmd);
-            }
+            // const aliases: string[] = cmd.aliases ?? [];
+            // for (const alias of aliases) {
+            //   this.commands.set(alias, cmd);
+            // }
         }
         const promptCmd = this.commands.get("/prompt");
         if (promptCmd) {
             const promptSubmCommands = await promptCmd.getSubCommands();
+            const prompts = await loadPrompts(options.config);
             for (const cmd of promptSubmCommands) {
+                const prompt = prompts.get(cmd);
                 this.commands.set(`/${cmd}`, {
                     command: `/${cmd}`,
-                    description: "",
-                    execute: (args) => {
-                        return promptCmd.execute([cmd, ...args]);
-                    },
+                    description: prompt?.description ?? "",
                     getSubCommands: () => Promise.resolve([]),
+                    async handle(args, options) {
+                        return promptCmd.handle([cmd, ...args], options);
+                    },
                 });
             }
         }
@@ -123,6 +130,24 @@ export class CommandManager {
             throw new Error("Commands have not been initialized. Call initializeCommmands() first.");
         }
     }
+    async getCompletions() {
+        this.ensureInitialized();
+        return Promise.all(Array.from(this.commands.entries()).map(async (entry) => {
+            const subs = await entry[1].getSubCommands();
+            return {
+                name: entry[0].slice(1),
+                // value: entry[0].slice(1),
+                // label: entry[0].slice(1),
+                description: entry[1].description,
+                getArgumentCompletions(_argumentPrefix) {
+                    return subs.map((sub) => ({
+                        value: sub,
+                        label: sub,
+                    }));
+                },
+            };
+        }));
+    }
     getCommands() {
         this.ensureInitialized();
         return Array.from(this.commands.keys()).sort();
@@ -131,7 +156,7 @@ export class CommandManager {
         this.ensureInitialized();
         return (await this.commands.get(command)?.getSubCommands()) ?? [];
     }
-    async handle({ userInput }) {
+    async handle({ userInput }, options) {
         this.ensureInitialized();
         const commandArgs = userInput.split(" ");
         const command = commandArgs.at(0);
@@ -139,7 +164,7 @@ export class CommandManager {
         if (command) {
             const replCommand = this.commands.get(command);
             if (replCommand) {
-                const result = await replCommand.execute(args);
+                const result = await replCommand.handle(args, options);
                 if (result === "continue") {
                     return {
                         continue: true,

package/dist/commands/model-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model-command.d.ts","sourceRoot":"","sources":["../../source/commands/model-command.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CA+GjE"}
+{"version":3,"file":"model-command.d.ts","sourceRoot":"","sources":["../../source/commands/model-command.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,YAAY,CAAC,OAAO,EAAE,cAAc,GAAG,WAAW,CAoIjE"}