amai 0.0.10 → 0.0.11

package/dist/server.js

@@ -1,16 +1,16 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 import WebSocket2 from 'ws';
 import { z } from 'zod';
-import fs5, { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from 'fs/promises';
 import path10 from 'path';
-import fs4, { readdirSync } from 'fs';
+import fs6, { readdirSync } from 'fs';
 import os3 from 'os';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
+import fs7, { unlink, mkdir } from 'fs/promises';
 import pc3 from 'picocolors';
 import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
 import { cors } from 'hono/cors';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 
 var DEFAULT_SERVER_URL = "wss://ama-production-a628.up.railway.app";
 var AMA_DIR = path10.join(os3.homedir(), ".amai");
@@ -26,14 +26,14 @@ var ProjectRegistry = class {
   }
   load() {
     try {
-      if (fs4.existsSync(REGISTRY_FILE)) {
-        const data = fs4.readFileSync(REGISTRY_FILE, "utf8");
+      if (fs6.existsSync(REGISTRY_FILE)) {
+        const data = fs6.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();
-          fs4.copyFileSync(REGISTRY_FILE, backupFile);
-          fs4.unlinkSync(REGISTRY_FILE);
+          fs6.copyFileSync(REGISTRY_FILE, backupFile);
+          fs6.unlinkSync(REGISTRY_FILE);
           return;
         }
         const projects = parsed;
@@ -46,11 +46,11 @@ var ProjectRegistry = class {
       }
     } catch (error) {
       console.error("Failed to load project registry:", error);
-      if (fs4.existsSync(REGISTRY_FILE)) {
+      if (fs6.existsSync(REGISTRY_FILE)) {
         try {
           const backupFile = REGISTRY_FILE + ".backup." + Date.now();
-          fs4.copyFileSync(REGISTRY_FILE, backupFile);
-          fs4.unlinkSync(REGISTRY_FILE);
+          fs6.copyFileSync(REGISTRY_FILE, backupFile);
+          fs6.unlinkSync(REGISTRY_FILE);
           console.log("Corrupted registry file backed up and removed. Starting fresh.");
         } catch (backupError) {
         }
@@ -59,11 +59,11 @@ var ProjectRegistry = class {
   }
   save() {
     try {
-      if (!fs4.existsSync(AMA_DIR)) {
-        fs4.mkdirSync(AMA_DIR, { recursive: true });
+      if (!fs6.existsSync(AMA_DIR)) {
+        fs6.mkdirSync(AMA_DIR, { recursive: true });
       }
       const projects = Array.from(this.projects.values());
-      fs4.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
+      fs6.writeFileSync(REGISTRY_FILE, JSON.stringify(projects, null, 2), "utf8");
     } catch (error) {
       console.error("Failed to save project registry:", error);
     }
@@ -152,6 +152,60 @@ z.object({
   ),
   end_line_one_indexed: 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 {
@@ -192,6 +246,7 @@ var read_file = async function(input, projectCwd) {
         };
       }
     }
+    let absolute_file_path;
     if (projectCwd) {
       const validation = validatePath(relative_file_path, projectCwd);
       if (!validation.valid) {
@@ -201,128 +256,17 @@ var read_file = async function(input, projectCwd) {
           error: "ACCESS_DENIED"
         };
       }
-      const absolute_file_path = validation.resolvedPath;
-      try {
-        const fileStats = await 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 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.resolve(relative_file_path);
-      try {
-        const fileStats = await 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 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.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,
@@ -413,13 +357,13 @@ var Diff = class {
       editLength++;
     };
     if (callback) {
-      (function exec3() {
+      (function exec2() {
         setTimeout(function() {
           if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
             return callback(void 0);
           }
           if (!execEditLength()) {
-            exec3();
+            exec2();
           }
         }, 0);
       })();
@@ -646,17 +590,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 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}`,
@@ -680,7 +626,7 @@ var apply_patch = async function(input, projectCwd) {
     }
     const newContent = fileContent.replace(old_string, new_string);
     try {
-      await writeFile(absolute_file_path, newContent, "utf-8");
+      await Bun.write(absolute_file_path, newContent);
       const diffStats = calculateDiffStats(fileContent, newContent);
       return {
         success: true,
@@ -729,25 +675,24 @@ var editFiles = async function(input, projectCwd) {
     await mkdir(dirPath, { recursive: true });
     let isNewFile = providedNewFile;
     let existingContent = "";
+    const file = Bun.file(filePath);
     if (isNewFile === void 0) {
-      try {
-        existingContent = await fs4.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 fs4.promises.readFile(filePath, "utf-8");
-      } catch (error) {
+      const exists = await file.exists();
+      if (exists) {
+        existingContent = await file.text();
+      } else {
         isNewFile = true;
       }
     }
-    try {
-      await fs4.promises.writeFile(filePath, content);
-    } catch (writeError) {
-      throw writeError;
-    }
+    await Bun.write(filePath, content);
     const diffStats = calculateDiffStats(existingContent, content);
     if (isNewFile) {
       return {
@@ -810,25 +755,31 @@ var deleteFile = async function(input, projectCwd) {
         error: "INVALID_FILE_PATH"
       };
     }
-    const originalContent = await 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 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 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"
       };
     }
@@ -845,72 +796,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.]"
+};
 z.object({
   query: z.string().describe("The regex pattern to search for"),
   options: z.object({
     includePattern: z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts")'),
     excludePattern: z.string().optional().describe("Glob pattern for files to exclude"),
-    caseSensitive: z.boolean().optional().describe("Whether the search should be case sensitive")
-  })
+    caseSensitive: z.boolean().optional().describe("Whether the search should be case sensitive"),
+    path: z.string().optional().describe("Subdirectory to search in")
+  }).optional()
 });
-var execAsync = promisify(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: path13, mtime }) => mtimeMap.set(path13, 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.isAbsolute(projectCwd)) {
+    const { includePattern, excludePattern, caseSensitive, path: subPath } = options || {};
+    let searchDir = projectCwd || process.cwd();
+    if (subPath) {
+      searchDir = path10.isAbsolute(subPath) ? subPath : path10.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 (!fs6.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 args = [
+      "-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) {
+      args.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) + "...";
+      args.push("--glob", includePattern);
+    }
+    if (excludePattern) {
+      args.push("--glob", `!${excludePattern}`);
+    }
+    args.push("--glob", "!node_modules/**");
+    args.push("--glob", "!.git/**");
+    args.push("--glob", "!dist/**");
+    args.push("--glob", "!build/**");
+    args.push("--glob", "!*.min.js");
+    args.push("--glob", "!*.min.css");
+    args.push("--glob", "!package-lock.json");
+    args.push("--glob", "!yarn.lock");
+    args.push("--glob", "!bun.lockb");
+    args.push("--regexp", query);
+    args.push(searchDir);
+    const proc = Bun.spawn([rgPath, ...args], {
+      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),
@@ -919,9 +1016,25 @@ var grepTool = async function(input, projectCwd) {
   }
 };
 z.object({
-  pattern: z.string().describe('Glob pattern (e.g., "**/*.js")'),
-  path: z.string().optional().describe("Relative directory path to search in")
+  pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.js", "src/**/*.ts", "*.json"). Supports standard glob syntax with *, **, and ? wildcards'),
+  path: 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) {
@@ -934,6 +1047,13 @@ var globTool = async function(input, projectCwd) {
   try {
     const basePath = projectCwd || process.cwd();
     const searchPath = inputPath ? resolveProjectPath(inputPath, basePath) : basePath;
+    if (!fs6.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) {
@@ -944,21 +1064,49 @@ var globTool = async function(input, projectCwd) {
         };
       }
     }
-    const filesGenerator = 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}`,
@@ -966,59 +1114,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;
 z.object({
-  path: z.string().optional(),
-  recursive: z.boolean().optional().describe("Whether to list files recursively"),
-  maxDepth: z.number().optional().describe("Maximum recursion depth (default: unlimited)"),
+  path: z.string().optional().describe("Relative path to the directory to list"),
+  recursive: z.boolean().optional().describe("Whether to list files recursively (default: true)"),
+  maxDepth: z.number().optional().describe("Maximum recursion depth (default: 3)"),
   pattern: z.string().optional().describe("File extension (e.g., '.ts') or glob-like pattern"),
-  includeDirectories: z.boolean().optional().describe("Whether to include directories in results (default: true)"),
-  includeFiles: z.boolean().optional().describe("Whether to include files in results (default: true)")
+  showHidden: 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.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 {
@@ -1034,88 +1243,119 @@ var list = async function(input, projectCwd) {
         };
       }
     }
-    try {
-      await access(absolutePath);
-    } catch {
+    if (!fs6.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 stat(absolutePath)).isDirectory();
-    if (!isDir) {
+    const stats = fs6.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 readdir(currentDir, { withFileTypes: true });
+      if (collected.length >= RESULT_LIMIT2) {
+        truncated = true;
+        return;
+      }
+      let entries;
+      try {
+        entries = fs6.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.join(currentDir, entry.name);
-        const entryRelativePath = path10.relative(absolutePath, entryAbsolutePath) || ".";
+        const entryRelativePath = path10.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.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"
     };
   }
@@ -1131,19 +1371,19 @@ var startHttpServer = () => {
 var CREDENTIALS_DIR = path10.join(os3.homedir(), ".amai");
 var CREDENTIALS_PATH = path10.join(CREDENTIALS_DIR, "credentials.json");
 function getTokens() {
-  if (!fs4.existsSync(CREDENTIALS_PATH)) {
+  if (!fs6.existsSync(CREDENTIALS_PATH)) {
     return null;
   }
-  const raw = fs4.readFileSync(CREDENTIALS_PATH, "utf8");
+  const raw = fs6.readFileSync(CREDENTIALS_PATH, "utf8");
   const data = JSON.parse(raw);
   return data;
 }
 var getUserId = () => {
   try {
-    if (!fs4.existsSync(CREDENTIALS_PATH)) {
+    if (!fs6.existsSync(CREDENTIALS_PATH)) {
       return;
     }
-    const raw = fs4.readFileSync(CREDENTIALS_PATH, "utf8");
+    const raw = fs6.readFileSync(CREDENTIALS_PATH, "utf8");
     const data = JSON.parse(raw);
     return {
       userId: data.user.id
@@ -1192,7 +1432,7 @@ z.object({
   command: z.string().describe("The terminal command to execute (e.g., 'ls -la', 'pwd', 'echo $HOME')"),
   is_background: 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}`);
@@ -1202,42 +1442,44 @@ var runSecureTerminalCommand = async (command, timeout) => {
         error: "HARMFUL_COMMAND_DETECTED"
       };
     }
-    return new Promise((resolve, reject) => {
-      const child = 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) => {
@@ -1251,13 +1493,12 @@ var runTerminalCommand = async (input, projectCwd) => {
           error: "HARMFUL_COMMAND_DETECTED"
         };
       }
-      const child = 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,
@@ -1267,9 +1508,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,
@@ -1288,7 +1533,7 @@ 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 = readdirSync(dir, { withFileTypes: true });
   for (const file of filePath) {
@@ -1310,28 +1555,34 @@ var IDE_PROJECTS_PATHS = {
 };
 function getWorkspaceStoragePath(ide) {
   const platform = os3.platform();
-  const appName = "Cursor" ;
+  const appName = ide === "cursor" ? "Cursor" : "Code";
+  const appNameLower = appName.toLowerCase();
   if (platform === "darwin") {
     return path10.join(HOME, "Library", "Application Support", appName, "User", "workspaceStorage");
   } else if (platform === "win32") {
     return path10.join(process.env.APPDATA || "", appName, "User", "workspaceStorage");
   } else {
-    return path10.join(HOME, ".config", appName, "User", "workspaceStorage");
+    const capitalizedPath = path10.join(HOME, ".config", appName, "User", "workspaceStorage");
+    const lowercasePath = path10.join(HOME, ".config", appNameLower, "User", "workspaceStorage");
+    if (fs6.existsSync(capitalizedPath)) {
+      return capitalizedPath;
+    }
+    return lowercasePath;
   }
 }
 function scanWorkspaceStorage(ide) {
   const projects = [];
-  const storagePath = getWorkspaceStoragePath();
-  if (!fs4.existsSync(storagePath)) {
+  const storagePath = getWorkspaceStoragePath(ide);
+  if (!fs6.existsSync(storagePath)) {
     return projects;
   }
   try {
-    const workspaces = fs4.readdirSync(storagePath);
+    const workspaces = fs6.readdirSync(storagePath);
     for (const workspace of workspaces) {
       const workspaceJsonPath = path10.join(storagePath, workspace, "workspace.json");
-      if (fs4.existsSync(workspaceJsonPath)) {
+      if (fs6.existsSync(workspaceJsonPath)) {
         try {
-          const content = fs4.readFileSync(workspaceJsonPath, "utf-8");
+          const content = fs6.readFileSync(workspaceJsonPath, "utf-8");
           const data = JSON.parse(content);
           if (data.folder && typeof data.folder === "string") {
             let projectPath = data.folder;
@@ -1339,7 +1590,7 @@ function scanWorkspaceStorage(ide) {
               projectPath = projectPath.replace("file://", "");
               projectPath = decodeURIComponent(projectPath);
             }
-            if (fs4.existsSync(projectPath) && fs4.statSync(projectPath).isDirectory()) {
+            if (fs6.existsSync(projectPath) && fs6.statSync(projectPath).isDirectory()) {
               projects.push({
                 name: path10.basename(projectPath),
                 path: projectPath,
@@ -1363,11 +1614,11 @@ var scanIdeProjects = async () => {
     const seenPaths = /* @__PURE__ */ new Set();
     const addProject = (projectPath, ide) => {
       try {
-        const resolvedPath = fs4.realpathSync(projectPath);
-        if (fs4.existsSync(resolvedPath) && fs4.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
+        const resolvedPath = fs6.realpathSync(projectPath);
+        if (fs6.existsSync(resolvedPath) && fs6.statSync(resolvedPath).isDirectory() && !seenPaths.has(resolvedPath)) {
           const isIdeProjectsDir = Object.values(IDE_PROJECTS_PATHS).some((ideDir) => {
             try {
-              return fs4.realpathSync(ideDir) === resolvedPath;
+              return fs6.realpathSync(ideDir) === resolvedPath;
             } catch {
               return false;
             }
@@ -1388,32 +1639,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 (fs4.existsSync(dirPath)) {
-        const projects = fs4.readdirSync(dirPath);
+      if (ide === "cursor" || ide === "vscode") continue;
+      if (fs6.existsSync(dirPath)) {
+        const projects = fs6.readdirSync(dirPath);
         projects.forEach((project) => {
           const projectPath = path10.join(dirPath, project);
           try {
-            const stats = fs4.lstatSync(projectPath);
+            const stats = fs6.lstatSync(projectPath);
             let actualPath = null;
             if (stats.isSymbolicLink()) {
-              actualPath = fs4.realpathSync(projectPath);
+              actualPath = fs6.realpathSync(projectPath);
             } else if (stats.isFile()) {
               try {
-                let content = fs4.readFileSync(projectPath, "utf-8").trim();
+                let content = fs6.readFileSync(projectPath, "utf-8").trim();
                 if (content.startsWith("~/") || content === "~") {
                   content = content.replace(/^~/, HOME);
                 }
                 const resolvedContent = path10.isAbsolute(content) ? content : path10.resolve(path10.dirname(projectPath), content);
-                if (fs4.existsSync(resolvedContent) && fs4.statSync(resolvedContent).isDirectory()) {
-                  actualPath = fs4.realpathSync(resolvedContent);
+                if (fs6.existsSync(resolvedContent) && fs6.statSync(resolvedContent).isDirectory()) {
+                  actualPath = fs6.realpathSync(resolvedContent);
                 }
               } catch {
                 return;
               }
             } else if (stats.isDirectory()) {
-              actualPath = fs4.realpathSync(projectPath);
+              actualPath = fs6.realpathSync(projectPath);
             }
             if (actualPath) {
               addProject(actualPath, ide);
@@ -1437,7 +1692,7 @@ var Global;
 })(Global || (Global = {}));
 
 // src/snapshot/snapshot.ts
-var execAsync2 = promisify(exec);
+var execAsync = promisify(exec);
 var Snapshot;
 ((Snapshot2) => {
   const log = {
@@ -1447,7 +1702,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",
@@ -1471,8 +1726,8 @@ var Snapshot;
     const worktree = project.cwd;
     const git = gitdir(projectId);
     try {
-      await fs5.mkdir(git, { recursive: true });
-      const gitExists = await fs5.access(path10.join(git, "HEAD")).then(() => true).catch(() => false);
+      await fs7.mkdir(git, { recursive: true });
+      const gitExists = await fs7.access(path10.join(git, "HEAD")).then(() => true).catch(() => false);
       if (!gitExists) {
         await runGit(`git init`, {
           env: { GIT_DIR: git, GIT_WORK_TREE: worktree }
@@ -1557,7 +1812,7 @@ var Snapshot;
         for (const file of newFiles) {
           const fullPath = path10.join(worktree, file);
           try {
-            await fs5.unlink(fullPath);
+            await fs7.unlink(fullPath);
             log.info("deleted newly created file", { file: fullPath });
           } catch {
           }
@@ -1594,7 +1849,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.unlink(file).catch(() => {
+            await fs7.unlink(file).catch(() => {
             });
           }
         }