@probelabs/probe 0.6.0-rc172 → 0.6.0-rc174

package/build/utils/symlink-utils.js

@@ -0,0 +1,63 @@
+/**
+ * Symlink resolution utilities for the probe package
+ * @module utils/symlink-utils
+ */
+
+import fs from 'fs';
+import { promises as fsPromises } from 'fs';
+
+/**
+ * Get entry type following symlinks (async version)
+ *
+ * Uses fs.stat() which follows symlinks to get the actual target type.
+ * Falls back to dirent type if stat fails (e.g., broken symlink).
+ *
+ * @param {fs.Dirent} entry - Directory entry from readdir
+ * @param {string} fullPath - Full path to the entry
+ * @returns {Promise<{isFile: boolean, isDirectory: boolean, size: number}>}
+ */
+export async function getEntryType(entry, fullPath) {
+	try {
+		const stats = await fsPromises.stat(fullPath);
+		return {
+			isFile: stats.isFile(),
+			isDirectory: stats.isDirectory(),
+			size: stats.size
+		};
+	} catch {
+		// Fall back to dirent type if stat fails (e.g., broken symlink)
+		return {
+			isFile: entry.isFile(),
+			isDirectory: entry.isDirectory(),
+			size: 0
+		};
+	}
+}
+
+/**
+ * Get entry type following symlinks (sync version)
+ *
+ * Uses fs.statSync() which follows symlinks to get the actual target type.
+ * Falls back to dirent type if stat fails (e.g., broken symlink).
+ *
+ * @param {fs.Dirent} entry - Directory entry from readdir
+ * @param {string} fullPath - Full path to the entry
+ * @returns {{isFile: boolean, isDirectory: boolean, size: number}}
+ */
+export function getEntryTypeSync(entry, fullPath) {
+	try {
+		const stats = fs.statSync(fullPath);
+		return {
+			isFile: stats.isFile(),
+			isDirectory: stats.isDirectory(),
+			size: stats.size
+		};
+	} catch {
+		// Fall back to dirent type if stat fails (e.g., broken symlink)
+		return {
+			isFile: entry.isFile(),
+			isDirectory: entry.isDirectory(),
+			size: 0
+		};
+	}
+}

package/cjs/agent/ProbeAgent.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) {
@@ -19036,7 +19036,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) {
@@ -19082,7 +19082,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);
@@ -28312,6 +28312,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 {
@@ -28826,10 +28868,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;
           }
