@travisennis/acai 0.0.3 → 0.0.5

package/dist/terminal/wrap-ansi.js

@@ -0,0 +1,190 @@
+import { ansiStyles } from "./ansi-styles.js";
+import stringWidth from "./string-width.js";
+import stripAnsi from "./strip-ansi.js";
+const ESCAPES = new Set(["\\u001B", "\\u009B"]);
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = "\\u0007";
+const ANSI_CSI = "[";
+const ANSI_OSC = "]";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+const wrapAnsiCode = (code) => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url) => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+// Calculate the length of words split on ' ', ignoring
+// the extra characters added by ansi escape codes
+const wordLengths = (string) => string.split(" ").map((character) => stringWidth(character));
+// Wrap a long word across multiple rows
+// Ansi escape codes do not count towards length
+const wrapWord = (rows, word, columns) => {
+    const characters = [...word];
+    let isInsideEscape = false;
+    let isInsideLinkEscape = false;
+    let visible = stringWidth(stripAnsi(rows.at(-1) ?? ""));
+    for (const [index, character] of characters.entries()) {
+        const characterLength = stringWidth(character);
+        if (visible + characterLength <= columns) {
+            rows[rows.length - 1] += character;
+        }
+        else {
+            rows.push(character);
+            visible = 0;
+        }
+        if (ESCAPES.has(character)) {
+            isInsideEscape = true;
+            const ansiEscapeLinkCandidate = characters
+                .slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length)
+                .join("");
+            isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+        }
+        if (isInsideEscape) {
+            if (isInsideLinkEscape) {
+                if (character === ANSI_ESCAPE_BELL) {
+                    isInsideEscape = false;
+                    isInsideLinkEscape = false;
+                }
+            }
+            else if (character === ANSI_SGR_TERMINATOR) {
+                isInsideEscape = false;
+            }
+            continue;
+        }
+        visible += characterLength;
+        if (visible === columns && index < characters.length - 1) {
+            rows.push("");
+            visible = 0;
+        }
+    }
+    // It's possible that the last row we copy over is only
+    // ansi escape characters, handle this edge-case
+    const lastRow = rows.at(-1);
+    if (!visible && lastRow && lastRow.length > 0 && rows.length > 1) {
+        const poppedRow = rows.pop();
+        if (poppedRow) {
+            rows[rows.length - 1] += poppedRow;
+        }
+    }
+};
+// Trims spaces from a string ignoring invisible sequences
+const stringVisibleTrimSpacesRight = (string) => {
+    const words = string.split(" ");
+    let last = words.length;
+    while (last > 0) {
+        if (stringWidth(words[last - 1]) > 0) {
+            break;
+        }
+        last--;
+    }
+    if (last === words.length) {
+        return string;
+    }
+    return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode.
+//
+// 'hard' will never allow a string to take up more than columns characters.
+//
+// 'soft' allows long words to expand past the column length.
+const exec = (string, columns, options = {}) => {
+    if (options.trim !== false && string.trim() === "") {
+        return "";
+    }
+    let returnValue = "";
+    let escapeCode;
+    let escapeUrl;
+    const lengths = wordLengths(string);
+    let rows = [""];
+    for (const [index, word] of string.split(" ").entries()) {
+        if (options.trim !== false) {
+            rows[rows.length - 1] = rows.at(-1)?.trimStart() ?? "";
+        }
+        let rowLength = stringWidth(rows.at(-1) ?? "");
+        if (index !== 0) {
+            if (rowLength >= columns &&
+                (options.wordWrap === false || options.trim === false)) {
+                // If we start with a new word but the current row length equals the length of the columns, add a new row
+                rows.push("");
+                rowLength = 0;
+            }
+            if (rowLength > 0 || options.trim === false) {
+                rows[rows.length - 1] += " ";
+                rowLength++;
+            }
+        }
+        // In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
+        if (options.hard && lengths[index] > columns) {
+            const remainingColumns = columns - rowLength;
+            const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+            const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+            if (breaksStartingNextLine < breaksStartingThisLine) {
+                rows.push("");
+            }
+            wrapWord(rows, word, columns);
+            continue;
+        }
+        if (rowLength + lengths[index] > columns &&
+            rowLength > 0 &&
+            lengths[index] > 0) {
+            if (options.wordWrap === false && rowLength < columns) {
+                wrapWord(rows, word, columns);
+                continue;
+            }
+            rows.push("");
+        }
+        if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+            wrapWord(rows, word, columns);
+            continue;
+        }
+        rows[rows.length - 1] += word;
+    }
+    if (options.trim !== false) {
+        rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+    }
+    const preString = rows.join("\n");
+    const pre = [...preString];
+    // We need to keep a separate index as `String#slice()` works on Unicode code units, while `pre` is an array of codepoints.
+    let preStringIndex = 0;
+    for (const [index, character] of pre.entries()) {
+        returnValue += character;
+        if (ESCAPES.has(character)) {
+            const match = new RegExp(`(?:\\\\${ANSI_CSI}(?<code>\\d+)m|\\\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(preString.slice(preStringIndex));
+            if (match?.groups) {
+                const { groups } = match;
+                if (groups["code"] !== undefined) {
+                    const code = Number.parseFloat(groups["code"]);
+                    escapeCode = code === END_CODE ? undefined : code;
+                }
+                else if (groups["uri"] !== undefined) {
+                    escapeUrl = groups["uri"].length === 0 ? undefined : groups["uri"];
+                }
+            }
+        }
+        const code = ansiStyles["codes"].get(Number(escapeCode));
+        if (pre[index + 1] === "\n") {
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink("");
+            }
+            if (escapeCode && code) {
+                returnValue += wrapAnsiCode(code);
+            }
+        }
+        else if (character === "\n") {
+            if (escapeCode && code) {
+                returnValue += wrapAnsiCode(escapeCode);
+            }
+            if (escapeUrl) {
+                returnValue += wrapAnsiHyperlink(escapeUrl);
+            }
+        }
+        preStringIndex += character.length;
+    }
+    return returnValue;
+};
+// For each newline, invoke the method separately
+export default function wrapAnsi(string, columns, options) {
+    return String(string)
+        .normalize()
+        .replaceAll("\r\n", "\n")
+        .split("\n")
+        .map((line) => exec(line, columns, options))
+        .join("\n");
+}

package/dist/{token-utils.d.ts → tokens/counter.d.ts}

@@ -5,3 +5,4 @@ export declare class TokenCounter {
     count(input: string): number;
     free(): void;
 }
+//# sourceMappingURL=counter.d.ts.map

package/dist/tokens/counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"counter.d.ts","sourceRoot":"","sources":["../../source/tokens/counter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAElE,qBAAa,YAAY;IACvB,OAAO,CAAC,gBAAgB,CAAwC;gBAEpD,KAAK,GAAE,aAAmC;IAItD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAI5B,IAAI;CAGL"}

package/dist/{token-utils.js → tokens/counter.js}

@@ -1,7 +1,7 @@
 import { encoding_for_model } from "tiktoken";
 export class TokenCounter {
     tiktokenEncoding;
-    constructor(model = "chatgpt-4o-latest") {
+    constructor(model = "gpt-5-chat-latest") {
         this.tiktokenEncoding = encoding_for_model(model);
     }
     count(input) {

package/dist/tokens/manage-output.d.ts

@@ -0,0 +1,34 @@
+import type { TokenCounter } from "./counter.ts";
+/**
+ * Interface for options when managing output
+ */
+interface ManageOutputOptions {
+    tokenCounter: TokenCounter;
+    threshold?: number;
+    truncate?: boolean;
+}
+/**
+ * Interface for the result of managing output
+ */
+interface TruncatedOutput {
+    content: string;
+    tokenCount: number;
+    truncated: true;
+    warning: string;
+}
+interface Output {
+    content: string;
+    tokenCount: number;
+    truncated: false;
+    warning?: string;
+}
+type ManagedOutput = Output | TruncatedOutput;
+/**
+ * Manages output by counting tokens and optionally truncating if over threshold.
+ * @param input - The input string to manage
+ * @param options - Configuration for management
+ * @returns Managed output details
+ */
+export declare function manageOutput(input: string, options: ManageOutputOptions): ManagedOutput;
+export {};
+//# sourceMappingURL=manage-output.d.ts.map

package/dist/tokens/manage-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage-output.d.ts","sourceRoot":"","sources":["../../source/tokens/manage-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,UAAU,mBAAmB;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,UAAU,MAAM;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,KAAK,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,KAAK,aAAa,GAAG,MAAM,GAAG,eAAe,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,mBAAmB,GAC3B,aAAa,CA2Cf"}

package/dist/tokens/manage-output.js

@@ -0,0 +1,44 @@
+/**
+ * Manages output by counting tokens and optionally truncating if over threshold.
+ * @param input - The input string to manage
+ * @param options - Configuration for management
+ * @returns Managed output details
+ */
+export function manageOutput(input, options) {
+    const { threshold = 8000, truncate = true } = options;
+    if (!input) {
+        return { content: input, tokenCount: 0, truncated: false };
+    }
+    let tokenCount;
+    try {
+        tokenCount = options.tokenCounter.count(input);
+    }
+    catch (error) {
+        console.warn(`Token counting failed: ${error}. Using fallback.`);
+        // Fallback: Rough estimate (4 chars ~1 token)
+        tokenCount = Math.ceil(input.length / 4);
+    }
+    if (tokenCount <= threshold) {
+        return { content: input, tokenCount, truncated: false };
+    }
+    const _exceededBy = tokenCount - threshold;
+    let truncatedContent = input;
+    let truncated = false;
+    if (truncate) {
+        // Simple truncation: Cut to approx threshold tokens, add ellipsis
+        // For better UX, could be smarter (e.g., by lines for grep, preserve JSON)
+        // But keep general for now
+        const targetLength = threshold * 4; // Rough char estimate
+        truncatedContent = `${input.slice(0, targetLength)}\n\n[Output truncated at ~${threshold} tokens (${_exceededBy} tokens omitted)]`;
+        truncated = true;
+    }
+    const warning = truncated
+        ? `Warning: Output exceeds token threshold (${threshold}). Tokens: ${tokenCount}. ${truncate ? "Truncated." : "Full output returned—consider summarizing."}`
+        : undefined;
+    return {
+        content: truncatedContent,
+        tokenCount,
+        truncated,
+        warning,
+    };
+}

package/dist/{token-tracker.d.ts → tokens/tracker.d.ts}

@@ -12,3 +12,4 @@ export declare class TokenTracker extends EventEmitter<TokenTrackerEvents> {
     printSummary(): void;
 }
 export {};
+//# sourceMappingURL=tracker.d.ts.map

package/dist/tokens/tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../../source/tokens/tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,IAAI,CAAC;AAO7C,UAAU,kBAAkB;IAC1B,KAAK,EAAE,CAAC,kBAAkB,CAAC,CAAC;CAC7B;AAED,qBAAa,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IAChE,OAAO,CAAC,MAAM,CAAoB;IAElC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,SAAS;IAQ9D,aAAa,IAAI,kBAAkB;IAcnC,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAoB9C,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAY3C,YAAY;CAOb"}

package/dist/tool-executor.d.ts

@@ -0,0 +1,28 @@
+interface AskContext {
+    toolName: string;
+    toolCallId: string;
+    message: string;
+    choices: {
+        accept: string;
+        acceptAll: string;
+        reject: string;
+    };
+}
+export type AskResponse = {
+    result: "accept" | "accept-all";
+    reason?: string;
+} | {
+    result: "reject";
+    reason: string;
+};
+export declare class ToolExecutor {
+    private autoAcceptAll;
+    private autoAcceptMap;
+    constructor(autoAcceptAll: boolean);
+    autoAccept(toolName: string): boolean;
+    ask(ctx: AskContext, { abortSignal }: {
+        abortSignal?: AbortSignal;
+    }): Promise<AskResponse>;
+}
+export {};
+//# sourceMappingURL=tool-executor.d.ts.map

package/dist/tool-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-executor.d.ts","sourceRoot":"","sources":["../source/tool-executor.ts"],"names":[],"mappings":"AAIA,UAAU,UAAU;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE;QACP,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED,MAAM,MAAM,WAAW,GACnB;IAAE,MAAM,EAAE,QAAQ,GAAG,YAAY,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,qBAAa,YAAY;IACvB,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,aAAa,CAA8B;gBAEvC,aAAa,EAAE,OAAO;IAIlC,UAAU,CAAC,QAAQ,EAAE,MAAM;IAIrB,GAAG,CACP,GAAG,EAAE,UAAU,EACf,EAAE,WAAW,EAAE,EAAE;QAAE,WAAW,CAAC,EAAE,WAAW,CAAA;KAAE,GAC7C,OAAO,CAAC,WAAW,CAAC;CAgExB"}

package/dist/tool-executor.js

@@ -0,0 +1,74 @@
+import { input } from "./terminal/input-prompt.js";
+import { select } from "./terminal/select-prompt.js";
+import style from "./terminal/style.js";
+export class ToolExecutor {
+    autoAcceptAll;
+    autoAcceptMap = new Map();
+    constructor(autoAcceptAll) {
+        this.autoAcceptAll = autoAcceptAll;
+    }
+    autoAccept(toolName) {
+        return !!this.autoAcceptMap.get(toolName);
+    }
+    async ask(ctx, { abortSignal }) {
+        if (this.autoAcceptAll) {
+            return {
+                result: "accept-all",
+            };
+        }
+        if (this.autoAcceptMap.has(ctx.toolName)) {
+            if (this.autoAcceptMap.get(ctx.toolName) === true) {
+                return {
+                    result: "accept-all",
+                };
+            }
+        }
+        let userChoice;
+        try {
+            userChoice = await select({
+                message: `${style.blue.bold("●")} ${ctx.message}`,
+                choices: [
+                    { name: ctx.choices.accept, value: "accept" },
+                    {
+                        name: ctx.choices.acceptAll,
+                        value: "accept-all",
+                    },
+                    { name: ctx.choices.reject, value: "reject" },
+                ],
+                initial: 0,
+                signal: abortSignal,
+            });
+        }
+        catch (e) {
+            if (e.name === "AbortError") {
+                throw new Error("Operation aborted during user input");
+            }
+            throw e;
+        }
+        if (userChoice === "reject") {
+            let reason;
+            try {
+                reason = await input({
+                    message: `${style.yellowBright.bold("●")} Feedback`,
+                    signal: abortSignal,
+                });
+            }
+            catch (e) {
+                if (e.name === "AbortError") {
+                    throw new Error("Operation aborted during user input");
+                }
+                throw e;
+            }
+            return {
+                result: userChoice,
+                reason,
+            };
+        }
+        if (userChoice === "accept-all") {
+            this.autoAcceptMap.set(ctx.toolName, true);
+        }
+        return {
+            result: userChoice,
+        };
+    }
+}

package/dist/tools/agent.d.ts

@@ -1,6 +1,6 @@
 import type { ModelManager } from "../models/manager.ts";
-import type { TokenTracker } from "../token-tracker.ts";
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { TokenTracker } from "../tokens/tracker.ts";
 import type { SendData } from "./types.ts";
 export declare const AgentTool: {
     name: "agent";
@@ -15,3 +15,4 @@ export declare const createAgentTools: (options: {
         prompt: string;
     }, string>;
 };
+//# sourceMappingURL=agent.d.ts.map

package/dist/tools/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../source/tools/agent.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,SAAS;;CAErB,CAAC;AA+BF,eAAO,MAAM,gBAAgB,GAAI,SAAS;IACxC,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC;;;;CAyDA,CAAC"}

package/dist/tools/agent.js

@@ -1,9 +1,9 @@
 import { generateText, stepCountIs, tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
 import { AiConfig } from "../models/ai-config.js";
+import style from "../terminal/style.js";
 import { BashTool } from "./bash.js";
-import { DirectoryTreeTool } from "./directory-tree.js";
+// import { DirectoryTreeTool } from "./directory-tree.ts";
 import { GrepTool } from "./grep.js";
 import { initCliTools } from "./index.js";
 import { ReadFileTool } from "./read-file.js";
@@ -16,7 +16,7 @@ const TOOLS = [
     BashTool.name,
     ReadFileTool.name,
     ReadMultipleFilesTool.name,
-    DirectoryTreeTool.name,
+    // DirectoryTreeTool.name,
 ];
 function getToolDescription() {
     const toolNames = TOOLS.join(", ");
@@ -42,10 +42,13 @@ export const createAgentTools = (options) => {
             description: getToolDescription(),
             inputSchema: inputSchema,
             execute: async ({ prompt }, { abortSignal, toolCallId }) => {
+                if (abortSignal?.aborted) {
+                    throw new Error("Agent execution aborted");
+                }
                 sendData?.({
                     event: "tool-init",
                     id: toolCallId,
-                    data: `Initializing agent with prompt: ${chalk.cyan(prompt)}`,
+                    data: `Initializing agent with prompt: ${style.cyan(prompt)}`,
                 });
                 try {
                     const modelConfig = modelManager.getModelMetadata("task-agent");

package/dist/tools/bash-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function validatePaths(command: string, baseDir: string, cwd: string): {
+    isValid: boolean;
+    error?: string;
+};
+export declare const resolveCwd: (cwdInput: string | null | undefined, workingDir: string) => string;
+export declare const isMutatingCommand: (rawCommand: string) => boolean;
+//# sourceMappingURL=bash-utils.d.ts.map

package/dist/tools/bash-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-utils.d.ts","sourceRoot":"","sources":["../../source/tools/bash-utils.ts"],"names":[],"mappings":"AAKA,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACV;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAiEtC;AAED,eAAO,MAAM,UAAU,GACrB,UAAU,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,YAAY,MAAM,KACjB,MAiDF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,YAAY,MAAM,KAAG,OAmHtD,CAAC"}