@travisennis/acai 0.0.1

package/dist/source/tools/bash.js

@@ -0,0 +1,294 @@
+import path from "node:path";
+import { input, select } from "@inquirer/prompts";
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { config } from "../config.js";
+import { executeCommand } from "../utils/process.js";
+import { CommandValidation } from "./command-validation.js";
+export const BashTool = {
+    name: "bash",
+};
+function tokenize(inputStr) {
+    const tokens = [];
+    let current = "";
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < inputStr.length; i++) {
+        const ch = inputStr[i];
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            current += ch;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            current += ch;
+            continue;
+        }
+        if (!inSingle && !inDouble && /\s/.test(ch)) {
+            if (current.length > 0) {
+                const raw = current;
+                const unquoted = raw.replace(/^['"]|['"]$/g, "");
+                tokens.push({ raw, unquoted });
+                current = "";
+            }
+            continue;
+        }
+        if (ch === "\\" && inDouble && i + 1 < inputStr.length) {
+            const next = inputStr[i + 1];
+            if (next === '"' || next === "\\") {
+                current += next;
+                i++;
+                continue;
+            }
+        }
+        current += ch;
+    }
+    if (current.length > 0) {
+        const raw = current;
+        const unquoted = raw.replace(/^['"]|['"]$/g, "");
+        tokens.push({ raw, unquoted });
+    }
+    return tokens;
+}
+function shouldSkipPathValidation(tokens, index) {
+    if (index === 0)
+        return false;
+    const cmd = tokens[0]?.unquoted;
+    if (cmd !== "git")
+        return false;
+    const sub = tokens[1]?.unquoted;
+    if (sub !== "commit" &&
+        sub !== "tag" &&
+        !(sub === "notes" && tokens[2]?.unquoted === "add")) {
+        return false;
+    }
+    const prev = tokens[index - 1]?.unquoted;
+    if (prev === "-m" || prev === "--message")
+        return true;
+    return false;
+}
+function looksLikeUrl(str) {
+    return str.startsWith("http://") || str.startsWith("https://");
+}
+// Whitelist of allowed commands
+const ALLOWED_COMMANDS = [
+    "chmod",
+    "ls",
+    "pwd",
+    "cat",
+    "grep",
+    "find",
+    "echo",
+    "mkdir",
+    "touch",
+    "cp",
+    "mv",
+    "pwd",
+    "wc",
+    "diff",
+    "sort",
+    "head",
+    "tail",
+    "sleep",
+    "npm",
+    "npx",
+    "node",
+    "git",
+    "gh",
+    "rg",
+    "jq",
+    "sed",
+    "awk",
+];
+// Command execution timeout in milliseconds
+const DEFAULT_TIMEOUT = 1.5 * 60 * 1000; // 1.5 minutes
+// Initialize command validator with allowed commands
+const commandValidator = new CommandValidation(ALLOWED_COMMANDS);
+// Ensure path is within base directory
+function isPathWithinBaseDir(requestedPath, baseDir) {
+    const normalizedRequestedPath = path.normalize(requestedPath);
+    const normalizedBaseDir = path.normalize(baseDir);
+    return normalizedRequestedPath.startsWith(normalizedBaseDir);
+}
+export const createBashTool = ({ baseDir, sendData, tokenCounter, terminal, autoAcceptAll, }) => {
+    let autoAcceptCommands = autoAcceptAll;
+    return {
+        [BashTool.name]: tool({
+            description: `Execute bash commands and return their output. Limited to a whitelist of safe commands: ${ALLOWED_COMMANDS.join(", ")}. Commands will only execute within the project directory for security. Always specify absolute paths to avoid errors.`,
+            inputSchema: z.object({
+                command: z
+                    .string()
+                    .describe("Full CLI command to execute. Must be from the allowed list without chaining operators."),
+                cwd: z
+                    .string()
+                    .nullable()
+                    .describe("Working directory (default: project root). Must be within the project directory."),
+                timeout: z
+                    .number()
+                    .nullable()
+                    .describe(`Command execution timeout in milliseconds. Default: ${DEFAULT_TIMEOUT}ms`),
+            }),
+            execute: async ({ command, cwd, timeout }, { toolCallId }) => {
+                // Guard against null cwd and timeout
+                const safeCwd = cwd == null ? baseDir : cwd;
+                const safeTimeout = timeout == null ? DEFAULT_TIMEOUT : timeout;
+                sendData?.({
+                    event: "tool-init",
+                    id: toolCallId,
+                    data: `Executing: ${chalk.cyan(command)} in ${chalk.cyan(safeCwd)}`,
+                });
+                // Validate command using CommandValidation
+                if (!commandValidator.isValid(command)) {
+                    const errorMsg = `Command not allowed. Ensure all sub-commands are in the approved list: ${ALLOWED_COMMANDS.join(", ")} and no unsafe operators (>, <, \`, $()) are used.`;
+                    sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
+                    return errorMsg;
+                }
+                // Validate working directory
+                if (!isPathWithinBaseDir(safeCwd, baseDir)) {
+                    const errorMsg = `Working directory must be within the project directory: ${baseDir}`;
+                    sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
+                    return errorMsg;
+                }
+                // Validate command arguments for paths outside baseDir
+                const tokens = tokenize(command);
+                for (let i = 0; i < tokens.length; i++) {
+                    const token = tokens[i];
+                    if (token == null)
+                        continue;
+                    const part = token.unquoted;
+                    if (shouldSkipPathValidation(tokens, i)) {
+                        continue;
+                    }
+                    if (looksLikeUrl(part)) {
+                        continue;
+                    }
+                    if (part.startsWith("/") ||
+                        part.includes("../") ||
+                        part.includes("./") ||
+                        (part.includes("/") && !part.startsWith("-"))) {
+                        try {
+                            const resolvedPath = path.resolve(safeCwd, part);
+                            if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
+                                const errorMsg = `Command argument references path outside the project directory: ${part} (resolved to ${resolvedPath})`;
+                                sendData?.({
+                                    event: "tool-error",
+                                    id: toolCallId,
+                                    data: errorMsg,
+                                });
+                                return errorMsg;
+                            }
+                        }
+                        catch (e) {
+                            console.info(`Could not resolve potential path argument: ${part}`, e);
+                        }
+                    }
+                }
+                // Prompt user for command execution approval (only in interactive mode)
+                if (terminal) {
+                    if (!autoAcceptCommands) {
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                    }
+                    terminal.lineBreak();
+                    terminal.writeln(`${chalk.blue.bold("●")} About to execute command: ${chalk.cyan(command)}`);
+                    terminal.writeln(`${chalk.gray("Working directory:")} ${safeCwd}`);
+                    terminal.lineBreak();
+                    let userChoice;
+                    if (autoAcceptCommands) {
+                        terminal.writeln(chalk.green("✓ Auto-accepting command (all future commands will be accepted)"));
+                        userChoice = "accept";
+                    }
+                    else {
+                        userChoice = await select({
+                            message: "What would you like to do with this command?",
+                            choices: [
+                                { name: "Execute this command", value: "accept" },
+                                {
+                                    name: "Execute all future commands (including this)",
+                                    value: "accept-all",
+                                },
+                                { name: "Reject this command", value: "reject" },
+                            ],
+                            default: "accept",
+                        });
+                    }
+                    terminal.lineBreak();
+                    if (userChoice === "accept-all") {
+                        autoAcceptCommands = true;
+                        terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future commands"));
+                        terminal.lineBreak();
+                    }
+                    if (userChoice === "reject") {
+                        const reason = await input({ message: "Feedback: " });
+                        terminal.lineBreak();
+                        const rejectionMsg = `Command rejected by user. Reason: ${reason}`;
+                        sendData?.({
+                            event: "tool-completion",
+                            id: toolCallId,
+                            data: rejectionMsg,
+                        });
+                        return rejectionMsg;
+                    }
+                }
+                try {
+                    const result = await executeCommand(command, {
+                        cwd: safeCwd,
+                        timeout: safeTimeout,
+                        shell: true,
+                        throwOnError: false,
+                    });
+                    if (result.signal === "SIGTERM") {
+                        const timeoutMessage = `Command timed out after ${safeTimeout}ms. This might be because the command is waiting for input.`;
+                        sendData?.({
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: timeoutMessage,
+                        });
+                        return timeoutMessage;
+                    }
+                    const formattedResult = format(result);
+                    sendData?.({
+                        event: "tool-update",
+                        id: toolCallId,
+                        data: {
+                            primary: "Result",
+                            secondary: formattedResult.split("\n").slice(-5),
+                        },
+                    });
+                    let tokenCount = 0;
+                    try {
+                        tokenCount = tokenCounter.count(formattedResult);
+                    }
+                    catch (tokenError) {
+                        console.error("Error calculating token count:", tokenError);
+                        // Log or handle error, but don't block file return
+                    }
+                    const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
+                    // Adjust max token check message if line selection was used
+                    const maxTokenMessage = `Output of commmand (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please adjust how you call the command to get back more specific results`;
+                    const finalResult = tokenCount <= maxTokens ? formattedResult : maxTokenMessage;
+                    sendData?.({
+                        event: "tool-completion",
+                        id: toolCallId,
+                        data: tokenCount <= maxTokens
+                            ? "Command executed successfully."
+                            : `Output of commmand (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}).`,
+                    });
+                    return finalResult;
+                }
+                catch (error) {
+                    sendData?.({
+                        event: "tool-error",
+                        id: toolCallId,
+                        data: `Command failed: ${error.message}`,
+                    });
+                    return `Command failed: ${error.message}`;
+                }
+            },
+        }),
+    };
+};
+function format({ stdout, stderr, }) {
+    return `${stdout}\n${stderr}`;
+}

package/dist/source/tools/code-interpreter.d.ts

@@ -0,0 +1,12 @@
+import type { SendData } from "./types.ts";
+export declare const CodeInterpreterTool: {
+    name: "codeInterpreter";
+};
+export declare const createCodeInterpreterTool: ({ sendData, }: Readonly<{
+    sendData?: SendData | undefined;
+}>) => {
+    codeInterpreter: import("ai").Tool<{
+        code: string;
+        timeoutSeconds: number | null;
+    }, string>;
+};

package/dist/source/tools/code-interpreter.js

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import { tool } from "ai";
+import { z } from "zod";
+export const CodeInterpreterTool = {
+    name: "codeInterpreter",
+};
+export const createCodeInterpreterTool = ({ sendData, }) => {
+    return {
+        [CodeInterpreterTool.name]: tool({
+            description: "Executes JavaScript code in a separate Node.js process using Node's Permission Model. By default, the child process has no permissions except read/write within the current working directory. The tool returns stdout, stderr, and exitCode. Use console.log/console.error to produce output. Timeout defaults to 5 seconds and can be extended up to 60 seconds.",
+            inputSchema: z.object({
+                code: z.string().describe("JavaScript code to be executed."),
+                timeoutSeconds: z
+                    .number()
+                    .int()
+                    .min(1)
+                    .max(60)
+                    .nullable()
+                    .describe("Execution timeout in seconds (1-60). Default 5."),
+            }),
+            execute: async ({ code, timeoutSeconds }, { toolCallId }) => {
+                const workingDirectory = process.cwd();
+                try {
+                    sendData?.({
+                        event: "tool-init",
+                        id: toolCallId,
+                        data: "Initializing code interpreter environment",
+                    });
+                    sendData?.({
+                        event: "tool-update",
+                        id: toolCallId,
+                        data: {
+                            primary: "Executing...",
+                            secondary: [
+                                `${"`".repeat(3)} javascript\n${code.slice(0, 500)}${"`".repeat(3)}`,
+                            ],
+                        },
+                    });
+                    if (code.trim().length === 0) {
+                        throw new Error("No code provided");
+                    }
+                    const timeoutMs = Math.min(Math.max((timeoutSeconds ?? 5) * 1000, 1000), 60000);
+                    const tmpBase = join(workingDirectory, ".acai-ci-tmp");
+                    await mkdir(tmpBase, { recursive: true });
+                    const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}.mjs`);
+                    await writeFile(scriptPath, code, { encoding: "utf8" });
+                    const args = [
+                        "--permission",
+                        `--allow-fs-read=${workingDirectory}`,
+                        `--allow-fs-write=${workingDirectory}`,
+                        scriptPath,
+                    ];
+                    const child = spawn(process.execPath, args, {
+                        cwd: workingDirectory,
+                        // do not rely solely on spawn's timeout; we implement manual timeout below
+                        stdio: "pipe",
+                        env: Object.assign({}, process.env, {
+                            // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                            NO_COLOR: "true",
+                            // biome-ignore lint/style/useNamingConvention: Environment variable keys are uppercase by convention
+                            NODE_OPTIONS: "",
+                        }),
+                    });
+                    let stdout = "";
+                    let stderr = "";
+                    let timedOut = false;
+                    const timer = setTimeout(() => {
+                        timedOut = true;
+                        try {
+                            child.kill("SIGKILL");
+                        }
+                        catch { }
+                    }, timeoutMs);
+                    child.stdout.setEncoding("utf8");
+                    child.stderr.setEncoding("utf8");
+                    child.stdout.on("data", (chunk) => {
+                        stdout += String(chunk);
+                    });
+                    child.stderr.on("data", (chunk) => {
+                        stderr += String(chunk);
+                    });
+                    const completed = await new Promise((resolve, reject) => {
+                        child.on("error", (err) => reject(err));
+                        child.on("close", (code, signal) => resolve({ code, signal }));
+                    });
+                    clearTimeout(timer);
+                    // Cleanup temp file/directory
+                    await rm(scriptPath, { force: true });
+                    await rm(tmpBase, { force: true, recursive: true });
+                    if (timedOut) {
+                        throw new Error("Script timed out");
+                    }
+                    if (completed.code === null) {
+                        throw new Error(`Process terminated by signal ${completed.signal ?? "unknown"}`);
+                    }
+                    if (completed.code !== 0) {
+                        const message = `Process exited with code ${completed.code}. Stderr: ${stderr.trim()}`;
+                        throw new Error(message);
+                    }
+                    const result = {
+                        stdout: stdout.trim(),
+                        stderr: stderr.trim(),
+                        exitCode: completed.code ?? -1,
+                    };
+                    sendData?.({
+                        event: "tool-completion",
+                        id: toolCallId,
+                        data: "Code execution completed successfully",
+                    });
+                    return JSON.stringify(result, null, 2);
+                }
+                catch (err) {
+                    const errorMessage = err.name === "ETIMEDOUT" ||
+                        err.message.includes("timed out")
+                        ? "Script timed out"
+                        : `Error: ${err.message}`;
+                    sendData?.({
+                        event: "tool-error",
+                        id: toolCallId,
+                        data: errorMessage,
+                    });
+                    return errorMessage;
+                }
+            },
+        }),
+    };
+};

package/dist/source/tools/command-validation.d.ts

@@ -0,0 +1,8 @@
+export declare class CommandValidation {
+    private readonly allowedCommands;
+    private readonly unsafeOperatorPatterns;
+    constructor(allowedCommands: string[]);
+    private isCommandAllowed;
+    private hasUnsafeOperators;
+    isValid(command: string): boolean;
+}

package/dist/source/tools/command-validation.js

@@ -0,0 +1,69 @@
+export class CommandValidation {
+    allowedCommands;
+    unsafeOperatorPatterns;
+    constructor(allowedCommands) {
+        this.allowedCommands = allowedCommands;
+        this.unsafeOperatorPatterns = [
+            /`/, // backticks
+            /\$\(/, // $(
+            />/, // redirect out
+            /</, // redirect in
+        ];
+    }
+    isCommandAllowed(command) {
+        const baseCommand = command.split(" ")[0] || "";
+        return this.allowedCommands.includes(baseCommand);
+    }
+    hasUnsafeOperators(command) {
+        // Remove all quoted segments first
+        const stripped = command
+            .replace(/'([^'\\]|\\.)*'/g, "")
+            .replace(/"([^"\\]|\\.)*"/g, "");
+        // Check for unsafe operators only in unquoted portions
+        return this.unsafeOperatorPatterns.some((re) => re.test(stripped));
+    }
+    isValid(command) {
+        if (!command.trim())
+            return false;
+        // First check for unsafe operators in unquoted portions
+        if (this.hasUnsafeOperators(command)) {
+            return false;
+        }
+        // Process command while preserving quoted strings
+        const subCommands = [];
+        let currentSegment = "";
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        for (let i = 0; i < command.length; i++) {
+            const char = command[i];
+            // Handle quote states
+            if (char === "'" && !inDoubleQuote)
+                inSingleQuote = !inSingleQuote;
+            if (char === '"' && !inSingleQuote)
+                inDoubleQuote = !inDoubleQuote;
+            // Split on operators only when not in quotes
+            if (!inSingleQuote &&
+                !inDoubleQuote &&
+                (char === "&" || char === "|" || char === ";")) {
+                if (currentSegment.trim()) {
+                    subCommands.push(currentSegment.trim());
+                    currentSegment = "";
+                }
+                // Skip the operator and any subsequent same operators (like && or ||)
+                while (i + 1 < command.length &&
+                    ["&", "|", ";"].includes(command[i + 1] ?? "")) {
+                    i++;
+                }
+            }
+            else {
+                currentSegment += char;
+            }
+        }
+        // Add the last segment
+        if (currentSegment.trim()) {
+            subCommands.push(currentSegment.trim());
+        }
+        // Validate all sub-commands
+        return subCommands.every((cmd) => this.isCommandAllowed(cmd));
+    }
+}

package/dist/source/tools/delete-file.d.ts

@@ -0,0 +1,12 @@
+import type { SendData } from "./types.ts";
+export declare const DeleteFileTool: {
+    name: "deleteFile";
+};
+export declare const createDeleteFileTool: ({ workingDir, sendData, }: {
+    workingDir: string;
+    sendData?: SendData;
+}) => Promise<{
+    deleteFile: import("ai").Tool<{
+        path: string;
+    }, string>;
+}>;

package/dist/source/tools/delete-file.js

@@ -0,0 +1,56 @@
+import { existsSync } from "node:fs";
+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 DeleteFileTool = {
+    name: "deleteFile",
+};
+export const createDeleteFileTool = async ({ workingDir, sendData, }) => {
+    const allowedDirectory = workingDir;
+    return {
+        [DeleteFileTool.name]: tool({
+            description: "Delete a file permanently.",
+            inputSchema: z.object({
+                path: z.string().describe("Absolute path to the file to delete"),
+            }),
+            execute: async ({ path: userPath }, { toolCallId }) => {
+                sendData?.({
+                    id: toolCallId,
+                    event: "tool-init",
+                    data: `Deleting file: ${chalk.cyan(userPath)}`,
+                });
+                try {
+                    const filePath = await validatePath(joinWorkingDir(userPath, workingDir), allowedDirectory);
+                    // Check if file exists before attempting delete
+                    if (!existsSync(filePath)) {
+                        throw new Error(`File not found: ${filePath}`);
+                    }
+                    // Ensure it's a file, not a directory
+                    const stats = await fs.stat(filePath);
+                    if (stats.isDirectory()) {
+                        throw new Error(`Path is a directory, not a file: ${filePath}`);
+                    }
+                    // Delete the original file
+                    await fs.unlink(filePath);
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-completion",
+                        data: `File deleted successfully: ${userPath}`,
+                    });
+                    return `Successfully deleted ${filePath}`;
+                }
+                catch (error) {
+                    const errorMessage = `Failed to delete file: ${error.message}`;
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-error",
+                        data: errorMessage,
+                    });
+                    return errorMessage;
+                }
+            },
+        }),
+    };
+};

