@travisennis/acai 0.0.6 → 0.0.8

package/dist/tools/bash.js

@@ -1,108 +1,216 @@
+import { execSync } from "node:child_process";
 import { z } from "zod";
-import { config } from "../config.js";
 import { initExecutionEnvironment } from "../execution/index.js";
 import { logger } from "../logger.js";
 import style from "../terminal/style.js";
-import { manageTokenLimit } from "../tokens/threshold.js";
-import { isMutatingCommand, resolveCwd, validatePaths } from "./bash-utils.js";
-import { isPathWithinAllowedDirs } from "./filesystem-utils.js";
+import { resolveCwd, validatePaths } from "../utils/bash.js";
+import { convertNullString } from "../utils/zod.js";
 export const BashTool = {
-    name: "bash",
+    name: "Bash",
 };
+const installedTools = getInstalledTools();
+const toolDescription = `Execute commands in a shell. Commands can execute only within the allowed directories. Always use absolute paths.
+
+Tools available:
+${installedTools}`;
 // Command execution timeout in milliseconds
 const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
 const inputSchema = z.object({
     command: z.string().describe("Full CLI command to execute."),
     cwd: z
-        .string()
-        .nullable()
-        .describe("Working directory file path (default: project root). Must be within the project directory."),
-    timeout: z.coerce
-        .number()
-        .nullable()
-        .describe(`Command execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT}ms`),
+        .preprocess((val) => convertNullString(val), z.string().nullable())
+        .describe("Working directory file path (default: project root). Must be within the project directory. Required but nullable."),
+    timeout: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe(`Command execution timeout in milliseconds. Required but nullable. If null, the default value is ${DEFAULT_TIMEOUT}ms`),
+    background: z
+        .boolean()
+        .optional()
+        .describe("Run command in background. If true, command will run until program exit."),
 });
