@travisennis/acai 0.0.1

package/dist/tools/edit-file.js

@@ -0,0 +1,107 @@
+import { input, select } from "@inquirer/prompts";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { applyFileEdits, joinWorkingDir, validatePath, } from "./filesystem-utils.js";
+export const EditFileTool = {
+    name: "editFile",
+};
+export const createEditFileTool = async ({ workingDir, terminal, sendData, autoAcceptAll, }) => {
+    const allowedDirectory = workingDir;
+    let autoAcceptEdits = autoAcceptAll;
+    return {
+        [EditFileTool.name]: tool({
+            description: "Make line-based edits to a text file. Each edit replaces exact line sequences " +
+                "with new content. Returns a git-style diff showing the changes made. " +
+                "Only works within allowed directories.",
+            inputSchema: z.object({
+                path: z.string().describe("The path of the file to edit."),
+                edits: z.array(z.object({
+                    oldText: z
+                        .string()
+                        .describe("Text to search for - must match exactly and enough context must be provided to uniquely match the target text"),
+                    newText: z.string().describe("Text to replace with"),
+                })),
+            }),
+            execute: async ({ path, edits }, { toolCallId }) => {
+                sendData?.({
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `Editing file: ${chalk.cyan(path)}`,
+                });
+                try {
+                    const validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory);
+                    if (terminal) {
+                        terminal.writeln(`\n${chalk.blue.bold("●")} Proposing file changes: ${chalk.cyan(path)}`);
+                        terminal.lineBreak();
+                        const result = await applyFileEdits(validPath, edits, true);
+                        terminal.writeln(`The agent is proposing the following ${chalk.cyan(edits.length)} edits:`);
+                        terminal.lineBreak();
+                        terminal.display(result);
+                        terminal.lineBreak();
+                        let userChoice;
+                        if (autoAcceptEdits) {
+                            terminal.writeln(chalk.green("✓ Auto-accepting edits (all future edits will be accepted)"));
+                            userChoice = "accept";
+                        }
+                        else {
+                            userChoice = await select({
+                                message: "What would you like to do with these changes?",
+                                choices: [
+                                    { name: "Accept these changes", value: "accept" },
+                                    {
+                                        name: "Accept all future edits (including these)",
+                                        value: "accept-all",
+                                    },
+                                    { name: "Reject these changes", value: "reject" },
+                                ],
+                                default: "accept",
+                            });
+                        }
+                        terminal.lineBreak();
+                        if (userChoice === "accept-all") {
+                            autoAcceptEdits = true;
+                            terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future edits"));
+                            terminal.lineBreak();
+                        }
+                        if (userChoice === "accept" || userChoice === "accept-all") {
+                            const finalEdits = await applyFileEdits(validPath, edits, false);
+                            // Send completion message indicating success
+                            sendData?.({
+                                id: toolCallId,
+                                event: "tool-completion",
+                                data: "Edits accepted and applied successfully.",
+                            });
+                            return finalEdits;
+                        }
+                        const reason = await input({ message: "Feedback: " });
+                        terminal.lineBreak();
+                        // Send completion message indicating rejection
+                        sendData?.({
+                            id: toolCallId,
+                            event: "tool-completion",
+                            data: `Edits rejected by user. Reason: ${reason}`,
+                        });
+                        return `The user rejected these changes. Reason: ${reason}`;
+                    }
+                    const finalEdits = await applyFileEdits(validPath, edits, false);
+                    // Send completion message indicating success
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-completion",
+                        data: "Edits accepted and applied successfully.",
+                    });
+                    return finalEdits;
+                }
+                catch (error) {
+                    sendData?.({
+                        event: "tool-error",
+                        id: toolCallId,
+                        data: `Failed to edit file: ${error.message}`,
+                    });
+                    return `Failed to edit file: ${error.message}`;
+                }
+            },
+        }),
+    };
+};

package/dist/tools/filesystem-utils.d.ts

@@ -0,0 +1,22 @@
+import type { TokenCounter } from "../token-utils.ts";
+export declare function normalizePath(p: string): string;
+export declare function joinWorkingDir(userPath: string, workingDir: string): string;
+export declare function expandHome(filepath: string): string;
+export declare function validatePath(requestedPath: string, allowedDirectory: string): Promise<string>;
+export interface FileEdit {
+    oldText: string;
+    newText: string;
+}
+export declare function applyFileEdits(filePath: string, edits: FileEdit[], dryRun?: boolean): Promise<string>;
+/**
+ * Generates a string representation of a directory tree starting from the given path.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ */
+export declare function directoryTree(dirPath: string): Promise<string>;
+export declare function readFileAndCountTokens(filePath: string, workingDir: string, allowedDirectory: string, tokenCounter: TokenCounter, maxTokens: number): Promise<{
+    path: string;
+    content: string | null;
+    tokenCount: number;
+    error: string | null;
+}>;

package/dist/tools/filesystem-utils.js

