@creativeaitools/agent-wiki 2.0.0

package/_system/config.example.json

@@ -0,0 +1,105 @@
+{
+  "schemaVersion": 1,
+  "wikiType": "vault",
+  "pythonCommand": null,
+  "knownVaults": {},
+  "workspace": {
+    "root": null,
+    "wikiDir": "wiki",
+    "scan": {
+      "includeExtensions": [
+        ".md",
+        ".markdown",
+        ".txt",
+        ".pdf",
+        ".docx",
+        ".csv",
+        ".json",
+        ".yaml",
+        ".yml"
+      ],
+      "excludeDirs": [
+        ".git",
+        ".hg",
+        ".svn",
+        ".obsidian",
+        ".venv",
+        "venv",
+        "env",
+        "__pycache__",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".ruff_cache",
+        "node_modules",
+        "dist",
+        "build",
+        ".next",
+        ".turbo",
+        ".cache",
+        "_system",
+        "reports",
+        "target",
+        "vendor"
+      ],
+      "excludeFileGlobs": [
+        "*.lock",
+        "package-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "uv.lock",
+        "poetry.lock"
+      ]
+    }
+  },
+  "conversion": {
+    "enabled": false,
+    "defaultBackend": "auto",
+    "backendOrder": [
+      "pymupdf4llm",
+      "markitdown"
+    ],
+    "allowNetwork": false,
+    "allowOcr": false,
+    "allowLlm": false,
+    "allowTranscription": false,
+    "allowHostedDocumentIntelligence": false,
+    "backends": {
+      "pymupdf4llm": {
+        "enabled": true,
+        "command": null,
+        "formats": [
+          "pdf"
+        ]
+      },
+      "markitdown": {
+        "enabled": true,
+        "command": "markitdown",
+        "formats": [
+          "pdf",
+          "docx",
+          "pptx",
+          "xlsx",
+          "html",
+          "csv",
+          "json",
+          "xml",
+          "epub"
+        ]
+      },
+      "arxiv2md": {
+        "enabled": false,
+        "command": null,
+        "formats": [
+          "pdf"
+        ]
+      },
+      "marker": {
+        "enabled": false,
+        "command": null,
+        "formats": [
+          "pdf"
+        ]
+      }
+    }
+  }
+}

package/dist/src/catalog.js

