@travisennis/acai 0.0.4 → 0.0.6

package/dist/tools/move-file.js

@@ -1,44 +1,58 @@
 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",
 };
-export const createMoveFileTool = async ({ workingDir, sendData, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    source: z.string(),
+    destination: z.string(),
+});
+export const createMoveFileTool = async ({ workingDir, allowedDirs, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [MoveFileTool.name]: tool({
+        toolDef: {
             description: "Move or rename files and directories. Can move files between directories " +
                 "and rename them in a single operation. If the destination exists, the " +
                 "operation will fail. Works across different directories and can be used " +
                 "for simple renaming within the same directory. Both source and destination must be within allowed directories.",
-            inputSchema: z.object({
-                source: z.string(),
-                destination: z.string(),
-            }),
-            execute: async ({ source, destination }, { toolCallId }) => {
-                try {
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-init",
-                        data: `Moving file from ${chalk.cyan(source)} to ${chalk.cyan(destination)}`,
-                    });
-                    const validSourcePath = await validatePath(joinWorkingDir(source, workingDir), allowedDirectory);
-                    const validDestPath = await validatePath(joinWorkingDir(destination, workingDir), allowedDirectory);
-                    await fs.rename(validSourcePath, validDestPath);
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: "Done",
-                    });
-                    return `Successfully moved ${source} to ${destination}`;
+            inputSchema,
+        },
+        async *execute({ source, destination }, { toolCallId, abortSignal }) {
+            try {
+                if (abortSignal?.aborted) {
+                    throw new Error("File move aborted");
                 }
-                catch (error) {
-                    return `Failed to move file: ${error.message}`;
+                yield {
+                    name: MoveFileTool.name,
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `${style.cyan(source)} => ${style.cyan(destination)}`,
+                };
+                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);
+                yield {
+                    name: MoveFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    data: "File moved",
+                };
+                yield `Successfully moved ${source} to ${destination}`;
+            }
+            catch (error) {
+                yield {
+                    name: MoveFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: error.message,
+                };
+                yield `Failed to move file: ${error.message}`;
+            }
+        },
     };
 };

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

@@ -1,17 +1,56 @@
-import type { TokenCounter } from "../token-utils.ts";
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { ToolResult } from "./types.ts";
 export declare const ReadFileTool: {
     name: "readFile";
 };
