@probelabs/probe 0.6.0-rc173 → 0.6.0-rc174

package/build/agent/index.js

@@ -2210,9 +2210,50 @@ var init_directory_resolver = __esm({
   }
 });
 
+// src/utils/symlink-utils.js
+import fs2 from "fs";
+import { promises as fsPromises } from "fs";
+async function getEntryType(entry, fullPath) {
+  try {
+    const stats = await fsPromises.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 = fs2.statSync(fullPath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      size: stats.size
+    };
+  } catch {
+    return {
+      isFile: entry.isFile(),
+      isDirectory: entry.isDirectory(),
+      size: 0
+    };
+  }
+}
+var init_symlink_utils = __esm({
+  "src/utils/symlink-utils.js"() {
+    "use strict";
+  }
+});
+
 // src/downloader.js
 import axios from "axios";
-import fs2 from "fs-extra";
+import fs3 from "fs-extra";
 import path2 from "path";
 import { createHash } from "crypto";
 import { promisify } from "util";
@@ -2249,7 +2290,7 @@ async function acquireFileLock(lockPath, version) {
     timestamp: Date.now()
   };
   try {
-    await fs2.writeFile(lockPath, JSON.stringify(lockData), { flag: "wx" });
+    await fs3.writeFile(lockPath, JSON.stringify(lockData), { flag: "wx" });
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log(`Acquired file lock: ${lockPath}`);
     }
