@travisennis/acai 0.0.11 → 0.0.13

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

@@ -18,7 +18,166 @@ const toolMetadataSchema = z.object({
     })),
     needsApproval: z.boolean().default(true),
 });
-export function parseToolMetadata(output) {
+const KNOWN_EXTENSIONS = [
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".py",
+    ".rb",
+    ".tool",
+];
+const EXTENSION_INTERPRETER_MAP = {
+    ".js": process.execPath,
+    ".mjs": process.execPath,
+    ".cjs": process.execPath,
+    ".sh": "/bin/bash",
+    ".bash": "/bin/bash",
+    ".zsh": "/bin/zsh",
+    ".py": "python3",
+    ".rb": "ruby",
+};
+export function getShebang(scriptPath) {
+    try {
+        const fd = fs.openSync(scriptPath, "r");
+        const buffer = Buffer.alloc(256);
+        const bytesRead = fs.readSync(fd, buffer, 0, 256, 0);
+        fs.closeSync(fd);
+        const content = buffer.toString("utf8", 0, bytesRead);
+        if (content.startsWith("#!")) {
+            return content.slice(2).trim().split("\n")[0].trim();
+        }
+    }
+    catch {
+        // Can't read file, skip
+    }
+    return null;
+}
+export function parseShebang(shebang, scriptPath) {
+    if (shebang.startsWith("/usr/bin/env ")) {
+        const interpreter = shebang
+            .slice("/usr/bin/env ".length)
+            .trim()
+            .split(" ")[0];
+        return { command: interpreter, args: [scriptPath] };
+    }
+    const parts = shebang.split(" ");
+    return { command: parts[0], args: [...parts.slice(1), scriptPath] };
+}
+export function resolveToolInterpreter(scriptPath) {
+    // 1. Check shebang
+    const shebang = getShebang(scriptPath);
+    if (shebang) {
+        return parseShebang(shebang, scriptPath);
+    }
+    // 2. Check extension
+    const ext = path.extname(scriptPath).toLowerCase();
+    if (EXTENSION_INTERPRETER_MAP[ext]) {
+        return { command: EXTENSION_INTERPRETER_MAP[ext], args: [scriptPath] };
+    }
+    // 3. Extensionless executable
+    if (!ext) {
+        try {
+            const stats = fs.statSync(scriptPath);
+            if (stats.mode & 0o111) {
+                return { command: scriptPath, args: [] };
+            }
+        }
+        catch {
+            // File doesn't exist or can't stat, skip
+        }
+    }
+    return null;
+}
+export function parseTextSchema(content) {
+    const lines = content
+        .trim()
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l && !l.startsWith("#") && !l.startsWith("//"));
+    let name;
+    let description;
+    const parameters = [];
+    for (const line of lines) {
+        if (line.startsWith("name:")) {
+            name = line.slice(5).trim();
+            continue;
+        }
+        if (line.startsWith("description:")) {
+            description = line.slice(12).trim();
+            continue;
+        }
+        const param = parseTextSchemaParameter(line);
+        if (param) {
+            parameters.push(param);
+        }
+    }
+    if (!name || !description) {
+        logger.warn("Text schema missing required name or description");
+        return null;
+    }
+    if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
+        logger.warn(`Invalid tool name: ${name}`);
+        return null;
+    }
+    return {
+        name,
+        description,
+        parameters,
+        needsApproval: true,
+    };
+}
+/**
+ * Parse a single line as a text schema parameter definition.
+ * Supports formats:
+ *   - "paramName: type [optional|required] description"
+ *   - "paramName: [optional|required] description" (type defaults to string)
+ *   - "paramName: description" (type defaults to string, required)
+ */
+function parseTextSchemaParameter(line) {
+    // Parse parameters: "paramName: type [optional|required] description text"
+    const fullMatch = line.match(/^(\w+):\s*(string|number|boolean)\s+(optional|required)?\s*(.*)$/);
+    if (fullMatch) {
+        const [, paramName, paramType, requirement, paramDescription] = fullMatch;
+        return {
+            name: paramName,
+            type: paramType,
+            description: paramDescription || `Parameter ${paramName}`,
+            required: requirement !== "optional",
+        };
+    }
+    // Handle params without type keyword (default to string)
+    const simpleMatch = line.match(/^(\w+):\s*(.*)$/);
+    if (!simpleMatch) {
+        return null;
+    }
+    const [, paramName, rest] = simpleMatch;
+    const typeMatch = rest.match(/^(string|number|boolean)\s*(.*)$/);
+    if (typeMatch) {
+        const [, paramType, afterType] = typeMatch;
+        const optMatch = afterType.match(/^(optional|required)\s*(.*)$/);
+        return {
+            name: paramName,
+            type: paramType,
+            description: optMatch
+                ? optMatch[2] || `Parameter ${paramName}`
+                : afterType || `Parameter ${paramName}`,
+            required: optMatch?.[1] !== "optional",
+        };
+    }
+    const optMatch = rest.match(/^(optional|required)\s*(.*)$/);
+    return {
+        name: paramName,
+        type: "string",
+        description: optMatch
+            ? optMatch[2] || rest
+            : rest || `Parameter ${paramName}`,
+        required: optMatch?.[1] !== "optional",
+    };
+}
+function parseToolMetadata(output) {
     try {
         const parsed = JSON.parse(output.trim());
         return toolMetadataSchema.parse(parsed);
@@ -58,20 +217,29 @@ function generateZodSchema(parameters) {
     }
     return z.object(fields);
 }
-async function getMetadata(scriptPath) {
+async function getMetadata(scriptPath, sessionContext) {
+    const interpreter = resolveToolInterpreter(scriptPath);
+    if (!interpreter) {
+        logger.warn(`No valid interpreter for ${scriptPath}, skipping.`);
+        return null;
+    }
     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",
-                },
+            const 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",
+            };
+            if (sessionContext) {
+                env["ACAI_SESSION_ID"] = sessionContext.sessionId;
+                env["ACAI_PROJECT_DIR"] = sessionContext.projectDir;
+                env["ACAI_AGENT_NAME"] = sessionContext.agentName;
+            }
+            child = spawn(interpreter.command, interpreter.args, {
+                env,
                 stdio: ["ignore", "pipe", "pipe"],
             });
         }