package/dist/source/tools/directory-tree.d.ts

@@ -0,0 +1,12 @@
+import type { SendData } from "./types.ts";
+export declare const DirectoryTreeTool: {
+    name: "directoryTree";
+};
+export declare const createDirectoryTreeTool: ({ workingDir, sendData, }: {
+    workingDir: string;
+    sendData?: SendData;
+}) => Promise<{
+    directoryTree: import("ai").Tool<{
+        path: string;
+    }, string>;
+}>;

package/dist/source/tools/directory-tree.js

@@ -0,0 +1,38 @@
+import { tool } from "ai";
+import chalk from "chalk";
+import { z } from "zod";
+import { directoryTree, joinWorkingDir, validatePath, } from "./filesystem-utils.js";
+export const DirectoryTreeTool = {
+    name: "directoryTree",
+};
+export const createDirectoryTreeTool = async ({ workingDir, sendData, }) => {
+    const allowedDirectory = workingDir;
+    return {
+        [DirectoryTreeTool.name]: tool({
+            description: "Get a directory tree structure for a given path. This tool will ignore any directories or files listed in a .gitignore file. Use this tool when you need to see a complete directory tree for a project. This can be used to get an understanding of how a project is organized and what files are available before using other file system tools.",
+            inputSchema: z.object({
+                path: z.string().describe("The path."),
+            }),
+            execute: async ({ path }, { toolCallId }) => {
+                let validPath;
+                try {
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-init",
+                        data: `Listing directory tree: ${chalk.cyan(path)}`,
+                    });
+                    validPath = await validatePath(joinWorkingDir(path, workingDir), allowedDirectory);
+                    sendData?.({
+                        id: toolCallId,
+                        event: "tool-completion",
+                        data: "Done",
+                    });
+                }
+                catch (error) {
+                    return `Failed to show directory tree: ${error.message}`;
+                }
+                return directoryTree(validPath);
+            },
+        }),
+    };
+};

package/dist/source/tools/edit-file.d.ts

@@ -0,0 +1,19 @@
+import type { Terminal } from "../terminal/index.ts";
+import type { SendData } from "./types.ts";
+export declare const EditFileTool: {
+    name: "editFile";
+};
+export declare const createEditFileTool: ({ workingDir, terminal, sendData, autoAcceptAll, }: {
+    workingDir: string;
+    terminal?: Terminal;
+    sendData?: SendData;
+    autoAcceptAll: boolean;
+}) => Promise<{
+    editFile: import("ai").Tool<{
+        path: string;
+        edits: {
+            oldText: string;
+            newText: string;
+        }[];
+    }, string>;
+}>;