@travisennis/acai 0.0.1

package/dist/commands/model-command.js

@@ -0,0 +1,84 @@
+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/commands/paste-command.d.ts

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

package/dist/commands/paste-command.js

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

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

package/dist/commands/prompt-command.js

@@ -0,0 +1,111 @@
+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/commands/reset-command.d.ts

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

package/dist/commands/reset-command.js

@@ -0,0 +1,16 @@
+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/commands/rules-command.d.ts

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

package/dist/commands/rules-command.js

@@ -0,0 +1,68 @@
+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/commands/save-command.d.ts

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

package/dist/commands/save-command.js

@@ -0,0 +1,14 @@
+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/commands/types.d.ts

@@ -0,0 +1,26 @@
+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/commands/types.js

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

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

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

package/dist/commands/usage-command.js

@@ -0,0 +1,21 @@
+export function usageCommand({ terminal, tokenTracker, }) {
+    return {
+        command: "/usage",
+        description: "Show token usage breakdown",
+        result: "continue",
+        getSubCommands: () => Promise.resolve([]),
+        execute() {
+            const entries = Object.entries(tokenTracker.getUsageBreakdown());
+            if (entries.length === 0) {
+                terminal.info("No usage yet.");
+            }
+            else {
+                terminal.table(entries, {
+                    header: ["App", "Tokens"],
+                    colWidths: [30, 70],
+                });
+            }
+            return Promise.resolve();
+        },
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+export declare class DirectoryProvider {
+    private baseDir;
+    constructor(baseDir: string);
+    getPath(subdir?: string): string;
+    ensurePath(subdir?: string): Promise<string>;
+    ensurePathSync(subdir?: string): string;
+}
+export declare class ConfigManager {
+    readonly project: DirectoryProvider;
+    readonly app: DirectoryProvider;
+    constructor();
+    private _readConfig;
+    readProjectConfig(): Promise<ProjectConfig>;
+    readAgentsFile(): Promise<string>;
+    writeAgentsFile(rules: string): Promise<void>;
+    readProjectLearnedRulesFile(): Promise<string>;
+    writeProjectLearnedRulesFile(rules: string): Promise<void>;
+    readCachedLearnedRulesFile(): Promise<string>;
+    writeCachedLearnedRulesFile(rules: string): Promise<void>;
+    readAppConfig(configName: string): Promise<Record<PropertyKey, unknown>>;
+    ensureAppConfig(configName: string): Promise<Record<PropertyKey, unknown>>;
+    writeAppConfig(configName: string, data: Record<PropertyKey, unknown>): Promise<void>;
+}
+declare const ProjectConfigSchema: z.ZodObject<{
+    logs: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>>;
+    tools: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens: number;
+    }, {
+        maxTokens?: number | undefined;
+    }>>>;
+    notify: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    tools: {
+        maxTokens: number;
+    };
+    notify: boolean;
+    logs?: {
+        path: string;
+    } | undefined;
+}, {
+    logs?: {
+        path: string;
+    } | undefined;
+    tools?: {
+        maxTokens?: number | undefined;
+    } | undefined;
+    notify?: boolean | undefined;
+}>;
+export type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+export declare const config: ConfigManager;
+export {};

package/dist/config.js

@@ -0,0 +1,193 @@
+import { mkdirSync } from "node:fs";
+import fs from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { jsonParser } from "./parsing.js";
+export class DirectoryProvider {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    getPath(subdir) {
+        return subdir ? path.join(this.baseDir, subdir) : this.baseDir;
+    }
+    // Async-by-default: prefer non-blocking filesystem operations.
+    async ensurePath(subdir) {
+        const dirPath = this.getPath(subdir);
+        await fs.mkdir(dirPath, { recursive: true });
+        return dirPath;
+    }
+    // Synchronous helper for call-sites that require immediate directory availability.
+    ensurePathSync(subdir) {
+        const dirPath = this.getPath(subdir);
+        mkdirSync(dirPath, { recursive: true });
+        return dirPath;
+    }
+}
+export class ConfigManager {
+    project;
+    app;
+    constructor() {
+        this.project = new DirectoryProvider(path.join(process.cwd(), ".acai"));
+        this.app = new DirectoryProvider(path.join(homedir(), ".acai"));
+    }
+    async _readConfig(configPath) {
+        try {
+            const data = await fs.readFile(configPath, "utf8");
+            return jsonParser(ProjectConfigSchema).parse(data);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return {};
+            }
+            throw error;
+        }
+    }
+    // Project config helpers
+    async readProjectConfig() {
+        const appConfigPath = path.join(this.app.getPath(), "acai.json");
+        const projectConfigPath = path.join(this.project.getPath(), "acai.json");
+        const appConfig = await this._readConfig(appConfigPath);
+        const projectConfig = await this._readConfig(projectConfigPath);
+        const mergedConfig = {
+            ...appConfig,
+            ...projectConfig,
+        };
+        return ProjectConfigSchema.parse(mergedConfig);
+    }
+    async readAgentsFile() {
+        const agentsPath = path.join(process.cwd(), "AGENTS.md");
+        try {
+            return await fs.readFile(agentsPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return "";
+            }
+            throw error;
+        }
+    }
+    async writeAgentsFile(rules) {
+        const agentsPath = path.join(process.cwd(), "AGENTS.md");
+        try {
+            return await fs.writeFile(agentsPath, rules, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+    // Project-specific learned rules
+    async readProjectLearnedRulesFile() {
+        const rulesPath = path.join(this.project.getPath("rules"), "learned-rules.md");
+        try {
+            return await fs.readFile(rulesPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return "";
+            }
+            throw error;
+        }
+    }
+    async writeProjectLearnedRulesFile(rules) {
+        const rulesDir = await this.project.ensurePath("rules");
+        const rulesPath = path.join(rulesDir, "learned-rules.md");
+        try {
+            return await fs.writeFile(rulesPath, rules, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+    // App-cached learned rules (used during conversation analysis)
+    async readCachedLearnedRulesFile() {
+        const rulesPath = path.join(this.app.getPath("rules"), "learned-rules.md");
+        try {
+            return await fs.readFile(rulesPath, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return "";
+            }
+            throw error;
+        }
+    }
+    async writeCachedLearnedRulesFile(rules) {
+        const rulesDir = await this.app.ensurePath("rules");
+        const rulesPath = path.join(rulesDir, "learned-rules.md");
+        try {
+            return await fs.writeFile(rulesPath, rules, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return;
+            }
+            throw error;
+        }
+    }
+    // App config helpers
+    async readAppConfig(configName) {
+        const configPath = path.join(this.app.getPath(), `${configName}.json`);
+        try {
+            const data = await fs.readFile(configPath, "utf8");
+            return JSON.parse(data);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return {};
+            }
+            throw error;
+        }
+    }
+    async ensureAppConfig(configName) {
+        const configPath = path.join(this.app.getPath(), `${configName}.json`);
+        try {
+            await fs.access(configPath);
+            return await this.readAppConfig(configName);
+        }
+        catch {
+            // Create directory and default config if missing
+            await this.app.ensurePath();
+            const defaultConfig = {
+                logs: {
+                    path: path.join(this.app.getPath(), "logs", "current.log"),
+                },
+                tools: {
+                    maxTokens: 30000,
+                },
+                notify: true,
+            };
+            await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
+            return defaultConfig;
+        }
+    }
+    async writeAppConfig(configName, data) {
+        await this.app.ensurePath();
+        const configPath = path.join(this.app.getPath(), `${configName}.json`);
+        await fs.writeFile(configPath, JSON.stringify(data, null, 2));
+    }
+}
+// Type definitions
+const ProjectConfigSchema = z.object({
+    logs: z
+        .object({
+        path: z.string(),
+    })
+        .optional(),
+    tools: z
+        .object({
+        maxTokens: z.number().default(30000),
+    })
+        .optional()
+        .default({ maxTokens: 30000 }),
+    notify: z.boolean().optional().default(true),
+});
+// Create a singleton instance
+export const config = new ConfigManager();