-export declare const createReadFileTool: ({ workingDir, sendData, tokenCounter, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    encoding: z.ZodEnum<{
+        utf8: "utf8";
+        ascii: "ascii";
+        "utf-8": "utf-8";
+        utf16le: "utf16le";
+        ucs2: "ucs2";
+        "ucs-2": "ucs-2";
+        base64: "base64";
+        base64url: "base64url";
+        latin1: "latin1";
+        binary: "binary";
+        hex: "hex";
+    }>;
+    startLine: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+    lineCount: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+type ReadFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createReadFileTool: ({ workingDir, allowedDirs, tokenCounter, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
 }) => Promise<{
-    readFile: import("ai").Tool<{
-        path: string;
-        encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
-        startLine: number | null;
-        lineCount: number | null;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            encoding: z.ZodEnum<{
+                utf8: "utf8";
+                ascii: "ascii";
+                "utf-8": "utf-8";
+                utf16le: "utf16le";
+                ucs2: "ucs2";
+                "ucs-2": "ucs-2";
+                base64: "base64";
+                base64url: "base64url";
+                latin1: "latin1";
+                binary: "binary";
+                hex: "hex";
+            }>;
+            startLine: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+            lineCount: z.ZodNullable<z.ZodCoercedNumber<unknown>>;
+        }, z.core.$strip>;
+    };
+    execute({ path: providedPath, encoding, startLine, lineCount, }: ReadFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
+//# 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":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAef,CAAC;AAEH,KAAK,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEvD,eAAO,MAAM,kBAAkB,GAAU,4CAItC;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;;;;;;;;;;;;;;;;qEAiBQ,mBAAmB,+BACO,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAoFhC,CAAC"}

package/dist/tools/read-file.js

@@ -1,86 +1,98 @@
 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 { manageTokenLimit } from "../tokens/threshold.js";
 import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 import { fileEncodingSchema } from "./types.js";
 export const ReadFileTool = {
     name: "readFile",
 };
-export const createReadFileTool = async ({ workingDir, sendData, tokenCounter, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    path: z.string().describe("Absolute path to file to read"),
+    encoding: fileEncodingSchema.describe('Encoding format for reading the file. Use "utf-8" as default for text files'),
+    startLine: z.coerce
+        .number()
+        .nullable()
+        .describe("1-based line number to start reading from. Pass null to start at beginning of file"),
+    lineCount: z.coerce
+        .number()
+        .nullable()
+        .describe("Maximum number of lines to read. Pass null to get all lines."),
+});
+export const createReadFileTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [ReadFileTool.name]: tool({
+        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.",
-            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
-                    .number()
-                    .nullable()
-                    .describe("1-based line number to start reading from. Pass null to start at beginning of file"),
-                lineCount: z
-                    .number()
-                    .nullable()
-                    .describe("Maximum number of lines to read. Pass null to get all lines."),
-            }),
-            execute: async ({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId }) => {
-                sendData?.({
+            inputSchema,
+        },
+        async *execute({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) {
+            try {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("File reading aborted");
+                }
+                yield {
+                    name: ReadFileTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading file: ${chalk.cyan(providedPath)}${startLine ? chalk.cyan(`:${startLine}`) : ""}${lineCount ? chalk.cyan(`:${lineCount}`) : ""}`,
-                });
-                try {
-                    const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory);
-                    let file = await fs.readFile(filePath, { encoding });
-                    // Apply line-based selection if requested
-                    if (isNumber(startLine) || isNumber(lineCount)) {
-                        const lines = file.split("\n");
-                        const totalLines = lines.length;
-                        const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
-                        const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
-                        if (startIndex < 0 || startIndex >= totalLines) {
-                            return `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");
-                    }
-                    let tokenCount = 0;
-                    try {
-                        // Only calculate tokens for non-image files and if encoding is text-based
-                        if (encoding.startsWith("utf")) {
-                            tokenCount = tokenCounter.count(file);
-                        }
-                    }
-                    catch (tokenError) {
-                        console.error("Error calculating token count:", tokenError);
-                        // Log or handle error, but don't block file return
-                    }
-                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                    // Adjust max token check message if line selection was used
-                    const maxTokenMessage = isNumber(startLine) || isNumber(lineCount)
-                        ? `Selected file content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Consider adjusting startLine/lineCount or using grepFiles.`
-                        : `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please use startLine and lineCount parameters to read specific portions of the file, or using grepFiles to search for specific content.`;
-                    const result = tokenCount <= maxTokens ? file : maxTokenMessage;
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        // Include token count only if calculated (i.e., for text files)
-                        data: tokenCount <= maxTokens
-                            ? `File read successfully ${tokenCount > 0 ? ` (${tokenCount} tokens)` : ""}`
-                            : result,
-                    });
-                    return result;
+                    data: `${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
+                };
+                const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
+                if (abortSignal?.aborted) {
+                    throw new Error("File reading aborted before file read");
                 }
-                catch (error) {
-                    return `Failed to read file: ${error.message}`;
+                let file = await fs.readFile(filePath, { encoding });
+                // Apply line-based selection if requested
+                if (isNumber(startLine) || isNumber(lineCount)) {
+                    const lines = file.split("\n");
+                    const totalLines = lines.length;
+                    const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
+                    const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
+                    if (startIndex < 0 || startIndex >= totalLines) {
+                        const errorMsg = `startLine ${startLine} is out of bounds for file with ${totalLines} lines.`;
+                        yield {
+                            name: ReadFileTool.name,
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: errorMsg,
+                        };
+                        yield errorMsg;
+                        return;
+                    }
+                    const endIndex = Math.min(startIndex + count, totalLines);
+                    file = lines.slice(startIndex, endIndex).join("\n");
                 }
-            },
-        }),
+                const result = await manageTokenLimit(file, tokenCounter, "ReadFile", isNumber(startLine) || isNumber(lineCount)
+                    ? "Consider adjusting startLine/lineCount or using grepFiles"
+                    : "Use startLine and lineCount parameters to read specific portions, or use grepFiles for targeted access", encoding);
+                // Calculate line count for the returned content
+                const linesRead = result.content.split("\n").length;
+                yield {
+                    name: ReadFileTool.name,
+                    id: toolCallId,
+                    event: "tool-completion",
+                    // Include success, line count, and token count
+                    data: !result.truncated
+                        ? `Read ${linesRead} lines (${result.tokenCount} tokens)`
+                        : result.content,
+                };
+                yield result.content;
+            }
+            catch (error) {
+                const errorMsg = `${error.message}`;
+                yield {
+                    name: ReadFileTool.name,
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMsg,
+                };
+                yield errorMsg;
+            }
+        },
     };
 };

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

@@ -1,14 +1,26 @@
-import type { TokenCounter } from "../token-utils.ts";
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { ToolResult } from "./types.ts";
 export declare const ReadMultipleFilesTool: {
     name: "readMultipleFiles";
 };
-export declare const createReadMultipleFilesTool: ({ workingDir, sendData, tokenCounter, }: {
+declare const inputSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type ReadMultipleFilesInputSchema = z.infer<typeof inputSchema>;
+export declare const createReadMultipleFilesTool: ({ workingDir, allowedDirs, tokenCounter, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
     tokenCounter: TokenCounter;
 }) => Promise<{
-    readMultipleFiles: import("ai").Tool<{
-        paths: string[];
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            paths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    execute({ paths }: ReadMultipleFilesInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
+//# 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":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,qBAAqB;;CAEjC,CAAC;AAEF,QAAA,MAAM,WAAW;;iBAEf,CAAC;AAEH,KAAK,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEhE,eAAO,MAAM,2BAA2B,GAAU,4CAI/C;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;CAC5B;;;;;;;uBAcgB,4BAA4B,+BACV,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAwIhC,CAAC"}

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

@@ -1,55 +1,139 @@
-import { tool } from "ai";
-import chalk from "chalk";
+import { readFile } from "node:fs/promises";
 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 { manageTokenLimit } from "../tokens/threshold.js";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
 export const ReadMultipleFilesTool = {
     name: "readMultipleFiles",
 };
-export const createReadMultipleFilesTool = async ({ workingDir, sendData, tokenCounter, }) => {
-    const allowedDirectory = workingDir;
+const inputSchema = z.object({
+    paths: z.array(z.string()),
+});
+export const createReadMultipleFilesTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [ReadMultipleFilesTool.name]: tool({
+        toolDef: {
             description: "Read the contents of multiple files simultaneously. This is more " +
                 "efficient than reading files one by one when you need to analyze " +
                 "or compare multiple files. Each file's content is returned with its " +
                 "path as a reference. Failed reads for individual files won't stop " +
                 "the entire operation. Only works within allowed directories.",
-            inputSchema: z.object({
-                paths: z.array(z.string()),
-            }),
-            execute: async ({ paths }, { toolCallId }) => {
-                sendData?.({
+            inputSchema,
+        },
+        async *execute({ paths }, { toolCallId, abortSignal }) {
+            try {
+                // Check if execution has been aborted
+                if (abortSignal?.aborted) {
+                    throw new Error("Multiple file reading aborted");
+                }
+                yield {
+                    name: ReadMultipleFilesTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading files: ${paths.map((p) => chalk.cyan(p)).join(", ")}`,
-                });
-                const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                const results = await Promise.all(paths.map((filePath) => readFileAndCountTokens(filePath, workingDir, allowedDirectory, tokenCounter, maxTokens)));
+                    data: `${paths.map((p) => style.cyan(p)).join(", ")}`,
+                };
+                if (abortSignal?.aborted) {
+                    throw new Error("Multiple file reading aborted before reading files");
+                }
+                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 fileResult;
+                }));
+                const processedResults = await Promise.all(results.map(async (result) => {
+                    if (result.error) {
+                        return {
+                            path: result.path,
+                            content: `${result.path}: Error - ${result.error}`,
+                            tokenCount: 0,
+                            error: result.error,
+                            truncated: false,
+                        };
+                    }
+                    // Apply token limit check to each file
+                    const managedResult = await manageTokenLimit(result.content ?? "", tokenCounter, "ReadMultipleFiles", "Use readFile with startLine/lineCount or grepFiles for targeted access");
+                    return {
+                        path: result.path,
+                        content: formatFile(result.path, managedResult.content, "markdown"),
+                        tokenCount: managedResult.tokenCount,
+                        error: null,
+                        truncated: managedResult.truncated,
+                    };
+                }));
+                const formattedResults = processedResults.map((r) => r.content);
+                const finalResult = await manageTokenLimit(formattedResults.join("\n---\n"), tokenCounter, "ReadMultipleFiles", "Reduce number of files or use more specific paths");
+                // Aggregate results with detailed breakdown
                 let totalTokens = 0;
                 let filesReadCount = 0;
