@travisennis/acai 0.0.1

package/dist/repl.js

@@ -0,0 +1,431 @@
+import { isNumber, isRecord } from "@travisennis/stdlib/typeguards";
+import { generateObject, NoSuchToolError, stepCountIs, streamText, } from "ai";
+import chalk from "chalk";
+import { config as configManager } from "./config.js";
+import { logger } from "./logger.js";
+import { processPrompt } from "./mentions.js";
+import { AiConfig } from "./models/ai-config.js";
+import { systemPrompt } from "./prompts.js";
+import { ReplPrompt } from "./repl-prompt.js";
+import { isMarkdown } from "./terminal/markdown-utils.js";
+import { getCurrentBranch, getDiffStat, hasUncommittedChanges, inGitDirectory, } from "./tools/git-utils.js"; // Modified import
+import { initAgents, initTools } from "./tools/index.js";
+export class Repl {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run() {
+        const { config, promptManager, terminal, modelManager, tokenTracker, messageHistory, commands, tokenCounter, toolEvents, autoAcceptAll, } = this.options;
+        logger.info(config, "Config:");
+        terminal.displayWelcome();
+        const promptHistory = [];
+        let currentContextWindow = 0;
+        messageHistory.on("clear-history", () => {
+            currentContextWindow = 0;
+        });
+        let prevCb = null;
+        while (true) {
+            const abortController = new AbortController();
+            const { signal } = abortController;
+            const cb = () => {
+                abortController.abort();
+            };
+            if (prevCb) {
+                process.removeListener("SIGINT", prevCb);
+            }
+            // Handle Ctrl+C (SIGINT)
+            process.on("SIGINT", cb);
+            prevCb = cb;
+            const langModel = modelManager.getModel("repl");
+            const modelConfig = modelManager.getModelMetadata("repl");
+            const currentDir = process.cwd().split("/").pop() || process.cwd();
+            const branch = await getCurrentBranch();
+            let branchDisplay = "";
+            if (branch) {
+                const hasChanges = await hasUncommittedChanges();
+                const asterisk = hasChanges ? "*" : "";
+                branchDisplay = ` ${chalk.gray(branch + asterisk)}`;
+            }
+            terminal.hr();
+            terminal.writeln(`${chalk.blue(currentDir)}${branchDisplay}`);
+            terminal.writeln(chalk.dim(langModel.modelId));
+            terminal.displayProgressBar(currentContextWindow, modelConfig.contextWindow);
+            if (!promptManager.isPending()) {
+                // For interactive input
+                const prompt = new ReplPrompt({ commands, history: promptHistory });
+                const userInput = await prompt.input();
+                prompt.close();
+                // see if the userInput contains a command
+                const commandResult = await commands.handle({ userInput });
+                if (commandResult.break) {
+                    break;
+                }
+                if (commandResult.continue) {
+                    terminal.lineBreak();
+                    continue;
+                }
+                if (!userInput.trim()) {
+                    continue;
+                }
+                // if there is no pending prompt then use the user's input. otherwise, the prompt was loaded from a command
+                if (!promptManager.isPending()) {
+                    const processedPrompt = await processPrompt(userInput, {
+                        baseDir: process.cwd(),
+                        model: modelConfig,
+                    });
+                    for (const context of processedPrompt.context) {
+                        promptManager.addContext(context);
+                    }
+                    promptManager.set(processedPrompt.message);
+                }
+                terminal.lineBreak();
+            }
+            // flag to see if the user prompt has added context
+            const hasAddedContext = promptManager.hasContext();
+            if (hasAddedContext) {
+                terminal.info("Context will be added to prompt.");
+                terminal.lineBreak();
+            }
+            const userPrompt = promptManager.get();
+            const userMsg = promptManager.getUserMessage();
+            messageHistory.appendUserMessage(userMsg);
+            const finalSystemPrompt = await systemPrompt({
+                supportsToolCalling: modelConfig.supportsToolCalling,
+            });
+            const aiConfig = new AiConfig({
+                modelMetadata: modelConfig,
+                prompt: userPrompt,
+            });
+            const maxTokens = aiConfig.getMaxTokens();
+            const tools = modelConfig.supportsToolCalling
+                ? {
+                    ...(await initTools({
+                        terminal,
+                        tokenCounter,
+                        autoAcceptAll,
+                        events: toolEvents,
+                    })),
+                    ...(await initAgents({
+                        terminal,
+                        modelManager,
+                        tokenTracker,
+                        tokenCounter,
+                        events: toolEvents,
+                    })),
+                }
+                : undefined;
+            try {
+                const result = streamText({
+                    model: langModel,
+                    maxOutputTokens: maxTokens,
+                    messages: [
+                        {
+                            role: "system",
+                            content: finalSystemPrompt,
+                            providerOptions: {
+                                anthropic: { cacheControl: { type: "ephemeral" } },
+                            },
+                        },
+                        ...messageHistory.get(),
+                    ],
+                    temperature: modelConfig.defaultTemperature,
+                    stopWhen: stepCountIs(60),
+                    maxRetries: 2,
+                    providerOptions: aiConfig.getProviderOptions(),
+                    tools,
+                    // biome-ignore lint/style/useNamingConvention: third-party controlled
+                    experimental_repairToolCall: modelConfig.supportsToolCalling
+                        ? toolCallRepair(modelManager, terminal)
+                        : undefined,
+                    abortSignal: signal,
+                    onFinish: async (result) => {
+                        logger.debug("onFinish called");
+                        if (result.response.messages.length > 0) {
+                            messageHistory.appendResponseMessages(result.response.messages);
+                        }
+                        terminal.hr();
+                        // Notify if configured in project config (acai.json)
+                        const projectConfig = await configManager.readProjectConfig();
+                        if (projectConfig.notify) {
+                            terminal.alert();
+                        }
+                        // Create a more visual representation of steps/tool usage
+                        this.displayToolUse(result, terminal);
+                        if (await inGitDirectory()) {
+                            // Added check
+                            const stats = await getDiffStat();
+                            terminal.writeln(`${chalk.dim("Files changed:")} ${chalk.yellow(stats.filesChanged)} ` +
+                                `${chalk.green(`+${stats.insertions}`)} ` + // Insertions first (green)
+                                `${chalk.red(`-${stats.deletions}`)}`);
+                        }
+                        const total = result.totalUsage ??
+                            result.usage;
+                        const outgoingTokens = isNumber(total.inputTokens)
+                            ? total.inputTokens
+                            : 0;
+                        const incomingTokens = isNumber(total.outputTokens)
+                            ? total.outputTokens
+                            : 0;
+                        const tokenSummary = `Tokens: ↑ ${outgoingTokens} ↓ ${incomingTokens}`;
+                        terminal.writeln(chalk.dim(tokenSummary));
+                        // Track aggregate usage across all steps when available
+                        tokenTracker.trackUsage("repl", total);
+                        // Derive current context window from final step usage
+                        const finalTotalTokens = result.usage.totalTokens;
+                        if (isNumber(finalTotalTokens)) {
+                            currentContextWindow = finalTotalTokens ?? 0;
+                        }
+                        else {
+                            // Fallback: find the stopped step
+                            for (const step of result.steps) {
+                                if (step.finishReason === "stop") {
+                                    const usage = step.usage;
+                                    currentContextWindow = Number.isNaN(usage.totalTokens)
+                                        ? 0
+                                        : (usage.totalTokens ?? 0);
+                                }
+                            }
+                        }
+                        // comment out auto-summarization for now. it's been causing issues.
+                        // if (currentContextWindow > 70000) {
+                        //   logger.info(
+                        //     `Condensing history from ${currentContextWindow} to 0`,
+                        //   );
+                        //   await messageHistory.summarizeAndReset();
+                        // }
+                        terminal.hr();
+                    },
+                    onError: ({ error }) => {
+                        logger.error(error, // Log the full error object
+                        "Error on REPL streamText");
+                        terminal.error(error.message.length > 100
+                            ? `${error.message.slice(0, 100)}...`
+                            : error.message);
+                    },
+                });
+                let accumulatedText = "";
+                let lastType = null;
+                for await (const chunk of result.fullStream) {
+                    // Handle text-related chunks (reasoning or text-delta)
+                    if (chunk.type === "reasoning-delta" || chunk.type === "text-delta") {
+                        if (chunk.type === "reasoning-delta") {
+                            if (lastType !== "reasoning") {
+                                terminal.writeln(chalk.dim("<think>"));
+                            }
+                            terminal.write(chalk.dim(chunk.text)); // Stream reasoning directly
+                            lastType = "reasoning";
+                        }
+                        else if (chunk.type === "text-delta") {
+                            if (lastType === "reasoning") {
+                                // Finishing reasoning: Print </think>
+                                terminal.writeln(chalk.dim("\n</think>\n"));
+                            }
+                            accumulatedText += chunk.text;
+                            lastType = "text";
+                        }
+                    }
+                    else if (chunk.type === "tool-result") {
+                        const messages = toolEvents.get(chunk.toolCallId);
+                        if (messages) {
+                            displayToolMessages(messages, terminal);
+                            toolEvents.delete(chunk.toolCallId);
+                        }
+                        else {
+                            logger.warn(`No tool events found for ${chunk.toolCallId}`);
+                        }
+                    }
+                    else {
+                        // Close thinking tags when moving from reasoning to any other chunk type
+                        if (lastType === "reasoning") {
+                            terminal.write(chalk.dim("\n</think>\n\n"));
+                        }
+                        // if there is accumulatedText, display it
+                        if (accumulatedText) {
+                            terminal.writeln(`${chalk.blue.bold("●")} Response:`);
+                            terminal.display(accumulatedText, true);
+                            terminal.lineBreak();
+                        }
+                        accumulatedText = "";
+                        lastType = null;
+                    }
+                }
+                // Ensure the final closing tag for reasoning is written if it was the last type
+                if (lastType === "reasoning") {
+                    terminal.write(chalk.gray("\n</think>\n\n"));
+                }
+                // if there is accumulatedText, display it
+                if (accumulatedText) {
+                    terminal.writeln(`${chalk.green.bold("●")} Response:`);
+                    terminal.display(accumulatedText, true);
+                    terminal.lineBreak();
+                }
+                terminal.lineBreak(); // Add a final newline for clarity
+                await result.consumeStream();
+            }
+            catch (e) {
+                if (isRecord(e) && isRecord(e["data"]) && "error" in e["data"]) {
+                    terminal.error(e["data"]["error"].message);
+                }
+                else {
+                    terminal.error(e.message.length > 100
+                        ? `${e.message.slice(0, 100)}...`
+                        : e.message);
+                }
+                terminal.lineBreak();
+                if (e instanceof Error) {
+                    logger.error(e);
+                }
+                else {
+                    logger.error(JSON.stringify(e, null, 2));
+                }
+            }
+        }
+    }
+    displayToolUse(result, terminal) {
+        const toolsCalled = [];
+        const toolColors = new Map();
+        const chalkColors = [
+            "red",
+            "green",
+            "yellow",
+            "blue",
+            "magenta",
+            "cyan",
+            "white",
+            "gray",
+            "redBright",
+            "greenBright",
+            "yellowBright",
+            "blueBright",
+            "magentaBright",
+            "cyanBright",
+            "whiteBright",
+            "blackBright",
+        ];
+        terminal.writeln(chalk.dim(`Steps: ${result.steps.length}`));
+        for (const step of result.steps) {
+            let currentToolCalls = [];
+            if (step.toolResults.length > 0) {
+                currentToolCalls = step.toolResults;
+            }
+            else if (step.toolCalls.length > 0) {
+                currentToolCalls = step.toolCalls;
+            }
+            for (const toolCallOrResult of currentToolCalls) {
+                const toolName = toolCallOrResult.toolName;
+                if (!toolColors.has(toolName)) {
+                    const availableColors = chalkColors.filter((color) => !Array.from(toolColors.values()).some((c) => c === chalk[color]));
+                    const color = availableColors.length > 0
+                        ? (availableColors[Math.floor(Math.random() * availableColors.length)] ?? "white")
+                        : "white";
+                    toolColors.set(toolName, chalk[color]);
+                }
+                toolsCalled.push(toolName);
+            }
+        }
+        if (toolsCalled.length > 0) {
+            terminal.writeln(chalk.dim("Tools:"));
+            for (const toolCalled of toolsCalled) {
+                const colorFn = toolColors.get(toolCalled) ?? chalk.white;
+                terminal.write(`${colorFn("██")} `);
+            }
+            terminal.lineBreak();
+            const uniqueTools = new Set(toolsCalled);
+            for (const [index, toolCalled] of Array.from(uniqueTools).entries()) {
+                const colorFn = toolColors.get(toolCalled) ?? chalk.white;
+                terminal.write(colorFn(toolCalled));
+                if (index < new Set(toolsCalled).size - 1) {
+                    terminal.write(" - ");
+                }
+            }
+            terminal.lineBreak();
+            terminal.lineBreak();
+        }
+    }
+}
+function displayToolMessages(messages, terminal) {
+    const isError = messages[messages.length - 1]?.event === "tool-error";
+    const indicator = isError ? chalk.red.bold("●") : chalk.blue.bold("●");
+    const initMessage = messages.find((m) => m.event === "tool-init")?.data ?? "Tool Execution";
+    terminal.write(`${indicator} `); // Write indicator without newline (sync)
+    terminal.display(initMessage); // Display initial message (async)
+    for (const msg of messages) {
+        switch (msg.event) {
+            case "tool-update":
+                _handleToolUpdateMessage(msg.data, terminal);
+                break;
+            case "tool-completion":
+                _handleToolCompletionMessage(msg.data, terminal);
+                break;
+            case "tool-error":
+                _handleToolErrorMessage(msg.data, terminal);
+                break;
+            // 'tool-init' is handled before the loop, so no case needed here.
+            default:
+                // Optional: Log an unexpected event type for debugging, or do nothing.
+                logger.debug(`Unhandled tool message event: ${msg.event}`);
+                break;
+        }
+    }
+    terminal.lineBreak();
+}
+// Helper function to handle tool update messages
+function _handleToolUpdateMessage(data, terminal) {
+    if (data.secondary && data.secondary.length > 0) {
+        const content = data.secondary.join("\n");
+        if (content.trim().length !== 0) {
+            terminal.display(`└── ${data.primary}`);
+            terminal.hr();
+            if (isMarkdown(content)) {
+                terminal.display(content, true);
+            }
+            else {
+                terminal.write(chalk.green(content));
+                terminal.lineBreak();
+            }
+            terminal.hr();
+        }
+    }
+    else {
+        terminal.display(`└── ${data.primary}`);
+    }
+}
+// Helper function to handle tool completion messages
+function _handleToolCompletionMessage(data, terminal) {
+    terminal.display(`└── ${data}`);
+}
+// Helper function to handle tool error messages
+function _handleToolErrorMessage(data, terminal) {
+    terminal.write("└── ");
+    terminal.error(data);
+}
+const toolCallRepair = (modelManager, terminal) => {
+    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null; // do not attempt to fix invalid tool names
+        }
+        terminal.warn(`Attempting to repair tool call: ${toolCall.toolName}.`);
+        terminal.lineBreak();
+        const tool = tools[toolCall.toolName];
+        try {
+            const { object: repairedArgs } = await generateObject({
+                model: modelManager.getModel("tool-repair"),
+                schema: tool.inputSchema,
+                prompt: [
+                    `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
+                    JSON.stringify(toolCall.input),
+                    "The tool accepts the following schema:",
+                    JSON.stringify(inputSchema(toolCall)),
+                    "Please fix the arguments.",
+                ].join("\n"),
+            });
+            return { ...toolCall, args: JSON.stringify(repairedArgs) };
+        }
+        catch (err) {
+            logger.error(err, `Failed to repair tool call: ${toolCall.toolName}.`);
+            return null;
+        }
+    };
+    return fn;
+};

package/dist/source/cli.d.ts

@@ -0,0 +1,19 @@
+import type { MessageHistory } from "./messages.ts";
+import type { ModelManager } from "./models/manager.js";
+import type { PromptManager } from "./prompts/manager.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+import type { TokenCounter } from "./token-utils.ts";
+interface CliOptions {
+    messageHistory: MessageHistory;
+    promptManager: PromptManager;
+    modelManager: ModelManager;
+    tokenTracker: TokenTracker;
+    config: Record<PropertyKey, unknown>;
+    tokenCounter: TokenCounter;
+}
+export declare class Cli {
+    private options;
+    constructor(options: CliOptions);
+    run(): Promise<void>;
+}
+export {};

package/dist/source/cli.js

@@ -0,0 +1,116 @@
+import { generateObject, generateText, NoSuchToolError, stepCountIs, } from "ai";
+import { logger } from "./logger.js";
+import { AiConfig } from "./models/ai-config.js";
+import { minSystemPrompt } from "./prompts.js";
+import { DeleteFileTool } from "./tools/delete-file.js";
+import { EditFileTool } from "./tools/edit-file.js";
+import { initCliTools } from "./tools/index.js";
+import { MoveFileTool } from "./tools/move-file.js";
+import { SaveFileTool } from "./tools/save-file.js";
+import { ThinkTool } from "./tools/think.js";
+export class Cli {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run() {
+        const { config, promptManager, modelManager, tokenTracker, messageHistory, tokenCounter, } = this.options;
+        logger.info(config, "Config:");
+        const abortController = new AbortController();
+        const { signal } = abortController;
+        const cb = () => {
+            abortController.abort();
+        };
+        // Handle Ctrl+C (SIGINT)
+        process.on("SIGINT", cb);
+        const langModel = modelManager.getModel("cli");
+        const modelConfig = modelManager.getModelMetadata("cli");
+        const userPrompt = promptManager.get();
+        const userMsg = promptManager.getUserMessage();
+        messageHistory.appendUserMessage(userMsg);
+        const finalSystemPrompt = await minSystemPrompt();
+        const aiConfig = new AiConfig({
+            modelMetadata: modelConfig,
+            prompt: userPrompt,
+        });
+        const maxTokens = aiConfig.getMaxTokens();
+        const tools = modelConfig.supportsToolCalling
+            ? await initCliTools({ tokenCounter })
+            : undefined;
+        try {
+            const result = await generateText({
+                model: langModel,
+                maxOutputTokens: maxTokens,
+                messages: [
+                    {
+                        role: "system",
+                        content: finalSystemPrompt,
+                        providerOptions: {
+                            anthropic: { cacheControl: { type: "ephemeral" } },
+                        },
+                    },
+                    ...messageHistory.get(),
+                ],
+                temperature: modelConfig.defaultTemperature,
+                stopWhen: stepCountIs(60),
+                maxRetries: 2,
+                providerOptions: aiConfig.getProviderOptions(),
+                tools,
+                // biome-ignore lint/style/useNamingConvention: third-party controlled
+                experimental_activeTools: [
+                    EditFileTool.name,
+                    SaveFileTool.name,
+                    MoveFileTool.name,
+                    DeleteFileTool.name,
+                    ThinkTool.name,
+                ],
+                // biome-ignore lint/style/useNamingConvention: third-party controlled
+                experimental_repairToolCall: modelConfig.supportsToolCalling
+                    ? toolCallRepair(modelManager)
+                    : undefined,
+                abortSignal: signal,
+            });
+            if (result.response.messages.length > 0) {
+                messageHistory.appendResponseMessages(result.response.messages);
+            }
+            // this tracks the usage of every step in the call to streamText. it's a cumulative usage.
+            tokenTracker.trackUsage("cli", result.usage);
+            process.stdout.end(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                logger.error(e);
+            }
+            else {
+                logger.error(JSON.stringify(e, null, 2));
+            }
+        }
+    }
+}
+const toolCallRepair = (modelManager) => {
+    const fn = async ({ toolCall, tools, inputSchema, error, }) => {
+        if (NoSuchToolError.isInstance(error)) {
+            return null; // do not attempt to fix invalid tool names
+        }
+        const tool = tools[toolCall.toolName];
+        try {
+            const { object: repairedArgs } = await generateObject({
+                model: modelManager.getModel("tool-repair"),
+                schema: tool.inputSchema,
+                prompt: [
+                    `The model tried to call the tool "${toolCall.toolName}" with the following arguments:`,
+                    JSON.stringify(toolCall.input),
+                    "The tool accepts the following schema:",
+                    JSON.stringify(inputSchema(toolCall)),
+                    "Please fix the arguments.",
+                ].join("\n"),
+            });
+            return { ...toolCall, args: JSON.stringify(repairedArgs) };
+        }
+        catch (err) {
+            logger.error(err, `Failed to repair tool call: ${toolCall.toolName}.`);
+            return null;
+        }
+    };
+    return fn;
+};

package/dist/source/commands/application-log-command.d.ts

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

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

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import { editor } from "@inquirer/prompts";
+import { config } from "../config.js";
+export const applicationLogCommand = ({ terminal, }) => {
+    return {
+        command: "/application-logs",
+        description: "Opens the application log file defined in acai.json in the editor.",
+        result: "continue",
+        getSubCommands: () => Promise.resolve([]),
+        execute: async () => {
+            let logFilePath;
+            try {
+                const projectConfig = await config.readProjectConfig();
+                logFilePath = projectConfig.logs?.path;
+                if (!logFilePath) {
+                    terminal.error("Application log path is not defined in .acai/acai.json under the 'logs.path' key.");
+                    return;
+                }
+                const content = await readFile(logFilePath, { encoding: "utf8" });
+                // Use the editor prompt to display the content (read-only)
+                await editor({
+                    message: `Viewing ${logFilePath}`,
+                    // Attempt to infer postfix from file extension, default otherwise
+                    postfix: logFilePath.includes(".")
+                        ? `.${logFilePath.split(".").pop()}`
+                        : ".log",
+                    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 for: ${logFilePath}`);
+            }
+            catch (error) {
+                if (logFilePath && error.code === "ENOENT") {
+                    terminal.error(`Application log file not found at: ${logFilePath}`);
+                }
+                else {
+                    terminal.error(`Error reading or displaying log file ${logFilePath ?? "specified in config"}: ${error}`);
+                }
+            }
+        },
+    };
+};

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

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

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

@@ -0,0 +1,12 @@
+export const clearCommand = ({ terminal }) => {
+    return {
+        command: "/clear",
+        description: "Clears the terminal screen.",
+        result: "continue", // Keep the REPL running
+        getSubCommands: () => Promise.resolve([]),
+        execute: () => {
+            terminal.clear();
+            return Promise.resolve();
+        },
+    };
+};

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

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