sharkbait 1.0.11 → 1.0.13

package/dist/cli.js

@@ -746,14 +746,6 @@ var REQUIRES_CONFIRMATION = [
     undoHint: "chown with original owner"
   }
 ];
-var SHELL_CHAINING_PATTERNS = [
-  /;/,
-  /\|\|/,
-  /&&/,
-  /\$\(/,
-  /`[^`]+`/,
-  /\|\s*\w/
-];
 var DANGEROUS_PREFIXES = ["sudo", "doas", "pkexec", "exec"];
 function classifyCommand(command) {
   const trimmed = command.trim();
@@ -780,17 +772,30 @@ function classifyCommand(command) {
       reversibility: "effort"
     };
   }
-  for (const pattern of SHELL_CHAINING_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return {
-        status: "requires_confirmation",
-        reason: "Command contains shell operators (;, &&, ||, |, $()) — each sub-command cannot be independently verified",
-        reversibility: "effort"
-      };
+  if (/\$\(/.test(trimmed) || /`[^`]+`/.test(trimmed)) {
+    return {
+      status: "requires_confirmation",
+      reason: "Command contains command substitution ($() or backticks)",
+      reversibility: "effort"
+    };
+  }
+  const hasChaining = /;|&&|\|\||(\|\s*\w)/.test(trimmed);
+  if (hasChaining) {
+    const subCommands = trimmed.split(/\s*(?:;|&&|\|\|)\s*/).flatMap((segment) => segment.split(/\s*\|\s*/)).map((s) => s.trim()).filter(Boolean);
+    for (const sub of subCommands) {
+      const subSafety = classifySimpleCommand(sub);
+      if (subSafety.status === "blocked")
+        return subSafety;
+      if (subSafety.status === "requires_confirmation")
+        return subSafety;
     }
+    return { status: "allowed" };
   }
-  const baseCommand = extractBaseCommand(trimmed);
-  if (isOnAllowlist(baseCommand, trimmed)) {
+  return classifySimpleCommand(trimmed);
+}
+function classifySimpleCommand(command) {
+  const baseCommand = extractBaseCommand(command);
+  if (isOnAllowlist(baseCommand, command)) {
     return { status: "allowed" };
   }
   return {
@@ -941,6 +946,57 @@ function getErrorMessage(error) {
   return "Unknown error";
 }
 
+// src/utils/runtime.ts
+import { spawn as nodeSpawn } from "child_process";
+import { readFile, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+function exec(args, options) {
+  return new Promise((resolve2) => {
+    const [cmd, ...rest] = args;
+    const proc = nodeSpawn(cmd, rest, {
+      cwd: options?.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (options?.stdin) {
+      proc.stdin?.write(options.stdin);
+    }
+    proc.stdin?.end();
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      resolve2({ stdout, stderr, exitCode: code ?? 1 });
+    });
+    proc.on("error", (err) => {
+      resolve2({ stdout, stderr: err.message, exitCode: 1 });
+    });
+  });
+}
+function spawnBackground(args, options) {
+  const [cmd, ...rest] = args;
+  const proc = nodeSpawn(cmd, rest, {
+    cwd: options?.cwd,
+    stdio: ["ignore", "ignore", "ignore"],
+    detached: process.platform !== "win32"
+  });
+  proc.unref();
+  return proc.pid;
+}
+async function readTextFile(filePath) {
+  return readFile(filePath, "utf-8");
+}
+async function writeTextFile(filePath, content) {
+  await writeFile(filePath, content);
+}
+function fileExists(filePath) {
+  return existsSync2(filePath);
+}
+
 // src/tools/file-ops.ts
 function enforcePath(filePath, operation) {
   const safety = validatePath(filePath, process.cwd(), operation);
@@ -964,11 +1020,10 @@ var fileTools = [
     async execute({ path, startLine, endLine }) {
       const filePath = path;
       enforcePath(filePath, "read");
-      const file = Bun.file(filePath);
-      if (!await file.exists()) {
+      if (!fileExists(filePath)) {
         throw new ToolError(`File not found: ${filePath}`, "read_file");
       }
-      const content = await file.text();
+      const content = await readTextFile(filePath);
       if (startLine !== undefined && endLine !== undefined) {
         const lines = content.split(`
 `);
@@ -998,7 +1053,7 @@ var fileTools = [
       if (dir) {
         await mkdir(dir, { recursive: true });
       }
-      await Bun.write(filePath, content);
+      await writeTextFile(filePath, content);
       return { success: true, path: filePath };
     }
   },
@@ -1017,11 +1072,10 @@ var fileTools = [
     async execute({ path, oldString, newString }) {
       const filePath = path;
       enforcePath(filePath, "write");
-      const file = Bun.file(filePath);
-      if (!await file.exists()) {
+      if (!fileExists(filePath)) {
         throw new ToolError(`File not found: ${filePath}`, "edit_file");
       }
-      const content = await file.text();
+      const content = await readTextFile(filePath);
       const oldStr = oldString;
       if (!content.includes(oldStr)) {
         throw new ToolError(`String not found in file: ${oldStr.substring(0, 50)}...`, "edit_file");
@@ -1031,7 +1085,7 @@ var fileTools = [
         throw new ToolError(`String found ${occurrences} times. Please provide more context for unique match.`, "edit_file");
       }
       const newContent = content.replace(oldStr, newString);
-      await Bun.write(filePath, newContent);
+      await writeTextFile(filePath, newContent);
       return { success: true, path: filePath };
     }
   },
@@ -1109,9 +1163,8 @@ var fileTools = [
           "-m",
           String(limit)
         ];
-        const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
-        const output = await new Response(proc.stdout).text();
-        return output;
+        const result = await exec(args);
+        return result.stdout;
       } catch {
         try {
           const args = [
@@ -1122,12 +1175,8 @@ var fileTools = [
             "--include",
             glob
           ];
-          const proc = Bun.spawn(args, {
-            stdout: "pipe",
-            stderr: "pipe"
-          });
-          const output = await new Response(proc.stdout).text();
-          return output;
+          const result = await exec(args);
+          return result.stdout;
         } catch {
           return "No matches found";
         }
@@ -1169,9 +1218,8 @@ var fileTools = [
         args.push("-m", String(maxResults));
       }
       try {
-        const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
-        const output = await new Response(proc.stdout).text();
-        return output || "No matches found";
+        const result = await exec(args);
+        return result.stdout || "No matches found";
       } catch {
         return "Search failed - ripgrep may not be installed";
       }
@@ -1228,33 +1276,23 @@ var shellTools = [
       if (background) {
         const shell = process.platform === "win32" ? "cmd" : "sh";
         const shellArg = process.platform === "win32" ? "/c" : "-c";
-        const proc = Bun.spawn([shell, shellArg, cmd], {
-          cwd: workingDir,
-          stdout: "pipe",
-          stderr: "pipe"
+        const pid = spawnBackground([shell, shellArg, cmd], {
+          cwd: workingDir
         });
         return {
-          pid: proc.pid,
+          pid,
           message: "Started in background"
         };
       }
       try {
         const shell = process.platform === "win32" ? "cmd" : "sh";
         const shellArg = process.platform === "win32" ? "/c" : "-c";
-        const proc = Bun.spawn([shell, shellArg, cmd], {
-          cwd: workingDir,
-          stdout: "pipe",
-          stderr: "pipe"
-        });
         const timeoutPromise = new Promise((_, reject) => {
           setTimeout(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)), timeoutMs);
         });
-        const outputPromise = (async () => {
-          const stdout2 = await new Response(proc.stdout).text();
-          const stderr2 = await new Response(proc.stderr).text();
-          const exitCode2 = await proc.exited;
-          return { stdout: stdout2, stderr: stderr2, exitCode: exitCode2 };
-        })();
+        const outputPromise = exec([shell, shellArg, cmd], {
+          cwd: workingDir
+        });
         const { stdout, stderr, exitCode } = await Promise.race([
           outputPromise,
           timeoutPromise
@@ -1319,11 +1357,7 @@ var shellTools = [
         cmd = app ? [app, target] : ["xdg-open", target];
       }
       try {
-        const proc = Bun.spawn(cmd, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        await proc.exited;
+        await exec(cmd);
         return { success: true, message: `Opened ${target}` };
       } catch (error) {
         return { success: false, error: getErrorMessage(error) };
@@ -1335,7 +1369,7 @@ var shellTools = [
 // src/tools/beads.ts
 import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 function getBdPath() {
   const paths = [
     "bd",
@@ -1351,16 +1385,12 @@ function getBdPath() {
 var BD_PATH = getBdPath();
 function isBeadsInitialized(cwd) {
   const dir = cwd || process.cwd();
-  return existsSync2(join3(dir, ".beads"));
+  return existsSync3(join3(dir, ".beads"));
 }
 async function isBdInstalled() {
   try {
-    const proc = Bun.spawn([BD_PATH, "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await proc.exited;
-    return true;
+    const result = await exec([BD_PATH, "--version"]);
+    return result.exitCode === 0;
   } catch {
     return false;
   }
@@ -1419,21 +1449,14 @@ var beadsTools = [
         args.push("--no-db");
       }
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe",
-          cwd: process.cwd()
-        });
-        const output = await new Response(proc.stdout).text();
-        const stderr = await new Response(proc.stderr).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          throw new Error(stderr || output || "Failed to initialize beads");
+        const result = await exec(args, { cwd: process.cwd() });
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || result.stdout || "Failed to initialize beads");
         }
         return {
           success: true,
           message: "Beads initialized successfully.",
-          output: output.trim()
+          output: result.stdout.trim()
         };
       } catch (error) {
         return {
@@ -1453,16 +1476,11 @@ var beadsTools = [
     },
     async execute() {
       try {
-        const proc = Bun.spawn([BD_PATH, "ready", "--json"], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec([BD_PATH, "ready", "--json"]);
+        if (result.exitCode !== 0) {
           throw new Error("Failed to get ready tasks");
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch (error) {
         return { tasks: [], message: "Beads (bd) not available" };
       }
@@ -1497,32 +1515,25 @@ var beadsTools = [
       }
       args.push("--json");
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe",
-          cwd: process.cwd()
-        });
-        const output = await new Response(proc.stdout).text();
-        const stderr = await new Response(proc.stderr).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          if (stderr.includes("no beads database found")) {
+        const result = await exec(args, { cwd: process.cwd() });
+        if (result.exitCode !== 0) {
+          if (result.stderr.includes("no beads database found")) {
             return {
               success: false,
               error: "Beads database not found. Use beads_init to initialize.",
               hint: "Run beads_init first, then retry creating the task."
             };
           }
-          throw new Error(stderr || "Failed to create task");
+          throw new Error(result.stderr || "Failed to create task");
         }
-        const jsonStart = output.indexOf("{");
-        const jsonEnd = output.lastIndexOf("}");
+        const jsonStart = result.stdout.indexOf("{");
+        const jsonEnd = result.stdout.lastIndexOf("}");
         if (jsonStart === -1 || jsonEnd === -1) {
-          throw new Error(`No JSON in output: ${output}`);
+          throw new Error(`No JSON in output: ${result.stdout}`);
         }
-        const jsonStr = output.substring(jsonStart, jsonEnd + 1);
-        const result = JSON.parse(jsonStr);
-        return { success: true, ...result };
+        const jsonStr = result.stdout.substring(jsonStart, jsonEnd + 1);
+        const parsed = JSON.parse(jsonStr);
+        return { success: true, ...parsed };
       } catch (error) {
         return {
           success: false,
@@ -1543,16 +1554,11 @@ var beadsTools = [
     },
     async execute({ id }) {
       try {
-        const proc = Bun.spawn([BD_PATH, "show", id, "--json"], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec([BD_PATH, "show", id, "--json"]);
+        if (result.exitCode !== 0) {
           throw new Error(`Task not found: ${id}`);
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch (error) {
         throw new Error(`Failed to get task: ${error}`);
       }
@@ -1572,12 +1578,8 @@ var beadsTools = [
     async execute({ id, message }) {
       const msg = message || "Completed";
       try {
-        const proc = Bun.spawn([BD_PATH, "close", id, "-m", msg], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec([BD_PATH, "close", id, "-m", msg]);
+        if (result.exitCode !== 0) {
           throw new Error(`Failed to complete task: ${id}`);
         }
         return { success: true, id, message: msg };
@@ -1599,9 +1601,8 @@ var beadsTools = [
     },
     async execute({ childId, parentId }) {
       try {
-        const proc = Bun.spawn([BD_PATH, "dep", "add", childId, parentId], { stdout: "pipe", stderr: "pipe" });
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec([BD_PATH, "dep", "add", childId, parentId]);
+        if (result.exitCode !== 0) {
           throw new Error("Failed to add dependency");
         }
         return { success: true, childId, parentId };
@@ -1632,16 +1633,11 @@ var beadsTools = [
         args.push("--status", status);
       }
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
           return { tasks: [] };
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch {
         return { tasks: [], message: "Beads (bd) not available" };
       }
@@ -1661,12 +1657,8 @@ var gitTools = [
     },
     async execute() {
       try {
-        const proc = Bun.spawn(["git", "status", "--porcelain"], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        return output.trim() || "Working tree clean";
+        const { stdout } = await exec(["git", "status", "--porcelain"]);
+        return stdout.trim() || "Working tree clean";
       } catch (error) {
         throw new Error("Not a git repository or git not installed");
       }
@@ -1692,12 +1684,8 @@ var gitTools = [
         args.push(file);
       }
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        return output.trim() || "No changes";
+        const { stdout } = await exec(args);
+        return stdout.trim() || "No changes";
       } catch (error) {
         throw new Error("Failed to get diff");
       }
@@ -1717,23 +1705,13 @@ var gitTools = [
     async execute({ message, all }) {
       try {
         if (all) {
-          const addProc = Bun.spawn(["git", "add", "-A"], {
-            stdout: "pipe",
-            stderr: "pipe"
-          });
-          await addProc.exited;
+          await exec(["git", "add", "-A"]);
         }
-        const proc = Bun.spawn(["git", "commit", "-m", message], {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          const stderr = await new Response(proc.stderr).text();
-          throw new Error(stderr || "Commit failed");
+        const result = await exec(["git", "commit", "-m", message]);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || "Commit failed");
         }
-        return { success: true, message, output: output.trim() };
+        return { success: true, message, output: result.stdout.trim() };
       } catch (error) {
         throw new Error(`Commit failed: ${error}`);
       }
@@ -1758,14 +1736,9 @@ var gitTools = [
         args.push("origin", branch);
       }
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const exitCode = await proc.exited;
-        const stderr = await new Response(proc.stderr).text();
-        if (exitCode !== 0) {
-          throw new Error(stderr || "Push failed");
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || "Push failed");
         }
         return { success: true, message: "Pushed successfully" };
       } catch (error) {
@@ -1813,21 +1786,15 @@ var gitTools = [
           default:
             throw new Error(`Unknown action: ${action}`);
         }
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          const stderr = await new Response(proc.stderr).text();
-          throw new Error(stderr || "Branch operation failed");
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || "Branch operation failed");
         }
         return {
           success: true,
           branch: name,
           action,
-          output: output.trim()
+          output: result.stdout.trim()
         };
       } catch (error) {
         throw new Error(`Branch operation failed: ${error}`);
@@ -1854,12 +1821,8 @@ var gitTools = [
         args.push("--oneline");
       }
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        return output.trim();
+        const { stdout } = await exec(args);
+        return stdout.trim();
       } catch (error) {
         throw new Error("Failed to get log");
       }
@@ -1895,17 +1858,11 @@ var githubTools = [
       }
       args.push("--json", "number,url,title");
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          const stderr = await new Response(proc.stderr).text();
-          throw new Error(stderr || "Failed to create PR");
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || "Failed to create PR");
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch (error) {
         throw new Error(`Failed to create PR: ${error}`);
       }
@@ -1936,16 +1893,11 @@ var githubTools = [
       }
       args.push("--json", "number,title,author,url,state,headRefName");
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
           return { prs: [] };
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch {
         return { prs: [], message: "GitHub CLI (gh) not available" };
       }
@@ -1974,14 +1926,9 @@ var githubTools = [
         args.push("--delete-branch");
       }
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          const stderr = await new Response(proc.stderr).text();
-          throw new Error(stderr || "Failed to merge PR");
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || "Failed to merge PR");
         }
         return { success: true, number, method: method || "squash" };
       } catch (error) {
@@ -2023,17 +1970,11 @@ var githubTools = [
       }
       args.push("--json", "number,url,title");
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
-          const stderr = await new Response(proc.stderr).text();
-          throw new Error(stderr || "Failed to create issue");
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || "Failed to create issue");
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch (error) {
         throw new Error(`Failed to create issue: ${error}`);
       }
@@ -2056,16 +1997,11 @@ var githubTools = [
       }
       args.push("--json", "status,conclusion,name,createdAt,url,headBranch");
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
           return { runs: [] };
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch {
         return { runs: [], message: "GitHub CLI (gh) not available" };
       }
@@ -2091,16 +2027,11 @@ var githubTools = [
         "number,title,body,state,author,url,headRefName,baseRefName,additions,deletions,changedFiles"
       ];
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
           throw new Error(`PR #${number} not found`);
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch (error) {
         throw new Error(`Failed to view PR: ${error}`);
       }
@@ -2139,16 +2070,11 @@ var githubTools = [
       }
       args.push("--json", "number,title,state,author,labels,url");
       try {
-        const proc = Bun.spawn(args, {
-          stdout: "pipe",
-          stderr: "pipe"
-        });
-        const output = await new Response(proc.stdout).text();
-        const exitCode = await proc.exited;
-        if (exitCode !== 0) {
+        const result = await exec(args);
+        if (result.exitCode !== 0) {
           return { issues: [] };
         }
-        return JSON.parse(output);
+        return JSON.parse(result.stdout);
       } catch {
         return { issues: [], message: "GitHub CLI (gh) not available" };
       }
@@ -2385,7 +2311,7 @@ var fetchTools = [
 ];
 
 // src/tools/codebase.ts
-import { readdir as readdir2, stat as stat2, readFile } from "fs/promises";
+import { readdir as readdir2, stat as stat2, readFile as readFile2 } from "fs/promises";
 import { join as join4, extname } from "path";
 async function buildDirectoryTree(dir, prefix = "", maxDepth = 3, currentDepth = 0) {
   if (currentDepth >= maxDepth) {
@@ -2432,7 +2358,7 @@ async function buildDirectoryTree(dir, prefix = "", maxDepth = 3, currentDepth =
 }
 async function countLines(filePath) {
   try {
-    const content = await readFile(filePath, "utf-8");
+    const content = await readFile2(filePath, "utf-8");
     return content.split(`
 `).length;
   } catch {
@@ -2480,7 +2406,7 @@ async function detectTechnologies(projectDir) {
   try {
     const pkgJsonPath = join4(projectDir, "package.json");
     try {
-      const pkgJsonContent = await readFile(pkgJsonPath, "utf-8");
+      const pkgJsonContent = await readFile2(pkgJsonPath, "utf-8");
       const pkgJson = JSON.parse(pkgJsonContent);
       const allDeps = {
         ...pkgJson.dependencies,
@@ -2513,8 +2439,8 @@ async function detectTechnologies(projectDir) {
     for (const { file, tech } of configFiles) {
       try {
         const filePath = join4(projectDir, file);
-        const fileExists = await stat2(filePath).then(() => true).catch(() => false);
-        if (fileExists && !technologies.includes(tech)) {
+        const fileExists2 = await stat2(filePath).then(() => true).catch(() => false);
+        if (fileExists2 && !technologies.includes(tech)) {
           technologies.push(tech);
         }
       } catch {}
@@ -2585,7 +2511,7 @@ var codebaseTools = [
     async execute({ path }) {
       const pkgJsonPath = path || join4(process.cwd(), "package.json");
       try {
-        const content = await readFile(pkgJsonPath, "utf-8");
+        const content = await readFile2(pkgJsonPath, "utf-8");
         const pkgJson = JSON.parse(content);
         const dependencies = pkgJson.dependencies || {};
         const devDependencies = pkgJson.devDependencies || {};
@@ -3486,7 +3412,7 @@ Platform: ${process.platform}
 // src/utils/config.ts
 import { join as join5 } from "path";
 import { homedir as homedir3 } from "os";
-import { readFileSync, existsSync as existsSync3 } from "fs";
+import { readFileSync, existsSync as existsSync4 } from "fs";
 var cachedConfig = null;
 function deepMerge(target, source) {
   const result = { ...target };
@@ -3503,7 +3429,7 @@ function deepMerge(target, source) {
 }
 function loadJsonConfig(filePath) {
   try {
-    if (!existsSync3(filePath)) {
+    if (!existsSync4(filePath)) {
       return null;
     }
     const raw = readFileSync(filePath, "utf-8");
@@ -3585,12 +3511,12 @@ function loadConfig() {
 }
 function getWorkingDir(cliOption) {
   if (cliOption) {
-    if (existsSync3(cliOption))
+    if (existsSync4(cliOption))
       return cliOption;
     return process.cwd();
   }
   const config = loadConfig();
-  if (config.paths.defaultWorkingDir && existsSync3(config.paths.defaultWorkingDir)) {
+  if (config.paths.defaultWorkingDir && existsSync4(config.paths.defaultWorkingDir)) {
     return config.paths.defaultWorkingDir;
   }
   return process.cwd();
@@ -7575,10 +7501,10 @@ function ConfirmDialog({
 
 // src/ui/commands/registry.ts
 import { resolve as resolve2, isAbsolute } from "path";
-import { existsSync as existsSync4, statSync as statSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync5, statSync as statSync2, readFileSync as readFileSync2 } from "fs";
 
 // src/commands/init.ts
-import { writeFile } from "fs/promises";
+import { writeFile as writeFile2, readFile as fsReadFile } from "fs/promises";
 import { join as join6 } from "path";
 async function initProject() {
   log.info("Initializing Sharkbait in current project...");
@@ -7595,7 +7521,7 @@ async function initProject() {
     }
   };
   try {
-    await writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
+    await writeFile2(configPath, JSON.stringify(defaultConfig, null, 2));
     log.success(`Created ${configPath}`);
   } catch (error) {
     log.warn(`Could not create config file: ${error}`);
@@ -7613,16 +7539,16 @@ SHARKBAIT_MAX_CONTEXT_TOKENS=100000
 SHARKBAIT_CONFIRM_DESTRUCTIVE=true
 `;
   try {
-    await writeFile(envExamplePath, envExample);
+    await writeFile2(envExamplePath, envExample);
     log.success(`Created ${envExamplePath}`);
   } catch (error) {
     log.warn(`Could not create .env.example: ${error}`);
   }
   const gitignorePath = join6(cwd, ".gitignore");
   try {
-    const gitignoreContent = await Bun.file(gitignorePath).text();
+    const gitignoreContent = await fsReadFile(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".env")) {
-      await Bun.write(gitignorePath, gitignoreContent + `
+      await writeFile2(gitignorePath, gitignoreContent + `
 # Sharkbait
 .env
 `);
@@ -7723,7 +7649,7 @@ Usage: /cd <path>`
         };
       }
       const newPath = isAbsolute(args) ? args : resolve2(ctx.currentDir, args);
-      if (!existsSync4(newPath)) {
+      if (!existsSync5(newPath)) {
         ctx.setPendingConfirm({ type: "mkdir", data: { path: newPath } });
         return {
           handled: true,
@@ -8092,7 +8018,7 @@ Example:
         }
       }
       const resolvedPath = isAbsolute(filePath) ? filePath : resolve2(ctx.currentDir, filePath);
-      if (!existsSync4(resolvedPath)) {
+      if (!existsSync5(resolvedPath)) {
         return {
           handled: true,
           message: `File not found: ${resolvedPath}`,
@@ -8778,7 +8704,7 @@ ${event.consolidated}`,
 }
 
 // src/version.ts
-var VERSION = "1.0.11";
+var VERSION = "1.0.13";
 
 // src/agent/start-chat.ts
 async function startChat(options = {}) {
@@ -8797,7 +8723,7 @@ async function startChat(options = {}) {
   await waitUntilExit();
 }
 // src/commands/init.ts
-import { writeFile as writeFile2 } from "fs/promises";
+import { writeFile as writeFile3, readFile as fsReadFile2 } from "fs/promises";
 import { join as join7 } from "path";
 async function initProject2() {
   log.info("Initializing Sharkbait in current project...");
@@ -8814,7 +8740,7 @@ async function initProject2() {
     }
   };
   try {
-    await writeFile2(configPath, JSON.stringify(defaultConfig, null, 2));
+    await writeFile3(configPath, JSON.stringify(defaultConfig, null, 2));
     log.success(`Created ${configPath}`);
   } catch (error) {
     log.warn(`Could not create config file: ${error}`);
@@ -8832,16 +8758,16 @@ SHARKBAIT_MAX_CONTEXT_TOKENS=100000
 SHARKBAIT_CONFIRM_DESTRUCTIVE=true
 `;
   try {
-    await writeFile2(envExamplePath, envExample);
+    await writeFile3(envExamplePath, envExample);
     log.success(`Created ${envExamplePath}`);
   } catch (error) {
     log.warn(`Could not create .env.example: ${error}`);
   }
   const gitignorePath = join7(cwd, ".gitignore");
   try {
-    const gitignoreContent = await Bun.file(gitignorePath).text();
+    const gitignoreContent = await fsReadFile2(gitignorePath, "utf-8");
     if (!gitignoreContent.includes(".env")) {
-      await Bun.write(gitignorePath, gitignoreContent + `
+      await writeFile3(gitignorePath, gitignoreContent + `
 # Sharkbait
 .env
 `);
@@ -8965,10 +8891,10 @@ Task completed.`);
 import React4, { useState as useState3, useEffect as useEffect3 } from "react";
 import { render as render2, Box as Box13, Text as Text13, useInput as useInput2, useApp as useApp2 } from "ink";
 import TextInput from "ink-text-input";
-import { writeFile as writeFile3, readFile as readFile2, mkdir as mkdir4, stat as stat3 } from "fs/promises";
+import { writeFile as writeFile4, readFile as readFile3, mkdir as mkdir4, stat as stat3 } from "fs/promises";
 import { join as join8, resolve as resolve3 } from "path";
 import { homedir as homedir4 } from "os";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { execSync } from "child_process";
 import { jsxDEV as jsxDEV13, Fragment as Fragment3 } from "react/jsx-dev-runtime";
 function SetupWizardWithCallback({ onComplete }) {
@@ -8993,8 +8919,8 @@ function SetupWizardWithCallback({ onComplete }) {
     const configDir2 = join8(homedir4(), ".sharkbait");
     const configPath = join8(configDir2, "config.json");
     try {
-      if (existsSync5(configPath)) {
-        const content = await readFile2(configPath, "utf-8");
+      if (existsSync6(configPath)) {
+        const content = await readFile3(configPath, "utf-8");
         const existing = JSON.parse(content);
         setState((prev) => ({
           ...prev,
@@ -9126,7 +9052,7 @@ function SetupWizardWithCallback({ onComplete }) {
       case "working-dir": {
         if (value.trim()) {
           const resolved = resolve3(value.trim().replace(/^~/, homedir4()));
-          if (!existsSync5(resolved)) {
+          if (!existsSync6(resolved)) {
             setError(`Directory not found: ${resolved}`);
             return;
           }
@@ -9172,7 +9098,7 @@ function SetupWizardWithCallback({ onComplete }) {
           showSpinner: true
         }
       };
-      await writeFile3(join8(configDir2, "config.json"), JSON.stringify(config, null, 2));
+      await writeFile4(join8(configDir2, "config.json"), JSON.stringify(config, null, 2));
       const envLines = [
         "# Sharkbait Azure OpenAI Configuration",
         `# Generated by 'sharkbait setup' on ${new Date().toISOString()}`,
@@ -9191,7 +9117,7 @@ function SetupWizardWithCallback({ onComplete }) {
       const envContent = envLines.join(`
 `) + `
 `;
-      await writeFile3(join8(configDir2, ".env"), envContent);
+      await writeFile4(join8(configDir2, ".env"), envContent);
       setStep("complete");
     } catch (err) {
       setError(`Failed to save: ${err}`);
@@ -9830,12 +9756,12 @@ async function runSetup() {
 }
 
 // src/commands/review.ts
-import { readFileSync as readFileSync3, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync7 } from "fs";
 import { resolve as resolve4, isAbsolute as isAbsolute2 } from "path";
 async function runReview(filePath, options = {}) {
   const config = loadConfig();
   const resolvedPath = isAbsolute2(filePath) ? filePath : resolve4(process.cwd(), filePath);
-  if (!existsSync6(resolvedPath)) {
+  if (!existsSync7(resolvedPath)) {
     console.error(`❌ File not found: ${resolvedPath}`);
     process.exit(1);
   }
@@ -9955,7 +9881,7 @@ ${"━".repeat(60)}`);
 }
 
 // src/version.ts
-var VERSION2 = "1.0.11";
+var VERSION2 = "1.0.13";
 
 // src/ui/logo.tsx
 import { Box as Box14, Text as Text14 } from "ink";
@@ -9990,12 +9916,12 @@ var SHARK_LOGO2 = `
 `.trimEnd();
 
 // src/cli.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir5 } from "os";
 var args = process.argv.slice(2);
 if (args.length === 0) {
-  const configExists = existsSync7(join9(homedir5(), ".sharkbait", "config.json"));
+  const configExists = existsSync8(join9(homedir5(), ".sharkbait", "config.json"));
   if (!configExists) {
     const completed = await runSetup();
     if (completed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sharkbait",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "AI-powered coding assistant for the command line. Uses OpenAI Responses API (not Chat). Autonomous agents, parallel code reviews, 36 tools.",
   "type": "module",
   "main": "./dist/cli.js",