@travisennis/acai 0.0.8 → 0.0.10

package/dist/tools/index.d.ts

@@ -16,10 +16,10 @@ export declare function initTools({ workspace, }: {
             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 }: {
@@ -134,12 +134,12 @@ export declare function initTools({ workspace, }: {
         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>;
@@ -203,6 +203,50 @@ export declare function initTools({ workspace, }: {
             maxResults: number | null;
         }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
     };
+    readonly CodeSearch: {
+        toolDef: {
+            description: string;
+            inputSchema: import("zod").ZodObject<{
+                query: import("zod").ZodString;
+                path: import("zod").ZodDefault<import("zod").ZodString>;
+                regexPattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
+                filePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
+                excludePattern: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
+                excludeDir: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodString>>;
+                maxResults: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                contextLines: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedNumber<unknown>>>;
+                filesOnly: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
+                showContent: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
+                codeOnly: import("zod").ZodPipe<import("zod").ZodTransform<unknown, unknown>, import("zod").ZodNullable<import("zod").ZodCoercedBoolean<unknown>>>;
+            }, import("zod/v4/core").$strip>;
+        };
+        display({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: {
+            query: string;
+            path: string;
+            regexPattern: string | null;
+            filePattern: string | null;
+            excludePattern: string | null;
+            excludeDir: string | null;
+            maxResults: number | null;
+            contextLines: number | null;
+            filesOnly: boolean | null;
+            showContent: boolean | null;
+            codeOnly: boolean | null;
+        }): string;
+        execute({ query, path, regexPattern, filePattern, excludePattern, excludeDir, maxResults, contextLines, filesOnly, showContent, codeOnly, }: {
+            query: string;
+            path: string;
+            regexPattern: string | null;
+            filePattern: string | null;
+            excludePattern: string | null;
+            excludeDir: string | null;
+            maxResults: number | null;
+            contextLines: number | null;
+            filesOnly: boolean | null;
+            showContent: boolean | null;
+            codeOnly: boolean | null;
+        }, { abortSignal }: import("./types.ts").ToolExecutionOptions): Promise<string>;
+    };
     readonly DirectoryTree: {
         toolDef: {
             description: string;
@@ -252,5 +296,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,4 +1,7 @@
+import { config } from "../config/index.js";
+import { AgentTool, createAgentTools } from "./agent.js";
 import { BashTool, createBashTool } from "./bash.js";
+import { CodeSearchTool, createCodeSearchTool } from "./code-search.js";
 import { createDirectoryTreeTool, DirectoryTreeTool, } from "./directory-tree.js";
 import { loadDynamicTools } from "./dynamic-tool-loader.js";
 import { createEditFileTool, EditFileTool } from "./edit-file.js";
@@ -7,37 +10,44 @@ 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 codeSearchTool = createCodeSearchTool();
     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 dynamicTools = await loadDynamicTools({
         baseDir: workspace.primaryDir,
+        existingToolNames: [
+            EditFileTool.name,
+            BashTool.name,
+            SaveFileTool.name,
+            ReadFileTool.name,
+            GlobTool.name,
+            GrepTool.name,
+            CodeSearchTool.name,
+            DirectoryTreeTool.name,
+            ThinkTool.name,
+            LsTool.name,
+            SkillTool.name,
+            AgentTool.name,
+            WebSearchTool.name,
+            WebFetchTool.name,
+        ],
     });
     // Build tools object for AI SDK
     const tools = {
@@ -47,9 +57,14 @@ export async function initTools({ workspace, }) {
         [ReadFileTool.name]: readFileTool,
         [GlobTool.name]: globTool,
         [GrepTool.name]: grepTool,
+        [CodeSearchTool.name]: codeSearchTool,
         [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;;;;;;;;2CAS0C,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 directory.",
             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";
@@ -23,9 +24,8 @@ declare const inputSchema: z.ZodObject<{
     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;

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":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD,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,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;0DAQyD,mBAAmB;+EAWpE,mBAAmB,mBACL,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EA2BrB,CAAC"}

package/dist/tools/read-file.js

@@ -1,12 +1,14 @@
 import fs from "node:fs/promises";
+import { createInterface } from "node:readline/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
 import { z } from "zod";
 import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.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;
+// default limit in bytes (20KB)
+const DEFAULT_BYTE_LIMIT = 20 * 1024;
 export const ReadFileTool = {
     name: "Read",
 };
@@ -24,51 +26,89 @@ const inputSchema = z.object({
         .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)"),
+        .describe("Maximum number of bytes to read. Set to 0 for no limit. (Default: 20KB)"),
 });
-export const createReadFileTool = async ({ workingDir, allowedDirs, }) => {
-    const allowedDirectory = allowedDirs ?? [workingDir];
+export const createReadFileTool = async (options) => {
+    const { primaryDir, allowedDirs } = options.workspace;
+    const allowedDirectory = allowedDirs ?? [primaryDir];
     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 }) {
             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 filePath = await validatePath(joinWorkingDir(providedPath, primaryDir), allowedDirectory, { abortSignal });
+            const effectiveEncoding = encoding ?? "utf-8";
             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 file = await readFileContent(filePath, effectiveEncoding, startLine, lineCount, abortSignal);
+            validateByteLimit(file, effectiveEncoding, effectiveMaxBytes);
             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) {
+    if (maxBytes <= 0) {
+        return;
+    }
+    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` +
+            "• Set maxBytes: 0 to read the entire file\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;AAEvD,eAAO,MAAM,kBAAkB,GAAU,SAAS;IAChD,SAAS,EAAE,gBAAgB,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;sBAUqB,mBAAmB;mDAKI,mBAAmB,mBACzC,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;EAoDrB,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,28 +17,27 @@ 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];
+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 });
+            const filePath = await validatePath(joinWorkingDir(userPath, primaryDir), allowedDirectory, { requireExistence: false, abortSignal });
             try {
                 await fs.stat(filePath);
-                const projectConfig = await config.getConfig();
-                validateFileNotReadOnly(filePath, projectConfig, workingDir);
+                validateFileNotReadOnly(filePath, projectConfig, primaryDir);
             }
             catch (error) {
                 if (error.code !== "ENOENT") {

package/dist/tools/skill.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { ToolExecutionOptions } from "./types.ts";
+export declare const SkillTool: {
+    name: "Skill";
+};
+declare const inputSchema: z.ZodObject<{
+    skill: z.ZodString;
+    args: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SkillInputSchema = z.infer<typeof inputSchema>;
+export declare function createSkillTool(): Promise<{
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            skill: z.ZodString;
+            args: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    display({ skill: skillName }: SkillInputSchema): string;
+    execute({ skill: skillName, args }: SkillInputSchema, { abortSignal }: ToolExecutionOptions): Promise<string>;
+}>;
+export {};
+//# sourceMappingURL=skill.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skill.d.ts","sourceRoot":"","sources":["../../source/tools/skill.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,SAAS;;CAErB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAKf,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEpD,wBAAsB,eAAe;;;;;;;;kCAWH,gBAAgB,GAAG,MAAM;wCAIzB,gBAAgB,mBAC3B,oBAAoB,GACpC,OAAO,CAAC,MAAM,CAAC;GA4CrB"}