@travisennis/acai 0.0.1

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const compactCommand: (options: CommandOptions) => ReplCommand;

package/dist/commands/compact-command.js

@@ -0,0 +1,51 @@
+import { generateText } from "ai";
+import { createUserMessage } from "../messages.js";
+export const compactCommand = (options) => {
+    return {
+        command: "/compact",
+        description: "Saves, summarizes, and resets the chat history. Optional instructions can be provided for the summary.",
+        result: "continue",
+        getSubCommands: () => Promise.resolve([]),
+        execute: async (args) => {
+            const { messageHistory, terminal } = options;
+            if (!messageHistory.isEmpty()) {
+                const additionalInstructions = args.join(" ");
+                await summarizeAndReset(options, additionalInstructions);
+            }
+            terminal.info("Message history summarized and reset.");
+        },
+    };
+};
+async function summarizeAndReset({ messageHistory, modelManager, tokenTracker }, additionalInstructions) {
+    const app = "conversation-summarizer";
+    // save existing message history
+    await messageHistory.save();
+    // summarize message history
+    let userPrompt = `Your tasks is to provide a detailed summary of our conversation so far. Focus on information that would be helpful for continuing the conversation and the task, including what was the orginal task requested by the user, what we have done so far and why, which files we're working on, and what we're going to do next. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently. You need to provide enough information that another coding agent can you use your summary to pick up where you have left off.
+
+Your summary should include the following sections:
+1. Primary Request and Intent: Capture all of the user's explicit requests and intents in detail
+2. Key Technical Concepts: List all important technical concepts, technologies, and frameworks discussed.
+3. Files and Code Sections: Enumerate specific files and code sections examined, modified, or created. Pay special attention to the most recent messages and include full code snippets where applicable and include a summary of why this file read or edit is important.
+4. Errors and fixes: List all errors that you ran into, and how you fixed them. Pay special attention to specific user feedback that you received, especially if the user told you to do something differently.
+5. Problem Solving: Document problems solved and any ongoing troubleshooting efforts.
+6. All user messages: List ALL user messages that are not tool results. These are critical for understanding the users' feedback and changing intent.
+7. Pending Tasks: Outline any pending tasks that you have explicitly been asked to work on.
+8. Current Work: Describe in detail precisely what was being worked on immediately before this summary request, paying special attention to the most recent messages from both user and assistant. Include file names and code snippets where applicable.
+9. Optional Next Step: List the next step that you will take that is related to the most recent work you were doing. IMPORTANT: ensure that this step is DIRECTLY in line with the user's explicit requests, and the task you were working on immediately before this summary request. If your last task was concluded, then only list next steps if they are explicitly in line with the users request. Do not start on tangential requests without confirming with the user first.
+
+ If there is a next step, include direct quotes from the most recent conversation showing exactly what task you were working on and where you left off. This should be verbatim to ensure there's no drift in task interpretation.`;
+    if (additionalInstructions && additionalInstructions.trim().length > 0) {
+        userPrompt += `\n\nAdditional instructions provided by the user: ${additionalInstructions}`;
+    }
+    messageHistory.appendUserMessage(createUserMessage([], userPrompt));
+    const { text, usage } = await generateText({
+        model: modelManager.getModel(app),
+        system: "You are a helpful AI assistant tasked with summarizing conversations so that a coding agent such as yourself can understand what actions have been taken on a code base and what future work still needs to be done.",
+        messages: messageHistory.get(),
+    });
+    tokenTracker.trackUsage(app, usage);
+    //clear messages
+    messageHistory.clear();
+    messageHistory.appendUserMessage(createUserMessage([text]));
+}

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare function copyCommand(options: CommandOptions): ReplCommand;

package/dist/commands/copy-command.js

