amai 0.0.10 → 0.0.12

package/dist/cli.cjs

@@ -1,18 +1,18 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 'use strict';
 
 var pc5 = require('picocolors');
 var WebSocket = require('ws');
 var zod = require('zod');
-var fs5 = require('fs/promises');
 var path10 = require('path');
-var fs6 = require('fs');
+var fs8 = require('fs');
 var os3 = require('os');
-var child_process = require('child_process');
-var util = require('util');
+var fs7 = require('fs/promises');
 var hono = require('hono');
 var nodeServer = require('@hono/node-server');
 var cors = require('hono/cors');
+var child_process = require('child_process');
+var util = require('util');
 var url = require('url');
 var readline = require('readline');
 
@@ -21,10 +21,10 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pc5__default = /*#__PURE__*/_interopDefault(pc5);
 var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
-var fs5__default = /*#__PURE__*/_interopDefault(fs5);
 var path10__default = /*#__PURE__*/_interopDefault(path10);
-var fs6__default = /*#__PURE__*/_interopDefault(fs6);
+var fs8__default = /*#__PURE__*/_interopDefault(fs8);
 var os3__default = /*#__PURE__*/_interopDefault(os3);
+var fs7__default = /*#__PURE__*/_interopDefault(fs7);
 var readline__default = /*#__PURE__*/_interopDefault(readline);
 
 var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
@@ -42,14 +42,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs6__default.default.existsSync(REGISTRY_FILE)) {
-        const data = fs6__default.default.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs8__default.default.existsSync(REGISTRY_FILE)) {
+        const data = fs8__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();
-          fs6__default.default.copyFileSync(REGISTRY_FILE, backupFile);
-          fs6__default.default.unlinkSync(REGISTRY_FILE);
+          fs8__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs8__default.default.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -62,11 +62,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs6__default.default.existsSync(REGISTRY_FILE)) {
+      if (fs8__default.default.existsSync(REGISTRY_FILE)) {
         try {
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs6__default.default.copyFileSync(REGISTRY_FILE, backupFile);
-          fs6__default.default.unlinkSync(REGISTRY_FILE);
+          fs8__default.default.copyFileSync(REGISTRY_FILE, backupFile);
+          fs8__default.default.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -75,11 +75,11 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs6__default.default.existsSync(AMA_DIR)) {
-        fs6__default.default.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs8__default.default.existsSync(AMA_DIR)) {
+        fs8__default.default.mkdirSync(AMA_DIR, { recursive: true });
       }
       const projects = Array.from(this.projects.values());
-      fs6__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+      fs8__default.default.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
     } catch (error) {
       console.error("Failed to save project registry:", error);
     }
@@ -168,6 +168,60 @@ zod.z.object({
   ),
   end_line_one_indexed: zod.z.number().optional().describe("The one-indexed line number to end reading at (inclusive).")
 });
