@travisennis/acai 0.0.1 → 0.0.3

package/dist/repl.js

@@ -8,7 +8,7 @@ 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 { getCurrentBranch, getDiffStat, getGitStatus, hasUncommittedChanges, inGitDirectory, } from "./tools/git-utils.js"; // Modified import
 import { initAgents, initTools } from "./tools/index.js";
 export class Repl {
     options;
@@ -39,16 +39,8 @@ export class Repl {
             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(await getProjectStatusLine());
             terminal.writeln(chalk.dim(langModel.modelId));
             terminal.displayProgressBar(currentContextWindow, modelConfig.contextWindow);
             if (!promptManager.isPending()) {
@@ -84,7 +76,8 @@ export class Repl {
             // flag to see if the user prompt has added context
             const hasAddedContext = promptManager.hasContext();
             if (hasAddedContext) {
-                terminal.info("Context will be added to prompt.");
+                const contextTokenCount = promptManager.getContextTokenCount();
+                terminal.info(`Context will be added to prompt. (${contextTokenCount} tokens)`);
                 terminal.lineBreak();
             }
             const userPrompt = promptManager.get();
@@ -152,23 +145,19 @@ export class Repl {
                         }
                         // 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)
+                        const inputTokens = isNumber(total.inputTokens)
                             ? total.inputTokens
                             : 0;
-                        const incomingTokens = isNumber(total.outputTokens)
+                        const outputTokens = isNumber(total.outputTokens)
                             ? total.outputTokens
                             : 0;
-                        const tokenSummary = `Tokens: ↑ ${outgoingTokens} ↓ ${incomingTokens}`;
+                        const tokenSummary = `Tokens: ↑ ${inputTokens} ↓ ${outputTokens}`;
                         terminal.writeln(chalk.dim(tokenSummary));
+                        const inputCost = modelConfig.costPerInputToken * inputTokens;
+                        const outputCost = modelConfig.costPerOutputToken * outputTokens;
+                        terminal.writeln(chalk.dim(`Cost: $${(inputCost + outputCost).toFixed(2)}`));
                         // Track aggregate usage across all steps when available
                         tokenTracker.trackUsage("repl", total);
                         // Derive current context window from final step usage
@@ -241,8 +230,8 @@ export class Repl {
                             terminal.write(chalk.dim("\n</think>\n\n"));
                         }
                         // if there is accumulatedText, display it
-                        if (accumulatedText) {
-                            terminal.writeln(`${chalk.blue.bold("●")} Response:`);
+                        if (accumulatedText.trim()) {
+                            terminal.writeln(`${chalk.blue.bold("● Response:")}`);
                             terminal.display(accumulatedText, true);
                             terminal.lineBreak();
                         }
@@ -255,8 +244,8 @@ export class Repl {
                     terminal.write(chalk.gray("\n</think>\n\n"));
                 }
                 // if there is accumulatedText, display it
-                if (accumulatedText) {
-                    terminal.writeln(`${chalk.green.bold("●")} Response:`);
+                if (accumulatedText.trim()) {
+                    terminal.writeln(`${chalk.green.bold("● Response:")}`);
                     terminal.display(accumulatedText, true);
                     terminal.lineBreak();
                 }
@@ -325,6 +314,7 @@ export class Repl {
             }
         }
         if (toolsCalled.length > 0) {
+            terminal.lineBreak();
             terminal.writeln(chalk.dim("Tools:"));
             for (const toolCalled of toolsCalled) {
                 const colorFn = toolColors.get(toolCalled) ?? chalk.white;
@@ -361,7 +351,9 @@ function displayToolMessages(messages, terminal) {
             case "tool-error":
                 _handleToolErrorMessage(msg.data, terminal);
                 break;
-            // 'tool-init' is handled before the loop, so no case needed here.
+            case "tool-init":
+                // 'tool-init' is handled before the loop, so nothing to do here.
+                break;
             default:
                 // Optional: Log an unexpected event type for debugging, or do nothing.
                 logger.debug(`Unhandled tool message event: ${msg.event}`);
@@ -429,3 +421,34 @@ const toolCallRepair = (modelManager, terminal) => {
     };
     return fn;
 };
+async function getProjectStatusLine() {
+    //
+    const currentDir = process.cwd().split("/").pop() || process.cwd();
+    const branch = await getCurrentBranch();
+    let gitStatus = "";
+    if (branch) {
+        const hasChanges = await hasUncommittedChanges();
+        const asterisk = hasChanges ? "*" : "";
+        gitStatus = ` ${chalk.gray(branch + asterisk)}`;
+    }
+    if (await inGitDirectory()) {
+        // Added check
+        const stats = await getDiffStat();
+        const fileChanges = await getGitStatus();
+        let fileStatus = "";
+        if (fileChanges.added)
+            fileStatus += ` +${fileChanges.added}`;
+        if (fileChanges.modified)
+            fileStatus += ` ~${fileChanges.modified}`;
+        if (fileChanges.deleted)
+            fileStatus += ` -${fileChanges.deleted}`;
+        if (fileChanges.untracked)
+            fileStatus += ` ?${fileChanges.untracked}`;
+        gitStatus +=
+            " " +
+                `${chalk.dim("[")}${chalk.yellow(fileStatus.trim())} ` +
+                `${chalk.green(`+${stats.insertions}`)} ` + // Insertions first (green)
+                `${chalk.red(`-${stats.deletions}`)}${chalk.dim("]")}`; // Deletions last (red)
+    }
+    return `${chalk.blue(currentDir)}${gitStatus}`;
+}

package/dist/terminal/formatting.d.ts

@@ -1,8 +1,3 @@
-/**
- * Terminal Formatting Utilities
- *
- * Provides functions for formatting and displaying text in the terminal.
- */
 /**
  * Clear the terminal screen
  */
@@ -34,4 +29,20 @@ export declare function getTerminalSize(): {
  * Word wrap text to the specified width
  */
 export declare function wordWrap(text: string, width: number): string;
+export declare const ESC = "\u001B[";
+export declare const OSC = "\u001B]";
+export declare const BEL = "\u0007";
+export declare const SEP = ";";
 export declare const link: (text: string, url: string) => string;
+export declare const image: (data: string | Buffer, options?: {
+    width?: number | string;
+    height?: number | string;
+    preserveAspectRatio?: boolean;
+}) => string;
+export declare function ansiRegex({ onlyFirst }?: {
+    onlyFirst?: boolean | undefined;
+}): RegExp;
+/**
+ * Strip ANSI escape sequences from a string
+ */
+export declare function stripAnsi(s: string): string;

package/dist/terminal/formatting.js

@@ -3,7 +3,7 @@
  *
  * Provides functions for formatting and displaying text in the terminal.
  */
-import chalk from "chalk";
+import { supportsHyperlinks } from "./supports-hyperlinks.js";
 /**
  * Clear the terminal screen
  */
@@ -99,8 +99,42 @@ function wrapLine(line, width) {
     }
     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(""));
+export const ESC = "\u001B[";
+export const OSC = "\u001B]";
+export const BEL = "\u0007";
+export const SEP = ";";
+export const link = (text, url) => {
+    if (supportsHyperlinks.stdout) {
+        return [OSC, "8", SEP, SEP, url, BEL, text, OSC, "8", SEP, SEP, BEL].join("");
+    }
+    return `[${text}](${url})`;
+};
+export const image = (data, options = {}) => {
+    let returnValue = `${OSC}1337;File=inline=1`;
+    if (options.width) {
+        returnValue += `;width=${options.width}`;
+    }
+    if (options.height) {
+        returnValue += `;height=${options.height}`;
+    }
+    if (options.preserveAspectRatio === false) {
+        returnValue += ";preserveAspectRatio=0";
+    }
+    return `${returnValue}:${Buffer.from(data).toString("base64")}${BEL}`;
+};
+export function ansiRegex({ onlyFirst = false } = {}) {
+    // Valid string terminator sequences are BEL, ESC\, and 0x9c
+    const st = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+    const pattern = [
+        `[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${st})`,
+        "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))",
+    ].join("|");
+    return new RegExp(pattern, onlyFirst ? undefined : "g");
+}
+/**
+ * Strip ANSI escape sequences from a string
+ */
+export function stripAnsi(s) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: need to detect ansi control characters
+    return s.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}

package/dist/terminal/index.d.ts

@@ -75,7 +75,7 @@ export declare class Terminal {
     /**
      * Display a table of data
      */
-    table(data: [string, string | number][], options?: {
+    table(data: (string | number)[][], options?: {
         header?: string[];
         colWidths?: number[];
     }): void;

package/dist/terminal/index.js

@@ -10,7 +10,7 @@ import ora from "ora";
 import wrapAnsi from "wrap-ansi";
 import { logger } from "../logger.js";
 import { getPackageVersion } from "../version.js";
-import { clearTerminal, getTerminalSize, setTerminalTitle, link as terminalLink, } from "./formatting.js";
+import { clearTerminal, getTerminalSize, setTerminalTitle, stripAnsi, link as terminalLink, } from "./formatting.js";
 import { applyMarkdown } from "./markdown.js";
 /**
  * Initialize the terminal interface
@@ -214,9 +214,6 @@ export class Terminal {
         const cols = this.terminalWidth > 0 ? this.terminalWidth : 80;
         const width = Math.max(4, cols - 4);
         // Helper to strip ANSI sequences for accurate visible-width calculation
-        const stripAnsi = (s) => 
-        // biome-ignore lint/suspicious/noControlCharactersInRegex: need to detect ansi control characters
-        s.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
         const paddedHeader = ` ${header} `;
         const headerVisibleLen = stripAnsi(paddedHeader).length;
         const headerStartPos = 1;
@@ -249,27 +246,68 @@ export class Terminal {
      * Create a clickable link in the terminal if supported
      */
     link(text, url) {
-        return terminalLink(text, url);
+        return chalk.underline.blue(terminalLink(text, url));
     }
     /**
      * Display a table of data
      */
     table(data, options = {}) {
         const { header, colWidths } = options;
+        // Determine number of columns from data or header
+        let colCount = header?.length;
+        if (colCount === undefined) {
+            colCount = data.length > 0 && data[0] ? data[0].length : 1;
+        }
         // Calculate column widths based on terminal width
         const padding = 5; // Account for table borders and padding
-        const availableWidth = Math.max(10, this.terminalWidth - padding);
-        const colCount = header?.length ?? 1;
-        const width = Math.max(10, Math.floor(availableWidth / Math.max(1, colCount)));
-        const computedColWidths = colWidths
-            ? colWidths.map((percent) => Math.max(10, Math.floor((percent / 100) * availableWidth)))
-            : new Array(colCount).fill(width);
+        const availableWidth = Math.max(20, this.terminalWidth - padding);
+        let computedColWidths;
+        if (colWidths && colWidths.length === colCount) {
+            // Use provided percentages
+            computedColWidths = colWidths.map((percent) => Math.max(10, Math.floor((percent / 100) * availableWidth)));
+        }
+        else {
+            // Distribute width evenly with minimum width per column
+            const minColWidth = 15;
+            const maxColsThatFit = Math.floor(availableWidth / minColWidth);
+            const actualColCount = Math.min(colCount, maxColsThatFit);
+            if (actualColCount === 1) {
+                computedColWidths = [availableWidth];
+            }
+            else {
+                // Calculate base width and distribute remaining pixels
+                const baseWidth = Math.floor(availableWidth / actualColCount);
+                const remainder = availableWidth % actualColCount;
+                computedColWidths = Array(actualColCount).fill(baseWidth);
+                // Distribute remainder pixels to first few columns
+                for (let i = 0; i < remainder && i < actualColCount; i++) {
+                    computedColWidths[i] = (computedColWidths[i] || 0) + 1;
+                }
+            }
+            // If we have fewer computed widths than columns, extend the array
+            while (computedColWidths.length < colCount) {
+                computedColWidths.push(minColWidth);
+            }
+        }
         const table = new Table({
             head: header,
             colWidths: computedColWidths,
-            wordWrap: true, // Enable word wrapping for the description column
+            wordWrap: true,
+            wrapOnWordBoundary: true,
+        });
+        // Ensure all data rows have the same number of columns
+        const normalizedData = data.map((row) => {
+            if (row.length < colCount) {
+                // Pad with empty strings if row has fewer columns
+                return [...row, ...Array(colCount - row.length).fill("")];
+            }
+            if (row.length > colCount) {
+                // Truncate if row has more columns
+                return row.slice(0, colCount);
+            }
+            return row;
         });
-        table.push(...data);
+        table.push(...normalizedData);
         this.writeln(table.toString());
     }
     /**
@@ -400,7 +438,9 @@ export class Terminal {
         const percentage = total === 0 ? 1 : current / total;
         const filledWidth = Math.max(0, Math.min(progressBarMaxWidth, Math.floor(percentage * progressBarMaxWidth)));
         const emptyWidth = Math.max(0, progressBarMaxWidth - filledWidth);
-        const a = chalk.yellow("─"); //"█"
+        const a = filledWidth / progressBarMaxWidth > 0.5
+            ? chalk.red("─")
+            : chalk.yellow("─"); //"█"
         const b = chalk.gray("─"); // "░"
         const filledBar = a.repeat(filledWidth);
         const emptyBar = b.repeat(emptyWidth);

package/dist/terminal/markdown.js

@@ -105,7 +105,6 @@ function format(token, listDepth = 0, orderedListNumber = null, parent = null) {
             return chalk.strikethrough(token.text);
         }
         default:
-            console.log(token.type);
             return "";
     }
 }

package/dist/terminal/supports-color.d.ts

@@ -0,0 +1,16 @@
+interface ColorSupport {
+    level: number;
+    hasBasic: boolean;
+    has256: boolean;
+    has16m: boolean;
+}
+export declare function createSupportsColor(stream: {
+    isTty?: boolean;
+}, options?: {
+    streamIsTty?: boolean;
+}): ColorSupport | false;
+export declare const supportsColor: {
+    stdout: false | ColorSupport;
+    stderr: false | ColorSupport;
+};
+export {};

package/dist/terminal/supports-color.js

@@ -0,0 +1,121 @@
+// based on https://raw.githubusercontent.com/chalk/supports-color/refs/heads/main/index.js
+import os from "node:os";
+import process from "node:process";
+import tty from "node:tty";
+const { env } = process;
+function envForceColor() {
+    if (!("FORCE_COLOR" in env)) {
+        return;
+    }
+    if (env["FORCE_COLOR"] === "true") {
+        return 1;
+    }
+    if (env["FORCE_COLOR"] === "false") {
+        return 0;
+    }
+    if (env["FORCE_COLOR"] && env["FORCE_COLOR"].length === 0) {
+        return 1;
+    }
+    const level = Math.min(Number.parseInt(env["FORCE_COLOR"] || "0", 10), 3);
+    if (![0, 1, 2, 3].includes(level)) {
+        return;
+    }
+    return level;
+}
+function translateLevel(level) {
+    if (level === 0) {
+        return false;
+    }
+    return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3,
+    };
+}
+function _supportsColor(haveStream, options = {}) {
+    const noFlagForceColor = envForceColor();
+    const forceColor = noFlagForceColor;
+    if (forceColor === 0) {
+        return 0;
+    }
+    // Check for Azure DevOps pipelines.
+    // Has to be above the `!streamIsTTY` check.
+    if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+        return 1;
+    }
+    if (haveStream && !options.streamIsTty && forceColor === undefined) {
+        return 0;
+    }
+    const min = forceColor || 0;
+    if (env["TERM"] === "dumb") {
+        return min;
+    }
+    if (process.platform === "win32") {
+        // Windows 10 build 10586 is the first Windows release that supports 256 colors.
+        // Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10_586) {
+            return Number(osRelease[2]) >= 14_931 ? 3 : 2;
+        }
+        return 1;
+    }
+    if ("CI" in env) {
+        if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+            return 3;
+        }
+        if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) ||
+            env["CI_NAME"] === "codeship") {
+            return 1;
+        }
+        return min;
+    }
+    if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env["TEAMCITY_VERSION"] || "")
+            ? 1
+            : 0;
+    }
+    if (env["COLORTERM"] === "truecolor") {
+        return 3;
+    }
+    if (env["TERM"] === "xterm-kitty") {
+        return 3;
+    }
+    if (env["TERM"] === "xterm-ghostty") {
+        return 3;
+    }
+    if ("TERM_PROGRAM" in env) {
+        const termProgramVersion = String(env["TERM_PROGRAM_VERSION"] || "0");
+        const version = Number.parseInt(termProgramVersion.split(".")[0] ?? "0", 10);
+        switch (env["TERM_PROGRAM"]) {
+            case "iTerm.app": {
+                return version >= 3 ? 3 : 2;
+            }
+            case "Apple_Terminal": {
+                return 2;
+            }
+            // No default
+        }
+    }
+    if (/-256(color)?$/i.test(env["TERM"] || "")) {
+        return 2;
+    }
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env["TERM"] || "")) {
+        return 1;
+    }
+    if ("COLORTERM" in env) {
+        return 1;
+    }
+    return min;
+}
+export function createSupportsColor(stream, options = {}) {
+    const level = _supportsColor(true, {
+        streamIsTty: stream?.isTty,
+        ...options,
+    });
+    return translateLevel(level);
+}
+export const supportsColor = {
+    stdout: createSupportsColor({ isTty: tty.isatty(1) }),
+    stderr: createSupportsColor({ isTty: tty.isatty(2) }),
+};

package/dist/terminal/supports-hyperlinks.d.ts

@@ -0,0 +1,7 @@
+export declare function createSupportsHyperlinks(stream: {
+    isTty?: boolean;
+}): boolean;
+export declare const supportsHyperlinks: {
+    stdout: boolean;
+    stderr: boolean;
+};

package/dist/terminal/supports-hyperlinks.js

@@ -0,0 +1,98 @@
+// based on https://raw.githubusercontent.com/chalk/supports-hyperlinks/refs/heads/main/index.js
+import process from "node:process";
+import { createSupportsColor } from "./supports-color.js";
+function parseVersion(versionString = "") {
+    if (/^\d{3,4}$/.test(versionString)) {
+        // Env var doesn't always use dots. example: 4601 => 46.1.0
+        const match = /(\d{1,2})(\d{2})/.exec(versionString) ?? [];
+        return {
+            major: 0,
+            minor: Number.parseInt(match[1] ?? "0", 10),
+            patch: Number.parseInt(match[2] ?? "0", 10),
+        };
+    }
+    const versions = (versionString ?? "")
+        .split(".")
+        .map((n) => Number.parseInt(n, 10));
+    return {
+        major: versions[0] ?? 0,
+        minor: versions[1] ?? 0,
+        patch: versions[2] ?? 0,
+    };
+}
+export function createSupportsHyperlinks(stream) {
+    const { CI, CURSOR_TRACE_ID, FORCE_HYPERLINK, NETLIFY, TEAMCITY_VERSION, TERM_PROGRAM, TERM_PROGRAM_VERSION, VTE_VERSION, TERM, } = process.env;
+    if (FORCE_HYPERLINK) {
+        return !(FORCE_HYPERLINK.length > 0 && Number.parseInt(FORCE_HYPERLINK, 10) === 0);
+    }
+    // Netlify does not run a TTY, it does not need `supportsColor` check
+    if (NETLIFY) {
+        return true;
+    }
+    // If they specify no colors, they probably don't want hyperlinks.
+    if (!createSupportsColor(stream)) {
+        return false;
+    }
+    if (stream && !stream.isTty) {
+        return false;
+    }
+    // Windows Terminal
+    if ("WT_SESSION" in process.env) {
+        return true;
+    }
+    if (process.platform === "win32") {
+        return false;
+    }
+    if (CI) {
+        return false;
+    }
+    if (TEAMCITY_VERSION) {
+        return false;
+    }
+    if (TERM_PROGRAM) {
+        const version = parseVersion(TERM_PROGRAM_VERSION);
+        switch (TERM_PROGRAM) {
+            case "iTerm.app": {
+                if (version.major === 3) {
+                    return version.minor >= 1;
+                }
+                return version.major > 3;
+            }
+            case "WezTerm": {
+                return version.major >= 20_200_620;
+            }
+            case "vscode": {
+                // Cursor forked VS Code and supports hyperlinks in 0.x.x
+                if (CURSOR_TRACE_ID) {
+                    return true;
+                }
+                // eslint-disable-next-line no-mixed-operators
+                return (version.major > 1 || (version.major === 1 && version.minor >= 72));
+            }
+            case "ghostty": {
+                return true;
+            }
+            // No default
+        }
+    }
+    if (VTE_VERSION) {
+        // 0.50.0 was supposed to support hyperlinks, but throws a segfault
+        if (VTE_VERSION === "0.50.0") {
+            return false;
+        }
+        const version = parseVersion(VTE_VERSION);
+        return version.major > 0 || version.minor >= 50;
+    }
+    switch (TERM) {
+        case "alacritty": {
+            // Support added in v0.11 (2022-10-13)
+            return true;
+        }
+        // No default
+    }
+    return false;
+}
+export const supportsHyperlinks = {
+    stdout: createSupportsHyperlinks({ isTty: process.stdout.isTTY }),
+    stderr: createSupportsHyperlinks({ isTty: process.stderr.isTTY }),
+};