@@ -0,0 +1,51 @@
+import Clipboard from "@crosscopy/clipboard";
+function extractLastAssistantText(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg)
+            continue;
+        if (msg.role !== "assistant")
+            continue;
+        if (!("content" in msg) || !Array.isArray(msg.content))
+            continue;
+        // Find last text part
+        for (let j = msg.content.length - 1; j >= 0; j--) {
+            const part = msg.content[j];
+            if (part &&
+                part.type === "text" &&
+                typeof part.text === "string") {
+                const text = part.text;
+                if (text.trim().length > 0)
+                    return text;
+            }
+        }
+    }
+    return null;
+}
+export function copyCommand(options) {
+    return {
+        command: "/copy",
+        description: "Copy the last assistant response to the clipboard",
+        result: "continue",
+        async getSubCommands() {
+            return [];
+        },
+        async execute(_args) {
+            const { messageHistory, terminal } = options;
+            const history = messageHistory.get();
+            const lastText = extractLastAssistantText(history);
+            if (!lastText) {
+                terminal.info("No assistant response to copy.");
+                return;
+            }
+            try {
+                await Clipboard.setText(lastText);
+                terminal.success("Copied last response to clipboard.");
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                terminal.error(`Could not copy to clipboard: ${message}`);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const editCommand: ({ terminal }: CommandOptions) => ReplCommand;

package/dist/commands/edit-command.js

@@ -0,0 +1,53 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import { editor, search } from "@inquirer/prompts";
+import { globby } from "globby";
+export const editCommand = ({ terminal }) => {
+    return {
+        command: "/edit",
+        description: "Opens file in $EDITOR for editing. Usage: /edit [file-path]",
+        result: "continue",
+        getSubCommands: () => Promise.resolve([]),
+        execute: async (args) => {
+            let fileToEdit;
+            if (args.length > 0) {
+                // File path provided as argument
+                const filePath = args.join(" "); // Handle file paths with spaces
+                const resolvedPath = resolve(filePath);
+                if (!existsSync(resolvedPath)) {
+                    terminal.error(`File not found: ${filePath}`);
+                    return;
+                }
+                fileToEdit = filePath;
+            }
+            else {
+                // No file path provided, use search prompt
+                fileToEdit = await search({
+                    message: "Search for file:",
+                    source: async (input) => {
+                        if (!input) {
+                            return [];
+                        }
+                        const foundFiles = await globby(`**/*${input}*`, {
+                            gitignore: true,
+                        });
+                        return foundFiles.map((file) => ({
+                            name: file,
+                            value: file,
+                        }));
+                    },
+                });
+            }
+            const content = readFileSync(fileToEdit, { encoding: "utf8" });
+            const edit = await editor({
+                message: `Edit ${fileToEdit}?`,
+                postfix: extname(fileToEdit),
+                default: content,
+            });
+            writeFileSync(fileToEdit, edit);
+            if (content !== edit) {
+                terminal.info(`File updated: ${fileToEdit}`);
+            }
+        },
+    };
+};

package/dist/commands/edit-prompt-command.d.ts

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const editPromptCommand: ({ terminal, promptManager, }: CommandOptions) => ReplCommand;

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

@@ -0,0 +1,25 @@
+import { editor } from "@inquirer/prompts";
+import { syncTry } from "@travisennis/stdlib/try";
+export const editPromptCommand = ({ terminal, promptManager, }) => {
+    return {
+        command: "/edit-prompt",
+        description: "Edit the prompt.",
+        result: "use",
+        getSubCommands: () => Promise.resolve([]),
+        execute: async () => {
+            try {
+                const prompt = syncTry(() => promptManager.get());
+                const updatedPrompt = await editor({
+                    message: " Edit prompt?",
+                    postfix: "md",
+                    default: prompt.unwrapOr(""),
+                });
+                terminal.writeln(`> ${updatedPrompt}`);
+                promptManager.set(updatedPrompt);
+            }
+            catch (error) {
+                terminal.error(`Error updating prompt: ${error.message}`);
+            }
+        },
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const exitCommand: ({ messageHistory, }: CommandOptions) => ReplCommand;

package/dist/commands/exit-command.js

@@ -0,0 +1,14 @@
+export const exitCommand = ({ messageHistory, }) => {
+    return {
+        command: "/exit",
+        aliases: ["/bye", "/quit"],
+        description: "Exits and saves the chat history.",
+        result: "break",
+        getSubCommands: () => Promise.resolve([]),
+        execute: async () => {
+            if (!messageHistory.isEmpty()) {
+                await messageHistory.save();
+            }
+        },
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const filesCommand: ({ terminal, promptManager, modelManager, }: CommandOptions) => ReplCommand;

package/dist/commands/files-command.js

@@ -0,0 +1,63 @@
+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";
+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 selectedFiles = await checkbox({
+                        message: "Select files to include:",
+                        choices: foundFiles,
+                        pageSize: 15,
+                    });
+                    if (selectedFiles.length === 0) {
+                        terminal.warn("No files selected.");
+                        return;
+                    }
+                    // Process the selected files
+                    workingFiles = selectedFiles;
+                }
+                else {
+                    const patternList = args.filter(Boolean);
+                    const foundFiles = await globby(patternList, { gitignore: true });
+                    if (foundFiles.length === 0) {
+                        terminal.warn("No files found matching the pattern(s)");
+                        return;
+                    }
+                    // Process the selected files
+                    workingFiles = foundFiles;
+                }
+                // Read the content of the files and format them for the next prompt
+                const format = modelManager.getModelMetadata("repl").promptFormat;
+                let tokenCount = 0;
+                const tokenCounter = new TokenCounter();
+                await Promise.all(workingFiles.map(async (filePath) => {
+                    try {
+                        const content = await readFile(filePath, "utf-8");
+                        const formattedFile = formatFile(filePath, content, format);
+                        tokenCount += tokenCounter.count(formattedFile);
+                        promptManager.addContext(formattedFile);
+                    }
+                    catch (error) {
+                        terminal.error(`Error reading file ${filePath}: ${error.message}`);
+                    }
+                }));
+                tokenCounter.free();
+                terminal.success(`File contents will be added to your next prompt (${workingFiles.length} files, ${tokenCount} tokens)`);
+            }
+            catch (error) {
+                terminal.error(`Error processing file patterns: ${error.message}`);
+            }
+        },
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const generateRulesCommand: ({ terminal, messageHistory, modelManager, tokenTracker, config, }: CommandOptions) => ReplCommand;

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

@@ -0,0 +1,61 @@
+import { checkbox } from "@inquirer/prompts";
+import { analyzeConversation } from "../conversation-analyzer.js";
+import { logger } from "../logger.js"; // Import logger
+async function _processAndSaveRules(newRules, terminal, config) {
+    if (!newRules || newRules.length === 0) {
+        terminal.warn("No new generalizable rules were identified.");
+        return;
+    }
+    terminal.info("Generated potential rules:");
+    terminal.lineBreak();
+    const rulesToKeep = await checkbox({
+        message: "Select the rules you want to keep:",
+        choices: newRules.map((rule) => ({ name: rule, value: rule })),
+    });
+    if (rulesToKeep.length === 0) {
+        terminal.warn("No rules selected to save.");
+        return;
+    }
+    terminal.info("Saving selected rules...");
+    const existingRules = await config.readProjectLearnedRulesFile();
+    const rulesToAdd = rulesToKeep.join("\n");
+    const updatedProjectRules = existingRules.endsWith("\n") || existingRules.length === 0
+        ? `${existingRules}${rulesToAdd}`
+        : `${existingRules}\n${rulesToAdd}`;
+    await config.writeProjectLearnedRulesFile(updatedProjectRules);
+    terminal.success("Selected rules saved to project learned rules.");
+    terminal.lineBreak();
+    terminal.display(rulesToAdd); // Display only the saved rules
+}
+export const generateRulesCommand = ({ terminal, messageHistory, modelManager, tokenTracker, config, // This is the config module from CommandOptions
+ }) => {
+    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;
+            }
+            terminal.lineBreak();
+            terminal.info("Analyzing conversation to generate rules...");
+            try {
+                const newRules = await analyzeConversation({
+                    modelManager,
+                    messages: messageHistory.get(),
+                    tokenTracker,
+                    terminal,
+                });
+                // Pass the config object available in CommandOptions scope
+                await _processAndSaveRules(newRules, terminal, config);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                terminal.error(`Error generating rules: ${errorMessage}`);
+                logger.error(error, "Error during rule generation:");
+            }
+        },
+    };
+};

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

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

package/dist/commands/help-command.js

@@ -0,0 +1,19 @@
+export const helpCommand = ({ terminal }, cmds) => {
+    return {
+        command: "/help",
+        description: "Shows available commands.",
+        result: "continue",
+        getSubCommands: () => Promise.resolve([]),
+        execute: () => {
+            const commands = cmds;
+            const entries = Array.from(commands.entries())
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([key, cmd]) => [key, cmd.description]);
+            terminal.table(entries, {
+                header: ["Command", "Description"],
+                colWidths: [30, 70],
+            });
+            return Promise.resolve();
+        },
+    };
+};

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

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

package/dist/commands/init-command.js

@@ -0,0 +1,40 @@
+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, }) => {
+    return {
+        command: "/init",
+        description: "Creates the AGENTS.md file.",
+        result: "continue",
+        getSubCommands: () => Promise.resolve([]),
+        execute: async () => {
+            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()}`,
+                stopWhen: stepCountIs(40),
+                tools: await initTools({
+                    terminal,
+                    tokenCounter,
+                    events: toolEvents,
+                    autoAcceptAll: true,
+                }),
+            });
+            for await (const text of result.textStream) {
+                terminal.write(text);
+            }
+        },
+    };
+};

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare const lastLogCommand: ({ terminal }: CommandOptions) => ReplCommand;

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

@@ -0,0 +1,76 @@
+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";
+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);
+    if (files.length === 0) {
+        return null;
+    }
+    const datedFiles = files
+        .map((file) => {
+        const filename = file.split("/").pop();
+        if (!filename) {
+            return null; // Skip if filename is somehow undefined
+        }
+        // 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);
+            }
+        }
+        return null; // Exclude files that don't match the pattern or have invalid dates
+    })
+        .filter((item) => item !== null);
+    if (datedFiles.length === 0) {
+        return null; // No valid log files found
+    }
+    // Sort files by date (descending)
+    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 }) => {
+    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;
+            }
+            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)}`,
+                    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.
+                });
+                terminal.info("Closed log view");
+            }
+            catch (error) {
+                terminal.error(`Error reading or displaying log file ${mostRecentLog}: ${error}`);
+            }
+        },
+    };
+};

