@probelabs/probe 0.6.0-rc173 → 0.6.0-rc174

package/cjs/index.cjs

@@ -104,7 +104,7 @@ var require_package = __commonJS({
 // node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports2, module2) {
-    var fs8 = require("fs");
+    var fs9 = require("fs");
     var path8 = require("path");
     var os4 = require("os");
     var crypto2 = require("crypto");
@@ -213,7 +213,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs8.existsSync(filepath)) {
+            if (fs9.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -223,7 +223,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path8.resolve(process.cwd(), ".env.vault");
       }
-      if (fs8.existsSync(possibleVaultPath)) {
+      if (fs9.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -272,7 +272,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path9 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs8.readFileSync(path9, { encoding }));
+          const parsed = DotenvModule.parse(fs9.readFileSync(path9, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e4) {
           if (debug) {
@@ -563,6 +563,48 @@ var init_directory_resolver = __esm({
   }
 });
 
+// src/utils/symlink-utils.js
+async function getEntryType(entry, fullPath) {
+  try {
+    const stats = await import_fs2.promises.stat(fullPath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      isFile: entry.isFile(),
+      isDirectory: entry.isDirectory(),
+      size: 0
+    };
+  }
+}
+function getEntryTypeSync(entry, fullPath) {
+  try {
+    const stats = import_fs.default.statSync(fullPath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      isFile: entry.isFile(),
+      isDirectory: entry.isDirectory(),
+      size: 0
+    };
+  }
+}
+var import_fs, import_fs2;
+var init_symlink_utils = __esm({
+  "src/utils/symlink-utils.js"() {
+    "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_fs2 = require("fs");
+  }
+});
+
 // src/downloader.js
 function sanitizeError(err) {
   try {
@@ -1077,10 +1119,11 @@ async function extractBinary(assetPath, outputDir) {
       const entries = await import_fs_extra2.default.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = import_path2.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
+        const entryType = await getEntryType(entry, fullPath);
+        if (entryType.isDirectory) {
           const result = await findBinary(fullPath);
           if (result) return result;
-        } else if (entry.isFile()) {
+        } else if (entryType.isFile) {
           if (entry.name === binaryName || entry.name === BINARY_NAME || isWindows && entry.name.endsWith(".exe")) {
             return fullPath;
           }
@@ -1293,6 +1336,7 @@ var init_downloader = __esm({
     import_url2 = require("url");
     init_utils();
     init_directory_resolver();
+    init_symlink_utils();
     exec = (0, import_util.promisify)(import_child_process.exec);
     REPO_OWNER = "probelabs";
     REPO_NAME = "probe";
@@ -20478,7 +20522,7 @@ var require_dist_cjs56 = __commonJS({
     var httpAuthSchemes = (init_httpAuthSchemes2(), __toCommonJS(httpAuthSchemes_exports));
     var propertyProvider = require_dist_cjs24();
     var sharedIniFileLoader = require_dist_cjs42();
-    var fs8 = require("fs");
+    var fs9 = require("fs");
     var fromEnvSigningName = ({ logger: logger2, signingName } = {}) => async () => {
       logger2?.debug?.("@aws-sdk/token-providers - fromEnvSigningName");
       if (!signingName) {
@@ -20524,7 +20568,7 @@ var require_dist_cjs56 = __commonJS({
         throw new propertyProvider.TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
       }
     };
-    var { writeFile } = fs8.promises;
+    var { writeFile } = fs9.promises;
     var writeSSOTokenToFile = (id, ssoToken) => {
       const tokenFilepath = sharedIniFileLoader.getSSOTokenFilepath(id);
       const tokenString = JSON.stringify(ssoToken, null, 2);
@@ -38202,22 +38246,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs, actualFS, import_promises, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
+var import_node_path, import_node_url, import_fs3, actualFS, import_promises, realpathSync, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
 var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
     init_esm2();
     import_node_path = require("node:path");
     import_node_url = require("node:url");
-    import_fs = require("fs");
+    import_fs3 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync = import_fs.realpathSync.native;
+    realpathSync = import_fs3.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs.lstatSync,
-      readdir: import_fs.readdir,
-      readdirSync: import_fs.readdirSync,
-      readlinkSync: import_fs.readlinkSync,
+      lstatSync: import_fs3.lstatSync,
+      readdir: import_fs3.readdir,
+      readdirSync: import_fs3.readdirSync,
+      readlinkSync: import_fs3.readlinkSync,
       realpathSync,
       promises: {
         lstat: import_promises.lstat,
@@ -39328,8 +39372,8 @@ var init_esm4 = __esm({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs8 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs8);
+      constructor(cwd = process.cwd(), pathImpl, sep4, { nocase, childrenCacheSize = 16 * 1024, fs: fs9 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs9);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, import_node_url.fileURLToPath)(cwd);
         }
@@ -39887,8 +39931,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs8) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
+      newRoot(fs9) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -39916,8 +39960,8 @@ var init_esm4 = __esm({
       /**
        * @internal
        */
-      newRoot(fs8) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs8 });
+      newRoot(fs9) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs9 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -41126,7 +41170,7 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process6, import_util11, import_crypto3, import_events, import_fs2, import_fs3, import_path4, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process6, import_util11, import_crypto3, import_events, import_fs4, import_fs5, import_path4, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
@@ -41135,10 +41179,11 @@ var init_probeTool = __esm({
     import_util11 = require("util");
     import_crypto3 = require("crypto");
     import_events = require("events");
-    import_fs2 = __toESM(require("fs"), 1);
-    import_fs3 = require("fs");
+    import_fs4 = __toESM(require("fs"), 1);
+    import_fs5 = require("fs");
     import_path4 = __toESM(require("path"), 1);
     init_esm5();
+    init_symlink_utils();
     toolCallEmitter = new import_events.EventEmitter();
     activeToolExecutions = /* @__PURE__ */ new Map();
     wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
@@ -41244,7 +41289,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await import_fs3.promises.readdir(targetDir, { withFileTypes: true });
+          const files = await import_fs5.promises.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -41252,21 +41297,12 @@ var init_probeTool = __esm({
             return `${(size / (1024 * 1024 * 1024)).toFixed(1)}G`;
           };
           const entries = await Promise.all(files.map(async (file) => {
-            const isDirectory = file.isDirectory();
             const fullPath = import_path4.default.join(targetDir, file.name);
-            let size = 0;
-            try {
-              const stats = await import_fs3.promises.stat(fullPath);
-              size = stats.size;
-            } catch (statError) {
-              if (debug) {
-                console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
-              }
-            }
+            const entryType = await getEntryType(file, fullPath);
             return {
               name: file.name,
-              isDirectory,
-              size
+              isDirectory: entryType.isDirectory,
+              size: entryType.size
             };
           }));
           entries.sort((a4, b4) => {
@@ -55485,7 +55521,7 @@ function validateFlowchart(text, options = {}) {
         const byLine = /* @__PURE__ */ new Map();
         const collect = (arr) => {
           for (const e4 of arr || []) {
-            if (e4 && (e4.code === "FL-LABEL-PARENS-UNQUOTED" || e4.code === "FL-LABEL-AT-IN-UNQUOTED")) {
+            if (e4 && (e4.code === "FL-LABEL-PARENS-UNQUOTED" || e4.code === "FL-LABEL-AT-IN-UNQUOTED" || e4.code === "FL-LABEL-QUOTE-IN-UNQUOTED")) {
               const ln = e4.line ?? 0;
               const col = e4.column ?? 1;
               const list2 = byLine.get(ln) || [];
@@ -55566,6 +55602,8 @@ function validateFlowchart(text, options = {}) {
                 const covered = existing.some((r4) => !(endCol < r4.start || startCol > r4.end));
                 const hasParens = seg.includes("(") || seg.includes(")");
                 const hasAt = seg.includes("@");
+                const hasQuote = seg.includes('"');
+                const isSingleQuoted = /^'[^]*'$/.test(trimmed);
                 if (!covered && !isQuoted && !isParenWrapped && hasParens) {
                   errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-PARENS-UNQUOTED", message: "Parentheses inside an unquoted label are not supported by Mermaid.", hint: 'Wrap the label in quotes, e.g., A["Mark (X)"] \u2014 or replace ( and ) with HTML entities: &#40; and &#41;.' });
                   existing.push({ start: startCol, end: endCol });
@@ -55576,6 +55614,11 @@ function validateFlowchart(text, options = {}) {
                   existing.push({ start: startCol, end: endCol });
                   byLine.set(ln, existing);
                 }
+                if (!covered && !isQuoted && !isSlashPair && hasQuote && !isSingleQuoted) {
+                  errs.push({ line: ln, column: startCol, severity: "error", code: "FL-LABEL-QUOTE-IN-UNQUOTED", message: "Quotes are not allowed inside unquoted node labels. Use &quot; for quotes or wrap the entire label in quotes.", hint: 'Example: C["HTML Output: data-trigger-visibility=&quot;true&quot;"]' });
+                  existing.push({ start: startCol, end: endCol });
+                  byLine.set(ln, existing);
+                }
                 i4 = j4;
                 continue;
               } else {
@@ -79637,11 +79680,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs4.existsSync)(configPath)) {
+  if (!(0, import_fs6.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs4.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs6.readFileSync)(configPath, "utf8");
     const config = JSON.parse(content);
     if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
       console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -79666,9 +79709,9 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs4.existsSync)(configPath)) {
+    if ((0, import_fs6.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs4.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs6.readFileSync)(configPath, "utf8");
         config = JSON.parse(content);
         if (process.env.DEBUG === "1" || process.env.DEBUG_MCP === "1") {
           console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
@@ -79764,11 +79807,11 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs4, import_path5, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
+var import_fs6, import_path5, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs4 = require("fs");
+    import_fs6 = require("fs");
     import_path5 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
@@ -82637,7 +82680,7 @@ var ProbeAgent_exports = {};
 __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
-var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai2, import_crypto7, import_events4, import_fs5, import_promises3, import_path7, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv, import_anthropic2, import_openai2, import_google2, import_ai2, import_crypto7, import_events4, import_fs7, import_promises3, import_path7, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     "use strict";
@@ -82649,7 +82692,7 @@ var init_ProbeAgent = __esm({
     import_ai2 = require("ai");
     import_crypto7 = require("crypto");
     import_events4 = require("events");
-    import_fs5 = require("fs");
+    import_fs7 = require("fs");
     import_promises3 = require("fs/promises");
     import_path7 = require("path");
     init_tokenCounter();
@@ -86743,7 +86786,7 @@ async function executeBashCommand(command, options = {}) {
   let cwd = workingDirectory;
   try {
     cwd = (0, import_path8.resolve)(cwd);
-    if (!(0, import_fs6.existsSync)(cwd)) {
+    if (!(0, import_fs8.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error2) {
@@ -86955,7 +86998,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs6.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs8.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -86968,13 +87011,13 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process9, import_path8, import_fs6;
+var import_child_process9, import_path8, import_fs8;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process9 = require("child_process");
     import_path8 = require("path");
-    import_fs6 = require("fs");
+    import_fs8 = require("fs");
     init_bashCommandUtils();
   }
 });
@@ -87170,14 +87213,14 @@ function parseFileToolOptions(options = {}) {
     defaultPath: options.defaultPath
   };
 }
-var import_ai5, import_fs7, import_path10, import_fs8, editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var import_ai5, import_fs9, import_path10, import_fs10, editTool, createTool, editSchema, createSchema, editDescription, createDescription, editToolDefinition, createToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai5 = require("ai");
-    import_fs7 = require("fs");
+    import_fs9 = require("fs");
     import_path10 = require("path");
-    import_fs8 = require("fs");
+    import_fs10 = require("fs");
     editTool = (options = {}) => {
       const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
       return (0, import_ai5.tool)({
@@ -87237,10 +87280,10 @@ Important:
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
             }
-            if (!(0, import_fs8.existsSync)(resolvedPath2)) {
+            if (!(0, import_fs10.existsSync)(resolvedPath2)) {
               return `Error editing file: File not found - ${file_path}`;
             }
-            const content = await import_fs7.promises.readFile(resolvedPath2, "utf-8");
+            const content = await import_fs9.promises.readFile(resolvedPath2, "utf-8");
             if (!content.includes(old_string)) {
               return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
             }
@@ -87257,7 +87300,7 @@ Important:
             if (newContent === content) {
               return `Error editing file: No changes made - old_string and new_string might be the same`;
             }
-            await import_fs7.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            await import_fs9.promises.writeFile(resolvedPath2, newContent, "utf-8");
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath2}, replaced ${replacedCount} occurrence(s)`);
@@ -87321,13 +87364,13 @@ Important:
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
             }
-            if ((0, import_fs8.existsSync)(resolvedPath2) && !overwrite) {
+            if ((0, import_fs10.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
             const dir = (0, import_path10.dirname)(resolvedPath2);
-            await import_fs7.promises.mkdir(dir, { recursive: true });
-            await import_fs7.promises.writeFile(resolvedPath2, content, "utf-8");
-            const action = (0, import_fs8.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
+            await import_fs9.promises.mkdir(dir, { recursive: true });
+            await import_fs9.promises.writeFile(resolvedPath2, content, "utf-8");
+            const action = (0, import_fs10.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
               console.error(`[Create] Successfully ${action} ${resolvedPath2}`);
@@ -87743,10 +87786,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs9.default.existsSync(directory)) {
+  if (!import_fs11.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs9.default.existsSync(import_path11.default.join(directory, ".git"));
+  const gitDirExists = import_fs11.default.existsSync(import_path11.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -87777,8 +87820,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs9.default.readdirSync(dir, { withFileTypes: true });
-      const files = entries.filter((entry) => entry.isFile());
+      const entries = import_fs11.default.readdirSync(dir, { withFileTypes: true });
+      const files = entries.filter((entry) => {
+        const fullPath = import_path11.default.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isFile;
+      });
       for (const file of files) {
         if (result.length >= maxFiles) break;
         const filePath = import_path11.default.join(dir, file.name);
@@ -87786,7 +87832,10 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
         if (shouldIgnore(relativePath, ignorePatterns)) continue;
         result.push(relativePath);
       }
-      const dirs = entries.filter((entry) => entry.isDirectory());
+      const dirs = entries.filter((entry) => {
+        const fullPath = import_path11.default.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isDirectory;
+      });
       for (const subdir of dirs) {
         const subdirPath = import_path11.default.join(dir, subdir.name);
         const relativeSubdirPath = import_path11.default.relative(directory, subdirPath);
@@ -87802,11 +87851,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = import_path11.default.join(directory, ".gitignore");
-  if (!import_fs9.default.existsSync(gitignorePath)) {
+  if (!import_fs11.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs9.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs11.default.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error2) {
     console.error(`Warning: Could not read .gitignore: ${error2.message}`);
@@ -87824,14 +87873,15 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs9, import_path11, import_util12, import_child_process10, execAsync3;
+var import_fs11, import_path11, import_util12, import_child_process10, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs9 = __toESM(require("fs"), 1);
+    import_fs11 = __toESM(require("fs"), 1);
     import_path11 = __toESM(require("path"), 1);
     import_util12 = require("util");
     import_child_process10 = require("child_process");
+    init_symlink_utils();
     execAsync3 = (0, import_util12.promisify)(import_child_process10.exec);
   }
 });
@@ -87846,11 +87896,11 @@ function initializeSimpleTelemetryFromOptions(options) {
   });
   return telemetry;
 }
-var import_fs10, import_path12, SimpleTelemetry, SimpleAppTracer;
+var import_fs12, import_path12, SimpleTelemetry, SimpleAppTracer;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs10 = require("fs");
+    import_fs12 = require("fs");
     import_path12 = require("path");
     SimpleTelemetry = class {
       constructor(options = {}) {
@@ -87866,10 +87916,10 @@ var init_simpleTelemetry = __esm({
       initializeFileExporter() {
         try {
           const dir = (0, import_path12.dirname)(this.filePath);
-          if (!(0, import_fs10.existsSync)(dir)) {
-            (0, import_fs10.mkdirSync)(dir, { recursive: true });
+          if (!(0, import_fs12.existsSync)(dir)) {
+            (0, import_fs12.mkdirSync)(dir, { recursive: true });
           }
-          this.stream = (0, import_fs10.createWriteStream)(this.filePath, { flags: "a" });
+          this.stream = (0, import_fs12.createWriteStream)(this.filePath, { flags: "a" });
           this.stream.on("error", (error2) => {
             console.error(`[SimpleTelemetry] Stream error: ${error2.message}`);
           });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc173",
+  "version": "0.6.0-rc174",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -79,7 +79,7 @@
     "@ai-sdk/openai": "^2.0.10",
     "@anthropic-ai/claude-agent-sdk": "^0.1.46",
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@probelabs/maid": "^0.0.21",
+    "@probelabs/maid": "^0.0.22",
     "adm-zip": "^0.5.16",
     "ai": "^5.0.0",
     "ajv": "^8.17.1",

package/src/agent/probeTool.js

@@ -8,6 +8,7 @@ import fs from 'fs';
 import { promises as fsPromises } from 'fs';
 import path from 'path';
 import { glob } from 'glob';
+import { getEntryType } from '../utils/symlink-utils.js';
 
 // Create an event emitter for tool calls (simplified for single-shot operations)
 export const toolCallEmitter = new EventEmitter();
@@ -287,23 +288,13 @@ export const listFilesTool = {
 
       // Format the results as ls-style output
       const entries = await Promise.all(files.map(async (file) => {
-        const isDirectory = file.isDirectory();
         const fullPath = path.join(targetDir, file.name);
-
-        let size = 0;
-        try {
-          const stats = await fsPromises.stat(fullPath);
-          size = stats.size;
-        } catch (statError) {
-          if (debug) {
-            console.log(`[DEBUG] Could not stat file ${file.name}:`, statError.message);
-          }
-        }
+        const entryType = await getEntryType(file, fullPath);
 
         return {
           name: file.name,
-          isDirectory,
-          size
+          isDirectory: entryType.isDirectory,
+          size: entryType.size
         };
       }));
 

package/src/downloader.js

@@ -14,6 +14,7 @@ import os from 'os';
 import { fileURLToPath } from 'url';
 import { ensureBinDirectory } from './utils.js';
 import { getPackageBinDir } from './directory-resolver.js';
+import { getEntryType } from './utils/symlink-utils.js';
 
 const exec = promisify(execCallback);
 
@@ -770,10 +771,13 @@ async function extractBinary(assetPath, outputDir) {
 			for (const entry of entries) {
 				const fullPath = path.join(dir, entry.name);
 
-				if (entry.isDirectory()) {
+				// Use shared utility to follow symlinks and get actual target type
+				const entryType = await getEntryType(entry, fullPath);
+
+				if (entryType.isDirectory) {
 					const result = await findBinary(fullPath);
 					if (result) return result;
-				} else if (entry.isFile()) {
+				} else if (entryType.isFile) {
 					// Check if this is the binary we're looking for
 					if (entry.name === binaryName ||
 						entry.name === BINARY_NAME ||

package/src/extractor.js

@@ -9,6 +9,7 @@ import tar from 'tar';
 import AdmZip from 'adm-zip';
 import os from 'os';
 import { fileURLToPath } from 'url';
+import { getEntryType } from './utils/symlink-utils.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -148,10 +149,13 @@ async function findBinary(dir, baseDir, binaryName, isWindows) {
 			continue;
 		}
 
-		if (entry.isDirectory()) {
+		// Use shared utility to follow symlinks and get actual target type
+		const entryType = await getEntryType(entry, fullPath);
+
+		if (entryType.isDirectory) {
 			const result = await findBinary(fullPath, baseDir, binaryName, isWindows);
 			if (result) return result;
-		} else if (entry.isFile()) {
+		} else if (entryType.isFile) {
 			// Check if this is the binary we're looking for
 			if (entry.name === binaryName ||
 				entry.name === BINARY_NAME ||

package/src/utils/file-lister.js

@@ -7,6 +7,7 @@ import fs from 'fs';
 import path from 'path';
 import { promisify } from 'util';
 import { exec } from 'child_process';
+import { getEntryTypeSync } from './symlink-utils.js';
 
 const execAsync = promisify(exec);
 
@@ -101,7 +102,10 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 			const entries = fs.readdirSync(dir, { withFileTypes: true });
 
 			// Process files first (at current level)
-			const files = entries.filter(entry => entry.isFile());
+			const files = entries.filter(entry => {
+				const fullPath = path.join(dir, entry.name);
+				return getEntryTypeSync(entry, fullPath).isFile;
+			});
 			for (const file of files) {
 				if (result.length >= maxFiles) break;
 
@@ -115,7 +119,10 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 			}
 
 			// Then add directories to queue for next level
-			const dirs = entries.filter(entry => entry.isDirectory());
+			const dirs = entries.filter(entry => {
+				const fullPath = path.join(dir, entry.name);
+				return getEntryTypeSync(entry, fullPath).isDirectory;
+			});
 			for (const subdir of dirs) {
 				const subdirPath = path.join(dir, subdir.name);
 				const relativeSubdirPath = path.relative(directory, subdirPath);