@travisennis/acai 0.0.1

package/dist/tools/index.d.ts

@@ -0,0 +1,161 @@
+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 { Message } from "./types.ts";
+export declare function initTools({ terminal, tokenCounter, events, autoAcceptAll, }: {
+    terminal: Terminal;
+    tokenCounter: TokenCounter;
+    events: Map<string, Message[]>;
+    autoAcceptAll: boolean;
+}): Promise<{
+    readonly memoryWrite: import("ai").Tool<{
+        filePath: string;
+        content: string;
+    }, string>;
+    readonly memoryRead: import("ai").Tool<{
+        filePath: string | null;
+    }, string | {
+        content: string;
+    }>;
+    readonly webSearch: import("ai").Tool<{
+        query: string;
+    }, string>;
+    readonly bash: import("ai").Tool<{
+        cwd: string | null;
+        timeout: number | null;
+        command: string;
+    }, string>;
+    readonly webFetch: import("ai").Tool<{
+        url: string;
+    }, string>;
+    readonly think: import("ai").Tool<{
+        thought: string;
+    }, string>;
+    readonly grepFiles: import("ai").Tool<{
+        path: string;
+        pattern: string;
+        recursive: boolean | null;
+        ignoreCase: boolean | null;
+        filePattern: string | null;
+        contextLines: number | null;
+        searchIgnored: boolean | null;
+    }, string>;
+    readonly codeInterpreter: import("ai").Tool<{
+        code: string;
+        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;
+    }, string>;
+    readonly saveFile: import("ai").Tool<{
+        path: string;
+        content: string;
+        encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+    }, string>;
+    readonly editFile: import("ai").Tool<{
+        path: string;
+        edits: {
+            oldText: string;
+            newText: string;
+        }[];
+    }, string>;
+    readonly readMultipleFiles: import("ai").Tool<{
+        paths: string[];
+    }, string>;
+    readonly 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>;
+}>;
+export declare function initCliTools({ tokenCounter, }: {
+    tokenCounter: TokenCounter;
+}): Promise<{
+    readonly memoryWrite: import("ai").Tool<{
+        filePath: string;
+        content: string;
+    }, string>;
+    readonly memoryRead: import("ai").Tool<{
+        filePath: string | null;
+    }, string | {
+        content: string;
+    }>;
+    readonly webSearch: import("ai").Tool<{
+        query: string;
+    }, string>;
+    readonly bash: import("ai").Tool<{
+        cwd: string | null;
+        timeout: number | null;
+        command: string;
+    }, string>;
+    readonly webFetch: import("ai").Tool<{
+        url: string;
+    }, string>;
+    readonly think: import("ai").Tool<{
+        thought: string;
+    }, string>;
+    readonly grepFiles: import("ai").Tool<{
+        path: string;
+        pattern: string;
+        recursive: boolean | null;
+        ignoreCase: boolean | null;
+        filePattern: string | null;
+        contextLines: number | null;
+        searchIgnored: boolean | null;
+    }, string>;
+    readonly codeInterpreter: import("ai").Tool<{
+        code: string;
+        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;
+    }, string>;
+    readonly saveFile: import("ai").Tool<{
+        path: string;
+        content: string;
+        encoding: "utf8" | "ascii" | "utf-8" | "utf16le" | "ucs2" | "ucs-2" | "base64" | "base64url" | "latin1" | "binary" | "hex";
+    }, string>;
+    readonly editFile: import("ai").Tool<{
+        path: string;
+        edits: {
+            oldText: string;
+            newText: string;
+        }[];
+    }, string>;
+    readonly readMultipleFiles: import("ai").Tool<{
+        paths: string[];
+    }, string>;
+    readonly 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>;
+}>;
+export declare function initAgents({ modelManager, tokenTracker, tokenCounter, events, }: {
+    terminal: Terminal;
+    modelManager: ModelManager;
+    tokenTracker: TokenTracker;
+    tokenCounter: TokenCounter;
+    events: Map<string, Message[]>;
+}): Promise<{
+    agent: import("ai").Tool<{
+        prompt: string;
+    }, string>;
+}>;

