@aigne/doc-smith 0.2.6 → 0.2.8

package/tests/test-all-validation-cases.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { checkMarkdown } from "../utils/markdown-checker.mjs";
 import checkDetailResult from "../agents/check-detail-result.mjs";
+import { checkMarkdown } from "../utils/markdown-checker.mjs";
 import { shutdownValidation } from "../utils/mermaid-validator.mjs";
 
 // Mock structure plan for link validation
@@ -164,25 +164,6 @@ This content ends properly.
   },
 
   // ========== CODE BLOCK VALIDATION CASES ==========
-  {
-    category: "💻 CODE BLOCK VALIDATION",
-    name: "Inconsistent code block indentation",
-    expectPass: false,
-    expectedErrors: ["code block with inconsistent indentation"],
-    content: `# Test Document
-
-Here's incorrectly indented code:
-
-    \`\`\`javascript
-function test() {
-    return "content not properly indented";
-}
-    \`\`\`
-
-This content ends properly.
-`,
-  },
-
   {
     category: "💻 CODE BLOCK VALIDATION",
     name: "Incomplete code block",
@@ -216,6 +197,68 @@ This content ends properly.
 `,
   },
 
+  {
+    category: "💻 CODE BLOCK VALIDATION",
+    name: "Code block with inconsistent indentation (user case)",
+    expectPass: false,
+    expectedErrors: ["code block with inconsistent indentation"],
+    content: `# API Response Handling
+
+You can retrieve the response body in various formats:
+
+*   **\`response.content\`**: Accesses the raw response body as bytes. This is useful for non-text data like images or binary files.
+    \`\`\`python
+    import requests
+
+r = requests.get('https://httpbin.org/image/png')
+print(type(r.content))
+# Expected output: <class 'bytes'>
+    \`\`\`
+
+*   **\`response.text\`**: Accesses the response body as Unicode text. Requests automatically guesses the encoding, or you can explicitly set \`response.encoding\`.
+    \`\`\`python
+    import requests
+
+r = requests.get('https://httpbin.org/get')
+print(type(r.text))
+# Expected output: <class 'str'>
+print(r.text)
+# Expected output: {"args": {}, "headers": ..., "origin": "...", "url": "https://httpbin.org/get"}
+    \`\`\`
+
+*   **\`response.json(**kwargs)\`**: Decodes the response body as JSON into a Python object (dictionary, list, etc.). This method raises \`requests.exceptions.JSONDecodeError\` if the content is not valid JSON.
+    \`\`\`python
+    import requests
+
+r = requests.get('https://httpbin.org/json')
+print(type(r.json()))
+# Expected output: <class 'dict'>
+print(r.json())
+# Expected output: {'slideshow': {'author': 'Yours Truly', 'date': 'date of publication', 'slides': [...], 'title': 'Sample Slide Show'}}
+    \`\`\`
+
+**Status and Error Handling**
+
+*   **\`response.ok\`**: A boolean property that returns \`True\` if \`status_code\` is less than 400, indicating no client or server error. It does *not* necessarily mean \`200 OK\`.
+
+*   **\`response.raise_for_status()\`**: Raises an \`HTTPError\` if the HTTP request returned an unsuccessful status code (4xx or 5xx). This is a convenient way to check for errors and is typically used after a request to ensure it was successful.
+
+    \`\`\`python
+    import requests
+    from requests.exceptions import HTTPError
+
+try:
+    r = requests.get('https://httpbin.org/status/404')
+    r.raise_for_status() # This will raise an HTTPError for 404
+except HTTPError as e:
+    print(f"HTTP Error occurred: {e}")
+# Expected output: HTTP Error occurred: 404 Client Error: NOT FOUND for url: https://httpbin.org/status/404
+    \`\`\`
+
+This document ends properly.
+`,
+  },
+
   // ========== CONTENT STRUCTURE CASES ==========
   {
     category: "📝 CONTENT STRUCTURE",
@@ -598,11 +641,8 @@ async function runValidationTests() {
 
         // Check if expected error types are present
         if (testCase.expectedErrors) {
-          const foundExpectedErrors = testCase.expectedErrors.every(
-            (expectedError) =>
-              errors.some((error) =>
-                error.toLowerCase().includes(expectedError.toLowerCase())
-              )
+          const foundExpectedErrors = testCase.expectedErrors.every((expectedError) =>
+            errors.some((error) => error.toLowerCase().includes(expectedError.toLowerCase())),
           );
 
           if (foundExpectedErrors) {
@@ -618,7 +658,7 @@ async function runValidationTests() {
         console.log(
           `❌ FAIL - Expected ${expectPass ? "PASS" : "FAIL"} but got ${
             hasErrors ? "FAIL" : "PASS"
-          }`
+          }`,
         );
         failedTests++;
       }
@@ -643,7 +683,7 @@ async function runValidationTests() {
         console.log("✅ Direct call and wrapper consistent");
       } else {
         console.log(
-          `⚠️  Inconsistent results: direct=${errors.length}, wrapper=${wrapperErrors.length}`
+          `⚠️  Inconsistent results: direct=${errors.length}, wrapper=${wrapperErrors.length}`,
         );
       }
     } catch (error) {
@@ -653,15 +693,13 @@ async function runValidationTests() {
   }
 
   // Final summary
-  console.log("\n" + "=".repeat(80));
+  console.log(`\n${"=".repeat(80)}`);
   console.log("📊 TEST SUMMARY");
   console.log("=".repeat(80));
   console.log(`Total Tests: ${totalTests}`);
   console.log(`Passed: ${passedTests} ✅`);
   console.log(`Failed: ${failedTests} ❌`);
-  console.log(
-    `Success Rate: ${((passedTests / totalTests) * 100).toFixed(1)}%`
-  );
+  console.log(`Success Rate: ${((passedTests / totalTests) * 100).toFixed(1)}%`);
 
   console.log("\n🔍 VALIDATION COVERAGE:");
   console.log("✅ Link validation (dead links, allowed links)");
@@ -674,13 +712,9 @@ async function runValidationTests() {
   console.log("✅ Edge cases and error conditions");
 
   if (failedTests === 0) {
-    console.log(
-      "\n🎉 ALL TESTS PASSED! Validation system is working correctly."
-    );
+    console.log("\n🎉 ALL TESTS PASSED! Validation system is working correctly.");
   } else {
-    console.log(
-      `\n⚠️  ${failedTests} test(s) failed. Please review the validation logic.`
-    );
+    console.log(`\n⚠️  ${failedTests} test(s) failed. Please review the validation logic.`);
   }
 
   // Shutdown worker pool to ensure clean exit

package/tests/test-save-docs.mjs

@@ -1,7 +1,6 @@
-import { writeFile, mkdir, readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
 import saveDocs from "../agents/save-docs.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -81,12 +80,8 @@ async function testSaveDocs() {
       "_sidebar.md",
     ];
 
-    const missingFiles = expectedFiles.filter(
-      (file) => !remainingFiles.includes(file)
-    );
-    const extraFiles = remainingFiles.filter(
-      (file) => !expectedFiles.includes(file)
-    );
+    const missingFiles = expectedFiles.filter((file) => !remainingFiles.includes(file));
+    const extraFiles = remainingFiles.filter((file) => !expectedFiles.includes(file));
 
     if (missingFiles.length === 0 && extraFiles.length === 0) {
       console.log("\n✅ Test passed! All files are as expected.");
@@ -101,14 +96,8 @@ async function testSaveDocs() {
     }
 
     // Verify that invalid files were deleted
-    const deletedFiles = [
-      "old-file.md",
-      "another-old-file.md",
-      "old-translation.zh.md",
-    ];
-    const stillExist = deletedFiles.filter((file) =>
-      remainingFiles.includes(file)
-    );
+    const deletedFiles = ["old-file.md", "another-old-file.md", "old-translation.zh.md"];
+    const stillExist = deletedFiles.filter((file) => remainingFiles.includes(file));
 
     if (stillExist.length === 0) {
       console.log("✅ All invalid files were successfully deleted.");

package/utils/constants.mjs

@@ -99,8 +99,7 @@ export const DOCUMENT_STYLES = {
 // Predefined target audiences
 export const TARGET_AUDIENCES = {
   actionFirst: "Developers, Implementation Engineers, DevOps",
-  conceptFirst:
-    "Architects, Technical Leads, Developers interested in principles",
+  conceptFirst: "Architects, Technical Leads, Developers interested in principles",
   generalUsers: "General Users",
   custom: "Enter your own target audience",
 };

package/utils/markdown-checker.mjs

@@ -1,9 +1,9 @@
-import { unified } from "unified";
-import remarkParse from "remark-parse";
 import remarkGfm from "remark-gfm";
 import remarkLint from "remark-lint";
-import { VFile } from "vfile";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
 import { visit } from "unist-util-visit";
+import { VFile } from "vfile";
 import { validateMermaidSyntax } from "./mermaid-validator.mjs";
 
 /**
@@ -16,10 +16,7 @@ function countTableColumns(line) {
   const trimmed = line.trim();
 
   // Remove leading and trailing pipes if present
-  const content =
-    trimmed.startsWith("|") && trimmed.endsWith("|")
-      ? trimmed.slice(1, -1)
-      : trimmed;
+  const content = trimmed.startsWith("|") && trimmed.endsWith("|") ? trimmed.slice(1, -1) : trimmed;
 
   if (!content.trim()) {
     return 0;
@@ -65,7 +62,7 @@ function countTableColumns(line) {
  * @param {Array} errorMessages - Array to push error messages to
  */
 function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
-  const linkRegex = /(?<!\!)\[([^\]]+)\]\(([^)]+)\)/g;
+  const linkRegex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
   let match;
 
   while ((match = linkRegex.exec(markdown)) !== null) {
@@ -77,7 +74,7 @@ function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
     if (/^(https?:\/\/|mailto:)/.test(trimLink)) continue;
 
     // Preserve anchors
-    const [path, hash] = trimLink.split("#");
+    const [path, _hash] = trimLink.split("#");
 
     // Only process relative paths or paths starting with /
     if (!path) continue;
@@ -85,7 +82,89 @@ function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
     // Check if this link is in the allowed links set
     if (!allowedLinks.has(trimLink)) {
       errorMessages.push(
-        `Found a dead link in ${source}: [${match[1]}](${trimLink}), ensure the link exists in the structure plan path`
+        `Found a dead link in ${source}: [${match[1]}](${trimLink}), ensure the link exists in the structure plan path`,
+      );
+    }
+  }
+}
+
+/**
+ * Check code block content for indentation consistency issues
+ * @param {Array} codeBlockContent - Array of {line, lineNumber} objects from the code block
+ * @param {string} source - Source description for error reporting
+ * @param {Array} errorMessages - Array to push error messages to
+ */
+function checkCodeBlockIndentation(codeBlockContent, source, errorMessages) {
+  if (codeBlockContent.length === 0) return;
+
+  // Filter out empty lines for base indentation calculation
+  const nonEmptyLines = codeBlockContent.filter((item) => item.line.trim().length > 0);
+  if (nonEmptyLines.length === 0) return;
+
+  // Find the base indentation from the first meaningful line
+  let baseCodeIndent = null;
+  const problematicLines = [];
+
+  for (const item of nonEmptyLines) {
+    const { line, lineNumber } = item;
+    const match = line.match(/^(\s*)/);
+    const currentIndent = match ? match[1].length : 0;
+    const trimmedLine = line.trim();
+
+    // Skip lines that are clearly comments (common pattern: # comment)
+    if (trimmedLine.startsWith("#") && !trimmedLine.includes("=") && !trimmedLine.includes("{")) {
+      continue;
+    }
+
+    // Establish base indentation from the first meaningful line
+    if (baseCodeIndent === null) {
+      baseCodeIndent = currentIndent;
+      continue;
+    }
+
+    // Check if current line has less indentation than the base
+    // This indicates inconsistent indentation that may cause rendering issues
+    if (currentIndent < baseCodeIndent && baseCodeIndent > 0) {
+      problematicLines.push({
+        lineNumber,
+        line: line.trimEnd(),
+        currentIndent,
+        baseIndent: baseCodeIndent,
+      });
+    }
+  }
+
+  // Report indentation issues if found
+  if (problematicLines.length > 0) {
+    // Group consecutive issues to avoid spam
+    const groupedIssues = [];
+    let currentGroup = [problematicLines[0]];
+
+    for (let i = 1; i < problematicLines.length; i++) {
+      const current = problematicLines[i];
+      const previous = problematicLines[i - 1];
+
+      if (current.lineNumber - previous.lineNumber <= 2) {
+        currentGroup.push(current);
+      } else {
+        groupedIssues.push(currentGroup);
+        currentGroup = [current];
+      }
+    }
+    groupedIssues.push(currentGroup);
+
+    // Report the most significant groups
+    for (const group of groupedIssues.slice(0, 2)) {
+      // Limit to avoid spam
+      const firstIssue = group[0];
+      const lineNumbers =
+        group.length > 1
+          ? `lines ${group[0].lineNumber}-${group[group.length - 1].lineNumber}`
+          : `line ${firstIssue.lineNumber}`;
+
+      const issue = `inconsistent indentation: ${firstIssue.currentIndent} spaces (base: ${firstIssue.baseIndent} spaces)`;
+      errorMessages.push(
+        `Found code block with inconsistent indentation in ${source} at ${lineNumbers}: ${issue}. This may cause rendering issues`,
       );
     }
   }
@@ -103,10 +182,9 @@ function checkContentStructure(markdown, source, errorMessages) {
 
   // State variables for different checks
   let inCodeBlock = false;
-  let codeBlockIndentLevel = 0;
-  let codeBlockStartLine = 0;
   let inAnyCodeBlock = false;
   let anyCodeBlockStartLine = 0;
+  let codeBlockContent = [];
 
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -118,17 +196,28 @@ function checkContentStructure(markdown, source, errorMessages) {
         // Starting a new code block
         inAnyCodeBlock = true;
         anyCodeBlockStartLine = lineNumber;
+        inCodeBlock = true;
+        codeBlockContent = [];
       } else {
         // Ending the code block
         inAnyCodeBlock = false;
+
+        if (inCodeBlock) {
+          // Check code block content for indentation issues
+          checkCodeBlockIndentation(codeBlockContent, source, errorMessages);
+          inCodeBlock = false;
+        }
       }
+    } else if (inCodeBlock) {
+      // Collect code block content for indentation analysis
+      codeBlockContent.push({ line, lineNumber });
     }
   }
 
   // Check for incomplete code blocks (started but not closed)
   if (inAnyCodeBlock) {
     errorMessages.push(
-      `Found incomplete code block in ${source} starting at line ${anyCodeBlockStartLine}: code block opened with \`\`\` but never closed. Please return the complete content`
+      `Found incomplete code block in ${source} starting at line ${anyCodeBlockStartLine}: code block opened with \`\`\` but never closed. Please return the complete content`,
     );
   }
 
@@ -136,19 +225,15 @@ function checkContentStructure(markdown, source, errorMessages) {
   const newlineCount = (markdown.match(/\n/g) || []).length;
   if (newlineCount === 0 && markdown.trim().length > 0) {
     errorMessages.push(
-      `Found single line content in ${source}: content appears to be on only one line, check for missing line breaks`
+      `Found single line content in ${source}: content appears to be on only one line, check for missing line breaks`,
     );
   }
 
   // Check if content ends with proper punctuation (indicating completeness)
   const trimmedText = markdown.trim();
-  if (
-    trimmedText.length > 0 &&
-    !trimmedText.endsWith(".") &&
-    !trimmedText.endsWith("。")
-  ) {
+  if (trimmedText.length > 0 && !trimmedText.endsWith(".") && !trimmedText.endsWith("。")) {
     errorMessages.push(
-      `Found incomplete content in ${source}: content does not end with proper punctuation (. or 。). Please return the complete content`
+      `Found incomplete content in ${source}: content does not end with proper punctuation (. or 。). Please return the complete content`,
     );
   }
 }
@@ -161,11 +246,7 @@ function checkContentStructure(markdown, source, errorMessages) {
  * @param {Array} [options.allowedLinks] - Set of allowed links for link validation
  * @returns {Promise<Array<string>>} - Array of error messages in check-detail-result format
  */
-export async function checkMarkdown(
-  markdown,
-  source = "content",
-  options = {}
-) {
+export async function checkMarkdown(markdown, source = "content", options = {}) {
   const file = new VFile({ value: markdown, path: source });
   const errorMessages = [];
 
@@ -224,15 +305,14 @@ export async function checkMarkdown(
         // Check for mermaid syntax errors
         mermaidChecks.push(
           validateMermaidSyntax(node.value).catch((error) => {
-            const errorMessage =
-              error?.message || String(error) || "Unknown mermaid syntax error";
+            const errorMessage = error?.message || String(error) || "Unknown mermaid syntax error";
 
             // Format mermaid error in check-detail-result style
             const line = node.position?.start?.line || "unknown";
             errorMessages.push(
-              `Found Mermaid syntax error in ${source} at line ${line}: ${errorMessage}`
+              `Found Mermaid syntax error in ${source} at line ${line}: ${errorMessage}`,
             );
-          })
+          }),
         );
 
         // Check for specific mermaid rendering issues
@@ -240,38 +320,31 @@ export async function checkMarkdown(
         const line = node.position?.start?.line || "unknown";
 
         // Check for backticks in node labels
-        const nodeLabelRegex =
-          /[A-Za-z0-9_]+\["([^"]*`[^"]*)"\]|[A-Za-z0-9_]+{"([^}]*`[^}]*)"}/g;
+        const nodeLabelRegex = /[A-Za-z0-9_]+\["([^"]*`[^"]*)"\]|[A-Za-z0-9_]+{"([^}]*`[^}]*)"}/g;
         let match;
         while ((match = nodeLabelRegex.exec(mermaidContent)) !== null) {
           const label = match[1] || match[2];
           errorMessages.push(
-            `Found backticks in Mermaid node label in ${source} at line ${line}: "${label}" - backticks in node labels cause rendering issues in Mermaid diagrams`
+            `Found backticks in Mermaid node label in ${source} at line ${line}: "${label}" - backticks in node labels cause rendering issues in Mermaid diagrams`,
           );
         }
 
         // Check for numbered list format in edge descriptions
         const edgeDescriptionRegex = /--\s*"([^"]*)"\s*-->/g;
         let edgeMatch;
-        while (
-          (edgeMatch = edgeDescriptionRegex.exec(mermaidContent)) !== null
-        ) {
+        while ((edgeMatch = edgeDescriptionRegex.exec(mermaidContent)) !== null) {
           const description = edgeMatch[1];
           if (/^\d+\.\s/.test(description)) {
             errorMessages.push(
-              `Unsupported markdown: list - Found numbered list format in Mermaid edge description in ${source} at line ${line}: "${description}" - numbered lists in edge descriptions are not supported`
+              `Unsupported markdown: list - Found numbered list format in Mermaid edge description in ${source} at line ${line}: "${description}" - numbered lists in edge descriptions are not supported`,
             );
           }
         }
 
         // Check for special characters in node labels that should be quoted
-        const nodeWithSpecialCharsRegex =
-          /([A-Za-z0-9_]+)\[([^\]]*[(){}:;,\-\s\.][^\]]*)\]/g;
+        const nodeWithSpecialCharsRegex = /([A-Za-z0-9_]+)\[([^\]]*[(){}:;,\-\s.][^\]]*)\]/g;
         let specialCharMatch;
