@travisennis/acai 0.0.1 → 0.0.2

package/source/tools/grep.ts

@@ -1,184 +0,0 @@
-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

@@ -1,278 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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,
-  };
-};