@travisennis/acai 0.0.4 → 0.0.5

package/dist/tools/code-interpreter.js

@@ -8,100 +8,28 @@ import { z } from "zod";
 export const CodeInterpreterTool = {
     name: "codeInterpreter",
 };
-const toolDescription = `Executes JavaScript or Typescript code in a separate Node.js process using Node's Permission Model. 
-
-⚠️ **IMPORTANT TYPE SELECTION**:
-- Use "JavaScript" for plain JavaScript code (no TypeScript syntax)
-- Use "Typescript" for code containing interfaces, type annotations, generics, etc.
-- Code type is automatically validated before execution
+const toolDescription = `Executes Typescript code in a separate Node.js process using Node's Permission Model. 
 
 ⚠️ **IMPORTANT**: This tool uses ES Modules (ESM) only.
 - Use \`import\` statements, NOT \`require()\`
 - Examples: \`import fs from 'node:fs'\` NOT \`const fs = require('fs')\`
 - Add file extensions for relative imports: \`import { utils } from './utils.js'\`
 
-These scripts are run in the \`${process.cwd}/.acai-ci-tmp\`. Keep this in mind if you intend to import or reference files from this project in your script.
+These scripts are run in the \`${process.cwd()}/.acai-ci-tmp\`. You can import project source files using relative paths from the project root with .ts extensions:
 
-Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
-/**
- * Detects if code contains TypeScript syntax patterns
- */
-function containsTypeScriptSyntax(code) {
-    // Common TypeScript patterns that don't exist in JavaScript
-    const tsPatterns = [
-        // Type annotations
-        /:\s*[a-zA-Z]\w*(?:\s*\[])?\s*(?=[,;=)])/g, // Type annotations after variables/parameters (including any, string[], etc.)
-        /:\s*\{[^}]*\}\s*(?=[,;=)])/g, // Object type annotations
-        /:\s*\([^)]*\)\s*=>/g, // Function type annotations
-        // Type declarations
-        /^\s*interface\s+\w+/gm, // Interface declarations
-        /^\s*type\s+\w+\s*=/gm, // Type aliases
-        /^\s*enum\s+\w+/gm, // Enum declarations
-        // Generic types
-        /<\s*[A-Z]\w*(?:\s*,\s*[A-Z]\w*)*\s*>/g, // Generic type parameters
-        /\w+\s*<\s*[^<>]+?\s*>/g, // Generic type usage
-        // TypeScript-specific keywords (in specific contexts)
-        /\b(?:implements|extends\s+[A-Z]\w*|readonly|private|protected|public)\b/g,
-        // Utility types
-        /\b(?:Partial|Required|Pick|Omit|Record|Exclude|Extract)\b/g,
-    ];
-    return tsPatterns.some((pattern) => pattern.test(code));
-}
-/**
- * Validates that code content matches the specified type
- */
-function validateCodeTypeMatch(code, specifiedType) {
-    if (!code?.trim()) {
-        return "No code provided";
-    }
-    const detectedType = containsTypeScriptSyntax(code)
-        ? "Typescript"
-        : "JavaScript";
-    const expectedType = specifiedType ?? "JavaScript";
-    // If TypeScript syntax detected but JavaScript specified
-    if (detectedType === "Typescript" && expectedType === "JavaScript") {
-        return `Code contains TypeScript syntax but is specified as JavaScript. Please either:
-1. Change type to "Typescript", or
-2. Remove TypeScript syntax (interfaces, type annotations, generics, etc.)
+\`\`\` typescript
+import { functionName } from '../source/path/to/module.ts';
+\`\`\`
+
+The interpreter supports ES Modules with TypeScript files directly.
 
-Detected TypeScript patterns: ${getTypeScriptPatternsFound(code).join(", ")}`;
-    }
-    // If no TypeScript syntax but TypeScript specified (warning, not error)
-    if (detectedType === "JavaScript" && expectedType === "Typescript") {
-        // This is not an error, just potentially unnecessary
-        return null;
-    }
-    return null;
-}
-/**
- * Identifies specific TypeScript patterns found in code
- */
-function getTypeScriptPatternsFound(code) {
-    const patterns = [];
-    if (/\binterface\s+\w+/.test(code))
-        patterns.push("interface");
-    if (/\btype\s+\w+\s*=/.test(code))
-        patterns.push("type alias");
-    if (/:\s*[a-zA-Z]\w*(?:\s*\[])?\s*(?=[,;=)])/g.test(code))
-        patterns.push("type annotations");
-    if (/<\s*[A-Z]\w*\s*>/.test(code))
-        patterns.push("generics");
-    if (/\benum\s+\w+/.test(code))
-        patterns.push("enum");
-    return patterns;
-}
+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 JavaScript or Typescript code to be executed."),
-                type: z
-                    .enum(["JavaScript", "Typescript"])
-                    .nullable()
-                    .describe("The type of code. Either Javascript or Typescript."),
+                code: z.string().describe("The Typescript code to be executed."),
                 timeoutSeconds: z
                     .number()
                     .int()
