@travisennis/acai 0.0.5 → 0.0.7

package/dist/terminal/table/utils.js

@@ -0,0 +1,326 @@
+import stringWidth from "../string-width.js";
+function codeRegex(capture) {
+    return capture
+        ? // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape sequences for terminal formatting
+            /\u001b\[((?:\d*;){0,5}\d*)m/g
+        : // biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape sequences for terminal formatting
+            /\u001b\[(?:\d*;){0,5}\d*m/g;
+}
+export function strlen(str) {
+    const code = codeRegex(false);
+    const stripped = `${str}`.replace(code, "");
+    const split = stripped.split("\n");
+    return split.reduce((memo, s) => {
+        return stringWidth(s) > memo ? stringWidth(s) : memo;
+    }, 0);
+}
+export function repeat(str, times) {
+    return Array(times + 1).join(str);
+}
+export function pad(str, len, padChar, dir) {
+    const length = strlen(str);
+    let result = str;
+    if (len + 1 >= length) {
+        const padlen = len - length;
+        switch (dir) {
+            case "right": {
+                result = repeat(padChar, padlen) + result;
+                break;
+            }
+            case "center": {
+                const right = Math.ceil(padlen / 2);
+                const left = padlen - right;
+                result = repeat(padChar, left) + result + repeat(padChar, right);
+                break;
+            }
+            default: {
+                result = result + repeat(padChar, padlen);
+                break;
+            }
+        }
+    }
+    return result;
+}
+const codeCache = {};
+function addToCodeCache(name, on, off) {
+    const onCode = `\u001b[${on}m`;
+    const offCode = `\u001b[${off}m`;
+    codeCache[onCode] = { set: name, to: true };
+    codeCache[offCode] = { set: name, to: false };
+    codeCache[name] = { on: onCode, off: offCode };
+}
+// https://github.com/Marak/colors.js/blob/master/lib/styles.js
+addToCodeCache("bold", "1", "22");
+addToCodeCache("italics", "3", "23");
+addToCodeCache("underline", "4", "24");
+addToCodeCache("inverse", "7", "27");
+addToCodeCache("strikethrough", "9", "29");
+function updateState(state, controlChars) {
+    const controlCode = controlChars[1]
+        ? Number.parseInt(controlChars[1].split(";")[0], 10)
+        : 0;
+    if ((controlCode >= 30 && controlCode <= 39) ||
+        (controlCode >= 90 && controlCode <= 97)) {
+        state.lastForegroundAdded = controlChars[0];
+        return;
+    }
+    if ((controlCode >= 40 && controlCode <= 49) ||
+        (controlCode >= 100 && controlCode <= 107)) {
+        state.lastBackgroundAdded = controlChars[0];
+        return;
+    }
+    if (controlCode === 0) {
+        for (const i in state) {
+            /* istanbul ignore else */
+            if (Object.hasOwn(state, i)) {
+                delete state[i];
+            }
+        }
+        return;
+    }
+    const info = codeCache[controlChars[0]];
+    if (info) {
+        state[info.set] = info.to;
+    }
+}
+function readState(line) {
+    const code = codeRegex(true);
+    let controlChars = code.exec(line);
+    const state = {};
+    while (controlChars !== null) {
+        updateState(state, controlChars);
+        controlChars = code.exec(line);
+    }
+    return state;
+}
+function unwindState(state, ret) {
+    const lastBackgroundAdded = state.lastBackgroundAdded;
+    const lastForegroundAdded = state.lastForegroundAdded;
+    delete state.lastBackgroundAdded;
+    delete state.lastForegroundAdded;
+    let result = ret;
+    Object.keys(state).forEach((key) => {
+        if (state[key]) {
+            const cacheEntry = codeCache[key];
+            result += cacheEntry.off;
+        }
+    });
+    if (lastBackgroundAdded && lastBackgroundAdded !== "\u001b[49m") {
+        result += "\u001b[49m";
+    }
+    if (lastForegroundAdded && lastForegroundAdded !== "\u001b[39m") {
+        result += "\u001b[39m";
+    }
+    return result;
+}
+function rewindState(state, ret) {
+    const lastBackgroundAdded = state.lastBackgroundAdded;
+    const lastForegroundAdded = state.lastForegroundAdded;
+    delete state.lastBackgroundAdded;
+    delete state.lastForegroundAdded;
+    let result = ret;
+    Object.keys(state).forEach((key) => {
+        if (state[key]) {
+            const cacheEntry = codeCache[key];
+            result = cacheEntry.on + result;
+        }
+    });
+    if (lastBackgroundAdded && lastBackgroundAdded !== "\u001b[49m") {
+        result = lastBackgroundAdded + result;
+    }
+    if (lastForegroundAdded && lastForegroundAdded !== "\u001b[39m") {
+        result = lastForegroundAdded + result;
+    }
+    return result;
+}
+function truncateWidth(str, desiredLength) {
+    if (str.length === strlen(str)) {
+        return str.substr(0, desiredLength);
+    }
+    let result = str;
+    while (strlen(result) > desiredLength) {
+        result = result.slice(0, -1);
+    }
+    return result;
+}
+function truncateWidthWithAnsi(str, desiredLength) {
+    const code = codeRegex(true);
+    const split = str.split(codeRegex(false));
+    let splitIndex = 0;
+    let retLen = 0;
+    let ret = "";
+    let myArray;
+    const state = {};
+    while (retLen < desiredLength) {
+        myArray = code.exec(str);
+        let toAdd = split[splitIndex];
+        splitIndex++;
+        if (retLen + strlen(toAdd) > desiredLength) {
+            toAdd = truncateWidth(toAdd, desiredLength - retLen);
+        }
+        ret += toAdd;
+        retLen += strlen(toAdd);
+        if (retLen < desiredLength) {
+            if (!myArray) {
+                break;
+            } // full-width chars may cause a whitespace which cannot be filled
+            ret += myArray[0];
+            updateState(state, myArray);
+        }
+    }
+    return unwindState(state, ret);
+}
+export function truncate(str, desiredLength, truncateChar) {
+    const finalTruncateChar = truncateChar || "…";
+    const lengthOfStr = strlen(str);
+    if (lengthOfStr <= desiredLength) {
+        return str;
+    }
+    const finalDesiredLength = desiredLength - strlen(finalTruncateChar);
+    let ret = truncateWidthWithAnsi(str, finalDesiredLength);
+    ret += finalTruncateChar;
+    const hrefTag = "\x1B]8;;\x07";
+    if (str.includes(hrefTag) && !ret.includes(hrefTag)) {
+        ret += hrefTag;
+    }
+    return ret;
+}
+export function defaultOptions() {
+    return {
+        chars: {
+            top: "─",
+            topMid: "┬",
+            topLeft: "┌",
+            topRight: "┐",
+            bottom: "─",
+            bottomMid: "┴",
+            bottomLeft: "└",
+            bottomRight: "┘",
+            left: "│",
+            leftMid: "├",
+            mid: "─",
+            midMid: "┼",
+            right: "│",
+            rightMid: "┤",
+            middle: "│",
+        },
+        truncate: "…",
+        colWidths: [],
+        rowHeights: [],
+        colAligns: [],
+        rowAligns: [],
+        style: {
+            "padding-left": 1,
+            "padding-right": 1,
+            head: ["red"],
+            border: ["grey"],
+            compact: false,
+        },
+        head: [],
+        wordWrap: false,
+        wrapOnWordBoundary: true,
+    };
+}
+export function mergeOptions(options, defaults) {
+    const finalOptions = options || {};
+    const finalDefaults = defaults || defaultOptions();
+    const ret = Object.assign({}, finalDefaults, finalOptions);
+    ret.chars = Object.assign({}, finalDefaults.chars, finalOptions.chars);
+    ret.style = Object.assign({}, finalDefaults.style, finalOptions.style);
+    return ret;
+}
+// Wrap on word boundary
+function wordWrap(maxLength, input) {
+    const lines = [];
+    const split = input.split(/(\s+)/g);
+    const line = [];
+    let lineLength = 0;
+    let whitespace = "";
+    for (let i = 0; i < split.length; i += 2) {
+        const word = split[i];
+        let newLength = lineLength + strlen(word);
+        if (lineLength > 0 && whitespace) {
+            newLength += whitespace.length;
+        }
+        if (newLength > maxLength) {
+            if (lineLength !== 0) {
+                lines.push(line.join(""));
+            }
+            line.length = 0;
+            line.push(word);
+            lineLength = strlen(word);
+        }
+        else {
+            line.push(whitespace || "", word);
+            lineLength = newLength;
+        }
+        whitespace = split[i + 1];
+    }
+    if (lineLength) {
+        lines.push(line.join(""));
+    }
+    return lines;
+}
+// Wrap text (ignoring word boundaries)
+function textWrap(maxLength, input) {
+    const lines = [];
+    let line = "";
+    function pushLine(str, ws) {
+        if (line.length && ws)
+            line += ws;
+        line += str;
+        while (line.length > maxLength) {
+            lines.push(line.slice(0, maxLength));
+            line = line.slice(maxLength);
+        }
+    }
+    const split = input.split(/(\s+)/g);
+    for (let i = 0; i < split.length; i += 2) {
+        pushLine(split[i], i ? split[i - 1] : "");
+    }
+    if (line.length)
+        lines.push(line);
+    return lines;
+}
+export function multiLineWordWrap(maxLength, input, wrapOnWordBoundary = true) {
+    const output = [];
+    const lines = input.split("\n");
+    const handler = wrapOnWordBoundary ? wordWrap : textWrap;
+    for (let i = 0; i < lines.length; i++) {
+        output.push(...handler(maxLength, lines[i]));
+    }
+    return output;
+}
+export function colorizeLines(input) {
+    let state = {};
+    const output = [];
+    for (let i = 0; i < input.length; i++) {
+        const line = rewindState(state, input[i]);
+        state = readState(line);
+        const temp = Object.assign({}, state);
+        output.push(unwindState(temp, line));
+    }
+    return output;
+}
+/**
+ * Credit: Matheus Sampaio https://github.com/matheussampaio
+ */
+export function hyperlink(url, text) {
+    const Osc = "\u001B]";
+    const Bel = "\u0007";
+    const Sep = ";";
+    return [
+        Osc,
+        "8",
+        Sep,
+        Sep,
+        url || text,
+        Bel,
+        text,
+        Osc,
+        "8",
+        Sep,
+        Sep,
+        Bel,
+    ].join("");
+}

package/dist/tokens/threshold.d.ts

@@ -0,0 +1,20 @@
+import type { TokenCounter } from "./counter.ts";
+export declare function clearTokenCache(): void;
+export declare class TokenLimitExceededError extends Error {
+    constructor(toolName: string, tokenCount: number, maxTokens: number, guidance?: string);
+}
+/**
+ * Check if content exceeds token limit
+ * @param content - The content to check
+ * @param tokenCounter - Token counter instance
+ * @param toolName - Name of the tool for messages
+ * @param additionalGuidance - Optional tool-specific guidance
+ * @param encoding - Optional encoding type for non-text file handling
+ * @returns Content with token count if under limit
+ * @throws TokenLimitExceededError if content exceeds token limit
+ */
+export declare function manageTokenLimit<T extends string>(content: T, tokenCounter: TokenCounter, toolName: string, additionalGuidance?: string, encoding?: string): Promise<{
+    content: T;
+    tokenCount: number;
+}>;
+//# sourceMappingURL=threshold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"threshold.d.ts","sourceRoot":"","sources":["../../source/tokens/threshold.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAQjD,wBAAgB,eAAe,SAG9B;AAyBD,qBAAa,uBAAwB,SAAQ,KAAK;gBAE9C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,QAAQ,CAAC,EAAE,MAAM;CASpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EACrD,OAAO,EAAE,CAAC,EACV,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,EAChB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,OAAO,EAAE,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CA2B7C"}

package/dist/tokens/threshold.js

@@ -0,0 +1,67 @@
+import { config } from "../config.js";
+// Cache for maxTokens config to avoid repeated async calls
+let maxTokensCache = null;
+let cacheExpiry = 0;
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+// Export cache management for testing
+export function clearTokenCache() {
+    maxTokensCache = null;
+    cacheExpiry = 0;
+}
+/**
+ * Get maxTokens from config with caching
+ */
+async function getMaxTokens() {
+    const now = Date.now();
+    if (maxTokensCache !== null && now < cacheExpiry) {
+        return maxTokensCache;
+    }
+    try {
+        const projectConfig = await config.getConfig();
+        maxTokensCache = projectConfig.tools.maxTokens;
+        cacheExpiry = now + CACHE_DURATION;
+        return maxTokensCache;
+    }
+    catch (error) {
+        console.info("Failed to read config for maxTokens, using default:", error);
+        maxTokensCache = 8000; // Default fallback
+        cacheExpiry = now + CACHE_DURATION;
+        return maxTokensCache;
+    }
+}
+export class TokenLimitExceededError extends Error {
+    constructor(toolName, tokenCount, maxTokens, guidance) {
+        super(`${toolName}: Content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). ${guidance || "Please adjust parameters to reduce content size."}`);
+        this.name = "TokenLimitExceededError";
+    }
+}
+/**
+ * Check if content exceeds token limit
+ * @param content - The content to check
+ * @param tokenCounter - Token counter instance
+ * @param toolName - Name of the tool for messages
+ * @param additionalGuidance - Optional tool-specific guidance
+ * @param encoding - Optional encoding type for non-text file handling
+ * @returns Content with token count if under limit
+ * @throws TokenLimitExceededError if content exceeds token limit
+ */
+export async function manageTokenLimit(content, tokenCounter, toolName, additionalGuidance, encoding) {
+    // For non-text files, return content directly without token management
+    if (encoding && !encoding.startsWith("utf")) {
+        return { content, tokenCount: 0 };
+    }
+    let tokenCount = 0;
+    try {
+        tokenCount = tokenCounter.count(content);
+    }
+    catch (tokenError) {
+        console.info("Error calculating token count:", tokenError);
+        // Return content if token counting fails
+        return { content, tokenCount: 0 };
+    }
+    const maxTokens = await getMaxTokens();
+    if (tokenCount <= maxTokens) {
+        return { content, tokenCount };
+    }
+    throw new TokenLimitExceededError(toolName, tokenCount, maxTokens, additionalGuidance);
+}

package/dist/tools/advanced-edit-file.d.ts

@@ -0,0 +1,69 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
+export declare const AdvancedEditFileTool: {
+    name: "advancedEditFile";
+};
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        exact: "exact";
+        regex: "regex";
+        ast: "ast";
+    }>>;
+    operations: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            replace: "replace";
+            "insert-before": "insert-before";
+            "insert-after": "insert-after";
+            delete: "delete";
+        }>;
+        pattern: z.ZodString;
+        replacement: z.ZodOptional<z.ZodString>;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    astPattern: z.ZodOptional<z.ZodString>;
+    astReplacement: z.ZodOptional<z.ZodString>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type AdvancedEditFileInputSchema = z.infer<typeof inputSchema>;
+interface FileOperation {
+    type: "replace" | "insert-before" | "insert-after" | "delete";
+    pattern: string;
+    replacement?: string;
+    flags?: string;
+}
+export declare const createAdvancedEditFileTool: ({ workingDir, allowedDirs, }: {
+    workingDir: string;
+    allowedDirs?: string[];
+}) => Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            mode: z.ZodDefault<z.ZodEnum<{
+                exact: "exact";
+                regex: "regex";
+                ast: "ast";
+            }>>;
+            operations: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    replace: "replace";
+                    "insert-before": "insert-before";
+                    "insert-after": "insert-after";
+                    delete: "delete";
+                }>;
+                pattern: z.ZodString;
+                replacement: z.ZodOptional<z.ZodString>;
+                flags: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            astPattern: z.ZodOptional<z.ZodString>;
+            astReplacement: z.ZodOptional<z.ZodString>;
+            dryRun: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+    };
+    execute({ path, mode, operations, astPattern, astReplacement, dryRun, }: AdvancedEditFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+}>;
+export declare function applyAdvancedFileEdits(filePath: string, mode: "exact" | "regex" | "ast", operations: FileOperation[], astPattern?: string, astReplacement?: string, dryRun?: boolean, abortSignal?: AbortSignal): Promise<string>;
+export {};
+//# sourceMappingURL=advanced-edit-file.d.ts.map

package/dist/tools/advanced-edit-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced-edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/advanced-edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,oBAAoB;;CAEhC,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;iBAuCf,CAAC;AAEH,KAAK,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE/D,UAAU,aAAa;IACrB,IAAI,EAAE,SAAS,GAAG,eAAe,GAAG,cAAc,GAAG,QAAQ,CAAC;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,0BAA0B,GAAU,8BAG9C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;6EAiBQ,2BAA2B,+BACD,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAoDhC,CAAC;AA2MF,wBAAsB,sBAAsB,CAC1C,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,KAAK,EAC/B,UAAU,EAAE,aAAa,EAAE,EAC3B,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAyEjB"}