@@ -96,11 +264,18 @@ async function getMetadata(scriptPath) {
             }
             try {
                 const metadata = parseToolMetadata(stdout);
-                resolve(metadata);
+                resolve({ ...metadata, format: "json" });
             }
-            catch (e) {
-                logger.error(`Failed to parse metadata from ${scriptPath}: ${String(e)}`);
-                resolve(null);
+            catch {
+                // JSON parse failed, try text format
+                const textMetadata = parseTextSchema(stdout);
+                if (textMetadata) {
+                    resolve({ ...textMetadata, format: "text" });
+                }
+                else {
+                    logger.error(`Failed to parse metadata from ${scriptPath}: not valid JSON or text format`);
+                    resolve(null);
+                }
             }
         });
         child.on("error", (err) => {
@@ -109,22 +284,70 @@ async function getMetadata(scriptPath) {
         });
     });
 }
-async function spawnChildProcess(scriptPath, params, abortSignal) {
-    const paramsArray = Object.entries(params).map(([name, value]) => ({
-        name,
-        value,
-    }));
-    const paramsJson = JSON.stringify(paramsArray);
+/**
+ * Processes child process stdout/stderr into a result string.
+ * Trims, truncates oversized output, falls back to stderr or a placeholder,
+ * and attempts JSON parsing for structured output.
+ */
+export function processChildOutput(stdout, stderr) {
+    const maxOutputBytes = 2_000_000;
+    let output = stdout.trim();
+    if (output.length > maxOutputBytes) {
+        output = `${output.substring(0, maxOutputBytes)}\n[Output truncated]`;
+    }
+    if (!output) {
+        const errText = stderr.trim();
+        if (errText) {
+            output = errText;
+        }
+    }
+    if (!output) {
+        output = "[No output from dynamic tool]";
+    }
+    if (output.startsWith("{") || output.startsWith("[")) {
+        try {
+            return JSON.stringify(JSON.parse(output));
+        }
+        catch {
+            return output;
+        }
+    }
+    return output;
+}
+async function spawnChildProcess(scriptPath, params, abortSignal, sessionContext, format = "json") {
+    const interpreter = resolveToolInterpreter(scriptPath);
+    if (!interpreter) {
+        throw new Error(`No valid interpreter for ${scriptPath}`);
+    }
+    let paramsInput;
+    if (format === "text") {
+        paramsInput = `${Object.entries(params)
+            .map(([key, value]) => `${key}=${value}`)
+            .join("\n")}\n`;
+    }
+    else {
+        const paramsArray = Object.entries(params).map(([name, value]) => ({
+            name,
+            value,
+        }));
+        paramsInput = `${JSON.stringify(paramsArray)}\n`;
+    }
+    const 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",
+    };
+    if (sessionContext) {
+        env["ACAI_SESSION_ID"] = sessionContext.sessionId;
+        env["ACAI_PROJECT_DIR"] = sessionContext.projectDir;
+        env["ACAI_AGENT_NAME"] = sessionContext.agentName;
+    }
     return new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, [scriptPath], {
+        const child = spawn(interpreter.command, interpreter.args, {
             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",
-            },
+            env,
             stdio: ["pipe", "pipe", "pipe"],
         });
         let stdout = "";
@@ -135,7 +358,7 @@ async function spawnChildProcess(scriptPath, params, abortSignal) {
             child.kill();
             reject(new Error("Execution timed out after 30 seconds"));
         }, 30000);
