@unrdf/diataxis-kit 26.4.2

package/src/scaffold.mjs

@@ -0,0 +1,458 @@
+/**
+ * @file Scaffold generator - converts DiataxisEntry to markdown files
+ * @module scaffold
+ */
+
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { stableStringify } from './stable-json.mjs';
+import { hashString, hashObject } from './hash.mjs';
+
+/**
+ * @typedef {Object} ScaffoldOutput
+ * @property {string} packageName - Package name
+ * @property {string[]} filesGenerated - Absolute paths to generated files
+ * @property {string} indexPath - Absolute path to index.md
+ * @property {string} filesHash - SHA256 of concatenated file hashes
+ */
+
+/**
+ * Generate scaffold markdown files from a DiataxisEntry
+ * @param {import('./diataxis-schema.mjs').DiataxisEntry} diataxisEntry - Entry to scaffold
+ * @param {string} outputDir - Output directory path
+ * @returns {Promise<ScaffoldOutput>} Scaffold output metadata
+ */
+export async function generateScaffold(diataxisEntry, outputDir) {
+  const absOutputDir = resolve(outputDir);
+
+  // Create output directory structure
+  await mkdir(absOutputDir, { recursive: true });
+  await mkdir(join(absOutputDir, 'tutorials'), { recursive: true });
+  await mkdir(join(absOutputDir, 'how-to'), { recursive: true });
+  await mkdir(join(absOutputDir, 'reference'), { recursive: true });
+  await mkdir(join(absOutputDir, 'explanation'), { recursive: true });
+
+  /** @type {string[]} */
+  const filesGenerated = [];
+
+  // Generate tutorial files
+  for (const tutorial of diataxisEntry.tutorials) {
+    const filePath = join(absOutputDir, 'tutorials', `tutorial-${tutorial.id}.md`);
+    const content = generateTutorialMarkdown(tutorial, diataxisEntry);
+    await writeFile(filePath, content, 'utf8');
+    filesGenerated.push(filePath);
+  }
+
+  // Generate how-to files
+  for (const howto of diataxisEntry.howtos) {
+    const filePath = join(absOutputDir, 'how-to', `howto-${howto.id}.md`);
+    const content = generateHowToMarkdown(howto, diataxisEntry);
+    await writeFile(filePath, content, 'utf8');
+    filesGenerated.push(filePath);
+  }
+
+  // Generate reference file
+  const referencePath = join(absOutputDir, 'reference', 'reference.md');
+  const referenceContent = generateReferenceMarkdown(diataxisEntry.reference, diataxisEntry);
+  await writeFile(referencePath, referenceContent, 'utf8');
+  filesGenerated.push(referencePath);
+
+  // Generate explanation file
+  const explanationPath = join(absOutputDir, 'explanation', 'explanation.md');
+  const explanationContent = generateExplanationMarkdown(diataxisEntry.explanation, diataxisEntry);
+  await writeFile(explanationPath, explanationContent, 'utf8');
+  filesGenerated.push(explanationPath);
+
+  // Generate index.md
+  const indexPath = join(absOutputDir, 'index.md');
+  const indexContent = generateIndexMarkdown(diataxisEntry, filesGenerated);
+  await writeFile(indexPath, indexContent, 'utf8');
+
+  // Calculate filesHash (SHA256 of concatenated file hashes)
+  const fileHashes = [];
+  const allFiles = [...filesGenerated, indexPath].sort();
+  for (const filePath of allFiles) {
+    const fileContent = await readFile(filePath, 'utf8');
+    const hash = hashString(fileContent);
+    fileHashes.push(hash);
+  }
+  const filesHash = hashString(fileHashes.join(''));
+
+  return {
+    packageName: diataxisEntry.packageName,
+    filesGenerated: filesGenerated.sort(),
+    indexPath,
+    filesHash
+  };
+}
+
+/**
+ * Generate markdown content for a tutorial
+ * @param {import('./diataxis-schema.mjs').Tutorial} tutorial - Tutorial object
+ * @param {import('./diataxis-schema.mjs').DiataxisEntry} entry - Parent entry
+ * @returns {string} Markdown content
+ */
+function generateTutorialMarkdown(tutorial, entry) {
+  const proof = calculateProof({
+    source: tutorial.source,
+    title: tutorial.title,
+    confidenceScore: tutorial.confidenceScore
+  });
+
+  const frontmatter = generateFrontmatter({
+    title: tutorial.title,
+    type: 'tutorial',
+    packageName: entry.packageName,
+    version: entry.version,
+    generatedAt: entry.generatedAt,
+    confidenceScore: tutorial.confidenceScore,
+    proof
+  });
+
+  const prerequisites = tutorial.prerequisites?.length > 0
+    ? tutorial.prerequisites.map(p => `- ${p}`).join('\n')
+    : '- None';
+
+  const steps = tutorial.stepsOutline?.length > 0
+    ? tutorial.stepsOutline.map((step, i) => `${i + 1}. ${step}`).join('\n')
+    : '1. (Steps to be defined)';
+
+  const proofBlock = generateProofBlock({
+    sources: tutorial.source,
+    fingerprintInput: `${tutorial.source.sort().join('|')}|${tutorial.title}|${tutorial.confidenceScore}`,
+    hash: proof
+  });
+
+  return `${frontmatter}
+
+## Overview
+
+${tutorial.goal || 'Learn how to use this feature.'}
+
+## Prerequisites
+
+${prerequisites}
+
+## Steps
+
+${steps}
+
+${proofBlock}
+`;
+}
+
+/**
+ * Generate markdown content for a how-to
+ * @param {import('./diataxis-schema.mjs').HowTo} howto - How-to object
+ * @param {import('./diataxis-schema.mjs').DiataxisEntry} entry - Parent entry
+ * @returns {string} Markdown content
+ */
+function generateHowToMarkdown(howto, entry) {
+  const proof = calculateProof({
+    source: howto.source,
+    title: howto.title,
+    confidenceScore: howto.confidenceScore
+  });
+
+  const frontmatter = generateFrontmatter({
+    title: howto.title,
+    type: 'how-to',
+    packageName: entry.packageName,
+    version: entry.version,
+    generatedAt: entry.generatedAt,
+    confidenceScore: howto.confidenceScore,
+    proof
+  });
+
+  const steps = howto.steps?.length > 0
+    ? howto.steps.map((step, i) => `${i + 1}. ${step}`).join('\n')
+    : '1. (Steps to be defined)';
+
+  const proofBlock = generateProofBlock({
+    sources: howto.source,
+    fingerprintInput: `${howto.source.sort().join('|')}|${howto.title}|${howto.confidenceScore}`,
+    hash: proof
+  });
+
+  return `${frontmatter}
+
+## Task
+
+${howto.task || 'Perform a specific task.'}
+
+## Context
+
+${howto.context || 'Use this guide when you need to accomplish a specific goal.'}
+
+## Steps
+
+${steps}
+
+${proofBlock}
+`;
+}
+
+/**
+ * Generate markdown content for reference
+ * @param {import('./diataxis-schema.mjs').Reference} reference - Reference object
+ * @param {import('./diataxis-schema.mjs').DiataxisEntry} entry - Parent entry
+ * @returns {string} Markdown content
+ */
+function generateReferenceMarkdown(reference, entry) {
+  const proof = calculateProof({
+    source: reference.source,
+    title: reference.title,
+    confidenceScore: reference.confidenceScore
+  });
+
+  const frontmatter = generateFrontmatter({
+    title: reference.title,
+    type: 'reference',
+    packageName: entry.packageName,
+    version: entry.version,
+    generatedAt: entry.generatedAt,
+    confidenceScore: reference.confidenceScore,
+    proof
+  });
+
+  let tableContent = '| Name | Type | Description |\n|------|------|-------------|\n';
+
+  if (reference.items?.length > 0) {
+    for (const item of reference.items) {
+      const name = escapeMarkdown(item.name || '');
+      const type = escapeMarkdown(item.type || 'unknown');
+      const description = escapeMarkdown(item.description || '');
+      tableContent += `| ${name} | ${type} | ${description} |\n`;
+    }
+  } else {
+    tableContent += '| - | - | (No items documented) |\n';
+  }
+
+  const proofBlock = generateProofBlock({
+    sources: reference.source,
+    fingerprintInput: `${reference.source.sort().join('|')}|${reference.title}|${reference.confidenceScore}`,
+    hash: proof
+  });
+
+  return `${frontmatter}
+
+## Overview
+
+This reference documentation provides technical details for ${entry.packageName}.
+
+## API Reference
+
+${tableContent}
+
+${proofBlock}
+`;
+}
+
+/**
+ * Generate markdown content for explanation
+ * @param {import('./diataxis-schema.mjs').Explanation} explanation - Explanation object
+ * @param {import('./diataxis-schema.mjs').DiataxisEntry} entry - Parent entry
+ * @returns {string} Markdown content
+ */
+function generateExplanationMarkdown(explanation, entry) {
+  const proof = calculateProof({
+    source: explanation.source,
+    title: explanation.title,
+    confidenceScore: explanation.confidenceScore
+  });
+
+  const frontmatter = generateFrontmatter({
+    title: explanation.title,
+    type: 'explanation',
+    packageName: entry.packageName,
+    version: entry.version,
+    generatedAt: entry.generatedAt,
+    confidenceScore: explanation.confidenceScore,
+    proof
+  });
+
+  const concepts = explanation.concepts?.length > 0
+    ? explanation.concepts.map(c => `- ${c}`).join('\n')
+    : '- (No concepts documented)';
+
+  const architecture = explanation.architecture || '(No architecture documented)';
+
+  const tradeoffs = explanation.tradeoffs?.length > 0
+    ? explanation.tradeoffs.map(t => `- ${t}`).join('\n')
+    : '- (No tradeoffs documented)';
+
+  const proofBlock = generateProofBlock({
+    sources: explanation.source,
+    fingerprintInput: `${explanation.source.sort().join('|')}|${explanation.title}|${explanation.confidenceScore}`,
+    hash: proof
+  });
+
+  return `${frontmatter}
+
+## Concepts
+
+${concepts}
+
+## Architecture
+
+${architecture}
+
+## Tradeoffs
+
+${tradeoffs}
+
+${proofBlock}
+`;
+}
+
+/**
+ * Generate index.md content
+ * @param {import('./diataxis-schema.mjs').DiataxisEntry} entry - Diataxis entry
+ * @param {string[]} filesGenerated - List of generated files
+ * @returns {string} Markdown content
+ */
+function generateIndexMarkdown(entry, filesGenerated) {
+  const tutorialCount = entry.tutorials?.length || 0;
+  const howtoCount = entry.howtos?.length || 0;
+  const hasReference = entry.reference?.items?.length > 0;
+  const hasExplanation = entry.explanation?.concepts?.length > 0 ||
+                         entry.explanation?.architecture?.length > 0 ||
+                         entry.explanation?.tradeoffs?.length > 0;
+
+  let tutorialLinks = '';
+  if (tutorialCount > 0) {
+    tutorialLinks = '### Tutorials\n\n';
+    for (const tutorial of entry.tutorials) {
+      tutorialLinks += `- [${tutorial.title}](tutorials/tutorial-${tutorial.id}.md)\n`;
+    }
+    tutorialLinks += '\n';
+  }
+
+  let howtoLinks = '';
+  if (howtoCount > 0) {
+    howtoLinks = '### How-To Guides\n\n';
+    for (const howto of entry.howtos) {
+      howtoLinks += `- [${howto.title}](how-to/howto-${howto.id}.md)\n`;
+    }
+    howtoLinks += '\n';
+  }
+
+  let referenceLink = '';
+  if (hasReference) {
+    referenceLink = '### Reference\n\n';
+    referenceLink += `- [${entry.reference.title}](reference/reference.md)\n\n`;
+  }
+
+  let explanationLink = '';
+  if (hasExplanation) {
+    explanationLink = '### Explanation\n\n';
+    explanationLink += `- [${entry.explanation.title}](explanation/explanation.md)\n\n`;
+  }
+
+  return `---
+title: "${entry.packageName} Documentation"
+packageName: "${entry.packageName}"
+version: "${entry.version}"
+generatedAt: "${entry.generatedAt}"
+---
+
+# ${entry.packageName} Documentation
+
+Generated documentation using the Diátaxis framework.
+
+## Quick Stats
+
+- **Tutorials**: ${tutorialCount}
+- **How-To Guides**: ${howtoCount}
+- **Reference**: ${hasReference ? 'Available' : 'Not available'}
+- **Explanation**: ${hasExplanation ? 'Available' : 'Not available'}
+
+## Documentation Sections
+
+${tutorialLinks}${howtoLinks}${referenceLink}${explanationLink}
+
+---
+
+*Generated at ${entry.generatedAt}*
+`;
+}
+
+/**
+ * Generate YAML frontmatter
+ * @param {Object} metadata - Frontmatter metadata
+ * @param {string} metadata.title - Document title
+ * @param {string} metadata.type - Document type
+ * @param {string} metadata.packageName - Package name
+ * @param {string} metadata.version - Package version
+ * @param {string} metadata.generatedAt - Generation timestamp
+ * @param {number} metadata.confidenceScore - Confidence score
+ * @param {string} metadata.proof - Proof hash
+ * @returns {string} YAML frontmatter block
+ */
+function generateFrontmatter(metadata) {
+  // Fixed order for determinism
+  return `---
+title: "${metadata.title}"
+type: "${metadata.type}"
+packageName: "${metadata.packageName}"
+version: "${metadata.version}"
+generatedAt: "${metadata.generatedAt}"
+confidenceScore: ${metadata.confidenceScore}
+proof: "${metadata.proof}"
+---`;
+}
+
+/**
+ * Generate proof block
+ * @param {Object} proofData - Proof data
+ * @param {string[]} proofData.sources - Source list
+ * @param {string} proofData.fingerprintInput - Fingerprint input
+ * @param {string} proofData.hash - Computed hash
+ * @returns {string} Proof block markdown
+ */
+function generateProofBlock(proofData) {
+  const sourcesList = proofData.sources?.length > 0
+    ? proofData.sources.map(s => `- ${s}`).join('\n')
+    : '- (No sources recorded)';
+
+  const proofJson = stableStringify({
+    sources: proofData.sources || [],
+    fingerprintInput: proofData.fingerprintInput,
+    hash: proofData.hash
+  }, { indent: 2 });
+
+  return `## Proof
+
+This file was generated from the following evidence sources:
+
+${sourcesList}
+
+\`\`\`json
+${proofJson}
+\`\`\``;
+}
+
+/**
+ * Calculate proof hash for a content object
+ * @param {Object} data - Data to hash
+ * @param {string[]} data.source - Source array
+ * @param {string} data.title - Content title
+ * @param {number} data.confidenceScore - Confidence score
+ * @returns {string} SHA256 hash (hex)
+ */
+function calculateProof(data) {
+  const fingerprintInput = `${data.source.sort().join('|')}|${data.title}|${data.confidenceScore}`;
+  return hashString(fingerprintInput);
+}
+
+/**
+ * Escape markdown special characters in table cells
+ * @param {string} text - Text to escape
+ * @returns {string} Escaped text
+ */
+function escapeMarkdown(text) {
+  return text
+    .replace(/\|/g, '\\|')
+    .replace(/\n/g, ' ')
+    .replace(/\r/g, '');
+}

