@travisennis/acai 0.0.4 → 0.0.5

package/dist/tools/index.d.ts

@@ -1,21 +1,22 @@
 import type { ModelManager } from "../models/manager.ts";
 import type { Terminal } from "../terminal/index.ts";
-import type { TokenTracker } from "../token-tracker.ts";
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { TokenTracker } from "../tokens/tracker.ts";
+import type { ToolExecutor } from "../tool-executor.ts";
 import type { Message } from "./types.ts";
-export declare function initTools({ terminal, tokenCounter, events, autoAcceptAll, }: {
+export declare function initTools({ terminal, tokenCounter, events, toolExecutor, }: {
     terminal: Terminal;
     tokenCounter: TokenCounter;
     events: Map<string, Message[]>;
-    autoAcceptAll: boolean;
+    toolExecutor?: ToolExecutor;
 }): Promise<{
     readonly webSearch: import("ai").Tool<{
         query: string;
     }, string>;
     readonly bash: import("ai").Tool<{
+        command: string;
         cwd: string | null;
         timeout: number | null;
-        command: string;
     }, string>;
     readonly webFetch: import("ai").Tool<{
         url: string;
@@ -24,8 +25,8 @@ export declare function initTools({ terminal, tokenCounter, events, autoAcceptAl
         thought: string;
     }, string>;
     readonly grepFiles: import("ai").Tool<{
-        path: string;
         pattern: string;
+        path: string;
         recursive: boolean | null;
         ignoreCase: boolean | null;
         filePattern: string | null;
@@ -35,15 +36,11 @@ export declare function initTools({ terminal, tokenCounter, events, autoAcceptAl
     }, string>;
     readonly codeInterpreter: import("ai").Tool<{
         code: string;
-        type: "Typescript" | "JavaScript" | null;
         timeoutSeconds: number | null;
     }, string>;
     readonly deleteFile: import("ai").Tool<{
         path: string;
     }, string>;
-    readonly directoryTree: import("ai").Tool<{
-        path: string;
-    }, string>;
     readonly moveFile: import("ai").Tool<{
         source: string;
         destination: string;
@@ -77,9 +74,9 @@ export declare function initCliTools({ tokenCounter, }: {
         query: string;
     }, string>;
     readonly bash: import("ai").Tool<{
+        command: string;
         cwd: string | null;
         timeout: number | null;
-        command: string;
     }, string>;
     readonly webFetch: import("ai").Tool<{
         url: string;
@@ -88,8 +85,8 @@ export declare function initCliTools({ tokenCounter, }: {
         thought: string;
     }, string>;
     readonly grepFiles: import("ai").Tool<{
-        path: string;
         pattern: string;
+        path: string;
         recursive: boolean | null;
         ignoreCase: boolean | null;
         filePattern: string | null;
@@ -99,15 +96,11 @@ export declare function initCliTools({ tokenCounter, }: {
     }, string>;
     readonly codeInterpreter: import("ai").Tool<{
         code: string;
-        type: "Typescript" | "JavaScript" | null;
         timeoutSeconds: number | null;
     }, string>;
     readonly deleteFile: import("ai").Tool<{
         path: string;
     }, string>;
-    readonly directoryTree: import("ai").Tool<{
-        path: string;
-    }, string>;
     readonly moveFile: import("ai").Tool<{
         source: string;
         destination: string;
@@ -145,3 +138,4 @@ export declare function initAgents({ modelManager, tokenTracker, tokenCounter, e
         prompt: string;
     }, string>;
 }>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAcxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAe1C,wBAAsB,SAAS,CAAC,EAC9B,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,YAAY,GACb,EAAE;IACD,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;IAC/B,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqGA;AAED,wBAAsB,YAAY,CAAC,EACjC,YAAY,GACb,EAAE;IACD,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FA;AAED,wBAAsB,UAAU,CAAC,EAC/B,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;CAChC;;;;GAeA"}

package/dist/tools/index.js

@@ -2,7 +2,8 @@ import { createAgentTools } from "./agent.js";
 import { createBashTool } from "./bash.js";
 import { createCodeInterpreterTool } from "./code-interpreter.js";
 import { createDeleteFileTool } from "./delete-file.js";
-import { createDirectoryTreeTool } from "./directory-tree.js";
+// import { createDirectoryTreeTool } from "./directory-tree.ts";
+import { loadDynamicTools } from "./dynamic-tool-loader.js";
 import { createEditFileTool } from "./edit-file.js";
 import { createGrepTool } from "./grep.js";
 import { createMoveFileTool } from "./move-file.js";
@@ -23,7 +24,7 @@ const sendDataHandler = (events) => {
         }
     };
 };
-export async function initTools({ terminal, tokenCounter, events, autoAcceptAll, }) {
+export async function initTools({ terminal, tokenCounter, events, toolExecutor, }) {
     const sendDataFn = sendDataHandler(events);
     const readFileTool = await createReadFileTool({
         workingDir: process.cwd(),
@@ -39,33 +40,35 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
         workingDir: process.cwd(),
         terminal,
         sendData: sendDataFn,
-        autoAcceptAll,
+        toolExecutor,
     });
     const saveFileTool = await createSaveFileTool({
         workingDir: process.cwd(),
         sendData: sendDataFn,
         terminal,
-        autoAcceptAll,
+        toolExecutor,
     });
     const moveFileTool = await createMoveFileTool({
         workingDir: process.cwd(),
         sendData: sendDataFn,
     });
-    const directoryTreeTool = await createDirectoryTreeTool({
-        workingDir: process.cwd(),
-        sendData: sendDataFn,
-    });
+    // const directoryTreeTool = await createDirectoryTreeTool({
+    //   workingDir: process.cwd(),
+    //   sendData: sendDataFn,
+    //   tokenCounter,
+    // });
     const deleteFileTool = await createDeleteFileTool({
         workingDir: process.cwd(),
         sendData: sendDataFn,
         terminal,
-        autoAcceptAll,
+        toolExecutor,
     });
     const codeInterpreterTool = createCodeInterpreterTool({
         sendData: sendDataFn,
     });
     const grepTool = createGrepTool({
         sendData: sendDataFn,
+        tokenCounter,
     });
     const thinkTool = createThinkTool({
         sendData: sendDataFn,
@@ -78,12 +81,16 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
         sendData: sendDataFn,
         tokenCounter,
     });
-    const bashTool = createBashTool({
+    const bashTool = await createBashTool({
         baseDir: process.cwd(),
         sendData: sendDataFn,
         tokenCounter,
         terminal,
-        autoAcceptAll,
+        toolExecutor,
+    });
+    const dynamicTools = await loadDynamicTools({
+        baseDir: process.cwd(),
+        sendData: sendDataFn,
     });
     const tools = {
         ...readFileTool,
@@ -91,7 +98,7 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
         ...editFileTool,
         ...saveFileTool,
         ...moveFileTool,
-        ...directoryTreeTool,
+        // ...directoryTreeTool,
         ...deleteFileTool,
         ...codeInterpreterTool,
         ...grepTool,
@@ -99,6 +106,7 @@ export async function initTools({ terminal, tokenCounter, events, autoAcceptAll,
         ...webFetchTool,
         ...bashTool,
         ...webSearchTool,
+        ...dynamicTools,
     };
     return tools;
 }
@@ -117,33 +125,32 @@ export async function initCliTools({ tokenCounter, }) {
         workingDir: process.cwd(),
         terminal: undefined,
         sendData: undefined,
-        autoAcceptAll: true,
     });
     const saveFileTool = await createSaveFileTool({
         workingDir: process.cwd(),
         sendData: undefined,
         terminal: undefined,
-        autoAcceptAll: true,
     });
     const moveFileTool = await createMoveFileTool({
         workingDir: process.cwd(),
         sendData: undefined,
     });
-    const directoryTreeTool = await createDirectoryTreeTool({
-        workingDir: process.cwd(),
-        sendData: undefined,
-    });
+    // const directoryTreeTool = await createDirectoryTreeTool({
+    //   workingDir: process.cwd(),
+    //   sendData: undefined,
+    //   tokenCounter,
+    // });
     const deleteFileTool = await createDeleteFileTool({
         workingDir: process.cwd(),
         sendData: undefined,
         terminal: undefined,
-        autoAcceptAll: true,
     });
     const codeInterpreterTool = createCodeInterpreterTool({
         sendData: undefined,
     });
     const grepTool = createGrepTool({
         sendData: undefined,
+        tokenCounter,
     });
     const thinkTool = createThinkTool({
         sendData: undefined,
@@ -156,12 +163,15 @@ export async function initCliTools({ tokenCounter, }) {
         sendData: undefined,
         tokenCounter,
     });
-    const bashTool = createBashTool({
+    const bashTool = await createBashTool({
         baseDir: process.cwd(),
         sendData: undefined,
         tokenCounter,
         terminal: undefined,
-        autoAcceptAll: true,
+    });
+    const dynamicTools = await loadDynamicTools({
+        baseDir: process.cwd(),
+        sendData: undefined,
     });
     const tools = {
         ...readFileTool,
@@ -169,7 +179,7 @@ export async function initCliTools({ tokenCounter, }) {
         ...editFileTool,
         ...saveFileTool,
         ...moveFileTool,
-        ...directoryTreeTool,
+        // ...directoryTreeTool,
         ...deleteFileTool,
         ...codeInterpreterTool,
         ...grepTool,
@@ -177,6 +187,7 @@ export async function initCliTools({ tokenCounter, }) {
         ...webFetchTool,
         ...bashTool,
         ...webSearchTool,
+        ...dynamicTools,
     };
     return tools;
 }

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

@@ -11,3 +11,4 @@ export declare const createMoveFileTool: ({ workingDir, sendData, }: {
         destination: string;
     }, string>;
 }>;
+//# sourceMappingURL=move-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"move-file.d.ts","sourceRoot":"","sources":["../../source/tools/move-file.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,2BAGtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;;;;;EAsDA,CAAC"}

package/dist/tools/move-file.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
+import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const MoveFileTool = {
     name: "moveFile",
@@ -18,15 +18,22 @@ export const createMoveFileTool = async ({ workingDir, sendData, }) => {
                 source: z.string(),
                 destination: z.string(),
             }),
-            execute: async ({ source, destination }, { toolCallId }) => {
+            execute: async ({ source, destination }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("File move aborted");
+                }
                 try {
                     sendData?.({
                         id: toolCallId,
                         event: "tool-init",
-                        data: `Moving file from ${chalk.cyan(source)} to ${chalk.cyan(destination)}`,
+                        data: `Moving file from ${style.cyan(source)} to ${style.cyan(destination)}`,
                     });
-                    const validSourcePath = await validatePath(joinWorkingDir(source, workingDir), allowedDirectory);
-                    const validDestPath = await validatePath(joinWorkingDir(destination, workingDir), allowedDirectory);
+                    const validSourcePath = await validatePath(joinWorkingDir(source, workingDir), allowedDirectory, { abortSignal });
+                    const validDestPath = await validatePath(joinWorkingDir(destination, workingDir), allowedDirectory, { requireExistence: false, abortSignal });
+                    if (abortSignal?.aborted) {
+                        throw new Error("File move aborted before file operation");
+                    }
                     await fs.rename(validSourcePath, validDestPath);
                     sendData?.({
                         id: toolCallId,

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

@@ -1,4 +1,4 @@
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
 import type { SendData } from "./types.ts";
 export declare const ReadFileTool: {
     name: "readFile";
@@ -15,3 +15,4 @@ export declare const createReadFileTool: ({ workingDir, sendData, tokenCounter,
         lineCount: number | null;
     }, string>;
 }>;
+//# sourceMappingURL=read-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"read-file.d.ts","sourceRoot":"","sources":["../../source/tools/read-file.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,yCAItC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;EAkHA,CAAC"}

package/dist/tools/read-file.js

@@ -1,9 +1,9 @@
 import fs from "node:fs/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
 import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
 import { config } from "../config.js";
+import style from "../terminal/style.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 import { fileEncodingSchema } from "./types.js";
 export const ReadFileTool = {
@@ -20,23 +20,30 @@ export const createReadFileTool = async ({ workingDir, sendData, tokenCounter, }
             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
+                startLine: z.coerce
                     .number()
                     .nullable()
                     .describe("1-based line number to start reading from. Pass null to start at beginning of file"),
-                lineCount: z
+                lineCount: z.coerce
                     .number()
                     .nullable()
                     .describe("Maximum number of lines to read. Pass null to get all lines."),
             }),
-            execute: async ({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId }) => {
+            execute: async ({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("File reading aborted");
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading file: ${chalk.cyan(providedPath)}${startLine ? chalk.cyan(`:${startLine}`) : ""}${lineCount ? chalk.cyan(`:${lineCount}`) : ""}`,
+                    data: `Reading file: ${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
                 });
                 try {
-                    const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory);
+                    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)) {

package/dist/tools/read-multiple-files.d.ts

@@ -1,4 +1,4 @@
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
 import type { SendData } from "./types.ts";
 export declare const ReadMultipleFilesTool: {
     name: "readMultipleFiles";
@@ -12,3 +12,4 @@ export declare const createReadMultipleFilesTool: ({ workingDir, sendData, token
         paths: string[];
     }, string>;
 }>;
+//# sourceMappingURL=read-multiple-files.d.ts.map

package/dist/tools/read-multiple-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-multiple-files.d.ts","sourceRoot":"","sources":["../../source/tools/read-multiple-files.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,qBAAqB;;CAEjC,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAU,yCAI/C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;EAmGA,CAAC"}

package/dist/tools/read-multiple-files.js

@@ -1,8 +1,10 @@
+import { readFile } from "node:fs/promises";
 import { tool } from "ai";
-import chalk from "chalk";
 import { z } from "zod";
 import { config } from "../config.js";
-import { readFileAndCountTokens } from "./filesystem-utils.js";
+import { formatFile } from "../formatting.js";
+import style from "../terminal/style.js";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const ReadMultipleFilesTool = {
     name: "readMultipleFiles",
 };
@@ -18,31 +20,64 @@ export const createReadMultipleFilesTool = async ({ workingDir, sendData, tokenC
             inputSchema: z.object({
                 paths: z.array(z.string()),
             }),
-            execute: async ({ paths }, { toolCallId }) => {
+            execute: async ({ paths }, { toolCallId, abortSignal }) => {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("Multiple file reading aborted");
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading files: ${paths.map((p) => chalk.cyan(p)).join(", ")}`,
+                    data: `Reading files: ${paths.map((p) => style.cyan(p)).join(", ")}`,
                 });
+                if (abortSignal?.aborted) {
+                    throw new Error("Multiple file reading aborted before reading files");
+                }
                 const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                const results = await Promise.all(paths.map((filePath) => readFileAndCountTokens(filePath, workingDir, allowedDirectory, tokenCounter, maxTokens)));
+                const results = await Promise.all(paths.map(async (filePath) => {
+                    if (abortSignal?.aborted) {
+                        throw new Error("Multiple file reading aborted during file processing");
+                    }
+                    const fileResult = await validateAndReadFile(filePath, workingDir, allowedDirectory);
+                    return countTokensAndCheckLimit(fileResult, tokenCounter, maxTokens);
+                }));
                 let totalTokens = 0;
                 let filesReadCount = 0;
+                let filesExceededLimitCount = 0;
+                let filesErrorCount = 0;
                 const formattedResults = results.map((result) => {
                     if (result.error) {
+                        filesErrorCount++;
                         return `${result.path}: Error - ${result.error}`;
                     }
                     // Check if tokenCount is > 0, meaning it wasn't skipped
                     if (result.tokenCount > 0) {
                         filesReadCount++;
                     }
+                    else if (result.content?.includes("exceeds maximum allowed tokens")) {
+                        filesExceededLimitCount++;
+                    }
                     totalTokens += result.tokenCount; // Add the token count (will be 0 for skipped files)
                     // Return content (or max token message)
-                    return `${result.path}:\n${result.content}\n`;
+                    return formatFile(result.path, result.content ?? "", "markdown");
                 });
-                const completionMessage = filesReadCount === paths.length
-                    ? `Read ${paths.length} files successfully (${totalTokens} total tokens).`
-                    : `Read ${filesReadCount} of ${paths.length} files successfully (${totalTokens} total tokens). Files exceeding token limit were skipped.`;
+                let completionMessage;
+                if (filesReadCount === paths.length) {
+                    completionMessage = `Read ${paths.length} files successfully (${totalTokens} total tokens).`;
+                }
+                else {
+                    const parts = [];
+                    if (filesReadCount > 0) {
+                        parts.push(`Read ${filesReadCount} files successfully (${totalTokens} total tokens)`);
+                    }
+                    if (filesExceededLimitCount > 0) {
+                        parts.push(`${filesExceededLimitCount} files exceeded token limit and were skipped`);
+                    }
+                    if (filesErrorCount > 0) {
+                        parts.push(`${filesErrorCount} files could not be read`);
+                    }
+                    completionMessage = `${parts.join(", ")}.`;
+                }
                 sendData?.({
                     id: toolCallId,
                     event: "tool-completion",
@@ -53,3 +88,49 @@ export const createReadMultipleFilesTool = async ({ workingDir, sendData, tokenC
         }),
     };
 };
+async function validateAndReadFile(filePath, workingDir, allowedDirectory) {
+    try {
+        const validPath = await validatePath(joinWorkingDir(filePath, workingDir), allowedDirectory);
+        const content = await readFile(validPath, "utf-8");
+        return {
+            path: filePath,
+            content,
+            error: null,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            path: filePath,
+            content: null,
+            error: errorMessage,
+        };
+    }
+}
+async function countTokensAndCheckLimit(fileResult, tokenCounter, maxTokens) {
+    if (fileResult.error || fileResult.content === null) {
+        return {
+            path: fileResult.path,
+            content: null,
+            tokenCount: 0,
+            error: fileResult.error,
+        };
+    }
+    let tokenCount = 0;
+    try {
+        tokenCount = tokenCounter.count(fileResult.content);
+    }
+    catch (tokenError) {
+        console.error("Error calculating token count:", tokenError);
+        // Handle token calculation error if needed
+    }
+    const maxTokenMessage = `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Use readFile with startLine/lineCount or grepFiles for targeted access.`;
+    const finalContent = tokenCount > maxTokens ? maxTokenMessage : fileResult.content;
+    const actualTokenCount = tokenCount > maxTokens ? 0 : tokenCount; // Don't count tokens for skipped files
+    return {
+        path: fileResult.path,
+        content: finalContent,
+        tokenCount: actualTokenCount,
+        error: null,
+    };
+}

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

@@ -1,13 +1,14 @@
 import type { Terminal } from "../terminal/index.ts";
+import type { ToolExecutor } from "../tool-executor.ts";
 import { type SendData } from "./types.ts";
 export declare const SaveFileTool: {
     name: "saveFile";
 };
-export declare const createSaveFileTool: ({ workingDir, sendData, terminal, autoAcceptAll, }: {
+export declare const createSaveFileTool: ({ workingDir, terminal, sendData, toolExecutor, }: {
     workingDir: string;
-    sendData?: SendData;
     terminal?: Terminal;
-    autoAcceptAll?: boolean;
+    sendData?: SendData;
+    toolExecutor?: ToolExecutor;
 }) => Promise<{
     saveFile: import("ai").Tool<{
         path: string;
@@ -15,3 +16,4 @@ export declare const createSaveFileTool: ({ workingDir, sendData, terminal, auto
         encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
     }, string>;
 }>;
+//# sourceMappingURL=save-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"save-file.d.ts","sourceRoot":"","sources":["../../source/tools/save-file.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAErE,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,mDAKtC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;EAoJA,CAAC"}