amai 0.0.19 → 0.0.21

package/dist/cli.cjs

@@ -5,9 +5,9 @@ var pc5 = require('picocolors');
 var WebSocket = require('ws');
 var zod = require('zod');
 var path10 = require('path');
-var fs10 = require('fs');
+var fs11 = require('fs');
+var fsp = require('fs/promises');
 var os3 = require('os');
-var fs8 = require('fs/promises');
 var hono = require('hono');
 var nodeServer = require('@hono/node-server');
 var cors = require('hono/cors');
@@ -19,19 +19,37 @@ var readline = require('readline');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
 var pc5__default = /*#__PURE__*/_interopDefault(pc5);
 var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
 var path10__default = /*#__PURE__*/_interopDefault(path10);
-var fs10__default = /*#__PURE__*/_interopDefault(fs10);
+var fs11__default = /*#__PURE__*/_interopDefault(fs11);
+var fsp__namespace = /*#__PURE__*/_interopNamespace(fsp);
 var os3__default = /*#__PURE__*/_interopDefault(os3);
-var fs8__default = /*#__PURE__*/_interopDefault(fs8);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 
 var MUTATING_TOOLS = /* @__PURE__ */ new Set([
   "editFile",
   "deleteFile",
   "stringReplace",
-  "runTerminalCommand"
+  "bash"
 ]);
 function isMutatingTool(toolName) {
   return MUTATING_TOOLS.has(toolName);
@@ -52,11 +70,11 @@ function isPathWithinProject(filePath, projectCwd) {
 }
 function safeRealpath(p) {
   try {
-    return fs10__default.default.realpathSync(p);
+    return fs11__default.default.realpathSync(p);
   } catch {
     const parent = path10__default.default.dirname(p);
     try {
-      const realParent = fs10__default.default.realpathSync(parent);
+      const realParent = fs11__default.default.realpathSync(parent);
       return path10__default.default.join(realParent, path10__default.default.basename(p));
     } catch {
       return path10__default.default.resolve(p);
@@ -105,77 +123,231 @@ function requireProjectCwd(toolName, projectCwd) {
 
 // src/tools/read-file.ts
 var MAX_FILE_SIZE = 10 * 1024 * 1024;
-var MAX_LINES_RETURNED = 1e4;
+var MAX_LINES_RETURNED = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
+var MAX_BYTES = 50 * 1024;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".zip",
+  ".tar",
+  ".gz",
+  ".exe",
+  ".dll",
+  ".so",
+  ".class",
+  ".jar",
+  ".war",
+  ".7z",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".odt",
+  ".ods",
+  ".odp",
+  ".bin",
+  ".dat",
+  ".obj",
+  ".o",
+  ".a",
+  ".lib",
+  ".wasm",
+  ".pyc",
+  ".pyo",
+  ".ico",
+  ".bmp",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".flv"
+]);
+async function isBinaryFile(filepath, fileSize) {
+  const ext = path10__default.default.extname(filepath).toLowerCase();
+  if (BINARY_EXTENSIONS.has(ext)) return true;
+  if (fileSize === 0) return false;
+  try {
+    const fh = await fsp__namespace.open(filepath, "r");
+    try {
+      const sampleSize = Math.min(4096, fileSize);
+      const bytes = Buffer.alloc(sampleSize);
+      const result = await fh.read(bytes, 0, sampleSize, 0);
+      if (result.bytesRead === 0) return false;
+      let nonPrintableCount = 0;
+      for (let i = 0; i < result.bytesRead; i++) {
+        if (bytes[i] === 0) return true;
+        if (bytes[i] < 9 || bytes[i] > 13 && bytes[i] < 32) {
+          nonPrintableCount++;
+        }
+      }
+      return nonPrintableCount / result.bytesRead > 0.3;
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return false;
+  }
+}
+async function findSimilarFiles(filepath) {
+  const dir = path10__default.default.dirname(filepath);
+  const base = path10__default.default.basename(filepath).toLowerCase();
+  try {
+    const entries = await fsp__namespace.readdir(dir);
+    return entries.filter(
+      (entry) => entry.toLowerCase().includes(base) || base.includes(entry.toLowerCase())
+    ).map((entry) => path10__default.default.join(dir, entry)).slice(0, 3);
+  } catch {
+    return [];
+  }
+}
 zod.z.object({
-  relative_file_path: zod.z.string().describe("The relative path to the file to read."),
-  should_read_entire_file: zod.z.boolean().describe("Whether to read the entire file."),
-  start_line_one_indexed: zod.z.number().optional().describe(
-    "The one-indexed line number to start reading from (inclusive)."
-  ),
-  end_line_one_indexed: zod.z.number().optional().describe("The one-indexed line number to end reading at (inclusive).")
+  relative_file_path: zod.z.string().describe("The path to the file or directory to read."),
+  should_read_entire_file: zod.z.boolean().describe("Whether to read the entire file.").optional().default(true),
+  start_line_one_indexed: zod.z.number().optional().describe("The one-indexed line number to start reading from (inclusive). Alias: offset."),
+  end_line_one_indexed: zod.z.number().optional().describe("The one-indexed line number to end reading at (inclusive). Alias: offset + limit.")
 });
 async function readFileContent(absolute_file_path, relative_file_path, should_read_entire_file, start_line_one_indexed, end_line_one_indexed) {
-  const file = Bun.file(absolute_file_path);
-  const exists = await file.exists();
-  if (!exists) {
+  let stat2;
+  try {
+    stat2 = fs11__default.default.statSync(absolute_file_path);
+  } catch {
+    const suggestions = await findSimilarFiles(absolute_file_path);
+    let message = `File not found: ${relative_file_path}`;
+    if (suggestions.length > 0) {
+      message += `
+
+Did you mean one of these?
+${suggestions.join("\n")}`;
+    }
     return {
       success: false,
-      message: `File not found: ${relative_file_path}`,
+      message,
       error: "FILE_NOT_FOUND"
     };
   }
+  if (stat2.isDirectory()) {
+    try {
+      const dirents = await fsp__namespace.readdir(absolute_file_path, { withFileTypes: true });
+      const entries = await Promise.all(
+        dirents.map(async (dirent) => {
+          if (dirent.isDirectory()) return dirent.name + "/";
+          if (dirent.isSymbolicLink()) {
+            const target = await fsp__namespace.stat(path10__default.default.join(absolute_file_path, dirent.name)).catch(() => void 0);
+            if (target?.isDirectory()) return dirent.name + "/";
+          }
+          return dirent.name;
+        })
+      );
+      entries.sort((a, b) => a.localeCompare(b));
+      const truncated = entries.length > MAX_LINES_RETURNED;
+      const sliced = entries.slice(0, MAX_LINES_RETURNED);
+      const output = [
+        `<path>${absolute_file_path}</path>`,
+        `<type>directory</type>`,
+        `<entries>`,
+        sliced.join("\n"),
+        truncated ? `
+(Showing ${sliced.length} of ${entries.length} entries)` : `
+(${entries.length} entries)`,
+        `</entries>`
+      ].join("\n");
+      return {
+        success: true,
+        message: `Listed directory: ${relative_file_path} (${entries.length} entries)`,
+        content: output,
+        totalLines: entries.length,
+        truncated
+      };
+    } catch (err) {
+      return {
+        success: false,
+        message: `Failed to list directory: ${relative_file_path}`,
+        error: "READ_ERROR"
+      };
+    }
+  }
   try {
-    const stat = await file.stat();
-    if (stat.size > MAX_FILE_SIZE) {
+    if (stat2.size > MAX_FILE_SIZE) {
       return {
         success: false,
-        message: `File too large (${Math.round(stat.size / 1024 / 1024)}MB). Maximum is ${MAX_FILE_SIZE / 1024 / 1024}MB. Use line ranges to read portions.`,
+        message: `File too large (${Math.round(stat2.size / 1024 / 1024)}MB). Maximum is ${MAX_FILE_SIZE / 1024 / 1024}MB. Use line ranges to read portions.`,
         error: "FILE_TOO_LARGE"
       };
     }
-    const fileContent = await file.text();
-    const lines = fileContent.split(/\r?\n/);
-    const totalLines = lines.length;
-    if (should_read_entire_file) {
-      const cappedLines = lines.slice(0, MAX_LINES_RETURNED);
-      const truncated = totalLines > MAX_LINES_RETURNED;
-      const content = cappedLines.join("\n");
+    const binary = await isBinaryFile(absolute_file_path, stat2.size);
+    if (binary) {
       return {
-        success: true,
-        message: truncated ? `Read first ${MAX_LINES_RETURNED} of ${totalLines} lines from: ${relative_file_path} (truncated)` : `Successfully read entire file: ${relative_file_path} (${totalLines} lines)`,
-        content,
-        totalLines,
-        truncated
+        success: false,
+        message: `Cannot read binary file: ${relative_file_path}`,
+        error: "BINARY_FILE"
       };
     }
-    const startIndex = start_line_one_indexed - 1;
-    if (startIndex >= totalLines) {
+    const fileContent = await Bun.file(absolute_file_path).text();
+    const lines = fileContent.split(/\r?\n/);
+    const totalLines = lines.length;
+    const start = should_read_entire_file ? 0 : (start_line_one_indexed ?? 1) - 1;
+    const end = should_read_entire_file ? Math.min(totalLines, MAX_LINES_RETURNED) : Math.min(end_line_one_indexed ?? totalLines, totalLines);
+    if (start >= totalLines && !(totalLines === 0 && start === 0)) {
       return {
         success: false,
-        message: "start_line_one_indexed must be less than or equal to the total number of lines in the file",
+        message: `Offset ${start + 1} is out of range for this file (${totalLines} lines)`,
         error: "INVALID_LINE_RANGE"
       };
     }
-    const normalizedEnd = Math.min(end_line_one_indexed, totalLines);
-    const rangeSize = normalizedEnd - startIndex;
-    const cappedEnd = rangeSize > MAX_LINES_RETURNED ? startIndex + MAX_LINES_RETURNED : normalizedEnd;
-    const selectedLines = lines.slice(startIndex, cappedEnd).join("\n");
-    const linesRead = cappedEnd - startIndex;
+    const outputLines = [];
+    let bytes = 0;
+    let truncatedByBytes = false;
+    let actualEnd = start;
+    for (let i = start; i < end; i++) {
+      let line = lines[i];
+      if (line.length > MAX_LINE_LENGTH) {
+        line = line.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX;
+      }
+      const numberedLine = `${i + 1}: ${line}`;
+      const lineBytes = Buffer.byteLength(numberedLine, "utf-8") + (outputLines.length > 0 ? 1 : 0);
+      if (bytes + lineBytes > MAX_BYTES && outputLines.length > 0) {
+        truncatedByBytes = true;
+        break;
+      }
+      outputLines.push(numberedLine);
+      bytes += lineBytes;
+      actualEnd = i + 1;
+    }
+    const hasMoreLines = actualEnd < totalLines;
+    const truncated = truncatedByBytes || hasMoreLines || should_read_entire_file && totalLines > MAX_LINES_RETURNED;
+    let output = `<path>${absolute_file_path}</path>
+<type>file</type>
+<content>
+`;
+    output += outputLines.join("\n");
+    if (truncatedByBytes) {
+      output += `
+
+(Output capped at ${MAX_BYTES / 1024} KB. Showing lines ${start + 1}-${actualEnd}. Use start_line_one_indexed=${actualEnd + 1} to continue.)`;
+    } else if (hasMoreLines && !should_read_entire_file) {
+      output += `
+
+(Showing lines ${start + 1}-${actualEnd} of ${totalLines}. Use start_line_one_indexed=${actualEnd + 1} to continue.)`;
+    } else {
+      output += `
+
+(End of file - total ${totalLines} lines)`;
+    }
+    output += "\n</content>";
     return {
       success: true,
-      message: `Successfully read lines ${start_line_one_indexed}-${cappedEnd} from file: ${relative_file_path} (${linesRead} lines of ${totalLines} total)`,
-      content: selectedLines,
+      message: truncated ? `Read lines ${start + 1}-${actualEnd} of ${totalLines} from: ${relative_file_path} (truncated)` : `Successfully read file: ${relative_file_path} (${totalLines} lines)`,
+      content: output,
       totalLines,
-      truncated: cappedEnd < normalizedEnd
+      truncated
     };
   } catch (error) {
-    if (error?.code === "EISDIR") {
-      return {
-        success: false,
-        message: `Path is not a file: ${relative_file_path}`,
-        error: "NOT_A_FILE"
-      };
-    }
     return {
       success: false,
       message: `Failed to read file: ${relative_file_path}`,
@@ -184,12 +356,12 @@ async function readFileContent(absolute_file_path, relative_file_path, should_re
   }
 }
 var read_file = async function(input, projectCwd) {
-  const { relative_file_path, should_read_entire_file, start_line_one_indexed, end_line_one_indexed } = input;
+  const { relative_file_path, should_read_entire_file = true, start_line_one_indexed, end_line_one_indexed } = input;
   try {
     if (!relative_file_path) {
       return {
         success: false,
-        message: "Missing required parameter: target_file",
+        message: "Missing required parameter: relative_file_path",
         error: "MISSING_TARGET_FILE"
       };
     }
@@ -522,10 +694,310 @@ function calculateDiffStats(oldContent, newContent) {
 zod.z.object({
   file_path: zod.z.string().describe("The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is"),
   new_string: zod.z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
-  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)")
+  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)"),
+  replaceAll: zod.z.boolean().optional().describe("Replace all occurrences of old_string (default false)")
 });
+function levenshtein(a, b) {
+  if (a === "" || b === "") return Math.max(a.length, b.length);
+  const matrix = Array.from(
+    { length: a.length + 1 },
+    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+  return matrix[a.length][b.length];
+}
+var SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0;
+var MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+var SimpleReplacer = function* (_content, find) {
+  yield find;
+};
+var LineTrimmedReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines[searchLines.length - 1] === "") searchLines.pop();
+  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
+    let matches = true;
+    for (let j = 0; j < searchLines.length; j++) {
+      if (originalLines[i + j].trim() !== searchLines[j].trim()) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      let matchStartIndex = 0;
+      for (let k = 0; k < i; k++) matchStartIndex += originalLines[k].length + 1;
+      let matchEndIndex = matchStartIndex;
+      for (let k = 0; k < searchLines.length; k++) {
+        matchEndIndex += originalLines[i + k].length;
+        if (k < searchLines.length - 1) matchEndIndex += 1;
+      }
+      yield content.substring(matchStartIndex, matchEndIndex);
+    }
+  }
+};
+var BlockAnchorReplacer = function* (content, find) {
+  const originalLines = content.split("\n");
+  const searchLines = find.split("\n");
+  if (searchLines.length < 3) return;
+  if (searchLines[searchLines.length - 1] === "") searchLines.pop();
+  const firstLineSearch = searchLines[0].trim();
+  const lastLineSearch = searchLines[searchLines.length - 1].trim();
+  const searchBlockSize = searchLines.length;
+  const candidates = [];
+  for (let i = 0; i < originalLines.length; i++) {
+    if (originalLines[i].trim() !== firstLineSearch) continue;
+    for (let j = i + 2; j < originalLines.length; j++) {
+      if (originalLines[j].trim() === lastLineSearch) {
+        candidates.push({ startLine: i, endLine: j });
+        break;
+      }
+    }
+  }
+  if (candidates.length === 0) return;
+  const computeSimilarity = (startLine, endLine) => {
+    const actualBlockSize = endLine - startLine + 1;
+    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
+    if (linesToCheck <= 0) return 1;
+    let similarity = 0;
+    for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
+      const originalLine = originalLines[startLine + j].trim();
+      const searchLine = searchLines[j].trim();
+      const maxLen = Math.max(originalLine.length, searchLine.length);
+      if (maxLen === 0) continue;
+      const distance = levenshtein(originalLine, searchLine);
+      similarity += (1 - distance / maxLen) / linesToCheck;
+    }
+    return similarity;
+  };
+  const extractBlock = (startLine, endLine) => {
+    let matchStartIndex = 0;
+    for (let k = 0; k < startLine; k++) matchStartIndex += originalLines[k].length + 1;
+    let matchEndIndex = matchStartIndex;
+    for (let k = startLine; k <= endLine; k++) {
+      matchEndIndex += originalLines[k].length;
+      if (k < endLine) matchEndIndex += 1;
+    }
+    return content.substring(matchStartIndex, matchEndIndex);
+  };
+  if (candidates.length === 1) {
+    const { startLine, endLine } = candidates[0];
+    if (computeSimilarity(startLine, endLine) >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+      yield extractBlock(startLine, endLine);
+    }
+    return;
+  }
+  let bestMatch = null;
+  let maxSimilarity = -1;
+  for (const candidate of candidates) {
+    const similarity = computeSimilarity(candidate.startLine, candidate.endLine);
+    if (similarity > maxSimilarity) {
+      maxSimilarity = similarity;
+      bestMatch = candidate;
+    }
+  }
+  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+    yield extractBlock(bestMatch.startLine, bestMatch.endLine);
+  }
+};
+var WhitespaceNormalizedReplacer = function* (content, find) {
+  const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+  const normalizedFind = normalizeWhitespace(find);
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (normalizeWhitespace(line) === normalizedFind) {
+      yield line;
+    } else {
+      const normalizedLine = normalizeWhitespace(line);
+      if (normalizedLine.includes(normalizedFind)) {
+        const words = find.trim().split(/\s+/);
+        if (words.length > 0) {
+          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+          try {
+            const regex = new RegExp(pattern);
+            const match = line.match(regex);
+            if (match) yield match[0];
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  const findLines = find.split("\n");
+  if (findLines.length > 1) {
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+      const block = lines.slice(i, i + findLines.length);
+      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
+        yield block.join("\n");
+      }
+    }
+  }
+};
+var IndentationFlexibleReplacer = function* (content, find) {
+  const removeIndentation = (text) => {
+    const lines = text.split("\n");
+    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+    if (nonEmptyLines.length === 0) return text;
+    const minIndent = Math.min(
+      ...nonEmptyLines.map((line) => {
+        const match = line.match(/^(\s*)/);
+        return match ? match[1].length : 0;
+      })
+    );
+    return lines.map((line) => line.trim().length === 0 ? line : line.slice(minIndent)).join("\n");
+  };
+  const normalizedFind = removeIndentation(find);
+  const contentLines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+    const block = contentLines.slice(i, i + findLines.length).join("\n");
+    if (removeIndentation(block) === normalizedFind) {
+      yield block;
+    }
+  }
+};
+var EscapeNormalizedReplacer = function* (content, find) {
+  const unescapeString = (str) => {
+    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match, capturedChar) => {
+      switch (capturedChar) {
+        case "n":
+          return "\n";
+        case "t":
+          return "	";
+        case "r":
+          return "\r";
+        case "'":
+          return "'";
+        case '"':
+          return '"';
+        case "`":
+          return "`";
+        case "\\":
+          return "\\";
+        case "\n":
+          return "\n";
+        case "$":
+          return "$";
+        default:
+          return match;
+      }
+    });
+  };
+  const unescapedFind = unescapeString(find);
+  if (content.includes(unescapedFind)) {
+    yield unescapedFind;
+  }
+  const lines = content.split("\n");
+  const findLines = unescapedFind.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    if (unescapeString(block) === unescapedFind) {
+      yield block;
+    }
+  }
+};
+var TrimmedBoundaryReplacer = function* (content, find) {
+  const trimmedFind = find.trim();
+  if (trimmedFind === find) return;
+  if (content.includes(trimmedFind)) {
+    yield trimmedFind;
+  }
+  const lines = content.split("\n");
+  const findLines = find.split("\n");
+  for (let i = 0; i <= lines.length - findLines.length; i++) {
+    const block = lines.slice(i, i + findLines.length).join("\n");
+    if (block.trim() === trimmedFind) {
+      yield block;
+    }
+  }
+};
+var ContextAwareReplacer = function* (content, find) {
+  const findLines = find.split("\n");
+  if (findLines.length < 3) return;
+  if (findLines[findLines.length - 1] === "") findLines.pop();
+  const contentLines = content.split("\n");
+  const firstLine = findLines[0].trim();
+  const lastLine = findLines[findLines.length - 1].trim();
+  for (let i = 0; i < contentLines.length; i++) {
+    if (contentLines[i].trim() !== firstLine) continue;
+    for (let j = i + 2; j < contentLines.length; j++) {
+      if (contentLines[j].trim() === lastLine) {
+        const blockLines = contentLines.slice(i, j + 1);
+        if (blockLines.length === findLines.length) {
+          let matchingLines = 0;
+          let totalNonEmptyLines = 0;
+          for (let k = 1; k < blockLines.length - 1; k++) {
+            const blockLine = blockLines[k].trim();
+            const findLine = findLines[k].trim();
+            if (blockLine.length > 0 || findLine.length > 0) {
+              totalNonEmptyLines++;
+              if (blockLine === findLine) matchingLines++;
+            }
+          }
+          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
+            yield blockLines.join("\n");
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+};
+var MultiOccurrenceReplacer = function* (content, find) {
+  let startIndex = 0;
+  while (true) {
+    const index = content.indexOf(find, startIndex);
+    if (index === -1) break;
+    yield find;
+    startIndex = index + find.length;
+  }
+};
+var REPLACERS = [
+  SimpleReplacer,
+  LineTrimmedReplacer,
+  BlockAnchorReplacer,
+  WhitespaceNormalizedReplacer,
+  IndentationFlexibleReplacer,
+  EscapeNormalizedReplacer,
+  TrimmedBoundaryReplacer,
+  ContextAwareReplacer,
+  MultiOccurrenceReplacer
+];
+function smartReplace(content, oldString, newString, replaceAll = false) {
+  if (oldString === newString) {
+    throw new Error("No changes to apply: oldString and newString are identical.");
+  }
+  let notFound = true;
+  for (const replacer of REPLACERS) {
+    for (const search of replacer(content, oldString)) {
+      const index = content.indexOf(search);
+      if (index === -1) continue;
+      notFound = false;
+      if (replaceAll) {
+        return content.replaceAll(search, newString);
+      }
+      const lastIndex = content.lastIndexOf(search);
+      if (index !== lastIndex) continue;
+      return content.substring(0, index) + newString + content.substring(index + search.length);
+    }
+  }
+  if (notFound) {
+    throw new Error(
+      "oldString not found in content. It must match the file contents exactly, including whitespace, indentation, and line endings."
+    );
+  }
+  throw new Error(
+    "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match."
+  );
+}
 var apply_patch = async function(input, projectCwd) {
-  const { file_path, new_string, old_string } = input;
+  const { file_path, new_string, old_string, replaceAll: shouldReplaceAll = false } = input;
   try {
     if (!file_path) {
       return {
@@ -570,6 +1042,22 @@ var apply_patch = async function(input, projectCwd) {
     const file = Bun.file(absolute_file_path);
     const exists = await file.exists();
     if (!exists) {
+      if (old_string === "") {
+        const { mkdir: mkdir2 } = await import('fs/promises');
+        const path17 = await import('path');
+        await mkdir2(path17.dirname(absolute_file_path), { recursive: true });
+        await Bun.write(absolute_file_path, new_string);
+        const diffStats = calculateDiffStats("", new_string);
+        return {
+          success: true,
+          isNewFile: true,
+          old_string: "",
+          new_string,
+          linesAdded: diffStats.linesAdded,
+          linesRemoved: diffStats.linesRemoved,
+          message: `Created new file: ${file_path}`
+        };
+      }
       return {
         success: false,
         message: `File not found: ${file_path}`,
@@ -586,22 +1074,31 @@ var apply_patch = async function(input, projectCwd) {
         error: "READ_ERROR"
       };
     }
-    if (!fileContent.includes(old_string)) {
-      return {
-        success: false,
-        message: `old_string not found in file: ${file_path}`,
-        error: "STRING_NOT_FOUND"
-      };
-    }
-    const occurrences = fileContent.split(old_string).length - 1;
-    if (occurrences > 1) {
+    let newContent;
+    try {
+      newContent = smartReplace(fileContent, old_string, new_string, shouldReplaceAll);
+    } catch (err) {
+      if (err.message.includes("not found")) {
+        return {
+          success: false,
+          message: `old_string not found in file: ${file_path}. Ensure it matches the file contents exactly, including whitespace and indentation.`,
+          error: "STRING_NOT_FOUND"
+        };
+      }
+      if (err.message.includes("multiple matches")) {
+        const occurrences = fileContent.split(old_string).length - 1;
+        return {
+          success: false,
+          message: `old_string appears ${occurrences > 1 ? occurrences + " times" : "multiple times (via fuzzy match)"} in the file. Provide more surrounding context to make it unique, or set replaceAll to true.`,
+          error: "STRING_NOT_UNIQUE"
+        };
+      }
       return {
         success: false,
-        message: `old_string appears ${occurrences} times in the file. It must be unique. Please include more context to make it unique.`,
-        error: "STRING_NOT_UNIQUE"
+        message: err.message,
+        error: "REPLACE_ERROR"
       };
     }
-    const newContent = fileContent.replace(old_string, new_string);
     try {
       await Bun.write(absolute_file_path, newContent);
       const diffStats = calculateDiffStats(fileContent, newContent);
@@ -635,11 +1132,18 @@ var CODE_DIR = path10__default.default.join(AMA_DIR, "code");
 var STORAGE_DIR = path10__default.default.join(AMA_DIR, "storage");
 zod.z.object({
   target_file: zod.z.string().describe("The relative path to the file to modify. The tool will create any directories in the path that don't exist"),
-  content: zod.z.string().describe("The content to write to the file"),
-  providedNewFile: zod.z.boolean().describe("The new file content to write to the file").optional()
+  content: zod.z.string().describe("The full content to write to the file"),
+  providedNewFile: zod.z.boolean().describe("Whether this is a new file (true) or an edit to an existing file (false). Auto-detected if omitted.").optional()
 });
 var editFiles = async function(input, projectCwd) {
   const { target_file, content, providedNewFile } = input;
+  if (!target_file) {
+    return {
+      success: false,
+      error: "Missing required parameter: target_file",
+      message: "target_file is required"
+    };
+  }
   try {
     if (projectCwd) {
       const validation = validatePath(target_file, projectCwd);
@@ -654,7 +1158,7 @@ var editFiles = async function(input, projectCwd) {
     const basePath = projectCwd || process.cwd();
     const filePath = resolveProjectPath(target_file, basePath);
     const dirPath = path10__default.default.dirname(filePath);
-    await fs8.mkdir(dirPath, { recursive: true });
+    await fsp.mkdir(dirPath, { recursive: true });
     let isNewFile = providedNewFile;
     let existingContent = "";
     const file = Bun.file(filePath);
@@ -674,6 +1178,15 @@ var editFiles = async function(input, projectCwd) {
         isNewFile = true;
       }
     }
+    if (!isNewFile && existingContent === content) {
+      return {
+        success: true,
+        isNewFile: false,
+        message: `No changes needed: ${target_file} (content identical)`,
+        linesAdded: 0,
+        linesRemoved: 0
+      };
+    }
     await Bun.write(filePath, content);
     const diffStats = calculateDiffStats(existingContent, content);
     if (isNewFile) {
@@ -682,7 +1195,7 @@ var editFiles = async function(input, projectCwd) {
         isNewFile: true,
         old_string: "",
         new_string: content,
-        message: `Created new file: ${target_file}`,
+        message: `Created new file: ${target_file} (+${diffStats.linesAdded} lines)`,
         linesAdded: diffStats.linesAdded,
         linesRemoved: diffStats.linesRemoved
       };
@@ -692,7 +1205,7 @@ var editFiles = async function(input, projectCwd) {
         isNewFile: false,
         old_string: existingContent,
         new_string: content,
-        message: `Modified file: ${target_file}`,
+        message: `Modified file: ${target_file} (+${diffStats.linesAdded} -${diffStats.linesRemoved} lines)`,
         linesAdded: diffStats.linesAdded,
         linesRemoved: diffStats.linesRemoved
       };
@@ -757,7 +1270,7 @@ var deleteFile = async function(input, projectCwd) {
       };
     }
     try {
-      await fs8.unlink(absolute_file_path);
+      await fsp.unlink(absolute_file_path);
     } catch {
       return {
         success: false,
@@ -780,7 +1293,8 @@ var deleteFile = async function(input, projectCwd) {
 };
 var GREP_LIMITS = {
   DEFAULT_MAX_MATCHES: 200,
-  MAX_LINE_LENGTH: 500,
+  MAX_LINE_LENGTH: 2e3,
+  // aligned with OpenCode's 2000-char truncation
   MAX_TOTAL_OUTPUT_SIZE: 1 * 1024 * 1024,
   EXECUTION_TIMEOUT_MS: 15e3,
   TRUNCATION_MESSAGE: "\n[Results truncated due to size limits. Use more specific patterns or file filters to narrow your search.]"
@@ -788,11 +1302,11 @@ var GREP_LIMITS = {
 zod.z.object({
   query: zod.z.string().describe("The regex pattern to search for"),
   options: zod.z.object({
-    includePattern: zod.z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts")'),
+    includePattern: zod.z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts", "*.{ts,tsx}")'),
     excludePattern: zod.z.string().optional().describe("Glob pattern for files to exclude"),
     caseSensitive: zod.z.boolean().optional().describe("Whether the search should be case sensitive"),
     path: zod.z.string().optional().describe("Subdirectory to search in"),
-    sortByMtime: zod.z.boolean().optional().describe("Sort results by file modification time (default: false)")
+    sortByMtime: zod.z.boolean().optional().describe("Sort results by file modification time (default: true)")
   }).optional()
 });
 var _cachedRgPath = null;
@@ -804,7 +1318,7 @@ async function getRipgrepPath() {
     "/usr/bin/rg"
   ];
   for (const rgPath of paths) {
-    if (fs10__default.default.existsSync(rgPath)) {
+    if (fs11__default.default.existsSync(rgPath)) {
       _cachedRgPath = rgPath;
       return rgPath;
     }
@@ -838,7 +1352,7 @@ var grepTool = async function(input, projectCwd) {
     };
   }
   try {
-    const { includePattern, excludePattern, caseSensitive, path: subPath, sortByMtime = false } = options || {};
+    const { includePattern, excludePattern, caseSensitive, path: subPath, sortByMtime = true } = options || {};
     let searchDir = projectCwd || process.cwd();
     if (subPath) {
       searchDir = path10__default.default.isAbsolute(subPath) ? subPath : path10__default.default.resolve(searchDir, subPath);
@@ -853,7 +1367,7 @@ var grepTool = async function(input, projectCwd) {
         }
       }
     }
-    if (!fs10__default.default.existsSync(searchDir)) {
+    if (!fs11__default.default.existsSync(searchDir)) {
       return {
         success: false,
         message: `Directory not found: ${searchDir}`,
@@ -862,12 +1376,15 @@ var grepTool = async function(input, projectCwd) {
     }
     const rgPath = await getRipgrepPath();
     const args2 = [
-      "-n",
-      "--with-filename",
-      "--no-heading",
+      "-nH",
+      // line numbers + filename (compact form, matching OpenCode)
+      "--hidden",
+      // search hidden files (aligned with OpenCode)
+      "--no-messages",
+      // suppress error messages for unreadable files
       "--color=never",
       "--max-count=100",
-      "--max-columns=1000"
+      "--max-columns=2000"
     ];
     if (!caseSensitive) {
       args2.push("-i");
@@ -887,6 +1404,7 @@ var grepTool = async function(input, projectCwd) {
     args2.push("--glob", "!package-lock.json");
     args2.push("--glob", "!yarn.lock");
     args2.push("--glob", "!bun.lockb");
+    args2.push("--glob", "!pnpm-lock.yaml");
     args2.push("--regexp", query);
     args2.push(searchDir);
     const proc = Bun.spawn([rgPath, ...args2], {
@@ -919,7 +1437,7 @@ var grepTool = async function(input, projectCwd) {
         message: `No matches found for pattern: ${query}`
       };
     }
-    if (exitCode !== 0) {
+    if (exitCode !== 0 && exitCode !== 2) {
       return {
         success: false,
         message: `Ripgrep error: ${stderr || "Unknown error"}`,
@@ -1005,8 +1523,7 @@ var grepTool = async function(input, projectCwd) {
 };
 zod.z.object({
   pattern: zod.z.string().describe('Glob pattern to match files (e.g., "**/*.js", "src/**/*.ts", "*.json"). Supports standard glob syntax with *, **, and ? wildcards'),
-  path: zod.z.string().optional().describe("Optional relative directory path within the project to limit the search scope. If not provided, searches from the project root"),
-  sortByMtime: zod.z.boolean().optional().describe("Sort results by modification time (default: false \u2014 faster without I/O)")
+  path: zod.z.string().optional().describe("Optional directory path to limit the search scope. If not provided, searches from the project root")
 });
 var RESULT_LIMIT = 100;
 var MTIME_BATCH_SIZE = 50;
@@ -1025,7 +1542,7 @@ async function getMtimesBatched2(files) {
   return results;
 }
 var globTool = async function(input, projectCwd) {
-  const { pattern, path: inputPath, sortByMtime = false } = input;
+  const { pattern, path: inputPath } = input;
   if (!pattern) {
     return {
       success: false,
@@ -1036,7 +1553,7 @@ var globTool = async function(input, projectCwd) {
   try {
     const basePath = projectCwd || process.cwd();
     const searchPath = inputPath ? resolveProjectPath(inputPath, basePath) : basePath;
-    if (!fs10__default.default.existsSync(searchPath)) {
+    if (!fs11__default.default.existsSync(searchPath)) {
       return {
         success: false,
         message: `Directory not found: ${searchPath}`,
@@ -1072,7 +1589,7 @@ var globTool = async function(input, projectCwd) {
       files.push(match);
     }
     let sortedFiles;
-    if (sortByMtime && files.length > 0) {
+    if (files.length > 0) {
       const filesWithMtime = await getMtimesBatched2(files);
       filesWithMtime.sort((a, b) => b.mtime - a.mtime);
       sortedFiles = filesWithMtime.map((f) => f.path);
@@ -1109,7 +1626,7 @@ var globTool = async function(input, projectCwd) {
     };
   }
 };
-var IGNORE_PATTERNS = [
+var DEFAULT_IGNORE_PATTERNS = [
   "node_modules",
   "__pycache__",
   ".git",
@@ -1141,18 +1658,19 @@ var IGNORE_PATTERNS = [
 var RESULT_LIMIT2 = 500;
 var MTIME_BATCH_SIZE2 = 50;
 zod.z.object({
-  path: zod.z.string().optional().describe("Relative path to the directory to list"),
+  path: zod.z.string().optional().describe("Path to the directory to list"),
   recursive: zod.z.boolean().optional().describe("Whether to list files recursively (default: true)"),
   maxDepth: zod.z.number().optional().describe("Maximum recursion depth (default: 3)"),
   pattern: zod.z.string().optional().describe("File extension (e.g., '.ts') or glob-like pattern"),
   showHidden: zod.z.boolean().optional().describe("Whether to show hidden files (default: false)"),
-  includeMetadata: zod.z.boolean().optional().describe("Whether to fetch file metadata like mtime (default: false \u2014 faster without I/O)")
+  includeMetadata: zod.z.boolean().optional().describe("Whether to fetch file metadata like mtime (default: false -- faster without I/O)"),
+  ignore: zod.z.array(zod.z.string()).optional().describe("Additional glob patterns to ignore (added to default ignore list)")
 });
-function shouldIgnore(name, showHidden) {
+function shouldIgnore(name, showHidden, ignoreSet) {
   if (!showHidden && name.startsWith(".") && name !== ".") {
     return true;
   }
-  return IGNORE_PATTERNS.includes(name);
+  return ignoreSet.has(name);
 }
 function matchPattern(name, pattern) {
   if (!pattern) return true;
@@ -1218,7 +1736,8 @@ var list = async function(input, projectCwd) {
     maxDepth = 3,
     pattern,
     showHidden = false,
-    includeMetadata = false
+    includeMetadata = false,
+    ignore: extraIgnore
   } = input;
   if (maxDepth !== void 0 && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
     return {
@@ -1240,14 +1759,14 @@ var list = async function(input, projectCwd) {
         };
       }
     }
-    if (!fs10__default.default.existsSync(absolutePath)) {
+    if (!fs11__default.default.existsSync(absolutePath)) {
       return {
         success: false,
         message: `Directory not found: ${absolutePath}`,
         error: "DIR_NOT_FOUND"
       };
     }
-    const stats = fs10__default.default.statSync(absolutePath);
+    const stats = fs11__default.default.statSync(absolutePath);
     if (!stats.isDirectory()) {
       return {
         success: false,
@@ -1255,6 +1774,12 @@ var list = async function(input, projectCwd) {
         error: "NOT_A_DIRECTORY"
       };
     }
+    const ignoreSet = new Set(DEFAULT_IGNORE_PATTERNS);
+    if (extraIgnore && extraIgnore.length > 0) {
+      for (const pat of extraIgnore) {
+        ignoreSet.add(pat);
+      }
+    }
     const collected = [];
     let truncated = false;
     const walk = async (currentDir, depth) => {
@@ -1264,7 +1789,7 @@ var list = async function(input, projectCwd) {
       }
       let entries;
       try {
-        entries = fs10__default.default.readdirSync(currentDir, { withFileTypes: true });
+        entries = fs11__default.default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -1279,7 +1804,7 @@ var list = async function(input, projectCwd) {
           truncated = true;
           break;
         }
-        if (shouldIgnore(entry.name, showHidden)) {
+        if (shouldIgnore(entry.name, showHidden, ignoreSet)) {
           continue;
         }
         const entryAbsolutePath = path10__default.default.join(currentDir, entry.name);
@@ -1379,10 +1904,10 @@ var CREDENTIALS_DIR = path10__default.default.join(os3__default.default.homedir(
 var CREDENTIALS_PATH = path10__default.default.join(CREDENTIALS_DIR, "credentials.json");
 function isAuthenticated() {
   try {
-    if (!fs10__default.default.existsSync(CREDENTIALS_PATH)) {
+    if (!fs11__default.default.existsSync(CREDENTIALS_PATH)) {
       return false;
     }
-    const raw = fs10__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs11__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return Boolean(data && data.access_token);
   } catch {
@@ -1391,10 +1916,10 @@ function isAuthenticated() {
 }
 function saveTokens(tokens) {
   try {
-    if (!fs10__default.default.existsSync(CREDENTIALS_DIR)) {
-      fs10__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    if (!fs11__default.default.existsSync(CREDENTIALS_DIR)) {
+      fs11__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
     }
-    fs10__default.default.writeFileSync(
+    fs11__default.default.writeFileSync(
       CREDENTIALS_PATH,
       JSON.stringify(tokens, null, 2),
       "utf8"
@@ -1405,18 +1930,18 @@ function saveTokens(tokens) {
 }
 function logout() {
   try {
-    if (fs10__default.default.existsSync(CREDENTIALS_PATH)) {
-      fs10__default.default.unlinkSync(CREDENTIALS_PATH);
+    if (fs11__default.default.existsSync(CREDENTIALS_PATH)) {
+      fs11__default.default.unlinkSync(CREDENTIALS_PATH);
     }
   } catch (error) {
     console.error(pc5__default.default.red("Failed to logout"), error);
   }
 }
 function getTokens() {
-  if (!fs10__default.default.existsSync(CREDENTIALS_PATH)) {
+  if (!fs11__default.default.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs10__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs11__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
@@ -1515,10 +2040,10 @@ async function login() {
 }
 var getUserId = () => {
   try {
-    if (!fs10__default.default.existsSync(CREDENTIALS_PATH)) {
+    if (!fs11__default.default.existsSync(CREDENTIALS_PATH)) {
       return;
     }
-    const raw = fs10__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs11__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     const fromUserObject = data.user?.id;
     const fromTopLevel = data.sub ?? data.user_id;
@@ -1544,26 +2069,20 @@ var getUserId = () => {
   }
 };
 var ExplanationSchema = zod.z.object({
-  explanation: zod.z.string().describe("One sentence explanation as to why this tool is being used")
+  description: zod.z.string().describe(
+    "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'"
+  )
 });
 var BLOCKED_PATTERNS = [
-  // rm with -r/-f flags (combined or separate) targeting /, ~, $HOME, or *
   /\brm\s+(-\w+\s+)*(\/ |\/\s*$|~|\/\*|\*)/,
-  // Disk-wiping commands
   /\bdd\s+.*of=\/dev\//,
   /\bmkfs\b/,
-  // Fork bomb
   /:\(\)\{.*\|.*&\}\s*;?\s*:/,
-  // Recursive chmod/chown on root
   /\bchmod\s+.*-R.*\s+\/\s*$/,
   /\bchown\s+.*-R.*\s+\/\s*$/,
-  // Pipe from remote URL directly into shell
   /\b(curl|wget)\s+.*\|\s*(ba)?sh/,
-  // Move root filesystem
   /\bmv\s+(\/|\*)\s/,
-  // Write random data to disk device
   /\bcat\s+\/dev\/(u?random|zero)\s*>\s*\/dev\//,
-  // Windows-specific destructive
   /\bformat\s+[A-Z]:/i,
   /\bdiskpart\b/i,
   /\bcipher\s+\/w:/i
@@ -1574,6 +2093,7 @@ var DANGEROUS_FLAGS = [
   /\bgit\s+push\s+-f\b/
 ];
 var MAX_OUTPUT_SIZE = 1 * 1024 * 1024;
+var DEFAULT_TIMEOUT = 12e4;
 function evaluateCommandSafety(command) {
   const trimmed = command.trim();
   for (const pattern of BLOCKED_PATTERNS) {
@@ -1589,8 +2109,10 @@ function evaluateCommandSafety(command) {
   return { safe: true };
 }
 zod.z.object({
-  command: zod.z.string().describe("The terminal command to execute (e.g., 'ls -la', 'pwd', 'echo $HOME')"),
-  is_background: zod.z.boolean().describe("Whether the command should be run in the background")
+  command: zod.z.string().describe("The terminal command to execute"),
+  is_background: zod.z.boolean().optional().default(false).describe("Whether the command should be run in the background"),
+  timeout: zod.z.number().optional().describe("Optional timeout in milliseconds. If not specified, commands will time out after 120000ms (2 minutes)."),
+  workdir: zod.z.string().optional().describe("The working directory to run the command in. Defaults to the project directory. Use this instead of 'cd' commands.")
 }).merge(ExplanationSchema);
 var runSecureTerminalCommand = async (command, timeout, cwd) => {
   try {
@@ -1647,7 +2169,7 @@ var runSecureTerminalCommand = async (command, timeout, cwd) => {
     };
   }
 };
-var runTerminalCommand = async (input, projectCwd) => {
+var bashTool = async (input, projectCwd) => {
   try {
     const safety = evaluateCommandSafety(input.command);
     if (!safety.safe) {
@@ -1658,9 +2180,18 @@ var runTerminalCommand = async (input, projectCwd) => {
         error: "BLOCKED_COMMAND"
       };
     }
+    if (input.timeout !== void 0 && input.timeout < 0) {
+      return {
+        success: false,
+        message: `Invalid timeout value: ${input.timeout}. Timeout must be a positive number.`,
+        error: "INVALID_TIMEOUT"
+      };
+    }
+    const cwd = input.workdir || projectCwd || process.cwd();
+    const timeout = input.timeout ?? DEFAULT_TIMEOUT;
     if (input?.is_background) {
       const proc = Bun.spawn(["sh", "-c", input.command], {
-        cwd: projectCwd || process.cwd(),
+        cwd,
         stdout: "ignore",
         stderr: "ignore"
       });
@@ -1674,8 +2205,8 @@ var runTerminalCommand = async (input, projectCwd) => {
     } else {
       const result = await runSecureTerminalCommand(
         input.command,
-        3e4,
-        projectCwd
+        timeout,
+        cwd
       );
       if (result?.error && !result?.exitCode) {
         return result;
@@ -1706,14 +2237,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs10__default.default.existsSync(REGISTRY_FILE)) {
-        const data = fs10__default.default.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs11__default.default.existsSync(REGISTRY_FILE)) {
+        const data = fs11__default.default.readFileSync(REGISTRY_FILE, "utf8");
         const parsed = JSON.parse(data);
         if (!Array.isArray(parsed)) {
           console.error("Invalid project registry format: expected array, got", typeof parsed);
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs10__default.default.copyFileSync(REGISTRY_FILE, backupFile);
-          fs10__default.default.unlinkSync(REGISTRY_FILE);
+          fs11__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs11__default.default.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -1726,11 +2257,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs10__default.default.existsSync(REGISTRY_FILE)) {
+      if (fs11__default.default.existsSync(REGISTRY_FILE)) {
         try {
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs10__default.default.copyFileSync(REGISTRY_FILE, backupFile);
-          fs10__default.default.unlinkSync(REGISTRY_FILE);
+          fs11__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs11__default.default.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -1739,11 +2270,11 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs10__default.default.existsSync(AMA_DIR)) {
-        fs10__default.default.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs11__default.default.existsSync(AMA_DIR)) {
+        fs11__default.default.mkdirSync(AMA_DIR, { recursive: true });
       }
       const projects = Array.from(this.projects.values());
-      fs10__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+      fs11__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
     } catch (error) {
       console.error("Failed to save project registry:", error);
     }
@@ -1783,7 +2314,7 @@ var ProjectRegistry = class {
 var projectRegistry = new ProjectRegistry();
 var ignoreFiles = ["node_modules", ".git", ".next", ".env", ".env.local", ".env.development.local", ".env.test.local", ".env.production.local", ".output", ".turbo", ".vercel", ".next", ".tanstack", ".nitro", ".wrangler", ".alchemy", ".coverage", ".nyc_output", ".cache", "tmp", "temp", ".idea", ".vscode", ".zig-cache", "zig-out", ".coverage", "coverage", "logs", ".venv", "venv", "env", ".next", ".turbo", ".vercel", ".output", ".tanstack", ".nitro", ".wrangler", ".alchemy", ".coverage", ".nyc_output", ".cache", "tmp", "temp", ".idea", ".vscode", ".zig-cache", "zig-out", ".coverage", "coverage", "logs", ".venv", "venv", "env"];
 var getContext = (dir, base = dir, allFiles = []) => {
-  const filePath = fs10.readdirSync(dir, { withFileTypes: true });
+  const filePath = fs11.readdirSync(dir, { withFileTypes: true });
   for (const file of filePath) {
     if (ignoreFiles.includes(file.name)) continue;
     const fullPath = path10__default.default.join(dir, file.name);
@@ -1812,7 +2343,7 @@ function getWorkspaceStoragePath(ide) {
   } else {
     const capitalizedPath = path10__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
     const lowercasePath = path10__default.default.join(HOME, ".config", appNameLower, "User", "workspaceStorage");
-    if (fs10__default.default.existsSync(capitalizedPath)) {
+    if (fs11__default.default.existsSync(capitalizedPath)) {
       return capitalizedPath;
     }
     return lowercasePath;
@@ -1821,16 +2352,16 @@ function getWorkspaceStoragePath(ide) {
 function scanWorkspaceStorage(ide) {
   const projects = [];
   const storagePath = getWorkspaceStoragePath(ide);
-  if (!fs10__default.default.existsSync(storagePath)) {
+  if (!fs11__default.default.existsSync(storagePath)) {
     return projects;
   }
   try {
-    const workspaces = fs10__default.default.readdirSync(storagePath);
+    const workspaces = fs11__default.default.readdirSync(storagePath);
     for (const workspace of workspaces) {
       const workspaceJsonPath = path10__default.default.join(storagePath, workspace, "workspace.json");
-      if (fs10__default.default.existsSync(workspaceJsonPath)) {
+      if (fs11__default.default.existsSync(workspaceJsonPath)) {
         try {
-          const content = fs10__default.default.readFileSync(workspaceJsonPath, "utf-8");
+          const content = fs11__default.default.readFileSync(workspaceJsonPath, "utf-8");
           const data = JSON.parse(content);
           if (data.folder && typeof data.folder === "string") {
             let projectPath = data.folder;
@@ -1838,7 +2369,7 @@ function scanWorkspaceStorage(ide) {
               projectPath = projectPath.replace("file://", "");
               projectPath = decodeURIComponent(projectPath);
             }
-            if (fs10__default.default.existsSync(projectPath) && fs10__default.default.statSync(projectPath).isDirectory()) {
+            if (fs11__default.default.existsSync(projectPath) && fs11__default.default.statSync(projectPath).isDirectory()) {
               projects.push({
                 name: path10__default.default.basename(projectPath),
                 path: projectPath,
@@ -1862,11 +2393,11 @@ var scanIdeProjects = async () => {
     const seenPaths = /* @__PURE__ */ new Set();
     const addProject = (projectPath, ide) => {
       try {
-        const resolvedPath = fs10__default.default.realpathSync(projectPath);
-        if (fs10__default.default.existsSync(resolvedPath) && fs10__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+        const resolvedPath = fs11__default.default.realpathSync(projectPath);
+        if (fs11__default.default.existsSync(resolvedPath) && fs11__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
           const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
             try {
-              return fs10__default.default.realpathSync(ideDir) === resolvedPath;
+              return fs11__default.default.realpathSync(ideDir) === resolvedPath;
             } catch {
               return false;
             }
@@ -1893,30 +2424,30 @@ var scanIdeProjects = async () => {
     }
     for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
       if (ide === "cursor" || ide === "vscode") continue;
-      if (fs10__default.default.existsSync(dirPath)) {
-        const projects = fs10__default.default.readdirSync(dirPath);
+      if (fs11__default.default.existsSync(dirPath)) {
+        const projects = fs11__default.default.readdirSync(dirPath);
         projects.forEach((project) => {
           const projectPath = path10__default.default.join(dirPath, project);
           try {
-            const stats = fs10__default.default.lstatSync(projectPath);
+            const stats = fs11__default.default.lstatSync(projectPath);
             let actualPath = null;
             if (stats.isSymbolicLink()) {
-              actualPath = fs10__default.default.realpathSync(projectPath);
+              actualPath = fs11__default.default.realpathSync(projectPath);
             } else if (stats.isFile()) {
               try {
-                let content = fs10__default.default.readFileSync(projectPath, "utf-8").trim();
+                let content = fs11__default.default.readFileSync(projectPath, "utf-8").trim();
                 if (content.startsWith("~/") || content === "~") {
                   content = content.replace(/^~/, HOME);
                 }
                 const resolvedContent = path10__default.default.isAbsolute(content) ? content : path10__default.default.resolve(path10__default.default.dirname(projectPath), content);
-                if (fs10__default.default.existsSync(resolvedContent) && fs10__default.default.statSync(resolvedContent).isDirectory()) {
-                  actualPath = fs10__default.default.realpathSync(resolvedContent);
+                if (fs11__default.default.existsSync(resolvedContent) && fs11__default.default.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs11__default.default.realpathSync(resolvedContent);
                 }
               } catch {
                 return;
               }
             } else if (stats.isDirectory()) {
-              actualPath = fs10__default.default.realpathSync(projectPath);
+              actualPath = fs11__default.default.realpathSync(projectPath);
             }
             if (actualPath) {
               addProject(actualPath, ide);
@@ -1974,8 +2505,8 @@ var Snapshot;
     const worktree = project.cwd;
     const git = gitdir(projectId);
     try {
-      await fs8__default.default.mkdir(git, { recursive: true });
-      const gitExists = await fs8__default.default.access(path10__default.default.join(git, "HEAD")).then(() => true).catch(() => false);
+      await fsp__namespace.default.mkdir(git, { recursive: true });
+      const gitExists = await fsp__namespace.default.access(path10__default.default.join(git, "HEAD")).then(() => true).catch(() => false);
       if (!gitExists) {
         await runGit(`git init`, {
           env: { GIT_DIR: git, GIT_WORK_TREE: worktree }
@@ -2060,7 +2591,7 @@ var Snapshot;
         for (const file of newFiles) {
           const fullPath = path10__default.default.join(worktree, file);
           try {
-            await fs8__default.default.unlink(fullPath);
+            await fsp__namespace.default.unlink(fullPath);
             log.info("deleted newly created file", { file: fullPath });
           } catch {
           }
@@ -2097,7 +2628,7 @@ var Snapshot;
             log.info("file existed in snapshot but checkout failed, keeping", { file });
           } else {
             log.info("file did not exist in snapshot, deleting", { file });
-            await fs8__default.default.unlink(file).catch(() => {
+            await fsp__namespace.default.unlink(file).catch(() => {
             });
           }
         }
@@ -2151,10 +2682,10 @@ var Snapshot;
     const lines = numstatResult.stdout.trim().split("\n").filter(Boolean);
     for (const line of lines) {
       const [additions, deletions, file] = line.split("	");
-      const isBinaryFile = additions === "-" && deletions === "-";
+      const isBinaryFile2 = additions === "-" && deletions === "-";
       let before = "";
       let after = "";
-      if (!isBinaryFile) {
+      if (!isBinaryFile2) {
         const beforeResult = await runGit(
           `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" show ${from}:${file}`,
           { cwd: worktree }
@@ -2279,19 +2810,19 @@ var HTML_ERROR = (error) => `<!doctype html>
   </body>
 </html>`;
 function ensureCredentialsDir() {
-  if (!fs10__default.default.existsSync(AMA_DIR)) {
-    fs10__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs11__default.default.existsSync(AMA_DIR)) {
+    fs11__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
 }
 function saveCredentials(credentials) {
   ensureCredentialsDir();
-  fs10__default.default.writeFileSync(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2), "utf8");
+  fs11__default.default.writeFileSync(CREDENTIALS_PATH2, JSON.stringify(credentials, null, 2), "utf8");
 }
 function readCredentials() {
-  if (!fs10__default.default.existsSync(CREDENTIALS_PATH2)) {
+  if (!fs11__default.default.existsSync(CREDENTIALS_PATH2)) {
     return null;
   }
-  const raw = fs10__default.default.readFileSync(CREDENTIALS_PATH2, "utf8");
+  const raw = fs11__default.default.readFileSync(CREDENTIALS_PATH2, "utf8");
   const parsed = JSON.parse(raw);
   if (typeof parsed.accessToken !== "string" || typeof parsed.refreshToken !== "string" || typeof parsed.accountId !== "string" || typeof parsed.expiresAt !== "number") {
     return null;
@@ -2567,8 +3098,8 @@ async function getCodexStatus() {
 async function codexLogout() {
   pendingOAuth = void 0;
   stopOAuthServer();
-  if (fs10__default.default.existsSync(CREDENTIALS_PATH2)) {
-    fs10__default.default.unlinkSync(CREDENTIALS_PATH2);
+  if (fs11__default.default.existsSync(CREDENTIALS_PATH2)) {
+    fs11__default.default.unlinkSync(CREDENTIALS_PATH2);
   }
 }
 
@@ -2855,18 +3386,21 @@ var toolCallSchema = zod.z.object({
   parameters: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Parameters for the tool")
 });
 zod.z.object({
-  tool_calls: zod.z.array(toolCallSchema).min(1, "Provide at least one tool call").max(10, "Maximum of 10 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+  tool_calls: zod.z.array(toolCallSchema).min(1, "Provide at least one tool call").max(25, "Maximum of 25 tools allowed in batch").describe("Array of tool calls to execute in parallel")
 });
 var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
 var MAX_CONCURRENCY = 5;
 var PER_CALL_TIMEOUT = 3e4;
+var MAX_BATCH_SIZE = 25;
 var batchableToolExecutors = {
   deleteFile,
   grep: grepTool,
   glob: globTool,
   listDirectory: list,
   readFile: read_file,
-  runTerminalCommand
+  bash: bashTool,
+  stringReplace: apply_patch,
+  editFile: editFiles
 };
 function withTimeout(promise, ms) {
   return new Promise((resolve, reject) => {
@@ -2897,8 +3431,8 @@ async function runWithConcurrencyLimit(tasks, limit) {
 }
 var batchTool = async function(input, projectCwd) {
   const { tool_calls } = input;
-  const callsToExecute = tool_calls.slice(0, 10);
-  const discardedCalls = tool_calls.slice(10);
+  const callsToExecute = tool_calls.slice(0, MAX_BATCH_SIZE);
+  const discardedCalls = tool_calls.slice(MAX_BATCH_SIZE);
   const executeCall = async (call) => {
     const start = performance.now();
     try {
@@ -2948,7 +3482,7 @@ var batchTool = async function(input, projectCwd) {
     results.push({
       tool: call.tool,
       success: false,
-      error: "Maximum of 10 tools allowed in batch",
+      error: `Maximum of ${MAX_BATCH_SIZE} tools allowed in batch`,
       durationMs: 0
     });
   }
@@ -2983,7 +3517,7 @@ var TOOL_TIMEOUTS = {
   editFile: 15e3,
   deleteFile: 1e4,
   stringReplace: 15e3,
-  runTerminalCommand: 6e4,
+  bash: 6e4,
   batch: 12e4
 };
 function getTimeoutForTool(tool) {
@@ -3096,7 +3630,7 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand,
+  bash: bashTool,
   batch: batchTool
 };
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
@@ -3232,20 +3766,20 @@ function getCodeServerBin() {
 }
 function isCodeServerInstalled() {
   const binPath = getCodeServerBin();
-  return fs10__default.default.existsSync(binPath);
+  return fs11__default.default.existsSync(binPath);
 }
 async function installCodeServer() {
   const { ext } = getPlatformInfo();
   const downloadUrl = getDownloadUrl();
   const tarballPath = path10__default.default.join(AMA_DIR, `code-server.${ext}`);
-  if (!fs10__default.default.existsSync(AMA_DIR)) {
-    fs10__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs11__default.default.existsSync(AMA_DIR)) {
+    fs11__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
-  if (!fs10__default.default.existsSync(CODE_DIR)) {
-    fs10__default.default.mkdirSync(CODE_DIR, { recursive: true });
+  if (!fs11__default.default.existsSync(CODE_DIR)) {
+    fs11__default.default.mkdirSync(CODE_DIR, { recursive: true });
   }
-  if (!fs10__default.default.existsSync(STORAGE_DIR)) {
-    fs10__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
+  if (!fs11__default.default.existsSync(STORAGE_DIR)) {
+    fs11__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
   }
   console.log(pc5__default.default.cyan(`downloading code-server v${CODE_SERVER_VERSION}...`));
   console.log(pc5__default.default.gray(downloadUrl));
@@ -3254,13 +3788,13 @@ async function installCodeServer() {
     throw new Error(`Failed to download code-server: ${response.statusText}`);
   }
   const buffer = await response.arrayBuffer();
-  await fs10__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
+  await fs11__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
   console.log(pc5__default.default.cyan("Extracting code-server..."));
   await execAsync2(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
-  await fs10__default.default.promises.unlink(tarballPath);
+  await fs11__default.default.promises.unlink(tarballPath);
   const binPath = getCodeServerBin();
-  if (fs10__default.default.existsSync(binPath)) {
-    await fs10__default.default.promises.chmod(binPath, 493);
+  if (fs11__default.default.existsSync(binPath)) {
+    await fs11__default.default.promises.chmod(binPath, 493);
   }
   console.log(pc5__default.default.green("code-server installed successfully"));
 }
@@ -3285,42 +3819,55 @@ async function killExistingCodeServer() {
 async function setupDefaultSettings() {
   const userDir = path10__default.default.join(STORAGE_DIR, "User");
   const settingsPath = path10__default.default.join(userDir, "settings.json");
-  if (!fs10__default.default.existsSync(userDir)) {
-    fs10__default.default.mkdirSync(userDir, { recursive: true });
+  if (!fs11__default.default.existsSync(userDir)) {
+    fs11__default.default.mkdirSync(userDir, { recursive: true });
   }
   const defaultSettings = {
     // Disable signature verification for Open VSX extensions
     "extensions.verifySignature": false,
-    // Theme settings
-    "workbench.colorTheme": "Min Dark",
+    // Theme
+    "workbench.colorTheme": "Vesper",
     "workbench.startupEditor": "none",
-    // Editor settings
+    // Editor
     "editor.fontSize": 14,
     "editor.fontFamily": "'JetBrains Mono', 'Fira Code', Menlo, Monaco, 'Courier New', monospace",
     "editor.minimap.enabled": false,
     "editor.wordWrap": "on",
-    // UI settings
-    "window.menuBarVisibility": "compact",
-    "workbench.activityBar.location": "top"
+    "editor.renderLineHighlight": "gutter",
+    "editor.scrollbar.vertical": "auto",
+    "editor.scrollbar.horizontal": "auto",
+    "editor.overviewRulerBorder": false,
+    "editor.hideCursorInOverviewRuler": true,
+    "editor.guides.indentation": false,
+    // Minimal UI
+    "window.menuBarVisibility": "hidden",
+    "window.commandCenter": false,
+    "workbench.layoutControl.enabled": false,
+    "workbench.activityBar.location": "default",
+    "workbench.sideBar.location": "right",
+    "workbench.editor.showTabs": "single",
+    "workbench.statusBar.visible": false,
+    "breadcrumbs.enabled": false
   };
   let existingSettings = {};
-  if (fs10__default.default.existsSync(settingsPath)) {
+  if (fs11__default.default.existsSync(settingsPath)) {
     try {
-      const content = await fs10__default.default.promises.readFile(settingsPath, "utf-8");
+      const content = await fs11__default.default.promises.readFile(settingsPath, "utf-8");
       existingSettings = JSON.parse(content);
     } catch {
     }
   }
   const mergedSettings = { ...defaultSettings, ...existingSettings };
-  mergedSettings["workbench.colorTheme"] = "Min Dark";
+  mergedSettings["workbench.colorTheme"] = "Vesper";
   mergedSettings["extensions.verifySignature"] = false;
-  await fs10__default.default.promises.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+  await fs11__default.default.promises.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
   console.log(pc5__default.default.green("ama code-server settings configured"));
 }
 async function installExtensions() {
   const binPath = getCodeServerBin();
   const extensions = [
-    "castrogusttavo.min-theme"
+    "raunofreiberg.vesper",
+    "ziterz.codesandbox-black-theme"
   ];
   for (const ext of extensions) {
     try {
@@ -3335,7 +3882,7 @@ async function installExtensions() {
 async function startCodeServer(cwd) {
   const binPath = getCodeServerBin();
   const workDir = cwd || process.cwd();
-  if (!fs10__default.default.existsSync(binPath)) {
+  if (!fs11__default.default.existsSync(binPath)) {
     throw new Error("ama code-server is not installed. Run installCodeServer() first.");
   }
   await killExistingCodeServer();
@@ -3343,12 +3890,12 @@ async function startCodeServer(cwd) {
   await installExtensions();
   const workspaceStoragePath = path10__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
   try {
-    if (fs10__default.default.existsSync(workspaceStoragePath)) {
-      await fs10__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
+    if (fs11__default.default.existsSync(workspaceStoragePath)) {
+      await fs11__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
     }
     const stateDbPath = path10__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
-    if (fs10__default.default.existsSync(stateDbPath)) {
-      await fs10__default.default.promises.unlink(stateDbPath);
+    if (fs11__default.default.existsSync(stateDbPath)) {
+      await fs11__default.default.promises.unlink(stateDbPath);
     }
   } catch {
   }
@@ -3379,11 +3926,11 @@ var __dirname$1 = path10.dirname(__filename$1);
 var DAEMON_PID_FILE = path10__default.default.join(AMA_DIR, "daemon.pid");
 var DAEMON_LOG_FILE = path10__default.default.join(AMA_DIR, "daemon.log");
 function isDaemonRunning() {
-  if (!fs10__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs11__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs10__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs11__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, 0);
     return true;
   } catch {
@@ -3391,30 +3938,30 @@ function isDaemonRunning() {
   }
 }
 function stopDaemon() {
-  if (!fs10__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs11__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs10__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs11__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, "SIGTERM");
-    fs10__default.default.unlinkSync(DAEMON_PID_FILE);
+    fs11__default.default.unlinkSync(DAEMON_PID_FILE);
     return true;
   } catch (error) {
     return false;
   }
 }
 function startDaemon() {
-  if (!fs10__default.default.existsSync(AMA_DIR)) {
-    fs10__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs11__default.default.existsSync(AMA_DIR)) {
+    fs11__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
   if (isDaemonRunning()) {
     stopDaemon();
   }
   const daemonScript = path10__default.default.join(__dirname$1, "lib", "daemon-entry.js");
-  if (!fs10__default.default.existsSync(daemonScript)) {
+  if (!fs11__default.default.existsSync(daemonScript)) {
     throw new Error(`Daemon entry script not found at: ${daemonScript}. Please rebuild the project.`);
   }
-  const logFd = fs10__default.default.openSync(DAEMON_LOG_FILE, "a");
+  const logFd = fs11__default.default.openSync(DAEMON_LOG_FILE, "a");
   const daemon = child_process.spawn(process.execPath, [daemonScript], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -3422,20 +3969,20 @@ function startDaemon() {
     cwd: process.cwd()
   });
   daemon.unref();
-  fs10__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
-  fs10__default.default.closeSync(logFd);
+  fs11__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
+  fs11__default.default.closeSync(logFd);
 }
 function getDaemonPid() {
-  if (!fs10__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs11__default.default.existsSync(DAEMON_PID_FILE)) {
     return null;
   }
   try {
-    return Number(fs10__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    return Number(fs11__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
   } catch {
     return null;
   }
 }
-var VERSION = "0.0.19";
+var VERSION = "0.0.21";
 var PROJECT_DIR = process.cwd();
 var LOGO = `
    __ _ _ __ ___   __ _ 
@@ -3632,11 +4179,11 @@ if (args[0] === "update") {
       process.exit(1);
     }
     const resolvedPath = path10__default.default.resolve(projectPath);
-    if (!fs10__default.default.existsSync(resolvedPath)) {
+    if (!fs11__default.default.existsSync(resolvedPath)) {
       console.error(pc5__default.default.red(`path does not exist: ${resolvedPath}`));
       process.exit(1);
     }
-    if (!fs10__default.default.statSync(resolvedPath).isDirectory()) {
+    if (!fs11__default.default.statSync(resolvedPath).isDirectory()) {
       console.error(pc5__default.default.red(`path is not a directory: ${resolvedPath}`));
       process.exit(1);
     }