@travisennis/acai 0.0.4 → 0.0.5

package/dist/tools/dynamic-tool-loader.js

@@ -0,0 +1,280 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+import { config } from "../config.js";
+import { logger } from "../logger.js";
+import { parseToolMetadata } from "./dynamic-tool-parser.js";
+function generateZodSchema(parameters) {
+    const fields = {};
+    for (const param of parameters) {
+        let schema;
+        switch (param.type) {
+            case "string":
+                schema = z.string();
+                break;
+            case "number":
+                schema = z.coerce.number();
+                break;
+            case "boolean":
+                schema = z.coerce.boolean();
+                break;
+            default:
+                continue;
+        }
+        if (!param.required) {
+            schema = schema.optional();
+        }
+        if (param.default !== undefined) {
+            schema = schema.default(param.default);
+        }
+        fields[param.name] = schema.describe(param.description);
+    }
+    return z.object(fields);
+}
+async function getMetadata(scriptPath) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            // Find the node executable path
+            const nodePath = process.execPath;
+            child = spawn(nodePath, [scriptPath], {
+                env: {
+                    ...process.env,
+                    // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
+                    TOOL_ACTION: "describe",
+                    // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
+                    NODE_ENV: "production",
+                },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (e) {
+            logger.error(`Failed to spawn ${scriptPath}: ${e}`);
+            resolve(null);
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                logger.error(`Script ${scriptPath} failed to describe: ${stderr}`);
+                resolve(null);
+                return;
+            }
+            try {
+                const metadata = parseToolMetadata(stdout);
+                resolve(metadata);
+            }
+            catch (e) {
+                logger.error(`Failed to parse metadata from ${scriptPath}: ${String(e)}`);
+                resolve(null);
+            }
+        });
+        child.on("error", (err) => {
+            logger.error(`Spawn error for ${scriptPath}: ${err}`);
+            resolve(null);
+        });
+    });
+}
+export function createDynamicTool(scriptPath, metadata, sendData) {
+    const inputSchema = generateZodSchema(metadata.parameters);
+    const toolName = `dynamic-${metadata.name}`;
+    return {
+        [toolName]: tool({
+            description: metadata.description,
+            inputSchema,
+            execute: async (params, { toolCallId, abortSignal }) => {
+                if (abortSignal?.aborted) {
+                    throw new Error("Execution aborted");
+                }
+                sendData?.({
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `Executing dynamic tool: ${metadata.name}`,
+                });
+                // Validate params again for safety
+                try {
+                    inputSchema.parse(params);
+                }
+                catch (e) {
+                    const errMsg = `Invalid parameters for tool ${metadata.name}: ${e.message}`;
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-error",
+                        data: errMsg,
+                    });
+                    throw new Error(errMsg);
+                }
+                const paramsArray = Object.entries(params).map(([name, value]) => ({
+                    name,
+                    value,
+                }));
+                const paramsJson = JSON.stringify(paramsArray);
+                return new Promise((resolve) => {
+                    const child = spawn(process.execPath, [scriptPath], {
+                        cwd: path.dirname(scriptPath),
+                        env: {
+                            ...process.env,
+                            // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
+                            TOOL_ACTION: "execute",
+                            // biome-ignore lint/style/useNamingConvention: Environment variables are conventionally uppercase
+                            NODE_ENV: "production",
+                        },
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                    let stdout = "";
+                    let stderr = "";
+                    let hasTimedOut = false;
+                    const timer = setTimeout(() => {
+                        hasTimedOut = true;
+                        child.kill();
+                        sendData?.({
+                            id: toolCallId,
+                            event: "tool-update",
+                            data: { primary: "Execution timed out after 30 seconds" },
+                        });
+                        resolve("Execution timed out after 30 seconds");
+                    }, 30000);
+                    child.stdin.write(`${paramsJson}\n`);
+                    child.stdin.end();
+                    child.stdout.on("data", (data) => {
+                        stdout += data.toString();
+                    });
+                    child.stderr.on("data", (data) => {
+                        stderr += data.toString();
+                    });
+                    child.on("close", (code) => {
+                        clearTimeout(timer);
+                        if (hasTimedOut)
+                            return;
+                        if (code !== 0) {
+                            const errorMsg = `Dynamic tool ${metadata.name} failed: ${stderr || `Exited with code ${code}`}`;
+                            sendData?.({
+                                id: toolCallId,
+                                event: "tool-error",
+                                data: errorMsg,
+                            });
+                            resolve(errorMsg);
+                        }
+                        else {
+                            let output = stdout.trim();
+                            const maxOutputBytes = 2000000;
+                            if (output.length > maxOutputBytes) {
+                                output = `${output.substring(0, maxOutputBytes)}\n[Output truncated]`;
+                            }
+                            // If no stdout, prefer stderr so callers get useful info
+                            const errText = stderr.trim();
+                            if (!output && errText) {
+                                output = errText;
+                            }
+                            // Fallback to a non-empty placeholder to satisfy callers
+                            if (!output) {
+                                output = `[No output from dynamic tool ${metadata.name}]`;
+                            }
+                            // Send tool-update event with last 20 lines of output
+                            const outputLines = output.split("\n");
+                            const lastLines = outputLines.slice(-20).join("\n");
+                            sendData?.({
+                                id: toolCallId,
+                                event: "tool-update",
+                                data: {
+                                    primary: `Last 20 lines of output from ${metadata.name}:`,
+                                    secondary: lastLines.split("\n"),
+                                },
+                            });
+                            // Attempt to parse as JSON if structured
+                            if (output &&
+                                (output.startsWith("{") || output.startsWith("["))) {
+                                try {
+                                    resolve(JSON.parse(output));
+                                }
+                                catch {
+                                    resolve(output);
+                                }
+                            }
+                            else {
+                                resolve(output);
+                            }
+                            sendData?.({
+                                id: toolCallId,
+                                event: "tool-completion",
+                                data: `Dynamic tool ${metadata.name} completed`,
+                            });
+                        }
+                    });
+                    if (abortSignal) {
+                        abortSignal.addEventListener("abort", () => {
+                            child.kill();
+                        });
+                    }
+                });
+            },
+        }),
+    };
+}
+export async function loadDynamicTools({ baseDir, sendData, }) {
+    const projectConfig = await config.readProjectConfig();
+    const dynamicConfig = projectConfig.tools.dynamicTools;
+    if (!dynamicConfig.enabled) {
+        logger.info("Dynamic tools disabled in config.");
+        return {};
+    }
+    const projectToolsDir = path.join(baseDir, ".acai", "tools");
+    const userToolsDir = path.join(os.homedir(), ".acai", "tools");
+    const toolMap = new Map();
+    const scanDir = async (dir, isProject = false) => {
+        if (!fs.existsSync(dir))
+            return;
+        try {
+            const files = fs
+                .readdirSync(dir)
+                .filter((f) => f.endsWith(".js") || f.endsWith(".mjs"));
+            for (const file of files) {
+                const scriptPath = path.join(dir, file);
+                try {
+                    const metadata = await getMetadata(scriptPath);
+                    if (metadata) {
+                        toolMap.set(metadata.name, { path: scriptPath, metadata });
+                        logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name}`);
+                    }
+                    else {
+                        logger.warn(`Skipped invalid tool: ${file}`);
+                    }
+                }
+                catch (e) {
+                    logger.error(`Error scanning ${file}: ${e}`);
+                }
+            }
+        }
+        catch (e) {
+            logger.error(`Error reading dir ${dir}: ${e}`);
+        }
+    };
+    // Scan user first, then project to let project override
+    await scanDir(userToolsDir, false);
+    await scanDir(projectToolsDir, true);
+    // Enforce maxTools, preferring recent (project) entries
+    if (toolMap.size > dynamicConfig.maxTools) {
+        logger.warn(`Warning: ${toolMap.size} dynamic tools found, limiting to ${dynamicConfig.maxTools}`);
+        const entries = Array.from(toolMap.entries());
+        const limitedEntries = entries.slice(-dynamicConfig.maxTools);
+        toolMap.clear();
+        for (const [name, value] of limitedEntries) {
+            toolMap.set(name, value);
+        }
+    }
+    const tools = {};
+    for (const [_, { path, metadata }] of toolMap) {
+        Object.assign(tools, createDynamicTool(path, metadata, sendData));
+    }
+    return tools;
+}

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+declare const toolMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ToolMetadata = z.infer<typeof toolMetadataSchema>;
+export declare function parseToolMetadata(output: string): ToolMetadata;
+export {};
+//# sourceMappingURL=dynamic-tool-parser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-tool-parser.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;iBAYtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D"}

package/dist/tools/dynamic-tool-parser.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+const toolMetadataSchema = z.object({
+    name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_-]*$/),
+    description: z.string().min(1),
+    parameters: z.array(z.object({
+        name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_-]*$/),
+        type: z.enum(["string", "number", "boolean"]),
+        description: z.string().min(1),
+        required: z.boolean().default(true),
+        default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+    })),
+});
+export function parseToolMetadata(output) {
+    try {
+        const parsed = JSON.parse(output.trim());
+        return toolMetadataSchema.parse(parsed);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse tool metadata: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

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

@@ -1,13 +1,14 @@
 import type { Terminal } from "../terminal/index.ts";
+import type { ToolExecutor } from "../tool-executor.ts";
 import type { SendData } from "./types.ts";
 export declare const EditFileTool: {
     name: "editFile";
 };
-export declare const createEditFileTool: ({ workingDir, terminal, sendData, autoAcceptAll, }: {
+export declare const createEditFileTool: ({ workingDir, terminal, sendData, toolExecutor, }: {
     workingDir: string;
     terminal?: Terminal;
     sendData?: SendData;
-    autoAcceptAll: boolean;
+    toolExecutor?: ToolExecutor;
 }) => Promise<{
     editFile: import("ai").Tool<{
         path: string;
@@ -17,3 +18,10 @@ export declare const createEditFileTool: ({ workingDir, terminal, sendData, auto
         }[];
     }, string>;
 }>;
+interface FileEdit {
+    oldText: string;
+    newText: string;
+}
+export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean, abortSignal?: AbortSignal): Promise<string>;
+export {};
+//# sourceMappingURL=edit-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-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,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,mDAKtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;;;EA+JA,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAmEjB"}

package/dist/tools/edit-file.js

@@ -1,71 +1,85 @@
-import { input, select } from "@inquirer/prompts";
+import { readFile, writeFile } from "node:fs/promises";
 import { tool } from "ai";
-import chalk from "chalk";
+import { createTwoFilesPatch } from "diff";
 import { z } from "zod";
-import { applyFileEdits, joinWorkingDir, validatePath, } from "./filesystem-utils.js";
+import style from "../terminal/style.js";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const EditFileTool = {
     name: "editFile",
 };
-export const createEditFileTool = async ({ workingDir, terminal, sendData, autoAcceptAll, }) => {
+export const createEditFileTool = async ({ workingDir, terminal, sendData, toolExecutor, }) => {
     const allowedDirectory = workingDir;
-    let autoAcceptEdits = autoAcceptAll;
     return {
         [EditFileTool.name]: tool({
             description: "Make line-based edits to a text file. Each edit replaces exact line sequences " +
-                "with new content. Returns a git-style diff showing the changes made. " +
-                "Only works within allowed directories.",
+                "with new content. Exact literal matching is used: no whitespace, indentation, escape, or newline normalization is applied when locating matches. " +
+                "Provide enough context so the match is unique; otherwise the operation errors. Returns a git-style diff showing the changes made. " +
+                "Only works within allowed directories. " +
+                "Note: Special characters in oldText must be properly escaped for JSON (e.g., backticks as \\`...\\`). " +
+                "Multi-line strings require exact character-by-character matching including whitespace.",
             inputSchema: z.object({
                 path: z.string().describe("The path of the file to edit."),
                 edits: z.array(z.object({
                     oldText: z
                         .string()
-                        .describe("Text to search for - must match exactly and enough context must be provided to uniquely match the target text"),
+                        .describe("Text to search for - must match exactly and enough context must be provided to uniquely match the target text. " +
+                        "Special characters require JSON escaping: backticks (\\`...\\`), quotes, backslashes. " +
+                        "For multi-line content, include exact newlines and indentation."),
                     newText: z.string().describe("Text to replace with"),
                 })),
             }),
-            execute: async ({ path, edits }, { toolCallId }) => {
+            execute: async ({ path, edits }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("File editing aborted");
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Editing file: ${chalk.cyan(path)}`,
+                    data: `Editing file: ${style.cyan(path)}`,
                 });
                 try {
-                    const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory);
+                    const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
                     if (terminal) {
-                        terminal.writeln(`\n${chalk.blue.bold("●")} Proposing file changes: ${chalk.cyan(path)}`);
-                        terminal.lineBreak();
-                        const result = await applyFileEdits(validPath, edits, true);
-                        terminal.writeln(`The agent is proposing the following ${chalk.cyan(edits.length)} edits:`);
+                        terminal.writeln(`\n${style.blue.bold("●")} Proposing file changes: ${style.cyan(path)}`);
                         terminal.lineBreak();
+                        const result = await applyFileEdits(validPath, edits, true, abortSignal);
+                        terminal.writeln(`The agent is proposing the following ${style.cyan(edits.length)} edits:`);
+                        terminal.hr();
                         terminal.display(result);
-                        terminal.lineBreak();
-                        let userChoice;
-                        if (autoAcceptEdits) {
-                            terminal.writeln(chalk.green("✓ Auto-accepting edits (all future edits will be accepted)"));
-                            userChoice = "accept";
-                        }
-                        else {
-                            userChoice = await select({
+                        terminal.hr();
+                        let userResponse;
+                        if (toolExecutor) {
+                            const ctx = {
+                                toolName: EditFileTool.name,
+                                toolCallId,
                                 message: "What would you like to do with these changes?",
-                                choices: [
-                                    { name: "Accept these changes", value: "accept" },
-                                    {
-                                        name: "Accept all future edits (including these)",
-                                        value: "accept-all",
-                                    },
-                                    { name: "Reject these changes", value: "reject" },
-                                ],
-                                default: "accept",
-                            });
+                                choices: {
+                                    accept: "Accept these changes",
+                                    acceptAll: "Accept all future edits (including these)",
+                                    reject: "Reject these changes",
+                                },
+                            };
+                            try {
+                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
+                            }
+                            catch (e) {
+                                if (e.name === "AbortError") {
+                                    throw new Error("File editing aborted during user input");
+                                }
+                                throw e;
+                            }
                         }
+                        const { result: userChoice, reason } = userResponse ?? {
+                            result: "accept",
+                        };
                         terminal.lineBreak();
                         if (userChoice === "accept-all") {
-                            autoAcceptEdits = true;
-                            terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future edits"));
+                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all edits"));
                             terminal.lineBreak();
                         }
                         if (userChoice === "accept" || userChoice === "accept-all") {
-                            const finalEdits = await applyFileEdits(validPath, edits, false);
+                            const finalEdits = await applyFileEdits(validPath, edits, false, abortSignal);
                             // Send completion message indicating success
                             sendData?.({
                                 id: toolCallId,
@@ -74,17 +88,17 @@ export const createEditFileTool = async ({ workingDir, terminal, sendData, autoA
                             });
                             return finalEdits;
                         }
-                        const reason = await input({ message: "Feedback: " });
                         terminal.lineBreak();
                         // Send completion message indicating rejection
+                        const rejectionReason = reason || "No reason provided";
                         sendData?.({
                             id: toolCallId,
                             event: "tool-completion",
-                            data: `Edits rejected by user. Reason: ${reason}`,
+                            data: `Edits rejected by user. Reason: ${rejectionReason}`,
                         });
-                        return `The user rejected these changes. Reason: ${reason}`;
+                        return `The user rejected these changes. Reason: ${rejectionReason}`;
                     }
-                    const finalEdits = await applyFileEdits(validPath, edits, false);
+                    const finalEdits = await applyFileEdits(validPath, edits, false, abortSignal);
                     // Send completion message indicating success
                     sendData?.({
                         id: toolCallId,
@@ -105,3 +119,66 @@ export const createEditFileTool = async ({ workingDir, terminal, sendData, autoA
         }),
     };
 };
+// file editing and diffing utilities
+function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+function createUnifiedDiff(originalContent, newContent, filepath = "file") {
+    // Ensure consistent line endings for diff
+    const normalizedOriginal = normalizeLineEndings(originalContent);
+    const normalizedNew = normalizeLineEndings(newContent);
+    return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
+}
+export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal) {
+    if (abortSignal?.aborted) {
+        throw new Error("File edit operation aborted");
+    }
+    // Read file content literally with signal
+    const originalContent = await readFile(filePath, {
+        encoding: "utf-8",
+        signal: abortSignal,
+    });
+    if (edits.find((edit) => edit.oldText.length === 0)) {
+        throw new Error("Invalid oldText in edit. The value of oldText must be at least one character");
+    }
+    // Apply edits sequentially using strict literal, unique matches
+    let modifiedContent = originalContent;
+    for (const edit of edits) {
+        if (abortSignal?.aborted) {
+            throw new Error("File edit operation aborted during processing");
+        }
+        const { oldText, newText } = edit; // Use literal oldText and newText
+        // Strict literal match: find exactly one occurrence without any normalization
+        const firstIndex = modifiedContent.indexOf(oldText);
+        if (firstIndex === -1) {
+            throw new Error("oldText not found in content");
+        }
+        const secondIndex = modifiedContent.indexOf(oldText, firstIndex + oldText.length);
+        if (secondIndex !== -1) {
+            throw new Error("oldText found multiple times and requires more code context to uniquely identify the intended match");
+        }
+        modifiedContent =
+            modifiedContent.slice(0, firstIndex) +
+                newText +
+                modifiedContent.slice(firstIndex + oldText.length);
+    }
+    // Create unified diff (createUnifiedDiff normalizes line endings internally for diffing)
+    const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
+    // Format diff with appropriate number of backticks
+    let numBackticks = 3;
+    while (diff.includes("`".repeat(numBackticks))) {
+        numBackticks++;
+    }
+    const formattedDiff = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
+    if (!dryRun) {
+        if (abortSignal?.aborted) {
+            throw new Error("File edit operation aborted before writing");
+        }
+        // Write the modified content with signal
+        await writeFile(filePath, modifiedContent, {
+            encoding: "utf-8",
+            signal: abortSignal,
+        });
+    }
+    return formattedDiff;
+}

package/dist/tools/file-editing-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function replace(content: string, oldString: string, newString: string, replaceAll?: boolean): string;
+//# sourceMappingURL=file-editing-utils.d.ts.map

package/dist/tools/file-editing-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-editing-utils.d.ts","sourceRoot":"","sources":["../../source/tools/file-editing-utils.ts"],"names":[],"mappings":"AA6HA,wBAAgB,OAAO,CACrB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,UAAU,UAAQ,GACjB,MAAM,CAmCR"}