@mindrian_os/install 1.13.0-beta.11

package/lib/vault/wikilink-builder.test.cjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+/**
+ * Unit tests for lib/vault/wikilink-builder.cjs
+ *
+ * Zero-dependency test runner using Node's built-in `assert`.
+ * Run: node lib/vault/wikilink-builder.test.cjs
+ */
+
+'use strict';
+
+const assert = require('assert');
+const wb = require('./wikilink-builder.cjs');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed += 1;
+    process.stdout.write(`  ok  ${name}\n`);
+  } catch (err) {
+    failed += 1;
+    process.stdout.write(`  FAIL ${name}\n    ${err.message}\n`);
+  }
+}
+
+const profiles = [
+  {
+    name: 'avital-leibovich',
+    displayName: 'Avital Leibovich',
+    path: '/room/team/advisors/avital-leibovich/PROFILE.md',
+    category: 'advisors',
+  },
+  {
+    name: 'avital-only',
+    displayName: 'Avital',
+    path: '/room/team/advisors/avital-only/PROFILE.md',
+    category: 'advisors',
+  },
+  {
+    name: 'lawrence-aronhime',
+    displayName: 'Lawrence Aronhime',
+    path: '/room/team/mentors/lawrence-aronhime/PROFILE.md',
+    category: 'mentors',
+  },
+];
+
+// Test 1: first occurrence only
+test('buildTeamLinks replaces first occurrence only', () => {
+  const input = 'Lawrence Aronhime said X. Later Lawrence Aronhime said Y.';
+  const out = wb.buildTeamLinks(input, profiles, {});
+  const link = '[[team/mentors/lawrence-aronhime/PROFILE.md|Lawrence Aronhime]]';
+  assert.ok(out.includes(link), 'expected link inserted');
+  // Only one link
+  const count = out.split(link).length - 1;
+  assert.strictEqual(count, 1, `expected exactly 1 link, got ${count}`);
+  // Second occurrence is untouched plain text
+  assert.ok(out.endsWith('Later Lawrence Aronhime said Y.'), 'second occurrence preserved');
+});
+
+// Test 2: longest-name preference
+test('buildTeamLinks prefers longer name over prefix (Avital Leibovich > Avital)', () => {
+  const input = 'Meeting with Avital Leibovich today.';
+  const out = wb.buildTeamLinks(input, profiles, {});
+  assert.ok(
+    out.includes('[[team/advisors/avital-leibovich/PROFILE.md|Avital Leibovich]]'),
+    'longer name should win'
+  );
+  assert.ok(
+    !out.includes('[[team/advisors/avital-only/PROFILE.md|Avital]]'),
+    'shorter prefix should not link'
+  );
+});
+
+// Test 3: self-link skipped
+test('buildTeamLinks skips self-link when ownProfilePath matches', () => {
+  const input = '# Lawrence Aronhime\n\nLawrence Aronhime is a mentor.';
+  const out = wb.buildTeamLinks(input, profiles, {
+    ownProfilePath: '/room/team/mentors/lawrence-aronhime/PROFILE.md',
+  });
+  assert.strictEqual(out, input, 'content should be unchanged when processing own profile');
+});
+
+// Test 4: frontmatter skipped
+test('buildTeamLinks skips frontmatter region', () => {
+  const input =
+    '---\nauthor: Lawrence Aronhime\n---\nBody text by Lawrence Aronhime here.';
+  const out = wb.buildTeamLinks(input, profiles, {});
+  // Frontmatter author line unchanged
+  assert.ok(out.includes('author: Lawrence Aronhime'), 'frontmatter untouched');
+  // Body got linked
+  assert.ok(
+    out.includes('Body text by [[team/mentors/lawrence-aronhime/PROFILE.md|Lawrence Aronhime]] here.'),
+    'body should be linked'
+  );
+});
+
+// Test 5: idempotence
+test('buildTeamLinks is idempotent (running twice = same output)', () => {
+  const input = 'Lawrence Aronhime opened the meeting.';
+  const once = wb.buildTeamLinks(input, profiles, {});
+  const twice = wb.buildTeamLinks(once, profiles, {});
+  assert.strictEqual(once, twice, 'second pass should not change output');
+});
+
+// Test 6: buildSectionLink
+test('buildSectionLink returns exact format and honors display override', () => {
+  assert.strictEqual(
+    wb.buildSectionLink('business-model'),
+    '[[business-model/ROOM.md|business-model]]'
+  );
+  assert.strictEqual(
+    wb.buildSectionLink('business-model', { display: 'Business Model' }),
+    '[[business-model/ROOM.md|Business Model]]'
+  );
+});
+
+// Test 7: buildMeetingLink
+test('buildMeetingLink strips date prefix and title-cases', () => {
+  const out = wb.buildMeetingLink('2026-04-09-align-strategy-session');
+  assert.strictEqual(
+    out,
+    '[[meetings/2026-04-09-align-strategy-session/summary.md|Align Strategy Session]]'
+  );
+});
+
+// Test 8: buildFiledToFooter
+test('buildFiledToFooter returns both lines / one line appropriately', () => {
+  const both = wb.buildFiledToFooter({
+    targetPath: 'market-analysis/2026-04-09-tam.md',
+    meetingSlug: '2026-04-09-align-strategy-session',
+  });
+  assert.ok(both.includes('-> Full artifact: [[market-analysis/2026-04-09-tam.md]]'));
+  assert.ok(
+    both.includes('<- Source meeting: [[meetings/2026-04-09-align-strategy-session/summary.md|Align Strategy Session]]')
+  );
+  assert.strictEqual(both.split('\n').length, 2, 'should be 2 lines');
+
+  const one = wb.buildFiledToFooter({
+    targetPath: null,
+    meetingSlug: '2026-04-09-align-strategy-session',
+  });
+  assert.strictEqual(one.split('\n').length, 1, 'should be 1 line');
+  assert.ok(one.startsWith('<- Source meeting:'));
+});
+
+// Test 9: injectFiledToFooter idempotent + placement
+test('injectFiledToFooter inserts after frontmatter and is idempotent', () => {
+  const input = '---\nmeeting_id: 2026-04-09-align-strategy-session\n---\nBody.';
+  const once = wb.injectFiledToFooter(input, {
+    targetPath: 'market-analysis/2026-04-09-tam.md',
+    meetingSlug: '2026-04-09-align-strategy-session',
+  });
+  assert.ok(once.includes('-> Full artifact: [[market-analysis/2026-04-09-tam.md]]'));
+  assert.ok(once.includes('<- Source meeting: [[meetings/2026-04-09-align-strategy-session/summary.md|Align Strategy Session]]'));
+  // Lines sit after frontmatter close
+  const fmIdx = once.indexOf('\n---');
+  const arrowIdx = once.indexOf('-> Full artifact');
+  assert.ok(arrowIdx > fmIdx, 'footer should be after frontmatter close');
+
+  const twice = wb.injectFiledToFooter(once, {
+    targetPath: 'market-analysis/2026-04-09-tam.md',
+    meetingSlug: '2026-04-09-align-strategy-session',
+  });
+  assert.strictEqual(once, twice, 'second injection should be a no-op');
+});
+
+// Test 10: graceful zero-profile behavior
+test('buildTeamLinks with zero team profiles returns content unchanged', () => {
+  const input = 'Some body text mentioning Lawrence Aronhime.';
+  assert.strictEqual(wb.buildTeamLinks(input, [], {}), input);
+  assert.strictEqual(wb.buildTeamLinks(input, null, {}), input);
+});
+
+// ---------- Summary ----------
+process.stdout.write(`\n${passed} passed, ${failed} failed\n`);
+if (failed > 0) {
+  process.exit(1);
+}
+process.stdout.write('PASS\n');
+process.exit(0);