-                const formattedResults = results.map((result) => {
-                    if (result.error) {
-                        return `${result.path}: Error - ${result.error}`;
+                let filesExceededLimitCount = 0;
+                let filesErrorCount = 0;
+                for (const processedResult of processedResults) {
+                    if (processedResult.error) {
+                        filesErrorCount++;
+                    }
+                    else if (processedResult.truncated) {
+                        filesExceededLimitCount++;
+                        totalTokens += processedResult.tokenCount;
                     }
-                    // Check if tokenCount is > 0, meaning it wasn't skipped
-                    if (result.tokenCount > 0) {
+                    else {
                         filesReadCount++;
+                        totalTokens += processedResult.tokenCount;
                     }
-                    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`;
-                });
-                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.`;
-                sendData?.({
+                }
+                const parts = [];
+                if (filesReadCount > 0) {
+                    parts.push(`Read ${filesReadCount} files successfully (${totalTokens} total tokens)`);
+                }
+                if (filesExceededLimitCount > 0) {
+                    parts.push(`${filesExceededLimitCount} files exceeded token limit`);
+                }
+                if (filesErrorCount > 0) {
+                    parts.push(`${filesErrorCount} files could not be read`);
+                }
+                if (finalResult.truncated) {
+                    parts.push(`Combined output exceeded token limit. ${finalResult.content}`);
+                }
+                const completionMessage = `${parts.join(", ")}.`;
+                yield {
+                    name: ReadMultipleFilesTool.name,
                     id: toolCallId,
                     event: "tool-completion",
                     data: completionMessage,
-                });
-                return formattedResults.join("\n---\n");
-            },
-        }),
+                };
+                yield finalResult.content;
+            }
+            catch (error) {
+                const errorMsg = error.message;
+                yield {
+                    name: ReadMultipleFilesTool.name,
+                    id: toolCallId,
+                    event: "tool-error",
+                    data: errorMsg,
+                };
+                yield errorMsg;
+            }
+        },
     };
 };