+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) {
+    return {
+      success: false,
+      message: `File not found: ${relative_file_path}`,
+      error: "FILE_NOT_FOUND"
+    };
+  }
+  try {
+    const fileContent = await file.text();
+    const lines = fileContent.split(/\r?\n/);
+    const totalLines = lines.length;
+    if (should_read_entire_file) {
+      return {
+        success: true,
+        message: `Successfully read entire file: ${relative_file_path} (${totalLines} lines)`,
+        content: fileContent,
+        totalLines
+      };
+    }
+    const startIndex = start_line_one_indexed - 1;
+    if (startIndex >= totalLines) {
+      return {
+        success: false,
+        message: "start_line_one_indexed must be less than or equal to the total number of lines in the file",
+        error: "INVALID_LINE_RANGE"
+      };
+    }
+    const normalizedEnd = Math.min(end_line_one_indexed, totalLines);
+    const selectedLines = lines.slice(startIndex, normalizedEnd).join("\n");
+    const linesRead = normalizedEnd - start_line_one_indexed + 1;
+    return {
+      success: true,
+      message: `Successfully read lines ${start_line_one_indexed}-${normalizedEnd} from file: ${relative_file_path} (${linesRead} lines of ${totalLines} total)`,
+      content: selectedLines,
+      totalLines
+    };
+  } 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}`,
+      error: "READ_ERROR"
+    };
+  }
+}
 var read_file = async function(input, projectCwd) {
   const { relative_file_path, should_read_entire_file, start_line_one_indexed, end_line_one_indexed } = input;
   try {
@@ -208,6 +262,7 @@ var read_file = async function(input, projectCwd) {
         };
       }
     }
+    let absolute_file_path;
     if (projectCwd) {
       const validation = validatePath(relative_file_path, projectCwd);
       if (!validation.valid) {
@@ -217,128 +272,17 @@ var read_file = async function(input, projectCwd) {
           error: "ACCESS_DENIED"
         };
       }
-      const absolute_file_path = validation.resolvedPath;
-      try {
-        const fileStats = await fs5.stat(absolute_file_path);
-        if (!fileStats.isFile()) {
-          return {
-            success: false,
-            message: `Path is not a file: ${relative_file_path}`,
-            error: "NOT_A_FILE"
-          };
-        }
-      } catch (error) {
-        if (error?.code === "ENOENT") {
-          return {
-            success: false,
-            message: `File not found: ${relative_file_path}`,
-            error: "FILE_NOT_FOUND"
-          };
-        }
-        return {
-          success: false,
-          message: `Failed to access file: ${relative_file_path}`,
-          error: "READ_ERROR"
-        };
-      }
-      try {
-        const fileContent = await fs5.readFile(absolute_file_path, "utf-8");
-        const lines = fileContent.split(/\r?\n/);
-        const totalLines = lines.length;
-        if (should_read_entire_file) {
-          return {
-            success: true,
-            message: `Successfully read entire file: ${relative_file_path} (${totalLines} lines)`,
-            content: fileContent,
-            totalLines
-          };
-        }
-        const startIndex = start_line_one_indexed - 1;
-        if (startIndex >= totalLines) {
-          return {
-            success: false,
-            message: "start_line_one_indexed must be less than or equal to the total number of lines in the file",
-            error: "INVALID_LINE_RANGE"
-          };
-        }
-        const normalizedEnd = Math.min(end_line_one_indexed, totalLines);
-        const selectedLines = lines.slice(startIndex, normalizedEnd).join("\n");
-        const linesRead = normalizedEnd - start_line_one_indexed + 1;
-        return {
-          success: true,
-          message: `Successfully read lines ${start_line_one_indexed}-${normalizedEnd} from file: ${relative_file_path} (${linesRead} lines of ${totalLines} total)`,
-          content: selectedLines,
-          totalLines
-        };
-      } catch {
-        return {
-          success: false,
-          message: `Failed to read file: ${relative_file_path}`,
-          error: "READ_ERROR"
-        };
-      }
+      absolute_file_path = validation.resolvedPath;
     } else {
-      const absolute_file_path = path10__default.default.resolve(relative_file_path);
-      try {
-        const fileStats = await fs5.stat(absolute_file_path);
-        if (!fileStats.isFile()) {
-          return {
-            success: false,
-            message: `Path is not a file: ${relative_file_path}`,
-            error: "NOT_A_FILE"
-          };
-        }
-      } catch (error) {
-        if (error?.code === "ENOENT") {
-          return {
-            success: false,
-            message: `File not found: ${relative_file_path}`,
-            error: "FILE_NOT_FOUND"
-          };
-        }
-        return {
-          success: false,
-          message: `Failed to access file: ${relative_file_path}`,
-          error: "READ_ERROR"
-        };
-      }
-      try {
-        const fileContent = await fs5.readFile(absolute_file_path, "utf-8");
-        const lines = fileContent.split(/\r?\n/);
-        const totalLines = lines.length;
-        if (should_read_entire_file) {
-          return {
-            success: true,
-            message: `Successfully read entire file: ${relative_file_path} (${totalLines} lines)`,
-            content: fileContent,
-            totalLines
-          };
-        }
-        const startIndex = start_line_one_indexed - 1;
-        if (startIndex >= totalLines) {
-          return {
-            success: false,
-            message: "start_line_one_indexed must be less than or equal to the total number of lines in the file",
-            error: "INVALID_LINE_RANGE"
-          };
-        }
-        const normalizedEnd = Math.min(end_line_one_indexed, totalLines);
-        const selectedLines = lines.slice(startIndex, normalizedEnd).join("\n");
-        const linesRead = normalizedEnd - start_line_one_indexed + 1;
-        return {
-          success: true,
-          message: `Successfully read lines ${start_line_one_indexed}-${normalizedEnd} from file: ${relative_file_path} (${linesRead} lines of ${totalLines} total)`,
-          content: selectedLines,
-          totalLines
-        };
-      } catch {
-        return {
-          success: false,
-          message: `Failed to read file: ${relative_file_path}`,
-          error: "READ_ERROR"
-        };
-      }
-    }
+      absolute_file_path = path10__default.default.resolve(relative_file_path);
+    }
+    return await readFileContent(
+      absolute_file_path,
+      relative_file_path,
+      should_read_entire_file,
+      start_line_one_indexed,
+      end_line_one_indexed
+    );
   } catch {
     return {
       success: false,
@@ -429,13 +373,13 @@ var Diff = class {
       editLength++;
     };
     if (callback) {
-      (function exec4() {
+      (function exec3() {
         setTimeout(function() {
           if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
             return callback(void 0);
           }
           if (!execEditLength()) {
-            exec4();
+            exec3();
           }
         }, 0);
       })();
@@ -662,17 +606,19 @@ var apply_patch = async function(input, projectCwd) {
     }
     const basePath = projectCwd || process.cwd();
     const absolute_file_path = resolveProjectPath(file_path, basePath);
+    const file = Bun.file(absolute_file_path);
+    const exists = await file.exists();
+    if (!exists) {
+      return {
+        success: false,
+        message: `File not found: ${file_path}`,
+        error: "FILE_NOT_FOUND"
+      };
+    }
     let fileContent;
     try {
-      fileContent = await fs5.readFile(absolute_file_path, "utf-8");
+      fileContent = await file.text();
     } catch (error) {
-      if (error?.code === "ENOENT") {
-        return {
-          success: false,
-          message: `File not found: ${file_path}`,
-          error: "FILE_NOT_FOUND"
-        };
-      }
       return {
         success: false,
         message: `Failed to read file: ${file_path}`,
@@ -696,7 +642,7 @@ var apply_patch = async function(input, projectCwd) {
     }
     const newContent = fileContent.replace(old_string, new_string);
     try {
-      await fs5.writeFile(absolute_file_path, newContent, "utf-8");
+      await Bun.write(absolute_file_path, newContent);
       const diffStats = calculateDiffStats(fileContent, newContent);
       return {
         success: true,
@@ -742,28 +688,27 @@ 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 fs5.mkdir(dirPath, { recursive: true });
+    await fs7.mkdir(dirPath, { recursive: true });
     let isNewFile = providedNewFile;
     let existingContent = "";
+    const file = Bun.file(filePath);
     if (isNewFile === void 0) {
-      try {
-        existingContent = await fs6__default.default.promises.readFile(filePath, "utf-8");
+      const exists = await file.exists();
+      if (exists) {
+        existingContent = await file.text();
         isNewFile = false;
-      } catch (error) {
+      } else {
         isNewFile = true;
       }
     } else if (!isNewFile) {
-      try {
-        existingContent = await fs6__default.default.promises.readFile(filePath, "utf-8");
-      } catch (error) {
+      const exists = await file.exists();
+      if (exists) {
+        existingContent = await file.text();
+      } else {
         isNewFile = true;
       }
     }
-    try {
-      await fs6__default.default.promises.writeFile(filePath, content);
-    } catch (writeError) {
-      throw writeError;
-    }
+    await Bun.write(filePath, content);
     const diffStats = calculateDiffStats(existingContent, content);
     if (isNewFile) {
       return {
@@ -826,25 +771,31 @@ var deleteFile = async function(input, projectCwd) {
         error: "INVALID_FILE_PATH"
       };
     }
-    const originalContent = await fs5.readFile(absolute_file_path);
-    if (originalContent === void 0) {
+    const file = Bun.file(absolute_file_path);
+    const exists = await file.exists();
+    if (!exists) {
       return {
         success: false,
-        message: `Failed to read file before deletion: ${realPath}`,
-        error: "READ_ERROR"
+        message: `File not found: ${realPath}`,
+        error: "FILE_NOT_FOUND"
       };
     }
-    const deleteResult = await fs5.unlink(absolute_file_path).catch(() => {
+    let originalContent;
+    try {
+      originalContent = await file.text();
+    } catch {
       return {
         success: false,
         message: `Failed to read file before deletion: ${realPath}`,
-        error: "DELETE_ERROR"
+        error: "READ_ERROR"
       };
-    });
-    if (!deleteResult?.success) {
+    }
+    try {
+      await fs7.unlink(absolute_file_path);
+    } catch {
       return {
         success: false,
-        message: `Failed to delete file before deletion: ${realPath}`,
+        message: `Failed to delete file: ${realPath}`,
         error: "DELETE_ERROR"
       };
     }
@@ -861,72 +812,218 @@ var deleteFile = async function(input, projectCwd) {
     };
   }
 };
+var GREP_LIMITS = {
+  DEFAULT_MAX_MATCHES: 200,
+  MAX_LINE_LENGTH: 500,
+  MAX_TOTAL_OUTPUT_SIZE: 1 * 1024 * 1024,
+  TRUNCATION_MESSAGE: "\n[Results truncated due to size limits. Use more specific patterns or file filters to narrow your search.]"
+};
 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")'),
     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")
-  })
+    caseSensitive: zod.z.boolean().optional().describe("Whether the search should be case sensitive"),
+    path: zod.z.string().optional().describe("Subdirectory to search in")
+  }).optional()
 });
-var execAsync = util.promisify(child_process.exec);
+async function getRipgrepPath() {
+  const paths = [
+    "/opt/homebrew/bin/rg",
+    "/usr/local/bin/rg",
+    "/usr/bin/rg",
+    "rg"
+    // Fallback to PATH
+  ];
+  for (const rgPath of paths) {
+    try {
+      const proc = Bun.spawn(["which", rgPath], { stdout: "pipe", stderr: "pipe" });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        return rgPath;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return "rg";
+}
+async function getMtimesBatched(files) {
+  const mtimeMap = /* @__PURE__ */ new Map();
+  const BATCH_SIZE = 50;
+  for (let i = 0; i < files.length; i += BATCH_SIZE) {
+    const batch = files.slice(i, i + BATCH_SIZE);
+    const results = await Promise.all(
+      batch.map(async (filePath) => {
+        const mtime = await Bun.file(filePath).stat().then((stats) => stats.mtime.getTime()).catch(() => 0);
+        return { path: filePath, mtime };
+      })
+    );
+    results.forEach(({ path: path16, mtime }) => mtimeMap.set(path16, mtime));
+  }
+  return mtimeMap;
+}
 var grepTool = async function(input, projectCwd) {
   const { query, options } = input;
+  if (!query || query.trim() === "") {
+    return {
+      success: false,
+      message: "Missing required parameter: query",
+      error: "MISSING_QUERY"
+    };
+  }
   try {
-    const { includePattern, excludePattern: excludePattern2, caseSensitive } = options || {};
-    const searchDir = projectCwd || process.cwd();
-    if (projectCwd && !path10__default.default.isAbsolute(projectCwd)) {
+    const { includePattern, excludePattern, caseSensitive, path: subPath } = options || {};
+    let searchDir = projectCwd || process.cwd();
+    if (subPath) {
+      searchDir = path10__default.default.isAbsolute(subPath) ? subPath : path10__default.default.resolve(searchDir, subPath);
+      if (projectCwd) {
+        const validation = validatePath(subPath, projectCwd);
+        if (!validation.valid) {
+          return {
+            success: false,
+            message: validation.error || "Path validation failed",
+            error: "ACCESS_DENIED"
+          };
+        }
+      }
+    }
+    if (!fs8__default.default.existsSync(searchDir)) {
       return {
         success: false,
-        message: "Invalid project directory",
-        error: "INVALID_PROJECT_DIR"
+        message: `Directory not found: ${searchDir}`,
+        error: "DIR_NOT_FOUND"
       };
     }
-    let command = `rg -n --with-filename "${query}"`;
-    if (caseSensitive) {
-      command += " -i";
+    const rgPath = await getRipgrepPath();
+    const args2 = [
+      "-n",
+      // Line numbers
+      "--with-filename",
+      // Always show filename
+      "--no-heading",
+      // Don't group by file
+      "--color=never",
+      // No ANSI colors
+      "--max-count=100",
+      // Max matches per file
+      "--max-columns=1000"
+      // Truncate long lines
+    ];
+    if (!caseSensitive) {
+      args2.push("-i");
     }
     if (includePattern) {
-      command += ` --glob "${includePattern}"`;
-    }
-    if (excludePattern2) {
-      command += ` --glob "!${excludePattern2}"`;
-    }
-    command += ` --max-count 50`;
-    command += ` "${searchDir}"`;
-    const { stdout } = await execAsync(command);
-    const rawMatches = stdout.trim().split("\n").filter((line) => line.length > 0);
-    const detailedMatches = [];
-    const matches = [];
-    for (const rawMatch of rawMatches) {
-      const colonIndex = rawMatch.indexOf(":");
-      const secondColonIndex = rawMatch.indexOf(":", colonIndex + 1);
-      if (colonIndex > 0 && secondColonIndex > colonIndex) {
-        const file = rawMatch.substring(0, colonIndex);
-        const lineNumber = parseInt(rawMatch.substring(colonIndex + 1, secondColonIndex), 10);
-        let content = rawMatch.substring(secondColonIndex + 1);
-        if (content.length > 250) {
-          content = content.substring(0, 250) + "...";
+      args2.push("--glob", includePattern);
+    }
+    if (excludePattern) {
+      args2.push("--glob", `!${excludePattern}`);
+    }
+    args2.push("--glob", "!node_modules/**");
+    args2.push("--glob", "!.git/**");
+    args2.push("--glob", "!dist/**");
+    args2.push("--glob", "!build/**");
+    args2.push("--glob", "!*.min.js");
+    args2.push("--glob", "!*.min.css");
+    args2.push("--glob", "!package-lock.json");
+    args2.push("--glob", "!yarn.lock");
+    args2.push("--glob", "!bun.lockb");
+    args2.push("--regexp", query);
+    args2.push(searchDir);
+    const proc = Bun.spawn([rgPath, ...args2], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    if (exitCode === 1) {
+      return {
+        success: true,
+        matches: [],
+        detailedMatches: [],
+        query,
+        matchCount: 0,
+        message: `No matches found for pattern: ${query}`
+      };
+    }
+    if (exitCode !== 0) {
+      return {
+        success: false,
+        message: `Ripgrep error: ${stderr || "Unknown error"}`,
+        error: "GREP_EXEC_ERROR"
+      };
+    }
+    const lines = stdout.trim().split("\n").filter((line) => line.length > 0);
+    const rawMatches = [];
+    const uniqueFiles = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      const firstColon = line.indexOf(":");
+      const secondColon = line.indexOf(":", firstColon + 1);
+      if (firstColon > 0 && secondColon > firstColon) {
+        const file = line.substring(0, firstColon);
+        const lineNumber = parseInt(line.substring(firstColon + 1, secondColon), 10);
+        let content = line.substring(secondColon + 1);
+        if (content.length > GREP_LIMITS.MAX_LINE_LENGTH) {
+          content = content.substring(0, GREP_LIMITS.MAX_LINE_LENGTH) + "...";
         }
-        detailedMatches.push({
+        rawMatches.push({
           file,
           lineNumber,
-          content
+          content: content.trim(),
+          mtime: 0
         });
-        matches.push(`${file}:${lineNumber}:${content}`);
-      } else {
-        matches.push(rawMatch);
+        uniqueFiles.add(file);
       }
     }
+    const mtimeMap = await getMtimesBatched(Array.from(uniqueFiles));
+    for (const match of rawMatches) {
+      match.mtime = mtimeMap.get(match.file) || 0;
+    }
+    rawMatches.sort((a, b) => {
+      if (b.mtime !== a.mtime) {
+        return b.mtime - a.mtime;
+      }
+      return a.file.localeCompare(b.file);
+    });
+    const truncated = rawMatches.length > GREP_LIMITS.DEFAULT_MAX_MATCHES;
+    const finalMatches = truncated ? rawMatches.slice(0, GREP_LIMITS.DEFAULT_MAX_MATCHES) : rawMatches;
+    const detailedMatches = finalMatches.map((m) => ({
+      file: m.file,
+      lineNumber: m.lineNumber,
+      content: m.content
+    }));
+    const matches = finalMatches.map(
+      (m) => `${m.file}:${m.lineNumber}:${m.content}`
+    );
+    const groupedOutput = [`Found ${finalMatches.length} matches`];
+    let currentFile = "";
+    for (const match of finalMatches) {
+      if (currentFile !== match.file) {
+        if (currentFile !== "") {
+          groupedOutput.push("");
+        }
+        currentFile = match.file;
+        groupedOutput.push(`${match.file}:`);
+      }
+      groupedOutput.push(`  Line ${match.lineNumber}: ${match.content}`);
+    }
+    if (truncated) {
+      groupedOutput.push("");
+      groupedOutput.push(GREP_LIMITS.TRUNCATION_MESSAGE);
+    }
     return {
       success: true,
       matches,
       detailedMatches,
       query,
-      matchCount: matches.length,
-      message: `Found ${matches.length} matches for pattern: ${query}`
+      matchCount: finalMatches.length,
+      truncated,
+      message: `Found ${finalMatches.length} matches for pattern: ${query}`,
+      content: groupedOutput.join("\n")
     };
   } catch (error) {
+    console.error("[grep] error:", error);
     return {
       success: false,
       message: error?.message || String(error),
@@ -935,9 +1032,25 @@ var grepTool = async function(input, projectCwd) {
   }
 };
 zod.z.object({
-  pattern: zod.z.string().describe('Glob pattern (e.g., "**/*.js")'),
-  path: zod.z.string().optional().describe("Relative directory path to search in")
+  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")
 });
+var RESULT_LIMIT = 100;
+var MTIME_BATCH_SIZE = 50;
+async function getMtimesBatched2(files) {
+  const results = [];
+  for (let i = 0; i < files.length; i += MTIME_BATCH_SIZE) {
+    const batch = files.slice(i, i + MTIME_BATCH_SIZE);
+    const batchResults = await Promise.all(
+      batch.map(async (filePath) => {
+        const mtime = await Bun.file(filePath).stat().then((stats) => stats.mtime.getTime()).catch(() => 0);
+        return { path: filePath, mtime };
+      })
+    );
+    results.push(...batchResults);
+  }
+  return results;
+}
 var globTool = async function(input, projectCwd) {
   const { pattern, path: inputPath } = input;
   if (!pattern) {
@@ -950,6 +1063,13 @@ var globTool = async function(input, projectCwd) {
   try {
     const basePath = projectCwd || process.cwd();
     const searchPath = inputPath ? resolveProjectPath(inputPath, basePath) : basePath;
+    if (!fs8__default.default.existsSync(searchPath)) {
+      return {
+        success: false,
+        message: `Directory not found: ${searchPath}`,
+        error: "DIR_NOT_FOUND"
+      };
+    }
     if (projectCwd && inputPath) {
       const validation = validatePath(inputPath, projectCwd);
       if (!validation.valid) {
@@ -960,21 +1080,49 @@ var globTool = async function(input, projectCwd) {
         };
       }
     }
-    const filesGenerator = fs5.glob(pattern, {
-      cwd: searchPath
-    });
+    const glob = new Bun.Glob(pattern);
     const files = [];
-    for await (const file of filesGenerator) {
-      files.push(file);
+    let truncated = false;
+    for await (const match of glob.scan({
+      cwd: searchPath,
+      absolute: true,
+      onlyFiles: true,
+      followSymlinks: false
+    })) {
+      if (match.includes("/node_modules/") || match.includes("/.git/")) {
+        continue;
+      }
+      if (files.length >= RESULT_LIMIT) {
+        truncated = true;
+        break;
+      }
+      files.push(match);
+    }
+    const filesWithMtime = await getMtimesBatched2(files);
+    filesWithMtime.sort((a, b) => b.mtime - a.mtime);
+    const output = [];
+    if (filesWithMtime.length === 0) {
+      output.push("No files found");
+    } else {
+      output.push(...filesWithMtime.map((f) => f.path));
+      if (truncated) {
+        output.push("");
+        output.push("(Results are truncated. Consider using a more specific path or pattern.)");
+      }
     }
     const searchLocation = inputPath ? ` in "${inputPath}"` : " in current directory";
-    const message = `Found ${files.length} matches for pattern "${pattern}"${searchLocation}`;
+    const message = `Found ${filesWithMtime.length} matches for pattern "${pattern}"${searchLocation}`;
     return {
       success: true,
       message,
-      content: files
+      metadata: {
+        count: filesWithMtime.length,
+        truncated
+      },
+      content: output.join("\n")
     };
   } catch (error) {
+    console.error("[glob] error:", error);
     return {
       success: false,
       message: `Failed to find files matching pattern: ${pattern}`,
@@ -982,59 +1130,120 @@ var globTool = async function(input, projectCwd) {
     };
   }
 };
-var excludePatterns = [
-  "node_modules/",
-  "__pycache__/",
-  ".git/",
-  "dist/",
-  "build/",
-  "target/",
-  "vendor/",
-  "bin/",
-  "obj/",
-  ".idea/",
-  ".vscode/",
-  ".zig-cache/",
+var IGNORE_PATTERNS = [
+  "node_modules",
+  "__pycache__",
+  ".git",
+  "dist",
+  "build",
+  "target",
+  "vendor",
+  "bin",
+  "obj",
+  ".idea",
+  ".vscode",
+  ".zig-cache",
   "zig-out",
   ".coverage",
-  "coverage/",
-  "vendor/",
-  "tmp/",
-  "temp/",
-  ".cache/",
-  "cache/",
-  "logs/",
-  ".venv/",
-  "venv/",
-  "env/"
+  "coverage",
+  "tmp",
+  "temp",
+  ".cache",
+  "cache",
+  "logs",
+  ".venv",
+  "venv",
+  "env",
+  ".next",
+  ".turbo",
+  ".vercel",
+  ".output"
 ];
-var excludePattern = excludePatterns.join("|");
+var RESULT_LIMIT2 = 500;
+var MTIME_BATCH_SIZE2 = 50;
 zod.z.object({
-  path: zod.z.string().optional(),
-  recursive: zod.z.boolean().optional().describe("Whether to list files recursively"),
-  maxDepth: zod.z.number().optional().describe("Maximum recursion depth (default: unlimited)"),
+  path: zod.z.string().optional().describe("Relative 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"),
-  includeDirectories: zod.z.boolean().optional().describe("Whether to include directories in results (default: true)"),
-  includeFiles: zod.z.boolean().optional().describe("Whether to include files in results (default: true)")
+  showHidden: zod.z.boolean().optional().describe("Whether to show hidden files (default: false)")
 });
-var list = async function(input, projectCwd) {
-  const { path: relativePath, recursive, maxDepth, pattern, includeDirectories, includeFiles } = input;
-  if (maxDepth !== void 0) {
-    if (!Number.isInteger(maxDepth) || maxDepth < 0) {
-      return {
-        success: false,
-        message: "maxDepth must be a non-negative integer",
-        error: "INVALID_MAX_DEPTH"
-      };
+function shouldIgnore(name, showHidden) {
+  if (!showHidden && name.startsWith(".") && name !== ".") {
+    return true;
+  }
+  return IGNORE_PATTERNS.includes(name);
+}
+function matchPattern(name, pattern) {
+  if (!pattern) return true;
+  if (pattern.startsWith(".") && !pattern.includes("*")) {
+    return name.endsWith(pattern);
+  }
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${escaped}$`, "i");
+  return regex.test(name);
+}
+async function getMtimesBatched3(entries) {
+  for (let i = 0; i < entries.length; i += MTIME_BATCH_SIZE2) {
+    const batch = entries.slice(i, i + MTIME_BATCH_SIZE2);
+    await Promise.all(
+      batch.map(async (entry) => {
+        entry.mtime = await Bun.file(entry.absolutePath).stat().then((stats) => stats.mtime.getTime()).catch(() => 0);
+      })
+    );
+  }
+}
+function buildTreeOutput(entries, basePath) {
+  const tree = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const dir = path10__default.default.dirname(entry.relativePath);
+    const dirKey = dir === "." ? "" : dir;
+    if (!tree.has(dirKey)) {
+      tree.set(dirKey, []);
+    }
+    tree.get(dirKey).push(entry);
+  }
+  for (const [, items] of tree) {
+    items.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === "directory" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+  }
+  const lines = [`${basePath}/`];
+  function renderLevel(dirPath, indent) {
+    const items = tree.get(dirPath) || [];
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const isLast = i === items.length - 1;
+      const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      const childIndent = indent + (isLast ? "    " : "\u2502   ");
+      if (item.type === "directory") {
+        lines.push(`${indent}${prefix}${item.name}/`);
+        const childPath = dirPath ? `${dirPath}/${item.name}` : item.name;
+        renderLevel(childPath, childIndent);
+      } else {
+        lines.push(`${indent}${prefix}${item.name}`);
+      }
     }
   }
