@travisennis/acai 0.0.10 → 0.0.12

package/dist/tools/apply-patch.js

@@ -0,0 +1,377 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { createTwoFilesPatch } from "diff";
+import { z } from "zod";
+import { config } from "../config/index.js";
+import { clearProjectStatusCache } from "../repl/project-status.js";
+import style from "../terminal/style.js";
+import { validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
+export const ApplyPatchTool = {
+    name: "ApplyPatch",
+};
+const inputSchema = z.object({
+    patchText: z
+        .string()
+        .describe("The full apply_patch text between *** Begin Patch and *** End Patch markers"),
+});
+// Patch parsing functions
+function parsePatchHeader(lines, startIdx) {
+    const line = lines[startIdx];
+    if (line.startsWith("*** Add File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith("*** Delete File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+    }
+    if (line.startsWith("*** Update File:")) {
+        const filePath = line.split(":", 2)[1]?.trim();
+        let movePath;
+        let nextIdx = startIdx + 1;
+        if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
+            movePath = lines[nextIdx].split(":", 2)[1]?.trim();
+            nextIdx++;
+        }
+        return filePath ? { filePath, movePath, nextIdx } : null;
+    }
+    return null;
+}
+function parseUpdateFileChunks(lines, startIdx) {
+    const chunks = [];
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+        if (lines[i].startsWith("@@")) {
+            const contextLine = lines[i].substring(2).trim();
+            i++;
+            const oldLines = [];
+            const newLines = [];
+            let isEndOfFile = false;
+            while (i < lines.length && !lines[i].startsWith("@@")) {
+                const changeLine = lines[i];
+                // Check for end of file marker first (before general *** check)
+                if (changeLine === "*** End of File") {
+                    isEndOfFile = true;
+                    i++;
+                    break;
+                }
+                // Check for other *** markers (new file operations)
+                if (changeLine.startsWith("***")) {
+                    break;
+                }
+                if (changeLine.startsWith(" ")) {
+                    const content = changeLine.substring(1);
+                    oldLines.push(content);
+                    newLines.push(content);
+                }
+                else if (changeLine.startsWith("-")) {
+                    oldLines.push(changeLine.substring(1));
+                }
+                else if (changeLine.startsWith("+")) {
+                    newLines.push(changeLine.substring(1));
+                }
+                i++;
+            }
+            chunks.push({
+                oldLines,
+                newLines,
+                changeContext: contextLine || undefined,
+                isEndOfFile: isEndOfFile || undefined,
+            });
+        }
+        else {
+            i++;
+        }
+    }
+    return { chunks, nextIdx: i };
+}
+function parseAddFileContent(lines, startIdx) {
+    let content = "";
+    let i = startIdx;
+    while (i < lines.length && !lines[i].startsWith("***")) {
+        if (lines[i].startsWith("+")) {
+            content += `${lines[i].substring(1)}\n`;
+        }
+        i++;
+    }
+    if (content.endsWith("\n"))
+        content = content.slice(0, -1);
+    return { content, nextIdx: i };
+}
+export function parsePatch(patchText) {
+    const lines = patchText.split("\n");
+    const hunks = [];
+    const beginMarker = "*** Begin Patch";
+    const endMarker = "*** End Patch";
+    const beginIdx = lines.findIndex((l) => l.trim() === beginMarker);
+    const endIdx = lines.findIndex((l) => l.trim() === endMarker);
+    if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+        throw new Error("Invalid patch format: missing Begin/End markers");
+    }
+    let i = beginIdx + 1;
+    while (i < endIdx) {
+        const header = parsePatchHeader(lines, i);
+        if (!header) {
+            i++;
+            continue;
+        }
+        if (lines[i].startsWith("*** Add File:")) {
+            const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx);
+            hunks.push({ type: "add", path: header.filePath, contents: content });
+            i = nextIdx;
+            continue;
+        }
+        if (lines[i].startsWith("*** Delete File:")) {
+            hunks.push({ type: "delete", path: header.filePath });
+            i = header.nextIdx;
+            continue;
+        }
+        if (lines[i].startsWith("*** Update File:")) {
+            const { chunks: parsedChunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx);
+            hunks.push({
+                type: "update",
+                path: header.filePath,
+                movePath: header.movePath,
+                chunks: parsedChunks,
+            });
+            i = nextIdx;
+            continue;
+        }
+        i++;
+    }
+    return { hunks };
+}
+function resolvePathInRoot(rootAbs, p) {
+    // Relative paths are resolved against rootAbs
+    // Absolute paths are used as-is (but validated later)
+    const abs = path.isAbsolute(p) ? path.normalize(p) : path.resolve(rootAbs, p);
+    const rel = path.relative(rootAbs, abs) || ".";
+    return { abs, rel };
+}
+function seekSequence(lines, pattern, startIndex) {
+    if (pattern.length === 0)
+        return -1;
+    for (let i = startIndex; i <= lines.length - pattern.length; i++) {
+        let matches = true;
+        for (let j = 0; j < pattern.length; j++) {
+            if (lines[i + j] !== pattern[j]) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return i;
+    }
+    return -1;
+}
+function applyReplacements(lines, replacements) {
+    const result = [...lines];
+    for (let i = replacements.length - 1; i >= 0; i--) {
+        const [startIdx, oldLen, newSegment] = replacements[i];
+        result.splice(startIdx, oldLen);
+        for (let j = 0; j < newSegment.length; j++)
+            result.splice(startIdx + j, 0, newSegment[j]);
+    }
+    return result;
+}
+function computeReplacements(originalLines, filePath, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext) {
+            const contextIdx = seekSequence(originalLines, [chunk.changeContext], lineIndex);
+            if (contextIdx === -1) {
+                throw new Error(`Failed to find context '${chunk.changeContext}' in ${filePath}`);
+            }
+            lineIndex = contextIdx + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            const insertionIdx = originalLines.length > 0 &&
+                originalLines[originalLines.length - 1] === ""
+                ? originalLines.length - 1
+                : originalLines.length;
+            replacements.push([insertionIdx, 0, chunk.newLines]);
+            continue;
+        }
+        let pattern = chunk.oldLines;
+        let newSlice = chunk.newLines;
+        let found = seekSequence(originalLines, pattern, lineIndex);
+        if (found === -1 &&
+            pattern.length > 0 &&
+            pattern[pattern.length - 1] === "") {
+            pattern = pattern.slice(0, -1);
+            if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "")
+                newSlice = newSlice.slice(0, -1);
+            found = seekSequence(originalLines, pattern, lineIndex);
+        }
+        if (found !== -1) {
+            replacements.push([found, pattern.length, newSlice]);
+            lineIndex = found + pattern.length;
+        }
+        else {
+            throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.oldLines.join("\n")}`);
+        }
+    }
+    replacements.sort((a, b) => a[0] - b[0]);
+    return replacements;
+}
+function generateUnifiedDiff(oldContent, newContent, filePath) {
+    return createTwoFilesPatch(filePath, filePath, oldContent, newContent, "original", "modified");
+}
+function deriveNewContentsFromChunks(fileAbsPath, chunks) {
+    let originalContent;
+    try {
+        originalContent = fs.readFileSync(fileAbsPath, "utf-8");
+    }
+    catch (error) {
+        throw new Error(`Failed to read file ${fileAbsPath}: ${String(error)}`);
+    }
+    const originalLines = originalContent.split("\n");
+    if (originalLines.length > 0 &&
+        originalLines[originalLines.length - 1] === "")
+        originalLines.pop();
+    const replacements = computeReplacements(originalLines, fileAbsPath, chunks);
+    const newLines = applyReplacements(originalLines, replacements);
+    // ensure trailing newline
+    if (newLines.length === 0 || newLines[newLines.length - 1] !== "")
+        newLines.push("");
+    const newContent = newLines.join("\n");
+    return {
+        unifiedDiff: generateUnifiedDiff(originalContent, newContent, fileAbsPath),
+        content: newContent,
+    };
+}
+async function applyChanges(changes, signal) {
+    const changed = [];
+    for (const change of changes) {
+        if (signal?.aborted)
+            throw new Error("Cancelled");
+        if (change.type === "add") {
+            const dir = path.dirname(change.path);
+            if (dir !== "." && dir !== "/")
+                await fsp.mkdir(dir, { recursive: true });
+            await fsp.writeFile(change.path, change.content, "utf-8");
+            changed.push(change.path);
+            continue;
+        }
+        if (change.type === "delete") {
+            await fsp.unlink(change.path).catch(() => { });
+            changed.push(change.path);
+            continue;
+        }
+        // update
+        if (change.movePath) {
+            const dir = path.dirname(change.movePath);
+            if (dir !== "." && dir !== "/")
+                await fsp.mkdir(dir, { recursive: true });
+            await fsp.writeFile(change.movePath, change.newContent, "utf-8");
+            await fsp.unlink(change.path).catch(() => { });
+            changed.push(change.movePath);
+            continue;
+        }
+        await fsp.writeFile(change.path, change.newContent, "utf-8");
+        changed.push(change.path);
+    }
+    return changed;
+}
+export const createApplyPatchTool = async (options) => {
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectories = allowedDirs ?? [primaryDir];
+    const projectConfig = await config.getConfig();
+    return {
+        toolDef: {
+            description: "Apply a high-level apply_patch diff to modify files.\n\n" +
+                "Input must be in the apply_patch format surrounded by markers:\n\n" +
+                "*** Begin Patch\n" +
+                "*** Update File: path/to/file\n" +
+                "@@ optional context line\n" +
+                " unchanged line\n" +
+                "- removed line\n" +
+                "+ added line\n" +
+                "*** End Patch\n\n" +
+                "Supported operations:\n" +
+                "- *** Add File: path/to/file (content lines prefixed with +)\n" +
+                "- *** Update File (with optional *** Move to: new/path)\n" +
+                "- *** Delete File: path/to/file\n\n" +
+                "File paths may be absolute or relative to the project directory.",
+            inputSchema,
+        },
+        display({ patchText }) {
+            // Extract number of files being modified from patch text
+            try {
+                const { hunks } = parsePatch(patchText);
+                return `${style.cyan("apply patch")} (${hunks.length} file${hunks.length === 1 ? "" : "s"})`;
+            }
+            catch {
+                return `${style.cyan("apply patch")}`;
+            }
+        },
+        async execute({ patchText }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("Apply patch aborted");
+            }
+            const root = path.resolve(primaryDir);
+            const { hunks } = parsePatch(patchText);
+            if (hunks.length === 0) {
+                return "No changes found in patch.";
+            }
+            // Build a list of resolved file changes (absolute paths), and a diff preview.
+            const changes = [];
+            let diffOutput = "";
+            for (const hunk of hunks) {
+                if (abortSignal?.aborted)
+                    throw new Error("Cancelled");
+                const p = resolvePathInRoot(root, hunk.path);
+                // Validate path is within allowed directories
+                const validPath = await validatePath(p.abs, allowedDirectories, {
+                    requireExistence: hunk.type !== "add",
+                    abortSignal,
+                });
+                if (hunk.type === "add") {
+                    changes.push({
+                        type: "add",
+                        path: validPath,
+                        content: hunk.contents,
+                    });
+                    continue;
+                }
+                if (hunk.type === "delete") {
+                    // Validate file is not read-only before deletion
+                    validateFileNotReadOnly(validPath, projectConfig, primaryDir);
+                    changes.push({ type: "delete", path: validPath });
+                    continue;
+                }
+                // update - validate file is not read-only
+                validateFileNotReadOnly(validPath, projectConfig, primaryDir);
+                let moveAbs;
+                if (hunk.movePath) {
+                    const moveP = resolvePathInRoot(root, hunk.movePath);
+                    moveAbs = await validatePath(moveP.abs, allowedDirectories, {
+                        requireExistence: false,
+                        abortSignal,
+                    });
+                }
+                const upd = deriveNewContentsFromChunks(validPath, hunk.chunks);
+                changes.push({
+                    type: "update",
+                    path: validPath,
+                    movePath: moveAbs,
+                    newContent: upd.content,
+                    unifiedDiff: upd.unifiedDiff,
+                });
+                if (upd.unifiedDiff) {
+                    diffOutput += `*** Update File: ${path.relative(root, moveAbs ?? validPath)}\n`;
+                    diffOutput += `${upd.unifiedDiff}\n`;
+                }
+            }
+            // Apply changes
+            const changedAbs = await applyChanges(changes, abortSignal);
+            const changedRel = changedAbs.map((p) => path.relative(root, p));
+            clearProjectStatusCache();
+            const summary = `${changedRel.length} file(s) changed`;
+            const filesList = changedRel.map((x) => `  ${x}`).join("\n");
+            return `Patch applied successfully. ${summary}\n${filesList}\n\n${diffOutput}`;
+        },
+    };
+};

package/dist/tools/bash.d.ts

@@ -6,8 +6,8 @@ export declare const BashTool: {
 };
 declare const inputSchema: z.ZodObject<{
     command: z.ZodString;
-    cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
-    timeout: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    cwd: z.ZodPreprocess<z.ZodNullable<z.ZodString>>;
+    timeout: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
     background: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type BashInputSchema = z.infer<typeof inputSchema>;
@@ -19,8 +19,8 @@ export declare const createBashTool: (options: {
         description: string;
         inputSchema: z.ZodObject<{
             command: z.ZodString;
-            cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodString>>;
-            timeout: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            cwd: z.ZodPreprocess<z.ZodNullable<z.ZodString>>;
+            timeout: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
             background: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>;
     };

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

@@ -1 +1 @@
-{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAUpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0CvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAyLF,QAAA,MAAM,WAAW;;;;;iBAkBf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAU,SAAS;IAC5C,SAAS,EAAE,gBAAgB,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;;;;;;;;;;yBAqFwB,eAAe;mDAIK,eAAe,mBACrC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC"}
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAepD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AA0CvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AA6MF,QAAA,MAAM,WAAW;;;;;iBAkBf,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAU,SAAS;IAC5C,SAAS,EAAE,gBAAgB,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;;;;;;;;;;yBAyGwB,eAAe;mDAIK,eAAe,mBACrC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6BrB,CAAC"}

package/dist/tools/bash.js

@@ -1,4 +1,3 @@
-// import { execSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
@@ -6,6 +5,7 @@ import { z } from "zod";
 import { initExecutionEnvironment } from "../execution/index.js";
 import style from "../terminal/style.js";
 import { resolveCwd, validatePaths } from "../utils/bash.js";
+import { formatBinaryMessage, isBinaryOutput, saveBinaryOutput, } from "../utils/binary-output.js";
 import { detectDestructiveCommand, formatBlockedCommandMessage, } from "../utils/command-protection.js";
 import { expandEnvVars } from "../utils/env-expand.js";
 import { logger } from "../utils/logger.js";
@@ -18,7 +18,7 @@ import { convertNullString } from "../utils/zod.js";
 function detectMultilineGitCommit(command) {
     const trimmed = command.trim();
     // Check if it's a git commit command
-    if (!trimmed.startsWith("git commit") && !trimmed.startsWith("git ")) {
+    if (!trimmed.startsWith("git commit")) {
         return null;
     }
     // Look for -m or -am flags with a message containing newlines
@@ -209,6 +209,22 @@ export const BashTool = {
 const simpleDescription = "Run terminal commands.";
 // Command execution timeout in milliseconds
 const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
+// Maximum output size in bytes (50KB) to prevent context window exhaustion
+const MAX_OUTPUT_SIZE = 50 * 1024;
+/**
+ * Truncates output if it exceeds MAX_OUTPUT_SIZE and adds a clear message.
+ * This prevents extremely large outputs from exhausting the context window.
+ * The footer is always appended at the end, even when output is truncated.
+ */
+function truncateOutput(output, footer) {
+    if (output.length <= MAX_OUTPUT_SIZE) {
+        return `${output}\n${footer}`;
+    }
+    const truncatedLength = MAX_OUTPUT_SIZE;
+    const originalLength = output.length;
+    const truncated = output.slice(0, truncatedLength);
+    return `${truncated}\n\n[OUTPUT TRUNCATED: ${originalLength.toLocaleString()} characters total, showing first ${truncatedLength.toLocaleString()} characters. The output was too large and was truncated to prevent context window exhaustion. Consider using commands that produce smaller output (e.g., head, tail with line limits, or redirecting to a file).]\n${footer}`;
+}
 const inputSchema = z.object({
     command: z.string().describe("Full CLI command to execute."),
     cwd: z
@@ -268,7 +284,8 @@ export const createBashTool = async (options) => {
         return `Background process started with PID: ${proc.pid}`;
     }
     async function executeSync(cmd, cwd, timeout, signal) {
-        const { output, exitCode } = await execEnv.executeCommand(cmd, {
+        const startTime = Date.now();
+        const { output, exitCode, error } = await execEnv.executeCommand(cmd, {
             cwd,
             timeout,
             abortSignal: signal,
@@ -276,10 +293,25 @@ export const createBashTool = async (options) => {
             captureStderr: true,
             throwOnError: false,
         });
+        const elapsedMs = Date.now() - startTime;
+        const timeStr = elapsedMs < 1000 ? `${elapsedMs}ms` : `${(elapsedMs / 1000).toFixed(1)}s`;
+        const metadataFooter = `[exit:${exitCode} | ${timeStr}]`;
         if (exitCode !== 0) {
-            throw new Error(output);
+            const errorMessage = error
+                ? error.message
+                : `Command exited with code ${exitCode}`;
+            const combinedOutput = output
+                ? `${errorMessage}\n${output}`
+                : errorMessage;
+            throw new Error(truncateOutput(combinedOutput, metadataFooter));
+        }
+        // Check for binary output and handle specially
+        if (isBinaryOutput(output)) {
+            const saveResult = saveBinaryOutput(output);
+            const binaryMessage = formatBinaryMessage(saveResult);
+            return `${binaryMessage}\n${metadataFooter}`;
         }
-        return output;
+        return truncateOutput(output, metadataFooter);
     }
     return {
         toolDef: {
@@ -411,9 +443,9 @@ function fixRgCommand(command) {
         // If it's just alphanumeric with maybe some regex chars, it's probably a pattern
         // Common pattern chars: ., *, +, ?, [, ], ^, $, (, ), |, \\
         // But we want to be conservative - if it looks like a filename without path, add .
-        if (!lastToken.includes("/") && !lastToken.includes("*")) {
-            // Doesn't look like a path with glob or directory, likely a pattern
-            // Need to add path
+        if (!lastToken.includes("/") &&
+            !lastToken.includes("*") &&
+            !lastToken.includes(".")) {
             logger.debug(`Adding '.' to rg command: ${command}`);
             return `${command} .`;
         }

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

@@ -6,8 +6,8 @@ export declare const DirectoryTreeTool: {
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
-    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-    maxDepth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+    maxDepth: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
 }, z.core.$strip>;
 type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
 export declare const createDirectoryTreeTool: (options: {
@@ -17,8 +17,8 @@ export declare const createDirectoryTreeTool: (options: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodString;
-            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
-            maxDepth: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            maxResults: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
+            maxDepth: z.ZodDefault<z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>>;
         }, z.core.$strip>;
     };
     display({ path, maxDepth, maxResults }: DirectoryTreeInputSchema): string;

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

@@ -1 +1 @@
-{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;iBAYf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,SAAS;IACrD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;4CAQ2C,wBAAwB;4CAY9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}
+{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKvD,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;;;iBAcf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,SAAS;IACrD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;4CAS2C,wBAAwB;4CAY9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}

package/dist/tools/directory-tree.js

@@ -15,9 +15,11 @@ const inputSchema = z.object({
     path: z.string().describe("The path"),
     maxResults: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe(`Maximum number of items (files + directories) to return. Set to 0 for no limit. (default: ${DEFAULT_ITEM_LIMIT})`),
     maxDepth: z
         .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .default(null)
         .describe(`Maximum recursion depth. Set to 0 for no limit. (default: ${DEFAULT_DEPTH_LIMIT})`),
 });
 export const createDirectoryTreeTool = async (options) => {
@@ -25,7 +27,7 @@ export const createDirectoryTreeTool = async (options) => {
     const allowedDirectory = allowedDirs ?? [primaryDir];
     return {
         toolDef: {
-            description: "Show directory structure as a tree.",
+            description: "Show directory structure as a recursive tree. Use this to explore nested directories and understand the overall project structure. For a simple flat list of a single directory, use LS instead.",
             inputSchema,
         },
         display({ path, maxDepth, maxResults }) {

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import type { ToolExecutionOptions } from "./types.ts";
+import type { SessionContext, ToolExecutionOptions } from "./types.ts";
 declare const toolMetadataSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
@@ -16,7 +16,15 @@ declare const toolMetadataSchema: z.ZodObject<{
     }, z.core.$strip>>;
     needsApproval: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
-export type ToolMetadata = z.infer<typeof toolMetadataSchema>;
+type ToolMetadata = z.infer<typeof toolMetadataSchema>;
+interface InterpreterResult {
+    command: string;
+    args: string[];
+}
+export declare function getShebang(scriptPath: string): string | null;
+export declare function parseShebang(shebang: string, scriptPath: string): InterpreterResult;
+export declare function resolveToolInterpreter(scriptPath: string): InterpreterResult | null;
+export declare function parseTextSchema(content: string): ToolMetadata | null;
 export declare function parseToolMetadata(output: string): ToolMetadata;
 interface DynamicToolObject {
     toolDef: {
@@ -25,9 +33,10 @@ interface DynamicToolObject {
     };
     execute: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<string>;
 }
-export declare function loadDynamicTools({ baseDir, existingToolNames, }: {
+export declare function loadDynamicTools({ baseDir, existingToolNames, sessionContext, }: {
     baseDir: string;
     existingToolNames?: string[];
+    sessionContext?: SessionContext;
 }): Promise<Record<string, DynamicToolObject>>;
 export {};
 //# sourceMappingURL=dynamic-tool-loader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D;AA2LD,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB;AAwCD,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,iBAAsB,GACvB,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B,8CA2FA"}
+{"version":3,"file":"dynamic-tool-loader.d.ts","sourceRoot":"","sources":["../../source/tools/dynamic-tool-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvE,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;iBAatB,CAAC;AAEH,KAAK,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAMvD,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAyBD,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAc5D;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,iBAAiB,CAUnB;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,GACjB,iBAAiB,GAAG,IAAI,CA0B1B;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAwFpE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAS9D;AAsOD,UAAU,iBAAiB;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QAEpB,WAAW,EAAE,GAAG,CAAC;KAClB,CAAC;IACF,OAAO,EAAE,CACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC,MAAM,CAAC,CAAC;CACtB;AAwED,wBAAsB,gBAAgB,CAAC,EACrC,OAAO,EACP,iBAAsB,EACtB,cAAc,GACf,EAAE;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,8CAuJA"}