pi-para 0.5.2 → 0.6.0

package/dist/lint.js

@@ -1,827 +0,0 @@
-/**
- * Wiki health checks — validates wiki structure and content integrity.
- *
- * Checks for orphan pages, broken links, stale pages, scope drift,
- * archive candidates, missing pages, frontmatter issues, index drift,
- * empty categories, and duplicate slugs.
- *
- * When autoFix is true (default), fixable issues are repaired in-place:
- * broken links removed, index rebuilt for drift, missing frontmatter fields set.
- */
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { listPages, readPage, writePage, readIndex, writeIndex, PARA_CATEGORIES, } from "./wiki.js";
-import { extractWikilinks, removeWikilink, autoLinkSlugs, syncFrontmatterLinks, } from "./link-utils.js";
-import { normalizeTags, normalizeScopes } from "./tag-registry.js";
-import { containsSecrets, redactSecrets } from "./redact.js";
-import { CURRENT_SCHEMA_VERSION, migrateToLatest, parseFrontmatter, serializeFrontmatter, } from "./frontmatter.js";
-// -- Helpers ----------------------------------------------------------------
-function daysBetween(a, b) {
-    return Math.abs(b.getTime() - a.getTime()) / (1000 * 60 * 60 * 24);
-}
-function makeStats(pages, totalLinks, brokenLinks, orphanCount, logContent) {
-    const byCategory = {
-        projects: 0,
-        areas: 0,
-        resources: 0,
-        archives: 0,
-    };
-    let oldest = "";
-    let newest = "";
-    for (const p of pages) {
-        byCategory[p.category]++;
-        const created = p.frontmatter.created;
-        if (!oldest || created < oldest)
-            oldest = created;
-        if (!newest || created > newest)
-            newest = created;
-    }
-    // Find last ingest date from log
-    let lastIngest = "";
-    const ingestRe = /## \[(\d{4}-\d{2}-\d{2})\] ingest/g;
-    let match;
-    while ((match = ingestRe.exec(logContent)) !== null) {
-        if (!lastIngest || match[1] > lastIngest)
-            lastIngest = match[1];
-    }
-    return {
-        totalPages: pages.length,
-        byCategory,
-        totalLinks,
-        brokenLinks,
-        orphanPages: orphanCount,
-        oldestPage: oldest,
-        newestPage: newest,
-        lastIngest,
-    };
-}
-// -- Checks -----------------------------------------------------------------
-/** 1. Orphan pages: no inbound [[wikilinks]] from any other page */
-function checkOrphans(pages, allSlugs) {
-    // Build inbound link map
-    const inbound = new Set();
-    for (const p of pages) {
-        const bodyLinks = extractWikilinks(p.body);
-        const fmLinks = p.frontmatter.links;
-        for (const link of [...bodyLinks, ...fmLinks]) {
-            inbound.add(link);
-        }
-    }
-    const issues = [];
-    for (const p of pages) {
-        if (!inbound.has(p.slug)) {
-            issues.push({
-                severity: "info",
-                category: "orphan",
-                page: `${p.category}/${p.slug}`,
-                message: `Orphan page — no inbound [[wikilinks]] to "${p.frontmatter.title}"`,
-                autoFixable: false,
-            });
-        }
-    }
-    return issues;
-}
-/** 2. Broken links: [[wikilinks]] pointing to non-existent pages */
-function checkBrokenLinks(pages, allSlugs) {
-    const issues = [];
-    for (const p of pages) {
-        const bodyLinks = extractWikilinks(p.body);
-        const fmLinks = p.frontmatter.links;
-        const allLinks = new Set([...bodyLinks, ...fmLinks]);
-        for (const link of allLinks) {
-            if (!allSlugs.has(link)) {
-                issues.push({
-                    severity: "error",
-                    category: "broken-link",
-                    page: `${p.category}/${p.slug}`,
-                    message: `Broken link [[${link}]] — target page does not exist`,
-                    autoFixable: true,
-                });
-            }
-        }
-    }
-    return issues;
-}
-/** 3. Stale pages: not updated in > staleDays */
-function checkStale(pages, staleDays, now) {
-    const issues = [];
-    for (const p of pages) {
-        if (p.category === "archives")
-            continue; // archives are expected to be stale
-        const updated = new Date(p.frontmatter.updated);
-        if (daysBetween(updated, now) > staleDays) {
-            issues.push({
-                severity: "warning",
-                category: "stale",
-                page: `${p.category}/${p.slug}`,
-                message: `Stale page — not updated in >${staleDays} days (last: ${p.frontmatter.updated})`,
-                autoFixable: false,
-            });
-        }
-    }
-    return issues;
-}
-/** 4. Scope drift: projects/ pages where scope doesn't include the slug */
-function checkScopeDrift(pages) {
-    const issues = [];
-    for (const p of pages) {
-        if (p.category !== "projects")
-            continue;
-        if (!p.frontmatter.scope.includes(p.slug)) {
-            issues.push({
-                severity: "warning",
-                category: "scope-drift",
-                page: `${p.category}/${p.slug}`,
-                message: `Scope drift — projects/ page scope [${p.frontmatter.scope.join(", ")}] does not include its own slug "${p.slug}"`,
-                autoFixable: true,
-            });
-        }
-    }
-    return issues;
-}
-/** 5. Archive candidates: project pages with no recent log entries */
-function checkArchiveCandidates(pages, logContent, staleDays, now) {
-    const issues = [];
-    for (const p of pages) {
-        if (p.category !== "projects")
-            continue;
-        // Check if the page or its slug appears in any recent log entry
-        const logEntryRe = /## \[(\d{4}-\d{2}-\d{2})\] \w+ \|[^\n]*/g;
-        let hasRecentEntry = false;
-        let m;
-        while ((m = logEntryRe.exec(logContent)) !== null) {
-            const entryDate = new Date(m[0].match(/\d{4}-\d{2}-\d{2}/)[0]);
-            const entryText = m[0];
-            if (daysBetween(entryDate, now) <= staleDays &&
-                (entryText.includes(p.slug) || entryText.includes(p.frontmatter.title))) {
-                hasRecentEntry = true;
-                break;
-            }
-        }
-        // Also check lines below each entry header for page references
-        if (!hasRecentEntry) {
-            const updated = new Date(p.frontmatter.updated);
-            if (daysBetween(updated, now) > staleDays) {
-                issues.push({
-                    severity: "info",
-                    category: "archive-candidate",
-                    page: `${p.category}/${p.slug}`,
-                    message: `Archive candidate — project has no recent log entries and hasn't been updated in >${staleDays} days`,
-                    autoFixable: false,
-                });
-            }
-        }
-    }
-    return issues;
-}
-/** 6. Missing pages: slugs referenced in 2+ pages but lacking own page */
-function checkMissing(pages, allSlugs) {
-    // Count how many distinct pages reference each non-existent slug
-    const refCounts = new Map();
-    for (const p of pages) {
-        const bodyLinks = extractWikilinks(p.body);
-        const fmLinks = p.frontmatter.links;
-        const allLinks = new Set([...bodyLinks, ...fmLinks]);
-        for (const link of allLinks) {
-            if (!allSlugs.has(link)) {
-                if (!refCounts.has(link))
-                    refCounts.set(link, new Set());
-                refCounts.get(link).add(p.slug);
-            }
-        }
-    }
-    const issues = [];
-    for (const [slug, refs] of refCounts) {
-        if (refs.size >= 2) {
-            issues.push({
-                severity: "info",
-                category: "missing-page",
-                message: `Missing page "[[${slug}]]" — referenced by ${refs.size} pages: ${[...refs].join(", ")}`,
-                autoFixable: false,
-            });
-        }
-    }
-    return issues;
-}
-/** 7. Empty categories: PARA categories with zero pages */
-function checkEmptyCategories(pages) {
-    const counts = {
-        projects: 0,
-        areas: 0,
-        resources: 0,
-        archives: 0,
-    };
-    for (const p of pages) {
-        counts[p.category]++;
-    }
-    const issues = [];
-    for (const cat of PARA_CATEGORIES) {
-        if (cat === "archives")
-            continue; // archives being empty is fine
-        if (counts[cat] === 0) {
-            issues.push({
-                severity: "info",
-                category: "empty-category",
-                message: `Empty category "${cat}" — no pages`,
-                autoFixable: false,
-            });
-        }
-    }
-    return issues;
-}
-/** 8. Frontmatter issues: missing required fields, empty scope */
-function checkFrontmatter(pages) {
-    const issues = [];
-    for (const p of pages) {
-        const fm = p.frontmatter;
-        if (!fm.title || fm.title === "Untitled") {
-            issues.push({
-                severity: "error",
-                category: "frontmatter",
-                page: `${p.category}/${p.slug}`,
-                message: `Missing or default title`,
-                autoFixable: true,
-            });
-        }
-        if (fm.scope.length === 0) {
-            issues.push({
-                severity: "warning",
-                category: "frontmatter",
-                page: `${p.category}/${p.slug}`,
-                message: `Empty scope — page has no scope tags`,
-                autoFixable: true,
-            });
-        }
-        if (!fm.created) {
-            issues.push({
-                severity: "error",
-                category: "frontmatter",
-                page: `${p.category}/${p.slug}`,
-                message: `Missing created date`,
-                autoFixable: true,
-            });
-        }
-        if (!fm.updated) {
-            issues.push({
-                severity: "error",
-                category: "frontmatter",
-                page: `${p.category}/${p.slug}`,
-                message: `Missing updated date`,
-                autoFixable: true,
-            });
-        }
-    }
-    return issues;
-}
-/** 9. Index drift: pages on disk but not referenced in index.md */
-function checkIndexDrift(pages, indexContent) {
-    const issues = [];
-    for (const p of pages) {
-        // Check if slug appears as [[slug]] in the index
-        if (!indexContent.includes(`[[${p.slug}]]`)) {
-            issues.push({
-                severity: "warning",
-                category: "index-drift",
-                page: `${p.category}/${p.slug}`,
-                message: `Page not listed in index.md`,
-                autoFixable: true,
-            });
-        }
-    }
-    return issues;
-}
-/** 10. Duplicate slugs: same slug in different categories */
-function checkDuplicateSlugs(pages) {
-    const slugMap = new Map();
-    for (const p of pages) {
-        const existing = slugMap.get(p.slug) ?? [];
-        existing.push(p.category);
-        slugMap.set(p.slug, existing);
-    }
-    const issues = [];
-    for (const [slug, categories] of slugMap) {
-        if (categories.length > 1) {
-            issues.push({
-                severity: "warning",
-                category: "duplicate-slug",
-                message: `Duplicate slug "${slug}" exists in: ${categories.join(", ")}`,
-                autoFixable: false,
-            });
-        }
-    }
-    return issues;
-}
-/** 11. Link sync: slug mentions in body not wrapped in [[wikilinks]] */
-function checkLinkSync(pages, allSlugs) {
-    const issues = [];
-    for (const p of pages) {
-        // Find slugs mentioned in body but not wrapped in [[...]]
-        const bodyLinks = new Set(extractWikilinks(p.body));
-        const sortedSlugs = [...allSlugs]
-            .filter(s => s !== p.slug)
-            .sort((a, b) => b.length - a.length);
-        const unlinked = [];
-        for (const slug of sortedSlugs) {
-            if (bodyLinks.has(slug))
-                continue;
-            // Check if slug appears as plain text in body (word-boundary match)
-            const escaped = slug.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const re = new RegExp(`(?<![a-z0-9-])${escaped}(?![a-z0-9-])`);
-            if (re.test(p.body)) {
-                unlinked.push(slug);
-            }
-        }
-        if (unlinked.length > 0) {
-            issues.push({
-                severity: "warning",
-                category: "link-sync",
-                page: `${p.category}/${p.slug}`,
-                message: `${unlinked.length} unlinked slug mention(s): ${unlinked.join(", ")}`,
-                autoFixable: true,
-            });
-        }
-        // Check frontmatter.links out of sync with body
-        const expectedLinks = syncFrontmatterLinks(p.body);
-        const fmSet = new Set(p.frontmatter.links);
-        const expectedSet = new Set(expectedLinks);
-        const missingInFm = expectedLinks.filter(l => !fmSet.has(l));
-        const extraInFm = p.frontmatter.links.filter(l => !expectedSet.has(l));
-        if (missingInFm.length > 0 || extraInFm.length > 0) {
-            issues.push({
-                severity: "warning",
-                category: "link-sync",
-                page: `${p.category}/${p.slug}`,
-                message: `frontmatter.links out of sync with body [[wikilinks]]`,
-                autoFixable: true,
-            });
-        }
-    }
-    return issues;
-}
-/** 12. Tag health: spaces, scope duplicates, non-canonical tags */
-function checkTagHealth(pages) {
-    const issues = [];
-    for (const p of pages) {
-        const tags = p.frontmatter.tags;
-        const scope = p.frontmatter.scope;
-        const scopeSet = new Set(scope.map(s => s.toLowerCase()));
-        // Check for tags with spaces
-        const spaceTags = tags.filter(t => t.includes(" "));
-        if (spaceTags.length > 0) {
-            issues.push({
-                severity: "warning",
-                category: "tag-health",
-                page: `${p.category}/${p.slug}`,
-                message: `Tags with spaces: ${spaceTags.map(t => `"${t}"`).join(", ")}`,
-                autoFixable: true,
-            });
-        }
-        // Check for tags duplicating scope
-        const scopeDupes = tags.filter(t => scopeSet.has(t.toLowerCase()));
-        if (scopeDupes.length > 0) {
-            issues.push({
-                severity: "info",
-                category: "tag-health",
-                page: `${p.category}/${p.slug}`,
-                message: `Tags duplicating scope: ${scopeDupes.join(", ")}`,
-                autoFixable: true,
-            });
-        }
-        // Check if normalization would change the tag list
-        const normalized = normalizeTags(tags, scope);
-        const currentSorted = [...tags].sort();
-        if (JSON.stringify(normalized) !== JSON.stringify(currentSorted)) {
-            // Only report if not already covered by the above checks
-            const aliasChanges = tags.filter(t => {
-                const n = t.trim().toLowerCase().replace(/\s+/g, "-");
-                return normalized.includes(n) === false && !scopeSet.has(n) && !t.includes(" ");
-            });
-            if (aliasChanges.length > 0) {
-                issues.push({
-                    severity: "info",
-                    category: "tag-health",
-                    page: `${p.category}/${p.slug}`,
-                    message: `Tags to canonicalize: ${aliasChanges.join(", ")}`,
-                    autoFixable: true,
-                });
-            }
-        }
-    }
-    return issues;
-}
-/** 13. Secrets: detect API keys, tokens, passwords in page content */
-function checkSecrets(pages) {
-    const issues = [];
-    for (const p of pages) {
-        if (containsSecrets(p.body)) {
-            issues.push({
-                severity: "error",
-                category: "secrets",
-                page: `${p.category}/${p.slug}`,
-                message: `Page contains potential secrets (API keys, tokens, passwords)`,
-                autoFixable: true,
-            });
-        }
-    }
-    return issues;
-}
-/** 15. Schema version: pages below CURRENT_SCHEMA_VERSION need migration */
-function checkSchemaVersion(pages) {
-    const issues = [];
-    for (const p of pages) {
-        const version = p.frontmatter.schemaVersion ?? 1;
-        if (version < CURRENT_SCHEMA_VERSION) {
-            issues.push({
-                severity: "warning",
-                category: "schema-version",
-                page: `${p.category}/${p.slug}`,
-                message: `Schema version ${version} is below current (${CURRENT_SCHEMA_VERSION}) — needs migration`,
-                autoFixable: true,
-            });
-        }
-    }
-    return issues;
-}
-/** 14. PARA category misuse: reference docs in projects/ instead of resources/ */
-function checkCategoryMisuse(pages) {
-    const issues = [];
-    // projects/ should have goal-defined work with end dates, not reference docs.
-    // Heuristic: if a projects/ page's slug contains a scope project name as prefix
-    // (e.g. "pi-para-daemon" in scope "pi-para"), it's likely a sub-topic reference
-    // doc, not a standalone project.
-    for (const p of pages) {
-        if (p.category !== "projects")
-            continue;
-        // Check if the slug is a sub-topic of a scope value
-        // e.g. slug "pi-para-daemon" with scope ["pi-para"] → sub-topic
-        const isSubtopic = p.frontmatter.scope.some((s) => s !== p.slug && s !== "global" && p.slug.startsWith(s + "-"));
-        if (isSubtopic) {
-            issues.push({
-                severity: "warning",
-                category: "category-misuse",
-                page: `${p.category}/${p.slug}`,
-                message: `Likely a reference doc, not a project — slug "${p.slug}" is a sub-topic of scope [${p.frontmatter.scope.join(", ")}]. Consider moving to resources/.`,
-                autoFixable: false,
-            });
-        }
-    }
-    return issues;
-}
-// -- Auto-fix ---------------------------------------------------------------
-/** Fix secrets: redact API keys, tokens, passwords from page content */
-async function fixSecrets(wikiDir, pages) {
-    const fixed = [];
-    for (const p of pages) {
-        if (!containsSecrets(p.body))
-            continue;
-        const { text: redacted, redactions } = redactSecrets(p.body);
-        if (redactions > 0) {
-            const fixedPage = {
-                ...p,
-                body: redacted,
-                frontmatter: {
-                    ...p.frontmatter,
-                    updated: new Date().toISOString(),
-                },
-            };
-            await writePage(wikiDir, fixedPage);
-            fixed.push({
-                severity: "error",
-                category: "secrets",
-                page: `${p.category}/${p.slug}`,
-                message: `Fixed: redacted ${redactions} secret(s)`,
-                autoFixable: true,
-            });
-        }
-    }
-    return fixed;
-}
-/** Fix link sync: auto-link slug mentions and sync frontmatter.links */
-async function fixLinkSync(wikiDir, pages, allSlugs) {
-    const fixed = [];
-    for (const p of pages) {
-        const originalBody = p.body;
-        const originalLinks = [...p.frontmatter.links];
-        // Auto-link slug mentions
-        const newBody = autoLinkSlugs(p.body, allSlugs, p.slug);
-        // Sync frontmatter.links
-        const newLinks = syncFrontmatterLinks(newBody);
-        // Check if anything changed
-        const bodyChanged = newBody !== originalBody;
-        const linksChanged = JSON.stringify(newLinks.sort()) !== JSON.stringify(originalLinks.sort());
-        if (bodyChanged || linksChanged) {
-            const addedLinks = newLinks.filter(l => !originalLinks.includes(l));
-            const fixedPage = {
-                ...p,
-                body: newBody,
-                frontmatter: {
-                    ...p.frontmatter,
-                    links: newLinks,
-                    updated: new Date().toISOString(),
-                },
-            };
-            await writePage(wikiDir, fixedPage);
-            if (addedLinks.length > 0) {
-                fixed.push({
-                    severity: "warning",
-                    category: "link-sync",
-                    page: `${p.category}/${p.slug}`,
-                    message: `Fixed: auto-linked ${addedLinks.length} slug(s): ${addedLinks.join(", ")}`,
-                    autoFixable: true,
-                });
-            }
-            if (linksChanged && addedLinks.length === 0) {
-                fixed.push({
-                    severity: "warning",
-                    category: "link-sync",
-                    page: `${p.category}/${p.slug}`,
-                    message: `Fixed: synced frontmatter.links with body [[wikilinks]]`,
-                    autoFixable: true,
-                });
-            }
-        }
-    }
-    return fixed;
-}
-/** Fix tag health: normalize all tags via registry */
-async function fixTagHealth(wikiDir, pages) {
-    const fixed = [];
-    for (const p of pages) {
-        const original = [...p.frontmatter.tags];
-        const normalized = normalizeTags(p.frontmatter.tags, p.frontmatter.scope);
-        if (JSON.stringify(original.sort()) !== JSON.stringify(normalized)) {
-            const removed = original.filter(t => !normalized.includes(t.trim().toLowerCase().replace(/\s+/g, "-")));
-            p.frontmatter.tags = normalized;
-            p.frontmatter.updated = new Date().toISOString();
-            await writePage(wikiDir, p);
-            fixed.push({
-                severity: "warning",
-                category: "tag-health",
-                page: `${p.category}/${p.slug}`,
-                message: `Fixed: normalized tags [${original.join(", ")}] → [${normalized.join(", ")}]`,
-                autoFixable: true,
-            });
-        }
-    }
-    return fixed;
-}
-/** Fix broken links: remove [[broken]] from body and frontmatter.links */
-async function fixBrokenLinks(wikiDir, pages, allSlugs) {
-    const fixed = [];
-    for (const p of pages) {
-        const bodyLinks = extractWikilinks(p.body);
-        const fmLinks = p.frontmatter.links;
-        const allLinks = new Set([...bodyLinks, ...fmLinks]);
-        const broken = [...allLinks].filter((l) => !allSlugs.has(l));
-        if (broken.length === 0)
-            continue;
-        let newBody = p.body;
-        for (const link of broken) {
-            newBody = removeWikilink(newBody, link);
-        }
-        const newFmLinks = fmLinks.filter((l) => allSlugs.has(l));
-        const fixedPage = {
-            ...p,
-            body: newBody,
-            frontmatter: { ...p.frontmatter, links: newFmLinks },
-        };
-        await writePage(wikiDir, fixedPage);
-        for (const link of broken) {
-            fixed.push({
-                severity: "error",
-                category: "broken-link",
-                page: `${p.category}/${p.slug}`,
-                message: `Fixed: removed broken link [[${link}]]`,
-                autoFixable: true,
-            });
-        }
-    }
-    return fixed;
-}
-/** Fix index drift: rebuild index.md to include all pages */
-async function fixIndexDrift(wikiDir, pages, indexContent) {
-    const missing = [];
-    for (const p of pages) {
-        if (!indexContent.includes(`[[${p.slug}]]`)) {
-            missing.push(p);
-        }
-    }
-    if (missing.length === 0)
-        return [];
-    // Group missing pages by category
-    const byCategory = new Map();
-    for (const p of missing) {
-        const list = byCategory.get(p.category) ?? [];
-        list.push(p);
-        byCategory.set(p.category, list);
-    }
-    // Append missing entries to each category section in the index
-    let newIndex = indexContent;
-    for (const cat of PARA_CATEGORIES) {
-        const catPages = byCategory.get(cat);
-        if (!catPages || catPages.length === 0)
-            continue;
-        // Find the category section header
-        const headerRe = new RegExp(`(## ${cat.charAt(0).toUpperCase() + cat.slice(1)}[^\n]*\n)`, "i");
-        const headerMatch = newIndex.match(headerRe);
-        if (headerMatch && headerMatch.index !== undefined) {
-            const insertPos = headerMatch.index + headerMatch[0].length;
-            const lines = catPages
-                .map((p) => `- [[${p.slug}]] — ${p.frontmatter.title}\n`)
-                .join("");
-            newIndex =
-                newIndex.slice(0, insertPos) + lines + newIndex.slice(insertPos);
-        }
-    }
-    // Remove placeholder lines like "_No active projects yet._"
-    newIndex = newIndex.replace(/\n_No [^_]*yet\._\n?/g, "\n");
-    await writeIndex(wikiDir, newIndex);
-    return missing.map((p) => ({
-        severity: "warning",
-        category: "index-drift",
-        page: `${p.category}/${p.slug}`,
-        message: `Fixed: added [[${p.slug}]] to index.md`,
-        autoFixable: true,
-    }));
-}
-/** Fix frontmatter issues: set missing fields to defaults */
-async function fixFrontmatter(wikiDir, pages) {
-    const fixed = [];
-    for (const p of pages) {
-        const fm = p.frontmatter;
-        let changed = false;
-        if (!fm.title || fm.title === "Untitled") {
-            // Derive title from slug
-            fm.title = p.slug
-                .split("-")
-                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-                .join(" ");
-            changed = true;
-            fixed.push({
-                severity: "error",
-                category: "frontmatter",
-                page: `${p.category}/${p.slug}`,
-                message: `Fixed: set title to "${fm.title}"`,
-                autoFixable: true,
-            });
-        }
-        if (fm.scope.length === 0) {
-            // Default scope based on category
-            if (p.category === "areas") {
-                fm.scope = ["global"];
-            }
-            else if (p.category === "projects") {
-                fm.scope = [p.slug];
-            }
-            else {
-                fm.scope = ["global"];
-            }
-            changed = true;
-            fixed.push({
-                severity: "warning",
-                category: "frontmatter",
-                page: `${p.category}/${p.slug}`,
-                message: `Fixed: set scope to [${fm.scope.join(", ")}]`,
-                autoFixable: true,
-            });
-        }
-        if (changed) {
-            fm.updated = new Date().toISOString();
-            await writePage(wikiDir, { ...p, frontmatter: fm });
-        }
-    }
-    return fixed;
-}
-/** Fix schema version: run migrations on pages below current version */
-async function fixSchemaVersion(wikiDir, pages) {
-    const fixed = [];
-    for (const p of pages) {
-        const version = p.frontmatter.schemaVersion ?? 1;
-        if (version >= CURRENT_SCHEMA_VERSION)
-            continue;
-        // Read the raw file to get the original frontmatter as a plain object
-        const filePath = join(wikiDir, p.category, `${p.slug}.md`);
-        const content = await readFile(filePath, "utf-8");
-        const { frontmatter: rawFm, body: rawBody } = parseFrontmatter(content);
-        const rawObj = rawFm;
-        const result = migrateToLatest(rawObj, rawBody);
-        // Write back with migrated content
-        const migratedFm = result.fm;
-        migratedFm.updated = new Date().toISOString();
-        await writePage(wikiDir, {
-            category: p.category,
-            slug: p.slug,
-            frontmatter: migratedFm,
-            body: result.body,
-        });
-        fixed.push({
-            severity: "warning",
-            category: "schema-version",
-            page: `${p.category}/${p.slug}`,
-            message: `Fixed: migrated schema version ${version} → ${migratedFm.schemaVersion}`,
-            autoFixable: true,
-        });
-    }
-    return fixed;
-}
-/** Fix scope drift: add slug to projects/ page scope */
-async function fixScopeDrift(wikiDir, pages) {
-    const fixed = [];
-    for (const p of pages) {
-        if (p.category !== "projects")
-            continue;
-        if (p.frontmatter.scope.includes(p.slug))
-            continue;
-        p.frontmatter.scope.push(p.slug);
-        p.frontmatter.updated = new Date().toISOString();
-        await writePage(wikiDir, p);
-        fixed.push({
-            severity: "warning",
-            category: "scope-drift",
-            page: `${p.category}/${p.slug}`,
-            message: `Fixed: added "${p.slug}" to scope`,
-            autoFixable: true,
-        });
-    }
-    return fixed;
-}
-// -- Main -------------------------------------------------------------------
-export async function lintWiki(wikiDir, options) {
-    const staleDays = options?.staleDays ?? 90;
-    const autoFix = options?.autoFix ?? true;
-    const now = new Date();
-    // Load all pages
-    const refs = await listPages(wikiDir);
-    const pages = [];
-    for (const ref of refs) {
-        const page = await readPage(wikiDir, ref.category, ref.slug);
-        if (page)
-            pages.push(page);
-    }
-    // Build slug set
-    const allSlugs = new Set(pages.map((p) => p.slug));
-    // Load index and log
-    const indexContent = await readIndex(wikiDir);
-    let logContent = "";
-    try {
-        logContent = await readFile(join(wikiDir, "log.md"), "utf-8");
-    }
-    catch {
-        // log.md may not exist
-    }
-    // Count total outgoing links
-    let totalLinks = 0;
-    for (const p of pages) {
-        totalLinks += extractWikilinks(p.body).length;
-        totalLinks += p.frontmatter.links.length;
-    }
-    // Run all checks
-    const issues = [
-        ...checkOrphans(pages, allSlugs),
-        ...checkBrokenLinks(pages, allSlugs),
-        ...checkStale(pages, staleDays, now),
-        ...checkScopeDrift(pages),
-        ...checkArchiveCandidates(pages, logContent, staleDays, now),
-        ...checkMissing(pages, allSlugs),
-        ...checkEmptyCategories(pages),
-        ...checkFrontmatter(pages),
-        ...checkIndexDrift(pages, indexContent),
-        ...checkDuplicateSlugs(pages),
-        ...checkLinkSync(pages, allSlugs),
-        ...checkTagHealth(pages),
-        ...checkCategoryMisuse(pages),
-        ...checkSecrets(pages),
-        ...checkSchemaVersion(pages),
-    ];
-    // Auto-fix if enabled
-    const fixed = [];
-    if (autoFix) {
-        // Fix secrets first — highest priority
-        fixed.push(...(await fixSecrets(wikiDir, pages)));
-        fixed.push(...(await fixBrokenLinks(wikiDir, pages, allSlugs)));
-        fixed.push(...(await fixLinkSync(wikiDir, pages, allSlugs)));
-        fixed.push(...(await fixTagHealth(wikiDir, pages)));
-        fixed.push(...(await fixIndexDrift(wikiDir, pages, indexContent)));
-        fixed.push(...(await fixFrontmatter(wikiDir, pages)));
-        fixed.push(...(await fixScopeDrift(wikiDir, pages)));
-        fixed.push(...(await fixSchemaVersion(wikiDir, pages)));
-    }
-    // Recount broken links for stats
-    const brokenLinkCount = issues.filter((i) => i.category === "broken-link").length;
-    const orphanCount = issues.filter((i) => i.category === "orphan").length;
-    const stats = makeStats(pages, totalLinks, brokenLinkCount, orphanCount, logContent);
-    // Remove auto-fixed issues from the reported issues list
-    const fixedKeys = new Set(fixed.map((f) => `${f.category}:${f.page ?? ""}:${f.message}`));
-    // Filter: keep issues that weren't fixed, or that aren't fixable
-    const remainingIssues = autoFix
-        ? issues.filter((i) => {
-            if (!i.autoFixable)
-                return true;
-            // For fixable issues, check if a corresponding fix was applied
-            // Match by category + page
-            return !fixed.some((f) => f.category === i.category && f.page === i.page);
-        })
-        : issues;
-    return { issues: remainingIssues, fixed, stats };
-}
-//# sourceMappingURL=lint.js.map