@travisennis/acai 0.0.3 → 0.0.5

package/dist/commands/edit-prompt-command.js

@@ -1,25 +1,33 @@
-import { editor } from "@inquirer/prompts";
 import { syncTry } from "@travisennis/stdlib/try";
-export const editPromptCommand = ({ terminal, promptManager, }) => {
+import { editor } from "../terminal/editor-prompt.js";
+export const editPromptCommand = ({ terminal, promptManager, promptHistory, }) => {
     return {
         command: "/edit-prompt",
-        description: "Edit the prompt.",
-        result: "use",
+        description: "Edit the prompt. Accepts optional arguments as initial content.",
         getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
+        execute: async (args = []) => {
             try {
                 const prompt = syncTry(() => promptManager.get());
+                const initialContent = args.length > 0 ? args.join(" ") : prompt.unwrapOr("");
                 const updatedPrompt = await editor({
                     message: " Edit prompt?",
                     postfix: "md",
-                    default: prompt.unwrapOr(""),
+                    default: initialContent,
+                    skipPrompt: true,
                 });
+                if (updatedPrompt.trim().length === 0) {
+                    throw new Error("Prompt was empty.");
+                }
                 terminal.writeln(`> ${updatedPrompt}`);
                 promptManager.set(updatedPrompt);
+                // Add the edited prompt to history
+                promptHistory.push(updatedPrompt);
             }
             catch (error) {
-                terminal.error(`Error updating prompt: ${error.message}`);
+                terminal.error(`Error editing prompt: ${error.message}`);
+                return "continue";
             }
+            return "use";
         },
     };
 };

package/dist/commands/exit-command.d.ts

@@ -1,2 +1,13 @@
-import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare const exitCommand: ({ messageHistory, }: CommandOptions) => ReplCommand;
+import type { ReplCommand } from "./types.ts";
+export interface ExitCommandOptions {
+    messageHistory: {
+        isEmpty: () => boolean;
+        save: () => Promise<void>;
+    };
+    terminal: {
+        clear: () => void;
+    };
+    baseDir?: string | null;
+}
+export declare const exitCommand: ({ messageHistory, terminal, baseDir, }: ExitCommandOptions) => ReplCommand;
+//# sourceMappingURL=exit-command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exit-command.d.ts","sourceRoot":"","sources":["../../source/commands/exit-command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE;QACd,OAAO,EAAE,MAAM,OAAO,CAAC;QACvB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;KAC3B,CAAC;IACF,QAAQ,EAAE;QACR,KAAK,EAAE,MAAM,IAAI,CAAC;KACnB,CAAC;IACF,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,eAAO,MAAM,WAAW,GAAI,wCAIzB,kBAAkB,KAAG,WAwBvB,CAAC"}

package/dist/commands/exit-command.js

@@ -1,14 +1,26 @@
-export const exitCommand = ({ messageHistory, }) => {
+import path from "node:path";
+import { clearDirectory } from "../utils/filesystem.js";
+export const exitCommand = ({ messageHistory, terminal, baseDir, }) => {
     return {
         command: "/exit",
         aliases: ["/bye", "/quit"],
         description: "Exits and saves the chat history.",
-        result: "break",
         getSubCommands: () => Promise.resolve([]),
         execute: async () => {
+            terminal.clear();
             if (!messageHistory.isEmpty()) {
                 await messageHistory.save();
             }
+            // Clear the .tmp directory on exit
+            try {
+                const tmpDirPath = path.join(baseDir ?? process.cwd(), ".tmp");
+                await clearDirectory(tmpDirPath);
+            }
+            catch (error) {
+                // Log error but don't block exit
+                console.error("Failed to clear .tmp directory:", error);
+            }
+            return "break";
         },
     };
 };

package/dist/commands/files-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const filesCommand: ({ terminal, promptManager, modelManager, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=files-command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"files-command.d.ts","sourceRoot":"","sources":["../../source/commands/files-command.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,YAAY,GAAI,4CAI1B,cAAc,KAAG,WA0EnB,CAAC"}

package/dist/commands/files-command.js

@@ -1,20 +1,19 @@
 import { readFile } from "node:fs/promises";
-import { checkbox } from "@inquirer/prompts";
-import { globby } from "globby";
 import { formatFile } from "../formatting.js";
-import { TokenCounter } from "../token-utils.js";
+import { checkbox } from "../terminal/checkbox-prompt.js";
+import { TokenCounter } from "../tokens/counter.js";
+import { glob } from "../utils/glob.js";
 export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
     return {
         command: "/files",
         description: "Finds files matching the given patterns and adds their content to the next prompt. Usage: /files or /files src/**/*.ts",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async (args) => {
             try {
                 let workingFiles = [];
                 if (!args || args.length === 0) {
                     // Get all files in the current directory
-                    const foundFiles = await globby("**/*", { gitignore: true });
+                    const foundFiles = await glob("**/*", { gitignore: true });
                     const selectedFiles = await checkbox({
                         message: "Select files to include:",
                         choices: foundFiles,
@@ -22,17 +21,17 @@ export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
                     });
                     if (selectedFiles.length === 0) {
                         terminal.warn("No files selected.");
-                        return;
+                        return "continue";
                     }
                     // Process the selected files
                     workingFiles = selectedFiles;
                 }
                 else {
                     const patternList = args.filter(Boolean);
-                    const foundFiles = await globby(patternList, { gitignore: true });
+                    const foundFiles = await glob(patternList, { gitignore: true });
                     if (foundFiles.length === 0) {
                         terminal.warn("No files found matching the pattern(s)");
-                        return;
+                        return "continue";
                     }
                     // Process the selected files
                     workingFiles = foundFiles;
@@ -54,9 +53,11 @@ export const filesCommand = ({ terminal, promptManager, modelManager, }) => {
                 }));
                 tokenCounter.free();
                 terminal.success(`File contents will be added to your next prompt (${workingFiles.length} files, ${tokenCount} tokens)`);
+                return "continue";
             }
             catch (error) {
                 terminal.error(`Error processing file patterns: ${error.message}`);
+                return "continue";
             }
         },
     };

package/dist/commands/generate-rules-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const generateRulesCommand: ({ terminal, messageHistory, modelManager, tokenTracker, config, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=generate-rules-command.d.ts.map

package/dist/commands/generate-rules-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-rules-command.d.ts","sourceRoot":"","sources":["../../source/commands/generate-rules-command.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAuC9D,eAAO,MAAM,oBAAoB,GAAI,mEAMlC,cAAc,KAAG,WAmCnB,CAAC"}

package/dist/commands/generate-rules-command.js

@@ -1,6 +1,6 @@
-import { checkbox } from "@inquirer/prompts";
 import { analyzeConversation } from "../conversation-analyzer.js";
 import { logger } from "../logger.js"; // Import logger
+import { checkbox } from "../terminal/checkbox-prompt.js";
 async function _processAndSaveRules(newRules, terminal, config) {
     if (!newRules || newRules.length === 0) {
         terminal.warn("No new generalizable rules were identified.");
@@ -32,12 +32,11 @@ export const generateRulesCommand = ({ terminal, messageHistory, modelManager, t
     return {
         command: "/generate-rules",
         description: "Analyzes the current conversation to generate and save new interaction rules, then displays them.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async () => {
             if (messageHistory.isEmpty()) {
                 terminal.writeln("Cannot generate rules from an empty conversation.");
-                return;
+                return "continue";
             }
             terminal.lineBreak();
             terminal.info("Analyzing conversation to generate rules...");
@@ -55,7 +54,9 @@ export const generateRulesCommand = ({ terminal, messageHistory, modelManager, t
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 terminal.error(`Error generating rules: ${errorMessage}`);
                 logger.error(error, "Error during rule generation:");
+                return "continue";
             }
+            return "continue";
         },
     };
 };

package/dist/commands/health-command.d.ts

@@ -1,2 +1,4 @@
+import { execSync } from "node:child_process";
 import type { CommandOptions, ReplCommand } from "./types.ts";
-export declare function healthCommand({ terminal }: CommandOptions): ReplCommand;
+export declare function healthCommand({ terminal }: CommandOptions, execFn?: typeof execSync): ReplCommand;
+//# sourceMappingURL=health-command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"health-command.d.ts","sourceRoot":"","sources":["../../source/commands/health-command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,wBAAgB,aAAa,CAC3B,EAAE,QAAQ,EAAE,EAAE,cAAc,EAC5B,MAAM,kBAAW,GAChB,WAAW,CAqHb"}

package/dist/commands/health-command.js

@@ -1,10 +1,10 @@
-export function healthCommand({ terminal }) {
+import { execSync } from "node:child_process";
+export function healthCommand({ terminal }, execFn = execSync) {
     return {
         command: "/health",
         description: "Show application health status and environment variables",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
-        execute() {
+        async execute() {
             // Define the environment variables we care about
             const envVars = [
                 // AI Provider API Keys
@@ -15,6 +15,7 @@ export function healthCommand({ terminal }) {
                     description: "Google (Gemini models)",
                 },
                 { name: "DEEPSEEK_API_KEY", description: "DeepSeek" },
+                { name: "GROQ_API_KEY", description: "Groq (multiple models)" },
                 { name: "X_AI_API_KEY", description: "X.AI (Grok models)" },
                 { name: "XAI_API_KEY", description: "X.AI (Grok models - alt)" },
                 {
@@ -46,14 +47,50 @@ export function healthCommand({ terminal }) {
             // Count how many are set (derived from envStatus to avoid re-checking process.env)
             const setCount = envStatus.filter((row) => row[1] === "✓ Set").length;
             const totalCount = envVars.length;
-            terminal.info(`\nSummary: ${setCount}/${totalCount} environment variables are set`);
+            terminal.info(`Summary: ${setCount}/${totalCount} environment variables are set`);
             if (setCount === 0) {
                 terminal.warn("⚠️  No AI provider API keys are configured. The app may not function properly.");
             }
             else {
                 terminal.info("✓ At least one AI provider is configured.");
             }
-            return Promise.resolve();
+            // Check for required bash tools
+            const tools = [
+                { name: "git", command: "git --version" },
+                { name: "gh", command: "gh --version" },
+                { name: "rg", command: "rg --version" },
+                { name: "fd", command: "fd --version" },
+                { name: "ast-grep", command: "ast-grep --version" },
+                { name: "jq", command: "jq --version" },
+                { name: "yq", command: "yq --version" },
+            ];
+            const toolStatus = tools.map((tool) => {
+                let status = "✗ Not installed";
+                try {
+                    execFn(tool.command, { stdio: "ignore", timeout: 5000 });
+                    status = "✓ Installed";
+                }
+                catch (_error) {
+                    // Ignore error, tool is not installed
+                }
+                return [tool.name, status];
+            });
+            terminal.lineBreak();
+            terminal.info("Bash Tools Status:");
+            terminal.table(toolStatus, {
+                header: ["Tool", "Status"],
+                colWidths: [15, 20],
+            });
+            const installedCount = toolStatus.filter((row) => row[1] === "✓ Installed").length;
+            const totalTools = tools.length;
+            terminal.info(`Tool Summary: ${installedCount}/${totalTools} tools are installed.`);
+            if (installedCount < totalTools) {
+                terminal.warn("⚠️  Some tools are missing. Install them for full functionality.");
+            }
+            else {
+                terminal.info("✓ All required tools are installed.");
+            }
+            return "continue";
         },
     };
 }

package/dist/commands/help-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const helpCommand: ({ terminal }: CommandOptions, cmds: Map<string, ReplCommand>) => ReplCommand;
+//# sourceMappingURL=help-command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"help-command.d.ts","sourceRoot":"","sources":["../../source/commands/help-command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,WAAW,GACtB,cAAc,cAAc,EAC5B,MAAM,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,KAC7B,WAoBF,CAAC"}

package/dist/commands/help-command.js

@@ -2,9 +2,8 @@ export const helpCommand = ({ terminal }, cmds) => {
     return {
         command: "/help",
         description: "Shows available commands.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
-        execute: () => {
+        execute: async () => {
             const commands = cmds;
             const entries = Array.from(commands.entries())
                 .sort(([a], [b]) => a.localeCompare(b))
@@ -13,7 +12,7 @@ export const helpCommand = ({ terminal }, cmds) => {
                 header: ["Command", "Description"],
                 colWidths: [30, 70],
             });
-            return Promise.resolve();
+            return "continue";
         },
     };
 };

package/dist/commands/init-command.d.ts

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare const initCommand: ({ terminal, modelManager, tokenCounter, toolEvents, }: CommandOptions) => ReplCommand;
+//# sourceMappingURL=init-command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init-command.d.ts","sourceRoot":"","sources":["../../source/commands/init-command.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9D,eAAO,MAAM,WAAW,GAAI,uDAKzB,cAAc,KAAG,WAoCnB,CAAC"}

package/dist/commands/init-command.js

@@ -6,7 +6,6 @@ export const initCommand = ({ terminal, modelManager, tokenCounter, toolEvents,
     return {
         command: "/init",
         description: "Creates the AGENTS.md file.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async () => {
             const result = streamText({
@@ -29,12 +28,12 @@ Platform: ${platform()}`,
                     terminal,
                     tokenCounter,
                     events: toolEvents,
-                    autoAcceptAll: true,
                 }),
             });
             for await (const text of result.textStream) {
                 terminal.write(text);
             }
+            return "continue";
         },
     };
 };

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

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

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

@@ -0,0 +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"}

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

@@ -1,14 +1,14 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { editor } from "@inquirer/prompts";
-import chalk from "chalk";
-import { globby } from "globby";
 import { config } from "../config.js";
+import { editor } from "../terminal/editor-prompt.js";
+import style from "../terminal/style.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
 async function findMostRecentLog(logDir) {
     const logPattern = join(logDir, "*-repl-message.json");
-    const files = await globby(logPattern);
+    const files = await glob(logPattern);
     if (files.length === 0) {
         return null;
     }
@@ -21,16 +21,9 @@ async function findMostRecentLog(logDir) {
         // Match the ISO date string at the beginning of the filename
         const match = filename.match(isoDateRegex);
         if (match?.[1]) {
-            try {
-                const date = new Date(match[1]);
-                // Check if the date is valid
-                if (!Number.isNaN(date.getTime())) {
-                    return { file, date };
-                }
-            }
-            catch (e) {
-                // Ignore files with invalid date strings
-                console.warn(`Could not parse date from filename: ${filename}`, e);
+            const date = new Date(match[1]);
+            if (!Number.isNaN(date.getTime())) {
+                return { file, date };
             }
         }
         return null; // Exclude files that don't match the pattern or have invalid dates
@@ -47,29 +40,31 @@ export const lastLogCommand = ({ terminal }) => {
     return {
         command: "/last-log",
         description: "Opens the most recent REPL audit log in the editor.",
-        result: "continue",
         getSubCommands: () => Promise.resolve([]),
         execute: async () => {
             const logDir = config.app.ensurePathSync("audit");
             const mostRecentLog = await findMostRecentLog(logDir);
             if (!mostRecentLog) {
                 terminal.error(`No REPL audit logs found in '${logDir}'.`);
-                return;
+                return "continue";
             }
             try {
                 const content = await readFile(mostRecentLog, { encoding: "utf8" });
                 // Use the editor prompt to display the content (read-only)
                 await editor({
-                    message: `Viewing ${chalk.green(mostRecentLog)}`,
+                    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");
+                return "continue";
             }
             catch (error) {
                 terminal.error(`Error reading or displaying log file ${mostRecentLog}: ${error}`);
+                return "continue";
             }
         },
     };

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

@@ -0,0 +1,3 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare function listToolsCommand(options: CommandOptions): ReplCommand;
+//# sourceMappingURL=list-tools-command.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,61 @@
+import { initAgents, initTools } from "../tools/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;
+            try {
+                const tools = await initTools({
+                    terminal: options.terminal,
+                    tokenCounter: options.tokenCounter,
+                    events: new Map(),
+                });
+                const agentTools = await initAgents({
+                    terminal: options.terminal,
+                    modelManager: options.modelManager,
+                    tokenTracker: options.tokenTracker,
+                    tokenCounter: options.tokenCounter,
+                    events: new Map(),
+                });
+                const toolNames = Object.keys({ ...tools, ...agentTools }).sort();
+                terminal.writeln("Available tools:");
+                terminal.lineBreak();
+                // Separate static and dynamic tools
+                const staticTools = [];
+                const dynamicTools = [];
+                for (const toolName of toolNames) {
+                    if (toolName.startsWith("dynamic-")) {
+                        dynamicTools.push(toolName);
+                    }
+                    else {
+                        staticTools.push(toolName);
+                    }
+                }
+                // Display static tools
+                if (staticTools.length > 0) {
+                    terminal.writeln("  Static tools:");
+                    for (const toolName of staticTools) {
+                        terminal.writeln(`    ${toolName}`);
+                    }
+                }
+                // Display dynamic tools
+                if (dynamicTools.length > 0) {
+                    terminal.writeln("  Dynamic tools:");
+                    for (const toolName of dynamicTools) {
+                        terminal.writeln(`    ${toolName}`);
+                    }
+                }
+                // Display summary
+                terminal.writeln(`\n  Total: ${staticTools.length} static, ${dynamicTools.length} dynamic`);
+                return "continue";
+            }
+            catch (error) {
+                terminal.error(`Error listing tools: ${error.message}`);
+                return "continue";
+            }
+        },
+    };
+}

package/dist/commands/manager.d.ts

@@ -9,8 +9,12 @@ export declare class CommandManager {
     private config;
     private tokenCounter;
     private toolEvents;
-    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, }: CommandOptions);
-    initializeCommmands(): void;
+    private toolExecutor?;
+    private promptHistory;
+    private initialized;
+    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, toolExecutor, promptHistory, }: CommandOptions);
+    initializeCommmands(): Promise<void>;
+    private ensureInitialized;
     getCommands(): string[];
     getSubCommands(command: string): Promise<string[]>;
     handle({ userInput }: {
@@ -20,3 +24,4 @@ export declare class CommandManager {
         break: boolean;
     }>;
 }
+//# sourceMappingURL=manager.d.ts.map

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

@@ -0,0 +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"}

package/dist/commands/manager.js

@@ -11,12 +11,14 @@ import { healthCommand } from "./health-command.js";
 import { helpCommand } from "./help-command.js";
 import { initCommand } from "./init-command.js";
 import { lastLogCommand } from "./last-log-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 { resetCommand } from "./reset-command.js";
 import { rulesCommand } from "./rules-command.js";
 import { saveCommand } from "./save-command.js";
+import { shellCommand } from "./shell-command.js";
 import { usageCommand } from "./usage-command.js";
 export class CommandManager {
     commands;
@@ -28,7 +30,10 @@ export class CommandManager {
     config;
     tokenCounter;
     toolEvents;
-    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, }) {
+    toolExecutor;
+    promptHistory;
+    initialized;
+    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, toolExecutor, promptHistory, }) {
         this.commands = new Map();
         this.promptManager = promptManager;
         this.modelManager = modelManager;
@@ -38,9 +43,14 @@ export class CommandManager {
         this.config = config;
         this.tokenCounter = tokenCounter;
         this.toolEvents = toolEvents;
-        this.initializeCommmands();
+        this.toolExecutor = toolExecutor;
+        this.promptHistory = promptHistory;
+        this.initialized = false;
     }
-    initializeCommmands() {
+    async initializeCommmands() {
+        if (this.initialized) {
+            return;
+        }
         // Import and register each command
         const options = {
             promptManager: this.promptManager,
@@ -51,6 +61,8 @@ export class CommandManager {
             config: this.config,
             tokenCounter: this.tokenCounter,
             toolEvents: this.toolEvents,
+            toolExecutor: this.toolExecutor,
+            promptHistory: this.promptHistory,
         };
         // Register all commands
         const cmds = [
@@ -73,6 +85,8 @@ export class CommandManager {
             generateRulesCommand(options),
             applicationLogCommand(options),
             copyCommand(options),
+            listToolsCommand(options),
+            shellCommand(options),
         ];
         // Add help command with access to all commands
         const helpCmd = helpCommand(options, this.commands);
@@ -88,28 +102,51 @@ export class CommandManager {
                 this.commands.set(alias, cmd);
             }
         }
+        const promptCmd = this.commands.get("/prompt");
+        if (promptCmd) {
+            const promptSubmCommands = await promptCmd.getSubCommands();
+            for (const cmd of promptSubmCommands) {
+                this.commands.set(`/${cmd}`, {
+                    command: `/${cmd}`,
+                    description: "",
+                    execute: (args) => {
+                        return promptCmd.execute([cmd, ...args]);
+                    },
+                    getSubCommands: () => Promise.resolve([]),
+                });
+            }
+        }
+        this.initialized = true;
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error("Commands have not been initialized. Call initializeCommmands() first.");
+        }
     }
     getCommands() {
+        this.ensureInitialized();
         return Array.from(this.commands.keys()).sort();
     }
     async getSubCommands(command) {
+        this.ensureInitialized();
         return (await this.commands.get(command)?.getSubCommands()) ?? [];
     }
     async handle({ userInput }) {
+        this.ensureInitialized();
         const commandArgs = userInput.split(" ");
         const command = commandArgs.at(0);
         const args = commandArgs.slice(1);
         if (command) {
             const replCommand = this.commands.get(command);
             if (replCommand) {
-                await replCommand.execute(args);
-                if (replCommand.result === "continue") {
+                const result = await replCommand.execute(args);
+                if (result === "continue") {
                     return {
                         continue: true,
                         break: false,
                     };
                 }
-                if (replCommand.result === "break") {
+                if (result === "break") {
                     return {
                         continue: false,
                         break: true,

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

@@ -1,2 +1,3 @@
 import type { CommandOptions, ReplCommand } from "./types.ts";
 export declare function modelCommand(options: CommandOptions): ReplCommand;
+//# sourceMappingURL=model-command.d.ts.map

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

@@ -0,0 +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"}