@travisennis/acai 0.0.1

package/source/tools/grep.ts

@@ -0,0 +1,184 @@
+import { execSync } from "node:child_process";
+import { inspect } from "node:util";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import type { SendData } from "./types.ts";
+
+export const GrepTool = {
+  name: "grepFiles" as const,
+};
+
+export const createGrepTool = (
+  options: { sendData?: SendData | undefined } = {},
+) => {
+  const { sendData } = options;
+  return {
+    [GrepTool.name]: tool({
+      description: "Search files for patterns using ripgrep",
+      inputSchema: z.object({
+        pattern: z.string().describe("The regex pattern to search for"),
+        path: z.string().describe("The path to search in"),
+        recursive: z
+          .boolean()
+          .nullable()
+          .describe("Pass null to use the default (true, search recursively)."),
+        ignoreCase: z
+          .boolean()
+          .nullable()
+          .describe(
+            "Pass null to use the default (false, case-sensitive search).",
+          ),
+        filePattern: z
+          .string()
+          .nullable()
+          .describe("Pass null if no file pattern filter is needed."),
+        contextLines: z
+          .number()
+          .nullable()
+          .describe("Pass null if no context lines are needed."),
+        searchIgnored: z
+          .boolean()
+          .nullable()
+          .describe(
+            "Pass null to use the default (false, don't search ignored files).",
+          ),
+      }),
+      execute: (
+        {
+          pattern,
+          path,
+          recursive,
+          ignoreCase,
+          filePattern,
+          contextLines,
+          searchIgnored,
+        },
+        { toolCallId },
+      ) => {
+        try {
+          sendData?.({
+            event: "tool-init",
+            id: toolCallId,
+            data: `Searching codebase for "${chalk.cyan(inspect(pattern))}" in ${chalk.cyan(path)}`,
+          });
+          const result = grepFiles(pattern, path, {
+            recursive,
+            ignoreCase,
+            filePattern,
+            contextLines,
+            searchIgnored,
+          });
+
+          const matchCount =
+            result === "No matches found."
+              ? 0
+              : result
+                  .trim()
+                  .split("\n")
+                  .filter((line) => {
+                    if (line === "--") {
+                      return false;
+                    }
+                    // A match line from ripgrep with --line-number has the format:
+                    // path:linenumber:match
+                    // A context line has the format:
+                    // path-linenumber-match
+                    // This regex distinguishes between them by looking for the colon after the line number.
+                    return /^(.+?):(\d+):(.*)$/.test(line);
+                  }).length;
+
+          sendData?.({
+            event: "tool-completion",
+            id: toolCallId,
+            data: `Found ${chalk.cyan(matchCount)} matches.`,
+          });
+          return Promise.resolve(result);
+        } catch (error) {
+          sendData?.({
+            event: "tool-error",
+            id: toolCallId,
+            data: `Error searching for "${pattern}" in ${path}`,
+          });
+          return Promise.resolve((error as Error).message);
+        }
+      },
+    }),
+  };
+};
+
+interface GrepOptions {
+  recursive?: boolean | null;
+  ignoreCase?: boolean | null;
+  filePattern?: string | null;
+  contextLines?: number | null;
+  searchIgnored?: boolean | null;
+}
+
+/**
+ * Search files for patterns using ripgrep
+ *
+ * @param pattern - The regex pattern to search for
+ * @param path - The path to search in
+ * @param options - Additional options for the grep command
+ * @returns The result of the grep command
+ */
+function grepFiles(
+  pattern: string,
+  path: string,
+  options: GrepOptions = {},
+): string {
+  try {
+    // Handle null values by providing defaults
+    const effectiveRecursive =
+      options.recursive === null ? true : options.recursive;
+    const effectiveIgnoreCase =
+      options.ignoreCase === null ? false : options.ignoreCase;
+    const effectiveSearchIgnored =
+      options.searchIgnored === null ? false : options.searchIgnored;
+    const effectiveFilePattern = options.filePattern;
+    const effectiveContextLines = options.contextLines;
+
+    // Build the ripgrep command
+    let command = "rg --line-number";
+
+    // Ripgrep is recursive by default, so we only need to add
+    // --no-recursive if effectiveRecursive is explicitly false
+    if (effectiveRecursive === false) {
+      command += " --max-depth=0";
+    }
+
+    if (effectiveIgnoreCase) {
+      command += " --ignore-case";
+    }
+
+    if (effectiveContextLines !== null && effectiveContextLines !== undefined) {
+      command += ` --context=${effectiveContextLines}`;
+    }
+
+    // Add pattern (escaped for shell)
+    command += ` ${JSON.stringify(pattern)}`;
+
+    // Add path
+    command += ` ${path}`;
+
+    // Add file pattern if specified
+    if (effectiveFilePattern !== null && effectiveFilePattern !== undefined) {
+      command += ` --glob=${JSON.stringify(effectiveFilePattern)}`;
+    }
+
+    if (effectiveSearchIgnored) {
+      command += " --no-ignore";
+    }
+
+    // Execute the command
+    const result = execSync(command, { encoding: "utf-8" });
+    return result;
+  } catch (error) {
+    if (error instanceof Error && "status" in error && error.status === 1) {
+      // Status 1 in ripgrep just means "no matches found"
+      return "No matches found.";
+    }
+    throw new Error(`Error executing ripgrep: ${(error as Error).message}`);
+  }
+}

