@travisennis/acai 0.0.6 → 0.0.8

package/dist/tools/index.js

@@ -1,313 +1,57 @@
-import { tool } from "ai";
-import { AdvancedEditFileTool, createAdvancedEditFileTool, } from "./advanced-edit-file.js";
-import { AgentTool, createAgentTools } from "./agent.js";
 import { BashTool, createBashTool } from "./bash.js";
-import { CodeInterpreterTool, createCodeInterpreterTool, } from "./code-interpreter.js";
-import { createDeleteFileTool, DeleteFileTool } from "./delete-file.js";
 import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
 import { createEditFileTool, EditFileTool } from "./edit-file.js";
 import { createGlobTool, GlobTool } from "./glob.js";
 import { createGrepTool, GrepTool } from "./grep.js";
-import { createMoveFileTool, MoveFileTool } from "./move-file.js";
+import { createLsTool, LsTool } from "./ls.js";
 import { createReadFileTool, ReadFileTool } from "./read-file.js";
-import { createReadMultipleFilesTool, ReadMultipleFilesTool, } from "./read-multiple-files.js";
 import { createSaveFileTool, SaveFileTool } from "./save-file.js";
 import { createThinkTool, ThinkTool } from "./think.js";
-import { createWebFetchTool, WebFetchTool } from "./web-fetch.js";
-import { createWebSearchTool, WebSearchTool } from "./web-search.js";
-export async function initTools({ tokenCounter, workspace, modelManager, tokenTracker, }) {
+export async function initTools({ workspace, }) {
     const readFileTool = await createReadFileTool({
         workingDir: workspace.primaryDir,
         allowedDirs: workspace.allowedDirs,
-        tokenCounter,
-    });
-    const readMultipleFilesTool = await createReadMultipleFilesTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-        tokenCounter,
     });
     const editFileTool = await createEditFileTool({
         workingDir: workspace.primaryDir,
         allowedDirs: workspace.allowedDirs,
-        modelManager,
-        tokenTracker,
-    });
-    const advancedEditFileTool = await createAdvancedEditFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
     });
     const saveFileTool = await createSaveFileTool({
         workingDir: workspace.primaryDir,
         allowedDirs: workspace.allowedDirs,
     });
-    const moveFileTool = await createMoveFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
     const directoryTreeTool = await createDirectoryTreeTool({
         workingDir: workspace.primaryDir,
         allowedDirs: workspace.allowedDirs,
-        tokenCounter,
     });
