bmad-method-quarkus 1.0.0

package/tools/validate-sidebar-order.js

@@ -0,0 +1,388 @@
+/**
+ * Sidebar Order Validator
+ *
+ * Validates sidebar.order values in YAML frontmatter of markdown doc files.
+ *
+ * English docs — strict (errors):
+ *   - Duplicate sidebar.order values within the same directory
+ *   - Gaps in the ordering sequence
+ *   - sidebar: block present but missing or invalid order: field
+ *
+ * Translations — errors + warnings:
+ *   - Same structural rules as English (duplicates, gaps) — errors
+ *   - Order drift from English counterpart — warnings (non-blocking)
+ *
+ * Usage:
+ *   node tools/validate-sidebar-order.js
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DOCS_ROOT = path.resolve(__dirname, '../docs');
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/;
+const LOCALE_RE = /^[a-z]{2}(?:-[a-zA-Z0-9]+)*$/;
+const MAX_GAPS = 50;
+
+// ── Main ─────────────────────────────────────────────────────────────────
+
+/**
+ * Scan all docs, validate sidebar orders, and report errors/warnings.
+ * Exits 0 on success, 1 if any errors found.
+ */
+function main() {
+  if (!fs.existsSync(DOCS_ROOT)) {
+    console.error(`Error: docs directory not found at ${DOCS_ROOT}`);
+    process.exit(1);
+  }
+
+  const { languageDirs, englishSections } = classifyDocsDirs();
+  console.log(`\nValidating sidebar ordering in: ${DOCS_ROOT}\n`);
+  console.log(`English sections: ${englishSections.join(', ')}`);
+  console.log(`Translation languages: ${languageDirs.join(', ')}\n`);
+
+  const allErrors = [];
+  const allWarnings = [];
+  const englishOrderMaps = new Map();
+
+  for (const section of englishSections) {
+    const sectionDir = path.join(DOCS_ROOT, section);
+    if (!fs.existsSync(sectionDir)) continue;
+
+    console.log(`\nChecking English docs/${section}/`);
+    const { orderMap, issues } = checkDirectory(sectionDir);
+    englishOrderMaps.set(section, orderMap);
+
+    for (const issue of issues) {
+      allErrors.push(issue);
+      reportIssue(issue, '  ', `docs/${section}`);
+    }
+    if (issues.length === 0) {
+      console.log(`  [OK] docs/${section}/ — all orders valid`);
+    }
+  }
+
+  for (const lang of languageDirs) {
+    const langDir = path.join(DOCS_ROOT, lang);
+    const langSections = fs
+      .readdirSync(langDir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !e.name.startsWith('_'))
+      .map((e) => e.name);
+
+    console.log(`\nChecking ${lang}/ docs`);
+
+    for (const section of langSections) {
+      const sectionDir = path.join(langDir, section);
+      if (!fs.existsSync(sectionDir)) continue;
+
+      console.log(`  ${lang}/${section}/`);
+      const { issues } = checkDirectory(sectionDir);
+
+      for (const issue of issues) {
+        allErrors.push(issue);
+        reportIssue(issue, '    ', `${lang}/${section}`);
+      }
+      if (issues.length === 0) {
+        console.log(`    [OK] ${lang}/${section}/ — all orders valid`);
+      }
+    }
+
+    for (const w of checkTranslationDrift(lang, langSections, englishOrderMaps)) {
+      allWarnings.push(w);
+      const langDisplay = w.langOrder === null ? 'no order' : `order ${w.langOrder}`;
+      console.log(`  [WARN] ${rel(w.file)}: ${langDisplay} (English: ${w.englishOrder})`);
+    }
+  }
+
+  printSummary(allErrors, allWarnings);
+  process.exit(allErrors.length > 0 ? 1 : 0);
+}
+
+// ── Directory classification ─────────────────────────────────────────────
+
+/**
+ * Classify top-level docs/ subdirectories as language dirs or English sections.
+ * Language dirs match BCP 47 locale pattern; everything else is English.
+ * @returns {{ languageDirs: string[], englishSections: string[] }}
+ */
+function classifyDocsDirs() {
+  const dirs = fs.readdirSync(DOCS_ROOT, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith('_'));
+
+  const languageDirs = [];
+  const englishSections = [];
+
+  for (const d of dirs) {
+    (LOCALE_RE.test(d.name) ? languageDirs : englishSections).push(d.name);
+  }
+
+  return { languageDirs, englishSections };
+}
+
+// ── Per-directory validation ─────────────────────────────────────────────
+
+/**
+ * Validate sidebar.order values for all markdown files in a directory.
+ * Detects duplicates, gaps in sequence, missing-order, and invalid-order fields.
+ * @param {string} dirPath - Absolute path to the directory to scan.
+ * @returns {{ orderMap: Map<number, string[]>, issues: object[] }}
+ */
+function checkDirectory(dirPath) {
+  const issues = [];
+  const orderMap = new Map();
+  const missingOrder = [];
+  const invalidOrder = [];
+
+  for (const entry of listMdEntries(dirPath)) {
+    const fullPath = path.join(dirPath, entry.name);
+    const result = extractSidebarOrder(fs.readFileSync(fullPath, 'utf-8'));
+
+    if (!result.hasSidebar) continue;
+    if (result.order === null) {
+      if (result.orderInvalid) {
+        invalidOrder.push(fullPath);
+      } else {
+        missingOrder.push(fullPath);
+      }
+      continue;
+    }
+
+    if (!orderMap.has(result.order)) orderMap.set(result.order, []);
+    orderMap.get(result.order).push(fullPath);
+  }
+
+  for (const file of missingOrder) {
+    issues.push({ level: 'error', type: 'missing-order', file, message: 'Has sidebar: block but no order: field' });
+  }
+
+  for (const file of invalidOrder) {
+    issues.push({ level: 'error', type: 'invalid-order', file, message: 'Invalid sidebar.order: must be a positive integer' });
+  }
+
+  for (const [order, files] of orderMap) {
+    if (files.length > 1) {
+      for (const file of files) {
+        issues.push({ level: 'error', type: 'duplicate-order', file, order, message: `Duplicate sidebar.order: ${order}` });
+      }
+    }
+  }
+
+  if (orderMap.size > 0) {
+    let max = -Infinity;
+    for (const k of orderMap.keys()) if (k > max) max = k;
+
+    let gapCount = 0;
+    for (let i = 1; i <= max; i++) {
+      if (!orderMap.has(i)) {
+        issues.push({
+          level: 'error',
+          type: 'gap',
+          directory: dirPath,
+          missing: i,
+          message: `Gap in sidebar order: missing position ${i}`,
+        });
+        gapCount++;
+        if (gapCount >= MAX_GAPS) {
+          issues.push({
+            level: 'error',
+            type: 'gap-truncated',
+            directory: dirPath,
+            message: `Too many gaps (stopped after ${MAX_GAPS}) — check for typos in sidebar.order values`,
+          });
+          break;
+        }
+      }
+    }
+  }
+
+  return { orderMap, issues };
+}
+
+// ── Cross-language drift ─────────────────────────────────────────────────
+
+/**
+ * Compare translated sidebar orders against English counterparts and warn on drift.
+ * Warns on numeric drift and on translation having sidebar but missing order.
+ * Files without an English counterpart are skipped silently.
+ * @param {string} lang - Language directory name (e.g. "cs", "zh-cn").
+ * @param {string[]} langSections - Section subdirectories within the language folder.
+ * @param {Map<string, Map<number, string[]>>} englishOrderMaps - English order maps keyed by section name.
+ * @returns {object[]} Drift warnings.
+ */
+function checkTranslationDrift(lang, langSections, englishOrderMaps) {
+  const warnings = [];
+
+  for (const section of langSections) {
+    const sectionDir = path.join(DOCS_ROOT, lang, section);
+    if (!fs.existsSync(sectionDir)) continue;
+
+    const englishMap = englishOrderMaps.get(section);
+    if (!englishMap) continue;
+
+    for (const entry of listMdEntries(sectionDir)) {
+      const langFile = path.join(sectionDir, entry.name);
+      const englishFile = path.join(DOCS_ROOT, section, entry.name);
+      if (!fs.existsSync(englishFile)) continue;
+
+      const langResult = extractSidebarOrder(fs.readFileSync(langFile, 'utf-8'));
+      const engResult = extractSidebarOrder(fs.readFileSync(englishFile, 'utf-8'));
+
+      const langHasOrder = typeof langResult.order === 'number';
+      const engHasOrder = typeof engResult.order === 'number';
+
+      if (langHasOrder && engHasOrder && langResult.order !== engResult.order) {
+        warnings.push({
+          level: 'warning',
+          type: 'order-drift',
+          file: langFile,
+          englishFile,
+          langOrder: langResult.order,
+          englishOrder: engResult.order,
+        });
+      } else if (engHasOrder && langResult.hasSidebar && !langHasOrder) {
+        warnings.push({
+          level: 'warning',
+          type: 'order-drift',
+          file: langFile,
+          englishFile,
+          langOrder: null,
+          englishOrder: engResult.order,
+        });
+      }
+    }
+  }
+
+  return warnings;
+}
+
+// ── Output ───────────────────────────────────────────────────────────────
+
+/**
+ * Print a single validation issue to stdout.
+ * @param {object} issue - Issue object with type, file/order/message fields.
+ * @param {string} indent - Whitespace prefix for indentation.
+ * @param {string} ctxPath - Display path for gap issues (e.g. "docs/explanation").
+ */
+function reportIssue(issue, indent, ctxPath) {
+  switch (issue.type) {
+    case 'duplicate-order': {
+      console.log(`${indent}[ERROR] Duplicate order ${issue.order}: ${rel(issue.file)}`);
+      break;
+    }
+    case 'gap': {
+      console.log(`${indent}[ERROR] ${issue.message} in ${ctxPath}/`);
+      break;
+    }
+    case 'gap-truncated': {
+      console.log(`${indent}[ERROR] ${issue.message}`);
+      break;
+    }
+    case 'missing-order': {
+      console.log(`${indent}[ERROR] ${issue.message}: ${rel(issue.file)}`);
+      break;
+    }
+    case 'invalid-order': {
+      console.log(`${indent}[ERROR] ${issue.message}: ${rel(issue.file)}`);
+      break;
+    }
+  }
+}
+
+/**
+ * Print summary with error/warning counts and error type breakdown.
+ * @param {object[]} errors - All collected errors.
+ * @param {object[]} warnings - All collected warnings.
+ */
+function printSummary(errors, warnings) {
+  console.log(`\n${'─'.repeat(60)}`);
+  console.log('\nSummary:');
+  console.log(`   Errors:   ${errors.length}`);
+  console.log(`   Warnings: ${warnings.length}`);
+
+  if (errors.length > 0) {
+    const breakdown = {};
+    for (const e of errors) breakdown[e.type] = (breakdown[e.type] || 0) + 1;
+    console.log('\n   Error breakdown:');
+    for (const [type, count] of Object.entries(breakdown)) console.log(`     ${type}: ${count}`);
+  }
+
+  if (errors.length === 0 && warnings.length === 0) {
+    console.log('\n   All sidebar orders valid!');
+  }
+
+  console.log('');
+}
+
+// ── Leaf helpers ─────────────────────────────────────────────────────────
+
+/**
+ * Convert an absolute path to one relative to DOCS_ROOT.
+ * @param {string} filePath - Absolute file path.
+ * @returns {string} Relative path from docs root.
+ */
+function rel(filePath) {
+  return path.relative(DOCS_ROOT, filePath);
+}
+
+/**
+ * Extract sidebar.order from YAML frontmatter.
+ * Handles block mapping (sidebar:\n  order: 5) and flow mapping (sidebar: { order: 5 }).
+ * Only matches order: as a direct child of sidebar:, not from nested blocks.
+ * @param {string} content - Full file contents of a markdown file.
+ * @returns {{ hasSidebar: boolean, order?: number|null, orderInvalid?: boolean }}
+ */
+function extractSidebarOrder(content) {
+  const match = content.match(FRONTMATTER_RE);
+  if (!match) return { hasSidebar: false };
+
+  const frontmatter = match[1];
+
+  // Flow mapping: sidebar: { order: 5 }
+  const inline = frontmatter.match(/^sidebar:[ \t]*\{[^}]*\border:[ \t]*(\d+)/m);
+  if (inline) return validateOrder(inline[1]);
+
+  // Block mapping: sidebar:\n  order: 5
+  if (!/^sidebar:[ \t]*$/m.test(frontmatter)) return { hasSidebar: false };
+
+  const lines = frontmatter.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^sidebar:[ \t]*$/.test(l));
+  let baseIndent = null;
+
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*$/.test(line)) continue;
+
+    const indent = line.search(/\S/);
+    if (indent === 0) break;
+    if (baseIndent === null) baseIndent = indent;
+    if (indent < baseIndent) break;
+    if (indent > baseIndent) continue;
+
+    const m = line.match(/^\s+order:[ \t]*(\d+)/);
+    if (m) return validateOrder(m[1]);
+  }
+
+  return { hasSidebar: true, order: null };
+}
+
+/**
+ * Validate a parsed order value and return a result object.
+ * Rejects non-finite values (Infinity, NaN) and non-positive values (0, negative).
+ * @param {string} raw - Raw digit string from frontmatter.
+ * @returns {{ hasSidebar: boolean, order?: number|null, orderInvalid?: boolean }}
+ */
+function validateOrder(raw) {
+  const n = parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 1) return { hasSidebar: true, order: null, orderInvalid: true };
+  return { hasSidebar: true, order: n };
+}
+
+/**
+ * List markdown files (.md/.mdx) in a directory, excluding subdirectories.
+ * @param {string} dirPath - Absolute path to the directory.
+ * @returns {fs.Dirent[]} Dirent entries for markdown files.
+ */
+function listMdEntries(dirPath) {
+  return fs.readdirSync(dirPath, { withFileTypes: true }).filter((e) => e.isFile() && (e.name.endsWith('.md') || e.name.endsWith('.mdx')));
+}
+
+main();