@travisennis/acai 0.0.11 → 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/glob.d.ts

@@ -4,28 +4,28 @@ export declare const GlobTool: {
     name: "Glob";
 };
 export declare const inputSchema: z.ZodObject<{
-    patterns: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    path: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodString>;
-    gitignore: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    expandDirectories: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    ignoreFiles: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-    cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    patterns: z.ZodDefault<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+    path: z.ZodDefault<z.ZodPreprocess<z.ZodString>>;
+    gitignore: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    expandDirectories: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    ignoreFiles: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+    cwd: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
 }, z.core.$strip>;
 type GlobInputSchema = z.infer<typeof inputSchema>;
 export declare const createGlobTool: () => {
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
-            patterns: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            path: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodString>;
-            gitignore: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            expandDirectories: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            ignoreFiles: z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
-            cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            patterns: z.ZodDefault<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>;
+            path: z.ZodDefault<z.ZodPreprocess<z.ZodString>>;
+            gitignore: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            expandDirectories: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            ignoreFiles: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>>>;
+            cwd: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ patterns, path }: GlobInputSchema): string;

package/dist/tools/glob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA6EvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBA0EtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAmBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAuCrB,CAAC"}
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA6EvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBAkFtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAmBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAuCrB,CAAC"}

package/dist/tools/glob.js

@@ -81,18 +81,23 @@ export const inputSchema = z.object({
         }
         return val;
     }, z.union([z.string(), z.array(z.string())]))
+        .default("**/*")
         .describe("Glob patterns to search for (e.g., '*.ts', '**/*.test.ts', 'src/**/*.js')"),
     path: z
         .preprocess((val) => (val === null || val === undefined ? process.cwd() : val), z.string())
+        .default(process.cwd())
         .describe("Base directory to search in"),
     gitignore: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Respect ignore patterns in .gitignore files. (default: true)"),
     recursive: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Search recursively. (default: true)"),
     expandDirectories: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Automatically expand directories to files. (default: true)"),
     ignoreFiles: z
         .preprocess((val) => {
@@ -116,12 +121,15 @@ export const inputSchema = z.object({
         }
         return converted;
     }, z.union([z.string(), z.array(z.string())]).nullable())
+        .default(null)
         .describe("Glob patterns to look for ignore files (e.g., '.gitignore'). Pass null to use default behavior."),
     cwd: z
         .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
+        .default(null)
         .describe("Current working directory override. (default: process.cwd())"),
     maxResults: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("Maximum number of files to return. Set to 0 for no limit. (Default: 100)"),
 });
 export const createGlobTool = () => {
@@ -145,7 +153,7 @@ export const createGlobTool = () => {
             const effectivePath = typeof path === "string" && path.trim() !== "" ? path : process.cwd();
             const patternArray = normalizePatternArray(patterns);
             const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
-            const globOptions = buildGlobOptions(effectivePath, gitignore, recursive, expandDirectories, ignoreFiles, cwd);
+            const globOptions = buildGlobOptions(effectivePath, gitignore ?? null, recursive ?? null, expandDirectories ?? null, ignoreFiles ?? null, cwd ?? null);
             const matchingFiles = await glob(patternArray, globOptions);
             const filesToStat = matchingFiles.length > MAX_STAT_FILES
                 ? matchingFiles.slice(0, MAX_STAT_FILES)

package/dist/tools/grep.d.ts

@@ -6,13 +6,13 @@ export declare const GrepTool: {
 declare const inputSchema: z.ZodObject<{
     pattern: z.ZodString;
     path: z.ZodString;
-    recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-    contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    ignoreCase: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    filePattern: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+    contextLines: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    searchIgnored: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    literal: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
 }, z.core.$strip>;
 type GrepInputSchema = z.infer<typeof inputSchema>;
 export declare const createGrepTool: () => {
@@ -21,13 +21,13 @@ export declare const createGrepTool: () => {
         inputSchema: z.ZodObject<{
             pattern: z.ZodString;
             path: z.ZodString;
-            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            ignoreCase: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            filePattern: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
-            contextLines: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            searchIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            literal: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedBoolean<unknown>>>;
-            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            recursive: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            ignoreCase: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            filePattern: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedString<unknown>>>>;
+            contextLines: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            searchIgnored: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            literal: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedBoolean<unknown>>>>;
+            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }: GrepInputSchema): string;

package/dist/tools/grep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBAoCf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kFAapB,eAAe;sHAoCb,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAkErB,CAAC;AAEF,UAAU,WAAW;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAuMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA8B9D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,EAAE,CAgEV;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAqDrE;AA8BD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAE/D;AAyBD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAoDpD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,EACzB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,GAC/B,OAAO,CAAC,UAAU,CAAC,CAgGrB"}
+{"version":3,"file":"grep.d.ts","sourceRoot":"","sources":["../../source/tools/grep.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;iBA2Cf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;kFAapB,eAAe;sHAoCb,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CAkErB,CAAC;AAEF,UAAU,WAAW;IACnB,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAuMD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA8B9D;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,GACxB,MAAM,EAAE,CAgEV;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAqDrE;AA8BD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAE/D;AAyBD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,WAAW,EAAE,EACtB,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACpC;IAAE,SAAS,EAAE,WAAW,EAAE,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAoDpD;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,WAAgB,EACzB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI,GAC/B,OAAO,CAAC,UAAU,CAAC,CAgGrB"}

package/dist/tools/grep.js

@@ -16,24 +16,31 @@ const inputSchema = z.object({
     path: z.string().describe("The path to search in"),
     recursive: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Search recursively. (default: true))"),
     ignoreCase: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Use case-sensitive search. (default: false)"),
     filePattern: z
         .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
+        .default(null)
         .describe("Glob pattern to filter files (e.g., '*.ts', '**/*.test.js'). (Default: no filtering)"),
     contextLines: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("The number of context lines needed in search results. (Default: 0)"),
     searchIgnored: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Search ignored files. (Default: false)"),
     literal: z
         .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
+        .default(null)
         .describe("Pass true for fixed-string search (-F), false for regex, (Default: auto-detects unbalanced patterns like mismatched parentheses/brackets.)"),
     maxResults: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe("Maximum number of matches to return. Set to 0 for no limit. (Default: 100)"),
 });
 export const createGrepTool = () => {