package/src/stable-json.mjs

@@ -0,0 +1,113 @@
+/**
+ * @file Stable JSON stringification for deterministic output
+ * @module stable-json
+ */
+
+/**
+ * @typedef {Object} StableStringifyOptions
+ * @property {number} [indent=2] - Number of spaces for indentation
+ * @property {boolean} [includeNull=true] - Include null values in output
+ */
+
+/**
+ * Deterministically stringify an object with sorted keys
+ * @param {any} obj - Object to stringify
+ * @param {StableStringifyOptions} [options={}] - Stringification options
+ * @returns {string} Deterministically stringified JSON
+ */
+export function stableStringify(obj, options = {}) {
+  const indent = options.indent ?? 2;
+  const includeNull = options.includeNull ?? true;
+
+  /**
+   * Internal recursive stringifier
+   * @param {any} value - Value to stringify
+   * @param {number} depth - Current indentation depth
+   * @returns {string} Stringified value
+   */
+  function stringify(value, depth = 0) {
+    // Handle primitives
+    if (value === null) {
+      return includeNull ? 'null' : undefined;
+    }
+    if (value === undefined) {
+      return undefined;
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+      return String(value);
+    }
+    if (typeof value === 'string') {
+      return JSON.stringify(value);
+    }
+
+    // Handle arrays - preserve order, do NOT sort
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return '[]';
+      }
+      const items = value
+        .map(item => stringify(item, depth + 1))
+        .filter(item => item !== undefined);
+
+      if (indent === 0) {
+        return `[${items.join(',')}]`;
+      }
+
+      const currentIndent = ' '.repeat(depth * indent);
+      const nextIndent = ' '.repeat((depth + 1) * indent);
+      return `[\n${nextIndent}${items.join(`,\n${nextIndent}`)}\n${currentIndent}]`;
+    }
+
+    // Handle objects - SORT keys
+    if (typeof value === 'object') {
+      const keys = Object.keys(value).sort((a, b) => a.localeCompare(b));
+
+      if (keys.length === 0) {
+        return '{}';
+      }
+
+      const pairs = [];
+      for (const key of keys) {
+        const stringified = stringify(value[key], depth + 1);
+        if (stringified !== undefined) {
+          pairs.push([key, stringified]);
+        }
+      }
+
+      if (pairs.length === 0) {
+        return '{}';
+      }
+
+      if (indent === 0) {
+        return `{${pairs.map(([k, v]) => `${JSON.stringify(k)}:${v}`).join(',')}}`;
+      }
+
+      const currentIndent = ' '.repeat(depth * indent);
+      const nextIndent = ' '.repeat((depth + 1) * indent);
+      const pairStrings = pairs.map(([k, v]) => `${nextIndent}${JSON.stringify(k)}: ${v}`);
+      return `{\n${pairStrings.join(',\n')}\n${currentIndent}}`;
+    }
+
+    // Fallback for functions, symbols, etc.
+    return undefined;
+  }
+
+  const result = stringify(obj, 0);
+  return result ?? 'null';
+}
+
+/**
+ * Compare two objects for structural equality using stable stringify
+ * @param {any} obj1 - First object
+ * @param {any} obj2 - Second object
+ * @returns {boolean} True if structurally equal
+ */
+export function stableEqual(obj1, obj2) {
+  try {
+    const str1 = stableStringify(obj1, { indent: 0 });
+    const str2 = stableStringify(obj2, { indent: 0 });
+    return str1 === str2;
+  } catch {
+    return false;
+  }
+}