package/dist/tools/index.js

@@ -0,0 +1,209 @@
+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 { createEditFileTool } from "./edit-file.js";
+import { createGrepTool } from "./grep.js";
+import { createMemoryReadTool } from "./memory-read.js";
+import { createMemoryWriteTool } from "./memory-write.js";
+import { createMoveFileTool } from "./move-file.js";
+import { createReadFileTool } from "./read-file.js";
+import { createReadMultipleFilesTool } from "./read-multiple-files.js";
+import { createSaveFileTool } from "./save-file.js";
+import { createThinkTool } from "./think.js";
+import { createWebFetchTool } from "./web-fetch.js";
+import { createWebSearchTool } from "./web-search.js";
+const sendDataHandler = (events) => {
+    const msgStore = events;
+    return (msg) => {
+        if (msgStore.has(msg.id)) {
+            msgStore.get(msg.id)?.push(msg);
+        }
+        else {
+            msgStore.set(msg.id, [msg]);
+        }
+    };
+};
+export async function initTools({ terminal, tokenCounter, events, autoAcceptAll, }) {
+    const sendDataFn = sendDataHandler(events);
+    const readFileTool = await createReadFileTool({
+        workingDir: process.cwd(),
+        sendData: sendDataFn,
+        tokenCounter,
+    });
+    const readMultipleFilesTool = await createReadMultipleFilesTool({
+        workingDir: process.cwd(),
+        sendData: sendDataFn,
+        tokenCounter,
+    });
+    const editFileTool = await createEditFileTool({
+        workingDir: process.cwd(),
+        terminal,
+        sendData: sendDataFn,
+        autoAcceptAll,
+    });
+    const saveFileTool = await createSaveFileTool({
+        workingDir: process.cwd(),
+        sendData: sendDataFn,
+        terminal,
+        autoAcceptAll,
+    });
+    const moveFileTool = await createMoveFileTool({
+        workingDir: process.cwd(),
+        sendData: sendDataFn,
+    });
+    const directoryTreeTool = await createDirectoryTreeTool({
+        workingDir: process.cwd(),
+        sendData: sendDataFn,
+    });
+    const deleteFileTool = await createDeleteFileTool({
+        workingDir: process.cwd(),
+        sendData: sendDataFn,
+    });
+    const codeInterpreterTool = createCodeInterpreterTool({
+        sendData: sendDataFn,
+    });
+    const grepTool = createGrepTool({
+        sendData: sendDataFn,
+    });
+    const thinkTool = createThinkTool({
+        sendData: sendDataFn,
+    });
+    const webFetchTool = createWebFetchTool({
+        sendData: sendDataFn,
+        tokenCounter,
+    });
+    const webSearchTool = createWebSearchTool({
+        sendData: sendDataFn,
+        tokenCounter,
+    });
+    const bashTool = createBashTool({
+        baseDir: process.cwd(),
+        sendData: sendDataFn,
+        tokenCounter,
+        terminal,
+        autoAcceptAll,
+    });
+    const memoryReadTool = createMemoryReadTool({
+        sendData: sendDataFn,
+    });
+    const memoryWriteTool = createMemoryWriteTool({
+        sendData: sendDataFn,
+    });
+    const tools = {
+        ...readFileTool,
+        ...readMultipleFilesTool,
+        ...editFileTool,
+        ...saveFileTool,
+        ...moveFileTool,
+        ...directoryTreeTool,
+        ...deleteFileTool,
+        ...codeInterpreterTool,
+        ...grepTool,
+        ...thinkTool,
+        ...webFetchTool,
+        ...bashTool,
+        ...webSearchTool,
+        ...memoryReadTool,
+        ...memoryWriteTool,
+    };
+    return tools;
+}
+export async function initCliTools({ tokenCounter, }) {
+    const readFileTool = await createReadFileTool({
+        workingDir: process.cwd(),
+        sendData: undefined,
+        tokenCounter,
+    });
+    const readMultipleFilesTool = await createReadMultipleFilesTool({
+        workingDir: process.cwd(),
+        sendData: undefined,
+        tokenCounter,
+    });
+    const editFileTool = await createEditFileTool({
+        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 deleteFileTool = await createDeleteFileTool({
+        workingDir: process.cwd(),
+        sendData: undefined,
+    });
+    const codeInterpreterTool = createCodeInterpreterTool({
+        sendData: undefined,
+    });
+    const grepTool = createGrepTool({
+        sendData: undefined,
+    });
+    const thinkTool = createThinkTool({
+        sendData: undefined,
+    });
+    const webFetchTool = createWebFetchTool({
+        sendData: undefined,
+        tokenCounter,
+    });
+    const webSearchTool = createWebSearchTool({
+        sendData: undefined,
+        tokenCounter,
+    });
+    const bashTool = createBashTool({
+        baseDir: process.cwd(),
+        sendData: undefined,
+        tokenCounter,
+        terminal: undefined,
+        autoAcceptAll: true,
+    });
+    const memoryReadTool = createMemoryReadTool({
+        sendData: undefined,
+    });
+    const memoryWriteTool = createMemoryWriteTool({
+        sendData: undefined,
+    });
+    const tools = {
+        ...readFileTool,
+        ...readMultipleFilesTool,
+        ...editFileTool,
+        ...saveFileTool,
+        ...moveFileTool,
+        ...directoryTreeTool,
+        ...deleteFileTool,
+        ...codeInterpreterTool,
+        ...grepTool,
+        ...thinkTool,
+        ...webFetchTool,
+        ...bashTool,
+        ...webSearchTool,
+        ...memoryReadTool,
+        ...memoryWriteTool,
+    };
+    return tools;
+}
+export async function initAgents({ modelManager, tokenTracker, tokenCounter, events, }) {
+    const sendDataFn = sendDataHandler(events);
+    const agentTools = createAgentTools({
+        modelManager,
+        tokenTracker,
+        tokenCounter,
+        sendData: sendDataFn,
+    });
+    const tools = {
+        ...agentTools,
+    };
+    return tools;
+}

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

@@ -0,0 +1,13 @@
+import type { SendData } from "./types.ts";
+export declare const MemoryReadTool: {
+    name: "memoryRead";
+};
+export declare const createMemoryReadTool: (options?: {
+    sendData?: SendData | undefined;
+}) => {
+    memoryRead: import("ai").Tool<{
+        filePath: string | null;
+    }, string | {
+        content: string;
+    }>;
+};

package/dist/tools/memory-read.js

@@ -0,0 +1,135 @@
+import { access, lstat, mkdir, readdir, readFile } from "node:fs/promises";
+import { isAbsolute, join, normalize, resolve, sep } from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+import { config } from "../config.js";
+export const MemoryReadTool = {
+    name: "memoryRead",
+};
+const MEMORY_DIR = config.app.ensurePathSync("memory");
+// Helper to check if a file exists
+// Moved to module level as it does not use sendData
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Helper function, does not use sendData directly
+const _readSpecificMemoryFile = async (resolvedMemoryDir, filePath) => {
+    const normalizedRelativePath = normalize(filePath);
+    if (normalizedRelativePath.startsWith("..") ||
+        normalizedRelativePath.includes("..") ||
+        isAbsolute(normalizedRelativePath)) {
+        throw new Error(`Error: Invalid filePath "${filePath}". Must be a relative path and cannot use '..'.`);
+    }
+    const fullPath = join(resolvedMemoryDir, normalizedRelativePath);
+    if (!fullPath.startsWith(resolvedMemoryDir + sep) &&
+        fullPath !== resolvedMemoryDir) {
+        throw new Error(`Error: Path "${filePath}" resolves outside the allowed memory directory.`);
+    }
+    if (!(await fileExists(fullPath))) {
+        throw new Error(`Error: Memory file '${filePath}' does not exist.`);
+    }
+    const stats = await lstat(fullPath);
+    if (stats.isDirectory()) {
+        throw new Error(`Error: '${filePath}' is a directory. Please provide a path to a file to read.`);
+    }
+    const content = await readFile(fullPath, "utf-8");
+    return { filePath, content };
+};
+// Helper function, does not use sendData directly
+const _listMemoryFilesAndIndex = async (resolvedMemoryDir) => {
+    const entries = await readdir(resolvedMemoryDir, {
+        recursive: true,
+        withFileTypes: true,
+    });
+    const filesOnly = entries
+        .filter((entry) => entry.isFile())
+        .map((entry) => join(entry.parentPath ?? resolvedMemoryDir, entry.name)); // entry.path is available with recursive
+    const fileListString = filesOnly.length > 0
+        ? filesOnly
+            .map((p) => `- ${normalize(p.replace(resolvedMemoryDir + sep, ""))}`)
+            .join("\n") // Show relative paths
+        : "No files in memory.";
+    const indexPath = join(resolvedMemoryDir, "index.md");
+    let indexContent = "(empty)";
+    if (await fileExists(indexPath)) {
+        const stats = await lstat(indexPath);
+        if (stats.isFile()) {
+            indexContent = await readFile(indexPath, "utf-8");
+        }
+    }
+    const output = `Root memory file (index.md):
+'''
+${indexContent}
+'''
+
+Files in the memory directory:
+${fileListString}`;
+    return { content: output };
+};
+export const createMemoryReadTool = (options = {}) => {
+    const { sendData } = options;
+    const memoryReadTool = tool({
+        description: 'Read from memory files. If no path is provided, lists all files and shows content of "index.md".',
+        inputSchema: z.object({
+            filePath: z
+                .string()
+                .nullable()
+                .describe('Optional path to a specific memory file to read, relative to the memory directory. Cannot use ".." or absolute paths.'),
+        }),
+        execute: async ({ filePath }, { toolCallId }) => {
+            sendData?.({
+                event: "tool-init",
+                id: toolCallId,
+                data: "Initializing memory read...",
+            });
+            const resolvedMemoryDir = resolve(MEMORY_DIR);
+            try {
+                await mkdir(resolvedMemoryDir, { recursive: true });
+                let result;
+                if (filePath) {
+                    sendData?.({
+                        event: "tool-update",
+                        id: toolCallId,
+                        data: { primary: "Reading file:", secondary: [filePath] },
+                    });
+                    result = await _readSpecificMemoryFile(resolvedMemoryDir, filePath);
+                }
+                else {
+                    sendData?.({
+                        event: "tool-update",
+                        id: toolCallId,
+                        data: { primary: "Listing memory files and index" },
+                    });
+                    result = await _listMemoryFilesAndIndex(resolvedMemoryDir);
+                }
+                sendData?.({
+                    event: "tool-completion",
+                    id: toolCallId,
+                    data: "Done",
+                });
+                return result;
+            }
+            catch (error) {
+                let errorMsg = "Error reading memory: An unknown error occurred";
+                if (error instanceof Error) {
+                    errorMsg = `Error reading memory: ${error.message}`;
+                }
+                sendData?.({
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMsg,
+                });
+                return errorMsg;
+            }
+        },
+    });
+    return {
+        [MemoryReadTool.name]: memoryReadTool,
+    };
+};

package/dist/tools/memory-write.d.ts

@@ -0,0 +1,12 @@
+import type { SendData } from "./types.ts";
+export declare const MemoryWriteTool: {
+    name: "memoryWrite";
+};
+export declare const createMemoryWriteTool: (options?: {
+    sendData?: SendData | undefined;
+}) => {
+    memoryWrite: import("ai").Tool<{
+        filePath: string;
+        content: string;
+    }, string>;
+};

package/dist/tools/memory-write.js

@@ -0,0 +1,83 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, join, normalize, resolve, sep } from "node:path";
+import { tool } from "ai";
+import { z } from "zod";
+import { config } from "../config.js";
+export const MemoryWriteTool = {
+    name: "memoryWrite",
+};
+const MEMORY_DIR = config.app.ensurePathSync("memory");
+export const createMemoryWriteTool = (options = {}) => {
+    const { sendData } = options;
+    const memoryWriteTool = tool({
+        description: "Write content to a memory file.",
+        inputSchema: z.object({
+            filePath: z
+                .string()
+                .describe('Path to the memory file, relative to the memory directory. Cannot use ".." or absolute paths.'),
+            content: z.string().describe("Content to write to the file."),
+        }),
+        execute: async ({ filePath, content }, { toolCallId }) => {
+            sendData?.({
+                event: "tool-init",
+                id: toolCallId,
+                data: "Initializing memory write...",
+            });
+            const resolvedMemoryDir = resolve(MEMORY_DIR);
+            const normalizedRelativePath = normalize(filePath);
+            if (normalizedRelativePath.startsWith("..") ||
+                normalizedRelativePath.includes("..") ||
+                isAbsolute(normalizedRelativePath)) {
+                const errorMsg = `Error: Invalid filePath "${filePath}". Must be a relative path within the memory directory and cannot use '..'.`;
+                sendData?.({
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMsg,
+                });
+                return errorMsg;
+            }
+            const fullPath = join(resolvedMemoryDir, normalizedRelativePath);
+            if (!fullPath.startsWith(resolvedMemoryDir + sep) &&
+                fullPath !== resolvedMemoryDir) {
+                const errorMsg = `Error: Path "${filePath}" resolves outside the allowed memory directory.`;
+                sendData?.({
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMsg,
+                });
+                return errorMsg;
+            }
+            sendData?.({
+                event: "tool-update",
+                id: toolCallId,
+                data: { primary: "Writing to file:", secondary: [filePath] },
+            });
+            try {
+                await mkdir(dirname(fullPath), { recursive: true });
+                await writeFile(fullPath, content, "utf-8");
+                const successMsg = `Memory file '${filePath}' written successfully.`;
+                sendData?.({
+                    event: "tool-completion",
+                    id: toolCallId,
+                    data: successMsg,
+                });
+                return successMsg;
+            }
+            catch (error) {
+                let errorMsg = `Error writing memory file '${filePath}': An unknown error occurred`;
+                if (error instanceof Error) {
+                    errorMsg = `Error writing memory file '${filePath}': ${error.message}`;
+                }
+                sendData?.({
+                    event: "tool-error",
+                    id: toolCallId,
+                    data: errorMsg,
+                });
+                return errorMsg;
+            }
+        },
+    });
+    return {
+        [MemoryWriteTool.name]: memoryWriteTool,
+    };
+};

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

@@ -0,0 +1,13 @@
+import type { SendData } from "./types.ts";
+export declare const MoveFileTool: {
+    name: "moveFile";
+};
+export declare const createMoveFileTool: ({ workingDir, sendData, }: {
+    workingDir: string;
+    sendData?: SendData;
+}) => Promise<{
+    moveFile: import("ai").Tool<{
+        source: string;
+        destination: string;
+    }, string>;
+}>;

package/dist/tools/move-file.js

@@ -0,0 +1,44 @@
+import fs from "node:fs/promises";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { joinWorkingDir, validatePath } from "./filesystem-utils.js";
+export const MoveFileTool = {
+    name: "moveFile",
+};
+export const createMoveFileTool = async ({ workingDir, sendData, }) => {
+    const allowedDirectory = workingDir;
+    return {
+        [MoveFileTool.name]: tool({
+            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}`;
+                }
+                catch (error) {
+                    return `Failed to move file: ${error.message}`;
+                }
+            },
+        }),
+    };
+};

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

@@ -0,0 +1,17 @@
+import type { TokenCounter } from "../token-utils.ts";
+import type { SendData } from "./types.ts";
+export declare const ReadFileTool: {
+    name: "readFile";
+};
+export declare const createReadFileTool: ({ workingDir, sendData, tokenCounter, }: {
+    workingDir: string;
+    sendData?: SendData;
+    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>;
+}>;