-    const deleteFileTool = await createDeleteFileTool({
+    const globTool = createGlobTool();
+    const grepTool = createGrepTool();
+    const thinkTool = createThinkTool();
+    const lsTool = await createLsTool({
         workingDir: workspace.primaryDir,
         allowedDirs: workspace.allowedDirs,
     });
-    const codeInterpreterTool = await createCodeInterpreterTool({
-        tokenCounter,
-    });
-    const globTool = createGlobTool({
-        tokenCounter,
-    });
-    const grepTool = createGrepTool({
-        tokenCounter,
-    });
-    const thinkTool = createThinkTool();
-    const webFetchTool = createWebFetchTool({
-        tokenCounter,
-    });
-    const webSearchTool = createWebSearchTool({
-        tokenCounter,
-    });
     const bashTool = await createBashTool({
         baseDir: workspace.primaryDir,
         allowedDirs: workspace.allowedDirs,
-        tokenCounter,
     });
     const dynamicTools = await loadDynamicTools({
         baseDir: workspace.primaryDir,
     });
     // Build tools object for AI SDK
     const tools = {
-        [EditFileTool.name]: tool(editFileTool.toolDef),
-        [AdvancedEditFileTool.name]: tool(advancedEditFileTool.toolDef),
-        [BashTool.name]: tool(bashTool.toolDef),
-        [SaveFileTool.name]: tool(saveFileTool.toolDef),
-        [DeleteFileTool.name]: tool(deleteFileTool.toolDef),
-        [MoveFileTool.name]: tool(moveFileTool.toolDef),
-        [ReadFileTool.name]: tool(readFileTool.toolDef),
-        [ReadMultipleFilesTool.name]: tool(readMultipleFilesTool.toolDef),
-        [GlobTool.name]: tool(globTool.toolDef),
-        [GrepTool.name]: tool(grepTool.toolDef),
-        [DirectoryTreeTool.name]: tool(directoryTreeTool.toolDef),
-        [CodeInterpreterTool.name]: tool(codeInterpreterTool.toolDef),
-        [ThinkTool.name]: tool(thinkTool.toolDef),
-        [WebFetchTool.name]: tool(webFetchTool.toolDef),
-        [WebSearchTool.name]: tool(webSearchTool.toolDef),
+        [EditFileTool.name]: editFileTool,
+        [BashTool.name]: bashTool,
+        [SaveFileTool.name]: saveFileTool,
+        [ReadFileTool.name]: readFileTool,
+        [GlobTool.name]: globTool,
+        [GrepTool.name]: grepTool,
+        [DirectoryTreeTool.name]: directoryTreeTool,
+        [ThinkTool.name]: thinkTool,
+        [LsTool.name]: lsTool,
         // Add dynamic tools - they already have toolDef structure
-        ...Object.fromEntries(Object.entries(dynamicTools).map(([name, toolObj]) => [
-            name,
-            tool(toolObj.toolDef),
-        ])),
-    };
-    // Build executors map for manual loop
-    const executors = new Map();
-    // Add bash tool
-    executors.set(BashTool.name, bashTool.execute);
-    // Add editFile tool
-    executors.set(EditFileTool.name, editFileTool.execute);
-    // Add advancedEditFile tool
-    executors.set(AdvancedEditFileTool.name, advancedEditFileTool.execute);
-    // Add saveFile tool
-    executors.set(SaveFileTool.name, saveFileTool.execute);
-    // Add deleteFile tool
-    executors.set(DeleteFileTool.name, deleteFileTool.execute);
-    // Add moveFile tool
-    executors.set(MoveFileTool.name, moveFileTool.execute);
-    // Add readFile tool
-    executors.set(ReadFileTool.name, readFileTool.execute);
-    // Add readMultipleFiles tool
-    executors.set(ReadMultipleFilesTool.name, readMultipleFilesTool.execute);
-    // Add glob tool
-    executors.set(GlobTool.name, globTool.execute);
-    // Add grep tool
-    executors.set(GrepTool.name, grepTool.execute);
-    // Add directoryTree tool
-    executors.set(DirectoryTreeTool.name, directoryTreeTool.execute);
-    // Add webFetch tool
-    executors.set(WebFetchTool.name, webFetchTool.execute);
-    // Add webSearch tool
-    executors.set(WebSearchTool.name, webSearchTool.execute);
-    // Add think tool
-    executors.set(ThinkTool.name, thinkTool.execute);
-    // Add codeInterpreter tool
-    executors.set(CodeInterpreterTool.name, codeInterpreterTool.execute);
-    // Add dynamic tools to executors
-    for (const [name, toolObj] of Object.entries(dynamicTools)) {
-        executors.set(name, toolObj.execute);
-    }
-    return {
-        toolDefs: tools,
-        executors,
-    };
-}
-export async function initCliTools({ tokenCounter, workspace, modelManager, tokenTracker, }) {
-    const readFileTool = await createReadFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-        tokenCounter,
-    });
-    const readMultipleFilesTool = await createReadMultipleFilesTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-        tokenCounter,
-    });
-    const editFileTool = await createEditFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-        modelManager,
-        tokenTracker,
-    });
-    const advancedEditFileTool = await createAdvancedEditFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const saveFileTool = await createSaveFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const moveFileTool = await createMoveFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const directoryTreeTool = await createDirectoryTreeTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-        tokenCounter,
-    });
-    const deleteFileTool = await createDeleteFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const codeInterpreterTool = await createCodeInterpreterTool({
-        tokenCounter,
-    });
-    const globTool = createGlobTool({
-        tokenCounter,
-    });
-    const grepTool = createGrepTool({
-        tokenCounter,
-    });
-    const thinkTool = createThinkTool();
-    const webFetchTool = createWebFetchTool({
-        tokenCounter,
-    });
-    const webSearchTool = createWebSearchTool({
-        tokenCounter,
-    });
-    const bashTool = await createBashTool({
-        baseDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-        tokenCounter,
-    });
-    const dynamicTools = await loadDynamicTools({
-        baseDir: workspace.primaryDir,
-    });
-    const tools = {
-        [EditFileTool.name]: tool({
-            ...editFileTool.toolDef,
-            execute: editFileTool.execute,
-        }),
-        [AdvancedEditFileTool.name]: tool({
-            ...advancedEditFileTool.toolDef,
-            execute: advancedEditFileTool.execute,
-        }),
-        [BashTool.name]: tool({
-            ...bashTool.toolDef,
-            execute: bashTool.execute,
-        }),
-        [SaveFileTool.name]: tool({
-            ...saveFileTool.toolDef,
-            execute: saveFileTool.execute,
-        }),
-        [DeleteFileTool.name]: tool({
-            ...deleteFileTool.toolDef,
-            execute: deleteFileTool.execute,
-        }),
-        [MoveFileTool.name]: tool({
-            ...moveFileTool.toolDef,
-            execute: moveFileTool.execute,
-        }),
-        [ReadFileTool.name]: tool({
-            ...readFileTool.toolDef,
-            execute: readFileTool.execute,
-        }),
-        [ReadMultipleFilesTool.name]: tool({
-            ...readMultipleFilesTool.toolDef,
-            execute: readMultipleFilesTool.execute,
-        }),
-        [GlobTool.name]: tool({
-            ...globTool.toolDef,
-            execute: globTool.execute,
-        }),
-        [GrepTool.name]: tool({
-            ...grepTool.toolDef,
-            execute: grepTool.execute,
-        }),
-        [DirectoryTreeTool.name]: tool({
-            ...directoryTreeTool.toolDef,
-            execute: directoryTreeTool.execute,
-        }),
-        [CodeInterpreterTool.name]: tool({
-            ...codeInterpreterTool.toolDef,
-            execute: codeInterpreterTool.execute,
-        }),
-        [ThinkTool.name]: tool({
-            ...thinkTool.toolDef,
-            execute: thinkTool.execute,
-        }),
-        [WebFetchTool.name]: tool({
-            ...webFetchTool.toolDef,
-            execute: webFetchTool.execute,
-        }),
-        [WebSearchTool.name]: tool({
-            ...webSearchTool.toolDef,
-            execute: webSearchTool.execute,
-        }),
-        // Add dynamic tools with execute functions
-        ...Object.fromEntries(Object.entries(dynamicTools).map(([name, toolObj]) => [
-            name,
-            tool({
-                ...toolObj.toolDef,
-                execute: toolObj.execute,
-            }),
-        ])),
-    };
-    return {
-        toolDefs: tools,
-    };
-}
-export async function initAgents({ modelManager, tokenTracker, tokenCounter, workspace, }) {
-    const agentTools = createAgentTools({
-        modelManager,
-        tokenTracker,
-        tokenCounter,
-        workspace,
-    });
-    const tools = {
-        [AgentTool.name]: tool(agentTools.toolDef),
-    };
-    // Build executors map for manual loop
-    const executors = new Map();
-    executors.set(AgentTool.name, agentTools.execute);
-    return {
-        toolDefs: tools,
-        executors,
-    };
-}
-export async function initCliAgents({ modelManager, tokenTracker, tokenCounter, workspace, }) {
-    const agentTools = createAgentTools({
-        modelManager,
-        tokenTracker,
-        tokenCounter,
-        workspace,
-    });
-    const tools = {
-        [AgentTool.name]: tool({
-            ...agentTools.toolDef,
-            execute: agentTools.execute,
-        }),
+        ...Object.fromEntries(Object.entries(dynamicTools).map(([name, toolObj]) => [name, toolObj])),
     };
-    return { toolDefs: tools };
+    return tools;
 }