@@ -2257,13 +2298,13 @@ async function acquireFileLock(lockPath, version) {
   } catch (error) {
     if (error.code === "EEXIST") {
       try {
-        const existingLock = JSON.parse(await fs2.readFile(lockPath, "utf-8"));
+        const existingLock = JSON.parse(await fs3.readFile(lockPath, "utf-8"));
         const lockAge = Date.now() - existingLock.timestamp;
         if (lockAge > LOCK_TIMEOUT_MS) {
           if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
             console.log(`Removing stale lock file (age: ${Math.round(lockAge / 1e3)}s, pid: ${existingLock.pid})`);
           }
-          await fs2.remove(lockPath);
+          await fs3.remove(lockPath);
           return false;
         }
         if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2275,7 +2316,7 @@ async function acquireFileLock(lockPath, version) {
           console.log(`Lock file corrupted, removing: ${readError.message}`);
         }
         try {
-          await fs2.remove(lockPath);
+          await fs3.remove(lockPath);
         } catch {
         }
         return false;
@@ -2297,7 +2338,7 @@ async function acquireFileLock(lockPath, version) {
 }
 async function releaseFileLock(lockPath) {
   try {
-    await fs2.remove(lockPath);
+    await fs3.remove(lockPath);
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log(`Released file lock: ${lockPath}`);
     }
@@ -2310,13 +2351,13 @@ async function releaseFileLock(lockPath) {
 async function waitForFileLock(lockPath, binaryPath) {
   const startTime = Date.now();
   while (Date.now() - startTime < MAX_LOCK_WAIT_MS) {
-    if (await fs2.pathExists(binaryPath)) {
+    if (await fs3.pathExists(binaryPath)) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Binary now available at ${binaryPath}, download completed by another process`);
       }
       return true;
     }
-    const lockExists = await fs2.pathExists(lockPath);
+    const lockExists = await fs3.pathExists(lockPath);
     if (!lockExists) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Lock file removed but binary not found - download may have failed`);
@@ -2324,7 +2365,7 @@ async function waitForFileLock(lockPath, binaryPath) {
       return false;
     }
     try {
-      const lockData = JSON.parse(await fs2.readFile(lockPath, "utf-8"));
+      const lockData = JSON.parse(await fs3.readFile(lockPath, "utf-8"));
       const lockAge = Date.now() - lockData.timestamp;
       if (lockAge > LOCK_TIMEOUT_MS) {
         if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2642,13 +2683,13 @@ function findBestAsset(assets, osInfo, archInfo) {
   return bestAsset;
 }
 async function downloadAsset(asset, outputDir) {
-  await fs2.ensureDir(outputDir);
+  await fs3.ensureDir(outputDir);
   const assetPath = path2.join(outputDir, asset.name);
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Downloading ${asset.name}...`);
   }
   const assetResponse = await axios.get(asset.url, { responseType: "arraybuffer" });
-  await fs2.writeFile(assetPath, Buffer.from(assetResponse.data));
+  await fs3.writeFile(assetPath, Buffer.from(assetResponse.data));
   const checksumUrl = asset.checksumUrl || `${asset.url}.sha256`;
   const checksumFileName = asset.checksumName || `${asset.name}.sha256`;
   let checksumPath = null;
@@ -2658,7 +2699,7 @@ async function downloadAsset(asset, outputDir) {
     }
     const checksumResponse = await axios.get(checksumUrl);
     checksumPath = path2.join(outputDir, checksumFileName);
-    await fs2.writeFile(checksumPath, checksumResponse.data);
+    await fs3.writeFile(checksumPath, checksumResponse.data);
   } catch (error) {
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log("No checksum file found, skipping verification");
@@ -2673,9 +2714,9 @@ async function verifyChecksum(assetPath, checksumPath) {
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Verifying checksum...`);
   }
-  const checksumContent = await fs2.readFile(checksumPath, "utf-8");
+  const checksumContent = await fs3.readFile(checksumPath, "utf-8");
   const expectedChecksum = checksumContent.trim().split(" ")[0];
-  const fileBuffer = await fs2.readFile(assetPath);
+  const fileBuffer = await fs3.readFile(assetPath);
   const actualChecksum = createHash("sha256").update(fileBuffer).digest("hex");
   if (expectedChecksum !== actualChecksum) {
     console.error(`Checksum verification failed!`);
@@ -2698,7 +2739,7 @@ async function extractBinary(assetPath, outputDir) {
   const binaryPath = path2.join(outputDir, binaryName);
   try {
     const extractDir = path2.join(outputDir, "temp_extract");
-    await fs2.ensureDir(extractDir);
+    await fs3.ensureDir(extractDir);
     if (assetName.endsWith(".tar.gz") || assetName.endsWith(".tgz")) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Extracting tar.gz to ${extractDir}...`);
@@ -2716,11 +2757,11 @@ async function extractBinary(assetPath, outputDir) {
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Copying binary directly to ${binaryPath}`);
       }
-      await fs2.copyFile(assetPath, binaryPath);
+      await fs3.copyFile(assetPath, binaryPath);
       if (!isWindows) {
-        await fs2.chmod(binaryPath, 493);
+        await fs3.chmod(binaryPath, 493);
       }
-      await fs2.remove(extractDir);
+      await fs3.remove(extractDir);
       if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
         console.log(`Binary installed to ${binaryPath}`);
       }
@@ -2730,13 +2771,14 @@ async function extractBinary(assetPath, outputDir) {
       console.log(`Searching for binary in extracted files...`);
     }
     const findBinary = async (dir) => {
-      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      const entries = await fs3.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path2.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;
           }
@@ -2746,7 +2788,7 @@ async function extractBinary(assetPath, outputDir) {
     };
     const binaryFilePath = await findBinary(extractDir);
     if (!binaryFilePath) {
-      const allFiles = await fs2.readdir(extractDir, { recursive: true });
+      const allFiles = await fs3.readdir(extractDir, { recursive: true });
       console.error(`Binary not found in extracted files. Found: ${allFiles.join(", ")}`);
       throw new Error(`Binary not found in the archive.`);
     }
@@ -2754,11 +2796,11 @@ async function extractBinary(assetPath, outputDir) {
       console.log(`Found binary at ${binaryFilePath}`);
       console.log(`Copying binary to ${binaryPath}`);
     }
-    await fs2.copyFile(binaryFilePath, binaryPath);
+    await fs3.copyFile(binaryFilePath, binaryPath);
     if (!isWindows) {
-      await fs2.chmod(binaryPath, 493);
+      await fs3.chmod(binaryPath, 493);
     }
-    await fs2.remove(extractDir);
+    await fs3.remove(extractDir);
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
       console.log(`Binary successfully installed to ${binaryPath}`);
     }
@@ -2771,8 +2813,8 @@ async function extractBinary(assetPath, outputDir) {
 async function getVersionInfo(binDir) {
   try {
     const versionInfoPath = path2.join(binDir, "version-info.json");
-    if (await fs2.pathExists(versionInfoPath)) {
-      const content = await fs2.readFile(versionInfoPath, "utf-8");
+    if (await fs3.pathExists(versionInfoPath)) {
+      const content = await fs3.readFile(versionInfoPath, "utf-8");
       return JSON.parse(content);
     }
     return null;
@@ -2787,7 +2829,7 @@ async function saveVersionInfo(version, binDir) {
     lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
   };
   const versionInfoPath = path2.join(binDir, "version-info.json");
-  await fs2.writeFile(versionInfoPath, JSON.stringify(versionInfo, null, 2));
+  await fs3.writeFile(versionInfoPath, JSON.stringify(versionInfo, null, 2));
   if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
     console.log(`Version info saved: ${version} at ${versionInfoPath}`);
   }
@@ -2802,11 +2844,11 @@ async function getPackageVersion() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        if (fs2.existsSync(packageJsonPath)) {
+        if (fs3.existsSync(packageJsonPath)) {
           if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
             console.log(`Found package.json at: ${packageJsonPath}`);
           }
-          const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+          const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
           if (packageJson.version) {
             if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
               console.log(`Using version from package.json: ${packageJson.version}`);
@@ -2862,9 +2904,9 @@ async function doDownload(version) {
   const extractedBinaryPath = await extractBinary(assetPath, localDir);
   await saveVersionInfo(tagVersion, localDir);
   try {
-    await fs2.remove(assetPath);
+    await fs3.remove(assetPath);
     if (checksumPath) {
-      await fs2.remove(checksumPath);
+      await fs3.remove(checksumPath);
     }
   } catch (err) {
     if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2885,7 +2927,7 @@ async function downloadProbeBinary(version) {
     const isWindows = os2.platform() === "win32";
     const binaryName = isWindows ? `${BINARY_NAME}.exe` : `${BINARY_NAME}-binary`;
     const binaryPath = path2.join(localDir, binaryName);
-    if (await fs2.pathExists(binaryPath)) {
+    if (await fs3.pathExists(binaryPath)) {
       const versionInfo = await getVersionInfo(localDir);
       if (versionInfo && versionInfo.version === version) {
         if (process.env.DEBUG === "1" || process.env.VERBOSE === "1") {
@@ -2940,6 +2982,7 @@ var init_downloader = __esm({
     "use strict";
     init_utils();
     init_directory_resolver();
+    init_symlink_utils();
     exec = promisify(execCallback);
     REPO_OWNER = "probelabs";
     REPO_NAME = "probe";
@@ -2955,11 +2998,11 @@ var init_downloader = __esm({
 
 // src/utils.js
 import path3 from "path";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 import { fileURLToPath as fileURLToPath3 } from "url";
 async function getBinaryPath(options = {}) {
   const { forceDownload = false, version } = options;
-  if (process.env.PROBE_PATH && fs3.existsSync(process.env.PROBE_PATH) && !forceDownload) {
+  if (process.env.PROBE_PATH && fs4.existsSync(process.env.PROBE_PATH) && !forceDownload) {
     probeBinaryPath = process.env.PROBE_PATH;
     return probeBinaryPath;
   }
@@ -2972,13 +3015,13 @@ async function getBinaryPath(options = {}) {
   const binaryName = isWindows ? "probe.exe" : "probe-binary";
   const localPackageBin = path3.resolve(__dirname3, "..", "bin");
   const localBinaryPath = path3.join(localPackageBin, binaryName);
-  if (fs3.existsSync(localBinaryPath) && !forceDownload) {
+  if (fs4.existsSync(localBinaryPath) && !forceDownload) {
     probeBinaryPath = localBinaryPath;
     return probeBinaryPath;
   }
   const binDir = await getPackageBinDir();
   const binaryPath = path3.join(binDir, binaryName);
-  if (fs3.existsSync(binaryPath) && !forceDownload) {
+  if (fs4.existsSync(binaryPath) && !forceDownload) {
     probeBinaryPath = binaryPath;
     return probeBinaryPath;
   }
@@ -9674,7 +9717,7 @@ Command failed with exit code ${result.exitCode}`;
 
 // src/tools/edit.js
 import { tool as tool3 } from "ai";
-import { promises as fs4 } from "fs";
+import { promises as fs5 } from "fs";
 import { dirname, resolve as resolve3, isAbsolute, sep } from "path";
 import { existsSync as existsSync2 } from "fs";
 function isPathAllowed(filePath, allowedFolders) {
@@ -9762,7 +9805,7 @@ Important:
             if (!existsSync2(resolvedPath)) {
               return `Error editing file: File not found - ${file_path}`;
             }
-            const content = await fs4.readFile(resolvedPath, "utf-8");
+            const content = await fs5.readFile(resolvedPath, "utf-8");
             if (!content.includes(old_string)) {
               return `Error editing file: String not found - the specified old_string was not found in ${file_path}`;
             }
@@ -9779,7 +9822,7 @@ Important:
             if (newContent === content) {
               return `Error editing file: No changes made - old_string and new_string might be the same`;
             }
-            await fs4.writeFile(resolvedPath, newContent, "utf-8");
+            await fs5.writeFile(resolvedPath, newContent, "utf-8");
             const replacedCount = replace_all ? occurrences : 1;
             if (debug) {
               console.error(`[Edit] Successfully edited ${resolvedPath}, replaced ${replacedCount} occurrence(s)`);
@@ -9847,8 +9890,8 @@ Important:
               return `Error creating file: File already exists - ${file_path}. Use overwrite: true to replace it.`;
             }
             const dir = dirname(resolvedPath);
-            await fs4.mkdir(dir, { recursive: true });
-            await fs4.writeFile(resolvedPath, content, "utf-8");
+            await fs5.mkdir(dir, { recursive: true });
+            await fs5.writeFile(resolvedPath, content, "utf-8");
             const action = existsSync2(resolvedPath) && overwrite ? "overwrote" : "created";
             const bytes = Buffer.byteLength(content, "utf-8");
             if (debug) {
@@ -10118,7 +10161,7 @@ var init_tools = __esm({
 });
 
 // src/utils/file-lister.js
-import fs5 from "fs";
+import fs6 from "fs";
 import path4 from "path";
 import { promisify as promisify6 } from "util";
 import { exec as exec4 } from "child_process";
@@ -10128,10 +10171,10 @@ async function listFilesByLevel(options) {
     maxFiles = 100,
     respectGitignore = true
   } = options;
-  if (!fs5.existsSync(directory)) {
+  if (!fs6.existsSync(directory)) {
     throw new Error(`Directory does not exist: ${directory}`);
   }
-  const gitDirExists = fs5.existsSync(path4.join(directory, ".git"));
+  const gitDirExists = fs6.existsSync(path4.join(directory, ".git"));
   if (gitDirExists && respectGitignore) {
     try {
       return await listFilesUsingGit(directory, maxFiles);
@@ -10162,8 +10205,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
   while (queue.length > 0 && result.length < maxFiles) {
     const { dir, level } = queue.shift();
     try {
-      const entries = fs5.readdirSync(dir, { withFileTypes: true });
-      const files = entries.filter((entry) => entry.isFile());
+      const entries = fs6.readdirSync(dir, { withFileTypes: true });
+      const files = entries.filter((entry) => {
+        const fullPath = path4.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isFile;
+      });
       for (const file of files) {
         if (result.length >= maxFiles) break;
         const filePath = path4.join(dir, file.name);
@@ -10171,7 +10217,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 = path4.join(dir, entry.name);
+        return getEntryTypeSync(entry, fullPath).isDirectory;
+      });
       for (const subdir of dirs) {
         const subdirPath = path4.join(dir, subdir.name);
         const relativeSubdirPath = path4.relative(directory, subdirPath);
@@ -10187,11 +10236,11 @@ async function listFilesByLevelManually(directory, maxFiles, respectGitignore) {
 }
 function loadGitignorePatterns(directory) {
   const gitignorePath = path4.join(directory, ".gitignore");
-  if (!fs5.existsSync(gitignorePath)) {
+  if (!fs6.existsSync(gitignorePath)) {
     return [];
   }
   try {
-    const content = fs5.readFileSync(gitignorePath, "utf8");
+    const content = fs6.readFileSync(gitignorePath, "utf8");
     return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   } catch (error) {
     console.error(`Warning: Could not read .gitignore: ${error.message}`);
@@ -10213,6 +10262,7 @@ var execAsync3;
 var init_file_lister = __esm({
   "src/utils/file-lister.js"() {
     "use strict";
+    init_symlink_utils();
     execAsync3 = promisify6(exec4);
   }
 });
@@ -15401,8 +15451,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 = fileURLToPath4(cwd);
         }
@@ -15960,8 +16010,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
@@ -15989,8 +16039,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
@@ -17130,8 +17180,8 @@ import { exec as exec5 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { randomUUID as randomUUID2 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
-import fs6 from "fs";
-import { promises as fsPromises } from "fs";
+import fs7 from "fs";
+import { promises as fsPromises2 } from "fs";
 import path6 from "path";
 function isSessionCancelled(sessionId) {
   return activeToolExecutions.get(sessionId)?.cancelled || false;
@@ -17212,6 +17262,7 @@ var init_probeTool = __esm({
     "use strict";
     init_index();
     init_esm5();
+    init_symlink_utils();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
     wrapToolWithEmitter = (tool4, toolName, baseExecute) => {
@@ -17317,7 +17368,7 @@ var init_probeTool = __esm({
           console.log(`[DEBUG] Listing files in directory: ${targetDir}`);
         }
         try {
-          const files = await fsPromises.readdir(targetDir, { withFileTypes: true });
+          const files = await fsPromises2.readdir(targetDir, { withFileTypes: true });
           const formatSize = (size) => {
             if (size < 1024) return `${size}B`;
             if (size < 1024 * 1024) return `${(size / 1024).toFixed(1)}K`;
@@ -17325,21 +17376,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 = path6.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
             };
           }));
           entries.sort((a, b) => {
@@ -31858,7 +31900,7 @@ function validateFlowchart(text, options = {}) {
         const byLine = /* @__PURE__ */ new Map();
         const collect = (arr) => {
           for (const e of arr || []) {
-            if (e && (e.code === "FL-LABEL-PARENS-UNQUOTED" || e.code === "FL-LABEL-AT-IN-UNQUOTED")) {
+            if (e && (e.code === "FL-LABEL-PARENS-UNQUOTED" || e.code === "FL-LABEL-AT-IN-UNQUOTED" || e.code === "FL-LABEL-QUOTE-IN-UNQUOTED")) {
               const ln = e.line ?? 0;
               const col = e.column ?? 1;
               const list = byLine.get(ln) || [];
@@ -31939,6 +31981,8 @@ function validateFlowchart(text, options = {}) {
                 const covered = existing.some((r) => !(endCol < r.start || startCol > r.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 });
@@ -31949,6 +31993,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);
+                }
                 i = j;
                 continue;
               } else {
@@ -58258,7 +58307,7 @@ __export(enhanced_claude_code_exports, {
 });
 import { spawn as spawn3 } from "child_process";
 import { randomBytes } from "crypto";
-import fs7 from "fs/promises";
+import fs8 from "fs/promises";
 import path7 from "path";
 import os3 from "os";
 import { EventEmitter as EventEmitter4 } from "events";
@@ -58295,7 +58344,7 @@ async function createEnhancedClaudeCLIEngine(options = {}) {
         }
       }
     };
-    await fs7.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
+    await fs8.writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
   }
   if (debug) {
     console.log("[DEBUG] Enhanced Claude Code Engine");
@@ -58489,7 +58538,7 @@ ${opts.schema}`;
           }
         }
         if (mcpConfigPath) {
-          await fs7.unlink(mcpConfigPath).catch(() => {
+          await fs8.unlink(mcpConfigPath).catch(() => {
           });
           if (debug) {
             console.log("[DEBUG] MCP config file removed");

package/build/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/build/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/build/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/build/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);