+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,
+        };
+    }
+}

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

@@ -1,17 +1,52 @@
-import type { Terminal } from "../terminal/index.ts";
-import { type SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import { type ToolResult } from "./types.ts";
 export declare const SaveFileTool: {
     name: "saveFile";
 };
-export declare const createSaveFileTool: ({ workingDir, sendData, terminal, autoAcceptAll, }: {
+declare const inputSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    encoding: z.ZodEnum<{
+        utf8: "utf8";
+        ascii: "ascii";
+        "utf-8": "utf-8";
+        utf16le: "utf16le";
+        ucs2: "ucs2";
+        "ucs-2": "ucs-2";
+        base64: "base64";
+        base64url: "base64url";
+        latin1: "latin1";
+        binary: "binary";
+        hex: "hex";
+    }>;
+}, z.core.$strip>;
+type SaveFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createSaveFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
-    sendData?: SendData;
-    terminal?: Terminal;
-    autoAcceptAll?: boolean;
+    allowedDirs?: string[];
 }) => Promise<{
-    saveFile: import("ai").Tool<{
-        path: string;
-        content: string;
-        encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            encoding: z.ZodEnum<{
+                utf8: "utf8";
+                ascii: "ascii";
+                "utf-8": "utf-8";
+                utf16le: "utf16le";
+                ucs2: "ucs2";
+                "ucs-2": "ucs-2";
+                base64: "base64";
+                base64url: "base64url";
+                latin1: "latin1";
+                binary: "binary";
+                hex: "hex";
+            }>;
+        }, z.core.$strip>;
+    };
+    execute({ path: userPath, content, encoding }: SaveFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
+//# 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":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAEjE,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAMf,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;;;;;;;;;;;;;;;;;;;;;mDAa4C,mBAAmB,+BAC7B,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAuEhC,CAAC"}