package/dist/tools/ls.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { ToolExecutionOptions } from "./types.ts";
+export declare const LsTool: {
+    name: "LS";
+};
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    limit: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+}, z.core.$strip>;
+type LsInputSchema = z.infer<typeof inputSchema>;
+export declare const createLsTool: (options: {
+    workingDir: string;
+    allowedDirs?: string[];
+}) => Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodOptional<z.ZodString>;
+            limit: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+        }, z.core.$strip>;
+    };
+    display({ path: providedPath, limit }: LsInputSchema): string;
+    execute({ path: providedPath, limit }: LsInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+}>;
+export {};
+//# sourceMappingURL=ls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../source/tools/ls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,MAAM;;CAElB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAQf,CAAC;AAEH,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAIjD,eAAO,MAAM,YAAY,GAAU,SAAS;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;;;;;;;;2CAS0C,aAAa;2CAMnB,aAAa,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6DrB,CAAC"}

package/dist/tools/ls.js

@@ -0,0 +1,80 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import style from "../terminal/style.js";
+import { isDirectory } from "../utils/filesystem/operations.js";
+import { validatePath } from "../utils/filesystem/security.js";
+import { convertNullString } from "../utils/zod.js";
+export const LsTool = {
+    name: "LS",
+};
+const inputSchema = z.object({
+    path: z
+        .string()
+        .optional()
+        .describe("Directory to list (default: current directory)"),
+    limit: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of entries to return (default: 500)"),
+});
+const DEFAULT_ENTRY_LIMIT = 500;
+export const createLsTool = async (options) => {
+    const { workingDir, allowedDirs } = options;
+    const allowedDirectory = allowedDirs ?? [workingDir];
+    return {
+        toolDef: {
+            description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is limited to ${DEFAULT_ENTRY_LIMIT} entries by default. Use the limit parameter to adjust.`,
+            inputSchema,
+        },
+        display({ path: providedPath, limit }) {
+            const dirPath = providedPath ?? ".";
+            const effectiveLimit = limit ?? 500;
+            return `\n> Listing ${style.cyan(dirPath)} (limit: ${effectiveLimit})`;
+        },
+        async execute({ path: providedPath, limit }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("Directory listing aborted");
+            }
+            const dirPath = providedPath ?? ".";
+            const effectiveLimit = limit ?? DEFAULT_ENTRY_LIMIT;
+            const resolvedPath = await validatePath(path.resolve(workingDir, dirPath), allowedDirectory, { requireExistence: true, abortSignal });
+            if (abortSignal?.aborted) {
+                throw new Error("Directory listing aborted before validation");
+            }
+            const isDir = await isDirectory(resolvedPath);
+            if (!isDir) {
+                throw new Error(`Not a directory: ${resolvedPath}`);
+            }
+            let entries;
+            try {
+                entries = await fs.readdir(resolvedPath);
+            }
+            catch (e) {
+                throw new Error(`Cannot read directory: ${e.message}`);
+            }
+            entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            const results = [];
+            for (const entry of entries) {
+                if (results.length >= effectiveLimit) {
+                    break;
+                }
+                const fullPath = path.join(resolvedPath, entry);
+                let suffix = "";
+                try {
+                    const entryStat = await fs.stat(fullPath);
+                    if (entryStat.isDirectory()) {
+                        suffix = "/";
+                    }
+                }
+                catch {
+                    continue;
+                }
+                results.push(entry + suffix);
+            }
+            if (results.length === 0) {
+                return "(empty directory)";
+            }
+            return results.join("\n");
+        },
+    };
+};

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

@@ -1,13 +1,11 @@
-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 ReadFileTool: {
-    name: "readFile";
+    name: "Read";
 };
 declare const inputSchema: z.ZodObject<{
     path: z.ZodString;
-    encoding: z.ZodEnum<{
+    encoding: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
         utf8: "utf8";
         ascii: "ascii";
         "utf-8": "utf-8";
@@ -19,21 +17,21 @@ declare const inputSchema: z.ZodObject<{
         latin1: "latin1";
         binary: "binary";
         hex: "hex";
-    }>;
-    startLine: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
-    lineCount: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+    }>>>;
+    startLine: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    lineCount: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+    maxBytes: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
 }, z.core.$strip>;
 type ReadFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createReadFileTool: ({ workingDir, allowedDirs, tokenCounter, }: {
+export declare const createReadFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
     allowedDirs?: string[];
-    tokenCounter: TokenCounter;
 }) => Promise<{
     toolDef: {
         description: string;
         inputSchema: z.ZodObject<{
             path: z.ZodString;
-            encoding: z.ZodEnum<{
+            encoding: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
                 utf8: "utf8";
                 ascii: "ascii";
                 "utf-8": "utf-8";
@@ -45,12 +43,14 @@ export declare const createReadFileTool: ({ workingDir, allowedDirs, tokenCounte
                 latin1: "latin1";
                 binary: "binary";
                 hex: "hex";
-            }>;
-            startLine: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
-            lineCount: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+            }>>>;
+            startLine: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            lineCount: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+            maxBytes: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
         }, z.core.$strip>;
     };
-    execute({ path: providedPath, encoding, startLine, lineCount, }: ReadFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
+    display({ path: providedPath, startLine, lineCount }: ReadFileInputSchema): string;
+    execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }: ReadFileInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
 }>;
 export {};
 //# sourceMappingURL=read-file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.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;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAef,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,4CAItC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;;;;;;;;;;;;qEAiBQ,mBAAmB,+BACO,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAoFhC,CAAC"}
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAMvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;iBAuBf,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;;;;;;;;;;;;;;;;;;;;;;;0DAOyD,mBAAmB;+EAUpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqDrB,CAAC"}

package/dist/tools/read-file.js

@@ -2,97 +2,73 @@ import fs from "node:fs/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
 import { z } from "zod";
 import style from "../terminal/style.js";
-import { manageTokenLimit } from "../tokens/threshold.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
+import { convertNullString } from "../utils/zod.js";
 import { fileEncodingSchema } from "./types.js";
+// default limit in bytes
+const DEFAULT_BYTE_LIMIT = 80 * 1024;
 export const ReadFileTool = {
-    name: "readFile",
+    name: "Read",
 };
 const inputSchema = z.object({
     path: z.string().describe("Absolute path to file to read"),
-    encoding: fileEncodingSchema.describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
-    startLine: z.coerce
-        .number()
+    encoding: fileEncodingSchema
         .nullable()
-        .describe("1-based line number to start reading from. Pass null to start at beginning of file"),
-    lineCount: z.coerce
-        .number()
-        .nullable()
-        .describe("Maximum number of lines to read. Pass null to get all lines."),
+        .default("utf-8")
+        .describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
+    startLine: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("1-based line number to start reading from. Required but nullable. Pass null to start at beginning of file"),
+    lineCount: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of lines to read. Required but nullable. Pass null to get all lines."),
+    maxBytes: z
+        .preprocess((val) => convertNullString(val), z.coerce.number().nullable())
+        .describe("Maximum number of bytes to read. Set to 0 for no limit. (Default: 80KB)"),
 });
-export const createReadFileTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+export const createReadFileTool = async ({ workingDir, allowedDirs, }) => {
     const allowedDirectory = allowedDirs ?? [workingDir];
     return {
         toolDef: {
-            description: "Read the complete contents of a file from the file system unless startLine and lineCount are given to read a file selection. " +
-                "Handles various text encodings and provides detailed error messages " +
-                "if the file cannot be read. Use this tool when you need to examine " +
-                "the contents of a single file. Only works within allowed directories.",
+            description: `Read the complete contents of a file from the file system unless startLine and lineCount are given to read a file selection. Handles various text encodings and provides detailed error messages if the file cannot be read. Use this tool when you need to examine the contents of a single file. Only works within allowed directories. Automatically limits file size to prevent overwhelming output. Default limit is ${DEFAULT_BYTE_LIMIT} bytes (${DEFAULT_BYTE_LIMIT / 1024}KB). Use maxBytes parameter to override this limit.`,
             inputSchema,
         },
-        async *execute({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) {
-            try {
-                // Check if execution has been aborted
-                if (abortSignal?.aborted) {
-                    throw new Error("File reading aborted");
-                }
-                yield {
-                    name: ReadFileTool.name,
-                    id: toolCallId,
-                    event: "tool-init",
-                    data: `${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
-                };
-                const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
-                if (abortSignal?.aborted) {
-                    throw new Error("File reading aborted before file read");
-                }
-                let file = await fs.readFile(filePath, { encoding });
-                // Apply line-based selection if requested
-                if (isNumber(startLine) || isNumber(lineCount)) {
-                    const lines = file.split("\n");
-                    const totalLines = lines.length;
-                    const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
-                    const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
-                    if (startIndex < 0 || startIndex >= totalLines) {
-                        const errorMsg = `startLine ${startLine} is out of bounds for file with ${totalLines} lines.`;
-                        yield {
-                            name: ReadFileTool.name,
-                            event: "tool-error",
-                            id: toolCallId,
-                            data: errorMsg,
-                        };
-                        yield errorMsg;
-                        return;
-                    }
-                    const endIndex = Math.min(startIndex + count, totalLines);
-                    file = lines.slice(startIndex, endIndex).join("\n");
+        display({ path: providedPath, startLine, lineCount }) {
+            return `\n> ${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`;
+        },
+        async execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }, { abortSignal }) {
+            if (abortSignal?.aborted) {
+                throw new Error("File reading aborted");
+            }
+            const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
+            if (abortSignal?.aborted) {
+                throw new Error("File reading aborted before file read");
+            }
+            let file = await fs.readFile(filePath, {
+                encoding: encoding ?? "utf-8",
+            });
+            if (isNumber(startLine) || isNumber(lineCount)) {
+                const lines = file.split("\n");
+                const totalLines = lines.length;
+                const startIndex = (startLine ?? 1) - 1;
+                const count = lineCount ?? totalLines - startIndex;
+                if (startIndex < 0 || startIndex >= totalLines) {
+                    throw new Error(`startLine ${startLine} is out of bounds for file with ${totalLines} lines.`);
                 }
-                const result = await manageTokenLimit(file, tokenCounter, "ReadFile", isNumber(startLine) || isNumber(lineCount)
-                    ? "Consider adjusting startLine/lineCount or using grepFiles"
-                    : "Use startLine and lineCount parameters to read specific portions, or use grepFiles for targeted access", encoding);
-                // Calculate line count for the returned content
-                const linesRead = result.content.split("\n").length;
-                yield {
-                    name: ReadFileTool.name,
-                    id: toolCallId,
-                    event: "tool-completion",
-                    // Include success, line count, and token count
-                    data: !result.truncated
-                        ? `Read ${linesRead} lines (${result.tokenCount} tokens)`
-                        : result.content,
-                };
-                yield result.content;
+                const endIndex = Math.min(startIndex + count, totalLines);
+                file = lines.slice(startIndex, endIndex).join("\n");
             }
-            catch (error) {
-                const errorMsg = `${error.message}`;
-                yield {
-                    name: ReadFileTool.name,
-                    event: "tool-error",
-                    id: toolCallId,
-                    data: errorMsg,
-                };
-                yield errorMsg;
+            const effectiveMaxBytes = maxBytes ?? DEFAULT_BYTE_LIMIT;
+            if (effectiveMaxBytes !== null &&
+                effectiveMaxBytes !== undefined &&
+                effectiveMaxBytes > 0) {
+                const buffer = Buffer.from(file, encoding ?? "utf-8");
+                if (buffer.byteLength > effectiveMaxBytes) {
+                    const truncatedBuffer = buffer.subarray(0, effectiveMaxBytes);
+                    file = truncatedBuffer.toString(encoding ?? "utf-8");
+                }
             }
+            return file;
         },
     };
 };