@@ -0,0 +1,66 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { readJson, writeOperationalLog, writeText } from "./wiki-utils.js";
+export function renderIndexCommand(args) {
+    const wikiRoot = process.cwd();
+    const data = readJson(join(wikiRoot, "_system/cache/pages.json"));
+    if (!data || !Array.isArray(data.pages))
+        throw new Error("Missing _system/cache/pages.json; run compile first.");
+    const rendered = renderIndex(data.pages);
+    const path = join(wikiRoot, "index.md");
+    const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+    if (args.check) {
+        if (existing !== rendered) {
+            console.log("index.md is out of date");
+            return 1;
+        }
+        console.log("index.md is current");
+        return 0;
+    }
+    if (existing === rendered) {
+        console.log("index.md is current");
+        return 0;
+    }
+    writeText(path, rendered);
+    console.log("Wrote index.md");
+    if (!args["no-log"])
+        writeOperationalLog(wikiRoot, `index: regenerated root page catalog; pages=${data.pages.length}`);
+    return 0;
+}
+export function renderIndex(pages) {
+    const byType = new Map();
+    for (const page of pages) {
+        const type = String(page.pageType || "other");
+        byType.set(type, [...(byType.get(type) ?? []), page]);
+    }
+    const today = new Date().toISOString().slice(0, 10);
+    const lines = ["---", "id: index.root", "pageType: index", "title: Page Index", "status: active", `createdAt: ${today}`, `updatedAt: ${today}`, "---", "", "# Page Index", ""];
+    for (const type of ["overview", "source", "entity", "concept", "claim", "synthesis", "question", "report", "index"]) {
+        const rows = (byType.get(type) ?? []).sort((a, b) => String(a.title).localeCompare(String(b.title)));
+        if (!rows.length)
+            continue;
+        lines.push(`## ${label(type)}`, "", "| Page | Path | Status | Updated |", "|---|---|---|---|");
+        for (const page of rows) {
+            lines.push(`| ${esc(page.title || page.id)} | ${esc(page.path)} | ${esc(page.status)} | ${esc(page.updatedAt)} |`);
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n").trimEnd()}\n`;
+}
+function label(type) {
+    const labels = {
+        overview: "Overviews",
+        source: "Sources",
+        entity: "Entities",
+        concept: "Concepts",
+        claim: "Claims",
+        synthesis: "Syntheses",
+        question: "Questions",
+        report: "Reports",
+        index: "Indexes"
+    };
+    return labels[type] ?? `${type.charAt(0).toUpperCase()}${type.slice(1).replaceAll("-", " ")}s`;
+}
+function esc(value) {
+    return String(value ?? "").replaceAll("|", "\\|").replaceAll("\n", " ");
+}

package/dist/src/cli.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { loadConfig } from "./config.js";
+import { renderIndexCommand } from "./catalog.js";
+import { compileWiki } from "./compile.js";
+import { doctorWiki, initWiki, issuesToJson, issuesToText } from "./lifecycle.js";
+import { migrateRefs } from "./migrate.js";
+import { buildOnboardingReport, onboard } from "./onboard.js";
+import { createPage } from "./page.js";
+import { migrateWiki } from "./upgrade.js";
+import { writeOperationalLog } from "./wiki-utils.js";
+import { randomBytes } from "node:crypto";
+import { addRegistryEntry, getRegistryEntry, listRegistryEntries, registryPath, removeRegistryEntry } from "./registry.js";
+import { schedulePrompt } from "./schedule-prompts.js";
+import { defaultWorkspaceRoot, filesToJson, filesToText, loadState, markSourced, scanWorkspace, updateStateFromScan, wikiRootForWorkspace } from "./workspace.js";
+export function main(argv = process.argv.slice(2)) {
+    try {
+        const global = parseArgs(argv);
+        const command = global._[0];
+        if (!command || global.help) {
+            printHelp();
+            return global.help ? 0 : 2;
+        }
+        const wikiRoot = resolveWikiRoot(global);
+        if (command === "list")
+            return cmdList(global);
+        if (command === "registry")
+            return cmdRegistry(global);
+        if (command === "check")
+            return cmdCheck(global);
+        if (command === "schedule")
+            return schedulePrompt(global);
+        if (command === "init")
+            return cmdInit(global);
+        if (command === "doctor")
+            return cmdDoctor(global, wikiRoot);
+        if (command === "workspace")
+            return withWikiRoot(wikiRoot, () => cmdWorkspace(global));
+        if (command === "create-page")
+            return withWikiRoot(wikiRoot, () => createPage(global));
+        if (command === "onboard")
+            return onboard({ ...global, "wiki-root": wikiRoot ?? global["wiki-root"] });
+        if (command === "index")
+            return withWikiRoot(wikiRoot, () => renderIndexCommand(global));
+        if (command === "log")
+            return withWikiRoot(wikiRoot, () => cmdLog(global));
+        if (command === "migrate-refs-to-links")
+            return withWikiRoot(wikiRoot, () => migrateRefs(global));
+        if (command === "migrate")
+            return withWikiRoot(wikiRoot, () => migrateWiki(global));
+        if (command === "compile")
+            return withWikiRoot(wikiRoot, () => compileWiki(global));
+        if (command === "uuid")
+            return cmdUuid(global);
+        throw new Error(`Unknown command: ${command}`);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 2;
+    }
+}
+function cmdInit(args) {
+    const type = String(args.type ?? "");
+    if (type !== "vault" && type !== "workspace") {
+        throw new Error("init requires --type vault|workspace");
+    }
+    const result = initWiki({
+        wikiType: type,
+        root: stringOpt(args["root"], "."),
+        workspaceRoot: stringOpt(args["workspace-root"]),
+        wikiDir: stringOpt(args["wiki-dir"], "wiki"),
+        writeConfig: args["no-config"] ? false : true,
+        withTemplate: args["no-template"] ? false : true
+    });
+    console.log(`Initialized ${result.wikiType} wiki at ${result.wikiRoot}`);
+    if (result.workspaceRoot)
+        console.log(`Workspace root: ${result.workspaceRoot}`);
+    console.log(`Created folders: ${result.created.length}`);
+    if (result.configWritten)
+        console.log("Wrote _system/config.json");
+    if (result.templateCopied.length > 0)
+        console.log(`Copied template files: ${result.templateCopied.length}`);
+    return 0;
+}
+function cmdDoctor(args, wikiRoot) {
+    const root = wikiRoot ?? stringOpt(args["wiki-root"], stringOpt(args.root, ".")) ?? ".";
+    const type = stringOpt(args.type);
+    const issues = doctorWiki(root, type);
+    console.log(args.json ? issuesToJson(issues) : issuesToText(issues));
+    return issues.some((issue) => issue.level === "error") ? 1 : 0;
+}
+function cmdList(args) {
+    const entries = listRegistryEntries();
+    if (args.json) {
+        console.log(JSON.stringify({ schemaVersion: 1, registryPath: registryPath(), wikis: entries }, null, 2));
+        return 0;
+    }
+    if (entries.length === 0) {
+        console.log("No Agent Wiki roots registered.");
+        return 0;
+    }
+    const width = Math.max(...entries.map((entry) => entry.name.length), 4);
+    for (const entry of entries)
+        console.log(`${entry.name.padEnd(width)}  ${entry.type.padEnd(9)}  ${entry.root}`);
+    return 0;
+}
+function cmdRegistry(args) {
+    const subcommand = args._[1];
+    if (subcommand === "list")
+        return cmdList(args);
+    if (subcommand === "add") {
+        const name = stringOpt(args.name, args._[2]);
+        if (!name)
+            throw new Error("registry add requires a wiki name");
+        const root = required(args, "root");
+        const entry = addRegistryEntry(name, root, stringOpt(args.type));
+        console.log(args.json ? JSON.stringify(entry, null, 2) : `Registered ${entry.name}: ${entry.root}`);
+        return 0;
+    }
+    if (subcommand === "show") {
+        const name = stringOpt(args.name, args._[2]);
+        if (!name)
+            throw new Error("registry show requires a wiki name");
+        const entry = getRegistryEntry(name);
+        console.log(args.json ? JSON.stringify(entry, null, 2) : `${entry.name}  ${entry.type}  ${entry.root}`);
+        return 0;
+    }
+    if (subcommand === "remove") {
+        const name = stringOpt(args.name, args._[2]);
+        if (!name)
+            throw new Error("registry remove requires a wiki name");
+        const removed = removeRegistryEntry(name);
+        console.log(removed ? `Removed ${name}` : `No registered wiki named ${name}`);
+        return removed ? 0 : 1;
+    }
+    throw new Error("registry requires list, add, show, or remove");
+}
+function cmdCheck(args) {
+    const name = args._[1] && !String(args._[1]).startsWith("--") ? String(args._[1]) : undefined;
+    const entries = args.all ? listRegistryEntries() : [getRegistryEntry(name ?? required(args, "wiki"))];
+    const results = entries.map((entry) => checkEntry(entry, Boolean(args.full)));
+    if (args.json) {
+        console.log(JSON.stringify({ schemaVersion: 1, full: Boolean(args.full), results }, null, 2));
+    }
+    else {
+        for (const result of results) {
+            const status = result.ok ? "ok" : "fail";
+            console.log(`${status.padEnd(5)} ${result.name} (${result.root})`);
+            if (!result.ok) {
+                for (const issue of result.doctorIssues)
+                    console.log(`  ${issue.level}: ${issue.code} ${issue.message}`);
+                if (result.indexStatus)
+                    console.log(`  index: ${result.indexStatus}`);
+            }
+        }
+    }
+    return results.every((result) => result.ok) ? 0 : 1;
+}
+function checkEntry(entry, full) {
+    const doctorIssues = doctorWiki(entry.root, entry.type);
+    const onboarding = buildOnboardingReport(entry.root);
+    const errors = doctorIssues.filter((issue) => issue.level === "error");
+    let compileStatus = "skipped";
+    let indexStatus = "skipped";
+    if (full && errors.length === 0) {
+        const originalLog = console.log;
+        try {
+            console.log = () => undefined;
+            withWikiRoot(entry.root, () => compileWiki({}));
+            const indexCode = withWikiRoot(entry.root, () => renderIndexCommand({ check: true }));
+            compileStatus = "passed";
+            indexStatus = indexCode === 0 ? "current" : "out-of-date";
+        }
+        catch {
+            compileStatus = "failed";
+            indexStatus = "failed";
+        }
+        finally {
+            console.log = originalLog;
+        }
+    }
+    return {
+        name: entry.name,
+        root: entry.root,
+        type: entry.type,
+        ok: errors.length === 0 && onboarding.summary.ready && (!full || (compileStatus === "passed" && indexStatus === "current")),
+        doctorIssues,
+        onboardingSummary: onboarding.summary,
+        compileStatus,
+        indexStatus
+    };
+}
+function cmdWorkspace(args) {
+    const subcommand = args._[1];
+    if (subcommand === "scan" || subcommand === "pending") {
+        const includeUnchanged = subcommand === "scan";
+        const { files, wikiRoot } = workspaceFiles(args);
+        const filtered = includeUnchanged ? files : files.filter((item) => item.reason !== "unchanged");
+        if (subcommand === "scan" && args["write-state"]) {
+            updateStateFromScan(wikiRoot, files, loadState(wikiRoot));
+        }
+        console.log(args.json ? filesToJson(filtered) : filesToText(filtered));
+        return 0;
+    }
+    if (subcommand === "mark-sourced") {
+        const path = required(args, "path");
+        const sourceId = required(args, "source-id");
+        const sourcePath = required(args, "source-path");
+        const config = loadConfig(stringOpt(args.root, "."));
+        const workspaceRoot = defaultWorkspaceRoot(config, stringOpt(args["workspace-root"]));
+        const wikiRoot = wikiRootForWorkspace(workspaceRoot, stringOpt(args["wiki-dir"], config.wikiDir));
+        const state = markSourced(wikiRoot, loadState(wikiRoot), { relativePath: path, sourceId, sourcePath });
+        updateStateFromScan(wikiRoot, scanWorkspace(workspaceRoot, wikiRoot, config.workspaceScan, { state }), state);
+        console.log(`Mapped ${path} -> ${sourceId}`);
+        return 0;
+    }
+    throw new Error("workspace requires scan, pending, or mark-sourced");
+}
+function cmdLog(args) {
+    const message = required(args, "message");
+    const path = writeOperationalLog(process.cwd(), message);
+    console.log(`Wrote operational log: ${path}`);
+    return 0;
+}
+function cmdUuid(args) {
+    const length = Number(stringOpt(args.length, "10"));
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const bytes = randomBytes(length);
+    let out = "";
+    for (const byte of bytes)
+        out += alphabet[byte % alphabet.length];
+    console.log(out);
+    return 0;
+}
+function workspaceFiles(args) {
+    const config = loadConfig(stringOpt(args.root, "."));
+    const workspaceRoot = defaultWorkspaceRoot(config, stringOpt(args["workspace-root"]));
+    const wikiRoot = wikiRootForWorkspace(workspaceRoot, stringOpt(args["wiki-dir"], config.wikiDir));
+    const sinceHours = stringOpt(args["since-hours"]);
+    const since = sinceHours === undefined ? undefined : new Date(Date.now() - Number(sinceHours) * 60 * 60 * 1000);
+    const state = loadState(wikiRoot);
+    return { files: scanWorkspace(workspaceRoot, wikiRoot, config.workspaceScan, { since, state }), wikiRoot };
+}
+function parseArgs(argv) {
+    const parsed = { _: [] };
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token.startsWith("--")) {
+            const [key, inlineValue] = token.slice(2).split("=", 2);
+            if (inlineValue !== undefined) {
+                addArg(parsed, key, inlineValue);
+            }
+            else if (argv[index + 1] && !argv[index + 1].startsWith("--")) {
+                addArg(parsed, key, argv[index + 1]);
+                index += 1;
+            }
+            else {
+                addArg(parsed, key, true);
+            }
+        }
+        else {
+            parsed._.push(token);
+        }
+    }
+    return parsed;
+}
+function addArg(parsed, key, value) {
+    const existing = parsed[key];
+    if (typeof existing === "string")
+        parsed[key] = [existing, String(value)];
+    else if (Array.isArray(existing))
+        existing.push(String(value));
+    else
+        parsed[key] = value;
+}
+function required(args, key) {
+    const value = stringOpt(args[key]);
+    if (!value) {
+        throw new Error(`missing required --${key}`);
+    }
+    return value;
+}
+function stringOpt(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+function resolveWikiRoot(args) {
+    const name = stringOpt(args.wiki);
+    return name ? getRegistryEntry(name).root : undefined;
+}
+function withWikiRoot(root, fn) {
+    if (!root)
+        return fn();
+    const previous = process.cwd();
+    process.chdir(root);
+    try {
+        return fn();
+    }
+    finally {
+        process.chdir(previous);
+    }
+}
+function printHelp() {
+    console.log(`agent-wiki
+
+Commands:
+  list [--json]
+  registry list|add|show|remove
+  check WIKI|--all [--full] [--json]
+  schedule prompt process-inbox|extract-primitives|update-overview [WIKI...] [--wiki NAME]
+  --wiki NAME <command>
+  init --type vault|workspace [--root PATH] [--workspace-root PATH] [--wiki-dir wiki] [--no-config] [--no-template]
+  doctor [--wiki-root PATH] [--type vault|workspace] [--json]
+  create-page --type TYPE --subtype SUBTYPE --slug SLUG --title TITLE (--body-file PATH|--body TEXT)
+  onboard --check [--wiki-root PATH] [--questions] [--compact]
+  onboard --write-config [--type vault|workspace] [--wiki-dir wiki] [--python-command CMD] [--conversion disabled|available-local]
+  compile [--verbose]
+  index --write|--check
+  log --message TEXT
+  uuid [--length N]
+  migrate-refs-to-links --dry-run|--write
+  migrate --from v1 --check|--write
+  workspace scan [--workspace-root PATH] [--wiki-dir wiki] [--json] [--since-hours N] [--write-state]
+  workspace pending [--workspace-root PATH] [--wiki-dir wiki] [--json] [--since-hours N]
+  workspace mark-sourced --path PATH --source-id ID --source-path PATH [--workspace-root PATH] [--wiki-dir wiki]
+`);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    process.exitCode = main();
+}

package/dist/src/compile.js

@@ -0,0 +1,104 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { renderIndex } from "./catalog.js";
+import { walkMarkdownPages, writeJson, writeOperationalLog } from "./wiki-utils.js";
+export function compileWiki(args) {
+    const root = process.cwd();
+    const compiledAt = new Date().toISOString();
+    console.log("Agent Wiki v2 Compile Pipeline");
+    console.log(`Wiki root: ${root}`);
+    console.log(`Compiled at: ${compiledAt}`);
+    console.log();
+    for (const dir of ["_system/cache", "_system/indexes", "_system/logs", "reports"])
+        mkdirSync(join(root, dir), { recursive: true });
+    console.log("Reading vault pages...");
+    const pages = walkMarkdownPages(root);
+    const issues = validatePages(pages);
+    console.log(`  Found ${pages.length} pages with frontmatter`);
+    if (issues.length)
+        console.log(`  Validation issues detected: ${issues.length}`);
+    const claims = extractClaims(pages);
+    const relations = extractRelations(pages);
+    const timeline = extractTimeline(pages);
+    const contradictions = [];
+    const health = analyzeHealth(pages, claims);
+    const pageOutput = pages.map(({ meta, body, ...page }) => page);
+    console.log("\nWriting cache files...");
+    writeJson(join(root, "_system/cache/pages.json"), { compiledAt, pages: pageOutput });
+    writeJsonl(join(root, "_system/cache/claims.jsonl"), claims);
+    writeJsonl(join(root, "_system/cache/relations.jsonl"), relations);
+    writeJson(join(root, "_system/cache/agent-digest.json"), { compiledAt, pages: pageOutput.slice(0, 50), claims: claims.slice(0, 30), validationIssues: issues });
+    writeJson(join(root, "_system/cache/contradictions.json"), { compiledAt, contradictions });
+    writeJson(join(root, "_system/cache/questions.json"), { compiledAt, questions: pageOutput.filter((p) => p.pageType === "question") });
+    writeJson(join(root, "_system/cache/timeline-events.json"), { compiledAt, events: timeline });
+    writeJson(join(root, "_system/cache/source-index.json"), { compiledAt, sources: pageOutput.filter((p) => p.pageType === "source") });
+    writeJson(join(root, "_system/cache/validation-issues.json"), { compiledAt, issues, summary: summarize(issues) });
+    writeJson(join(root, "_system/cache/claims-index.json"), { compiledAt, claims: pageOutput.filter((p) => p.pageType === "claim") });
+    const indexes = buildIndexes(pageOutput);
+    for (const [name, data] of Object.entries(indexes))
+        writeJson(join(root, `_system/indexes/${name}.json`), { compiledAt, data });
+    console.log("\nWriting root page catalog...");
+    writeFileSync(join(root, "index.md"), renderIndex(pageOutput), "utf8");
+    writeReports(root, pageOutput, claims, health, compiledAt.slice(0, 10));
+    writeOperationalLog(root, `compile-wiki: regenerated index, cache, indexes, and reports; pages=${pages.length} claims=${claims.length} relations=${relations.length} contradictions=0 openQuestions=${pageOutput.filter((p) => p.pageType === "question" && ["open", "researching", "blocked"].includes(String(p.status))).length} evidenceGaps=${health.evidenceGaps.length} lowConfidence=${health.lowConfidence.length} validationIssues=${issues.length} duplicatePageIds=${issues.filter((i) => i.code === "duplicate_page_id").length}`);
+    console.log("\nCompile complete.");
+    console.log(`  Pages: ${pages.length} | Claims: ${claims.length} | Relations: ${relations.length} | Contradictions: 0`);
+    console.log(`  Validation issues: ${issues.length}`);
+    return 0;
+}
+function validatePages(pages) {
+    const issues = [];
+    const seen = new Map();
+    for (const page of pages) {
+        for (const field of ["id", "pageType", "title", "status", "createdAt", "updatedAt"]) {
+            if (!page[field])
+                issues.push({ code: "missing_required_field", path: page.path, field, message: `Missing required field ${field}` });
+        }
+        if (page.id)
+            seen.set(page.id, [...(seen.get(page.id) ?? []), page.path]);
+    }
+    for (const [id, paths] of seen)
+        if (paths.length > 1)
+            issues.push({ code: "duplicate_page_id", pageId: id, paths, path: paths[0], message: `Page id ${id} appears in multiple files.` });
+    return issues;
+}
+function extractClaims(pages) {
+    const claims = [];
+    for (const page of pages) {
+        if (page.pageType === "claim")
+            claims.push({ id: page.id, text: page.text || page.title, status: page.status, confidence: page.confidence, sourceIds: page.sourceIds || [], evidence: page.evidence || [], _owningPagePath: page.path });
+        for (const claim of Array.isArray(page.claims) ? page.claims : [])
+            claims.push({ ...claim, _owningPagePath: page.path });
+    }
+    return claims;
+}
+function extractRelations(pages) { return pages.flatMap((p) => (Array.isArray(p.relations) ? p.relations.map((r) => ({ ...r, _owningPagePath: p.path })) : [])); }
+function extractTimeline(pages) { return pages.flatMap((p) => (Array.isArray(p.timeline) ? p.timeline.map((r) => ({ ...r, _owningPagePath: p.path })) : [])); }
+function analyzeHealth(pages, claims) {
+    return { lowConfidence: claims.filter((c) => Number(c.confidence ?? 1) < 0.5), evidenceGaps: claims.filter((c) => !Array.isArray(c.evidence) || c.evidence.length === 0), stalePages: pages.filter((p) => false) };
+}
+function buildIndexes(pages) {
+    const idToPath = {}, pathToId = {}, pageType = {}, aliases = {}, tags = {};
+    for (const page of pages) {
+        idToPath[page.id] = page.path;
+        pathToId[page.path] = page.id;
+        (pageType[page.pageType] ??= []).push(page.id);
+        for (const alias of page.aliases || [])
+            aliases[String(alias)] = page.id;
+        for (const tag of page.tags || [])
+            (tags[String(tag)] ??= []).push(page.id);
+    }
+    return { "id-to-path": idToPath, "path-to-id": pathToId, "pagetype-index": pageType, "alias-index": aliases, "tag-index": tags };
+}
+function writeReports(root, pages, claims, health, date) {
+    const report = (title, rows) => `---\npageType: report\ntitle: ${title}\nstatus: active\nupdatedAt: ${date}\n---\n\n# ${title}\n\n${rows.length ? rows.join("\n") : "No entries."}\n`;
+    writeFileSync(join(root, "reports/open-questions.md"), report("Open Questions", pages.filter((p) => p.pageType === "question").map((p) => `- ${p.id}: ${p.title}`)), "utf8");
+    writeFileSync(join(root, "reports/contradictions.md"), report("Contradictions", []), "utf8");
+    writeFileSync(join(root, "reports/low-confidence.md"), report("Low Confidence", health.lowConfidence.map((c) => `- ${c.id}: ${c.text}`)), "utf8");
+    writeFileSync(join(root, "reports/claim-health.md"), report("Claim Health", [`Claims: ${claims.length}`, `Evidence gaps: ${health.evidenceGaps.length}`, `Low confidence: ${health.lowConfidence.length}`]), "utf8");
+    writeFileSync(join(root, "reports/stale-pages.md"), report("Stale Pages", []), "utf8");
+    writeFileSync(join(root, "reports/orphaned-claims.md"), report("Orphaned Claims", []), "utf8");
+    writeFileSync(join(root, "reports/evidence-gaps.md"), report("Evidence Gaps", health.evidenceGaps.map((c) => `- ${c.id}: ${c.text}`)), "utf8");
+}
+function writeJsonl(path, rows) { writeFileSync(path, rows.map((row) => JSON.stringify(row)).join("\n") + (rows.length ? "\n" : ""), "utf8"); }
+function summarize(issues) { return issues.reduce((acc, issue) => ({ ...acc, [issue.code]: (acc[issue.code] ?? 0) + 1 }), {}); }