package/dist/commands/manager.d.ts

@@ -0,0 +1,22 @@
+import type { CommandOptions } from "./types.ts";
+export declare class CommandManager {
+    private commands;
+    private promptManager;
+    private modelManager;
+    private messageHistory;
+    private tokenTracker;
+    private terminal;
+    private config;
+    private tokenCounter;
+    private toolEvents;
+    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, }: CommandOptions);
+    initializeCommmands(): void;
+    getCommands(): string[];
+    getSubCommands(command: string): Promise<string[]>;
+    handle({ userInput }: {
+        userInput: string;
+    }): Promise<{
+        continue: boolean;
+        break: boolean;
+    }>;
+}

package/dist/commands/manager.js

@@ -0,0 +1,123 @@
+import { applicationLogCommand } from "./application-log-command.js";
+import { clearCommand } from "./clear-command.js";
+import { compactCommand } from "./compact-command.js";
+import { copyCommand } from "./copy-command.js";
+import { editCommand } from "./edit-command.js";
+import { editPromptCommand } from "./edit-prompt-command.js";
+import { exitCommand } from "./exit-command.js";
+import { filesCommand } from "./files-command.js";
+import { generateRulesCommand } from "./generate-rules-command.js";
+import { helpCommand } from "./help-command.js";
+import { initCommand } from "./init-command.js";
+import { lastLogCommand } from "./last-log-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 { usageCommand } from "./usage-command.js";
+export class CommandManager {
+    commands;
+    promptManager;
+    modelManager;
+    messageHistory;
+    tokenTracker;
+    terminal;
+    config;
+    tokenCounter;
+    toolEvents;
+    constructor({ promptManager, modelManager, terminal, messageHistory, tokenTracker, config, tokenCounter, toolEvents, }) {
+        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.initializeCommmands();
+    }
+    initializeCommmands() {
+        // Import and register each command
+        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,
+        };
+        // Register all commands
+        const cmds = [
+            clearCommand(options),
+            compactCommand(options),
+            editCommand(options),
+            editPromptCommand(options),
+            exitCommand(options),
+            filesCommand(options),
+            initCommand(options),
+            pasteCommand(options),
+            promptCommand(options),
+            resetCommand(options),
+            saveCommand(options),
+            rulesCommand(options),
+            modelCommand(options),
+            usageCommand(options),
+            lastLogCommand(options),
+            generateRulesCommand(options),
+            applicationLogCommand(options),
+            copyCommand(options),
+        ];
+        // Add help command with access to all commands
+        const helpCmd = helpCommand(options, this.commands);
+        cmds.push({
+            ...helpCmd,
+            execute: () => helpCmd.execute([]),
+        });
+        // 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);
+            }
+        }
+    }
+    getCommands() {
+        return Array.from(this.commands.keys()).sort();
+    }
+    async getSubCommands(command) {
+        return (await this.commands.get(command)?.getSubCommands()) ?? [];
+    }
+    async handle({ userInput }) {
+        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") {
+                    return {
+                        continue: true,
+                        break: false,
+                    };
+                }
+                if (replCommand.result === "break") {
+                    return {
+                        continue: false,
+                        break: true,
+                    };
+                }
+            }
+        }
+        return {
+            continue: false,
+            break: false,
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+import type { CommandOptions, ReplCommand } from "./types.ts";
+export declare function modelCommand(options: CommandOptions): ReplCommand;