@travisennis/acai 0.0.6 → 0.0.8

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

@@ -5,7 +5,28 @@ import path from "node:path";
 import { z } from "zod";
 import { config } from "../config.js";
 import { logger } from "../logger.js";
-import { parseToolMetadata } from "./dynamic-tool-parser.js";
+// Tool Metadata Schema and Parser
+const toolMetadataSchema = z.object({
+    name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_-]*$/),
+    description: z.string().min(1),
+    parameters: z.array(z.object({
+        name: z.string().regex(/^[a-zA-Z_][a-zA-Z0-9_-]*$/),
+        type: z.enum(["string", "number", "boolean"]),
+        description: z.string().min(1),
+        required: z.boolean().default(true),
+        default: z.union([z.string(), z.number(), z.boolean()]).optional(),
+    })),
+    needsApproval: z.boolean().default(true),
+});
+export function parseToolMetadata(output) {
+    try {
+        const parsed = JSON.parse(output.trim());
+        return toolMetadataSchema.parse(parsed);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse tool metadata: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 function generateZodSchema(parameters) {
     const fields = {};
     for (const param of parameters) {
@@ -15,10 +36,14 @@ function generateZodSchema(parameters) {
                 schema = z.string();
                 break;
             case "number":
-                schema = z.coerce.number();
+                schema = z.preprocess((val) => typeof val === "string" && val.toLowerCase() === "null"
+                    ? null
+                    : val, z.coerce.number().nullable());
                 break;
             case "boolean":
-                schema = z.coerce.boolean();
+                schema = z.preprocess((val) => typeof val === "string" && val.toLowerCase() === "null"
+                    ? null
+                    : val, z.coerce.boolean().nullable());
                 break;
             default:
                 continue;
@@ -156,7 +181,7 @@ async function spawnChildProcess(scriptPath, params, abortSignal) {
         }
     });
 }
-export function createDynamicTool(scriptPath, metadata) {
+function createDynamicTool(scriptPath, metadata) {
     const inputSchema = generateZodSchema(metadata.parameters);
     const toolName = `dynamic-${metadata.name}`;
     return {
@@ -165,56 +190,26 @@ export function createDynamicTool(scriptPath, metadata) {
                 description: metadata.description,
                 inputSchema,
             },
-            async *execute(input, { toolCallId, abortSignal }) {
+            display() {
+                return "running";
+            },
+            async execute(input, { abortSignal }) {
+                if (abortSignal?.aborted) {
+                    throw new Error("Execution aborted");
+                }
                 try {
-                    if (abortSignal?.aborted) {
-                        throw new Error("Execution aborted");
-                    }
-                    yield {
-                        name: metadata.name,
-                        event: "tool-init",
-                        id: toolCallId,
-                        data: "Running",
-                    };
-                    // Validate params again for safety
-                    try {
-                        inputSchema.parse(input);
-                    }
-                    catch (e) {
-                        const errMsg = `Invalid parameters for tool ${metadata.name}: ${e.message}`;
-                        yield {
-                            name: metadata.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: errMsg,
-                        };
-                        yield errMsg;
-                        return;
-                    }
-                    const result = await spawnChildProcess(scriptPath, input, abortSignal);
-                    yield {
-                        name: metadata.name,
-                        event: "tool-completion",
-                        id: toolCallId,
-                        data: "Completed",
-                    };
-                    yield result;
+                    inputSchema.parse(input);
                 }
-                catch (error) {
-                    yield {
-                        name: metadata.name,
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: `${metadata.name}: ${error.message}`,
-                    };
-                    yield error.message;
+                catch (e) {
+                    throw new Error(`Invalid parameters for tool ${metadata.name}: ${e.message}`);
                 }
+                return spawnChildProcess(scriptPath, input, abortSignal);
             },
         },
     };
 }
 export async function loadDynamicTools({ baseDir }) {
-    const projectConfig = await config.readProjectConfig();
+    const projectConfig = await config.getConfig();
     const dynamicConfig = projectConfig.tools.dynamicTools;
     if (!dynamicConfig.enabled) {
         logger.info("Dynamic tools disabled in config.");

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

@@ -1,10 +1,7 @@
-import type { ToolCallOptions } from "ai";
 import { z } from "zod";
-import type { ModelManager } from "../models/manager.ts";
-import type { TokenTracker } from "../tokens/tracker.ts";
-import type { ToolResult } from "./types.ts";
+import type { ToolExecutionOptions } from "./types.ts";
 export declare const EditFileTool: {
-    name: "editFile";
+    name: "Edit";
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
@@ -14,12 +11,9 @@ declare const inputSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type EditFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createEditFileTool: ({ workingDir, allowedDirs, modelManager, tokenTracker, enableLlmFix, }: {
+export declare const createEditFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
     allowedDirs?: string[];
-    modelManager?: ModelManager;
-    tokenTracker?: TokenTracker;
-    enableLlmFix?: boolean;
 }) => Promise<{
     toolDef: {
         description: string;
@@ -31,17 +25,13 @@ export declare const createEditFileTool: ({ workingDir, allowedDirs, modelManage
             }, z.core.$strip>>;
         }, z.core.$strip>;
     };
-    execute({ path, edits }: EditFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ path, edits }: EditFileInputSchema): string;
+    execute({ path, edits }: EditFileInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
 interface FileEdit {
     oldText: string;
     newText: string;
 }
-export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean, abortSignal?: AbortSignal, options?: {
-    modelManager?: ModelManager;
-    tokenTracker?: TokenTracker;
-    enableLlmFix?: boolean;
-    instruction?: string;
-}): Promise<string>;
+export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean, abortSignal?: AbortSignal): Promise<string>;
 export {};
 //# sourceMappingURL=edit-file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;iBAcf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,wEAMtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;;;;;;;;;;;6BAcsB,mBAAmB,+BACP,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAkDhC,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,EACzB,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GACA,OAAO,CAAC,MAAM,CAAC,CA2DjB"}
+{"version":3,"file":"edit-file.d.ts","sourceRoot":"","sources":["../../source/tools/edit-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;iBAcf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,8BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;;;;6BAa4B,mBAAmB;6BAIzB,mBAAmB,mBACnB,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqBrB,CAAC;AAyBF,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,UAAQ,EACd,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,CAAC,CAsDjB"}

package/dist/tools/edit-file.js

@@ -1,12 +1,12 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { createTwoFilesPatch } from "diff";
 import { z } from "zod";
-import { logger } from "../logger.js";
+import { config } from "../config.js";
+import { clearProjectStatusCache } from "../repl/project-status.js";
 import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
-import { fixLlmEditWithInstruction } from "./llm-edit-fixer.js";
+import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
 export const EditFileTool = {
-    name: "editFile",
+    name: "Edit",
 };
 const inputSchema = z.object({
     path: z.string().describe("The path of the file to edit."),
@@ -19,7 +19,7 @@ const inputSchema = z.object({
         newText: z.string().describe("Text to replace with"),
     })),
 });
-export const createEditFileTool = async ({ workingDir, allowedDirs, modelManager, tokenTracker, enableLlmFix = true, }) => {
+export const createEditFileTool = async ({ workingDir, allowedDirs, }) => {
     const allowedDirectory = allowedDirs ?? [workingDir];
     return {
         toolDef: {
@@ -31,40 +31,19 @@ export const createEditFileTool = async ({ workingDir, allowedDirs, modelManager
                 "Multi-line strings require exact character-by-character matching including whitespace.",
             inputSchema,
         },
-        async *execute({ path, edits }, { toolCallId, abortSignal }) {
-            try {
-                if (abortSignal?.aborted) {
-                    throw new Error("File editing aborted");
-                }
-                yield {
-                    name: EditFileTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${style.cyan(path)}`,
-                };
-                const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
-                const result = await applyFileEdits(validPath, edits, false, abortSignal, {
-                    modelManager,
-                    tokenTracker,
-                    enableLlmFix,
-                });
-                yield {
-                    name: EditFileTool.name,
-                    id: toolCallId,
-                    event: "tool-completion",
-                    data: `Applied ${edits.length} edits`,
-                };
-                yield result;
-            }
-            catch (error) {
-                yield {
-                    name: EditFileTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield `Failed to edit file: ${error.message}`;
+        display({ path, edits }) {
+            return `\n> ${style.cyan(path)} (${edits.length} edit${edits.length === 1 ? "" : "s"})`;
+        },
+        async execute({ path, edits }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("File editing aborted");
             }
+            const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory, { abortSignal });
+            const projectConfig = await config.getConfig();
+            validateFileNotReadOnly(validPath, projectConfig, workingDir);
+            const result = await applyFileEdits(validPath, edits, false, abortSignal);
+            clearProjectStatusCache();
+            return result;
         },
     };
 };
@@ -78,7 +57,7 @@ function createUnifiedDiff(originalContent, newContent, filepath = "file") {
     const normalizedNew = normalizeLineEndings(newContent);
     return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
 }
-export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal, options) {
+export async function applyFileEdits(filePath, edits, dryRun = false, abortSignal) {
     if (abortSignal?.aborted) {
         throw new Error("File edit operation aborted");
     }
@@ -96,7 +75,7 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted during processing");
         }
-        const result = await applyEditWithLlmFix(edit, modifiedContent, abortSignal, options);
+        const result = await applyEditWithLlmFix(edit, modifiedContent);
         if (result.success) {
             modifiedContent = result.content;
         }
@@ -111,7 +90,7 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     while (diff.includes("`".repeat(numBackticks))) {
         numBackticks++;
     }
-    const formattedDiff = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
+    const formattedDiff = `${"`".repeat(numBackticks)} diff\n${diff}\n${"`".repeat(numBackticks)}`;
     if (!dryRun) {
         if (abortSignal?.aborted) {
             throw new Error("File edit operation aborted before writing");
@@ -125,38 +104,15 @@ export async function applyFileEdits(filePath, edits, dryRun = false, abortSigna
     return formattedDiff;
 }
 /**
- * Applies a single edit with LLM fix fallback
+ * Applies a single edit
  */
-async function applyEditWithLlmFix(edit, content, abortSignal, options) {
+async function applyEditWithLlmFix(edit, content) {
     const { oldText, newText } = edit;
     // Try the original edit first
     const originalResult = applyLiteralEdit(content, oldText, newText);
     if (originalResult.matchCount > 0) {
         return { success: true, content: originalResult.content };
     }
-    // If LLM fix is enabled and dependencies are available, try to fix the edit
-    if (options?.enableLlmFix !== false &&
-        options?.modelManager &&
-        options?.tokenTracker) {
-        try {
-            const fixedEdit = await fixLlmEditWithInstruction(options.instruction, oldText, newText, "oldText not found in content", content, options.modelManager ?? undefined, abortSignal);
-            if (fixedEdit && !fixedEdit.noChangesRequired) {
-                // Retry the edit with the corrected search string
-                const correctedResult = applyLiteralEdit(content, fixedEdit.search, fixedEdit.replace);
-                if (correctedResult.matchCount > 0) {
-                    return { success: true, content: correctedResult.content };
-                }
-            }
-            else if (fixedEdit?.noChangesRequired) {
-                // No changes required, skip this edit
-                return { success: true, content };
-            }
-        }
-        catch (llmError) {
-            // If LLM fix fails, fall back to original error
-            logger.warn(llmError, "LLM edit fix failed:");
-        }
-    }
     return { success: false, content };
 }
 /**

package/dist/tools/glob.d.ts

@@ -1,36 +1,35 @@
-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 GlobTool: {
-    name: "globFiles";
+    name: "Glob";
 };
 export declare const inputSchema: z.ZodObject<{
     patterns: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     path: z.ZodString;
-    gitignore: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-    recursive: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-    expandDirectories: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+    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.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-    cwd: z.ZodNullable<z.ZodCoercedString<unknown>>;
+    cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
+    maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type GlobInputSchema = z.infer<typeof inputSchema>;
-export declare const createGlobTool: (options: {
-    tokenCounter: TokenCounter;
-}) => {
+export declare const createGlobTool: () => {
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             patterns: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
             path: z.ZodString;
-            gitignore: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-            recursive: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
-            expandDirectories: z.ZodNullable<z.ZodCoercedBoolean<unknown>>;
+            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.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            cwd: z.ZodNullable<z.ZodCoercedString<unknown>>;
+            cwd: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedString<unknown>>>;
+            maxResults: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;
     };
-    execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, }: GlobInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ patterns, path }: GlobInputSchema): string;
+    execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }: GlobInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 };
 export {};
 //# sourceMappingURL=glob.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/tools/glob.ts"],"names":[],"mappings":"AAGA,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;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;iBA2BtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc,GAAI,SAAS;IAAE,YAAY,EAAE,YAAY,CAAA;CAAE;;;;;;;;;;;;;4FAkB7D,eAAe,+BACW,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;CA2HhC,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;AAIvD,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;iBA4BtB,CAAC;AAEH,KAAK,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;gCAMK,eAAe;wGAkBtC,eAAe,mBACD,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;CA4ErB,CAAC"}

package/dist/tools/glob.js

@@ -1,143 +1,112 @@
 import * as fs from "node:fs";
 import * as nodePath from "node:path";
-import { inspect } from "node:util";
 import { z } from "zod";
 import style from "../terminal/style.js";
-import { manageTokenLimit } from "../tokens/threshold.js";
 import { glob } from "../utils/glob.js";
+import { convertNullString } from "../utils/zod.js";
+const DEFAULT_MAX_RESULTS = 100;
 export const GlobTool = {
-    name: "globFiles",
+    name: "Glob",
 };
 export const inputSchema = z.object({
     patterns: z
         .union([z.string(), z.array(z.string())])
         .describe("Glob patterns to search for (e.g., '*.ts', '**/*.test.ts', 'src/**/*.js')"),
     path: z.string().describe("Base directory to search in"),
-    gitignore: z.coerce
-        .boolean()
-        .nullable()
+    gitignore: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Respect ignore patterns in .gitignore files. (default: true)"),
-    recursive: z.coerce
-        .boolean()
-        .nullable()
+    recursive: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Search recursively. (default: true)"),
-    expandDirectories: z.coerce
-        .boolean()
-        .nullable()
+    expandDirectories: z
+        .preprocess((val) => convertNullString(val), z.coerce.boolean().nullable())
         .describe("Automatically expand directories to files. (default: true)"),
     ignoreFiles: z
         .union([z.string(), z.array(z.string())])
         .nullable()
         .describe("Glob patterns to look for ignore files. (default: undefined)"),
-    cwd: z.coerce
-        .string()
-        .nullable()
+    cwd: z
+        .preprocess((val) => convertNullString(val), z.coerce.string().nullable())
         .describe("Current working directory override. (default: process.cwd())"),
+    maxResults: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of files to return. Set to 0 for no limit. (Default: 100)"),
 });
-export const createGlobTool = (options) => {
-    const { tokenCounter } = options;
+export const createGlobTool = () => {
     return {
         toolDef: {
-            description: "Search for files using glob patterns (e.g., `*.ts`, `**/*.test.ts`, `src/**/*.js`). Uses the fast-glob library with support for gitignore, recursive searching, and directory expansion.",
+            description: `Search for files using glob patterns (e.g., *.ts, **/*.test.ts, src/**/*.js). Uses the fast-glob library with support for .gitignore, recursive searching, directory expansion, and automatic result limiting to prevent overwhelming output. Default limit is ${DEFAULT_MAX_RESULTS} files. Use maxResults parameter to override this limit.`,
             inputSchema,
         },
-        async *execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, }, { toolCallId, abortSignal }) {
-            // Check if execution has been aborted
+        display({ patterns, path }) {
+            const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+            const patternStr = patternArray.length === 1
+                ? patternArray[0]
+                : JSON.stringify(patternArray);
+            return `\n> ${style.cyan(patternStr)} in ${style.cyan(path)}`;
+        },
+        async execute({ patterns, path, gitignore, recursive, expandDirectories, ignoreFiles, cwd, maxResults, }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("Glob search aborted");
             }
-            try {
-                const patternArray = Array.isArray(patterns) ? patterns : [patterns];
-                yield {
-                    name: GlobTool.name,
-                    event: "tool-init",
-                    id: toolCallId,
-                    data: `${style.cyan(inspect(patternArray))} in ${style.cyan(path)}`,
-                };
-                // Build glob options
-                const globOptions = {
-                    cwd: cwd || process.cwd(),
-                };
-                if (gitignore !== null) {
-                    globOptions["gitignore"] = gitignore;
-                }
-                if (recursive !== null) {
-                    globOptions["recursive"] = recursive;
-                }
-                if (expandDirectories !== null) {
-                    globOptions["expandDirectories"] = expandDirectories;
+            const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+            const globOptions = {
+                cwd: cwd || process.cwd(),
+            };
+            if (gitignore !== null) {
+                globOptions["gitignore"] = gitignore;
+            }
+            if (recursive !== null) {
+                globOptions["recursive"] = recursive;
+            }
+            if (expandDirectories !== null) {
+                globOptions["expandDirectories"] = expandDirectories;
+            }
+            if (ignoreFiles !== null) {
+                globOptions["ignoreFiles"] = ignoreFiles;
+            }
+            const matchingFiles = await glob(patternArray, {
+                ...globOptions,
+                cwd: path,
+            });
+            const filesWithStats = await Promise.all(matchingFiles.map(async (filePath) => {
+                const fullPath = nodePath.join(path, filePath);
+                try {
+                    const stats = await fs.promises.stat(fullPath);
+                    return {
+                        path: filePath,
+                        mtime: stats.mtime,
+                        isRecent: Date.now() - stats.mtime.getTime() < 7 * 24 * 60 * 60 * 1000,
+                    };
                 }
-                if (ignoreFiles !== null) {
-                    globOptions["ignoreFiles"] = ignoreFiles;
+                catch {
+                    return {
+                        path: filePath,
+                        mtime: new Date(0),
+                        isRecent: false,
+                    };
                 }
-                // Execute glob search
-                const matchingFiles = await glob(patternArray, {
-                    ...globOptions,
-                    cwd: path,
-                });
-                // Get file stats and sort by recency then alphabetically
-                const filesWithStats = await Promise.all(matchingFiles.map(async (filePath) => {
-                    const fullPath = nodePath.join(path, filePath);
-                    try {
-                        const stats = await fs.promises.stat(fullPath);
-                        return {
-                            path: filePath,
-                            mtime: stats.mtime,
-                            isRecent: Date.now() - stats.mtime.getTime() < 7 * 24 * 60 * 60 * 1000, // 7 days
-                        };
-                    }
-                    catch {
-                        // If stat fails, treat as old file
-                        return {
-                            path: filePath,
-                            mtime: new Date(0),
-                            isRecent: false,
-                        };
-                    }
-                }));
-                // Sort files: recent files first (newest to oldest), then older files alphabetically
-                const sortedFiles = filesWithStats
-                    .sort((a, b) => {
-                    // Recent files come first
-                    if (a.isRecent && !b.isRecent)
-                        return -1;
-                    if (!a.isRecent && b.isRecent)
-                        return 1;
-                    // Both recent: sort by modification time (newest first)
-                    if (a.isRecent && b.isRecent) {
-                        return b.mtime.getTime() - a.mtime.getTime();
-                    }
-                    // Both old: sort alphabetically by path
-                    return a.path.localeCompare(b.path);
-                })
-                    .map((file) => file.path);
-                // Format results
-                const resultContent = sortedFiles.length > 0
-                    ? sortedFiles.join("\n")
-                    : "No files found matching the specified patterns.";
-                const result = await manageTokenLimit(resultContent, tokenCounter, "Glob", "Use more specific glob patterns or recursive=false to reduce matches");
-                let completionMessage = `Found ${style.cyan(sortedFiles.length)} files.`;
-                if (result.truncated) {
-                    completionMessage += ` ${result.content}`;
+            }));
+            const sortedFiles = filesWithStats
+                .sort((a, b) => {
+                if (a.isRecent && !b.isRecent)
+                    return -1;
+                if (!a.isRecent && b.isRecent)
+                    return 1;
+                if (a.isRecent && b.isRecent) {
+                    return b.mtime.getTime() - a.mtime.getTime();
                 }
-                completionMessage += ` (${result.tokenCount} tokens)`;
-                yield {
-                    name: GlobTool.name,
-                    event: "tool-completion",
-                    id: toolCallId,
-                    data: completionMessage,
-                };
-                yield result.content;
-            }
-            catch (error) {
-                yield {
-                    name: GlobTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: error.message,
-                };
-                yield error.message;
-            }
+                return a.path.localeCompare(b.path);
+            })
+                .map((file) => file.path);
+            const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
+            const limitedFiles = effectiveMaxResults && effectiveMaxResults > 0
+                ? sortedFiles.slice(0, effectiveMaxResults)
+                : sortedFiles;
+            return limitedFiles.length > 0
+                ? limitedFiles.join("\n")
+                : "No files found matching the specified patterns.";
         },
     };
 };