@travisennis/acai 0.0.9 → 0.0.11

package/dist/tools/index.d.ts

@@ -11,15 +11,29 @@ export type CompleteToolNames = keyof CompleteToolSet;
 export declare function initTools({ workspace, }: {
     workspace: WorkspaceContext;
 }): Promise<{
+    readonly ApplyPatch: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                patchText: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ patchText }: {
+            patchText: string;
+        }): string;
+        execute({ patchText }: {
+            patchText: string;
+        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
     readonly Edit: {
         toolDef: {
             description: string;
             inputSchema: import("zod").ZodObject<{
                 path: import("zod").ZodString;
-                edits: import("zod").ZodArray<import("zod").ZodObject<{
+                edits: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodArray<import("zod").ZodObject<{
                     oldText: import("zod").ZodString;
                     newText: import("zod").ZodString;
-                }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path, edits }: {
@@ -112,7 +126,6 @@ export declare function initTools({ workspace, }: {
                 }>>>;
                 startLine: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
                 lineCount: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
-                maxBytes: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
             }, import("zod/v4/core").$strip>;
         };
         display({ path: providedPath, startLine, lineCount }: {
@@ -120,26 +133,24 @@ export declare function initTools({ workspace, }: {
             encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
-            maxBytes: number | null;
         }): string;
-        execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }: {
+        execute({ path: providedPath, encoding, startLine, lineCount, }: {
             path: string;
             encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex" | null;
             startLine: number | null;
             lineCount: number | null;
-            maxBytes: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
     readonly Glob: {
         toolDef: {
             description: string;
             inputSchema: import("zod").ZodObject<{
-                patterns: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>;
-                path: import("zod").ZodString;
+                patterns: import("zod").ZodPipe<import("zod").ZodTransform<{}, unknown>, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                path: import("zod").ZodPipe<import("zod").ZodTransform<{}, unknown>, import("zod").ZodString>;
                 gitignore: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
                 recursive: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
                 expandDirectories: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
-                ignoreFiles: import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>;
+                ignoreFiles: import("zod").ZodPipe<import("zod").ZodTransform<{} | null | undefined, unknown>, import("zod").ZodNullable<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString>]>>>;
                 cwd: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedString<unknown>>>;
                 maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
             }, import("zod/v4/core").$strip>;
@@ -252,5 +263,99 @@ export declare function initTools({ workspace, }: {
             path?: string | undefined;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
+    readonly Skill: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                skill: import("zod").ZodString;
+                args: import("zod").ZodOptional<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ skill: skillName }: {
+            skill: string;
+            args?: string | undefined;
+        }): string;
+        execute({ skill: skillName, args }: {
+            skill: string;
+            args?: string | undefined;
+        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
+    readonly Agent: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                prompt: import("zod").ZodString;
+                type: import("zod").ZodString;
+                timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>;
+        };
+        display: ({ prompt, type }: import("zod").infer<import("zod").ZodObject<{
+            prompt: import("zod").ZodString;
+            type: import("zod").ZodString;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>) => string;
+        execute: ({ prompt, type, timeout }: import("zod").infer<import("zod").ZodObject<{
+            prompt: import("zod").ZodString;
+            type: import("zod").ZodString;
+            timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>, { abortSignal }: import("./types.ts").ToolExecutionOptions) => Promise<string>;
+    };
+    readonly WebSearch: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                query: import("zod").ZodString;
+                numResults: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                timeout: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                provider: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    exa: "exa";
+                    duckduckgo: "duckduckgo";
+                }>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ query }: {
+            query: string;
+            numResults?: number | null | undefined;
+            timeout?: number | null | undefined;
+            provider?: "exa" | "duckduckgo" | undefined;
+        }): string;
+        execute(options: {
+            query: string;
+            numResults?: number | null | undefined;
+            timeout?: number | null | undefined;
+            provider?: "exa" | "duckduckgo" | undefined;
+        }, executionOptions: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
+    readonly WebFetch: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                url: import("zod").ZodString;
+                output: import("zod").ZodDefault<import("zod").ZodEnum<{
+                    markdown: "markdown";
+                    text: "text";
+                    html: "html";
+                    json: "json";
+                }>>;
+                jina: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+                timeout: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>>;
+                headers: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodTransform<string | null, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ url }: {
+            url: string;
+            output: "markdown" | "text" | "html" | "json";
+            jina?: boolean | null | undefined;
+            timeout?: number | null | undefined;
+            headers?: boolean | null | undefined;
+        }): string;
+        execute(options: {
+            url: string;
+            output: "markdown" | "text" | "html" | "json";
+            jina?: boolean | null | undefined;
+            timeout?: number | null | undefined;
+            headers?: boolean | null | undefined;
+        }, executionOptions: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
 }>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAepD,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAEtD,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAoBpD,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,eAAe,CACvE,OAAO,SAAS,CACjB,CAAC,CAAC,CAAC;CACL,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,UAAU,CAAC,IAAI,MAAM,eAAe,CAAC,OAAO,SAAS,CAAC,GAAG,IAAI,CAC5D,OAAO,EACP,MAAM,CACP;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,eAAe,CAAC;AAEtD,wBAAsB,SAAS,CAAC,EAC9B,SAAS,GACV,EAAE;IACD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EA"}

package/dist/tools/index.js

@@ -1,3 +1,6 @@
+import { config } from "../config/index.js";
+import { AgentTool, createAgentTools } from "./agent.js";
+import { ApplyPatchTool, createApplyPatchTool } from "./apply-patch.js";
 import { BashTool, createBashTool } from "./bash.js";
 import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
@@ -7,40 +10,48 @@ import { createGrepTool, GrepTool } from "./grep.js";
 import { createLsTool, LsTool } from "./ls.js";
 import { createReadFileTool, ReadFileTool } from "./read-file.js";
 import { createSaveFileTool, SaveFileTool } from "./save-file.js";
+import { createSkillTool, SkillTool } from "./skill.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({ workspace, }) {
-    const readFileTool = await createReadFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const editFileTool = await createEditFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const saveFileTool = await createSaveFileTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const directoryTreeTool = await createDirectoryTreeTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
+    const readFileTool = await createReadFileTool({ workspace });
+    const editFileTool = await createEditFileTool({ workspace });
+    const saveFileTool = await createSaveFileTool({ workspace });
+    const directoryTreeTool = await createDirectoryTreeTool({ workspace });
     const globTool = createGlobTool();
     const grepTool = createGrepTool();
     const thinkTool = createThinkTool();
-    const lsTool = await createLsTool({
-        workingDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
-    const bashTool = await createBashTool({
-        baseDir: workspace.primaryDir,
-        allowedDirs: workspace.allowedDirs,
-    });
+    const lsTool = await createLsTool({ workspace });
+    const projectConfig = await config.getConfig();
+    const bashTool = await createBashTool({ workspace, env: projectConfig.env });
+    const skillTool = await createSkillTool();
+    const agentTool = await createAgentTools({ workspace });
+    const webSearchTool = await createWebSearchTool();
+    const webFetchTool = await createWebFetchTool();
+    const applyPatchTool = await createApplyPatchTool({ workspace });
     const dynamicTools = await loadDynamicTools({
         baseDir: workspace.primaryDir,
+        existingToolNames: [
+            ApplyPatchTool.name,
+            EditFileTool.name,
+            BashTool.name,
+            SaveFileTool.name,
+            ReadFileTool.name,
+            GlobTool.name,
+            GrepTool.name,
+            DirectoryTreeTool.name,
+            ThinkTool.name,
+            LsTool.name,
+            SkillTool.name,
+            AgentTool.name,
+            WebSearchTool.name,
+            WebFetchTool.name,
+        ],
     });
     // Build tools object for AI SDK
     const tools = {
+        [ApplyPatchTool.name]: applyPatchTool,
         [EditFileTool.name]: editFileTool,
         [BashTool.name]: bashTool,
         [SaveFileTool.name]: saveFileTool,
@@ -50,6 +61,10 @@ export async function initTools({ workspace, }) {
         [DirectoryTreeTool.name]: directoryTreeTool,
         [ThinkTool.name]: thinkTool,
         [LsTool.name]: lsTool,
+        [SkillTool.name]: skillTool,
+        [AgentTool.name]: agentTool,
+        [WebSearchTool.name]: webSearchTool,
+        [WebFetchTool.name]: webFetchTool,
         // Add dynamic tools - they already have toolDef structure
         ...Object.fromEntries(Object.entries(dynamicTools).map(([name, toolObj]) => [name, toolObj])),
     };

package/dist/tools/ls.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const LsTool: {
     name: "LS";
@@ -9,8 +10,7 @@ declare const inputSchema: z.ZodObject<{
 }, z.core.$strip>;
 type LsInputSchema = z.infer<typeof inputSchema>;
 export declare const createLsTool: (options: {
-    workingDir: string;
-    allowedDirs?: string[];
+    workspace: WorkspaceContext;
 }) => Promise<{
     toolDef: {
         description: string;

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

@@ -1 +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"}
+{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../source/tools/ls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;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,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;2CAU0C,aAAa;2CAOnB,aAAa,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA6DrB,CAAC"}

package/dist/tools/ls.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { z } from "zod";
 import style from "../terminal/style.js";
 import { isDirectory } from "../utils/filesystem/operations.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { validatePath } from "../utils/filesystem/security.js";
 import { convertNullString } from "../utils/zod.js";
 export const LsTool = {
@@ -19,17 +20,18 @@ const inputSchema = z.object({
 });
 const DEFAULT_ENTRY_LIMIT = 500;
 export const createLsTool = async (options) => {
-    const { workingDir, allowedDirs } = options;
-    const allowedDirectory = allowedDirs ?? [workingDir];
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectory = allowedDirs ?? [primaryDir];
     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.`,
+            description: "List files in a single directory. Fast and simple - use this when you need a quick flat list of files in one directory. For recursive tree views, use DirectoryTree instead.",
             inputSchema,
         },
         display({ path: providedPath, limit }) {
             const dirPath = providedPath ?? ".";
             const effectiveLimit = limit ?? 500;
-            return `\n> Listing ${style.cyan(dirPath)} (limit: ${effectiveLimit})`;
+            const displayPath = toDisplayPath(dirPath);
+            return `${style.cyan(displayPath)} (limit: ${effectiveLimit})`;
         },
         async execute({ path: providedPath, limit }, { abortSignal }) {
             if (abortSignal?.aborted) {
@@ -37,7 +39,7 @@ export const createLsTool = async (options) => {
             }
             const dirPath = providedPath ?? ".";
             const effectiveLimit = limit ?? DEFAULT_ENTRY_LIMIT;
-            const resolvedPath = await validatePath(path.resolve(workingDir, dirPath), allowedDirectory, { requireExistence: true, abortSignal });
+            const resolvedPath = await validatePath(path.resolve(primaryDir, dirPath), allowedDirectory, { requireExistence: true, abortSignal });
             if (abortSignal?.aborted) {
                 throw new Error("Directory listing aborted before validation");
             }

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import type { ToolExecutionOptions } from "./types.ts";
 export declare const ReadFileTool: {
     name: "Read";
@@ -20,12 +21,10 @@ declare const inputSchema: z.ZodObject<{
     }>>>;
     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, }: {
-    workingDir: string;
-    allowedDirs?: string[];
+export declare const createReadFileTool: (options: {
+    workspace: WorkspaceContext;
 }) => Promise<{
     toolDef: {
         description: string;
@@ -46,11 +45,10 @@ export declare const createReadFileTool: ({ workingDir, allowedDirs, }: {
             }>>>;
             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>;
     };
     display({ path: providedPath, startLine, lineCount }: ReadFileInputSchema): string;
-    execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }: ReadFileInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+    execute({ path: providedPath, encoding, startLine, lineCount, }: 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,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"}
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAsBvD,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAkBf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;0DAOyD,mBAAmB;qEAUpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAsBrB,CAAC"}

package/dist/tools/read-file.js

@@ -1,12 +1,28 @@
 import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
 import { z } from "zod";
 import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "../utils/filesystem/security.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { convertNullString } from "../utils/zod.js";
 import { fileEncodingSchema } from "./types.js";
-// default limit in bytes
-const DEFAULT_BYTE_LIMIT = 80 * 1024;
+// hardcoded limit in bytes (50KB) - not configurable by the agent
+const BYTE_LIMIT = 50 * 1024;
+// Resolve a path for reading, expanding ~ and handling relative paths
+function resolveReadPath(providedPath, workingDir) {
+    // Expand ~ to home directory
+    let resolved = providedPath;
+    if (resolved.startsWith("~/") || resolved === "~") {
+        resolved = path.join(os.homedir(), resolved.slice(1));
+    }
+    // If not absolute, join with working directory
+    if (!path.isAbsolute(resolved)) {
+        resolved = path.join(workingDir, resolved);
+    }
+    return path.normalize(resolved);
+}
 export const ReadFileTool = {
     name: "Read",
 };
@@ -22,53 +38,82 @@ const inputSchema = z.object({
     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, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
+export const createReadFileTool = async (options) => {
+    const { primaryDir } = options.workspace;
     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. 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.`,
+            description: "Read the contents of a file.",
             inputSchema,
         },
         display({ path: providedPath, startLine, lineCount }) {
-            return `\n> ${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`;
+            const displayPath = toDisplayPath(providedPath);
+            return `${style.cyan(displayPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`;
         },
-        async execute({ path: providedPath, encoding, startLine, lineCount, maxBytes, }, { abortSignal }) {
+        async execute({ path: providedPath, encoding, startLine, lineCount, }, { 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 endIndex = Math.min(startIndex + count, totalLines);
-                file = lines.slice(startIndex, endIndex).join("\n");
-            }
-            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");
-                }
-            }
+            const filePath = resolveReadPath(providedPath, primaryDir);
+            const effectiveEncoding = encoding ?? "utf-8";
+            const file = await readFileContent(filePath, effectiveEncoding, startLine, lineCount, abortSignal);
+            validateByteLimit(file, effectiveEncoding, BYTE_LIMIT);
             return file;
         },
     };
 };
+// Read file content either line-by-line or as a whole
+async function readFileContent(filePath, encoding, startLine, lineCount, abortSignal) {
+    const useLineBasedRead = isNumber(startLine) || isNumber(lineCount);
+    if (useLineBasedRead) {
+        return readFileLines(filePath, startLine, lineCount, abortSignal);
+    }
+    if (abortSignal?.aborted) {
+        throw new Error("File reading aborted before file read");
+    }
+    return fs.readFile(filePath, { encoding });
+}
+// Read specific lines from a file using streaming
+async function readFileLines(filePath, startLine, lineCount, abortSignal) {
+    const fileStream = await fs.open(filePath, "r");
+    const rl = createInterface({
+        input: fileStream.createReadStream(),
+        crlfDelay: Number.POSITIVE_INFINITY,
+    });
+    const lines = [];
+    const startIndex = (startLine ?? 1) - 1;
+    const count = lineCount ?? Number.POSITIVE_INFINITY;
+    let currentIndex = 0;
+    for await (const line of rl) {
+        if (currentIndex >= startIndex && currentIndex < startIndex + count) {
+            lines.push(line);
+        }
+        currentIndex++;
+        if (currentIndex >= startIndex + count) {
+            break;
+        }
+        if (abortSignal?.aborted) {
+            rl.close();
+            await fileStream.close();
+            throw new Error("File reading aborted");
+        }
+    }
+    rl.close();
+    await fileStream.close();
+    if (startIndex >= currentIndex) {
+        throw new Error(`startLine ${startLine} is out of bounds for file with ${currentIndex} lines.`);
+    }
+    return lines.join("\n");
+}
+// Validate that file content doesn't exceed byte limit
+function validateByteLimit(file, encoding, maxBytes) {
+    const byteLength = Buffer.byteLength(file, encoding);
+    if (byteLength > maxBytes) {
+        const fileSizeKb = (byteLength / 1024).toFixed(1);
+        const limitKb = (maxBytes / 1024).toFixed(0);
+        throw new Error(`File (${fileSizeKb}KB) exceeds the ${limitKb}KB read limit. To read this file, use one of these options:\n` +
+            "• Use startLine and lineCount to read specific portions (e.g., startLine: 1, lineCount: 100)\n" +
+            "• Use the Grep tool to search for specific content\n" +
+            `• Use the Bash tool with 'tail' or 'head' commands`);
+    }
+}

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

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { WorkspaceContext } from "../index.ts";
 import { type ToolExecutionOptions } from "./types.ts";
 export declare const SaveFileTool: {
     name: "Write";
@@ -21,9 +22,8 @@ declare const inputSchema: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 type SaveFileInputSchema = z.infer<typeof inputSchema>;
-export declare const createSaveFileTool: ({ workingDir, allowedDirs, }: {
-    workingDir: string;
-    allowedDirs?: string[];
+export declare const createSaveFileTool: (options: {
+    workspace: WorkspaceContext;
 }) => Promise<{
     toolDef: {
         description: string;

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

@@ -1 +1 @@
-{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE3E,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,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;;;;;;;;;;;;;;;;;;;;;sBAYqB,mBAAmB;mDAII,mBAAmB,mBACzC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAqDrB,CAAC"}
+{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE3E,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AA8BvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;sBAUqB,mBAAmB;mDAKI,mBAAmB,mBACzC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA8BrB,CAAC"}

package/dist/tools/save-file.js

@@ -1,9 +1,10 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
-import { config } from "../config.js";
+import { config } from "../config/index.js";
 import { clearProjectStatusCache } from "../repl/project-status.js";
 import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.js";
 import { fileEncodingSchema } from "./types.js";
 export const SaveFileTool = {
@@ -16,46 +17,50 @@ const inputSchema = z.object({
         .describe('Encoding format for saving the file. Use "utf-8" as default for text files')
         .default("utf-8"),
 });
-export const createSaveFileTool = async ({ workingDir, allowedDirs, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
+async function checkFileNotReadOnly(filePath, projectConfig, primaryDir) {
+    try {
+        await fs.stat(filePath);
+        validateFileNotReadOnly(filePath, projectConfig, primaryDir);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+async function ensurePathIsFile(filePath) {
+    try {
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            throw new Error(`Cannot save file - path is a directory: ${filePath}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+export const createSaveFileTool = async (options) => {
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectory = allowedDirs ?? [primaryDir];
+    const projectConfig = await config.getConfig();
     return {
         toolDef: {
-            description: "Create a new file or completely overwrite an existing file with new content. " +
-                "Automatically creates all missing parent directories. " +
-                "Use with caution as it will overwrite existing files without warning. " +
-                "Handles text content with proper encoding. Only works within allowed directories.",
+            description: "Create or overwrite a file with new content.",
             inputSchema,
         },
         display({ path }) {
-            return `\n> ${style.cyan(path)}`;
+            const displayPath = toDisplayPath(path);
+            return `${style.cyan(displayPath)}`;
         },
         async execute({ path: userPath, content, encoding }, { abortSignal }) {
             if (abortSignal?.aborted) {
                 throw new Error("File saving aborted");
             }
-            const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
-            try {
-                await fs.stat(filePath);
-                const projectConfig = await config.getConfig();
-                validateFileNotReadOnly(filePath, projectConfig, workingDir);
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            }
-            try {
-                const stat = await fs.stat(filePath);
-                if (stat.isDirectory()) {
-                    throw new Error(`Cannot save file - path is a directory: ${filePath}`);
-                }
-            }
-            catch (error) {
-                if (error instanceof Error &&
-                    error.message.includes("is a directory")) {
-                    throw error;
-                }
-            }
+            const filePath = await validatePath(joinWorkingDir(userPath, primaryDir), allowedDirectory, { requireExistence: false, abortSignal });
+            await checkFileNotReadOnly(filePath, projectConfig, primaryDir);
+            await ensurePathIsFile(filePath);
             if (abortSignal?.aborted) {
                 throw new Error("File saving aborted before writing");
             }