@travisennis/acai 0.0.5 → 0.0.6

package/dist/tools/code-interpreter.js

@@ -3,8 +3,8 @@ import { randomUUID } from "node:crypto";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
-import { tool } from "ai";
 import { z } from "zod";
+import { manageTokenLimit } from "../tokens/threshold.js";
 export const CodeInterpreterTool = {
     name: "codeInterpreter",
 };
@@ -24,143 +24,144 @@ import { functionName } from '../source/path/to/module.ts';
 The interpreter supports ES Modules with TypeScript files directly.
 
 Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
-export const createCodeInterpreterTool = ({ sendData, }) => {
-    return {
-        [CodeInterpreterTool.name]: tool({
-            description: toolDescription,
-            inputSchema: z.object({
-                code: z.string().describe("The Typescript code to be executed."),
-                timeoutSeconds: z
-                    .number()
-                    .int()
-                    .min(1)
-                    .max(60)
-                    .nullable()
-                    .describe("Execution timeout in seconds (1-60). Default 5."),
-            }),
-            execute: async ({ code, timeoutSeconds }, { toolCallId, abortSignal }) => {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("Code interpretation aborted");
-                }
-                const workingDirectory = process.cwd();
-                try {
-                    sendData?.({
-                        event: "tool-init",
-                        id: toolCallId,
-                        data: "Initializing code interpreter environment",
-                    });
-                    const scriptType = "typescript";
-                    sendData?.({
-                        event: "tool-update",
-                        id: toolCallId,
-                        data: {
-                            primary: "Executing...",
-                            secondary: [
-                                `${"`".repeat(3)} ${scriptType}}\n${code.slice(0, 500)}${"`".repeat(3)}`,
-                            ],
-                        },
-                    });
-                    if (code.trim().length === 0) {
-                        throw new Error("No code provided");
-                    }
-                    if (abortSignal?.aborted) {
-                        throw new Error("Code interpretation aborted before execution");
-                    }
-                    const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
-                    const tmpBase = join(workingDirectory, ".acai-ci-tmp");
-                    await mkdir(tmpBase, { recursive: true });
-                    const ext = ".ts";
-                    const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
-                    await writeFile(scriptPath, code, { encoding: "utf8" });
-                    const args = [
-                        "--permission",
-                        `--allow-fs-read=${workingDirectory}`,
-                        `--allow-fs-write=${workingDirectory}`,
-                        scriptPath,
-                    ];
-                    const child = spawn(process.execPath, args, {
-                        cwd: workingDirectory,
-                        // do not rely solely on spawn's timeout; we implement manual timeout below
-                        stdio: "pipe",
-                        env: Object.assign({}, process.env, {
-                            // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                            NO_COLOR: "true",
-                            // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
-                            NODE_OPTIONS: "",
-                        }),
-                    });
-                    // Handle abort signal by killing the child process
-                    if (abortSignal) {
-                        abortSignal.addEventListener("abort", () => {
-                            try {
-                                child.kill("SIGKILL");
-                            }
-                            catch { }
-                            throw new Error("Code interpretation aborted during execution");
-                        });
-                    }
-                    let stdout = "";
-                    let stderr = "";
-                    let timedOut = false;
-                    const timer = setTimeout(() => {
-                        timedOut = true;
-                        try {
-                            child.kill("SIGKILL");
-                        }
-                        catch { }
-                    }, timeoutMs);
-                    child.stdout.setEncoding("utf8");
-                    child.stderr.setEncoding("utf8");
-                    child.stdout.on("data", (chunk) => {
-                        stdout += String(chunk);
-                    });
-                    child.stderr.on("data", (chunk) => {
-                        stderr += String(chunk);
-                    });
-                    const completed = await new Promise((resolve, reject) => {
-                        child.on("error", (err) => reject(err));
-                        child.on("close", (code, signal) => resolve({ code, signal }));
-                    });
-                    clearTimeout(timer);
-                    // Cleanup temp file/directory
-                    await rm(scriptPath, { force: true });
-                    await rm(tmpBase, { force: true, recursive: true });
-                    if (timedOut) {
-                        throw new Error("Script timed out");
-                    }
-                    if (completed.code === null) {
-                        throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
-                    }
-                    if (completed.code !== 0) {
-                        const message = `Process exited with code ${completed.code}. Stderr:\n${stderr.trim()}`;
-                        throw new Error(message);
+const inputSchema = z.object({
+    code: z.string().describe("The Typescript code to be executed."),
+    timeoutSeconds: z
+        .number()
+        .int()
+        .min(1)
+        .max(60)
+        .nullable()
+        .describe("Execution timeout in seconds (1-60). Default 5."),
+});
+export const createCodeInterpreterTool = async ({ tokenCounter, }) => {
+    const toolDef = {
+        description: toolDescription,
+        inputSchema,
+    };
+    async function* execute({ code, timeoutSeconds }, { toolCallId, abortSignal }) {
+        // Check if execution has been aborted
+        if (abortSignal?.aborted) {
+            throw new Error("Code interpretation aborted");
+        }
+        const workingDirectory = process.cwd();
+        const lines = code.split("\n");
+        try {
+            yield {
+                name: CodeInterpreterTool.name,
+                event: "tool-init",
+                id: toolCallId,
+                data: `Executing ${lines.length} lines of code.`,
+            };
+            if (code.trim().length === 0) {
+                throw new Error("No code provided");
+            }
+            if (abortSignal?.aborted) {
+                throw new Error("Code interpretation aborted before execution");
+            }
+            const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
+            const tmpBase = join(workingDirectory, ".acai-ci-tmp");
+            await mkdir(tmpBase, { recursive: true });
+            const ext = ".ts";
+            const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
+            await writeFile(scriptPath, code, { encoding: "utf8" });
+            const args = [
+                "--permission",
+                `--allow-fs-read=${workingDirectory}`,
+                `--allow-fs-write=${workingDirectory}`,
+                scriptPath,
+            ];
+            const child = spawn(process.execPath, args, {
+                cwd: workingDirectory,
+                // do not rely solely on spawn's timeout; we implement manual timeout below
+                stdio: "pipe",
+                env: Object.assign({}, process.env, {
+                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                    NO_COLOR: "true",
+                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                    NODE_OPTIONS: "",
+                    // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                    ACAI_CODE_INTERPRETER: "true",
+                }),
+            });
+            // Handle abort signal by killing the child process
+            if (abortSignal) {
+                const abortHandler = () => {
+                    try {
+                        child.kill("SIGKILL");
                     }
-                    const result = {
-                        stdout: stdout.trim(),
-                        stderr: stderr.trim(),
-                        exitCode: completed.code ?? -1,
-                    };
-                    sendData?.({
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: "Code execution completed successfully",
-                    });
-                    return JSON.stringify(result, null, 2);
-                }
-                catch (err) {
-                    const errorMessage = err.name === "ETIMEDOUT" ||
-                        err.message.includes("timed out")
-                        ? "Script timed out"
-                        : `Error:\n${err.message}`;
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: errorMessage,
-                    });
-                    return errorMessage;
+                    catch { }
+                    throw new Error("Code interpretation aborted during execution");
+                };
+                abortSignal.addEventListener("abort", abortHandler);
+            }
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    child.kill("SIGKILL");
                 }
-            },
-        }),
+                catch { }
+            }, timeoutMs);
+            child.stdout.setEncoding("utf8");
+            child.stderr.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                stdout += String(chunk);
+            });
+            child.stderr.on("data", (chunk) => {
+                stderr += String(chunk);
+            });
+            const completed = await new Promise((resolve, reject) => {
+                child.on("error", (err) => reject(err));
+                child.on("close", (code, signal) => resolve({ code, signal }));
+            });
+            clearTimeout(timer);
+            // Cleanup temp file/directory
+            await rm(scriptPath, { force: true });
+            await rm(tmpBase, { force: true, recursive: true });
+            if (timedOut) {
+                throw new Error("Script timed out");
+            }
+            if (completed.code === null) {
+                throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
+            }
+            if (completed.code !== 0) {
+                const message = `Process exited with code ${completed.code}. Stderr:\n${stderr.trim()}`;
+                throw new Error(message);
+            }
+            const result = {
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+                exitCode: completed.code ?? -1,
+            };
+            const resultJson = JSON.stringify(result, null, 2);
+            const managedResult = await manageTokenLimit(resultJson, tokenCounter, "CodeInterpreter", "Reduce script complexity or output size");
+            yield {
+                name: CodeInterpreterTool.name,
+                event: "tool-completion",
+                id: toolCallId,
+                data: `Completed successfully${managedResult.tokenCount > 0 ? ` (${managedResult.tokenCount} tokens)` : ""}`,
+            };
+            yield managedResult.content;
+        }
+        catch (err) {
+            const errorMessage = err.name === "ETIMEDOUT" ||
+                err.message.includes("timed out")
+                ? "Script timed out"
+                : err.message;
+            yield {
+                name: CodeInterpreterTool.name,
+                event: "tool-error",
+                id: toolCallId,
+                data: errorMessage,
+            };
+            yield errorMessage;
+        }
+    }
+    return {
+        toolDef,
+        execute,
     };
 };