package/source/tools/index.ts

@@ -0,0 +1,278 @@
+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 { createAgentTools } from "./agent.ts";
+import { createBashTool } from "./bash.ts";
+import { createCodeInterpreterTool } from "./code-interpreter.ts";
+import { createDeleteFileTool } from "./delete-file.ts";
+import { createDirectoryTreeTool } from "./directory-tree.ts";
+import { createEditFileTool } from "./edit-file.ts";
+import { createGrepTool } from "./grep.ts";
+import { createMemoryReadTool } from "./memory-read.ts";
+import { createMemoryWriteTool } from "./memory-write.ts";
+import { createMoveFileTool } from "./move-file.ts";
+import { createReadFileTool } from "./read-file.ts";
+import { createReadMultipleFilesTool } from "./read-multiple-files.ts";
+import { createSaveFileTool } from "./save-file.ts";
+import { createThinkTool } from "./think.ts";
+import type { Message } from "./types.ts";
+import { createWebFetchTool } from "./web-fetch.ts";
+import { createWebSearchTool } from "./web-search.ts";
+
+const sendDataHandler = (events: Map<string, Message[]>) => {
+  const msgStore: Map<string, Message[]> = events;
+  return (msg: Message) => {
+    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,
+}: {
+  terminal: Terminal;
+  tokenCounter: TokenCounter;
+  events: Map<string, Message[]>;
+  autoAcceptAll: boolean;
+}) {
+  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,
+  } as const;
+
+  return tools;
+}
+
+export async function initCliTools({
+  tokenCounter,
+}: {
+  tokenCounter: 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,
+  } as const;
+
+  return tools;
+}
+
+export async function initAgents({
+  modelManager,
+  tokenTracker,
+  tokenCounter,
+  events,
+}: {
+  terminal: Terminal;
+  modelManager: ModelManager;
+  tokenTracker: TokenTracker;
+  tokenCounter: TokenCounter;
+  events: Map<string, Message[]>;
+}) {
+  const sendDataFn = sendDataHandler(events);
+
+  const agentTools = createAgentTools({
+    modelManager,
+    tokenTracker,
+    tokenCounter,
+    sendData: sendDataFn,
+  });
+
+  const tools = {
+    ...agentTools,
+  };
+
+  return tools;
+}

package/source/tools/memory-read.ts

@@ -0,0 +1,174 @@
+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.ts";
+import type { SendData } from "./types.ts";
+
+export const MemoryReadTool = {
+  name: "memoryRead" as const,
+};
+
+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: string): Promise<boolean> {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Helper function, does not use sendData directly
+const _readSpecificMemoryFile = async (
+  resolvedMemoryDir: string,
+  filePath: string,
+) => {
+  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: string) => {
+  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: { sendData?: SendData | undefined } = {},
+) => {
+  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 }: { filePath: string | null },
+      { toolCallId },
+    ) => {
+      sendData?.({
+        event: "tool-init",
+        id: toolCallId,
+        data: "Initializing memory read...",
+      });
+
+      const resolvedMemoryDir = resolve(MEMORY_DIR);
+
+      try {
+        await mkdir(resolvedMemoryDir, { recursive: true });
+
+        let result: { content: string };
+        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: unknown) {
+        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,
+  };
+};