@travisennis/acai 0.0.1 → 0.0.2

package/dist/source/tools/bash.js

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

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

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

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

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

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

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

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

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

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