@aigne/doc-smith 0.2.5 → 0.2.6

package/utils/mermaid-worker-pool.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+/**
+ * Simplified Mermaid Worker Pool
+ * Manages worker threads for concurrent mermaid validation
+ */
+
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class SimpleMermaidWorkerPool {
+  constructor(options = {}) {
+    this.poolSize = options.poolSize || 3;
+    this.timeout = options.timeout || 15000; // Reduced timeout
+
+    this.workers = [];
+    this.availableWorkers = [];
+    this.requestQueue = [];
+    this.nextRequestId = 1;
+    this.isShuttingDown = false;
+  }
+
+  /**
+   * Initialize worker pool
+   */
+  async initialize() {
+    if (this.workers.length > 0) return; // Already initialized
+
+    const workerPath = join(__dirname, "mermaid-worker.mjs");
+
+    for (let i = 0; i < this.poolSize; i++) {
+      await this.createWorker(workerPath, i);
+    }
+  }
+
+  /**
+   * Create a single worker
+   */
+  async createWorker(workerPath, workerId) {
+    return new Promise((resolve, reject) => {
+      try {
+        const worker = new Worker(workerPath);
+        worker.workerId = workerId;
+        worker.isAvailable = true;
+        worker.currentRequest = null;
+
+        // Handle worker errors more gracefully
+        worker.on("error", (error) => {
+          if (worker.currentRequest) {
+            worker.currentRequest.reject(
+              new Error(`Worker error: ${error.message}`)
+            );
+            worker.currentRequest = null;
+          }
+        });
+
+        worker.on("exit", (code) => {
+          if (worker.currentRequest) {
+            worker.currentRequest.reject(
+              new Error("Worker exited unexpectedly")
+            );
+            worker.currentRequest = null;
+          }
+        });
+
+        worker.on("message", (data) => {
+          this.handleWorkerMessage(worker, data);
+        });
+
+        this.workers.push(worker);
+        this.availableWorkers.push(worker);
+
+        resolve(worker);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Handle worker message
+   */
+  handleWorkerMessage(worker, data) {
+    if (!worker.currentRequest) return;
+
+    const { resolve, reject, timeoutId } = worker.currentRequest;
+
+    // Clear timeout
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    // Reset worker state
+    worker.currentRequest = null;
+    worker.isAvailable = true;
+
+    // Move worker back to available pool
+    const workerIndex = this.workers.indexOf(worker);
+    if (workerIndex > -1 && !this.availableWorkers.includes(worker)) {
+      this.availableWorkers.push(worker);
+    }
+
+    // Process queued requests
+    this.processQueue();
+
+    // Handle response
+    if (data.error) {
+      reject(new Error(data.error));
+    } else {
+      resolve(data.result);
+    }
+  }
+
+  /**
+   * Process queued requests
+   */
+  processQueue() {
+    while (this.requestQueue.length > 0 && this.availableWorkers.length > 0) {
+      const queuedRequest = this.requestQueue.shift();
+      const worker = this.availableWorkers.shift();
+
+      this.executeRequest(worker, queuedRequest);
+    }
+  }
+
+  /**
+   * Execute a request on a worker
+   */
+  executeRequest(worker, request) {
+    const { content, resolve, reject } = request;
+    const requestId = this.nextRequestId++;
+
+    // Set timeout
+    const timeoutId = setTimeout(() => {
+      worker.currentRequest = null;
+      worker.isAvailable = true;
+      if (!this.availableWorkers.includes(worker)) {
+        this.availableWorkers.push(worker);
+      }
+      reject(new Error(`Validation timeout after ${this.timeout}ms`));
+    }, this.timeout);
+
+    // Store request info
+    worker.currentRequest = { resolve, reject, timeoutId };
+    worker.isAvailable = false;
+
+    // Send request
+    worker.postMessage({
+      id: requestId,
+      content: content,
+    });
+  }
+
+  /**
+   * Validate content using worker pool
+   */
+  async validate(content) {
+    if (this.isShuttingDown) {
+      throw new Error("Worker pool is shutting down");
+    }
+
+    // Initialize if needed
+    await this.initialize();
+
+    return new Promise((resolve, reject) => {
+      const request = { content, resolve, reject };
+
+      // If worker available, use it immediately
+      if (this.availableWorkers.length > 0) {
+        const worker = this.availableWorkers.shift();
+        this.executeRequest(worker, request);
+      } else {
+        // Queue the request
+        this.requestQueue.push(request);
+      }
+    });
+  }
+
+  /**
+   * Get pool statistics
+   */
+  getStats() {
+    return {
+      poolSize: this.poolSize,
+      totalWorkers: this.workers.length,
+      availableWorkers: this.availableWorkers.length,
+      busyWorkers: this.workers.length - this.availableWorkers.length,
+      queuedRequests: this.requestQueue.length,
+      isShuttingDown: this.isShuttingDown,
+    };
+  }
+
+  /**
+   * Shutdown the pool
+   */
+  async shutdown() {
+    if (this.isShuttingDown) return;
+
+    this.isShuttingDown = true;
+
+    // Reject all queued requests
+    while (this.requestQueue.length > 0) {
+      const request = this.requestQueue.shift();
+      request.reject(new Error("Worker pool is shutting down"));
+    }
+
+    // Terminate all workers
+    const terminationPromises = this.workers.map(async (worker) => {
+      try {
+        await worker.terminate();
+      } catch (error) {
+        // Ignore termination errors
+      }
+    });
+
+    await Promise.allSettled(terminationPromises);
+
+    // Clear arrays
+    this.workers.length = 0;
+    this.availableWorkers.length = 0;
+  }
+}
+
+// Global pool instance
+let globalPool = null;
+
+/**
+ * Get global worker pool
+ */
+export function getMermaidWorkerPool(options = {}) {
+  if (!globalPool) {
+    globalPool = new SimpleMermaidWorkerPool(options);
+  }
+  return globalPool;
+}
+
+/**
+ * Shutdown global pool
+ */
+export async function shutdownMermaidWorkerPool() {
+  if (globalPool) {
+    await globalPool.shutdown();
+    globalPool = null;
+  }
+}
+
+// Note: We don't add global process event listeners here to avoid preventing clean exit
+// The application should call shutdownMermaidWorkerPool() explicitly when needed
+
+export { SimpleMermaidWorkerPool };

package/utils/mermaid-worker.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+
+/**
+ * Simplified Mermaid Validation Worker
+ * Runs in isolated Worker thread to avoid global state conflicts
+ */
+
+import { parentPort } from "worker_threads";
+
+/**
+ * Validate mermaid syntax using official parser in isolated environment
+ */
+async function validateMermaidWithOfficialParser(content) {
+  const trimmedContent = content.trim();
+  if (!content || !trimmedContent) {
+    throw new Error("Empty mermaid diagram");
+  }
+
+  try {
+    // Import dependencies
+    const { JSDOM } = await import("jsdom");
+    const DOMPurifyModule = await import("dompurify");
+
+    // Create isolated DOM environment
+    const { window } = new JSDOM(`<!DOCTYPE html><html><body></body></html>`, {
+      pretendToBeVisual: true,
+      resources: "usable",
+    });
+
+    // Setup globals (safe in worker - no conflicts)
+    global.window = window;
+    global.document = window.document;
+
+    // Only set navigator if it doesn't exist
+    if (!global.navigator) {
+      global.navigator = {
+        userAgent: "node.js",
+        platform: "node",
+        cookieEnabled: false,
+        onLine: true,
+      };
+    }
+
+    global.DOMParser = window.DOMParser;
+    global.XMLSerializer = window.XMLSerializer;
+    global.HTMLElement = window.HTMLElement;
+    global.HTMLDivElement = window.HTMLDivElement;
+    global.SVGElement = window.SVGElement;
+    global.Element = window.Element;
+    global.Node = window.Node;
+
+    // Initialize DOMPurify with the JSDOM window
+    const dompurify = DOMPurifyModule.default(window);
+
+    // Verify DOMPurify is working before proceeding
+    if (typeof dompurify.sanitize !== "function") {
+      throw new Error(
+        "DOMPurify initialization failed - sanitize method not available"
+      );
+    }
+
+    // Test DOMPurify functionality
+    dompurify.sanitize("<p>test</p>");
+
+    // Step 5: Comprehensively set up DOMPurify in all possible global locations
+    global.DOMPurify = dompurify;
+    window.DOMPurify = dompurify;
+
+    // For ES module interception, we need to ensure DOMPurify is available
+    // in all the ways mermaid might try to access it
+    if (typeof globalThis !== "undefined") {
+      globalThis.DOMPurify = dompurify;
+    }
+
+    // Set up on the global scope itself
+    if (typeof self !== "undefined") {
+      self.DOMPurify = dompurify;
+    }
+
+    // CRITICAL: Override the DOMPurify constructor/factory to always use our window
+    // This is the key to solving the issue: mermaid imports DOMPurify directly
+    const originalDOMPurifyFactory = DOMPurifyModule.default;
+    try {
+      // This might work: intercept the factory function itself
+      if (
+        typeof originalDOMPurifyFactory === "function" &&
+        !originalDOMPurifyFactory.sanitize
+      ) {
+        // This means DOMPurify.default is a factory function, not an instance
+        // We need to make sure when mermaid calls DOMPurify.sanitize, it works
+        const factoryResult = originalDOMPurifyFactory(window);
+
+        // Copy methods from our working instance to the factory result
+        Object.assign(originalDOMPurifyFactory, factoryResult);
+      }
+    } catch (factoryError) {
+      // If factory modification fails, that's OK - we have other fallbacks
+    }
+
+    // Import and setup mermaid
+    const mermaid = await import("mermaid");
+
+    mermaid.default.initialize({
+      startOnLoad: false,
+      theme: "default",
+      securityLevel: "loose",
+      htmlLabels: false,
+    });
+
+    // Parse content
+    await mermaid.default.parse(trimmedContent);
+
+    return true;
+  } catch (error) {
+    const errorMessage = error.message || String(error);
+
+    // Keep parse errors as-is for useful info
+    if (errorMessage.includes("Parse error")) {
+      throw new Error(errorMessage);
+    }
+
+    if (errorMessage.includes("Expecting ")) {
+      throw new Error(
+        "Syntax error: " + errorMessage.replace(/^.*Expecting /, "Expected ")
+      );
+    }
+
+    if (errorMessage.includes("Lexical error")) {
+      throw new Error("Syntax error: invalid characters or tokens");
+    }
+
+    if (errorMessage.includes("No diagram type detected")) {
+      throw new Error("Syntax error: invalid or unrecognized diagram type");
+    }
+
+    throw new Error(errorMessage);
+  }
+}
+
+/**
+ * Basic validation fallback
+ */
+function validateBasicMermaidSyntax(content) {
+  const trimmedContent = content.trim();
+
+  if (!trimmedContent) {
+    throw new Error("Empty mermaid diagram");
+  }
+
+  const validDiagramTypes = [
+    "flowchart",
+    "graph",
+    "sequenceDiagram",
+    "classDiagram",
+    "stateDiagram",
+    "entityRelationshipDiagram",
+    "erDiagram",
+    "journey",
+    "gantt",
+    "pie",
+    "requirement",
+    "gitgraph",
+    "mindmap",
+    "timeline",
+    "quadrantChart",
+  ];
+
+  const firstLine = trimmedContent.split("\n")[0].trim();
+  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;
+
+  if (openBrackets !== closeBrackets) {
+    throw new Error("Unmatched brackets in diagram");
+  }
+
+  return true;
+}
+
+/**
+ * Main validation with fallback
+ */
+async function validateMermaidSyntax(content) {
+  try {
+    return await validateMermaidWithOfficialParser(content);
+  } catch (officialError) {
+    const errorMsg = officialError.message || String(officialError);
+
+    // Check if it's an environment issue
+    if (
+      errorMsg.includes("Cannot resolve module") ||
+      errorMsg.includes("window is not defined") ||
+      errorMsg.includes("canvas") ||
+      errorMsg.includes("Web APIs") ||
+      errorMsg.includes("getComputedTextLength") ||
+      errorMsg.includes("document is not defined") ||
+      errorMsg.includes("DOMPurify")
+    ) {
+      // Fall back to basic validation
+      return validateBasicMermaidSyntax(content);
+    }
+
+    // Re-throw syntax errors
+    throw officialError;
+  }
+}
+
+// Worker message handler
+if (parentPort) {
+  parentPort.on("message", async (data) => {
+    const { id, content } = data;
+
+    try {
+      if (!id || !content) {
+        throw new Error("Missing id or content");
+      }
+
+      const result = await validateMermaidSyntax(content);
+
+      parentPort.postMessage({
+        id,
+        success: true,
+        result,
+      });
+    } catch (error) {
+      parentPort.postMessage({
+        id,
+        error: error.message || String(error),
+      });
+    }
+  });
+}
+
+export { validateMermaidSyntax };

package/utils/utils.mjs

@@ -83,6 +83,7 @@ export async function saveDocWithTranslations({
   locale,
   translates = [],
   labels,
+  isTranslate = false,
 }) {
   const results = [];
   try {
@@ -96,20 +97,22 @@ export async function saveDocWithTranslations({
       return isEnglish ? `${flatName}.md` : `${flatName}.${language}.md`;
     };
 
-    // Save main content with appropriate filename based on locale
-    const mainFileName = getFileName(locale);
-    const mainFilePath = path.join(docsDir, mainFileName);
+    // Save main content with appropriate filename based on locale (skip if isTranslate is true)
+    if (!isTranslate) {
+      const mainFileName = getFileName(locale);
+      const mainFilePath = path.join(docsDir, mainFileName);
 
-    // Add labels front matter if labels are provided
-    let finalContent = processContent({ content });
-    if (labels && labels.length > 0) {
-      const frontMatter = `---\nlabels: ${JSON.stringify(labels)}\n---\n\n`;
-      finalContent = frontMatter + finalContent;
-    }
+      // Add labels front matter if labels are provided
+      let finalContent = processContent({ content });
+      if (labels && labels.length > 0) {
+        const frontMatter = `---\nlabels: ${JSON.stringify(labels)}\n---\n\n`;
+        finalContent = frontMatter + finalContent;
+      }
 
-    await fs.writeFile(mainFilePath, finalContent, "utf8");
-    results.push({ path: mainFilePath, success: true });
-    console.log(chalk.green(`Saved: ${chalk.cyan(mainFilePath)}`));
+      await fs.writeFile(mainFilePath, finalContent, "utf8");
+      results.push({ path: mainFilePath, success: true });
+      console.log(chalk.green(`Saved: ${chalk.cyan(mainFilePath)}`));
+    }
 
     // Process all translations
     for (const translate of translates) {
@@ -368,10 +371,11 @@ export async function loadConfigFromFile() {
  * Save value to config.yaml file
  * @param {string} key - The config key to save
  * @param {string} value - The value to save
+ * @param {string} [comment] - Optional comment to add above the key
  */
-export async function saveValueToConfig(key, value) {
-  if (!value) {
-    return; // Skip if no value provided
+export async function saveValueToConfig(key, value, comment) {
+  if (value === undefined) {
+    return; // Skip if value is undefined
   }
 
   try {
@@ -389,17 +393,38 @@ export async function saveValueToConfig(key, value) {
     }
 
     // Check if key already exists in the file
-    const keyRegex = new RegExp(`^${key}:\\s*.*$`, "m");
-    const newKeyLine = `${key}: ${value}`;
+    const lines = fileContent.split("\n");
+    const keyRegex = new RegExp(`^${key}:\\s*.*$`);
+    const newKeyLine = `${key}: "${value}"`;
+
+    const keyIndex = lines.findIndex((line) => keyRegex.test(line));
 
-    if (keyRegex.test(fileContent)) {
+    if (keyIndex !== -1) {
       // Replace existing key line
-      fileContent = fileContent.replace(keyRegex, newKeyLine);
+      lines[keyIndex] = newKeyLine;
+      fileContent = lines.join("\n");
+
+      // Add comment if provided and not already present
+      if (
+        comment &&
+        keyIndex > 0 &&
+        !lines[keyIndex - 1].trim().startsWith("# ")
+      ) {
+        // Add comment above the key if it doesn't already have one
+        lines.splice(keyIndex, 0, `# ${comment}`);
+        fileContent = lines.join("\n");
+      }
     } else {
       // Add key to the end of file
       if (fileContent && !fileContent.endsWith("\n")) {
         fileContent += "\n";
       }
+
+      // Add comment if provided
+      if (comment) {
+        fileContent += `# ${comment}\n`;
+      }
+
       fileContent += newKeyLine + "\n";
     }
 
@@ -655,3 +680,78 @@ function getDirectoryContents(dirPath, searchTerm = "") {
     return [];
   }
 }
+
+/**
+ * Get GitHub repository information
+ * @param {string} repoUrl - The repository URL
+ * @returns {Promise<Object>} - Repository information
+ */
+export async function getGitHubRepoInfo(repoUrl) {
+  try {
+    // Extract owner and repo from GitHub URL
+    const match = repoUrl.match(
+      /github\.com[\/:]([^\/]+)\/([^\/]+?)(?:\.git)?$/
+    );
+    if (!match) return null;
+
+    const [, owner, repo] = match;
+    const apiUrl = `https://api.github.com/repos/${owner}/${repo}`;
+
+    const response = await fetch(apiUrl);
+    if (!response.ok) return null;
+
+    const data = await response.json();
+    return {
+      name: data.name,
+      description: data.description || "",
+      icon: data.owner?.avatar_url || "",
+    };
+  } catch (error) {
+    console.warn("Failed to fetch GitHub repository info:", error.message);
+    return null;
+  }
+}
+
+/**
+ * Get project information automatically without user confirmation
+ * @returns {Promise<Object>} - Project information including name, description, icon, and fromGitHub flag
+ */
+export async function getProjectInfo() {
+  let repoInfo = null;
+  let defaultName = path.basename(process.cwd());
+  let defaultDescription = "";
+  let defaultIcon = "";
+  let fromGitHub = false;
+
+  // Check if we're in a git repository
+  try {
+    const gitRemote = execSync("git remote get-url origin", {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trim();
+
+    // Extract repository name from git remote URL
+    const repoName = gitRemote.split("/").pop().replace(".git", "");
+    defaultName = repoName;
+
+    // If it's a GitHub repository, try to get additional info
+    if (gitRemote.includes("github.com")) {
+      repoInfo = await getGitHubRepoInfo(gitRemote);
+      if (repoInfo) {
+        defaultDescription = repoInfo.description;
+        defaultIcon = repoInfo.icon;
+        fromGitHub = true;
+      }
+    }
+  } catch (error) {
+    // Not in git repository or no origin remote, use current directory name
+    console.warn("No git repository found, using current directory name");
+  }
+
+  return {
+    name: defaultName,
+    description: defaultDescription,
+    icon: defaultIcon,
+    fromGitHub,
+  };
+}