@travisennis/acai 0.0.4 → 0.0.5

package/dist/tools/bash-utils.js

@@ -0,0 +1,212 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isPathWithinBaseDir } from "./filesystem-utils.js";
+// Validate path arguments to ensure they're within the project
+export function validatePaths(command, baseDir, cwd) {
+    // Simple tokenization - split on spaces but respect quotes
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let quoteChar = "";
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i] ?? "";
+        if ((char === '"' || char === "'") && !inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+            current += char;
+        }
+        else if (char === quoteChar && inQuotes) {
+            inQuotes = false;
+            quoteChar = "";
+            current += char;
+        }
+        else if (char === " " && !inQuotes) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current)
+        tokens.push(current);
+    // Check each token that looks like a path
+    for (let i = 1; i < tokens.length; i++) {
+        // Skip the command itself
+        const token = tokens[i];
+        if (!token)
+            continue;
+        // Remove quotes for path checking
+        const cleanToken = token.replace(/^['"]|['"]$/g, "");
+        // Skip if it's clearly not a path
+        if (cleanToken.startsWith("-") ||
+            cleanToken.includes("://") ||
+            !cleanToken.includes("/")) {
+            continue;
+        }
+        // Skip git commit messages and other special cases
+        const prevToken = tokens[i - 1]?.replace(/^['"]|['"]$/g, "");
+        if (prevToken === "-m" || prevToken === "--message") {
+            continue;
+        }
+        try {
+            const resolvedPath = path.resolve(cwd, cleanToken);
+            if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
+                return {
+                    isValid: false,
+                    error: `Path '${cleanToken}' resolves outside the project directory (${resolvedPath}). All paths must be within ${baseDir}`,
+                };
+            }
+        }
+        catch (_e) { }
+    }
+    return { isValid: true };
+}
+export const resolveCwd = (cwdInput, workingDir) => {
+    const projectRootAbs = path.resolve(workingDir);
+    let projectRoot = projectRootAbs;
+    try {
+        projectRoot = fs.realpathSync(projectRootAbs);
+    }
+    catch {
+        // Fallback to resolved path
+    }
+    const raw = typeof cwdInput === "string" && cwdInput.trim() !== ""
+        ? cwdInput.trim()
+        : projectRoot;
+    const abs = path.isAbsolute(raw) ? raw : path.resolve(projectRoot, raw);
+    let target = abs;
+    try {
+        target = fs.realpathSync(abs);
+    }
+    catch {
+        // If the path doesn't exist entirely, validate intended path
+    }
+    const rel = path.relative(projectRoot, target);
+    const inside = rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+    if (!inside) {
+        throw new Error(`Working directory must be within the project directory: ${projectRoot}. Received: ${cwdInput ?? "<default>"} -> ${target}`);
+    }
+    // Check existence and that it's a directory
+    let stats;
+    try {
+        stats = fs.statSync(target);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+            throw new Error(`Working directory does not exist: ${target} (from ${cwdInput ?? "<default>"})`);
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Working directory is not a directory: ${target}`);
+    }
+    return target;
+};
+export const isMutatingCommand = (rawCommand) => {
+    const command = rawCommand.trim();
+    // Redirections that write to disk
+    if (/>|>>/.test(command)) {
+        return true;
+    }
+    // Normalize whitespace and split into simple segments (does not fully parse shell)
+    const segments = command
+        .split(/\s*(?:&&|\|\||;|\|)\s*/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    const mutatingBinaries = new Set([
+        "rm",
+        "mv",
+        "cp",
+        "mkdir",
+        "rmdir",
+        "touch",
+        "chmod",
+        "chown",
+        "ln",
+        "truncate",
+        "dd",
+        "tee",
+    ]);
+    const npmMutating = new Set([
+        "install",
+        "uninstall",
+        "update",
+        "ci",
+        "publish",
+        "link",
+        "dedupe",
+        "prune",
+        "rebuild",
+        "add",
+    ]);
+    const gitMutating = new Set([
+        "add",
+        "am",
+        "apply",
+        "branch",
+        "checkout",
+        "switch",
+        "cherry-pick",
+        "clean",
+        "commit",
+        "merge",
+        "mv",
+        "pull",
+        "push",
+        "rebase",
+        "reset",
+        "revert",
+        "stash",
+        "tag",
+        "worktree",
+        "submodule",
+        "config",
+    ]);
+    // Generic action words that should be considered mutating when present in the command
+    const actionMutating = new Set(["create", "update", "upgrade", "install"]);
+    for (const seg of segments) {
+        const tokens = seg.split(/\s+/);
+        if (tokens.length === 0)
+            continue;
+        const bin = tokens[0];
+        if (!bin)
+            continue;
+        // If any token is an action-like mutating word, consider mutating
+        if (tokens.some((t) => actionMutating.has(t))) {
+            return true;
+        }
+        // sed -i is mutating
+        if (bin === "sed") {
+            if (tokens.some((t) => /^-i/.test(t))) {
+                return true;
+            }
+            // sed without -i is not mutating
+        }
+        if (mutatingBinaries.has(bin)) {
+            return true;
+        }
+        if (bin === "git" && tokens.length > 1) {
+            const sub = tokens[1];
+            if (typeof sub === "string" && gitMutating.has(sub)) {
+                return true;
+            }
+        }
+        if (bin === "npm" && tokens.length > 1) {
+            const sub = tokens[1];
+            if (typeof sub === "string" && npmMutating.has(sub)) {
+                return true;
+            }
+        }
+        if ((bin === "pnpm" || bin === "yarn") && tokens.length > 1) {
+            const sub = tokens[1];
+            if (typeof sub === "string" && npmMutating.has(sub)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};

package/dist/tools/bash.d.ts

@@ -1,19 +1,21 @@
 import type { Terminal } from "../terminal/index.ts";
-import type { TokenCounter } from "../token-utils.ts";
+import type { TokenCounter } from "../tokens/counter.ts";
+import type { ToolExecutor } from "../tool-executor.ts";
 import type { SendData } from "./types.ts";
 export declare const BashTool: {
     name: "bash";
 };
-export declare const createBashTool: ({ baseDir, sendData, tokenCounter, terminal, autoAcceptAll, }: {
+export declare const createBashTool: ({ baseDir, sendData, tokenCounter, terminal, toolExecutor, }: {
     baseDir: string;
-    sendData?: SendData | undefined;
+    sendData?: SendData;
     tokenCounter: TokenCounter;
     terminal?: Terminal;
-    autoAcceptAll: boolean;
-}) => {
+    toolExecutor?: ToolExecutor;
+}) => Promise<{
     bash: import("ai").Tool<{
+        command: string;
         cwd: string | null;
         timeout: number | null;
-        command: string;
     }, string>;
-};
+}>;
+//# sourceMappingURL=bash.d.ts.map

package/dist/tools/bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash.d.ts","sourceRoot":"","sources":["../../source/tools/bash.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAe,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,QAAQ;;CAEpB,CAAC;AAKF,eAAO,MAAM,cAAc,GAAU,8DAMlC;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;;;;;;EAkLA,CAAC"}

package/dist/tools/bash.js

@@ -1,272 +1,155 @@
-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";
+import { initExecutionEnvironment } from "../execution/index.js";
+import { logger } from "../logger.js";
+import style from "../terminal/style.js";
+import { isMutatingCommand, resolveCwd, validatePaths } from "./bash-utils.js";
+import { isPathWithinBaseDir } from "./filesystem-utils.js";
 export const BashTool = {
     name: "bash",
 };
-// 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
-// Ensure path is within base directory
-function isPathWithinBaseDir(requestedPath, baseDir) {
-    const normalizedRequestedPath = path.normalize(requestedPath);
-    const normalizedBaseDir = path.normalize(baseDir);
-    return normalizedRequestedPath.startsWith(normalizedBaseDir);
-}
-// Validate path arguments to ensure they're within the project
-function validatePaths(command, baseDir, cwd) {
-    // Simple tokenization - split on spaces but respect quotes
-    const tokens = [];
-    let current = "";
-    let inQuotes = false;
-    let quoteChar = "";
-    for (let i = 0; i < command.length; i++) {
-        const char = command[i];
-        if ((char === '"' || char === "'") && !inQuotes) {
-            inQuotes = true;
-            quoteChar = char;
-            current += char;
-        }
-        else if (char === quoteChar && inQuotes) {
-            inQuotes = false;
-            quoteChar = "";
-            current += char;
-        }
-        else if (char === " " && !inQuotes) {
-            if (current) {
-                tokens.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current)
-        tokens.push(current);
-    // Check each token that looks like a path
-    for (let i = 1; i < tokens.length; i++) {
-        // Skip the command itself
-        const token = tokens[i];
-        if (!token)
-            continue;
-        // Remove quotes for path checking
-        const cleanToken = token.replace(/^['"]|['"]$/g, "");
-        // Skip if it's clearly not a path
-        if (cleanToken.startsWith("-") ||
-            cleanToken.includes("://") ||
-            !cleanToken.includes("/")) {
-            continue;
-        }
-        // Skip git commit messages and other special cases
-        const prevToken = tokens[i - 1]?.replace(/^['"]|['"]$/g, "");
-        if (prevToken === "-m" || prevToken === "--message") {
-            continue;
-        }
-        try {
-            const resolvedPath = path.resolve(cwd, cleanToken);
-            if (!isPathWithinBaseDir(resolvedPath, baseDir)) {
-                return {
-                    isValid: false,
-                    error: `Path '${cleanToken}' resolves outside the project directory (${resolvedPath}). All paths must be within ${baseDir}`,
-                };
-            }
-        }
-        catch (_e) { }
-    }
-    return { isValid: true };
-}
-// Initialize command validator with allowed commands
-const commandValidator = new CommandValidation(ALLOWED_COMMANDS);
-export const createBashTool = ({ baseDir, sendData, tokenCounter, terminal, autoAcceptAll, }) => {
-    let autoAcceptCommands = autoAcceptAll;
+export const createBashTool = async ({ baseDir, sendData, tokenCounter, terminal, toolExecutor, }) => {
+    const execEnv = await initExecutionEnvironment();
     return {
         [BashTool.name]: tool({
-            description: `Execute commands without a shell. Restrictions: no pipes (|), redirects (>, >>, <, <<), chaining (&&, ||, ;), background (&), or command substitution (\`...\`, $()). Pass a single allowed base command with quoted args. Compose by running multiple tool calls or using program flags (e.g., rg, jq). Commands execute only within the project directory. Always use absolute paths. Allowed commands: ${ALLOWED_COMMANDS.join(", ")}.`,
+            description: "Execute commands in a shell. Commands execute only within the project directory. Always use absolute paths.",
             inputSchema: z.object({
                 command: z.string().describe("Full CLI command to execute."),
                 cwd: z
                     .string()
                     .nullable()
-                    .describe("Working directory (default: project root). Must be within the project directory."),
-                timeout: z
+                    .describe("Working directory file path (default: project root). Must be within the project directory."),
+                timeout: z.coerce
                     .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 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 using improved validation
-                const commandValidation = commandValidator.isValid(command);
-                if (!commandValidation.isValid) {
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: commandValidation.error ?? "Unknown error.",
-                    });
-                    return commandValidation.error ?? "Unknown error.";
-                }
-                // Validate paths
-                const pathValidation = validatePaths(command, baseDir, safeCwd);
-                if (!pathValidation.isValid) {
+            execute: async ({ command, cwd, timeout }, { toolCallId, abortSignal }) => {
+                try {
+                    if (abortSignal?.aborted) {
+                        throw new Error("Command execution aborted");
+                    }
+                    // grok doesn't follow my instructions
+                    const safeCwd = cwd === "null" ? null : cwd;
+                    const resolvedCwd = resolveCwd(safeCwd, baseDir);
+                    const safeTimeout = timeout ?? DEFAULT_TIMEOUT;
                     sendData?.({
-                        event: "tool-error",
+                        event: "tool-init",
                         id: toolCallId,
-                        data: pathValidation.error ?? "Unknown error.",
+                        data: `Executing: ${style.cyan(command)} in ${style.cyan(resolvedCwd)}`,
                     });
-                    return pathValidation.error ?? "Unknown error.";
-                }
-                // 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";
+                    if (!isPathWithinBaseDir(resolvedCwd, baseDir)) {
+                        const errorMsg = `Working directory must be within the project directory: ${baseDir}`;
+                        sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
+                        return errorMsg;
                     }
-                    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",
+                    const pathValidation = validatePaths(command, baseDir, resolvedCwd);
+                    if (!pathValidation.isValid) {
+                        sendData?.({
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: pathValidation.error ?? "Unknown error.",
                         });
+                        return pathValidation.error ?? "Unknown error.";
                     }
-                    terminal.lineBreak();
-                    if (userChoice === "accept-all") {
-                        autoAcceptCommands = true;
-                        terminal.writeln(chalk.yellow("✓ Auto-accept mode enabled for all future commands"));
+                    if (terminal) {
+                        let userResponse;
+                        // Prompt only for potentially mutating commands when a toolExecutor is present
+                        if (toolExecutor && isMutatingCommand(command)) {
+                            // Display if autoAccept is false
+                            if (!toolExecutor.autoAccept(BashTool.name)) {
+                                terminal.writeln(`\n${style.blue.bold("●")} Proposing to execute command: ${style.cyan(command)} in ${style.cyan(resolvedCwd)}`);
+                                terminal.lineBreak();
+                            }
+                            const ctx = {
+                                toolName: BashTool.name,
+                                toolCallId,
+                                message: "What would you like to do with this command execution?",
+                                choices: {
+                                    accept: "Execute this command",
+                                    acceptAll: "Accept all future command executions (including this)",
+                                    reject: "Reject this command execution",
+                                },
+                            };
+                            try {
+                                userResponse = await toolExecutor.ask(ctx, { abortSignal });
+                            }
+                            catch (e) {
+                                if (e.name === "AbortError") {
+                                    throw new Error("Command execution aborted during user input");
+                                }
+                                throw e;
+                            }
+                        }
+                        const { result: userChoice, reason } = userResponse ?? {
+                            result: "accept",
+                        };
                         terminal.lineBreak();
+                        if (userChoice === "accept-all") {
+                            terminal.writeln(style.yellow("✓ Auto-accept mode enabled for all command executions"));
+                            terminal.lineBreak();
+                        }
+                        if (userChoice === "reject") {
+                            terminal.lineBreak();
+                            const rejectionReason = reason || "No reason provided";
+                            sendData?.({
+                                event: "tool-completion",
+                                id: toolCallId,
+                                data: `Command execution rejected by user. Reason: ${rejectionReason}`,
+                            });
+                            return `The user rejected this command execution. Reason: ${rejectionReason}`;
+                        }
                     }
-                    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;
+                    if (abortSignal?.aborted) {
+                        throw new Error("Command execution aborted before running the command");
                     }
-                }
-                // Execute command
-                try {
-                    const result = await executeCommand(command, {
-                        cwd: safeCwd,
+                    terminal?.startProgress();
+                    const { output, exitCode } = await execEnv.executeCommand(command, {
+                        cwd: resolvedCwd,
                         timeout: safeTimeout,
-                        shell: false,
+                        abortSignal,
+                        preserveOutputOnError: true,
+                        captureStderr: 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),
+                            secondary: output.trim().split("\n").slice(-20),
                         },
                     });
                     let tokenCount = 0;
                     try {
-                        tokenCount = tokenCounter.count(formattedResult);
+                        tokenCount = tokenCounter.count(output);
                     }
                     catch (tokenError) {
-                        console.error("Error calculating token count:", tokenError);
+                        console.info("Error calculating token count:", tokenError);
                     }
                     const maxTokens = (await config.readProjectConfig()).tools.maxTokens;
-                    const maxTokenMessage = `Output of command (${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;
+                    const maxTokenMessage = `Output of command (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}). Please adjust how you call the command to get back more specific results.`;
+                    const finalResult = tokenCount <= maxTokens ? output : maxTokenMessage;
                     sendData?.({
                         event: "tool-completion",
                         id: toolCallId,
                         data: tokenCount <= maxTokens
-                            ? "Command executed successfully."
+                            ? `Command executed successfully: ${exitCode} (${tokenCount} tokens)`
                             : `Output of command (${tokenCount} tokens) exceeds maximum allowed tokens (${maxTokens}).`,
                     });
+                    terminal?.stopProgress();
                     return finalResult;
                 }
                 catch (error) {
+                    logger.error(error, "Bash Tool Error:");
                     const errorMsg = `Command failed: ${error.message}`;
-                    sendData?.({
-                        event: "tool-error",
-                        id: toolCallId,
-                        data: errorMsg,
-                    });
+                    sendData?.({ event: "tool-error", id: toolCallId, data: errorMsg });
                     return errorMsg;
                 }
             },
         }),
     };
 };
-function format({ stdout, stderr, }) {
-    return `${stdout}\n${stderr}`;
-}

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

@@ -7,7 +7,7 @@ export declare const createCodeInterpreterTool: ({ sendData, }: Readonly<{
 }>) => {
     codeInterpreter: import("ai").Tool<{
         code: string;
-        type: "Typescript" | "JavaScript" | null;
         timeoutSeconds: number | null;
     }, string>;
 };
+//# sourceMappingURL=code-interpreter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"code-interpreter.d.ts","sourceRoot":"","sources":["../../source/tools/code-interpreter.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,mBAAmB;;CAE/B,CAAC;AAmBF,eAAO,MAAM,yBAAyB,GAAI,eAEvC,QAAQ,CAAC;IACV,QAAQ,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC,CAAC;;;;;CAiLD,CAAC"}