@@ -110,25 +38,19 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                     .nullable()
                     .describe("Execution timeout in seconds (1-60). Default 5."),
             }),
-            execute: async ({ code, type, timeoutSeconds }, { toolCallId }) => {
+            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 {
-                    // Pre-execution validation
-                    const validationError = validateCodeTypeMatch(code, type);
-                    if (validationError) {
-                        sendData?.({
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: validationError,
-                        });
-                        return validationError;
-                    }
                     sendData?.({
                         event: "tool-init",
                         id: toolCallId,
                         data: "Initializing code interpreter environment",
                     });
-                    const scriptType = (type ?? "JavaScript").toLowerCase();
+                    const scriptType = "typescript";
                     sendData?.({
                         event: "tool-update",
                         id: toolCallId,
@@ -142,10 +64,13 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                     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 = type === "JavaScript" ? ".mjs" : ".ts";
+                    const ext = ".ts";
                     const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
                     await writeFile(scriptPath, code, { encoding: "utf8" });
                     const args = [
@@ -165,6 +90,16 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                             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;
@@ -198,7 +133,7 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                         throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
                     }
                     if (completed.code !== 0) {
-                        const message = `Process exited with code ${completed.code}. Stderr: ${stderr.trim()}`;
+                        const message = `Process exited with code ${completed.code}. Stderr:\n${stderr.trim()}`;
                         throw new Error(message);
                     }
                     const result = {
@@ -217,7 +152,7 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                     const errorMessage = err.name === "ETIMEDOUT" ||
                         err.message.includes("timed out")
                         ? "Script timed out"
-                        : `Error: ${err.message}`;
+                        : `Error:\n${err.message}`;
                     sendData?.({
                         event: "tool-error",
                         id: toolCallId,

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

@@ -1,15 +1,17 @@
 import type { Terminal } from "../terminal/index.ts";
+import type { ToolExecutor } from "../tool-executor.ts";
 import type { SendData } from "./types.ts";
 export declare const DeleteFileTool: {
     name: "deleteFile";
 };
-export declare const createDeleteFileTool: ({ workingDir, sendData, terminal, autoAcceptAll, }: {
+export declare const createDeleteFileTool: ({ workingDir, terminal, sendData, toolExecutor, }: {
     workingDir: string;
-    sendData?: SendData;
     terminal?: Terminal;
-    autoAcceptAll?: boolean;
+    sendData?: SendData;
+    toolExecutor?: ToolExecutor;
 }) => Promise<{
     deleteFile: import("ai").Tool<{
         path: string;
     }, string>;
 }>;
+//# sourceMappingURL=delete-file.d.ts.map

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

@@ -0,0 +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"}

package/dist/tools/delete-file.js

@@ -1,82 +1,96 @@
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
-import { input, select } from "@inquirer/prompts";
 import { tool } from "ai";
-import chalk from "chalk";
 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, sendData, terminal, autoAcceptAll, }) => {
+export const createDeleteFileTool = async ({ workingDir, terminal, sendData, toolExecutor, }) => {
     const allowedDirectory = workingDir;
-    let autoAcceptDeletes = autoAcceptAll ?? false;
     return {
         [DeleteFileTool.name]: tool({
             description: "Delete a file permanently.",
             inputSchema: z.object({
                 path: z.string().describe("Absolute path to the file to delete"),
             }),
-            execute: async ({ path: userPath }, { toolCallId }) => {
+            execute: async ({ path: userPath }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("File deletion aborted");
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Deleting file: ${chalk.cyan(userPath)}`,
+                    data: `Deleting file: ${style.cyan(userPath)}`,
                 });
                 try {
-                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory);
+                    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${chalk.red.bold("●")} Proposing file deletion: ${chalk.cyan(userPath)}`);
+                        terminal.writeln(`\n${style.red.bold("●")} Proposing file deletion: ${style.cyan(userPath)}`);
                         terminal.lineBreak();
                         terminal.writeln("This action cannot be undone.");
                         terminal.lineBreak();
-                        let userChoice;
-                        if (autoAcceptDeletes) {
-                            terminal.writeln(chalk.green("✓ Auto-accepting deletions (all future deletions will be accepted)"));
-                            userChoice = "accept";
-                        }
-                        else {
-                            userChoice = await select({
-                                message: "What would you like to do with this file?",
-                                choices: [
-                                    { name: "Accept and delete this file", value: "accept" },
-                                    {
-                                        name: "Accept all future deletions (including this)",
-                                        value: "accept-all",
-                                    },
-                                    { name: "Reject this deletion", value: "reject" },
-                                ],
-                                default: "accept",
-                            });
+                        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") {
-                            autoAcceptDeletes = true;
-                            terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future deletions"));
+                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all deletions"));
                             terminal.lineBreak();
                         }
                         if (userChoice === "reject") {
-                            const reason = await input({ message: "Feedback: " });
                             terminal.lineBreak();
+                            const rejectionReason = reason || "No reason provided";
                             sendData?.({
                                 id: toolCallId,
                                 event: "tool-completion",
-                                data: `Deletion rejected by user. Reason: ${reason}`,
+                                data: `Deletion rejected by user. Reason: ${rejectionReason}`,
                             });
-                            return `The user rejected this deletion. Reason: ${reason}`;
+                            return `The user rejected this deletion. Reason: ${rejectionReason}`;
                         }
-                        // If accepted, proceed to delete file
                     }
-                    // Delete the file
+                    // 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,

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

@@ -1,12 +1,21 @@
+import type { TokenCounter } from "../tokens/counter.ts";
 import type { SendData } from "./types.ts";
 export declare const DirectoryTreeTool: {
     name: "directoryTree";
 };
-export declare const createDirectoryTreeTool: ({ workingDir, sendData, }: {
+export declare const createDirectoryTreeTool: ({ workingDir, sendData, tokenCounter, }: {
     workingDir: string;
     sendData?: SendData;
+    tokenCounter: TokenCounter;
 }) => Promise<{
     directoryTree: import("ai").Tool<{
         path: string;
     }, string>;
 }>;
+/**
+ * Generates a string representation of a directory tree starting from the given path.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ */
+export declare function directoryTree(dirPath: string): Promise<string>;
+//# sourceMappingURL=directory-tree.d.ts.map

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

@@ -0,0 +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"}

package/dist/tools/directory-tree.js

@@ -1,11 +1,16 @@
+import fs from "node:fs/promises";
+import path from "node:path";
 import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
-import { directoryTree, joinWorkingDir, validatePath, } from "./filesystem-utils.js";
+import { config } from "../config.js";
+import style from "../terminal/style.js";
+import { manageOutput } from "../tokens/manage-output.js";
+import ignore from "../utils/ignore.js";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const DirectoryTreeTool = {
     name: "directoryTree",
 };
-export const createDirectoryTreeTool = async ({ workingDir, sendData, }) => {
+export const createDirectoryTreeTool = async ({ workingDir, sendData, tokenCounter, }) => {
     const allowedDirectory = workingDir;
     return {
         [DirectoryTreeTool.name]: tool({
@@ -13,26 +18,104 @@ export const createDirectoryTreeTool = async ({ workingDir, sendData, }) => {
             inputSchema: z.object({
                 path: z.string().describe("The path."),
             }),
-            execute: async ({ path }, { toolCallId }) => {
+            execute: async ({ path }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("Directory tree listing aborted");
+                }
                 let validPath;
                 try {
+                    if (abortSignal?.aborted) {
+                        throw new Error("Directory tree listing aborted before path validation");
+                    }
                     sendData?.({
                         id: toolCallId,
                         event: "tool-init",
-                        data: `Listing directory tree: ${chalk.cyan(path)}`,
+                        data: `Listing directory tree: ${style.cyan(path)}`,
+                    });
+                    validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
+                    const rawTree = await directoryTree(validPath);
+                    const managed = manageOutput(rawTree, {
+                        tokenCounter,
+                        threshold: maxTokens,
                     });
-                    validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory);
+                    if (managed.truncated) {
+                        sendData?.({
+                            id: toolCallId,
+                            event: "tool-update",
+                            data: { primary: managed.warning },
+                        });
+                    }
                     sendData?.({
                         id: toolCallId,
                         event: "tool-completion",
-                        data: "Done",
+                        data: `Done (${managed.tokenCount} tokens)`,
                     });
+                    return managed.content;
                 }
                 catch (error) {
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-error",
+                        data: "Failed to show directory tree.",
+                    });
                     return `Failed to show directory tree: ${error.message}`;
                 }
-                return directoryTree(validPath);
             },
         }),
     };
 };
+/**
+ * Generates the indentation string for a given level in the directory tree.
+ * @param level - The current level in the directory tree.
+ * @param isLast - Indicates if the current item is the last in its parent directory.
+ * @returns The indentation string for the current level.
+ */
+function getIndent(level, isLast) {
+    const indent = "│   ".repeat(level - 1);
+    return level === 0 ? "" : `${indent}${isLast ? "└── " : "├── "}`;
+}
+/**
+ * Recursively generates a string representation of a directory tree.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @param level - The current level in the directory tree (default: 1).
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ * @throws Will log an error if there's an issue reading the directory.
+ */
+async function generateDirectoryTree(dirPath, ig, level = 1) {
+    const name = path.basename(dirPath);
+    let output = `${getIndent(level, false)}${name}\n`;
+    const items = await fs.readdir(dirPath);
+    const filteredItems = ig.filter(items);
+    for (let i = 0; i < filteredItems.length; i++) {
+        const item = filteredItems[i] ?? "";
+        const itemPath = path.join(dirPath, item);
+        const isLast = i === filteredItems.length - 1;
+        const stats = await fs.stat(itemPath);
+        if (stats.isDirectory()) {
+            output += await generateDirectoryTree(itemPath, ig, level + 1);
+        }
+        else {
+            output += `${getIndent(level + 1, isLast)}${item}\n`;
+        }
+    }
+    return output;
+}
+/**
+ * Generates a string representation of a directory tree starting from the given path.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ */
+export async function directoryTree(dirPath) {
+    let ig;
+    try {
+        const ignoreFile = await fs.readFile(path.join(process.cwd(), ".gitignore"));
+        ig = ignore().add(ignoreFile.toString()).add(".git");
+    }
+    catch (_error) {
+        // If .gitignore doesn't exist, create basic ignore with just .git
+        ig = ignore().add(".git");
+    }
+    return (await generateDirectoryTree(dirPath, ig)).trim();
+}

package/dist/tools/dynamic-tool-loader.d.ts

@@ -0,0 +1,12 @@
+import { type ToolMetadata } from "./dynamic-tool-parser.ts";
+import type { SendData } from "./types.ts";
+export declare function createDynamicTool(scriptPath: string, metadata: ToolMetadata, sendData?: SendData): {
+    [x: string]: import("ai").Tool<Record<string, unknown>, unknown>;
+};
+export declare function loadDynamicTools({ baseDir, sendData, }: {
+    baseDir: string;
+    sendData?: SendData;
+}): Promise<Record<string, {
+    [x: string]: import("ai").Tool<Record<string, unknown>, unknown>;
+}>>;
+//# sourceMappingURL=dynamic-tool-loader.d.ts.map

package/dist/tools/dynamic-tool-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAQA,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAwF3C,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,YAAY,EACtB,QAAQ,CAAC,EAAE,QAAQ;;EAuJpB;AAED,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;;IAgEA"}