@travisennis/acai 0.0.3 → 0.0.4

package/dist/mentions.js

@@ -78,7 +78,7 @@ async function processFileCommand(context) {
 async function processShellCommand(command) {
     try {
         const { stdout, stderr, code } = await executeCommand(command, {
-            shell: true,
+            shell: false,
         });
         if (code === 0) {
             return stdout;

package/dist/prompts.js

@@ -85,10 +85,12 @@ function toolUsage() {
 - Outline multi-step tasks before execution
 
 ### Bash Commands (\`${BashTool.name}\`)
-- Execute bash commands within project directory only
-- Always specify absolute paths to avoid errors
-- You have access to the Github CLI
-- Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
+- Shell is disabled. Do NOT use: |, >, >>, <, <<, ;, &&, ||, &, \`...\`, $().
+- Run a single allowed command with quoted args; no command substitution or chaining.
+- Compose multi-step flows via multiple tool calls or program flags (rg, jq, grep options, etc.).
+- For large gh/git messages, prefer --message-file instead of inlining big strings.
+- Commands execute only within the project directory; always use absolute paths.
+- Avoid interactive commands; prefer non-interactive flags (e.g., npm init -y).
 
 ### Code Interpreter (\`${CodeInterpreterTool.name}\`)
 - Executes JavaScript code in a separate Node.js process using Node's Permission Model

package/dist/tools/bash.js

@@ -116,7 +116,7 @@ export const createBashTool = ({ baseDir, sendData, tokenCounter, terminal, auto
     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.`,
+            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(", ")}.`,
             inputSchema: z.object({
                 command: z.string().describe("Full CLI command to execute."),
                 cwd: z
@@ -214,7 +214,7 @@ export const createBashTool = ({ baseDir, sendData, tokenCounter, terminal, auto
                     const result = await executeCommand(command, {
                         cwd: safeCwd,
                         timeout: safeTimeout,
-                        shell: true,
+                        shell: false,
                         throwOnError: false,
                     });
                     if (result.signal === "SIGTERM") {

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

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

package/dist/tools/code-interpreter.js

@@ -8,7 +8,12 @@ import { z } from "zod";
 export const CodeInterpreterTool = {
     name: "codeInterpreter",
 };
-const toolDescription = `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.
+const toolDescription = `Executes JavaScript or Typescript code in a separate Node.js process using Node's Permission Model. 
+
+⚠️ **IMPORTANT TYPE SELECTION**:
+- Use "JavaScript" for plain JavaScript code (no TypeScript syntax)
+- Use "Typescript" for code containing interfaces, type annotations, generics, etc.
+- Code type is automatically validated before execution
 
 ⚠️ **IMPORTANT**: This tool uses ES Modules (ESM) only.
 - Use \`import\` statements, NOT \`require()\`
@@ -18,12 +23,85 @@ const toolDescription = `Executes JavaScript code in a separate Node.js process
 These scripts are run in the \`${process.cwd}/.acai-ci-tmp\`. Keep this in mind if you intend to import or reference files from this project in your script.
 
 Timeout defaults to 5 seconds and can be extended up to 60 seconds.`;
+/**
+ * Detects if code contains TypeScript syntax patterns
+ */
+function containsTypeScriptSyntax(code) {
+    // Common TypeScript patterns that don't exist in JavaScript
+    const tsPatterns = [
+        // Type annotations
+        /:\s*[a-zA-Z]\w*(?:\s*\[])?\s*(?=[,;=)])/g, // Type annotations after variables/parameters (including any, string[], etc.)
+        /:\s*\{[^}]*\}\s*(?=[,;=)])/g, // Object type annotations
+        /:\s*\([^)]*\)\s*=>/g, // Function type annotations
+        // Type declarations
+        /^\s*interface\s+\w+/gm, // Interface declarations
+        /^\s*type\s+\w+\s*=/gm, // Type aliases
+        /^\s*enum\s+\w+/gm, // Enum declarations
+        // Generic types
+        /<\s*[A-Z]\w*(?:\s*,\s*[A-Z]\w*)*\s*>/g, // Generic type parameters
+        /\w+\s*<\s*[^<>]+?\s*>/g, // Generic type usage
+        // TypeScript-specific keywords (in specific contexts)
+        /\b(?:implements|extends\s+[A-Z]\w*|readonly|private|protected|public)\b/g,
+        // Utility types
+        /\b(?:Partial|Required|Pick|Omit|Record|Exclude|Extract)\b/g,
+    ];
+    return tsPatterns.some((pattern) => pattern.test(code));
+}
+/**
+ * Validates that code content matches the specified type
+ */
+function validateCodeTypeMatch(code, specifiedType) {
+    if (!code?.trim()) {
+        return "No code provided";
+    }
+    const detectedType = containsTypeScriptSyntax(code)
+        ? "Typescript"
+        : "JavaScript";
+    const expectedType = specifiedType ?? "JavaScript";
+    // If TypeScript syntax detected but JavaScript specified
+    if (detectedType === "Typescript" && expectedType === "JavaScript") {
+        return `Code contains TypeScript syntax but is specified as JavaScript. Please either:
+1. Change type to "Typescript", or
+2. Remove TypeScript syntax (interfaces, type annotations, generics, etc.)
+
+Detected TypeScript patterns: ${getTypeScriptPatternsFound(code).join(", ")}`;
+    }
+    // If no TypeScript syntax but TypeScript specified (warning, not error)
+    if (detectedType === "JavaScript" && expectedType === "Typescript") {
+        // This is not an error, just potentially unnecessary
+        return null;
+    }
+    return null;
+}
+/**
+ * Identifies specific TypeScript patterns found in code
+ */
+function getTypeScriptPatternsFound(code) {
+    const patterns = [];
+    if (/\binterface\s+\w+/.test(code))
+        patterns.push("interface");
+    if (/\btype\s+\w+\s*=/.test(code))
+        patterns.push("type alias");
+    if (/:\s*[a-zA-Z]\w*(?:\s*\[])?\s*(?=[,;=)])/g.test(code))
+        patterns.push("type annotations");
+    if (/<\s*[A-Z]\w*\s*>/.test(code))
+        patterns.push("generics");
+    if (/\benum\s+\w+/.test(code))
+        patterns.push("enum");
+    return patterns;
+}
 export const createCodeInterpreterTool = ({ sendData, }) => {
     return {
         [CodeInterpreterTool.name]: tool({
             description: toolDescription,
             inputSchema: z.object({
-                code: z.string().describe("JavaScript code to be executed."),
+                code: z
+                    .string()
+                    .describe("The JavaScript or Typescript code to be executed."),
+                type: z
+                    .enum(["JavaScript", "Typescript"])
+                    .nullable()
+                    .describe("The type of code. Either Javascript or Typescript."),
                 timeoutSeconds: z
                     .number()
                     .int()
@@ -32,21 +110,32 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                     .nullable()
                     .describe("Execution timeout in seconds (1-60). Default 5."),
             }),
-            execute: async ({ code, timeoutSeconds }, { toolCallId }) => {
+            execute: async ({ code, type, timeoutSeconds }, { toolCallId }) => {
                 const workingDirectory = process.cwd();
                 try {
+                    // Pre-execution validation
+                    const validationError = validateCodeTypeMatch(code, type);
+                    if (validationError) {
+                        sendData?.({
+                            event: "tool-error",
+                            id: toolCallId,
+                            data: validationError,
+                        });
+                        return validationError;
+                    }
                     sendData?.({
                         event: "tool-init",
                         id: toolCallId,
                         data: "Initializing code interpreter environment",
                     });
+                    const scriptType = (type ?? "JavaScript").toLowerCase();
                     sendData?.({
                         event: "tool-update",
                         id: toolCallId,
                         data: {
                             primary: "Executing...",
                             secondary: [
-                                `${"`".repeat(3)} javascript\n${code.slice(0, 500)}${"`".repeat(3)}`,
+                                `${"`".repeat(3)} ${scriptType}}\n${code.slice(0, 500)}${"`".repeat(3)}`,
                             ],
                         },
                     });
@@ -56,7 +145,8 @@ export const createCodeInterpreterTool = ({ sendData, }) => {
                     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`);
+                    const ext = type === "JavaScript" ? ".mjs" : ".ts";
+                    const scriptPath = join(tmpBase, `temp_script_${Date.now()}_${randomUUID()}${ext}`);
                     await writeFile(scriptPath, code, { encoding: "utf8" });
                     const args = [
                         "--permission",

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

@@ -8,5 +8,4 @@ export declare class CommandValidation {
         isValid: boolean;
         error?: string;
     };
-    private splitOnPipes;
 }

package/dist/tools/command-validation.js

@@ -3,12 +3,14 @@ export class CommandValidation {
     dangerousPatterns;
     constructor(allowedCommands) {
         this.allowedCommands = allowedCommands;
-        // Only block truly dangerous patterns, not useful shell operations
+        // Block shell operators and substitutions outright
         this.dangerousPatterns = [
             /`/, // backticks (command substitution)
             /\$\(/, // $() command substitution
-            /&&\s*rm\s+-rf/, // dangerous rm chains
-            /;\s*rm\s+-rf/, // dangerous rm chains
+            /\|/, // pipes
+            />|>>|<|<</, // redirects
+            /;|&&|\|\||&/, // chaining and backgrounding
+            /[\r\n]/, // newlines
         ];
     }
     isCommandAllowed(command) {
@@ -16,98 +18,28 @@ export class CommandValidation {
         return this.allowedCommands.includes(baseCommand);
     }
     hasDangerousPatterns(command) {
-        // Remove all quoted segments first
-        const stripped = command
-            .replace(/'([^'\\]|\\.)*'/g, "")
-            .replace(/"([^"\\]|\\.)*"/g, "");
-        // Check for dangerous patterns only in unquoted portions
-        return this.dangerousPatterns.some((re) => re.test(stripped));
+        // Do not strip quotes; reject if any dangerous pattern appears anywhere
+        return this.dangerousPatterns.some((re) => re.test(command));
     }
     isValid(command) {
         if (!command.trim()) {
             return { isValid: false, error: "Command cannot be empty" };
         }
-        // First check for dangerous patterns
         if (this.hasDangerousPatterns(command)) {
             return {
                 isValid: false,
-                error: "Command contains dangerous patterns (command substitution or unsafe rm chains)",
+                error: "Pipes, redirects, command substitution, chaining, and newlines are disabled for security.",
             };
         }
-        // Process command while preserving quoted strings to extract sub-commands
-        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 command separators only when not in quotes
-            // Note: We allow pipes (|) and redirects (>, <) but split on command separators
-            if (!inSingleQuote && !inDoubleQuote && (char === "&" || char === ";")) {
-                if (currentSegment.trim()) {
-                    subCommands.push(currentSegment.trim());
-                    currentSegment = "";
-                }
-                // Skip the operator and any subsequent same operators (like &&)
-                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 (but be smart about pipes)
-        for (const subCmd of subCommands) {
-            // For piped commands, validate each part of the pipe
-            const pipeParts = this.splitOnPipes(subCmd);
-            for (const part of pipeParts) {
-                const trimmedPart = part.trim();
-                if (trimmedPart && !this.isCommandAllowed(trimmedPart)) {
-                    const baseCmd = trimmedPart.split(" ")[0] || "";
-                    return {
-                        isValid: false,
-                        error: `Command '${baseCmd}' is not allowed. Allowed commands: ${this.allowedCommands.join(", ")}`,
-                    };
-                }
-            }
+        // No pipes to split now; validate the single command only
+        const trimmed = command.trim();
+        if (!this.isCommandAllowed(trimmed)) {
+            const baseCmd = trimmed.split(" ")[0] || "";
+            return {
+                isValid: false,
+                error: `Command '${baseCmd}' is not allowed. Allowed commands: ${this.allowedCommands.join(", ")}`,
+            };
         }
         return { isValid: true };
     }
-    splitOnPipes(command) {
-        const parts = [];
-        let current = "";
-        let inSingleQuote = false;
-        let inDoubleQuote = false;
-        for (let i = 0; i < command.length; i++) {
-            const char = command[i];
-            if (char === "'" && !inDoubleQuote)
-                inSingleQuote = !inSingleQuote;
-            if (char === '"' && !inSingleQuote)
-                inDoubleQuote = !inDoubleQuote;
-            if (char === "|" && !inSingleQuote && !inDoubleQuote) {
-                if (current.trim()) {
-                    parts.push(current.trim());
-                    current = "";
-                }
-            }
-            else {
-                current += char;
-            }
-        }
-        if (current.trim()) {
-            parts.push(current.trim());
-        }
-        return parts;
-    }
 }

package/dist/tools/index.d.ts

@@ -35,6 +35,7 @@ export declare function initTools({ terminal, tokenCounter, events, autoAcceptAl
     }, string>;
     readonly codeInterpreter: import("ai").Tool<{
         code: string;
+        type: "Typescript" | "JavaScript" | null;
         timeoutSeconds: number | null;
     }, string>;
     readonly deleteFile: import("ai").Tool<{
@@ -98,6 +99,7 @@ export declare function initCliTools({ tokenCounter, }: {
     }, string>;
     readonly codeInterpreter: import("ai").Tool<{
         code: string;
+        type: "Typescript" | "JavaScript" | null;
         timeoutSeconds: number | null;
     }, string>;
     readonly deleteFile: import("ai").Tool<{

package/dist/utils/process.d.ts

@@ -24,6 +24,14 @@ export interface ExecuteResult {
     /** The signal that terminated the process, if any */
     signal?: NodeJS.Signals;
 }
+export type ParseResult = {
+    ok: true;
+    argv: [string, ...string[]];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseArgv(input: string): ParseResult;
 /**
  * Executes a command and returns the result, providing unified error handling
  *

package/dist/utils/process.js

@@ -3,6 +3,81 @@ import { isUndefined } from "@travisennis/stdlib/typeguards";
 const MS_IN_SECOND = 1000;
 const SECONDS_IN_MINUTE = 60;
 const DEFAULT_TIMEOUT = 2 * SECONDS_IN_MINUTE * MS_IN_SECOND;
+// Quote/escape-aware argv tokenizer that forbids command substitution
+export function parseArgv(input) {
+    const argv = [];
+    let buf = "";
+    let i = 0;
+    const n = input.length;
+    let inSingle = false;
+    let inDouble = false;
+    while (i < n) {
+        const ch = input[i] ?? "";
+        // Reject shell-only constructs early
+        if (ch === "`")
+            return { ok: false, error: "Backticks are not allowed" };
+        if (ch === "$" && i + 1 < n && input[i + 1] === "(") {
+            return { ok: false, error: "Command substitution $() is not allowed" };
+        }
+        if (!inSingle && !inDouble && /\s/.test(ch)) {
+            if (buf.length > 0) {
+                argv.push(buf);
+                buf = "";
+            }
+            i += 1;
+            continue;
+        }
+        if (!inDouble && ch === "'" && !inSingle) {
+            inSingle = true;
+            i += 1;
+            continue;
+        }
+        if (inSingle && ch === "'") {
+            inSingle = false;
+            i += 1;
+            continue;
+        }
+        if (!inSingle && ch === '"' && !inDouble) {
+            inDouble = true;
+            i += 1;
+            continue;
+        }
+        if (inDouble && ch === '"') {
+            inDouble = false;
+            i += 1;
+            continue;
+        }
+        if (!inSingle && ch === "\\") {
+            i += 1;
+            if (i >= n)
+                return { ok: false, error: "Dangling escape" };
+            const next = input[i] ?? "";
+            // Inside double quotes, only escape " and \\ reliably
+            if (inDouble && next !== '"' && next !== "\\") {
+                // Keep backslash literally for safety
+                buf += `\\${next}`;
+            }
+            else {
+                buf += next;
+            }
+            i += 1;
+            continue;
+        }
+        buf += ch;
+        i += 1;
+    }
+    if (inSingle || inDouble)
+        return { ok: false, error: "Unterminated quote" };
+    if (buf.length > 0)
+        argv.push(buf);
+    if (argv.length === 0)
+        return { ok: false, error: "Empty command" };
+    const first = argv[0];
+    if (typeof first !== "string" || first.trim() === "") {
+        return { ok: false, error: "Missing command" };
+    }
+    return { ok: true, argv: argv };
+}
 /**
  * Executes a command and returns the result, providing unified error handling
  *
@@ -19,9 +94,18 @@ export function executeCommand(command, options) {
         [cmd, ...args] = command;
     }
     else {
-        const parts = command.split(" ");
-        cmd = parts[0] ?? "";
-        args = parts.slice(1);
+        const parsed = parseArgv(command);
+        if (!parsed.ok) {
+            const result = {
+                stdout: "",
+                stderr: parsed.error,
+                code: 1,
+            };
+            return throwOnError
+                ? Promise.reject(new Error(parsed.error))
+                : Promise.resolve(result);
+        }
+        [cmd, ...args] = parsed.argv;
     }
     if (isUndefined(cmd) || cmd.trim() === "") {
         const result = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travisennis/acai",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "An AI assistant for developing software.",
   "type": "module",
   "main": "dist/index.js",
@@ -44,26 +44,26 @@
     "typecheck:staged": "tsc --noEmit --pretty -p tsconfig.json"
   },
   "dependencies": {
-    "@ai-sdk/anthropic": "^2.0.6",
-    "@ai-sdk/deepseek": "^1.0.11",
-    "@ai-sdk/google": "^2.0.8",
-    "@ai-sdk/openai": "^2.0.20",
-    "@ai-sdk/openai-compatible": "^1.0.11",
+    "@ai-sdk/anthropic": "^2.0.9",
+    "@ai-sdk/deepseek": "^1.0.13",
+    "@ai-sdk/google": "^2.0.11",
+    "@ai-sdk/openai": "^2.0.23",
+    "@ai-sdk/openai-compatible": "^1.0.13",
     "@crosscopy/clipboard": "^0.2.8",
     "@inquirer/prompts": "^7.8.4",
     "@travisennis/stdlib": "^0.0.14",
-    "ai": "^5.0.23",
+    "ai": "^5.0.28",
     "chalk": "^5.6.0",
     "cheerio": "^1.1.2",
     "cli-highlight": "^2.1.11",
     "cli-table3": "^0.6.5",
     "diff": "^8.0.2",
     "duck-duck-scrape": "^2.2.7",
-    "exa-js": "^1.9.2",
+    "exa-js": "^1.9.3",
     "globby": "^14.1.0",
     "ignore": "^7.0.5",
     "log-update": "^6.1.0",
-    "marked": "16.2.0",
+    "marked": "16.2.1",
     "ora": "^8.2.0",
     "p-throttle": "^8.0.0",
     "pino": "^9.9.0",