-  const includeFilesNormalized = includeFiles ?? true;
-  const includeDirectoriesNormalized = includeDirectories ?? true;
-  if (!includeFilesNormalized && !includeDirectoriesNormalized) {
+  renderLevel("", "");
+  return lines.join("\n");
+}
+var list = async function(input, projectCwd) {
+  const {
+    path: relativePath,
+    recursive = true,
+    maxDepth = 3,
+    pattern,
+    showHidden = false
+  } = input;
+  if (maxDepth !== void 0 && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
     return {
       success: false,
-      message: "At least one of includeFiles or includeDirectories must be true",
-      error: "INVALID_INCLUDE_OPTIONS"
+      message: "maxDepth must be a non-negative integer",
+      error: "INVALID_MAX_DEPTH"
     };
   }
   try {
@@ -1050,88 +1259,119 @@ var list = async function(input, projectCwd) {
         };
       }
     }
-    try {
-      await fs5.access(absolutePath);
-    } catch {
+    if (!fs8__default.default.existsSync(absolutePath)) {
       return {
         success: false,
-        message: `File does not exist: ${absolutePath}`,
-        error: "FILE_DOES_NOT_EXIST"
+        message: `Directory not found: ${absolutePath}`,
+        error: "DIR_NOT_FOUND"
       };
     }
-    const isDir = (await fs5.stat(absolutePath)).isDirectory();
-    if (!isDir) {
+    const stats = fs8__default.default.statSync(absolutePath);
+    if (!stats.isDirectory()) {
       return {
         success: false,
-        message: `File is not a directory: ${absolutePath}`,
-        error: "FILE_IS_NOT_A_DIRECTORY"
+        message: `Path is not a directory: ${absolutePath}`,
+        error: "NOT_A_DIRECTORY"
       };
     }
     const collected = [];
-    const patternMatcher = (() => {
-      if (!pattern) return null;
-      if (pattern.startsWith(".") && !pattern.includes("*") && !pattern.includes("?")) {
-        return (entryName) => entryName.endsWith(pattern);
-      }
-      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-      const regex = new RegExp(`^${escaped}$`);
-      return (entryName) => regex.test(entryName);
-    })();
-    const matchPattern = (entryName) => {
-      if (!patternMatcher) return true;
-      return patternMatcher(entryName);
-    };
-    const maxDepthNormalized = recursive ? maxDepth ?? Infinity : 0;
+    let truncated = false;
     const walk = async (currentDir, depth) => {
-      const entries = await fs5.readdir(currentDir, { withFileTypes: true });
+      if (collected.length >= RESULT_LIMIT2) {
+        truncated = true;
+        return;
+      }
+      let entries;
+      try {
+        entries = fs8__default.default.readdirSync(currentDir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      entries.sort((a, b) => {
+        if (a.isDirectory() !== b.isDirectory()) {
+          return a.isDirectory() ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+      });
       for (const entry of entries) {
+        if (collected.length >= RESULT_LIMIT2) {
+          truncated = true;
+          break;
+        }
+        if (shouldIgnore(entry.name, showHidden)) {
+          continue;
+        }
         const entryAbsolutePath = path10__default.default.join(currentDir, entry.name);
-        const entryRelativePath = path10__default.default.relative(absolutePath, entryAbsolutePath) || ".";
+        const entryRelativePath = path10__default.default.relative(absolutePath, entryAbsolutePath);
         if (entry.isDirectory()) {
-          const isExcluded = entry.name.match(excludePattern);
-          if (includeDirectoriesNormalized && matchPattern(entry.name) && !isExcluded) {
-            collected.push({
-              name: entry.name,
-              absolutePath: entryAbsolutePath,
-              relativePath: entryRelativePath,
-              type: "directory"
-            });
-          }
-          if (recursive && depth < maxDepthNormalized && !isExcluded) {
+          collected.push({
+            name: entry.name,
+            absolutePath: entryAbsolutePath,
+            relativePath: entryRelativePath,
+            type: "directory",
+            mtime: 0,
+            depth
+          });
+          if (recursive && depth < maxDepth) {
             await walk(entryAbsolutePath, depth + 1);
           }
         } else if (entry.isFile()) {
-          if (includeFilesNormalized && matchPattern(entry.name) && !entry.name.match(excludePattern)) {
+          if (matchPattern(entry.name, pattern)) {
             collected.push({
               name: entry.name,
               absolutePath: entryAbsolutePath,
               relativePath: entryRelativePath,
-              type: "file"
+              type: "file",
+              mtime: 0,
+              depth
             });
           }
         }
       }
     };
     await walk(absolutePath, 0);
+    await getMtimesBatched3(collected);
     const totalFiles = collected.filter((item) => item.type === "file").length;
     const totalDirectories = collected.filter((item) => item.type === "directory").length;
-    let message = `Successfully listed ${collected.length} items in: ${relativePath ?? absolutePath}`;
+    const treeOutput = buildTreeOutput(collected, relativePath || path10__default.default.basename(absolutePath));
+    let message = `Listed ${collected.length} items`;
+    if (relativePath) {
+      message += ` in "${relativePath}"`;
+    }
+    message += ` (${totalFiles} files, ${totalDirectories} directories)`;
     if (recursive) {
-      message += ` (recursive${maxDepth !== void 0 ? `, max depth ${maxDepth}` : ""})`;
+      message += ` [depth: ${maxDepth}]`;
     }
     if (pattern) {
-      message += ` (filtered by pattern: ${pattern})`;
+      message += ` [filter: ${pattern}]`;
     }
-    message += ` - ${totalFiles} files, ${totalDirectories} directories`;
+    if (truncated) {
+      message += ` [TRUNCATED at ${RESULT_LIMIT2} items]`;
+    }
+    const files = collected.map((item) => ({
+      name: item.name,
+      path: item.relativePath,
+      type: item.type
+    }));
     return {
       success: true,
       message,
-      files: collected
+      metadata: {
+        totalFiles,
+        totalDirectories,
+        totalItems: collected.length,
+        truncated,
+        maxDepth,
+        recursive
+      },
+      files,
+      content: treeOutput
     };
   } catch (error) {
+    console.error("[list] error:", error);
     return {
       success: false,
-      message: `Failed to list files: ${error}`,
+      message: `Failed to list directory: ${error}`,
       error: "LIST_ERROR"
     };
   }
@@ -1149,10 +1389,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 (!fs6__default.default.existsSync(CREDENTIALS_PATH)) {
+    if (!fs8__default.default.existsSync(CREDENTIALS_PATH)) {
       return false;
     }
-    const raw = fs6__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs8__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return Boolean(data && data.access_token);
   } catch {
@@ -1161,10 +1401,10 @@ function isAuthenticated() {
 }
 function saveTokens(tokens) {
   try {
-    if (!fs6__default.default.existsSync(CREDENTIALS_DIR)) {
-      fs6__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    if (!fs8__default.default.existsSync(CREDENTIALS_DIR)) {
+      fs8__default.default.mkdirSync(CREDENTIALS_DIR, { recursive: true });
     }
-    fs6__default.default.writeFileSync(
+    fs8__default.default.writeFileSync(
       CREDENTIALS_PATH,
       JSON.stringify(tokens, null, 2),
       "utf8"
@@ -1175,18 +1415,18 @@ function saveTokens(tokens) {
 }
 function logout() {
   try {
-    if (fs6__default.default.existsSync(CREDENTIALS_PATH)) {
-      fs6__default.default.unlinkSync(CREDENTIALS_PATH);
+    if (fs8__default.default.existsSync(CREDENTIALS_PATH)) {
+      fs8__default.default.unlinkSync(CREDENTIALS_PATH);
     }
   } catch (error) {
     console.error(pc5__default.default.red("Failed to logout"), error);
   }
 }
 function getTokens() {
-  if (!fs6__default.default.existsSync(CREDENTIALS_PATH)) {
+  if (!fs8__default.default.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs6__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs8__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
@@ -1285,10 +1525,10 @@ async function login() {
 }
 var getUserId = () => {
   try {
-    if (!fs6__default.default.existsSync(CREDENTIALS_PATH)) {
+    if (!fs8__default.default.existsSync(CREDENTIALS_PATH)) {
       return;
     }
-    const raw = fs6__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs8__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return {
       userId: data.user.id
@@ -1337,7 +1577,7 @@ 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")
 }).merge(ExplanationSchema);
-var runSecureTerminalCommand = async (command, timeout) => {
+var runSecureTerminalCommand = async (command, timeout, cwd) => {
   try {
     if (isHarmfulCommand(command)) {
       console.log(`[CLI] Harmful command detected: ${command}`);
@@ -1347,42 +1587,44 @@ var runSecureTerminalCommand = async (command, timeout) => {
         error: "HARMFUL_COMMAND_DETECTED"
       };
     }
-    return new Promise((resolve, reject) => {
-      const child = child_process.spawn(command, {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "pipe"],
-        shell: true
-      });
-      let stdout = "";
-      let stderr = "";
-      let timeoutId = null;
-      if (timeoutId > 0) {
-        timeoutId = setTimeout(() => {
-          child.kill("SIGKILL");
-          reject(new Error(`Command timed out after ${timeout}ms`));
-        }, timeout);
-      }
-      child.stdout?.on("data", (data) => {
-        stdout += data.toString();
-      });
-      child.stderr?.on("data", (data) => {
-        stderr += data.toString();
-      });
-      child.stdout.on("close", (code) => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        resolve({ stdout, stderr, exitCode: code || 0 });
-      });
-      child.stderr.on("error", (error) => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        reject(error);
-      });
+    const proc = Bun.spawn(["sh", "-c", command], {
+      cwd: cwd || process.cwd(),
+      stdout: "pipe",
+      stderr: "pipe"
     });
-  } catch {
-    console.error("Error while ecexuting the securedShell command");
+    let timedOut = false;
+    let timeoutId = null;
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        proc.kill();
+      }, timeout);
+    }
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    if (timedOut) {
+      return {
+        success: false,
+        message: `Command timed out after ${timeout}ms`,
+        error: "TIMEOUT",
+        stdout,
+        stderr
+      };
+    }
+    return { stdout, stderr, exitCode };
+  } catch (error) {
+    console.error("Error while executing the securedShell command", error);
+    return {
+      success: false,
+      message: "Error while executing the securedShell command",
+      error: error.message
+    };
   }
 };
 var runTerminalCommand = async (input, projectCwd) => {
@@ -1396,13 +1638,12 @@ var runTerminalCommand = async (input, projectCwd) => {
           error: "HARMFUL_COMMAND_DETECTED"
         };
       }
-      const child = child_process.spawn(input.command, {
-        cwd: projectCwd,
-        detached: true,
-        stdio: "ignore",
-        shell: true
+      const proc = Bun.spawn(["sh", "-c", input.command], {
+        cwd: projectCwd || process.cwd(),
+        stdout: "ignore",
+        stderr: "ignore"
       });
-      child.unref();
+      proc.unref();
       console.log(`[LOCAL] Background command started: ${input.command}`);
       return {
         success: true,
@@ -1412,9 +1653,13 @@ var runTerminalCommand = async (input, projectCwd) => {
     } else {
       const result = await runSecureTerminalCommand(
         input.command,
-        3e4
+        3e4,
         // 30 second timeout
+        projectCwd
       );
+      if (result?.error && !result?.exitCode) {
+        return result;
+      }
       const success = result?.exitCode === 0;
       return {
         success,
@@ -1433,9 +1678,9 @@ var runTerminalCommand = async (input, projectCwd) => {
     };
   }
 };
-var ignoreFiles = ["node_modules", ".git", ".next", ".env", ".env.local", ".env.development.local", ".env.test.local", ".env.production.local"];
+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 = fs6.readdirSync(dir, { withFileTypes: true });
+  const filePath = fs8.readdirSync(dir, { withFileTypes: true });
   for (const file of filePath) {
     if (ignoreFiles.includes(file.name)) continue;
     const fullPath = path10__default.default.join(dir, file.name);
@@ -1455,28 +1700,34 @@ var IDE_PROJECTS_PATHS = {
 };
 function getWorkspaceStoragePath(ide) {
   const platform = os3__default.default.platform();
-  const appName = "Cursor" ;
+  const appName = ide === "cursor" ? "Cursor" : "Code";
+  const appNameLower = appName.toLowerCase();
   if (platform === "darwin") {
     return path10__default.default.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
   } else if (platform === "win32") {
     return path10__default.default.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
   } else {
-    return path10__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
+    const capitalizedPath = path10__default.default.join(HOME, ".config", appName, "User", "workspaceStorage");
+    const lowercasePath = path10__default.default.join(HOME, ".config", appNameLower, "User", "workspaceStorage");
+    if (fs8__default.default.existsSync(capitalizedPath)) {
+      return capitalizedPath;
+    }
+    return lowercasePath;
   }
 }
 function scanWorkspaceStorage(ide) {
   const projects = [];
-  const storagePath = getWorkspaceStoragePath();
-  if (!fs6__default.default.existsSync(storagePath)) {
+  const storagePath = getWorkspaceStoragePath(ide);
+  if (!fs8__default.default.existsSync(storagePath)) {
     return projects;
   }
   try {
-    const workspaces = fs6__default.default.readdirSync(storagePath);
+    const workspaces = fs8__default.default.readdirSync(storagePath);
     for (const workspace of workspaces) {
       const workspaceJsonPath = path10__default.default.join(storagePath, workspace, "workspace.json");
-      if (fs6__default.default.existsSync(workspaceJsonPath)) {
+      if (fs8__default.default.existsSync(workspaceJsonPath)) {
         try {
-          const content = fs6__default.default.readFileSync(workspaceJsonPath, "utf-8");
+          const content = fs8__default.default.readFileSync(workspaceJsonPath, "utf-8");
           const data = JSON.parse(content);
           if (data.folder && typeof data.folder === "string") {
             let projectPath = data.folder;
@@ -1484,7 +1735,7 @@ function scanWorkspaceStorage(ide) {
               projectPath = projectPath.replace("file://", "");
               projectPath = decodeURIComponent(projectPath);
             }
-            if (fs6__default.default.existsSync(projectPath) && fs6__default.default.statSync(projectPath).isDirectory()) {
+            if (fs8__default.default.existsSync(projectPath) && fs8__default.default.statSync(projectPath).isDirectory()) {
               projects.push({
                 name: path10__default.default.basename(projectPath),
                 path: projectPath,
@@ -1508,11 +1759,11 @@ var scanIdeProjects = async () => {
     const seenPaths = /* @__PURE__ */ new Set();
     const addProject = (projectPath, ide) => {
       try {
-        const resolvedPath = fs6__default.default.realpathSync(projectPath);
-        if (fs6__default.default.existsSync(resolvedPath) && fs6__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+        const resolvedPath = fs8__default.default.realpathSync(projectPath);
+        if (fs8__default.default.existsSync(resolvedPath) && fs8__default.default.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
           const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
             try {
-              return fs6__default.default.realpathSync(ideDir) === resolvedPath;
+              return fs8__default.default.realpathSync(ideDir) === resolvedPath;
             } catch {
               return false;
             }
@@ -1533,32 +1784,36 @@ var scanIdeProjects = async () => {
     for (const project of cursorProjects) {
       addProject(project.path, "cursor");
     }
+    const vscodeProjects = scanWorkspaceStorage("vscode");
+    for (const project of vscodeProjects) {
+      addProject(project.path, "vscode");
+    }
     for (const [ide, dirPath] of Object.entries(IDE_PROJECTS_PATHS)) {
-      if (ide === "cursor") continue;
-      if (fs6__default.default.existsSync(dirPath)) {
-        const projects = fs6__default.default.readdirSync(dirPath);
+      if (ide === "cursor" || ide === "vscode") continue;
+      if (fs8__default.default.existsSync(dirPath)) {
+        const projects = fs8__default.default.readdirSync(dirPath);
         projects.forEach((project) => {
           const projectPath = path10__default.default.join(dirPath, project);
           try {
-            const stats = fs6__default.default.lstatSync(projectPath);
+            const stats = fs8__default.default.lstatSync(projectPath);
             let actualPath = null;
             if (stats.isSymbolicLink()) {
-              actualPath = fs6__default.default.realpathSync(projectPath);
+              actualPath = fs8__default.default.realpathSync(projectPath);
             } else if (stats.isFile()) {
               try {
-                let content = fs6__default.default.readFileSync(projectPath, "utf-8").trim();
+                let content = fs8__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 (fs6__default.default.existsSync(resolvedContent) && fs6__default.default.statSync(resolvedContent).isDirectory()) {
-                  actualPath = fs6__default.default.realpathSync(resolvedContent);
+                if (fs8__default.default.existsSync(resolvedContent) && fs8__default.default.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs8__default.default.realpathSync(resolvedContent);
                 }
               } catch {
                 return;
               }
             } else if (stats.isDirectory()) {
-              actualPath = fs6__default.default.realpathSync(projectPath);
+              actualPath = fs8__default.default.realpathSync(projectPath);
             }
             if (actualPath) {
               addProject(actualPath, ide);
@@ -1582,7 +1837,7 @@ var Global;
 })(Global || (Global = {}));
 
 // src/snapshot/snapshot.ts
-var execAsync2 = util.promisify(child_process.exec);
+var execAsync = util.promisify(child_process.exec);
 var Snapshot;
 ((Snapshot2) => {
   const log = {
@@ -1592,7 +1847,7 @@ var Snapshot;
   };
   async function runGit(command, options = {}) {
     try {
-      const { stdout, stderr } = await execAsync2(command, {
+      const { stdout, stderr } = await execAsync(command, {
         cwd: options.cwd,
         env: { ...process.env, ...options.env },
         encoding: "utf-8",
@@ -1616,8 +1871,8 @@ var Snapshot;
     const worktree = project.cwd;
     const git = gitdir(projectId);
     try {
-      await fs5__default.default.mkdir(git, { recursive: true });
-      const gitExists = await fs5__default.default.access(path10__default.default.join(git, "HEAD")).then(() => true).catch(() => false);
+      await fs7__default.default.mkdir(git, { recursive: true });
+      const gitExists = await fs7__default.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 }
@@ -1702,7 +1957,7 @@ var Snapshot;
         for (const file of newFiles) {
           const fullPath = path10__default.default.join(worktree, file);
           try {
-            await fs5__default.default.unlink(fullPath);
+            await fs7__default.default.unlink(fullPath);
             log.info("deleted newly created file", { file: fullPath });
           } catch {
           }
@@ -1739,7 +1994,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 fs5__default.default.unlink(file).catch(() => {
+            await fs7__default.default.unlink(file).catch(() => {
             });
           }
         }
@@ -2085,6 +2340,81 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
+var toolCallSchema = zod.z.object({
+  tool: zod.z.string().describe("The name of the tool to execute"),
+  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")
+});
+var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
+var batchableToolExecutors = {
+  deleteFile,
+  grep: grepTool,
+  glob: globTool,
+  listDirectory: list,
+  readFile: read_file,
+  runTerminalCommand
+};
+var batchTool = async function(input, projectCwd) {
+  const { tool_calls } = input;
+  const callsToExecute = tool_calls.slice(0, 10);
+  const discardedCalls = tool_calls.slice(10);
+  const executeCall = async (call) => {
+    try {
+      if (DISALLOWED_TOOLS.has(call.tool)) {
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`
+        };
+      }
+      const executor = batchableToolExecutors[call.tool];
+      if (!executor) {
+        const availableTools = Object.keys(batchableToolExecutors).join(", ");
+        return {
+          tool: call.tool,
+          success: false,
+          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`
+        };
+      }
+      const result = await executor(call.parameters, projectCwd);
+      return {
+        tool: call.tool,
+        success: result.success !== false,
+        // Treat undefined success as true
+        result
+      };
+    } catch (error) {
+      return {
+        tool: call.tool,
+        success: false,
+        error: error.message || String(error)
+      };
+    }
+  };
+  const results = await Promise.all(callsToExecute.map(executeCall));
+  for (const call of discardedCalls) {
+    results.push({
+      tool: call.tool,
+      success: false,
+      error: "Maximum of 10 tools allowed in batch"
+    });
+  }
+  const successfulCalls = results.filter((r) => r.success).length;
+  const failedCalls = results.length - successfulCalls;
+  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
+
+Keep using the batch tool for optimal performance in your next response!`;
+  return {
+    success: failedCalls === 0,
+    message: outputMessage,
+    totalCalls: results.length,
+    successful: successfulCalls,
+    failed: failedCalls,
+    results
+  };
+};
 
 // src/server.ts
 var INITIAL_RECONNECT_DELAY2 = 1e3;
@@ -2107,7 +2437,8 @@ var toolExecutors = {
   listDirectory: list,
   readFile: read_file,
   stringReplace: apply_patch,
-  runTerminalCommand
+  runTerminalCommand,
+  batch: batchTool
 };
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
@@ -2188,7 +2519,7 @@ async function main() {
   await connectToUserStreams(serverUrl);
   startHttpServer();
 }
-var execAsync3 = util.promisify(child_process.exec);
+var execAsync2 = util.promisify(child_process.exec);
 var CODE_SERVER_VERSION = "4.96.4";
 function getPlatformInfo() {
   const platform = process.platform;
@@ -2222,50 +2553,50 @@ function getCodeServerBin() {
 }
 function isCodeServerInstalled() {
   const binPath = getCodeServerBin();
-  return fs6__default.default.existsSync(binPath);
+  return fs8__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 (!fs6__default.default.existsSync(AMA_DIR)) {
-    fs6__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs8__default.default.existsSync(AMA_DIR)) {
+    fs8__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
-  if (!fs6__default.default.existsSync(CODE_DIR)) {
-    fs6__default.default.mkdirSync(CODE_DIR, { recursive: true });
+  if (!fs8__default.default.existsSync(CODE_DIR)) {
+    fs8__default.default.mkdirSync(CODE_DIR, { recursive: true });
   }
-  if (!fs6__default.default.existsSync(STORAGE_DIR)) {
-    fs6__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
+  if (!fs8__default.default.existsSync(STORAGE_DIR)) {
+    fs8__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.cyan(`downloading code-server v${CODE_SERVER_VERSION}...`));
   console.log(pc5__default.default.gray(downloadUrl));
   const response = await fetch(downloadUrl);
   if (!response.ok) {
     throw new Error(`Failed to download code-server: ${response.statusText}`);
   }
   const buffer = await response.arrayBuffer();
-  await fs6__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
+  await fs8__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
   console.log(pc5__default.default.cyan("Extracting code-server..."));
-  await execAsync3(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
-  await fs6__default.default.promises.unlink(tarballPath);
+  await execAsync2(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
+  await fs8__default.default.promises.unlink(tarballPath);
   const binPath = getCodeServerBin();
-  if (fs6__default.default.existsSync(binPath)) {
-    await fs6__default.default.promises.chmod(binPath, 493);
+  if (fs8__default.default.existsSync(binPath)) {
+    await fs8__default.default.promises.chmod(binPath, 493);
   }
-  console.log(pc5__default.default.green("\u2713 code-server installed successfully"));
+  console.log(pc5__default.default.green("code-server installed successfully"));
 }
 async function killExistingCodeServer() {
   try {
     if (process.platform === "win32") {
-      await execAsync3("netstat -ano | findstr :8081 | findstr LISTENING").then(async ({ stdout }) => {
+      await execAsync2("netstat -ano | findstr :8081 | findstr LISTENING").then(async ({ stdout }) => {
         const pid = stdout.trim().split(/\s+/).pop();
-        if (pid) await execAsync3(`taskkill /PID ${pid} /F`);
+        if (pid) await execAsync2(`taskkill /PID ${pid} /F`);
       }).catch(() => {
       });
     } else {
-      await execAsync3("lsof -ti:8081").then(async ({ stdout }) => {
+      await execAsync2("lsof -ti:8081").then(async ({ stdout }) => {
         const pid = stdout.trim();
-        if (pid) await execAsync3(`kill -9 ${pid}`);
+        if (pid) await execAsync2(`kill -9 ${pid}`);
       }).catch(() => {
       });
     }
@@ -2275,8 +2606,8 @@ 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 (!fs6__default.default.existsSync(userDir)) {
-    fs6__default.default.mkdirSync(userDir, { recursive: true });
+  if (!fs8__default.default.existsSync(userDir)) {
+    fs8__default.default.mkdirSync(userDir, { recursive: true });
   }
   const defaultSettings = {
     // Disable signature verification for Open VSX extensions
@@ -2294,9 +2625,9 @@ async function setupDefaultSettings() {
     "workbench.activityBar.location": "top"
   };
   let existingSettings = {};
-  if (fs6__default.default.existsSync(settingsPath)) {
+  if (fs8__default.default.existsSync(settingsPath)) {
     try {
-      const content = await fs6__default.default.promises.readFile(settingsPath, "utf-8");
+      const content = await fs8__default.default.promises.readFile(settingsPath, "utf-8");
       existingSettings = JSON.parse(content);
     } catch {
     }
@@ -2304,7 +2635,7 @@ async function setupDefaultSettings() {
   const mergedSettings = { ...defaultSettings, ...existingSettings };
   mergedSettings["workbench.colorTheme"] = "Min Dark";
   mergedSettings["extensions.verifySignature"] = false;
-  await fs6__default.default.promises.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
+  await fs8__default.default.promises.writeFile(settingsPath, JSON.stringify(mergedSettings, null, 2));
   console.log(pc5__default.default.green("ama code-server settings configured"));
 }
 async function installExtensions() {
@@ -2315,7 +2646,7 @@ async function installExtensions() {
   for (const ext of extensions) {
     try {
       console.log(pc5__default.default.cyan(`ama installing extension: ${ext}...`));
-      await execAsync3(`"${binPath}" --user-data-dir "${STORAGE_DIR}" --install-extension ${ext}`);
+      await execAsync2(`"${binPath}" --user-data-dir "${STORAGE_DIR}" --install-extension ${ext}`);
       console.log(pc5__default.default.green(`ama extension ${ext} installed`));
     } catch (error) {
       console.log(pc5__default.default.yellow(`ama failed to install extension ${ext}`), error);
@@ -2325,7 +2656,7 @@ async function installExtensions() {
 async function startCodeServer(cwd) {
   const binPath = getCodeServerBin();
   const workDir = cwd || process.cwd();
-  if (!fs6__default.default.existsSync(binPath)) {
+  if (!fs8__default.default.existsSync(binPath)) {
     throw new Error("ama code-server is not installed. Run installCodeServer() first.");
   }
   await killExistingCodeServer();
@@ -2333,12 +2664,12 @@ async function startCodeServer(cwd) {
   await installExtensions();
   const workspaceStoragePath = path10__default.default.join(STORAGE_DIR, "User", "workspaceStorage");
   try {
-    if (fs6__default.default.existsSync(workspaceStoragePath)) {
-      await fs6__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
+    if (fs8__default.default.existsSync(workspaceStoragePath)) {
+      await fs8__default.default.promises.rm(workspaceStoragePath, { recursive: true, force: true });
     }
     const stateDbPath = path10__default.default.join(STORAGE_DIR, "User", "globalStorage", "state.vscdb");
-    if (fs6__default.default.existsSync(stateDbPath)) {
-      await fs6__default.default.promises.unlink(stateDbPath);
+    if (fs8__default.default.existsSync(stateDbPath)) {
+      await fs8__default.default.promises.unlink(stateDbPath);
     }
   } catch {
   }
@@ -2369,11 +2700,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 (!fs6__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs8__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs6__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs8__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, 0);
     return true;
   } catch {
@@ -2381,30 +2712,30 @@ function isDaemonRunning() {
   }
 }
 function stopDaemon() {
-  if (!fs6__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs8__default.default.existsSync(DAEMON_PID_FILE)) {
     return false;
   }
   try {
-    const pid = Number(fs6__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    const pid = Number(fs8__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
     process.kill(pid, "SIGTERM");
-    fs6__default.default.unlinkSync(DAEMON_PID_FILE);
+    fs8__default.default.unlinkSync(DAEMON_PID_FILE);
     return true;
   } catch (error) {
     return false;
   }
 }
 function startDaemon() {
-  if (!fs6__default.default.existsSync(AMA_DIR)) {
-    fs6__default.default.mkdirSync(AMA_DIR, { recursive: true });
+  if (!fs8__default.default.existsSync(AMA_DIR)) {
+    fs8__default.default.mkdirSync(AMA_DIR, { recursive: true });
   }
   if (isDaemonRunning()) {
     stopDaemon();
   }
   const daemonScript = path10__default.default.join(__dirname$1, "lib", "daemon-entry.js");
-  if (!fs6__default.default.existsSync(daemonScript)) {
+  if (!fs8__default.default.existsSync(daemonScript)) {
     throw new Error(`Daemon entry script not found at: ${daemonScript}. Please rebuild the project.`);
   }
-  const logFd = fs6__default.default.openSync(DAEMON_LOG_FILE, "a");
+  const logFd = fs8__default.default.openSync(DAEMON_LOG_FILE, "a");
   const daemon = child_process.spawn(process.execPath, [daemonScript], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -2412,20 +2743,20 @@ function startDaemon() {
     cwd: process.cwd()
   });
   daemon.unref();
-  fs6__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
-  fs6__default.default.closeSync(logFd);
+  fs8__default.default.writeFileSync(DAEMON_PID_FILE, String(daemon.pid));
+  fs8__default.default.closeSync(logFd);
 }
 function getDaemonPid() {
-  if (!fs6__default.default.existsSync(DAEMON_PID_FILE)) {
+  if (!fs8__default.default.existsSync(DAEMON_PID_FILE)) {
     return null;
   }
   try {
-    return Number(fs6__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
+    return Number(fs8__default.default.readFileSync(DAEMON_PID_FILE, "utf8"));
   } catch {
     return null;
   }
 }
-var VERSION = "0.0.10";
+var VERSION = "0.0.12";
 var PROJECT_DIR = process.cwd();
 var LOGO = `
    __ _ _ __ ___   __ _ 
@@ -2480,13 +2811,13 @@ async function checkForUpdates() {
 }
 function runNpmInstall() {
   return new Promise((resolve, reject) => {
-    const child = child_process.spawn("npm", ["install", "-g", "amai@latest"], {
+    const child = child_process.spawn("bun", ["add", "-g", "amai@latest"], {
       stdio: "inherit",
       shell: true
     });
     child.on("close", (code) => {
       if (code === 0) resolve();
-      else reject(new Error(`npm install exited with code ${code}`));
+      else reject(new Error(`bun add exited with code ${code}`));
     });
     child.on("error", reject);
   });
@@ -2592,11 +2923,11 @@ if (args[0] === "update") {
       process.exit(1);
     }
     const resolvedPath = path10__default.default.resolve(projectPath);
-    if (!fs6__default.default.existsSync(resolvedPath)) {
+    if (!fs8__default.default.existsSync(resolvedPath)) {
       console.error(pc5__default.default.red(`path does not exist: ${resolvedPath}`));
       process.exit(1);
     }
-    if (!fs6__default.default.statSync(resolvedPath).isDirectory()) {
+    if (!fs8__default.default.statSync(resolvedPath).isDirectory()) {
       console.error(pc5__default.default.red(`path is not a directory: ${resolvedPath}`));
       process.exit(1);
     }