package/dist/tools/delete-file.d.ts

@@ -1,17 +1,24 @@
-import type { Terminal } from "../terminal/index.ts";
-import type { ToolExecutor } from "../tool-executor.ts";
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
 export declare const DeleteFileTool: {
     name: "deleteFile";
 };
-export declare const createDeleteFileTool: ({ workingDir, terminal, sendData, toolExecutor, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+type DeleteFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createDeleteFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
-    terminal?: Terminal;
-    sendData?: SendData;
-    toolExecutor?: ToolExecutor;
+    allowedDirs?: string[];
 }) => Promise<{
-    deleteFile: import("ai").Tool<{
-        path: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ path: userPath }: DeleteFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=delete-file.d.ts.map

package/dist/tools/delete-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-file.d.ts","sourceRoot":"","sources":["../../source/tools/delete-file.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,mDAKxC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;EA2HA,CAAC"}
+{"version":3,"file":"delete-file.d.ts","sourceRoot":"","sources":["../../source/tools/delete-file.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,cAAc;;CAE1B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEzD,eAAO,MAAM,oBAAoB,GAAU,8BAGxC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;gCASyB,qBAAqB,+BACZ,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA2DhC,CAAC"}

package/dist/tools/delete-file.js

@@ -1,114 +1,70 @@
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
-import { tool } from "ai";
 import { z } from "zod";
 import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const DeleteFileTool = {
     name: "deleteFile",
 };
-export const createDeleteFileTool = async ({ workingDir, terminal, sendData, toolExecutor, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    path: z.string().describe("Absolute path to the file to delete"),
+});
+export const createDeleteFileTool = async ({ workingDir, allowedDirs, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [DeleteFileTool.name]: tool({
+        toolDef: {
             description: "Delete a file permanently.",
-            inputSchema: z.object({
-                path: z.string().describe("Absolute path to the file to delete"),
-            }),
-            execute: async ({ path: userPath }, { toolCallId, abortSignal }) => {
-                // Check if execution has been aborted
+            inputSchema,
+        },
+        async *execute({ path: userPath }, { toolCallId, abortSignal }) {
+            try {
                 if (abortSignal?.aborted) {
                     throw new Error("File deletion aborted");
                 }
-                sendData?.({
+                yield {
+                    name: DeleteFileTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Deleting file: ${style.cyan(userPath)}`,
-                });
-                try {
-                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { abortSignal });
-                    // Check if file exists before attempting delete
-                    if (!existsSync(filePath)) {
-                        throw new Error(`File not found: ${filePath}`);
-                    }
-                    // Pre-check for stat
-                    if (abortSignal?.aborted) {
-                        throw new Error("File deletion aborted before stat");
-                    }
-                    // Ensure it's a file, not a directory
-                    const stats = await fs.stat(filePath);
-                    if (stats.isDirectory()) {
-                        throw new Error(`Path is a directory, not a file: ${filePath}`);
-                    }
-                    if (terminal) {
-                        terminal.writeln(`\n${style.red.bold("●")} Proposing file deletion: ${style.cyan(userPath)}`);
-                        terminal.lineBreak();
-                        terminal.writeln("This action cannot be undone.");
-                        terminal.lineBreak();
-                        let userResponse;
-                        if (toolExecutor) {
-                            const ctx = {
-                                toolName: DeleteFileTool.name,
-                                toolCallId,
-                                message: "What would you like to do with this deletion?",
-                                choices: {
-                                    accept: "Accept this deletion",
-                                    acceptAll: "Accept all future deletions (including this)",
-                                    reject: "Reject this deletion",
-                                },
-                            };
-                            try {
-                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
-                            }
-                            catch (e) {
-                                if (e.name === "AbortError") {
-                                    throw new Error("File deletion aborted during user input");
-                                }
-                                throw e;
-                            }
-                        }
-                        const { result: userChoice, reason } = userResponse ?? {
-                            result: "accept",
-                        };
-                        terminal.lineBreak();
-                        if (userChoice === "accept-all") {
-                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all deletions"));
-                            terminal.lineBreak();
-                        }
-                        if (userChoice === "reject") {
-                            terminal.lineBreak();
-                            const rejectionReason = reason || "No reason provided";
-                            sendData?.({
-                                id: toolCallId,
-                                event: "tool-completion",
-                                data: `Deletion rejected by user. Reason: ${rejectionReason}`,
-                            });
-                            return `The user rejected this deletion. Reason: ${rejectionReason}`;
-                        }
-                    }
-                    // Pre-side-effect check
-                    if (abortSignal?.aborted) {
-                        throw new Error("File deletion aborted before unlink");
-                    }
-                    // Delete the file with signal
-                    await fs.unlink(filePath);
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: "File deleted successfully",
-                    });
-                    return `Successfully deleted ${filePath}`;
+                    data: `${style.cyan(userPath)}`,
+                };
+                const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { abortSignal });
+                // Check if file exists before attempting delete
+                if (!existsSync(filePath)) {
+                    throw new Error(`File not found: ${filePath}`);
                 }
-                catch (error) {
-                    const errorMessage = `Failed to delete file: ${error.message}`;
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-error",
-                        data: errorMessage,
-                    });
-                    return errorMessage;
+                // Pre-check for stat
+                if (abortSignal?.aborted) {
+                    throw new Error("File deletion aborted before stat");
+                }
+                // Ensure it's a file, not a directory
+                const stats = await fs.stat(filePath);
+                if (stats.isDirectory()) {
+                    throw new Error(`Path is a directory, not a file: ${filePath}`);
+                }
+                // Pre-side-effect check
+                if (abortSignal?.aborted) {
+                    throw new Error("File deletion aborted before unlink");
                 }
-            },
-        }),
+                // Delete the file with signal
+                await fs.unlink(filePath);
+                yield {
+                    name: DeleteFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: "File deleted",
+                };
+                yield `Successfully deleted ${filePath}`;
+            }
+            catch (error) {
+                const errorMessage = error.message;
+                yield {
+                    name: DeleteFileTool.name,
+                    id: toolCallId,
+                    event: "tool-error",
+                    data: errorMessage,
+                };
+                yield errorMessage;
+            }
+        },
     };
 };

package/dist/tools/directory-tree.d.ts

@@ -1,16 +1,26 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { SendData } from "./types.ts";
+import type { ToolResult } from "./types.ts";
 export declare const DirectoryTreeTool: {
     name: "directoryTree";
 };
-export declare const createDirectoryTreeTool: ({ workingDir, sendData, tokenCounter, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
+export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, tokenCounter, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
 }) => Promise<{
-    directoryTree: import("ai").Tool<{
-        path: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ path }: DirectoryTreeInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
 /**
  * Generates a string representation of a directory tree starting from the given path.
@@ -18,4 +28,5 @@ export declare const createDirectoryTreeTool: ({ workingDir, sendData, tokenCoun
  * @returns A Promise that resolves to a string representation of the directory tree.
  */
 export declare function directoryTree(dirPath: string): Promise<string>;
+export {};
 //# sourceMappingURL=directory-tree.d.ts.map

package/dist/tools/directory-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAU,yCAI3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;EAmEA,CAAC;AA8CF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAYpE"}
+{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,4CAI3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;sBASe,wBAAwB,+BACL,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA+DhC,CAAC;AA8CF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAYpE"}