@travisennis/acai 0.0.5 → 0.0.7

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

@@ -1,14 +1,26 @@
-import type { SendData } from "./types.ts";
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
+import type { ToolResult } from "./types.ts";
 export declare const MoveFileTool: {
     name: "moveFile";
 };
-export declare const createMoveFileTool: ({ workingDir, sendData, }: {
+declare const inputSchema: z.ZodObject<{
+    source: z.ZodString;
+    destination: z.ZodString;
+}, z.core.$strip>;
+type MoveFileInputSchema = z.infer<typeof inputSchema>;
+export declare const createMoveFileTool: ({ workingDir, allowedDirs, }: {
     workingDir: string;
-    sendData?: SendData;
+    allowedDirs?: string[];
 }) => Promise<{
-    moveFile: import("ai").Tool<{
-        source: string;
-        destination: string;
-    }, string>;
+    toolDef: {
+        description: string;
+        inputSchema: z.ZodObject<{
+            source: z.ZodString;
+            destination: z.ZodString;
+        }, z.core.$strip>;
+    };
+    execute({ source, destination }: MoveFileInputSchema, { toolCallId, abortSignal }: ToolCallOptions): AsyncGenerator<ToolResult>;
 }>;
+export {};
 //# sourceMappingURL=move-file.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"move-file.d.ts","sourceRoot":"","sources":["../../source/tools/move-file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAC1C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;iBAGf,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;;;;;;;;qCAY8B,mBAAmB,+BACf,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EAyDhC,CAAC"}

package/dist/tools/move-file.js

@@ -1,51 +1,65 @@
 import fs from "node:fs/promises";
-import { tool } from "ai";
 import { z } from "zod";
+import { config } from "../config.js";
+import { clearProjectStatusCache } from "../repl/project-status-line.js";
 import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { joinWorkingDir, validateFileNotReadOnly, validatePath, } from "../utils/filesystem/security.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, abortSignal }) => {
-                // Check if execution has been aborted
+            inputSchema,
+        },
+        async *execute({ source, destination }, { toolCallId, abortSignal }) {
+            try {
                 if (abortSignal?.aborted) {
                     throw new Error("File move aborted");
                 }
-                try {
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-init",
-                        data: `Moving file from ${style.cyan(source)} to ${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);
-                    sendData?.({
-                        id: toolCallId,
-                        event: "tool-completion",
-                        data: "Done",
-                    });
-                    return `Successfully moved ${source} to ${destination}`;
-                }
-                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 });
+                // Check if source file is read-only
+                const projectConfig = await config.getConfig();
+                validateFileNotReadOnly(validSourcePath, projectConfig, workingDir);
+                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",
+                };
+                // Clear project status cache since file operations change git status
+                clearProjectStatusCache();
+                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,18 +1,56 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { SendData } from "./types.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

@@ -1 +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"}
+{"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;AAMzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBAiBf,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;;;;;;;;;;;;;;;;;;;;;;qEAcQ,mBAAmB,+BACO,eAAe,GAC3C,cAAc,CAAC,UAAU,CAAC;EA+FhC,CAAC"}

package/dist/tools/read-file.js

@@ -1,93 +1,107 @@
 import fs from "node:fs/promises";
 import { isNumber } from "@travisennis/stdlib/typeguards";
-import { tool } from "ai";
 import { z } from "zod";
-import { config } from "../config.js";
 import style from "../terminal/style.js";
-import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+import { manageTokenLimit, TokenLimitExceededError, } from "../tokens/threshold.js";
+import { joinWorkingDir, validatePath } from "../utils/filesystem/security.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. Required but nullable. Pass null to start at beginning of file"),
+    lineCount: z.coerce
+        .number()
+        .nullable()
+        .describe("Maximum number of lines to read. Required but nullable. Pass null to get all lines."),
+});
+export const createReadFileTool = async ({ workingDir, allowedDirs, tokenCounter, }) => {
+    const allowedDirectory = allowedDirs ?? [workingDir];
     return {
-        [ReadFileTool.name]: tool({
-            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.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."),
-            }),
-            execute: async ({ path: providedPath, encoding, startLine, lineCount, }, { toolCallId, abortSignal }) => {
+        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,
+        },
+        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");
                 }
-                sendData?.({
+                yield {
+                    name: ReadFileTool.name,
                     id: toolCallId,
                     event: "tool-init",
-                    data: `Reading file: ${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
-                });
-                try {
-                    const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
-                    if (abortSignal?.aborted) {
-                        throw new Error("File reading aborted before file read");
-                    }
-                    let file = await fs.readFile(filePath, { encoding });
-                    // Apply line-based selection if requested
-                    if (isNumber(startLine) || isNumber(lineCount)) {
-                        const lines = file.split("\n");
-                        const totalLines = lines.length;
-                        const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
-                        const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
-                        if (startIndex < 0 || startIndex >= totalLines) {
-                            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
+                    data: `${style.cyan(providedPath)}${startLine ? style.cyan(`:${startLine}`) : ""}${lineCount ? style.cyan(`:${lineCount}`) : ""}`,
+                };
+                const filePath = await validatePath(joinWorkingDir(providedPath, workingDir), allowedDirectory, { abortSignal });
+                if (abortSignal?.aborted) {
+                    throw new Error("File reading aborted before file read");
+                }
+                let file = await fs.readFile(filePath, { encoding });
+                // Apply line-based selection if requested
+                if (isNumber(startLine) || isNumber(lineCount)) {
+                    const lines = file.split("\n");
+                    const totalLines = lines.length;
+                    const startIndex = (startLine ?? 1) - 1; // Default to start of file if only lineCount is given
+                    const count = lineCount ?? totalLines - startIndex; // Default to read all lines from start if only startLine is given
+                    if (startIndex < 0 || startIndex >= totalLines) {
+                        const errorMsg = `startLine ${startLine} is out of bounds for file with ${totalLines} lines.`;
+                        yield {
+                            name: ReadFileTool.name,
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: errorMsg,
+                        };
+                        yield errorMsg;
+                        return;
                     }
-                    const 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?.({
+                    const endIndex = Math.min(startIndex + count, totalLines);
+                    file = lines.slice(startIndex, endIndex).join("\n");
+                }
+                try {
+                    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 token count only if calculated (i.e., for text files)
-                        data: tokenCount <= maxTokens
-                            ? `File read successfully ${tokenCount > 0 ? ` (${tokenCount} tokens)` : ""}`
-                            : result,
-                    });
-                    return result;
+                        data: `Read ${linesRead} lines (${result.tokenCount} tokens)`,
+                    };
+                    yield result.content;
                 }
                 catch (error) {
-                    return `Failed to read file: ${error.message}`;
+                    if (error instanceof TokenLimitExceededError) {
+                        yield {
+                            name: ReadFileTool.name,
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: error.message,
+                        };
+                        yield error.message;
+                        return;
+                    }
+                    throw error;
                 }
-            },
-        }),
+            }
+            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,15 +1,26 @@
+import type { ToolCallOptions } from "ai";
+import { z } from "zod";
 import type { TokenCounter } from "../tokens/counter.ts";
-import type { SendData } from "./types.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

@@ -1 +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"}
+{"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;AAMzD,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;EAsMhC,CAAC"}