@aigne/doc-smith 0.9.8-alpha.2 → 0.9.8-alpha.4

package/utils/mermaid-validator.mjs

@@ -1,140 +0,0 @@
-/**
- * Simplified Mermaid validation using Worker Thread pool
- * Provides concurrent-safe validation with isolated worker environments
- */
-
-import { getMermaidWorkerPool, shutdownMermaidWorkerPool } from "./mermaid-worker-pool.mjs";
-
-/**
- * Basic mermaid syntax validation fallback
- * Used when worker validation fails due to environment issues
- * @param {string} content - Mermaid diagram content
- * @returns {boolean} - True if basic validation passes
- * @throws {Error} - If validation fails
- */
-export function validateBasicMermaidSyntax(content) {
-  const trimmedContent = content.trim();
-
-  if (!trimmedContent) {
-    throw new Error("Empty mermaid diagram");
-  }
-
-  // Check for valid diagram type
-  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");
-  }
-
-  // Basic quote matching
-  const singleQuotes = (content.match(/'/g) || []).length;
-  const doubleQuotes = (content.match(/"/g) || []).length;
-
-  if (singleQuotes % 2 !== 0) {
-    throw new Error("Unmatched single quotes in diagram");
-  }
-
-  if (doubleQuotes % 2 !== 0) {
-    throw new Error("Unmatched double quotes in diagram");
-  }
-
-  return true;
-}
-
-/**
- * Main validation function using simplified worker pool for concurrency safety
- * @param {string} content - Mermaid diagram content
- * @returns {Promise<boolean>} - True if validation passes
- * @throws {Error} - If validation fails
- */
-export async function validateMermaidSyntax(content) {
-  if (!content || !content.trim()) {
-    throw new Error("Empty mermaid diagram");
-  }
-
-  try {
-    // Use simplified worker pool for validation
-    const workerPool = getMermaidWorkerPool({
-      poolSize: 2, // Reduced pool size
-      timeout: 10000, // Reduced timeout
-    });
-
-    const result = await workerPool.validate(content);
-    return result;
-  } catch (error) {
-    // If worker validation fails, check if it's an environment issue
-    const errorMsg = error.message || String(error);
-
-    if (
-      errorMsg.includes("Worker error") ||
-      errorMsg.includes("Worker exited") ||
-      errorMsg.includes("Worker pool") ||
-      errorMsg.includes("timeout") ||
-      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")
-    ) {
-      // Fall back to basic validation for environment issues
-      console.warn(
-        "Worker-based mermaid validation failed, falling back to basic validation:",
-        errorMsg,
-      );
-      return validateBasicMermaidSyntax(content);
-    }
-
-    // If it's a genuine syntax error, re-throw it
-    throw error;
-  }
-}
-
-/**
- * Get worker pool statistics for monitoring
- * @returns {Object} - Pool statistics
- */
-export function getValidationStats() {
-  try {
-    const workerPool = getMermaidWorkerPool();
-    return workerPool.getStats();
-  } catch (error) {
-    return { error: error.message };
-  }
-}
-
-/**
- * Shutdown the validation worker pool
- * Call this when shutting down the application
- * @returns {Promise<void>}
- */
-export async function shutdownValidation() {
-  await shutdownMermaidWorkerPool();
-}

package/utils/mermaid-worker-pool.mjs

@@ -1,250 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Simplified Mermaid Worker Pool
- * Manages worker threads for concurrent mermaid validation
- */
-
-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);
-
-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

@@ -1,233 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Simplified Mermaid Validation Worker
- * Runs in isolated Worker thread to avoid global state conflicts
- */
-
-import { parentPort } from "node: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/openapi/index.mjs

@@ -1,28 +0,0 @@
-import { parse } from "yaml";
-
-function isMatchOpenAPISpec(content) {
-  if (!content) return false;
-  if (!(content.openapi || content.swagger)) return false;
-  if (!content.paths) return false;
-  if (!(content.info?.title && content.info?.version)) return false;
-  return true;
-}
-
-export function isOpenAPISpecFile(content) {
-  const trimmedContent = content.trim();
-  try {
-    const parsed = parse(trimmedContent, {
-      logLevel: "silent",
-    });
-    return isMatchOpenAPISpec(parsed);
-  } catch {
-    //
-  }
-  try {
-    const parsed = JSON.parse(trimmedContent);
-    return isMatchOpenAPISpec(parsed);
-  } catch {
-    //
-  }
-  return false;
-}