chapterhouse 0.7.0 → 0.8.1

package/dist/wiki/index-manager.test.js

@@ -1,160 +1,281 @@
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 import { join } from "node:path";
 import test from "node:test";
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, ".test-work", `wiki-index-${process.pid}`);
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-async function loadModules() {
+// Sandbox: every test gets a fresh CHAPTERHOUSE_HOME
+function makeSandbox() {
+    const dir = mkdtempSync(join(process.cwd(), ".test-work", "wiki-idx-"));
+    process.env.CHAPTERHOUSE_HOME = dir;
+    resetSingletons();
+    return dir;
+}
+async function loadModules(sandbox) {
     const nonce = `${Date.now()}-${Math.random()}`;
-    const indexManager = await import(new URL(`./index-manager.js?case=${nonce}`, import.meta.url).href);
-    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    const indexManager = await import(new URL(`./index-manager.js?c=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?c=${nonce}`, import.meta.url).href);
     return { indexManager, wikiFs };
 }
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
+function resetWikiState(indexManager, wikiFs) {
+    rmSync(wikiFs.getWikiDir(), { recursive: true, force: true });
+    for (const entry of indexManager.parseIndex()) {
+        indexManager.removeFromIndex(entry.path);
+    }
 }
-test.beforeEach(() => {
-    resetSandbox();
+async function loadModulesWithMocks(t, sandbox, options = {}) {
+    const warnings = [];
+    const infos = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: (obj, msg) => infos.push({ obj, msg }),
+                warn: (obj, msg) => warnings.push({ obj, msg }),
+                error: () => { },
+            }),
+        },
+    });
+    if (options.malformedMarker) {
+        const actualFrontmatter = await import(new URL(`./frontmatter.js?actual=${Date.now()}-${Math.random()}`, import.meta.url).href);
+        t.mock.module("./frontmatter.js", {
+            namedExports: {
+                parseWikiFrontmatter: (content) => {
+                    if (content.includes(options.malformedMarker)) {
+                        throw new Error("Malformed wiki page");
+                    }
+                    return actualFrontmatter.parseWikiFrontmatter(content);
+                },
+            },
+        });
+    }
+    return { ...(await loadModules(sandbox)), warnings, infos };
+}
+test.before(() => {
+    mkdirSync(join(process.cwd(), ".test-work"), { recursive: true });
 });