@@ -0,0 +1,191 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { createTwoFilesPatch } from "diff";
+import ignore from "ignore";
+// Normalize all paths consistently
+export function normalizePath(p) {
+    return path.normalize(p);
+}
+// Handle path joining with working directory
+export function joinWorkingDir(userPath, workingDir) {
+    if (path.isAbsolute(userPath)) {
+        return path.normalize(userPath);
+    }
+    return path.normalize(path.join(workingDir, userPath));
+}
+export function expandHome(filepath) {
+    if (filepath.startsWith("~/") || filepath === "~") {
+        return path.join(os.homedir(), filepath.slice(1));
+    }
+    return filepath;
+}
+// Security utilities
+export async function validatePath(requestedPath, allowedDirectory) {
+    const expandedPath = expandHome(requestedPath);
+    const absolute = path.isAbsolute(expandedPath)
+        ? path.resolve(expandedPath)
+        : path.resolve(process.cwd(), expandedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within allowed directories
+    const isAllowed = normalizedRequested.startsWith(allowedDirectory);
+    if (!isAllowed) {
+        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${allowedDirectory}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        const isRealPathAllowed = normalizedReal.startsWith(allowedDirectory);
+        if (!isRealPathAllowed) {
+            throw new Error("Access denied - symlink target outside allowed directories");
+        }
+        return realPath;
+    }
+    catch (_error) {
+        // For new files that don't exist yet, verify parent directory
+        const parentDir = path.dirname(absolute);
+        try {
+            const realParentPath = await fs.realpath(parentDir);
+            const normalizedParent = normalizePath(realParentPath);
+            const isParentAllowed = normalizedParent.startsWith(allowedDirectory);
+            if (!isParentAllowed) {
+                throw new Error("Access denied - parent directory outside allowed directories");
+            }
+            return absolute;
+        }
+        catch {
+            throw new Error(`Parent directory does not exist: ${parentDir}`);
+        }
+    }
+}
+// file editing and diffing utilities
+function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+function createUnifiedDiff(originalContent, newContent, filepath = "file") {
+    // Ensure consistent line endings for diff
+    const normalizedOriginal = normalizeLineEndings(originalContent);
+    const normalizedNew = normalizeLineEndings(newContent);
+    return createTwoFilesPatch(filepath, filepath, normalizedOriginal, normalizedNew, "original", "modified");
+}
+export async function applyFileEdits(filePath, edits, dryRun = false) {
+    // Read file content literally
+    const originalContent = await fs.readFile(filePath, "utf-8");
+    if (edits.find((edit) => edit.oldText.length === 0)) {
+        throw new Error("Invalid oldText in edit. The value of oldText must be at least one character");
+    }
+    // Apply edits sequentially
+    let modifiedContent = originalContent;
+    for (const edit of edits) {
+        const { oldText, newText } = edit; // Use literal oldText and newText
+        const normalizedContent = normalizeLineEndings(modifiedContent);
+        const normalizedOldText = normalizeLineEndings(oldText);
+        if (normalizedContent.includes(normalizedOldText)) {
+            modifiedContent = normalizedContent.replace(normalizedOldText, newText);
+        }
+        else {
+            // If literal match is not found, throw an error.
+            // The previous complex fallback logic is removed to ensure literal matching.
+            throw new Error(`Could not find literal match for edit:\n${edit.oldText}`);
+        }
+    }
+    // Create unified diff (createUnifiedDiff normalizes line endings internally for diffing)
+    const diff = createUnifiedDiff(originalContent, modifiedContent, filePath);
+    // Format diff with appropriate number of backticks
+    let numBackticks = 3;
+    while (diff.includes("`".repeat(numBackticks))) {
+        numBackticks++;
+    }
+    const formattedDiff = `${"`".repeat(numBackticks)}diff\n${diff}${"`".repeat(numBackticks)}\n\n`;
+    if (!dryRun) {
+        // Write the modified content (which has literal newlines from newText, and preserves original newlines not part of oldText/newText)
+        await fs.writeFile(filePath, modifiedContent, "utf-8");
+    }
+    return formattedDiff;
+}
+/**
+ * Generates the indentation string for a given level in the directory tree.
+ * @param level - The current level in the directory tree.
+ * @param isLast - Indicates if the current item is the last in its parent directory.
+ * @returns The indentation string for the current level.
+ */
+function getIndent(level, isLast) {
+    const indent = "│   ".repeat(level - 1);
+    return level === 0 ? "" : `${indent}${isLast ? "└── " : "├── "}`;
+}
+/**
+ * Recursively generates a string representation of a directory tree.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @param level - The current level in the directory tree (default: 1).
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ * @throws Will log an error if there's an issue reading the directory.
+ */
+async function generateDirectoryTree(dirPath, ig, level = 1) {
+    const name = path.basename(dirPath);
+    let output = `${getIndent(level, false)}${name}\n`;
+    const items = await fs.readdir(dirPath);
+    const filteredItems = ig.filter(items);
+    for (let i = 0; i < filteredItems.length; i++) {
+        const item = filteredItems[i] ?? "";
+        const itemPath = path.join(dirPath, item);
+        const isLast = i === items.length - 1;
+        const stats = await fs.stat(itemPath);
+        if (stats.isDirectory()) {
+            output += await generateDirectoryTree(itemPath, ig, level + 1);
+        }
+        else {
+            output += `${getIndent(level + 1, isLast)}${item}\n`;
+        }
+    }
+    return output;
+}
+/**
+ * Generates a string representation of a directory tree starting from the given path.
+ * @param dirPath - The path of the directory to generate the tree for.
+ * @returns A Promise that resolves to a string representation of the directory tree.
+ */
+export async function directoryTree(dirPath) {
+    let ig;
+    try {
+        const ignoreFile = await fs.readFile(path.join(process.cwd(), ".gitignore"));
+        ig = ignore().add(ignoreFile.toString()).add(".git");
+    }
+    catch (_error) {
+        // If .gitignore doesn't exist, create basic ignore with just .git
+        ig = ignore().add(".git");
+    }
+    return (await generateDirectoryTree(dirPath, ig)).trim();
+}
+export async function readFileAndCountTokens(filePath, workingDir, allowedDirectory, tokenCounter, maxTokens) {
+    try {
+        const validPath = await validatePath(joinWorkingDir(filePath, workingDir), allowedDirectory);
+        const content = await fs.readFile(validPath, "utf-8");
+        let tokenCount = 0;
+        try {
+            tokenCount = tokenCounter.count(content);
+        }
+        catch (tokenError) {
+            console.error("Error calculating token count:", tokenError);
+            // Handle token calculation error if needed
+        }
+        const maxTokenMessage = `File content (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Use readFile with startLine/lineCount or grepFiles for targeted access.`;
+        const finalContent = tokenCount > maxTokens ? maxTokenMessage : content;
+        const actualTokenCount = tokenCount > maxTokens ? 0 : tokenCount; // Don't count tokens for skipped files
+        return {
+            path: filePath,
+            content: finalContent,
+            tokenCount: actualTokenCount,
+            error: null,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            path: filePath,
+            content: null,
+            tokenCount: 0,
+            error: errorMessage,
+        };
+    }
+}

package/dist/tools/git-utils.d.ts

@@ -0,0 +1,14 @@
+export declare function getDiffStat(): Promise<{
+    filesChanged: number;
+    insertions: number;
+    deletions: number;
+}>;
+export declare const inGitDirectory: () => Promise<boolean>;
+/**
+ * Check if there are uncommitted changes
+ */
+export declare function hasUncommittedChanges(): Promise<boolean>;
+/**
+ * Get the current git branch name
+ */
+export declare function getCurrentBranch(): Promise<string | null>;

package/dist/tools/git-utils.js

@@ -0,0 +1,64 @@
+import { memoize } from "@travisennis/stdlib/functional";
+import { simpleGit } from "simple-git";
+import { executeCommand } from "../utils/process.js";
+// Function to get diff stats
+export async function getDiffStat() {
+    const git = simpleGit(process.cwd());
+    try {
+        // Get diff stat comparing working directory to HEAD
+        const diffSummary = await git.diffSummary(["--stat"]);
+        return {
+            filesChanged: diffSummary.files.length,
+            insertions: diffSummary.insertions,
+            deletions: diffSummary.deletions,
+        };
+    }
+    catch (error) {
+        // Handle cases where git diff fails (e.g., initial commit)
+        console.error("Error getting git diff stat:", error);
+        return {
+            filesChanged: 0,
+            insertions: 0,
+            deletions: 0,
+        };
+    }
+}
+export const inGitDirectory = memoize(async () => {
+    const { code } = await executeCommand(["git", "rev-parse", "--is-inside-work-tree"], {
+        cwd: process.cwd(),
+        throwOnError: false,
+    });
+    return code === 0;
+});
+/**
+ * Check if there are uncommitted changes
+ */
+export async function hasUncommittedChanges() {
+    if (!(await inGitDirectory())) {
+        return false;
+    }
+    const git = simpleGit(process.cwd());
+    try {
+        const status = await git.status();
+        return status.files.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the current git branch name
+ */
+export async function getCurrentBranch() {
+    if (!(await inGitDirectory())) {
+        return null;
+    }
+    const git = simpleGit(process.cwd());
+    try {
+        const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+        return branch.trim();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/tools/grep.d.ts

@@ -0,0 +1,17 @@
+import type { SendData } from "./types.ts";
+export declare const GrepTool: {
+    name: "grepFiles";
+};
+export declare const createGrepTool: (options?: {
+    sendData?: SendData | undefined;
+}) => {
+    grepFiles: import("ai").Tool<{
+        path: string;
+        pattern: string;
+        recursive: boolean | null;
+        ignoreCase: boolean | null;
+        filePattern: string | null;
+        contextLines: number | null;
+        searchIgnored: boolean | null;
+    }, string>;
+};

package/dist/tools/grep.js

@@ -0,0 +1,138 @@
+import { execSync } from "node:child_process";
+import { inspect } from "node:util";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+export const GrepTool = {
+    name: "grepFiles",
+};
+export const createGrepTool = (options = {}) => {
+    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.message);
+                }
+            },
+        }),
+    };
+};
+/**
+ * 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, path, options = {}) {
+    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.message}`);
+    }
+}