@travisennis/acai 0.0.1 → 0.0.3

package/dist/source/commands/init-command.js

@@ -1,40 +0,0 @@
-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/source/commands/last-log-command.d.ts

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

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

@@ -1,76 +0,0 @@
-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/source/commands/manager.d.ts

@@ -1,22 +0,0 @@
-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/source/commands/manager.js

@@ -1,123 +0,0 @@
-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/source/commands/model-command.d.ts

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

package/dist/source/commands/model-command.js

@@ -1,84 +0,0 @@
-import { formatModelInfo, getModelsByCategory, isValidModel, modelRegistry, models, providers, } from "../models/providers.js";
-export function modelCommand(options) {
-    const { terminal, modelManager } = options;
-    function switchModel(newModelName) {
-        try {
-            // Get current and new model configs
-            const currentModelConfig = modelManager.getModelMetadata("repl");
-            const newModelConfig = modelRegistry[newModelName]; // Ensure modelRegistry is available
-            if (!newModelConfig) {
-                terminal.error(`Model configuration not found for: ${newModelName}`);
-                return;
-            }
-            // Check for capability differences
-            if (currentModelConfig.supportsToolCalling &&
-                !newModelConfig.supportsToolCalling) {
-                terminal.warn("The new model doesn't support tool calling, which may limit functionality.");
-            }
-            if (currentModelConfig.supportsReasoning &&
-                !newModelConfig.supportsReasoning) {
-                terminal.warn("The new model doesn't support reasoning, which may change response quality.");
-            }
-            // Update model in ModelManager
-            modelManager.setModel("repl", newModelName);
-            // Assuming ModelManager handles the actual model instance switching internally.
-            terminal.info(`Model set to ${newModelName}.`); // Simplified message
-        }
-        catch (error) {
-            terminal.error(`Failed to switch model: ${error.message}`);
-        }
-    }
-    return {
-        command: "/model",
-        description: "List available models or switch to a different model. Usage: /model [provider:model-name|category|provider]",
-        result: "continue",
-        getSubCommands: () => Promise.resolve(models),
-        async execute(args) {
-            const arg = args.join(" ").trim();
-            const modelConfig = modelManager.getModelMetadata("repl");
-            // No args - display current model and list available models by category
-            if (!arg) {
-                const currentModel = modelConfig.id;
-                terminal.header(`Current model: ${currentModel}`);
-                terminal.header("Available models by category:");
-                // Display models by category
-                for (const category of ["fast", "balanced", "powerful"]) {
-                    // Use 'as const' for stricter typing
-                    terminal.writeln(`\n${category.charAt(0).toUpperCase() + category.slice(1)} models:`);
-                    for (const model of getModelsByCategory(category)) {
-                        terminal.writeln(formatModelInfo(model));
-                    }
-                }
-                return;
-            }
-            // Switch to a specific model
-            if (isValidModel(arg)) {
-                // Call the standalone switchModel function
-                switchModel(arg);
-                return;
-            }
-            // Display models by category
-            const categories = ["fast", "balanced", "powerful"];
-            if (categories.includes(arg)) {
-                terminal.header(`${arg.charAt(0).toUpperCase() + arg.slice(1)} models:`);
-                // Need to assert arg is a valid category if the check passes
-                for (const model of getModelsByCategory(arg)) {
-                    terminal.writeln(formatModelInfo(model));
-                }
-                return;
-            }
-            // Display models by provider
-            if (providers.includes(arg)) {
-                terminal.header(`Models from ${arg}:`);
-                // Need to ensure modelRegistry is accessible and correctly typed
-                for (const model of Object.values(modelRegistry).filter((m) => m.provider === arg)) {
-                    terminal.writeln(formatModelInfo(model));
-                }
-                return;
-            }
-            // Invalid model name
-            terminal.error(`Invalid model name or category: ${arg}`);
-            terminal.info("Usage: /model [provider:model-name|category|provider]");
-        },
-    };
-}

package/dist/source/commands/paste-command.d.ts

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

package/dist/source/commands/paste-command.js

@@ -1,40 +0,0 @@
-import Clipboard from "@crosscopy/clipboard";
-import { formatBlock } from "../formatting.js";
-import { logger } from "../logger.js";
-const base64UrlRegex = /^data:(.*?);base64,/;
-export const pasteCommand = ({ terminal, modelManager, promptManager, }) => {
-    return {
-        command: "/paste",
-        description: "Pastes image or text content from the clipboard into the next prompt.",
-        result: "continue",
-        getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
-            try {
-                if (Clipboard.hasImage()) {
-                    const base64DataUrl = await Clipboard.getImageBase64();
-                    const mimeTypeMatch = base64DataUrl.match(base64UrlRegex);
-                    const mimeType = mimeTypeMatch ? mimeTypeMatch[1] : "image/png";
-                    promptManager.addContext({
-                        type: "image",
-                        image: base64DataUrl,
-                        mediaType: mimeType,
-                    });
-                    terminal.success("Image from clipboard will be added to your next prompt.");
-                    return;
-                }
-                const clipboardContent = await Clipboard.getText();
-                if (!clipboardContent || clipboardContent.trim() === "") {
-                    terminal.warn("Clipboard is empty.");
-                    return;
-                }
-                promptManager.addContext(formatBlock(clipboardContent, "clipboard", modelManager.getModelMetadata("repl").promptFormat));
-                terminal.success("Clipboard content will be added to your next prompt.");
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                terminal.error(`Error processing clipboard content: ${message}`);
-                logger.error(error, "Paste command error:");
-            }
-        },
-    };
-};

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

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

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