-test.after(() => {
-    rmSync(sandboxRoot, { recursive: true, force: true });
+test("wikiSearch returns FTS5 results for matching query", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/rust/index.md", "---\ntitle: Rust Programming\nsummary: Systems programming with async support\ntags: [rust, async]\nupdated: 2026-05-01\n---\n\n# Rust\n\nSystems language.\n");
+        wikiFs.writePage("pages/topics/typescript/index.md", "---\ntitle: TypeScript\nsummary: Typed JavaScript for large projects\ntags: [ts, web]\nupdated: 2026-05-02\n---\n\n# TypeScript\n\nJS with types.\n");
+        indexManager.rebuildWikiIndex();
+        const results = indexManager.wikiSearch("rust async");
+        assert.ok(results.length > 0, "Should return results for 'rust async'");
+        assert.ok(results.some((r) => r.path === "pages/topics/rust/index.md"), "Should include rust page");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
-test("parseIndex reads sections, summaries, tags, and updated dates", async () => {
-    const { indexManager, wikiFs } = await loadModules();
-    wikiFs.writeIndexFile(`# Wiki Index\n\n## People\n\n- [Ada Lovelace](pages/people/ada.md) — Platform owner | tags: engineer, compiler | updated: 2026-05-01\n\n## Projects\n\n- [Roadmap](pages/projects/roadmap.md) - Shared priorities\n`);
-    assert.deepEqual(indexManager.parseIndex(), [
-        {
-            path: "pages/people/ada.md",
-            title: "Ada Lovelace",
-            summary: "Platform owner",
-            section: "People",
-            tags: ["engineer", "compiler"],
-            updated: "2026-05-01",
-        },
-        {
-            path: "pages/projects/roadmap.md",
-            title: "Roadmap",
-            summary: "Shared priorities",
-            section: "Projects",
-            tags: undefined,
-            updated: undefined,
-        },
-    ]);
+test("wikiSearch empty query returns most recently updated pages", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-01-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/beta/index.md", "---\ntitle: Beta\nsummary: Second topic\nupdated: 2026-05-14\n---\n\n# Beta\n");
+        indexManager.rebuildWikiIndex();
+        const results = indexManager.wikiSearch("", 10);
+        assert.ok(results.length >= 2, "Should return pages for empty query");
+        // Most recent first
+        const betaIdx = results.findIndex((r) => r.path === "pages/topics/beta/index.md");
+        const alphaIdx = results.findIndex((r) => r.path === "pages/topics/alpha/index.md");
+        assert.ok(betaIdx < alphaIdx, "More recently updated page should come first");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
-test("buildIndexEntryForPage treats frontmatter summary as the canonical index summary", async () => {
-    const { indexManager, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/shared/runbooks/deploy.md", `---\ntitle: Deploy Runbook\nsummary: Production deployment checklist\ntags: [ops, release]\nupdated: 2026-05-04\n---\n\n# Deploy\n\n${"Deploy carefully ".repeat(20)}\n`);
-    const entry = indexManager.buildIndexEntryForPage("pages/shared/runbooks/deploy.md");
-    assert.deepEqual(entry, {
-        path: "pages/shared/runbooks/deploy.md",
-        title: "Deploy Runbook",
-        summary: "Production deployment checklist",
-        section: "Knowledge",
-        tags: ["ops", "release"],
-        updated: "2026-05-04",
-    });
+test("rebuildWikiIndex populates wiki_pages from filesystem", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/projects/chapterhouse/index.md", "---\ntitle: Chapterhouse\nsummary: AI orchestrator\ntags: [ai, orchestration]\nupdated: 2026-05-10\n---\n\n# Chapterhouse\n");
+        wikiFs.writePage("pages/projects/chapterhouse/decisions.md", "---\ntitle: Decisions\nsummary: Architectural decisions\nupdated: 2026-05-09\n---\n\n# Decisions\n");
+        indexManager.rebuildWikiIndex();
+        const entries = indexManager.parseIndex();
+        const paths = entries.map((e) => e.path).sort();
+        assert.ok(paths.includes("pages/projects/chapterhouse/index.md"), "Should include index.md");
+        assert.ok(paths.includes("pages/projects/chapterhouse/decisions.md"), "Should include decisions.md");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
-test("parseIndex self-heals an empty index from on-disk pages", async () => {
-    const { indexManager, wikiFs } = await loadModules();
-    const today = new Date().toISOString().slice(0, 10);
-    wikiFs.writePage("pages/team/vision.md", "# Vision\n\nShared direction for the team.\n");
-    wikiFs.writeIndexFile("# Wiki Index\n\n");
-    const entries = indexManager.parseIndex();
-    assert.deepEqual(entries, [
-        {
-            path: "pages/index.md",
-            title: "Wiki",
-            summary: "Index of all wiki pages.",
-            section: "Knowledge",
-            tags: undefined,
-            updated: today,
-        },
-        {
-            path: "pages/team/vision.md",
-            title: "Vision",
-            summary: "Shared direction for the team.",
-            section: "Knowledge",
-            tags: undefined,
-            updated: undefined,
-        },
-    ]);
-    assert.match(wikiFs.readIndexFile(), /\[Vision\]\(pages\/team\/vision\.md\)/);
+test("ensureWikiIndexPopulated rebuilds from disk when wiki_pages starts empty", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/rust/index.md", "---\ntitle: Rust\nsummary: Systems programming\nupdated: 2026-05-10\n---\n\n# Rust\n");
+        for (const entry of indexManager.parseIndex()) {
+            indexManager.removeFromIndex(entry.path);
+        }
+        assert.equal(indexManager.parseIndex().length, 0, "Precondition: wiki_pages should start empty");
+        const result = indexManager.ensureWikiIndexPopulated();
+        assert.equal(result.reindexed, true);
+        assert.ok(result.diskPageCount >= 1);
+        assert.ok(result.indexedPageCount >= 1);
+        assert.ok(indexManager.parseIndex().some((entry) => entry.path === "pages/topics/rust/index.md"));
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
-test("the index renders entity categories as topic groups with nested facet pages", async () => {
-    const { indexManager, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/projects/chapterhouse/index.md", "---\ntitle: Chapterhouse\nupdated: 2026-05-09\n---\n\n# Chapterhouse\n\nThe per-session orchestrator.\n");
-    wikiFs.writePage("pages/projects/chapterhouse/decisions.md", "---\ntitle: Chapterhouse Decisions\nupdated: 2026-05-09\n---\n\n# Decisions\n\nUse SSE for streaming.\n");
-    wikiFs.writePage("pages/preferences.md", "---\ntitle: Preferences\n---\n\n# Preferences\n\nDark mode.\n");
-    indexManager.rebuildIndexFromPages();
-    const index = wikiFs.readIndexFile();
-    assert.match(index, /## Projects/);
-    assert.match(index, /^- \[Chapterhouse\]\(pages\/projects\/chapterhouse\/index\.md\) — /m);
-    assert.match(index, /^ {2}- \[Chapterhouse Decisions\]\(pages\/projects\/chapterhouse\/decisions\.md\) — /m);
-    assert.match(index, /## Preferences/);
-    // Indented facet bullets must still round-trip through parseIndex.
-    const paths = indexManager.parseIndex().map((entry) => entry.path).sort();
-    assert.deepEqual(paths, [
-        "pages/preferences.md",
-        "pages/projects/chapterhouse/decisions.md",
-        "pages/projects/chapterhouse/index.md",
-    ]);
+test("upsertWikiPage inserts and updates correctly", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager } = await loadModules(sandbox);
+        indexManager.upsertWikiPage("pages/people/ada/index.md", { title: "Ada Lovelace", summary: "Mathematician", tags: ["math"], updated: "2026-05-01", metadata: {} }, "First programmer");
+        const results = indexManager.wikiSearch("Ada");
+        assert.ok(results.some((r) => r.title === "Ada Lovelace"), "Should find Ada");
+        // Update
+        indexManager.upsertWikiPage("pages/people/ada/index.md", { title: "Ada Lovelace", summary: "Mathematician and programmer", tags: ["math", "history"], updated: "2026-05-02", metadata: {} }, "First programmer and mathematician");
+        const updated = indexManager.wikiSearch("programmer");
+        assert.ok(updated.length > 0, "Should find updated page");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
-test("searchIndex ranks strong metadata matches and falls back to page bodies", async () => {
-    const { indexManager, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/team/api.md", "# API\n\nObservability budget and telemetry plans.\n");
-    wikiFs.writePage("pages/team/ops.md", "# Ops\n\nDaily operational notes.\n");
-    indexManager.writeIndex([
-        {
-            path: "pages/team/api.md",
-            title: "API",
-            summary: "Status of the platform",
-            section: "Team",
-            tags: ["api"],
-            updated: new Date().toISOString().slice(0, 10),
-        },
-        {
-            path: "pages/team/ops.md",
-            title: "Operations",
-            summary: "Runbooks and incident work",
-            section: "Team",
-        },
-    ]);
-    const metadataHit = indexManager.searchIndex("api", 1);
-    const bodyFallback = indexManager.searchIndex("telemetry", 1);
-    assert.deepEqual(metadataHit.map((entry) => entry.path), ["pages/team/api.md"]);
-    assert.deepEqual(bodyFallback.map((entry) => entry.path), ["pages/team/api.md"]);
+test("FTS search returns results under 50ms", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        // Populate with 20 pages
+        for (let i = 0; i < 20; i++) {
+            wikiFs.writePage(`pages/topics/topic-${i}/index.md`, `---\ntitle: Topic ${i}\nsummary: Description for topic ${i} covering various subjects\ntags: [topic${i}]\nupdated: 2026-05-01\n---\n\n# Topic ${i}\n\nContent.\n`);
+        }
+        indexManager.rebuildWikiIndex();
+        const start = Date.now();
+        const results = indexManager.wikiSearch("topic description");
+        const elapsed = Date.now() - start;
+        assert.ok(results.length > 0, "Should return results");
+        assert.ok(elapsed < 50, `FTS search should complete in <50ms, took ${elapsed}ms`);
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
-test("addToIndex, removeFromIndex, and getIndexSummary keep the catalog in sync", async () => {
-    const { indexManager } = await loadModules();
-    const today = new Date().toISOString().slice(0, 10);
-    indexManager.addToIndex({
-        path: "pages/people/ada.md",
-        title: "Ada Lovelace",
-        summary: "Owns release quality",
-        section: "People",
-        tags: ["qa"],
-        updated: "2026-05-05",
-    });
-    indexManager.addToIndex({
-        path: "pages/projects/launch.md",
-        title: "Launch",
-        summary: "Tracks release milestones",
-        section: "Projects",
-    });
-    indexManager.addToIndex({
-        path: "pages/people/ada.md",
-        title: "Ada Lovelace",
-        summary: "Owns regression coverage",
-        section: "People",
-        tags: ["qa", "testing"],
-        updated: "2026-05-06",
-    });
-    assert.equal(indexManager.removeFromIndex("pages/projects/launch.md"), true);
-    assert.equal(indexManager.removeFromIndex("pages/projects/missing.md"), false);
-    const summary = indexManager.getIndexSummary();
-    assert.match(summary, /\*\*People\*\*: Ada Lovelace: Owns regression coverage \[qa, testing\] \(2026-05-06\)/);
-    assert.match(summary, new RegExp(`\\*\\*Index\\*\\*: Wiki: Index of all wiki pages\\. \\(${today}\\)`));
+test("removeFromIndex removes from wiki_pages", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager } = await loadModules(sandbox);
+        indexManager.upsertWikiPage("pages/people/test/index.md", { title: "Test Person", summary: "A test", tags: [], updated: "2026-05-01", metadata: {} }, "A test");
+        const before = indexManager.wikiSearch("Test Person");
+        assert.ok(before.length > 0, "Should exist before removal");
+        const removed = indexManager.removeFromIndex("pages/people/test/index.md");
+        assert.equal(removed, true);
+        const after = indexManager.wikiSearch("Test Person");
+        assert.equal(after.length, 0, "Should not exist after removal");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("searchIndex delegates to wikiSearch and returns IndexEntry shape", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/team/api.md", "---\ntitle: API Docs\nsummary: API documentation\ntags: [api]\nupdated: 2026-05-01\n---\n\n# API\n");
+        indexManager.rebuildWikiIndex();
+        const results = indexManager.searchIndex("api");
+        assert.ok(results.length > 0);
+        assert.ok("section" in results[0], "Should have section field");
+        assert.ok("title" in results[0], "Should have title field");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("rebuildWikiIndex removes stale entries not on disk", async () => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs } = await loadModules(sandbox);
+        wikiFs.writePage("pages/topics/keep/index.md", "---\ntitle: Keep\nsummary: Keep this\nupdated: 2026-05-01\n---\n\n# Keep\n");
+        // Insert stale entry directly
+        indexManager.upsertWikiPage("pages/topics/stale/index.md", { title: "Stale", summary: "Should be removed", tags: [], updated: "2026-01-01", metadata: {} }, "Stale");
+        // Rebuild syncs disk → DB
+        indexManager.rebuildWikiIndex();
+        const entries = indexManager.parseIndex();
+        const paths = entries.map((e) => e.path);
+        assert.ok(paths.includes("pages/topics/keep/index.md"), "Should keep on-disk page");
+        assert.ok(!paths.includes("pages/topics/stale/index.md"), "Should remove stale entry");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("reindexWikiPages skips unreadable pages and continues indexing others", async (t) => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs, warnings } = await loadModulesWithMocks(t, sandbox);
+        resetWikiState(indexManager, wikiFs);
+        const unreadablePath = join(wikiFs.getWikiDir(), "pages", "topics", "blocked", "index.md");
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-05-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/blocked/index.md", "---\ntitle: Blocked\nsummary: Unreadable topic\nupdated: 2026-05-02\n---\n\n# Blocked\n");
+        wikiFs.writePage("pages/topics/gamma/index.md", "---\ntitle: Gamma\nsummary: Third topic\nupdated: 2026-05-03\n---\n\n# Gamma\n");
+        chmodSync(unreadablePath, 0o000);
+        try {
+            const result = indexManager.reindexWikiPages();
+            const paths = indexManager.parseIndex().map((entry) => entry.path).sort();
+            assert.deepEqual(paths, [
+                "pages/topics/alpha/index.md",
+                "pages/topics/gamma/index.md",
+            ]);
+            assert.equal(result.diskPageCount, 3);
+            assert.equal(result.indexedPageCount, 2);
+            assert.ok(warnings.some((entry) => entry.obj.path === "pages/topics/blocked/index.md"), "Expected a warning for the unreadable page");
+        }
+        finally {
+            chmodSync(unreadablePath, 0o644);
+        }
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("reindexWikiPages skips malformed pages and continues indexing others", async (t) => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs, warnings } = await loadModulesWithMocks(t, sandbox, { malformedMarker: "UNPARSEABLE" });
+        resetWikiState(indexManager, wikiFs);
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-05-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/bad/index.md", "---\ntitle: Bad\nsummary: Broken topic\nupdated: 2026-05-02\n---\n\nUNPARSEABLE\n");
+        wikiFs.writePage("pages/topics/gamma/index.md", "---\ntitle: Gamma\nsummary: Third topic\nupdated: 2026-05-03\n---\n\n# Gamma\n");
+        const result = indexManager.reindexWikiPages();
+        const paths = indexManager.parseIndex().map((entry) => entry.path).sort();
+        assert.deepEqual(paths, [
+            "pages/topics/alpha/index.md",
+            "pages/topics/gamma/index.md",
+        ]);
+        assert.equal(result.diskPageCount, 3);
+        assert.equal(result.indexedPageCount, 2);
+        assert.ok(warnings.some((entry) => entry.obj.path === "pages/topics/bad/index.md"), "Expected a warning for the malformed page");
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
+});
+test("reindexWikiPages logs a summary with indexed and skipped counts", async (t) => {
+    const sandbox = makeSandbox();
+    try {
+        const { indexManager, wikiFs, infos } = await loadModulesWithMocks(t, sandbox);
+        resetWikiState(indexManager, wikiFs);
+        const unreadablePath = join(wikiFs.getWikiDir(), "pages", "topics", "blocked", "index.md");
+        wikiFs.writePage("pages/topics/alpha/index.md", "---\ntitle: Alpha\nsummary: First topic\nupdated: 2026-05-01\n---\n\n# Alpha\n");
+        wikiFs.writePage("pages/topics/blocked/index.md", "---\ntitle: Blocked\nsummary: Unreadable topic\nupdated: 2026-05-02\n---\n\n# Blocked\n");
+        wikiFs.writePage("pages/topics/gamma/index.md", "---\ntitle: Gamma\nsummary: Third topic\nupdated: 2026-05-03\n---\n\n# Gamma\n");
+        chmodSync(unreadablePath, 0o000);
+        try {
+            const result = indexManager.reindexWikiPages();
+            assert.equal(result.indexedPageCount, 2);
+            assert.ok(infos.some((entry) => /Reindexed 2 pages, skipped 1/.test(entry.msg)), "Expected a summary log with indexed and skipped counts");
+        }
+        finally {
+            chmodSync(unreadablePath, 0o644);
+        }
+    }
+    finally {
+        rmSync(sandbox, { recursive: true, force: true });
+    }
 });
 //# sourceMappingURL=index-manager.test.js.map