@travisennis/acai 0.0.1

package/dist/source/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/terminal/formatting.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Terminal Formatting Utilities
+ *
+ * Provides functions for formatting and displaying text in the terminal.
+ */
+/**
+ * Clear the terminal screen
+ */
+export declare function clearScreen(): void;
+/**
+ * Clear the terminal screen including scrollback buffer
+ *
+ * Unlike clearScreen, this function:
+ * 1. Clears the entire screen (\x1b[2J)
+ * 2. Clears the scrollback buffer (\x1b[3J)
+ * 3. Moves cursor to home position (\x1b[H)
+ * 4. Returns a Promise that resolves when the write operation completes
+ *
+ * @returns Promise that resolves when the terminal has been cleared
+ */
+export declare function clearTerminal(): Promise<void>;
+/**
+ * Sets the terminal title
+ */
+export declare function setTerminalTitle(title: string): void;
+/**
+ * Get the terminal size (rows and columns)
+ */
+export declare function getTerminalSize(): {
+    rows: number;
+    columns: number;
+};
+/**
+ * Word wrap text to the specified width
+ */
+export declare function wordWrap(text: string, width: number): string;
+export declare const link: (text: string, url: string) => string;

package/dist/source/terminal/formatting.js

@@ -0,0 +1,106 @@
+/**
+ * Terminal Formatting Utilities
+ *
+ * Provides functions for formatting and displaying text in the terminal.
+ */
+import chalk from "chalk";
+/**
+ * Clear the terminal screen
+ */
+export function clearScreen() {
+    // Clear screen and move cursor to top-left
+    process.stdout.write("\x1b[2J\x1b[0f");
+}
+/**
+ * Clear the terminal screen including scrollback buffer
+ *
+ * Unlike clearScreen, this function:
+ * 1. Clears the entire screen (\x1b[2J)
+ * 2. Clears the scrollback buffer (\x1b[3J)
+ * 3. Moves cursor to home position (\x1b[H)
+ * 4. Returns a Promise that resolves when the write operation completes
+ *
+ * @returns Promise that resolves when the terminal has been cleared
+ */
+export function clearTerminal() {
+    return new Promise((resolve) => {
+        process.stdout.write("\x1b[2J\x1b[3J\x1b[H", () => {
+            resolve();
+        });
+    });
+}
+/**
+ * Sets the terminal title
+ */
+export function setTerminalTitle(title) {
+    if (process.platform === "win32") {
+        process.title = title ? `✳✳ ${title}` : title;
+    }
+    else {
+        process.stdout.write(`\x1b]0;${title ? `✳✳ ${title}` : ""}\x07`);
+    }
+}
+/**
+ * Get the terminal size (rows and columns)
+ */
+export function getTerminalSize() {
+    // Default to a reasonable size if we can't determine the actual size
+    const defaultSize = { rows: 24, columns: 80 };
+    try {
+        if (process.stdout.isTTY) {
+            return {
+                rows: process.stdout.rows || defaultSize.rows,
+                columns: process.stdout.columns || defaultSize.columns,
+            };
+        }
+    }
+    catch (_error) {
+        // Ignore errors
+    }
+    return defaultSize;
+}
+/**
+ * Word wrap text to the specified width
+ */
+export function wordWrap(text, width) {
+    const lines = text.split("\n");
+    return lines.map((line) => wrapLine(line, width)).join("\n");
+}
+function wrapLine(line, width) {
+    // If the line is a code block or already shorter than the width, leave it as is
+    if (line.trim().startsWith("┃") || line.length <= width) {
+        return line;
+    }
+    // Word wrap the line
+    const words = line.split(" ");
+    const wrappedLines = [];
+    let currentLine = "";
+    for (const word of words) {
+        // If adding this word would exceed the width
+        if (currentLine.length + word.length + 1 > width) {
+            // Add the current line to wrapped lines if it's not empty
+            if (currentLine) {
+                wrappedLines.push(currentLine);
+                currentLine = word;
+            }
+            else {
+                // If the current line is empty, it means the word itself is longer than the width
+                wrappedLines.push(word);
+            }
+        }
+        else {
+            // Add the word to the current line
+            currentLine = currentLine ? `${currentLine} ${word}` : word;
+        }
+    }
+    // Add the last line if it's not empty
+    if (currentLine) {
+        wrappedLines.push(currentLine);
+    }
+    return wrappedLines.join("\n");
+}
+// const ESC = "\u001B[";
+const OSC = "\u001B]";
+const BEL = "\u0007";
+const SEP = ";";
+export const link = (text, url) => chalk.underline.blue([OSC, "8", SEP, SEP, url, BEL, text, OSC, "8", SEP, SEP, BEL].join(""));

package/dist/source/terminal/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Terminal Interface Module
+ *
+ * Provides a user interface for interacting with Claude Code in the terminal.
+ * Handles input/output, formatting, and display.
+ */
+import { type ChalkInstance } from "chalk";
+import type { SpinnerInstance, TerminalConfig } from "./types.ts";
+/**
+ * Initialize the terminal interface
+ */
+export declare function initTerminal(config?: Partial<TerminalConfig>): Terminal;
+/**
+ * Terminal class for handling user interaction
+ */
+export declare class Terminal {
+    private config;
+    private activeSpinners;
+    private terminalWidth;
+    private terminalHeight;
+    private isInteractive;
+    constructor(config: TerminalConfig);
+    /**
+     * Detect terminal capabilities
+     */
+    detectCapabilities(): void;
+    setTitle(title: string): void;
+    getLogo(): string;
+    /**
+     * Display the welcome message
+     */
+    displayWelcome(): void;
+    /**
+     * Clear the terminal screen
+     */
+    clear(): void;
+    /**
+     * Display formatted content
+     */
+    display(content: string, wrap?: boolean): void;
+    /**
+     * Display a message with emphasis
+     */
+    emphasize(message: string): void;
+    /**
+     * Display an informational message
+     */
+    info(message: string): void;
+    /**
+     * Display a success message
+     */
+    success(message: string): void;
+    /**
+     * Display a warning message
+     */
+    warn(message: string): void;
+    /**
+     * Display an error message
+     */
+    error(message: string): void;
+    /**
+     * Emits an alert.
+     */
+    alert(): void;
+    write(input: string): void;
+    writeln(input: string): void;
+    lineBreak(): void;
+    header(header: string, chalkFn?: ChalkInstance): void;
+    box(header: string, content: string): Promise<void>;
+    hr(chalkFn?: ChalkInstance): void;
+    /**
+     * Create a clickable link in the terminal if supported
+     */
+    link(text: string, url: string): string;
+    /**
+     * Display a table of data
+     */
+    table(data: [string, string | number][], options?: {
+        header?: string[];
+        colWidths?: number[];
+    }): void;
+    /**
+     * Create a spinner for showing progress
+     */
+    spinner(text: string, id?: string): SpinnerInstance;
+    /**
+     * Displays a horizontal progress bar in the console.
+     * @param current The current value.
+     * @param total The target value.
+     */
+    displayProgressBar(current: number, total: number): void;
+    private formatMarkdown;
+}
+export * from "./types.ts";