-        child.stdin.write(`${paramsJson}\n`);
+        child.stdin.write(paramsInput);
         child.stdin.end();
         child.stdout.on("data", (data) => {
             stdout += data.toString();
@@ -147,32 +370,7 @@ async function spawnChildProcess(scriptPath, params, abortSignal) {
             clearTimeout(timer);
             if (hasTimedOut)
                 return;
-            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]";
-            }
-            // Attempt to parse as JSON if structured
-            if (output && (output.startsWith("{") || output.startsWith("["))) {
-                try {
-                    resolve(JSON.stringify(JSON.parse(output)));
-                }
-                catch {
-                    resolve(output);
-                }
-            }
-            else {
-                resolve(output);
-            }
+            resolve(processChildOutput(stdout, stderr));
         });
         if (abortSignal) {
             abortSignal.addEventListener("abort", () => {
@@ -181,9 +379,10 @@ async function spawnChildProcess(scriptPath, params, abortSignal) {
         }
     });
 }
-function createDynamicTool(scriptPath, metadata) {
+function createDynamicTool(scriptPath, metadata, sessionContext) {
     const inputSchema = generateZodSchema(metadata.parameters);
     const toolName = metadata.name;
+    const format = metadata.format;
     return {
         [toolName]: {
             toolDef: {
@@ -193,7 +392,7 @@ function createDynamicTool(scriptPath, metadata) {
             display() {
                 return "running";
             },
-            async execute(input, { abortSignal }) {
+            async execute(input, { abortSignal, sessionContext: executionContext }) {
                 if (abortSignal?.aborted) {
                     throw new Error("Execution aborted");
                 }
@@ -203,12 +402,36 @@ function createDynamicTool(scriptPath, metadata) {
                 catch (e) {
                     throw new Error(`Invalid parameters for tool ${metadata.name}: ${e.message}`);
                 }
-                return spawnChildProcess(scriptPath, input, abortSignal);
+                // Prefer execution-time context over load-time context
+                const context = executionContext ?? sessionContext;
+                return spawnChildProcess(scriptPath, input, abortSignal, context, format);
             },
         },
     };
 }
-export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
+function findCompanion(dir, baseName) {
+    const companionExtensions = [
+        ".sh",
+        ".bash",
+        ".zsh",
+        ".py",
+        ".rb",
+        ".js",
+        ".mjs",
+        ".cjs",
+        "",
+    ];
+    for (const ext of companionExtensions) {
+        const candidate = path.join(dir, baseName + ext);
+        if (fs.existsSync(candidate)) {
+            const interpreter = resolveToolInterpreter(candidate);
+            if (interpreter)
+                return candidate;
+        }
+    }
+    return null;
+}
+export async function loadDynamicTools({ baseDir, existingToolNames = [], sessionContext, }) {
     const projectConfig = await config.getConfig();
     const dynamicConfig = projectConfig.tools.dynamicTools;
     if (!dynamicConfig.enabled) {
@@ -218,30 +441,86 @@ export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
     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);
+    const filterEligibleFiles = (dir) => {
+        return fs.readdirSync(dir).filter((f) => {
+            if (KNOWN_EXTENSIONS.some((ext) => f.endsWith(ext))) {
+                return true;
+            }
+            if (!path.extname(f)) {
+                const fullPath = path.join(dir, f);
                 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}`);
-                    }
+                    const stats = fs.statSync(fullPath);
+                    if (stats.mode & 0o111)
+                        return true;
                 }
-                catch (e) {
-                    logger.error(`Error scanning ${file}: ${e}`);
+                catch {
+                    // Can't stat, skip
+                }
+            }
+            return false;
+        });
+    };
+    const loadScriptTools = async (dir, files, isProject) => {
+        for (const file of files) {
+            if (file.endsWith(".tool"))
+                continue;
+            const scriptPath = path.join(dir, file);
+            try {
+                const metadata = await getMetadata(scriptPath, sessionContext);
+                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}`);
+            }
+        }
+    };
+    const loadDotToolFiles = async (dir, isProject) => {
+        const allDirFiles = fs.readdirSync(dir);
+        const allToolFiles = allDirFiles.filter((f) => f.endsWith(".tool"));
+        for (const toolFile of allToolFiles) {
+            const toolPath = path.join(dir, toolFile);
+            try {
+                const content = fs.readFileSync(toolPath, "utf8");
+                const metadata = parseTextSchema(content);
+                if (!metadata) {
+                    logger.warn(`Failed to parse .tool file: ${toolFile}`);
+                    continue;
                 }
+                const baseName = toolFile.slice(0, -5);
+                const companionPath = findCompanion(dir, baseName);
+                if (!companionPath) {
+                    logger.warn(`No companion executable found for ${toolFile}`);
+                    continue;
+                }
+                const metadataWithFormat = {
+                    ...metadata,
+                    format: "text",
+                };
+                toolMap.set(metadata.name, {
+                    path: companionPath,
+                    metadata: metadataWithFormat,
+                });
+                logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name} (from .tool file)`);
+            }
+            catch (e) {
+                logger.error(`Error reading .tool file ${toolFile}: ${e}`);
             }
         }
+    };
+    const scanDir = async (dir, isProject = false) => {
+        if (!fs.existsSync(dir))
+            return;
+        try {
+            const files = filterEligibleFiles(dir);
+            await loadScriptTools(dir, files, isProject);
+            await loadDotToolFiles(dir, isProject);
+        }
         catch (e) {
             logger.error(`Error reading dir ${dir}: ${e}`);
         }
@@ -274,7 +553,7 @@ export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
             logger.warn(`Duplicate dynamic tool name '${toolName}' found. Skipping duplicate.`);
             continue;
         }
-        Object.assign(tools, createDynamicTool(path, metadata));
+        Object.assign(tools, createDynamicTool(path, metadata, sessionContext));
     }
     if (conflictingTools.length > 0) {
         logger.warn(`Warning: ${conflictingTools.length} dynamic tool(s) skipped due to name conflicts: ${conflictingTools.join(", ")}`);

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

@@ -6,7 +6,7 @@ export declare const EditFileTool: {
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
-    edits: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
+    edits: z.ZodPreprocess<z.ZodArray<z.ZodObject<{
         oldText: z.ZodString;
         newText: z.ZodString;
     }, z.core.$strip>>>;
@@ -19,7 +19,7 @@ export declare const createEditFileTool: (options: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodString;
-            edits: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodObject<{
+            edits: z.ZodPreprocess<z.ZodArray<z.ZodObject<{
                 oldText: z.ZodString;
                 newText: z.ZodString;
             }, z.core.$strip>>>;