chapterhouse 0.7.0 → 0.8.0

package/dist/wiki/consolidation.js

@@ -0,0 +1,641 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { dirname, join, basename } from "node:path";
+import { config } from "../config.js";
+import { recordActionItem } from "../memory/action-items.js";
+import { getScope } from "../memory/scopes.js";
+import { getChapterhouseHome, resolveWikiRelativePath } from "../paths.js";
+import { childLogger } from "../util/logger.js";
+import { deletePage, listPages, readPage, writePage } from "./fs.js";
+import { parseWikiFrontmatter, validateAndBackfillFrontmatter } from "./frontmatter.js";
+import { rebuildWikiIndex, upsertWikiPage, removeWikiPage } from "./index-manager.js";
+import { normalizeWikiPath } from "./path-utils.js";
+const log = childLogger("wiki.consolidation");
+const TRUTH_REWRITE_BUDGET = 18;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const STALE_SESSION_MS = 7 * ONE_DAY_MS;
+const DEFAULT_MODEL = "claude-haiku-4.5";
+export async function runConsolidation(db) {
+    return runConsolidationWithDeps(db, createDefaultDeps(db));
+}
+export async function runConsolidationWithDeps(db, partialDeps = {}) {
+    ensureConsolidationSchema(db);
+    const deps = { ...createDefaultDeps(db), ...partialDeps };
+    const runAt = deps.now();
+    const modifiedPaths = new Set();
+    const result = {
+        truthRewrites: 0,
+        fragmentsMerged: 0,
+        linksRepaired: 0,
+        pagesReindexed: 0,
+        sourcesArchived: 0,
+        staleSessionsNotified: 0,
+        llmCallsUsed: 0,
+    };
+    const rewriteCandidates = collectRewriteCandidates(db);
+    for (const candidate of rewriteCandidates) {
+        if (result.llmCallsUsed >= TRUTH_REWRITE_BUDGET) {
+            break;
+        }
+        const row = db.prepare(`SELECT title FROM wiki_pages WHERE path = ?`).get(candidate.path);
+        if (!row) {
+            continue;
+        }
+        const synthesized = await deps.synthesizeTruth({
+            pagePath: candidate.path,
+            pageTitle: row.title,
+            existingTruth: candidate.currentTruth,
+            pendingEntries: candidate.pendingEntries,
+        });
+        result.llmCallsUsed += 1;
+        applyTruthRewrite(db, candidate.path, candidate.content, synthesized, runAt.toISOString());
+        modifiedPaths.add(candidate.path);
+        result.truthRewrites += 1;
+    }
+    result.fragmentsMerged += mergeFragments(db, runAt.toISOString(), modifiedPaths);
+    result.linksRepaired += repairOrphanLinks(db);
+    result.sourcesArchived += archiveOrphanSources(db);
+    result.staleSessionsNotified += notifyStaleSessions(db, deps, runAt);
+    ensureConsolidationStateTable(db);
+    deps.rebuildIndex();
+    result.linksRepaired += repairOrphanLinks(db);
+    result.pagesReindexed = modifiedPaths.size;
+    db.prepare(`
+    INSERT INTO wiki_consolidation_state (id, last_run, pages_processed)
+    VALUES (1, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET last_run = excluded.last_run, pages_processed = excluded.pages_processed
+  `).run(runAt.toISOString(), modifiedPaths.size);
+    await deps.commitWikiChanges(runAt);
+    return result;
+}
+function createDefaultDeps(db) {
+    return {
+        now: () => new Date(),
+        synthesizeTruth: synthesizeTruthWithCopilot,
+        rebuildIndex: rebuildWikiIndex,
+        commitWikiChanges: async (runAt) => commitWikiChanges(runAt),
+        createActionItem: ({ title, detail, source }) => createStaleSessionActionItem(db, { title, detail, source }),
+    };
+}
+function ensureConsolidationSchema(db) {
+    const wikiSourceColumns = db.prepare(`PRAGMA table_info(wiki_sources)`).all();
+    if (!wikiSourceColumns.some((column) => column.name === "status")) {
+        db.exec(`ALTER TABLE wiki_sources ADD COLUMN status TEXT NOT NULL DEFAULT 'active'`);
+    }
+    if (!wikiSourceColumns.some((column) => column.name === "session_id")) {
+        db.exec(`ALTER TABLE wiki_sources ADD COLUMN session_id TEXT`);
+    }
+    if (!wikiSourceColumns.some((column) => column.name === "session_name")) {
+        db.exec(`ALTER TABLE wiki_sources ADD COLUMN session_name TEXT`);
+    }
+    ensureConsolidationStateTable(db);
+}
+function ensureConsolidationStateTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS wiki_consolidation_state (
+      id INTEGER PRIMARY KEY,
+      last_run TEXT,
+      pages_processed INTEGER NOT NULL DEFAULT 0
+    )
+  `);
+}
+function collectRewriteCandidates(db) {
+    const rows = db.prepare(`
+    SELECT p.path, p.title, p.summary, p.last_updated, p.pinned,
+      (SELECT COUNT(*) FROM wiki_links WHERE to_page = p.path) AS inbound_links
+    FROM wiki_pages p
+  `).all();
+    const candidates = [];
+    for (const row of rows) {
+        const content = readPage(row.path);
+        if (!content) {
+            continue;
+        }
+        const { parsed: frontmatter } = parseWikiFrontmatter(content);
+        const frontmatterPinned = frontmatter.metadata.pinned === true;
+        const pinned = row.pinned === 1 || frontmatterPinned;
+        db.prepare(`UPDATE wiki_pages SET pinned = ? WHERE path = ?`).run(pinned ? 1 : 0, row.path);
+        if (pinned) {
+            continue;
+        }
+        const timelineEntries = parseTimelineEntries(content);
+        if (timelineEntries.length === 0) {
+            continue;
+        }
+        const pendingEntries = timelineEntries.filter((entry) => !row.last_updated || entry.timestamp > row.last_updated);
+        if (pendingEntries.length === 0) {
+            continue;
+        }
+        candidates.push({
+            path: row.path,
+            inboundLinks: row.inbound_links,
+            pendingEntries,
+            mostRecentTimelineAt: pendingEntries[pendingEntries.length - 1].timestamp,
+            currentTruth: extractSummary(content),
+            content,
+        });
+    }
+    candidates.sort((left, right) => {
+        if (right.pendingEntries.length !== left.pendingEntries.length) {
+            return right.pendingEntries.length - left.pendingEntries.length;
+        }
+        if (right.mostRecentTimelineAt !== left.mostRecentTimelineAt) {
+            return right.mostRecentTimelineAt.localeCompare(left.mostRecentTimelineAt);
+        }
+        return right.inboundLinks - left.inboundLinks;
+    });
+    return candidates;
+}
+function applyTruthRewrite(db, pagePath, content, compiledTruth, lastUpdatedIso) {
+    const normalizedPath = normalizeWikiPath(pagePath);
+    const { parsed: frontmatter } = parseWikiFrontmatter(content);
+    const summary = summarizeCompiledTruth(compiledTruth) || frontmatter.summary || frontmatter.title || normalizedPath;
+    const rewrittenContent = replaceSummarySection(content, compiledTruth);
+    const withFrontmatter = updateFrontmatterFields(rewrittenContent, {
+        summary,
+        updated: lastUpdatedIso.slice(0, 10),
+        last_updated: lastUpdatedIso,
+    });
+    const { content: backfilled } = validateAndBackfillFrontmatter(normalizedPath, withFrontmatter);
+    writePage(normalizedPath, backfilled);
+    const parsedAfter = parseWikiFrontmatter(backfilled).parsed;
+    upsertWikiPage(normalizedPath, parsedAfter, summary);
+    db.prepare(`
+    UPDATE wiki_pages
+    SET compiled_truth_hash = ?, last_updated = ?, pinned = ?
+    WHERE path = ?
+  `).run(hashCompiledTruth(compiledTruth), lastUpdatedIso, frontmatter.metadata.pinned === true ? 1 : 0, normalizedPath);
+}
+function mergeFragments(db, updatedAt, modifiedPaths) {
+    const pages = db.prepare(`
+    SELECT p.path, p.last_updated,
+      (SELECT COUNT(*) FROM wiki_links WHERE to_page = p.path) AS inbound_links
+    FROM wiki_pages p
+    ORDER BY p.path ASC
+  `).all();
+    const active = new Map(pages.map((page) => [page.path, page]));
+    let merged = 0;
+    for (const page of pages) {
+        if (!active.has(page.path)) {
+            continue;
+        }
+        for (const candidate of pages) {
+            if (page.path === candidate.path || !active.has(candidate.path)) {
+                continue;
+            }
+            if (!arePotentialFragments(db, page.path, candidate.path)) {
+                continue;
+            }
+            const canonical = chooseCanonicalPage(active.get(page.path), active.get(candidate.path));
+            const fragment = canonical.path === page.path ? candidate : page;
+            mergePageIntoCanonical(db, canonical.path, fragment.path, updatedAt, modifiedPaths);
+            modifiedPaths.add(canonical.path);
+            active.delete(fragment.path);
+            merged += 1;
+        }
+    }
+    return merged;
+}
+function arePotentialFragments(db, leftPath, rightPath) {
+    const leftInfo = pathInfo(leftPath);
+    const rightInfo = pathInfo(rightPath);
+    if (!leftInfo || !rightInfo || leftInfo.category !== rightInfo.category) {
+        return false;
+    }
+    if (leftInfo.slug.startsWith(rightInfo.slug) || rightInfo.slug.startsWith(leftInfo.slug)) {
+        return true;
+    }
+    if (levenshtein(leftInfo.slug, rightInfo.slug) <= 2) {
+        return true;
+    }
+    const sharedTarget = db.prepare(`
+    SELECT 1
+    FROM wiki_links l1
+    JOIN wiki_links l2 ON l1.to_page = l2.to_page
+    WHERE l1.from_page = ? AND l2.from_page = ?
+    LIMIT 1
+  `).get(leftPath, rightPath);
+    return Boolean(sharedTarget);
+}
+function chooseCanonicalPage(left, right) {
+    const leftSlug = pathInfo(left.path)?.slug ?? left.path;
+    const rightSlug = pathInfo(right.path)?.slug ?? right.path;
+    if (leftSlug.length !== rightSlug.length) {
+        return leftSlug.length < rightSlug.length ? left : right;
+    }
+    if (leftSlug !== rightSlug) {
+        return leftSlug.localeCompare(rightSlug) <= 0 ? left : right;
+    }
+    if (left.inbound_links !== right.inbound_links) {
+        return left.inbound_links > right.inbound_links ? left : right;
+    }
+    if ((left.last_updated ?? "") !== (right.last_updated ?? "")) {
+        return (left.last_updated ?? "") > (right.last_updated ?? "") ? left : right;
+    }
+    return left.path.localeCompare(right.path) <= 0 ? left : right;
+}
+function mergePageIntoCanonical(db, canonicalPath, fragmentPath, updatedAt, modifiedPaths) {
+    const canonicalContent = readPage(canonicalPath);
+    const fragmentContent = readPage(fragmentPath);
+    if (!canonicalContent || !fragmentContent) {
+        return;
+    }
+    const fragmentTimeline = extractTimelineBody(fragmentContent).trim();
+    let mergedContent = canonicalContent;
+    if (fragmentTimeline) {
+        mergedContent = appendTimelineRaw(canonicalContent, fragmentTimeline);
+        mergedContent = updateFrontmatterFields(mergedContent, {
+            updated: updatedAt.slice(0, 10),
+            last_updated: updatedAt,
+        });
+        const { content: backfilled } = validateAndBackfillFrontmatter(canonicalPath, mergedContent);
+        writePage(canonicalPath, backfilled);
+        const parsed = parseWikiFrontmatter(backfilled).parsed;
+        const summary = parsed.summary ?? (summarizeCompiledTruth(extractSummary(backfilled)) || parsed.title || canonicalPath);
+        upsertWikiPage(canonicalPath, parsed, summary);
+        db.prepare(`UPDATE wiki_pages SET last_updated = ? WHERE path = ?`).run(updatedAt, canonicalPath);
+    }
+    rewritePageReferences(db, fragmentPath, canonicalPath, updatedAt, modifiedPaths);
+    repointLinks(db, canonicalPath, fragmentPath);
+    deletePage(fragmentPath);
+    removeWikiPage(fragmentPath);
+}
+function rewritePageReferences(db, fragmentPath, canonicalPath, updatedAt, modifiedPaths) {
+    const fragmentContent = readPage(fragmentPath) ?? "";
+    const canonicalContent = readPage(canonicalPath) ?? "";
+    const fragmentTitle = parseWikiFrontmatter(fragmentContent).parsed.title ?? humanizeSlug(pathInfo(fragmentPath)?.slug ?? fragmentPath);
+    const canonicalTitle = parseWikiFrontmatter(canonicalContent).parsed.title ?? humanizeSlug(pathInfo(canonicalPath)?.slug ?? canonicalPath);
+    const fragmentSlug = pathInfo(fragmentPath)?.slug;
+    const canonicalSlug = pathInfo(canonicalPath)?.slug;
+    for (const pagePath of listPages()) {
+        if (pagePath === fragmentPath || pagePath === canonicalPath) {
+            continue;
+        }
+        const content = readPage(pagePath);
+        if (!content) {
+            continue;
+        }
+        let nextContent = content.replaceAll(`[[${fragmentTitle}]]`, `[[${canonicalTitle}]]`);
+        if (fragmentSlug && canonicalSlug) {
+            nextContent = nextContent.replaceAll(`[[${fragmentSlug}]]`, `[[${canonicalSlug}]]`);
+        }
+        if (nextContent === content) {
+            continue;
+        }
+        nextContent = updateFrontmatterFields(nextContent, {
+            updated: updatedAt.slice(0, 10),
+            last_updated: updatedAt,
+        });
+        const { content: backfilled } = validateAndBackfillFrontmatter(pagePath, nextContent);
+        writePage(pagePath, backfilled);
+        const parsed = parseWikiFrontmatter(backfilled).parsed;
+        upsertWikiPage(pagePath, parsed, parsed.summary ?? canonicalTitle);
+        db.prepare(`UPDATE wiki_pages SET last_updated = ? WHERE path = ?`).run(updatedAt, pagePath);
+        modifiedPaths.add(pagePath);
+    }
+}
+function repointLinks(db, canonicalPath, fragmentPath) {
+    const rows = db.prepare(`
+    SELECT from_page, to_page, link_type, extracted_at
+    FROM wiki_links
+    WHERE from_page = ? OR to_page = ?
+  `).all(fragmentPath, fragmentPath);
+    const tx = db.transaction(() => {
+        db.prepare(`DELETE FROM wiki_links WHERE from_page = ? OR to_page = ?`).run(fragmentPath, fragmentPath);
+        const insert = db.prepare(`
+      INSERT OR IGNORE INTO wiki_links (from_page, to_page, link_type, extracted_at)
+      VALUES (?, ?, ?, ?)
+    `);
+        for (const row of rows) {
+            const nextFrom = row.from_page === fragmentPath ? canonicalPath : row.from_page;
+            const nextTo = row.to_page === fragmentPath ? canonicalPath : row.to_page;
+            if (nextFrom === nextTo) {
+                continue;
+            }
+            insert.run(nextFrom, nextTo, row.link_type, row.extracted_at);
+        }
+    });
+    tx();
+}
+function repairOrphanLinks(db) {
+    const orphans = db.prepare(`
+    SELECT l.from_page, l.to_page, l.link_type, l.extracted_at
+    FROM wiki_links l
+    LEFT JOIN wiki_pages p ON p.path = l.to_page
+    WHERE p.path IS NULL
+  `).all();
+    if (orphans.length === 0) {
+        return 0;
+    }
+    const remove = db.prepare(`DELETE FROM wiki_links WHERE from_page = ? AND to_page = ? AND link_type = ?`);
+    const insert = db.prepare(`
+    INSERT OR IGNORE INTO wiki_links (from_page, to_page, link_type, extracted_at)
+    VALUES (?, ?, ?, ?)
+  `);
+    let repaired = 0;
+    for (const orphan of orphans) {
+        const resolvedTarget = resolvePageBySlug(db, orphan.to_page);
+        remove.run(orphan.from_page, orphan.to_page, orphan.link_type);
+        if (resolvedTarget && resolvedTarget !== orphan.from_page) {
+            insert.run(orphan.from_page, resolvedTarget, orphan.link_type, orphan.extracted_at);
+            repaired += 1;
+            log.info({ orphan, resolved_target: resolvedTarget }, "wiki.consolidation.repointed_orphan_link");
+            continue;
+        }
+        repaired += 1;
+        log.info({ orphan }, "wiki.consolidation.removed_orphan_link");
+    }
+    return repaired;
+}
+function resolvePageBySlug(db, missingPath) {
+    const slug = pathInfo(missingPath)?.slug ?? normalizeWikiPath(missingPath).split("/").filter(Boolean).at(-2);
+    if (!slug) {
+        return undefined;
+    }
+    const matches = db.prepare(`SELECT path FROM wiki_pages WHERE path LIKE ? ORDER BY path ASC`).all(`pages/%/${slug}/index.md`);
+    return matches.length === 1 ? matches[0].path : undefined;
+}
+function archiveOrphanSources(db) {
+    const rows = db.prepare(`
+    SELECT id, title, origin, raw_path, pages_updated, status
+    FROM wiki_sources
+    WHERE COALESCE(status, 'active') != 'archived'
+  `).all();
+    let archived = 0;
+    for (const row of rows) {
+        if (isSourceReferenced(row.id, row.title, row.origin, row.pages_updated)) {
+            continue;
+        }
+        if (row.raw_path) {
+            moveSourceToArchive(row.raw_path);
+        }
+        db.prepare(`UPDATE wiki_sources SET status = 'archived' WHERE id = ?`).run(row.id);
+        archived += 1;
+    }
+    return archived;
+}
+function isSourceReferenced(id, title, origin, pagesUpdatedRaw) {
+    const paths = parseJsonArray(pagesUpdatedRaw);
+    if (paths.length === 0) {
+        return false;
+    }
+    for (const pagePath of paths) {
+        const content = readPage(pagePath);
+        if (!content) {
+            continue;
+        }
+        if (content.includes(id)) {
+            return true;
+        }
+        if (title && content.includes(`Source ingested: ${title}`)) {
+            return true;
+        }
+        if (origin && content.includes(origin)) {
+            return true;
+        }
+    }
+    return false;
+}
+function moveSourceToArchive(rawPath) {
+    const sourcePath = resolveWikiRelativePath(rawPath);
+    if (!existsSync(sourcePath)) {
+        return;
+    }
+    const archivePath = join(dirname(sourcePath), "archive", basename(sourcePath));
+    mkdirSync(dirname(archivePath), { recursive: true });
+    renameSync(sourcePath, archivePath);
+}
+function notifyStaleSessions(db, deps, runAt) {
+    const cutoff = new Date(runAt.getTime() - STALE_SESSION_MS).toISOString();
+    const rows = db.prepare(`
+    SELECT session_id, COALESCE(session_name, session_id) AS session_name, MAX(ingested_at) AS last_ingested_at
+    FROM wiki_sources
+    WHERE session_id IS NOT NULL AND TRIM(session_id) != ''
+    GROUP BY session_id, COALESCE(session_name, session_id)
+    HAVING MAX(ingested_at) < ?
+  `).all(cutoff);
+    let created = 0;
+    for (const row of rows) {
+        const title = `Research session '${row.session_name}' has been inactive for 7+ days — consider closing or continuing`;
+        const detail = `Latest source for session '${row.session_name}' arrived at ${row.last_ingested_at}.`;
+        if (deps.createActionItem({ title, detail, source: "wiki:consolidation" })) {
+            created += 1;
+        }
+    }
+    return created;
+}
+function createStaleSessionActionItem(db, input) {
+    const globalScope = getScope("global");
+    if (!globalScope) {
+        return false;
+    }
+    const existing = recordDuplicateActionItemCheck(db, globalScope.id, input.title);
+    if (existing) {
+        return false;
+    }
+    recordActionItem({
+        scope_id: globalScope.id,
+        title: input.title,
+        detail: input.detail,
+        source: input.source,
+        tier: "warm",
+    });
+    return true;
+}
+function recordDuplicateActionItemCheck(db, scopeId, title) {
+    const row = db.prepare(`
+    SELECT 1
+    FROM mem_action_items
+    WHERE scope_id = ? AND title = ? AND status IN ('open', 'snoozed')
+    LIMIT 1
+  `).get(scopeId, title);
+    return Boolean(row);
+}
+async function synthesizeTruthWithCopilot(input) {
+    const token = config.copilotAuthToken || process.env.COPILOT_TOKEN || process.env.GITHUB_TOKEN;
+    if (!token) {
+        throw new Error(`Cannot consolidate '${input.pagePath}' without a Copilot auth token.`);
+    }
+    const prompt = [
+        `Rewrite the compiled truth for the wiki page '${input.pageTitle}' (${input.pagePath}).`,
+        "Keep it factual and concise.",
+        "Return Markdown only for the ## Summary section body, without the heading.",
+        "Existing compiled truth:",
+        input.existingTruth || "(none)",
+        "New timeline entries:",
+        input.pendingEntries.map((entry) => `- ${entry.timestamp}: ${entry.content}`).join("\n"),
+    ].join("\n\n");
+    const { CopilotClient, approveAll } = await import("@github/copilot-sdk");
+    const client = new CopilotClient({
+        autoStart: true,
+        autoRestart: false,
+        gitHubToken: token,
+    });
+    await client.start();
+    try {
+        const session = await client.createSession({
+            model: DEFAULT_MODEL,
+            tools: [],
+            onPermissionRequest: approveAll,
+        });
+        try {
+            const response = await session.sendAndWait({ prompt }, 30_000);
+            return String(response).trim();
+        }
+        finally {
+            try {
+                session.destroy();
+            }
+            catch { /* best effort */ }
+        }
+    }
+    finally {
+        try {
+            await client.stop();
+        }
+        catch { /* best effort */ }
+    }
+}
+async function commitWikiChanges(runAt) {
+    const repoRoot = getChapterhouseHome();
+    try {
+        execFileSync("git", ["-C", repoRoot, "rev-parse", "--is-inside-work-tree"], { stdio: "ignore" });
+    }
+    catch {
+        log.debug({ repoRoot }, "wiki.consolidation.git_skip_not_repo");
+        return false;
+    }
+    const status = execFileSync("git", ["-C", repoRoot, "status", "--porcelain"], { encoding: "utf-8" }).trim();
+    if (!status) {
+        return false;
+    }
+    execFileSync("git", ["-C", repoRoot, "add", "-A"], { stdio: "ignore" });
+    execFileSync("git", ["-C", repoRoot, "commit", "-m", `pkb: nightly consolidation [${runAt.toISOString().slice(0, 10)}]`, "--no-verify"], {
+        stdio: "ignore",
+    });
+    return true;
+}
+function parseTimelineEntries(content) {
+    const body = extractSectionBody(content, "Timeline");
+    if (!body.trim()) {
+        return [];
+    }
+    const matches = [...body.matchAll(/^###\s+([^\n]+)\n\n([\s\S]*?)(?=\n###\s+|\n##\s+|$)/gm)];
+    return matches
+        .map((match) => ({
+        timestamp: match[1].trim(),
+        content: match[2].trim(),
+        raw: match[0].trim(),
+    }))
+        .filter((entry) => !Number.isNaN(Date.parse(entry.timestamp)));
+}
+function extractTimelineBody(content) {
+    return extractSectionBody(content, "Timeline");
+}
+function extractSummary(content) {
+    return extractSectionBody(content, "Summary").trim();
+}
+function replaceSummarySection(content, summaryBody) {
+    const replacement = `## Summary\n\n${summaryBody.trim()}\n`;
+    const range = findSectionRange(content, "Summary");
+    if (range) {
+        return `${content.slice(0, range.start)}${replacement}${content.slice(range.end)}`;
+    }
+    const timelineRange = findSectionRange(content, "Timeline");
+    if (timelineRange) {
+        return `${content.slice(0, timelineRange.start)}${replacement}\n${content.slice(timelineRange.start)}`;
+    }
+    return `${content.trimEnd()}\n\n${replacement}`;
+}
+function appendTimelineRaw(content, timelineBody) {
+    const existingTimeline = extractTimelineBody(content).trim();
+    const combined = [existingTimeline, timelineBody.trim()].filter(Boolean).join("\n\n");
+    const replacement = `## Timeline\n\n${combined}\n`;
+    const range = findSectionRange(content, "Timeline");
+    if (range) {
+        return `${content.slice(0, range.start)}${replacement}${content.slice(range.end)}`;
+    }
+    return `${content.trimEnd()}\n\n${replacement}`;
+}
+function extractSectionBody(content, heading) {
+    const range = findSectionRange(content, heading);
+    return range ? content.slice(range.bodyStart, range.end) : "";
+}
+function findSectionRange(content, heading) {
+    const token = `## ${heading}`;
+    const start = content.indexOf(token);
+    if (start === -1) {
+        return undefined;
+    }
+    const headingLineEnd = content.indexOf("\n", start);
+    const bodyStart = headingLineEnd === -1 ? content.length : headingLineEnd + 1;
+    const nextSection = content.indexOf("\n## ", bodyStart);
+    return {
+        start,
+        bodyStart,
+        end: nextSection === -1 ? content.length : nextSection,
+    };
+}
+function updateFrontmatterFields(content, fields) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?/);
+    if (!match) {
+        return content;
+    }
+    const lines = match[1].split("\n");
+    for (const [key, value] of Object.entries(fields)) {
+        const serialized = typeof value === "boolean" ? `${key}: ${value ? "true" : "false"}` : `${key}: ${value}`;
+        const index = lines.findIndex((line) => line.startsWith(`${key}:`));
+        if (index >= 0) {
+            lines[index] = serialized;
+        }
+        else {
+            lines.push(serialized);
+        }
+    }
+    return `---\n${lines.join("\n")}\n---\n${content.slice(match[0].length)}`;
+}
+function summarizeCompiledTruth(compiledTruth) {
+    const firstMeaningfulLine = compiledTruth
+        .split("\n")
+        .map((line) => line.trim().replace(/^[-*]\s+/, ""))
+        .find((line) => Boolean(line));
+    return (firstMeaningfulLine ?? "").slice(0, 200);
+}
+function hashCompiledTruth(compiledTruth) {
+    return createHash("sha256").update(compiledTruth.trim()).digest("hex");
+}
+function parseJsonArray(raw) {
+    try {
+        const parsed = JSON.parse(raw || "[]");
+        return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function humanizeSlug(value) {
+    return value.split(/[-_]+/).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+}
+function pathInfo(path) {
+    const match = normalizeWikiPath(path).match(/^pages\/([^/]+)\/([^/]+)\/index\.md$/);
+    if (!match) {
+        return undefined;
+    }
+    return { category: match[1], slug: match[2] };
+}
+function levenshtein(left, right) {
+    const dp = Array.from({ length: left.length + 1 }, () => Array(right.length + 1).fill(0));
+    for (let i = 0; i <= left.length; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= right.length; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= left.length; i++) {
+        for (let j = 1; j <= right.length; j++) {
+            const cost = left[i - 1] === right[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[left.length][right.length];
+}
+//# sourceMappingURL=consolidation.js.map