package/lib/wiki/graph-links.cjs

@@ -0,0 +1,281 @@
+'use strict';
+/**
+ * graph-links.cjs -- SQLite integration for the wiki
+ *
+ * Queries LazyGraph edges (SQLite via lazygraph-ops.cjs) and converts
+ * them into navigational hyperlinks, backlinks, "See also" sections,
+ * and full graph data for Cytoscape.js visualization.
+ *
+ * Exports: getPageLinks, getBacklinks, getSeeAlso, getGraphData
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+// Edge type display configuration
+// BELONGS_TO and REASONING_INFORMS are structural -- skip for navigation
+const EDGE_DISPLAY = {
+  INFORMS:      { symbol: '\u2192', color: '#1E3A6E', cssClass: 'link-informs',      label: 'Informs' },
+  CONTRADICTS:  { symbol: '\u2297', color: '#A63D2F', cssClass: 'link-contradicts',  label: 'Contradicts' },
+  CONVERGES:    { symbol: '\u2295', color: '#C8A43C', cssClass: 'link-converges',    label: 'Converges' },
+  ENABLES:      { symbol: '\u25B6', color: '#2D6B4A', cssClass: 'link-enables',      label: 'Enables' },
+  INVALIDATES:  { symbol: '\u2298', color: '#B5602A', cssClass: 'link-invalidates',  label: 'Invalidates' }
+};
+
+const NAV_EDGE_TYPES = Object.keys(EDGE_DISPLAY);
+
+/**
+ * Safely require lazygraph-ops. Returns null if not available.
+ */
+function getLazyGraphOps() {
+  try {
+    return require('../core/lazygraph-ops.cjs');
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Check if a LazyGraph SQLite database exists for the room.
+ * @param {string} roomDir
+ * @returns {boolean}
+ */
+function hasLazyGraph(roomDir) {
+  const dbPath = path.join(path.resolve(roomDir), '.mindrian', 'room.db');
+  return fs.existsSync(dbPath);
+}
+
+/**
+ * Get all outgoing navigational edges from an artifact.
+ *
+ * @param {string} roomDir - Path to room/ directory
+ * @param {string} artifactId - e.g. "problem-definition/market-trends"
+ * @returns {Promise<Array<{type, targetId, targetTitle, symbol, color, cssClass, label}>>}
+ */
+async function getPageLinks(roomDir, artifactId) {
+  if (!hasLazyGraph(roomDir)) return [];
+
+  const ops = getLazyGraphOps();
+  if (!ops) return [];
+
+  let db, conn;
+  try {
+    ({ db, conn } = await ops.openGraph(roomDir));
+
+    // SQLite query: outgoing edges from this artifact to other artifacts
+    const rows = await ops.queryGraph(conn,
+      `SELECT e.type AS rel, e.target AS target, json_extract(n.properties, '$.title') AS title
+       FROM edges e
+       JOIN nodes n ON n.id = e.target AND n.type = 'Artifact'
+       WHERE e.source = '${esc(artifactId)}'`
+    );
+
+    const links = [];
+    for (const row of rows) {
+      const edgeType = row.rel;
+      const display = EDGE_DISPLAY[edgeType];
+      if (!display) continue; // Skip BELONGS_TO, REASONING_INFORMS, etc.
+
+      links.push({
+        type: edgeType,
+        targetId: row.target,
+        targetTitle: row.title || row.target,
+        symbol: display.symbol,
+        color: display.color,
+        cssClass: display.cssClass,
+        label: display.label
+      });
+    }
+
+    return links;
+  } catch (e) {
+    process.stderr.write(`[wiki] graph-links getPageLinks error: ${e.message}\n`);
+    return [];
+  } finally {
+    if (db) try { await ops.closeGraph(db); } catch (_) { /* ignore */ }
+  }
+}
+
+/**
+ * Get all incoming edges TO an artifact (backlinks -- "What links here").
+ *
+ * @param {string} roomDir - Path to room/ directory
+ * @param {string} artifactId - e.g. "problem-definition/market-trends"
+ * @returns {Promise<Array<{type, sourceId, sourceTitle, symbol, color}>>}
+ */
+async function getBacklinks(roomDir, artifactId) {
+  if (!hasLazyGraph(roomDir)) return [];
+
+  const ops = getLazyGraphOps();
+  if (!ops) return [];
+
+  let db, conn;
+  try {
+    ({ db, conn } = await ops.openGraph(roomDir));
+
+    // SQLite query: incoming edges to this artifact from other artifacts
+    const rows = await ops.queryGraph(conn,
+      `SELECT e.type AS rel, e.source AS source, json_extract(n.properties, '$.title') AS title
+       FROM edges e
+       JOIN nodes n ON n.id = e.source AND n.type = 'Artifact'
+       WHERE e.target = '${esc(artifactId)}'`
+    );
+
+    const backlinks = [];
+    for (const row of rows) {
+      const edgeType = row.rel;
+      const display = EDGE_DISPLAY[edgeType];
+      if (!display) continue;
+
+      backlinks.push({
+        type: edgeType,
+        sourceId: row.source,
+        sourceTitle: row.title || row.source,
+        symbol: display.symbol,
+        color: display.color
+      });
+    }
+
+    return backlinks;
+  } catch (e) {
+    process.stderr.write(`[wiki] graph-links getBacklinks error: ${e.message}\n`);
+    return [];
+  } finally {
+    if (db) try { await ops.closeGraph(db); } catch (_) { /* ignore */ }
+  }
+}
+
+/**
+ * Get "See also" links -- CONVERGES and ENABLES edges grouped by theme.
+ *
+ * @param {string} roomDir - Path to room/ directory
+ * @param {string} artifactId - e.g. "problem-definition/market-trends"
+ * @returns {Promise<Array<{targetId, targetTitle, reason}>>}
+ */
+async function getSeeAlso(roomDir, artifactId) {
+  if (!hasLazyGraph(roomDir)) return [];
+
+  const ops = getLazyGraphOps();
+  if (!ops) return [];
+
+  let db, conn;
+  try {
+    ({ db, conn } = await ops.openGraph(roomDir));
+
+    // CONVERGES edges (with optional theme from properties.term)
+    const convergesRows = await ops.queryGraph(conn,
+      `SELECT e.target AS target, json_extract(n.properties, '$.title') AS title, json_extract(e.properties, '$.term') AS theme
+       FROM edges e
+       JOIN nodes n ON n.id = e.target AND n.type = 'Artifact'
+       WHERE e.source = '${esc(artifactId)}' AND e.type = 'CONVERGES'`
+    );
+
+    // ENABLES edges
+    const enablesRows = await ops.queryGraph(conn,
+      `SELECT e.target AS target, json_extract(n.properties, '$.title') AS title
+       FROM edges e
+       JOIN nodes n ON n.id = e.target AND n.type = 'Artifact'
+       WHERE e.source = '${esc(artifactId)}' AND e.type = 'ENABLES'`
+    );
+
+    const seeAlso = [];
+    const seen = new Set();
+
+    for (const row of convergesRows) {
+      if (seen.has(row.target)) continue;
+      seen.add(row.target);
+      seeAlso.push({
+        targetId: row.target,
+        targetTitle: row.title || row.target,
+        reason: row.theme ? `Converges on: ${row.theme}` : 'Converging topic'
+      });
+    }
+
+    for (const row of enablesRows) {
+      if (seen.has(row.target)) continue;
+      seen.add(row.target);
+      seeAlso.push({
+        targetId: row.target,
+        targetTitle: row.title || row.target,
+        reason: 'Enables'
+      });
+    }
+
+    return seeAlso;
+  } catch (e) {
+    process.stderr.write(`[wiki] graph-links getSeeAlso error: ${e.message}\n`);
+    return [];
+  } finally {
+    if (db) try { await ops.closeGraph(db); } catch (_) { /* ignore */ }
+  }
+}
+
+/**
+ * Get all artifacts and edges for Cytoscape.js graph visualization.
+ *
+ * @param {string} roomDir - Path to room/ directory
+ * @returns {Promise<{nodes: Array<{id, title, section}>, edges: Array<{source, target, type}>}>}
+ */
+async function getGraphData(roomDir) {
+  if (!hasLazyGraph(roomDir)) return { nodes: [], edges: [] };
+
+  const ops = getLazyGraphOps();
+  if (!ops) return { nodes: [], edges: [] };
+
+  let db, conn;
+  try {
+    ({ db, conn } = await ops.openGraph(roomDir));
+
+    // All artifact nodes
+    const nodeRows = await ops.queryGraph(conn,
+      `SELECT id, json_extract(properties, '$.title') AS title, json_extract(properties, '$.section') AS section
+       FROM nodes WHERE type = 'Artifact'`
+    );
+
+    const nodes = nodeRows.map(row => ({
+      id: row.id,
+      title: row.title || row.id,
+      section: row.section || ''
+    }));
+
+    // All navigational edges between artifacts (skip BELONGS_TO, REASONING_INFORMS)
+    const typePlaceholders = NAV_EDGE_TYPES.map(t => `'${t}'`).join(',');
+    const edgeRows = await ops.queryGraph(conn,
+      `SELECT e.source AS source, e.target AS target, e.type AS type
+       FROM edges e
+       JOIN nodes n1 ON n1.id = e.source AND n1.type = 'Artifact'
+       JOIN nodes n2 ON n2.id = e.target AND n2.type = 'Artifact'
+       WHERE e.type IN (${typePlaceholders})`
+    );
+
+    const edges = edgeRows.map(row => ({
+      source: row.source,
+      target: row.target,
+      type: row.type
+    }));
+
+    return { nodes, edges };
+  } catch (e) {
+    process.stderr.write(`[wiki] graph-links getGraphData error: ${e.message}\n`);
+    return { nodes: [], edges: [] };
+  } finally {
+    if (db) try { await ops.closeGraph(db); } catch (_) { /* ignore */ }
+  }
+}
+
+/**
+ * Escape single quotes for SQL string literals.
+ */
+function esc(str) {
+  if (!str) return '';
+  return str.replace(/'/g, "''");
+}
+
+module.exports = {
+  getPageLinks,
+  getBacklinks,
+  getSeeAlso,
+  getGraphData,
+  EDGE_DISPLAY,
+  NAV_EDGE_TYPES
+};

package/lib/wiki/page-renderer.cjs

@@ -0,0 +1,229 @@
+'use strict';
+/**
+ * page-renderer.cjs — Markdown rendering pipeline for the wiki
+ *
+ * Scans room/ directory for .md files, parses frontmatter,
+ * renders markdown with wikilinks, and generates TOC.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const markdownIt = require('markdown-it');
+const matter = require('gray-matter');
+
+// Directories to skip when scanning room/
+const SKIP_DIRS = new Set(['.lazygraph', '.reasoning', 'meetings', 'node_modules', '.git']);
+const SKIP_FILES = new Set(['STATE.md']);
+
+// Section color mapping (matches build-graph)
+const SECTION_COLORS = {
+  'problem-definition': '#A63D2F',
+  'market-analysis': '#C8A43C',
+  'solution-design': '#5C5A56',
+  'business-model': '#2D6B4A',
+  'competitive-analysis': '#B5602A',
+  'team-execution': '#1E3A6E',
+  'team': '#1E3A6E',
+  'legal-ip': '#6B4E8B',
+  'financial-model': '#2A6B5E',
+  'opportunity-bank': '#C8A43C',
+  'funding': '#2D6B4A',
+  'personas': '#6B4E8B'
+};
+
+/**
+ * Scan room/ directory recursively for .md files.
+ * Returns { pages: Map, sections: Map }
+ */
+function scanRoom(roomDir) {
+  const absRoom = path.resolve(roomDir);
+  const pages = new Map();   // id -> { path, section, title, frontmatter, content }
+  const sections = new Map(); // section-name -> { label, color, pages: [] }
+
+  if (!fs.existsSync(absRoom)) {
+    return { pages, sections };
+  }
+
+  const entries = fs.readdirSync(absRoom, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      // Top-level .md files (e.g., README.md at room root)
+      if (entry.name.endsWith('.md') && !SKIP_FILES.has(entry.name)) {
+        const filePath = path.join(absRoom, entry.name);
+        const page = parsePage(filePath, '_root', absRoom);
+        pages.set(page.id, page);
+      }
+      continue;
+    }
+
+    const sectionName = entry.name;
+    if (SKIP_DIRS.has(sectionName)) continue;
+
+    const sectionDir = path.join(absRoom, sectionName);
+    const label = sectionName
+      .split('-')
+      .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+      .join(' ');
+    const color = SECTION_COLORS[sectionName] || '#5C5A56';
+
+    const sectionPages = [];
+
+    // Read .md files in section directory (one level deep)
+    const sectionEntries = fs.readdirSync(sectionDir, { withFileTypes: true });
+    for (const se of sectionEntries) {
+      if (!se.isFile() || !se.name.endsWith('.md')) continue;
+      if (SKIP_FILES.has(se.name)) continue;
+
+      const filePath = path.join(sectionDir, se.name);
+      const page = parsePage(filePath, sectionName, absRoom);
+      pages.set(page.id, page);
+      sectionPages.push(page.id);
+    }
+
+    sections.set(sectionName, { label, color, pages: sectionPages });
+  }
+
+  return { pages, sections };
+}
+
+/**
+ * Parse a single .md file into a page object.
+ */
+function parsePage(filePath, section, roomDir) {
+  const raw = fs.readFileSync(filePath, 'utf8');
+  const { data: frontmatter, content } = matter(raw);
+  const basename = path.basename(filePath, '.md');
+  const id = section === '_root' ? basename : `${section}/${basename}`;
+  const title = frontmatter.title || basename
+    .split('-')
+    .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+
+  return { id, path: filePath, section, title, frontmatter, content };
+}
+
+/**
+ * Build lookup index for wikilink resolution.
+ * Maps lowercase title / id variants to wiki URLs.
+ */
+function buildPageIndex(pages) {
+  const index = new Map();
+  for (const [id, page] of pages) {
+    const url = `/wiki/${id}`;
+    index.set(id.toLowerCase(), url);
+    index.set(page.title.toLowerCase(), url);
+    // Also map just the basename
+    const base = id.includes('/') ? id.split('/').pop() : id;
+    if (!index.has(base.toLowerCase())) {
+      index.set(base.toLowerCase(), url);
+    }
+  }
+  return index;
+}
+
+/**
+ * Create configured markdown-it instance with wikilinks.
+ */
+function createMarkdownRenderer(pageIndex) {
+  const md = markdownIt({
+    html: true,
+    linkify: true,
+    typographer: true
+  });
+
+  // Wikilinks plugin — resolve [[page-name]] to wiki URLs
+  try {
+    const wikilinks = require('@ig3/markdown-it-wikilinks');
+    md.use(wikilinks({
+      baseURL: '/wiki/',
+      uriSuffix: '',
+      makeAllLinksAbsolute: true,
+      postProcessPageName: (pageName) => {
+        // Try exact lookup first
+        const lower = pageName.toLowerCase().replace(/\s+/g, '-');
+        if (pageIndex && pageIndex.has(lower)) {
+          // Return just the path part after /wiki/
+          return pageIndex.get(lower).replace('/wiki/', '');
+        }
+        return lower;
+      }
+    }));
+  } catch (e) {
+    // Wikilinks plugin not installed — render as plain text
+    // This is non-fatal; links just won't resolve
+  }
+
+  return md;
+}
+
+/**
+ * Render a page object to HTML with TOC and wikilink extraction.
+ * @param {object} pageData - Page object from scanRoom
+ * @param {Map} pageIndex - Wikilink resolution index
+ * @param {Set} [contradictsTargets] - Set of artifact IDs that have CONTRADICTS relationship from this page
+ * @returns {{html, toc, frontmatter, wikilinks}}
+ */
+function renderPage(pageData, pageIndex, contradictsTargets) {
+  const md = createMarkdownRenderer(pageIndex);
+  let html = md.render(pageData.content);
+
+  // Post-process: mark CONTRADICTS wikilinks with special class
+  if (contradictsTargets && contradictsTargets.size > 0) {
+    // Match rendered wikilinks (from markdown-it-wikilinks) and add contradicts class
+    html = html.replace(/<a href="\/wiki\/([^"]+)"([^>]*)class="wikilink"([^>]*)>/g, (match, href, before, after) => {
+      const normalizedHref = href.toLowerCase();
+      for (const target of contradictsTargets) {
+        // Check if the link resolves to a contradicts target (by section or full id)
+        if (normalizedHref === target.toLowerCase() ||
+            normalizedHref.startsWith(target.toLowerCase().split('/')[0])) {
+          return `<a href="/wiki/${href}"${before}class="wikilink wikilink-contradicts"${after}>`;
+        }
+      }
+      return match;
+    });
+  }
+
+  // Extract TOC from rendered HTML (h2/h3)
+  const toc = extractTOC(html);
+
+  // Extract wikilinks from source content
+  const wikilinks = [];
+  const wlRegex = /\[\[([^\]]+)\]\]/g;
+  let match;
+  while ((match = wlRegex.exec(pageData.content)) !== null) {
+    wikilinks.push(match[1]);
+  }
+
+  return {
+    html,
+    toc,
+    frontmatter: pageData.frontmatter,
+    wikilinks
+  };
+}
+
+/**
+ * Extract TOC entries from rendered HTML.
+ * Returns array of { level, text, id }.
+ */
+function extractTOC(html) {
+  const toc = [];
+  const headingRegex = /<h([23])[^>]*(?:id="([^"]*)")?[^>]*>(.*?)<\/h[23]>/gi;
+  let match;
+  while ((match = headingRegex.exec(html)) !== null) {
+    const level = parseInt(match[1], 10);
+    const text = match[3].replace(/<[^>]+>/g, '').trim();
+    const id = match[2] || text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '');
+    toc.push({ level, text, id });
+  }
+  return toc;
+}
+
+module.exports = {
+  scanRoom,
+  renderPage,
+  buildPageIndex,
+  extractTOC,
+  SECTION_COLORS
+};