@@ -29042,6 +29085,7 @@ var init_downloader = __esm({
     import_url2 = require("url");
     init_utils2();
     init_directory_resolver();
+    init_symlink_utils();
     exec = (0, import_util3.promisify)(import_child_process.exec);
     REPO_OWNER = "probelabs";
     REPO_NAME = "probe";
@@ -35368,7 +35412,7 @@ async function executeBashCommand(command, options = {}) {
   let cwd = workingDirectory;
   try {
     cwd = (0, import_path4.resolve)(cwd);
-    if (!(0, import_fs.existsSync)(cwd)) {
+    if (!(0, import_fs3.existsSync)(cwd)) {
       throw new Error(`Working directory does not exist: ${cwd}`);
     }
   } catch (error2) {
@@ -35580,7 +35624,7 @@ function validateExecutionOptions(options = {}) {
   if (options.workingDirectory) {
     if (typeof options.workingDirectory !== "string") {
       errors.push("workingDirectory must be a string");
-    } else if (!(0, import_fs.existsSync)(options.workingDirectory)) {
+    } else if (!(0, import_fs3.existsSync)(options.workingDirectory)) {
       errors.push(`workingDirectory does not exist: ${options.workingDirectory}`);
     }
   }
@@ -35593,13 +35637,13 @@ function validateExecutionOptions(options = {}) {
     warnings
   };
 }
-var import_child_process6, import_path4, import_fs;
+var import_child_process6, import_path4, import_fs3;
 var init_bashExecutor = __esm({
   "src/agent/bashExecutor.js"() {
     "use strict";
     import_child_process6 = require("child_process");
     import_path4 = require("path");
-    import_fs = require("fs");
+    import_fs3 = require("fs");
     init_bashCommandUtils();
   }
 });
@@ -35795,14 +35839,14 @@ function parseFileToolOptions(options = {}) {
     defaultPath: options.defaultPath
   };
 }
-var import_ai3, import_fs2, import_path6, import_fs3, editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
+var import_ai3, import_fs4, import_path6, import_fs5, editTool, createTool, editDescription, createDescription, editToolDefinition, createToolDefinition;
 var init_edit = __esm({
   "src/tools/edit.js"() {
     "use strict";
     import_ai3 = require("ai");
-    import_fs2 = require("fs");
+    import_fs4 = require("fs");
     import_path6 = require("path");
-    import_fs3 = require("fs");
+    import_fs5 = require("fs");
     editTool = (options = {}) => {
       const { debug, allowedFolders, defaultPath } = parseFileToolOptions(options);
       return (0, import_ai3.tool)({
@@ -35862,10 +35906,10 @@ Important:
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               return `Error editing file: Permission denied - ${file_path} is outside allowed directories`;
             }
-            if (!(0, import_fs3.existsSync)(resolvedPath2)) {
+            if (!(0, import_fs5.existsSync)(resolvedPath2)) {
               return `Error editing file: File not found - ${file_path}`;
             }
-            const content = await import_fs2.promises.readFile(resolvedPath2, "utf-8");
+            const content = await import_fs4.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}`;
             }
@@ -35882,7 +35926,7 @@ Important:
             if (newContent === content) {
               return `Error editing file: No changes made - old_string and new_string might be the same`;
             }
-            await import_fs2.promises.writeFile(resolvedPath2, newContent, "utf-8");
+            await import_fs4.promises.writeFile(resolvedPath2, newContent, "utf-8");
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath2}, replaced ${replacedCount} occurrence(s)`);
@@ -35946,13 +35990,13 @@ Important:
             if (!isPathAllowed(resolvedPath2, allowedFolders)) {
               return `Error creating file: Permission denied - ${file_path} is outside allowed directories`;
             }
-            if ((0, import_fs3.existsSync)(resolvedPath2) && !overwrite) {
+            if ((0, import_fs5.existsSync)(resolvedPath2) && !overwrite) {
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
             const dir = (0, import_path6.dirname)(resolvedPath2);
-            await import_fs2.promises.mkdir(dir, { recursive: true });
-            await import_fs2.promises.writeFile(resolvedPath2, content, "utf-8");
-            const action = (0, import_fs3.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
+            await import_fs4.promises.mkdir(dir, { recursive: true });
+            await import_fs4.promises.writeFile(resolvedPath2, content, "utf-8");
+            const action = (0, import_fs5.existsSync)(resolvedPath2) && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
               console.error(`[Create] Successfully ${action} ${resolvedPath2}`);
@@ -36227,10 +36271,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!import_fs4.default.existsSync(directory)) {
+  if (!import_fs6.default.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = import_fs4.default.existsSync(import_path7.default.join(directory, ".git"));
+  const gitDirExists = import_fs6.default.existsSync(import_path7.default.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -36261,8 +36305,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = import_fs4.default.readdirSync(dir, { withFileTypes: true });
-      const files = entries.filter((entry) => entry.isFile());
+      const entries = import_fs6.default.readdirSync(dir, { withFileTypes: true });
+      const files = entries.filter((entry) => {
+        const fullPath = import_path7.default.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isFile;
+      });
       for (const file of files) {
         if (result.length >= maxFiles) break;
         const filePath = import_path7.default.join(dir, file.name);
@@ -36270,7 +36317,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_path7.default.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isDirectory;
+      });
       for (const subdir of dirs) {
         const subdirPath = import_path7.default.join(dir, subdir.name);
         const relativeSubdirPath = import_path7.default.relative(directory, subdirPath);
@@ -36286,11 +36336,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = import_path7.default.join(directory, ".gitignore");
-  if (!import_fs4.default.existsSync(gitignorePath)) {
+  if (!import_fs6.default.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = import_fs4.default.readFileSync(gitignorePath, "utf8");
+    const content = import_fs6.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}`);
@@ -36308,24 +36358,25 @@ function shouldIgnore(filePath, ignorePatterns) {
   }
   return false;
 }
-var import_fs4, import_path7, import_util11, import_child_process7, execAsync3;
+var import_fs6, import_path7, import_util11, import_child_process7, execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
-    import_fs4 = __toESM(require("fs"), 1);
+    import_fs6 = __toESM(require("fs"), 1);
     import_path7 = __toESM(require("path"), 1);
     import_util11 = require("util");
     import_child_process7 = require("child_process");
+    init_symlink_utils();
     execAsync3 = (0, import_util11.promisify)(import_child_process7.exec);
   }
 });
 
 // src/agent/simpleTelemetry.js
-var import_fs5, import_path8;
+var import_fs7, import_path8;
 var init_simpleTelemetry = __esm({
   "src/agent/simpleTelemetry.js"() {
     "use strict";
-    import_fs5 = require("fs");
+    import_fs7 = require("fs");
     import_path8 = require("path");
   }
 });
@@ -40163,22 +40214,22 @@ var init_esm3 = __esm({
 });
 
 // node_modules/path-scurry/dist/esm/index.js
-var import_node_path, import_node_url, import_fs6, 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_fs8, 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_fs6 = require("fs");
+    import_fs8 = require("fs");
     actualFS = __toESM(require("node:fs"), 1);
     import_promises = require("node:fs/promises");
     init_esm3();
-    realpathSync = import_fs6.realpathSync.native;
+    realpathSync = import_fs8.realpathSync.native;
     defaultFS = {
-      lstatSync: import_fs6.lstatSync,
-      readdir: import_fs6.readdir,
-      readdirSync: import_fs6.readdirSync,
-      readlinkSync: import_fs6.readlinkSync,
+      lstatSync: import_fs8.lstatSync,
+      readdir: import_fs8.readdir,
+      readdirSync: import_fs8.readdirSync,
+      readlinkSync: import_fs8.readlinkSync,
       realpathSync,
       promises: {
         lstat: import_promises.lstat,
@@ -41289,8 +41340,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);
         }
@@ -41848,8 +41899,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
@@ -41877,8 +41928,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
@@ -43087,7 +43138,7 @@ function createWrappedTools(baseTools) {
   }
   return wrappedTools;
 }
-var import_child_process8, import_util12, import_crypto3, import_events, import_fs7, import_fs8, import_path9, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
+var import_child_process8, import_util12, import_crypto3, import_events, import_fs9, import_fs10, import_path9, toolCallEmitter, activeToolExecutions, wrapToolWithEmitter, listFilesTool, searchFilesTool, listFilesToolInstance, searchFilesToolInstance;
 var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
@@ -43096,10 +43147,11 @@ var init_probeTool = __esm({
     import_util12 = require("util");
     import_crypto3 = require("crypto");
     import_events = require("events");
-    import_fs7 = __toESM(require("fs"), 1);
-    import_fs8 = require("fs");
+    import_fs9 = __toESM(require("fs"), 1);
+    import_fs10 = require("fs");
     import_path9 = __toESM(require("path"), 1);
     init_esm5();
+    init_symlink_utils();
     toolCallEmitter = new import_events.EventEmitter();
     activeToolExecutions = /* @__PURE__ */ new Map();
     wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
@@ -43205,7 +43257,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await import_fs8.promises.readdir(targetDir, { withFileTypes: true });
+          const files = await import_fs10.promises.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -43213,21 +43265,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_path9.default.join(targetDir, file.name);
-            let size = 0;
-            try {
-              const stats = await import_fs8.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) => {
@@ -57747,7 +57790,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) || [];
@@ -57828,6 +57871,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 });
@@ -57838,6 +57883,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 {
@@ -81899,11 +81949,11 @@ function loadMCPConfigurationFromPath(configPath) {
   if (!configPath) {
     throw new Error("Config path is required");
   }
-  if (!(0, import_fs9.existsSync)(configPath)) {
+  if (!(0, import_fs11.existsSync)(configPath)) {
     throw new Error(`MCP configuration file not found: ${configPath}`);
   }
   try {
-    const content = (0, import_fs9.readFileSync)(configPath, "utf8");
+    const content = (0, import_fs11.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}`);
@@ -81928,9 +81978,9 @@ function loadMCPConfiguration() {
   ].filter(Boolean);
   let config = null;
   for (const configPath of configPaths) {
-    if ((0, import_fs9.existsSync)(configPath)) {
+    if ((0, import_fs11.existsSync)(configPath)) {
       try {
-        const content = (0, import_fs9.readFileSync)(configPath, "utf8");
+        const content = (0, import_fs11.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}`);
@@ -82026,11 +82076,11 @@ function parseEnabledServers(config) {
   }
   return servers;
 }
-var import_fs9, import_path10, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
+var import_fs11, import_path10, import_os3, import_url4, __filename4, __dirname4, DEFAULT_CONFIG;
 var init_config = __esm({
   "src/agent/mcp/config.js"() {
     "use strict";
-    import_fs9 = require("fs");
+    import_fs11 = require("fs");
     import_path10 = require("path");
     import_os3 = require("os");
     import_url4 = require("url");
@@ -84900,7 +84950,7 @@ __export(ProbeAgent_exports, {
   ProbeAgent: () => ProbeAgent
 });
 module.exports = __toCommonJS(ProbeAgent_exports);
-var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto8, import_events4, import_fs10, import_promises3, import_path12, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
+var import_dotenv2, import_anthropic2, import_openai2, import_google2, import_ai5, import_crypto8, import_events4, import_fs12, import_promises3, import_path12, MAX_TOOL_ITERATIONS, MAX_HISTORY_MESSAGES, MAX_IMAGE_FILE_SIZE, ProbeAgent;
 var init_ProbeAgent = __esm({
   "src/agent/ProbeAgent.js"() {
     import_dotenv2 = __toESM(require_main(), 1);
@@ -84911,7 +84961,7 @@ var init_ProbeAgent = __esm({
     import_ai5 = require("ai");
     import_crypto8 = require("crypto");
     import_events4 = require("events");
-    import_fs10 = require("fs");
+    import_fs12 = require("fs");
     import_promises3 = require("fs/promises");
     import_path12 = require("path");
     init_tokenCounter();