@travisennis/acai 0.0.10 → 0.0.12

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

@@ -18,6 +18,156 @@ const toolMetadataSchema = z.object({
     })),
     needsApproval: z.boolean().default(true),
 });
+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;
+        }
+        // Parse parameters: "paramName: type [optional|required] description text"
+        const paramMatch = line.match(/^(\w+):\s*(string|number|boolean)\s+(optional|required)?\s*(.*)$/);
+        if (paramMatch) {
+            const [, paramName, paramType, requirement, paramDescription] = paramMatch;
+            parameters.push({
+                name: paramName,
+                type: paramType,
+                description: paramDescription || `Parameter ${paramName}`,
+                required: requirement !== "optional",
+            });
+            continue;
+        }
+        // Handle params without type keyword (default to string)
+        const simpleMatch = line.match(/^(\w+):\s*(.*)$/);
+        if (simpleMatch &&
+            !line.startsWith("name:") &&
+            !line.startsWith("description:")) {
+            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*(.*)$/);
+                parameters.push({
+                    name: paramName,
+                    type: paramType,
+                    description: optMatch
+                        ? optMatch[2] || `Parameter ${paramName}`
+                        : afterType || `Parameter ${paramName}`,
+                    required: !optMatch || optMatch[1] !== "optional",
+                });
+            }
+            else {
+                const optMatch = rest.match(/^(optional|required)\s*(.*)$/);
+                parameters.push({
+                    name: paramName,
+                    type: "string",
+                    description: optMatch
+                        ? optMatch[2] || rest
+                        : rest || `Parameter ${paramName}`,
+                    required: !optMatch || optMatch[1] !== "optional",
+                });
+            }
+        }
+    }
+    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,
+    };
+}
 export function parseToolMetadata(output) {
     try {
         const parsed = JSON.parse(output.trim());
@@ -58,20 +208,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 +255,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 +275,40 @@ 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);
+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 +319,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();
@@ -181,9 +365,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 +378,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 +388,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) {
@@ -222,13 +431,32 @@ export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
         if (!fs.existsSync(dir))
             return;
         try {
-            const files = fs
-                .readdirSync(dir)
-                .filter((f) => f.endsWith(".js") || f.endsWith(".mjs"));
+            const files = fs.readdirSync(dir).filter((f) => {
+                // Known extensions
+                if (KNOWN_EXTENSIONS.some((ext) => f.endsWith(ext))) {
+                    return true;
+                }
+                // Extensionless files that are executable
+                if (!path.extname(f)) {
+                    const fullPath = path.join(dir, f);
+                    try {
+                        const stats = fs.statSync(fullPath);
+                        if (stats.mode & 0o111)
+                            return true;
+                    }
+                    catch {
+                        // Can't stat, skip
+                    }
+                }
+                return false;
+            });
             for (const file of files) {
+                // Skip .tool files, they are handled separately
+                if (file.endsWith(".tool"))
+                    continue;
                 const scriptPath = path.join(dir, file);
                 try {
-                    const metadata = await getMetadata(scriptPath);
+                    const metadata = await getMetadata(scriptPath, sessionContext);
                     if (metadata) {
                         toolMap.set(metadata.name, { path: scriptPath, metadata });
                         logger.info(`Loaded ${isProject ? "project" : "user"} tool: ${metadata.name}`);
@@ -241,6 +469,38 @@ export async function loadDynamicTools({ baseDir, existingToolNames = [], }) {
                     logger.error(`Error scanning ${file}: ${e}`);
                 }
             }
+            // Scan for .tool files (text schema with companion executable)
+            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); // Remove .tool extension
+                    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}`);
+                }
+            }
         }
         catch (e) {
             logger.error(`Error reading dir ${dir}: ${e}`);
@@ -274,7 +534,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>>>;

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

@@ -1 +1 @@
-{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAIF,QAAA,MAAM,WAAW;;;;;;iBAqCf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;6BAY4B,mBAAmB;6BAKzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC;AAiDF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAwDD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CA6CjB"}
+{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAIF,QAAA,MAAM,WAAW;;;;;;iBAqCf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;6BAY4B,mBAAmB;6BAKzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC;AAiDF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAgQD,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAqEjB"}