package/src/verify-implementation.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * @file Quick verification of diataxis-kit implementations
+ */
+
+import { stableStringify, stableEqual } from './stable-json.mjs';
+import { hashObject, hashString, hashFile } from './hash.mjs';
+import { createDiataxisEntry, validateDiataxisEntry, ensureMinimumDiataxis } from './diataxis-schema.mjs';
+
+let errors = 0;
+
+function assert(condition, message) {
+  if (!condition) {
+    console.error(`❌ FAIL: ${message}`);
+    errors++;
+  } else {
+    console.log(`✅ PASS: ${message}`);
+  }
+}
+
+console.log('=== Testing stable-json.mjs ===\n');
+
+// Test 1: Key sorting
+const unsorted = { z: 1, a: 2, m: 3 };
+const json = stableStringify(unsorted, { indent: 0 });
+assert(json === '{"a":2,"m":3,"z":1}', 'Keys should be sorted alphabetically');
+
+// Test 2: Array order preserved
+const withArray = { b: [3, 1, 2], a: 1 };
+const jsonArray = stableStringify(withArray, { indent: 0 });
+assert(jsonArray === '{"a":1,"b":[3,1,2]}', 'Array order should be preserved');
+
+// Test 3: Nested object sorting
+const nested = { z: { z: 1, a: 2 }, a: 1 };
+const jsonNested = stableStringify(nested, { indent: 0 });
+assert(jsonNested === '{"a":1,"z":{"a":2,"z":1}}', 'Nested objects should have sorted keys');
+
+// Test 4: stableEqual
+const obj1 = { a: 1, b: 2 };
+const obj2 = { b: 2, a: 1 };
+assert(stableEqual(obj1, obj2), 'Objects with same content should be equal');
+
+const obj3 = { a: 1, b: 3 };
+assert(!stableEqual(obj1, obj3), 'Objects with different content should not be equal');
+
+console.log('\n=== Testing hash.mjs ===\n');
+
+// Test 5: hashString produces consistent output
+const str = 'test string';
+const hash1 = hashString(str);
+const hash2 = hashString(str);
+assert(hash1 === hash2, 'hashString should be deterministic');
+assert(hash1.length === 64, 'SHA256 hash should be 64 hex characters');
+assert(/^[a-f0-9]{64}$/.test(hash1), 'Hash should be valid hex');
+
+// Test 6: hashObject uses stable stringify
+const hashObj1 = hashObject({ b: 2, a: 1 });
+const hashObj2 = hashObject({ a: 1, b: 2 });
+assert(hashObj1 === hashObj2, 'hashObject should ignore key order');
+
+console.log('\n=== Testing diataxis-schema.mjs ===\n');
+
+// Test 7: createDiataxisEntry with minimal input
+const entry1 = createDiataxisEntry('test-package', '1.0.0', {});
+assert(entry1.packageName === 'test-package', 'Package name should be set');
+assert(entry1.version === '1.0.0', 'Version should be set');
+assert(entry1.generatedAt, 'Timestamp should be generated');
+assert(Array.isArray(entry1.tutorials), 'Tutorials should be an array');
+assert(Array.isArray(entry1.howtos), 'Howtos should be an array');
+assert(entry1.reference && typeof entry1.reference === 'object', 'Reference should be an object');
+assert(entry1.explanation && typeof entry1.explanation === 'object', 'Explanation should be an object');
+
+// Test 8: DETERMINISTIC mode
+process.env.DETERMINISTIC = '1';
+const entry2 = createDiataxisEntry('test-package', '1.0.0', {});
+assert(entry2.generatedAt === '2000-01-01T00:00:00.000Z', 'DETERMINISTIC=1 should use fixed timestamp');
+delete process.env.DETERMINISTIC;
+
+// Test 9: validateDiataxisEntry
+const validation1 = validateDiataxisEntry(entry1);
+assert(validation1.valid, 'Valid entry should pass validation');
+assert(validation1.errors.length === 0, 'Valid entry should have no errors');
+
+// Test 10: Invalid entry fails validation
+const invalidEntry = { packageName: 'test' };
+const validation2 = validateDiataxisEntry(invalidEntry);
+assert(!validation2.valid, 'Invalid entry should fail validation');
+assert(validation2.errors.length > 0, 'Invalid entry should have errors');
+
+// Test 11: ensureMinimumDiataxis
+const minimalEntry = createDiataxisEntry('test', '1.0.0', {
+  tutorials: [],
+  howtos: [],
+  reference: null,
+  explanation: null
+});
+const ensured = ensureMinimumDiataxis(minimalEntry);
+assert(ensured.reference.items.length === 0, 'Empty reference should be created');
+assert(ensured.explanation.concepts.length === 0, 'Empty explanation should be created');
+assert(ensured.confidence.reference === 0, 'Empty reference should have 0 confidence');
+assert(ensured.confidence.explanation === 0, 'Empty explanation should have 0 confidence');
+
+// Test 12: Evidence fingerprint
+const entry3 = createDiataxisEntry('test', '1.0.0', {
+  readmeHeadings: ['Installation', 'Usage'],
+  docsFiles: ['README.md'],
+  examplesFiles: ['example.js']
+});
+assert(entry3.evidence.fingerprint.length === 64, 'Fingerprint should be SHA256 hash');
+assert(entry3.evidence.readmeHeadings.length === 2, 'Evidence should preserve headings');
+
+// Test 13: Tutorial/HowTo ID generation
+const entry4 = createDiataxisEntry('test', '1.0.0', {
+  tutorials: [
+    { title: 'Getting Started with Test', goal: 'Learn basics', prerequisites: [], stepsOutline: [], confidenceScore: 0.8, source: ['README'] }
+  ],
+  howtos: [
+    { title: 'How to Install Test', task: 'Install', context: 'Setup', steps: [], confidenceScore: 0.9, source: ['README'] }
+  ]
+});
+assert(entry4.tutorials[0].id === 'getting-started-with-test', 'Tutorial ID should be generated from title');
+assert(entry4.howtos[0].id === 'how-to-install-test', 'HowTo ID should be generated from title');
+
+console.log('\n=== Summary ===\n');
+if (errors === 0) {
+  console.log('✅ All tests passed!');
+  process.exit(0);
+} else {
+  console.log(`❌ ${errors} test(s) failed`);
+  process.exit(1);
+}