@travisennis/acai 0.0.1 → 0.0.3

package/source/tools/bash.ts

@@ -1,367 +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.ts";
-import type { Terminal } from "../terminal/index.ts";
-import type { TokenCounter } from "../token-utils.ts";
-import { executeCommand } from "../utils/process.ts";
-import { CommandValidation } from "./command-validation.ts";
-import type { SendData } from "./types.ts";
-
-export const BashTool = {
-  name: "bash" as const,
-};
-
-type Token = { raw: string; unquoted: string };
-
-function tokenize(inputStr: string): Token[] {
-  const tokens: Token[] = [];
-  let current = "";
-  let inSingle = false;
-  let inDouble = false;
-  for (let i = 0; i < inputStr.length; i++) {
-    const ch: string = inputStr[i] as string;
-    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: Token[], index: number): boolean {
-  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: string): boolean {
-  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: string, baseDir: string): boolean {
-  const normalizedRequestedPath = path.normalize(requestedPath);
-  const normalizedBaseDir = path.normalize(baseDir);
-
-  return normalizedRequestedPath.startsWith(normalizedBaseDir);
-}
-
-export const createBashTool = ({
-  baseDir,
-  sendData,
-  tokenCounter,
-  terminal,
-  autoAcceptAll,
-}: {
-  baseDir: string;
-  sendData?: SendData | undefined;
-  tokenCounter: TokenCounter;
-  terminal?: Terminal;
-  autoAcceptAll: boolean;
-}) => {
-  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 as unknown as string,
-              );
-            }
-          }
-        }
-
-        // 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: string;
-          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 as Error).message}`,
-          });
-          return `Command failed: ${(error as Error).message}`;
-        }
-      },
-    }),
-  };
-};
-
-function format({
-  stdout,
-  stderr,
-}: {
-  stdout: string;
-  stderr: string;
-  code: number;
-}) {
-  return `${stdout}\n${stderr}`;
-}

package/source/tools/code-interpreter.ts

@@ -1,172 +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";
-import type { SendData } from "./types.ts";
-
-export const CodeInterpreterTool = {
-  name: "codeInterpreter" as const,
-};
-
-export const createCodeInterpreterTool = ({
-  sendData,
-}: Readonly<{
-  sendData?: SendData | undefined;
-}>) => {
-  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: "",
-            } as Record<string, string>),
-          });
-
-          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<{
-            code: number | null;
-            signal: NodeJS.Signals | null;
-          }>((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 as Error).name === "ETIMEDOUT" ||
-            (err as Error).message.includes("timed out")
-              ? "Script timed out"
-              : `Error: ${(err as Error).message}`;
-
-          sendData?.({
-            event: "tool-error",
-            id: toolCallId,
-            data: errorMessage,
-          });
-
-          return errorMessage;
-        }
-      },
-    }),
-  };
-};

package/source/tools/command-validation.ts

@@ -1,81 +0,0 @@
-export class CommandValidation {
-  private readonly allowedCommands: string[];
-  private readonly unsafeOperatorPatterns: RegExp[];
-
-  constructor(allowedCommands: string[]) {
-    this.allowedCommands = allowedCommands;
-    this.unsafeOperatorPatterns = [
-      /`/, // backticks
-      /\$\(/, // $(
-      />/, // redirect out
-      /</, // redirect in
-    ];
-  }
-
-  private isCommandAllowed(command: string): boolean {
-    const baseCommand = command.split(" ")[0] || "";
-    return this.allowedCommands.includes(baseCommand);
-  }
-
-  private hasUnsafeOperators(command: string): boolean {
-    // 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: string): boolean {
-    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: string[] = [];
-    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/source/tools/delete-file.ts

@@ -1,71 +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.ts";
-import type { SendData } from "./types.ts";
-
-export const DeleteFileTool = {
-  name: "deleteFile" as const,
-};
-
-export const createDeleteFileTool = async ({
-  workingDir,
-  sendData,
-}: {
-  workingDir: string;
-  sendData?: 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 as Error).message}`;
-          sendData?.({
-            id: toolCallId,
-            event: "tool-error",
-            data: errorMessage,
-          });
-          return errorMessage;
-        }
-      },
-    }),
-  };
-};