-        while (
-          (specialCharMatch =
-            nodeWithSpecialCharsRegex.exec(mermaidContent)) !== null
-        ) {
+        while ((specialCharMatch = nodeWithSpecialCharsRegex.exec(mermaidContent)) !== null) {
           const nodeId = specialCharMatch[1];
           const label = specialCharMatch[2];
 
@@ -279,15 +352,13 @@ export async function checkMarkdown(
           if (!/^".*"$/.test(label)) {
             // List of characters that typically need quoting
             const specialChars = ["(", ")", "{", "}", ":", ";", ",", "-", "."];
-            const foundSpecialChars = specialChars.filter((char) =>
-              label.includes(char)
-            );
+            const foundSpecialChars = specialChars.filter((char) => label.includes(char));
 
             if (foundSpecialChars.length > 0) {
               errorMessages.push(
                 `Found unquoted special characters in Mermaid node label in ${source} at line ${line}: "${label}" contains ${foundSpecialChars.join(
-                  ", "
-                )} - node labels with special characters should be quoted like ${nodeId}["${label}"]`
+                  ", ",
+                )} - node labels with special characters should be quoted like ${nodeId}["${label}"]`,
               );
             }
           }
@@ -317,7 +388,7 @@ export async function checkMarkdown(
               errorMessages.push(
                 `Found table separator with mismatched column count in ${source} at line ${
                   i + 1
-                }: separator has ${separatorColumns} columns but header has ${headerColumns} columns - this causes table rendering issues`
+                }: separator has ${separatorColumns} columns but header has ${headerColumns} columns - this causes table rendering issues`,
               );
             }
 
@@ -330,7 +401,7 @@ export async function checkMarkdown(
                   errorMessages.push(
                     `Found table data row with mismatched column count in ${source} at line ${
                       i + 2
-                    }: data row has ${dataColumns} columns but separator defines ${separatorColumns} columns - this causes table rendering issues`
+                    }: data row has ${dataColumns} columns but separator defines ${separatorColumns} columns - this causes table rendering issues`,
                   );
                 }
               }
@@ -349,7 +420,7 @@ export async function checkMarkdown(
     // Format messages in check-detail-result style
     file.messages.forEach((message) => {
       const line = message.line || "unknown";
-      const column = message.column || "unknown";
+      const _column = message.column || "unknown";
       const reason = message.reason || "Unknown markdown issue";
       const ruleId = message.ruleId || message.source || "markdown";
 
@@ -366,21 +437,17 @@ export async function checkMarkdown(
       // Format error message similar to check-detail-result style
       if (line !== "unknown") {
         errorMessages.push(
-          `Found ${errorType} issue in ${source} at line ${line}: ${reason} (${ruleId})`
+          `Found ${errorType} issue in ${source} at line ${line}: ${reason} (${ruleId})`,
         );
       } else {
-        errorMessages.push(
-          `Found ${errorType} issue in ${source}: ${reason} (${ruleId})`
-        );
+        errorMessages.push(`Found ${errorType} issue in ${source}: ${reason} (${ruleId})`);
       }
     });
 
     return errorMessages;
   } catch (error) {
     // Handle any unexpected errors during processing
-    errorMessages.push(
-      `Found markdown processing error in ${source}: ${error.message}`
-    );
+    errorMessages.push(`Found markdown processing error in ${source}: ${error.message}`);
     return errorMessages;
   }
 }

package/utils/mermaid-validator.mjs

@@ -3,10 +3,7 @@
  * Provides concurrent-safe validation with isolated worker environments
  */
 
-import {
-  getMermaidWorkerPool,
-  shutdownMermaidWorkerPool,
-} from "./mermaid-worker-pool.mjs";
+import { getMermaidWorkerPool, shutdownMermaidWorkerPool } from "./mermaid-worker-pool.mjs";
 
 /**
  * Worker-based mermaid validation - DEPRECATED but kept for compatibility
@@ -55,17 +52,15 @@ export function validateBasicMermaidSyntax(content) {
   ];
 
   const firstLine = trimmedContent.split("\n")[0].trim();
-  const hasValidType = validDiagramTypes.some((type) =>
-    firstLine.includes(type)
-  );
+  const hasValidType = validDiagramTypes.some((type) => firstLine.includes(type));
 
   if (!hasValidType) {
     throw new Error("Invalid or missing diagram type");
   }
 
   // Basic bracket matching
-  const openBrackets = (content.match(/[\[\{\(]/g) || []).length;
-  const closeBrackets = (content.match(/[\]\}\)]/g) || []).length;
+  const openBrackets = (content.match(/[[{(]/g) || []).length;
+  const closeBrackets = (content.match(/[\]})]/g) || []).length;
 
   if (openBrackets !== closeBrackets) {
     throw new Error("Unmatched brackets in diagram");
@@ -125,7 +120,7 @@ export async function validateMermaidSyntax(content) {
       // Fall back to basic validation for environment issues
       console.warn(
         "Worker-based mermaid validation failed, falling back to basic validation:",
-        errorMsg
+        errorMsg,
       );
       return validateBasicMermaidSyntax(content);
     }

package/utils/mermaid-worker-pool.mjs

@@ -5,9 +5,9 @@
  * Manages worker threads for concurrent mermaid validation
  */
 
-import { Worker } from "worker_threads";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -51,18 +51,14 @@ class SimpleMermaidWorkerPool {
         // Handle worker errors more gracefully
         worker.on("error", (error) => {
           if (worker.currentRequest) {
-            worker.currentRequest.reject(
-              new Error(`Worker error: ${error.message}`)
-            );
+            worker.currentRequest.reject(new Error(`Worker error: ${error.message}`));
             worker.currentRequest = null;
           }
         });
 
-        worker.on("exit", (code) => {
+        worker.on("exit", (_code) => {
           if (worker.currentRequest) {
-            worker.currentRequest.reject(
-              new Error("Worker exited unexpectedly")
-            );
+            worker.currentRequest.reject(new Error("Worker exited unexpectedly"));
             worker.currentRequest = null;
           }
         });
@@ -212,7 +208,7 @@ class SimpleMermaidWorkerPool {
     const terminationPromises = this.workers.map(async (worker) => {
       try {
         await worker.terminate();
-      } catch (error) {
+      } catch (_error) {
         // Ignore termination errors
       }
     });