-export const createBashTool = async ({ baseDir, allowedDirs, tokenCounter, }) => {
+export const createBashTool = async ({ baseDir, allowedDirs, }) => {
     const execEnv = await initExecutionEnvironment();
-    const projectConfig = await config.readProjectConfig();
-    const allowedPaths = projectConfig.logs?.path
-        ? [projectConfig.logs.path]
-        : [];
     const allowedDirectories = allowedDirs ?? [baseDir];
     return {
         toolDef: {
-            description: "Execute commands in a shell. Commands execute only within the project directory. Always use absolute paths.",
+            description: toolDescription,
             inputSchema,
         },
-        async *execute({ command, cwd, timeout }, { toolCallId, abortSignal }) {
-            try {
-                if (abortSignal?.aborted) {
-                    throw new Error("Command execution aborted");
-                }
-                // grok doesn't follow my instructions
-                const safeCwd = cwd === "null" ? null : cwd;
-                const resolvedCwd = resolveCwd(safeCwd, baseDir);
-                const safeTimeout = timeout ?? DEFAULT_TIMEOUT;
-                // Safety warning for potentially mutating commands
-                const isMutating = isMutatingCommand(command);
-                yield {
-                    name: BashTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `${style.cyan(command)}${isMutating ? " *" : ""}`,
-                };
-                if (!isPathWithinAllowedDirs(resolvedCwd, allowedDirectories)) {
-                    const errorMsg = `Working directory must be within the allowed directories: ${allowedDirectories.join(", ")}`;
-                    yield {
-                        name: BashTool.name,
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: errorMsg,
-                    };
-                    yield errorMsg;
-                    return;
-                }
-                const pathValidation = validatePaths(command, allowedDirectories, resolvedCwd, allowedPaths);
-                if (!pathValidation.isValid) {
-                    yield {
-                        name: BashTool.name,
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: pathValidation.error ?? "Unknown error.",
-                    };
-                    yield pathValidation.error ?? "Unknown error.";
-                    return;
-                }
-                if (abortSignal?.aborted) {
-                    throw new Error("Command execution aborted before running the command");
+        display({ command }) {
+            return `\n> ${style.cyan(command)}`;
+        },
+        async execute({ command, cwd, timeout, background }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("Command execution aborted");
+            }
+            // grok doesn't follow my instructions
+            const safeCwd = cwd === "null" ? null : cwd;
+            const resolvedCwd = resolveCwd(safeCwd, baseDir, allowedDirectories);
+            const safeTimeout = timeout ?? DEFAULT_TIMEOUT;
+            const pathValidation = validatePaths(command, allowedDirectories, resolvedCwd);
+            if (!pathValidation.isValid) {
+                throw new Error(pathValidation.error ?? "Unknown error.");
+            }
+            if (abortSignal?.aborted) {
+                throw new Error("Command execution aborted before running the command");
+            }
+            // Handle background execution
+            if (background) {
+                // Strip any existing & from command to avoid double backgrounding
+                let processedCommand = command.trim();
+                if (processedCommand.endsWith("&")) {
+                    logger.warn(`Stripping '&' from command since background=true: ${command}`);
+                    processedCommand = processedCommand.slice(0, -1).trim();
                 }
-                const { output, exitCode } = await execEnv.executeCommand(command, {
+                // Fix rg commands that don't have an explicit path
+                processedCommand = fixRgCommand(processedCommand);
+                const backgroundProcess = execEnv.executeCommandInBackground(processedCommand, {
                     cwd: resolvedCwd,
-                    timeout: safeTimeout,
                     abortSignal,
-                    preserveOutputOnError: true,
-                    captureStderr: true,
-                    throwOnError: false,
+                    onOutput: (output) => {
+                        logger.debug({ output }, "Background command output:");
+                    },
+                    onError: (error) => {
+                        logger.debug({ error }, "Background command error:");
+                    },
+                    onExit: (code) => {
+                        logger.debug(`Background command exited with code ${code}`);
+                    },
                 });
-                const result = await manageTokenLimit(output, tokenCounter, "Bash", "Adjust command to return more specific results");
-                yield {
-                    name: BashTool.name,
-                    event: "tool-completion",
-                    id: toolCallId,
-                    data: `${exitCode} (${result.tokenCount} tokens)`,
-                };
-                yield result.content;
+                return `Background process started with PID: ${backgroundProcess.pid}`;
+            }
+            // Handle regular synchronous execution
+            // Strip & if present to ensure synchronous behavior
+            let processedCommand = command.trim();
+            if (processedCommand.endsWith("&")) {
+                logger.warn(`Stripping '&' from command since background=false: ${command}`);
+                processedCommand = processedCommand.slice(0, -1).trim();
             }
-            catch (error) {
-                logger.error(error, "Bash Tool Error:");
-                yield {
-                    name: BashTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield error.message;
+            // Fix rg commands that don't have an explicit path
+            // rg hangs when stdin is a socket and no path is given
+            processedCommand = fixRgCommand(processedCommand);
+            const { output, exitCode } = await execEnv.executeCommand(processedCommand, {
+                cwd: resolvedCwd,
+                timeout: safeTimeout,
+                abortSignal,
+                preserveOutputOnError: true,
+                captureStderr: true,
+                throwOnError: false,
+            });
+            if (exitCode !== 0) {
+                throw new Error(output);
             }
+            return output;
         },
     };
 };
+function getInstalledTools() {
+    // Check for required bash tools
+    const tools = [
+        {
+            name: "git",
+            command: "git --version",
+            description: "Version control system - used for cloning repositories, checking out branches, committing changes, viewing history, and managing code versions",
+        },
+        {
+            name: "gh",
+            command: "gh --version",
+            description: "GitHub CLI - used for creating pull requests, managing issues, interacting with GitHub API, and automating GitHub workflows",
+        },
+        {
+            name: "rg",
+            command: "rg --version",
+            description: "ripgrep - fast text search tool for searching code patterns, file contents, and regular expressions across the codebase (use this instead of grep)",
+        },
+        {
+            name: "fd",
+            command: "fd --version",
+            description: "Fast file finder - alternative to find command, used for finding files by name, pattern, or type with intuitive syntax (use this instead of find)",
+        },
+        {
+            name: "ast-grep",
+            command: "ast-grep --version",
+            description: "AST-based code search - used for structural code search, refactoring, finding patterns in abstract syntax trees, and code transformations",
+        },
+        {
+            name: "jq",
+            command: "jq --version",
+            description: "JSON processor - used for parsing, filtering, and manipulating JSON output from APIs, commands, and configuration files",
+        },
+        {
+            name: "yq",
+            command: "yq --version",
+            description: "YAML processor - used for parsing and manipulating YAML files (configs, CI/CD pipelines, Kubernetes manifests) with jq-like syntax",
+        },
+    ];
+    const toolStatus = tools
+        .map((tool) => {
+        let status = false;
+        try {
+            execSync(tool.command, { stdio: "ignore", timeout: 5000 });
+            status = true;
+        }
+        catch (_error) {
+            // Ignore error, tool is not installed
+        }
+        return { name: tool.name, description: tool.description, status };
+    })
+        .filter((tool) => tool.status)
+        .map((tool) => `- **${tool.name}**: ${tool.description}`)
+        .join("\n");
+    return toolStatus;
+}
+/**
+ * Fix rg commands that don't have an explicit path
+ * rg hangs when stdin is a socket and no path is given
+ * See: https://github.com/BurntSushi/ripgrep/discussions/2047
+ */
+function fixRgCommand(command) {
+    const trimmed = command.trim();
+    // Check if command starts with rg
+    if (!trimmed.startsWith("rg ") && !trimmed.startsWith("rg\\")) {
+        return command;
+    }
+    // Check if command already has stdin redirection or piping
+    // Don't modify commands like: cat file.txt | rg pattern
+    // or rg pattern < input.txt
+    if (trimmed.includes("|") || trimmed.includes("<") || trimmed.includes(">")) {
+        return command;
+    }
+    // Simple heuristic: if last token starts with -, add .
+    // This handles cases like: rg -l pattern --type ts --type js
+    const tokens = trimmed.split(/\\s+/);
+    const lastToken = tokens[tokens.length - 1];
+    if (lastToken?.startsWith("-")) {
+        // Command ends with an option, need to add path
+        logger.debug(`Adding '.' to rg command: ${command}`);
+        return `${command} .`;
+    }
+    // Last token doesn't start with -, could be a path or pattern
+    if (lastToken) {
+        // If it's ., ./, /, or contains /, assume it's a path
+        if (lastToken === "." ||
+            lastToken.startsWith("./") ||
+            lastToken.startsWith("/") ||
+            lastToken.includes("/") ||
+            lastToken === "..") {
+            // Already has a path
+            return command;
+        }
+        // Check if it's a simple pattern (no special chars that would make it a path)
+        // 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
+            logger.debug(`Adding '.' to rg command: ${command}`);
+            return `${command} .`;
+        }
+        // Complex case with * or other chars, could be a glob pattern
+        // Default to adding . to be safe
+    }
+    // No last token or complex case, add . to be safe
+    logger.debug(`Adding '.' to rg command: ${command}`);
+    return `${command} .`;
+}

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

@@ -1,32 +1,28 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import type { TokenCounter } from "../tokens/counter.ts";
-import type { ToolResult } from "./types.ts";
+import type { ToolExecutionOptions } from "./types.ts";
 export declare const DirectoryTreeTool: {
-    name: "directoryTree";
+    name: "DirectoryTree";
 };
 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>>>;
 }, z.core.$strip>;
 type DirectoryTreeInputSchema = z.infer<typeof inputSchema>;
-export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, tokenCounter, }: {
+export declare const createDirectoryTreeTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
     allowedDirs?: string[];
-    tokenCounter: TokenCounter;
 }) => Promise<{
     toolDef: {
         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>>>;
         }, z.core.$strip>;
     };
-    execute({ path }: DirectoryTreeInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ path, maxDepth, maxResults }: DirectoryTreeInputSchema): string;
+    execute({ path, maxResults, maxDepth }: DirectoryTreeInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
-/**
- * Generates a string representation of a directory tree starting from the given path.
- * @param dirPath - The path of the directory to generate the tree for.
- * @returns A Promise that resolves to a string representation of the directory tree.
- */
-export declare function directoryTree(dirPath: string): Promise<string>;
 export {};
 //# sourceMappingURL=directory-tree.d.ts.map

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,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAIzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,iBAAiB;;CAE7B,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE5D,eAAO,MAAM,uBAAuB,GAAU,4CAI3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;sBASe,wBAAwB,+BACL,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA+DhC,CAAC;AA8CF;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAYpE"}
+{"version":3,"file":"directory-tree.d.ts","sourceRoot":"","sources":["../../source/tools/directory-tree.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,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,8BAG3C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;4CAO2C,wBAAwB;4CAW9B,wBAAwB,mBACvC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAyBrB,CAAC"}

package/dist/tools/directory-tree.js

@@ -2,65 +2,55 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import style from "../terminal/style.js";
-import { manageTokenLimit } from "../tokens/threshold.js";
+import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
 import ignore from "../utils/ignore.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { convertNullString } from "../utils/zod.js";
+const DEFAULT_ITEM_LIMIT = 500;
+const DEFAULT_DEPTH_LIMIT = 10;
 export const DirectoryTreeTool = {
-    name: "directoryTree",
+    name: "DirectoryTree",
 };
 const inputSchema = z.object({
-    path: z.string().describe("The path."),
+    path: z.string().describe("The path"),
+    maxResults: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .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())
+        .describe(`Maximum recursion depth. Set to 0 for no limit. (default: ${DEFAULT_DEPTH_LIMIT})`),
 });
-export const createDirectoryTreeTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+export const createDirectoryTreeTool = async ({ workingDir, allowedDirs, }) => {
     const allowedDirectory = allowedDirs ?? [workingDir];
     return {
         toolDef: {
-            description: "Get a directory tree structure for a given path. This tool will ignore any directories or files listed in a .gitignore file. Use this tool when you need to see a complete directory tree for a project. This can be used to get an understanding of how a project is organized and what files are available before using other file system tools.",
+            description: `Get a directory tree structure for a given path. This tool will ignore any directories or files listed in a .gitignore file. Use this tool when you need to see a complete directory tree for a path in the allowed directories. This can be used to get an understanding of how a project is organized and what files are available before using other file system tools. Results are automatically limited to prevent overwhelming output. Default limits are ${DEFAULT_ITEM_LIMIT} items and ${DEFAULT_DEPTH_LIMIT} depth. Use maxResults and maxDepth parameters for better control over output size.`,
             inputSchema,
         },
-        async *execute({ path }, { toolCallId, abortSignal }) {
-            try {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("Directory tree listing aborted");
-                }
-                yield {
-                    name: DirectoryTreeTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${style.cyan(path)}`,
-                };
-                const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
-                if (abortSignal?.aborted) {
-                    throw new Error("Directory tree listing aborted before tree generation");
-                }
-                const rawTree = await directoryTree(validPath);
-                const result = await manageTokenLimit(rawTree, tokenCounter, "DirectoryTree", "Use excludeDirPatterns or recursive=false to reduce output");
-                // Count files in the tree output
-                const fileCount = (result.content.match(/\n/g) || []).length + 1;
-                let completionMessage = `Found ${fileCount} files`;
-                if (result.truncated) {
-                    completionMessage += ` - ${result.content}`;
-                }
-                completionMessage += ` (${result.tokenCount} tokens)`;
-                yield {
-                    name: DirectoryTreeTool.name,
-                    id: toolCallId,
-                    event: "tool-completion",
-                    data: completionMessage,
-                };
-                yield result.content;
+        display({ path, maxDepth, maxResults }) {
+            let display = `\n> ${style.cyan(path)}`;
+            if (maxDepth || maxResults) {
+                const parts = [];
+                if (maxDepth)
+                    parts.push(`depth: ${maxDepth}`);
+                if (maxResults)
+                    parts.push(`max: ${maxResults}`);
+                display += ` (${parts.join(", ")})`;
             }
-            catch (error) {
-                const errorMsg = error.message;
-                yield {
-                    name: DirectoryTreeTool.name,
-                    id: toolCallId,
-                    event: "tool-error",
-                    data: errorMsg,
-                };
-                yield errorMsg;
+            return display;
+        },
+        async execute({ path, maxResults, maxDepth }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("Directory tree listing aborted");
+            }
+            const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+            if (abortSignal?.aborted) {
+                throw new Error("Directory tree listing aborted before tree generation");
             }
+            const treeResult = await directoryTree(validPath, {
+                maxResults: maxResults ?? DEFAULT_ITEM_LIMIT,
+                maxDepth: maxDepth ?? DEFAULT_DEPTH_LIMIT,
+            });
+            return treeResult.tree;
         },
     };
 };
@@ -71,41 +61,74 @@ export const createDirectoryTreeTool = async ({ workingDir, allowedDirs, tokenCo
  * @returns The indentation string for the current level.
  */
 function getIndent(level, isLast) {
-    const indent = "│   ".repeat(level - 1);
+    const indent = "│   ".repeat(Math.max(level - 1, 0));
     return level === 0 ? "" : `${indent}${isLast ? "└── " : "├── "}`;
 }
 /**
  * Recursively generates a string representation of a directory tree.
  * @param dirPath - The path of the directory to generate the tree for.
- * @param level - The current level in the directory tree (default: 1).
- * @returns A Promise that resolves to a string representation of the directory tree.
+ * @param ig - The ignore instance for filtering files.
+ * @param level - The current level in the directory tree (default: 0).
+ * @param options - Options for limiting results.
+ * @returns A Promise that resolves to a string representation of the directory tree with counts.
  * @throws Will log an error if there's an issue reading the directory.
  */
-async function generateDirectoryTree(dirPath, ig, level = 1) {
+async function generateDirectoryTree(dirPath, ig, level = 0, options = {}) {
     const name = path.basename(dirPath);
     let output = `${getIndent(level, false)}${name}\n`;
+    let fileCount = 0;
+    let directoryCount = 1; // Count the current directory
+    let totalCount = 1; // Count the current directory
+    let isTruncated = false;
+    // Check maxDepth limit - when maxDepth is reached, we should indicate truncation
+    if (options.maxDepth !== null &&
+        options.maxDepth !== undefined &&
+        options.maxDepth > 0 &&
+        level >= options.maxDepth) {
+        // When maxDepth is reached, return with truncation flag set
+        return {
+            tree: output,
+            fileCount: 0,
+            directoryCount: 1, // Count the current directory
+            totalCount: 1, // Count the current directory
+            isTruncated: true, // Set truncation flag when depth limit is reached
+        };
+    }
     const items = await fs.readdir(dirPath);
     const filteredItems = ig.filter(items);
     for (let i = 0; i < filteredItems.length; i++) {
+        // Check maxResults limit BEFORE processing each item to ensure strict adherence to limits
+        if (options.maxResults !== null &&
+            options.maxResults !== undefined &&
+            options.maxResults > 0 &&
+            totalCount >= options.maxResults) {
+            isTruncated = true;
+            break;
+        }
         const item = filteredItems[i] ?? "";
         const itemPath = path.join(dirPath, item);
         const isLast = i === filteredItems.length - 1;
         const stats = await fs.stat(itemPath);
         if (stats.isDirectory()) {
-            output += await generateDirectoryTree(itemPath, ig, level + 1);
+            const subTreeResult = await generateDirectoryTree(itemPath, ig, level + 1, options);
+            output += subTreeResult.tree;
+            fileCount += subTreeResult.fileCount;
+            directoryCount += subTreeResult.directoryCount;
+            totalCount += subTreeResult.totalCount;
+            // Propagate truncation from subtree results
+            if (subTreeResult.isTruncated) {
+                isTruncated = true;
+            }
         }
         else {
             output += `${getIndent(level + 1, isLast)}${item}\n`;
+            fileCount += 1;
+            totalCount += 1;
         }
     }
-    return output;
+    return { tree: output, fileCount, directoryCount, totalCount, isTruncated };
 }
-/**
- * Generates a string representation of a directory tree starting from the given path.
- * @param dirPath - The path of the directory to generate the tree for.
- * @returns A Promise that resolves to a string representation of the directory tree.
- */
-export async function directoryTree(dirPath) {
+async function directoryTree(dirPath, options = {}) {
     let ig;
     try {
         const ignoreFile = await fs.readFile(path.join(process.cwd(), ".gitignore"));
@@ -115,5 +138,12 @@ export async function directoryTree(dirPath) {
         // If .gitignore doesn't exist, create basic ignore with just .git
         ig = ignore().add(".git");
     }
-    return (await generateDirectoryTree(dirPath, ig)).trim();
+    const result = await generateDirectoryTree(dirPath, ig, 0, options);
+    return {
+        tree: result.tree.trim(),
+        fileCount: result.fileCount,
+        directoryCount: result.directoryCount,
+        totalCount: result.totalCount,
+        isTruncated: result.isTruncated,
+    };
 }

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

@@ -1,20 +1,34 @@
-import type { ToolCallOptions } from "ai";
-import { type ToolMetadata } from "./dynamic-tool-parser.ts";
-import type { ToolResult } from "./types.ts";
+import { z } from "zod";
+import type { ToolExecutionOptions } from "./types.ts";
+declare const toolMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>;
+    needsApproval: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ToolMetadata = z.infer<typeof toolMetadataSchema>;
+export declare function parseToolMetadata(output: string): ToolMetadata;
 interface DynamicToolObject {
     toolDef: {
         description: string;
         inputSchema: any;
     };
-    execute: (input: Record<string, unknown>, options: ToolCallOptions) => AsyncGenerator<ToolResult>;
-    ask?: (input: Record<string, unknown>, options: ToolCallOptions) => Promise<{
+    execute: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<string>;
+    ask?: (input: Record<string, unknown>, options: ToolExecutionOptions) => Promise<{
         approve: boolean;
         reason?: string;
     }>;
 }
-export declare function createDynamicTool(scriptPath: string, metadata: ToolMetadata): {
-    [x: string]: DynamicToolObject;
-};
 export declare function loadDynamicTools({ baseDir }: {
     baseDir: string;
 }): Promise<Record<string, DynamicToolObject>>;

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,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAI1C,OAAO,EAAqB,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA+K7C,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,eAAe,KACrB,cAAc,CAAC,UAAU,CAAC,CAAC;IAChC,GAAG,CAAC,EAAE,CACJ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,eAAe,KACrB,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAED,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,YAAY,GACrB;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAE,CAmEpC;AAED,wBAAsB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,8CAgEtE"}
+{"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;IACrB,GAAG,CAAC,EAAE,CACJ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrD;AAwCD,wBAAsB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,8CAgEtE"}