@@ -1,111 +0,0 @@
-import { readdir, readFile } from "node:fs/promises";
-import path, { basename } from "node:path";
-import { processPrompt } from "../mentions.js";
-export const promptCommand = ({ terminal, modelManager, promptManager, config, }) => {
-    return {
-        command: "/prompt",
-        description: "Loads and executes prompts. Project prompts override user prompts with the same name.",
-        result: "use",
-        getSubCommands: async () => {
-            const getPromptNamesFromDir = async (dirPath) => {
-                try {
-                    const dirents = await readdir(dirPath, { withFileTypes: true });
-                    return dirents
-                        .filter((dirent) => dirent.isFile() && dirent.name.endsWith(".md"))
-                        .map((dirent) => basename(dirent.name, ".md"));
-                }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        return []; // Directory doesn't exist, return empty array
-                    }
-                    terminal.error(`Error reading prompts from ${dirPath}: ${error}`);
-                    return []; // Return empty on other errors too, but log them
-                }
-            };
-            const userPromptDir = config.app.ensurePathSync("prompts"); // User prompts are global (~/.acai/prompts)
-            const projectPromptDir = config.project.ensurePathSync("prompts"); // Project prompts are local (./.acai/prompts)
-            const userPrompts = await getPromptNamesFromDir(userPromptDir);
-            const projectPrompts = await getPromptNamesFromDir(projectPromptDir);
-            // Combine and deduplicate, with project prompts taking precedence
-            const allPrompts = new Set([...userPrompts, ...projectPrompts]);
-            return Array.from(allPrompts).sort();
-        },
-        execute: async (args) => {
-            const promptName = args?.[0];
-            if (!promptName) {
-                terminal.warn("Please provide a prompt name. Usage: /prompt <prompt-name> [input...]");
-                return;
-            }
-            // Check for old format and provide helpful error
-            if (promptName.includes(":")) {
-                terminal.warn("The old format (user:name or project:name) is no longer supported. Use: /prompt <prompt-name> [input...]");
-                return;
-            }
-            try {
-                const promptResult = await findPrompt(promptName, config);
-                if (!promptResult) {
-                    terminal.error(`Prompt not found: ${promptName}. Available prompts can be seen with tab completion.`);
-                    return;
-                }
-                let promptContent;
-                try {
-                    promptContent = await readFile(promptResult.path, "utf8");
-                }
-                catch (error) {
-                    if (error.code === "ENOENT") {
-                        terminal.error(`Prompt file not found: ${promptName} at ${promptResult.path}`);
-                        return;
-                    }
-                    throw error;
-                }
-                // Combine remaining arguments into a single string for input
-                const inputArgs = args.slice(1);
-                const inputString = inputArgs.join(" ");
-                // Replace {{INPUT}} placeholder with the input string
-                if (promptContent.includes("{{INPUT}}")) {
-                    promptContent = promptContent.replace(/{{INPUT}}/g, inputString);
-                }
-                terminal.info(`Loaded ${promptResult.type} prompt: ${promptName}`);
-                if (inputArgs.length > 0) {
-                    terminal.info(`Input: "${inputString}"`);
-                }
-                const processedPrompt = await processPrompt(promptContent, {
-                    baseDir: process.cwd(),
-                    model: modelManager.getModelMetadata("repl"),
-                });
-                for (const context of processedPrompt.context) {
-                    promptManager.addContext(context);
-                }
-                promptManager.set(processedPrompt.message);
-            }
-            catch (error) {
-                terminal.error(`Error loading prompt: ${error.message}`);
-            }
-        },
-    };
-};
-async function findPrompt(promptName, config) {
-    // Check project prompts first (they take precedence)
-    const projectPath = path.join(config.project.ensurePathSync("prompts"), `${promptName}.md`);
-    try {
-        await readFile(projectPath, "utf8");
-        return { path: projectPath, type: "project" };
-    }
-    catch (error) {
-        if (error.code !== "ENOENT") {
-            throw error; // Re-throw non-file-not-found errors
-        }
-    }
-    // Check user prompts if not found in project
-    const userPath = path.join(config.app.ensurePathSync("prompts"), `${promptName}.md`);
-    try {
-        await readFile(userPath, "utf8");
-        return { path: userPath, type: "user" };
-    }
-    catch (error) {
-        if (error.code !== "ENOENT") {
-            throw error; // Re-throw non-file-not-found errors
-        }
-    }
-    return null; // Prompt not found in either location
-}

package/dist/source/commands/reset-command.d.ts

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

package/dist/source/commands/reset-command.js

@@ -1,16 +0,0 @@
-export const resetCommand = ({ terminal, messageHistory, }) => {
-    return {
-        command: "/reset",
-        description: "Saves the chat history and then resets it.",
-        result: "continue",
-        getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
-            if (!messageHistory.isEmpty()) {
-                await messageHistory.save();
-                messageHistory.clear();
-            }
-            terminal.setTitle(`acai: ${process.cwd()}`);
-            terminal.clear();
-        },
-    };
-};

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

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

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

@@ -1,68 +0,0 @@
-import { editor } from "@inquirer/prompts";
-import { config } from "../config.js";
-export const rulesCommand = ({ terminal }) => {
-    return {
-        command: "/rules",
-        description: "View, add, or edit rules. Usage: /rules [view|add <text>|edit]",
-        result: "continue",
-        getSubCommands: () => Promise.resolve(["view", "add", "edit"]),
-        execute: async (args) => {
-            const subCommand = args[0] ?? "view"; // Default to 'view'
-            const commandArgs = args.slice(1).join(" ");
-            try {
-                switch (subCommand) {
-                    case "view": {
-                        const currentContent = await config.readAgentsFile();
-                        if (currentContent) {
-                            terminal.writeln("--- Current Rules ---");
-                            terminal.writeln(currentContent);
-                            terminal.writeln("---------------------");
-                        }
-                        else {
-                            terminal.writeln("No rules defined yet. Use '/rules add' or '/rules edit'.");
-                        }
-                        break;
-                    }
-                    case "add": {
-                        const newMemory = commandArgs.trim();
-                        if (!newMemory) {
-                            terminal.error("Error: Memory text cannot be empty for 'add'.");
-                            terminal.writeln("Usage: /memory add <new memory text>");
-                            return;
-                        }
-                        const currentContent = await config.readAgentsFile();
-                        const updatedContent = currentContent
-                            ? `${currentContent.trim()}\n- ${newMemory}` // Ensure space after dash
-                            : `- ${newMemory}`; // Start with dash if new file
-                        await config.writeAgentsFile(updatedContent);
-                        break;
-                    }
-                    case "edit": {
-                        const currentContent = await config.readAgentsFile();
-                        const updatedContent = await editor({
-                            message: "Edit rules:",
-                            postfix: "md",
-                            default: currentContent,
-                        });
-                        // Check if the user cancelled the edit (editor returns the original content)
-                        // Or if the content is actually different
-                        if (updatedContent !== currentContent) {
-                            await config.writeAgentsFile(updatedContent);
-                        }
-                        else {
-                            terminal.writeln("Edit cancelled or no changes made.");
-                        }
-                        break;
-                    }
-                    default:
-                        terminal.writeln("Invalid subcommand. Usage: /rules [view|add <text>|edit]");
-                        break;
-                }
-            }
-            catch (_error) {
-                // Errors from read/write helpers are already logged
-                terminal.error("Failed to execute memory command.");
-            }
-        },
-    };
-};

package/dist/source/commands/save-command.d.ts

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

package/dist/source/commands/save-command.js

@@ -1,14 +0,0 @@
-export const saveCommand = ({ messageHistory, terminal, }) => {
-    return {
-        command: "/save",
-        description: "Saves the chat history.",
-        result: "continue",
-        getSubCommands: () => Promise.resolve([]),
-        execute: async () => {
-            if (!messageHistory.isEmpty()) {
-                await messageHistory.save();
-            }
-            terminal.info("Message history saved.");
-        },
-    };
-};

package/dist/source/commands/types.d.ts

@@ -1,26 +0,0 @@
-import type { ConfigManager } from "../config.ts";
-import type { MessageHistory } from "../messages.ts";
-import type { ModelManager } from "../models/manager.ts";
-import type { PromptManager } from "../prompts/manager.ts";
-import type { Terminal } from "../terminal/index.ts";
-import type { TokenTracker } from "../token-tracker.ts";
-import type { TokenCounter } from "../token-utils.ts";
-import type { Message } from "../tools/types.ts";
-export interface ReplCommand {
-    command: string;
-    aliases?: string[];
-    description: string;
-    result: "break" | "continue" | "use";
-    getSubCommands: () => Promise<string[]>;
-    execute: (args: string[]) => Promise<void>;
-}
-export interface CommandOptions {
-    promptManager: PromptManager;
-    modelManager: ModelManager;
-    terminal: Terminal;
-    messageHistory: MessageHistory;
-    tokenTracker: TokenTracker;
-    config: ConfigManager;
-    tokenCounter: TokenCounter;
-    toolEvents: Map<string, Message[]>;
-}

package/dist/source/commands/types.js

@@ -1 +0,0 @@
-export {};

package/dist/source/commands/usage-command.d.ts

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