chapterhouse 0.8.1 → 0.9.0

package/dist/api/server.test.js

@@ -1,9 +1,10 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
 import Database from "better-sqlite3";
+import { z } from "zod";
 import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 test("supports API_TOKEN env var and personal health route helpers", async () => {
     const runtime = await import("./server-runtime.js");
@@ -83,6 +84,23 @@ test("formats named SSE status events", async () => {
     assert.equal(sse.formatSseEvent("status", { status: "dreaming", message: "Consolidating memories..." }), 'event: status\ndata: {"status":"dreaming","message":"Consolidating memories..."}\n\n');
 });
 const repoRoot = process.cwd();
+const wikiLinkResponseSchema = z.object({
+    links: z.array(z.object({
+        source_slug: z.string(),
+        target_slug: z.string(),
+        link_type: z.string(),
+    }).passthrough()),
+});
+const wikiSourcesResponseSchema = z.object({
+    sources: z.array(z.object({
+        source_url: z.string().optional(),
+        path: z.string().optional(),
+        kind: z.string(),
+        status: z.string(),
+        session_id: z.string().nullable().optional(),
+        ingested_at: z.string().nullable().optional(),
+    }).passthrough()),
+});
 function getProjectDbPath(testRoot) {
     return join(testRoot, ".chapterhouse", "chapterhouse.db");
 }
@@ -738,6 +756,24 @@ tags: [ops]
         assert.deepEqual(await missingResponse.json(), { error: "Page not found" });
     });
 });
+test("POST /api/wiki/page/pin rejects path traversal slugs", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/wiki/page/pin`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                slug: "../../etc/passwd",
+                pinned: true,
+            }),
+        });
+        assert.equal(response.status, 400);
+        const body = await response.json();
+        assert.match(body.error ?? "", /unsafe wiki path/i);
+    });
+});
 test("server worker detail returns the stored dispatched prompt", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
         const db = new Database(join(testRoot, ".chapterhouse", "chapterhouse.db"));
@@ -873,6 +909,128 @@ test("server wiki route still returns 404 for other missing wiki pages", async (
         assert.deepEqual(await response.json(), { error: "Page not found" });
     });
 });
+test("GET /api/wiki/browser-pages maps wiki_pages rows to the browser contract and filters them", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_pages (path, title, entity_type, tags, summary, last_updated, pinned)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run("pages/topics/rust/index.md", "Rust", "topics", "[]", "Systems programming language", "2026-05-15T12:00:00.000Z", 1);
+            db.prepare(`
+        INSERT INTO wiki_pages (path, title, entity_type, tags, summary, last_updated, pinned)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `).run("pages/projects/chapterhouse/index.md", "Chapterhouse", "projects", "[]", "Team AI assistant", "2026-05-14T12:00:00.000Z", 0);
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/browser-pages?type=topics&q=systems`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(await response.json(), {
+            pages: [
+                {
+                    slug: "topics/rust/index",
+                    title: "Rust",
+                    summary: "Systems programming language",
+                    type: "topics",
+                    last_updated: "2026-05-15T12:00:00.000Z",
+                    pinned: true,
+                },
+            ],
+        });
+    });
+});
+test("GET /api/wiki/browser-pages falls back to indexed and orphan wiki pages when wiki_pages is empty", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const indexedDir = join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "fallback");
+        mkdirSync(indexedDir, { recursive: true });
+        writeFileSync(join(indexedDir, "index.md"), "# Fallback\n", "utf-8");
+        const orphanDir = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "orphan-browser");
+        mkdirSync(orphanDir, { recursive: true });
+        writeFileSync(join(orphanDir, "index.md"), "# Orphan Browser\n", "utf-8");
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare("DELETE FROM wiki_pages").run();
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/browser-pages?type=Unindexed&q=orphan`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        assert.deepEqual(body.pages.map((page) => ({
+            slug: page.slug,
+            title: page.title,
+            type: page.type,
+        })), [
+            {
+                slug: "projects/orphan-browser/index",
+                title: "pages/projects/orphan-browser/index.md",
+                type: "Unindexed",
+            },
+        ]);
+        assert.notEqual(body.pages[0]?.last_updated, "");
+    });
+});
+test("GET /api/wiki/pages coerces empty updated fields to page mtimes", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const indexedPath = join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "coerced-updated", "index.md");
+        const indexedMtime = new Date("2026-05-15T12:00:00.000Z");
+        mkdirSync(join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "coerced-updated"), { recursive: true });
+        writeFileSync(indexedPath, "# Coerced Updated\n", "utf-8");
+        utimesSync(indexedPath, indexedMtime, indexedMtime);
+        const orphanPath = join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "orphan-updated", "index.md");
+        const orphanMtime = new Date("2026-05-15T13:30:00.000Z");
+        mkdirSync(join(testRoot, ".chapterhouse", "wiki", "pages", "topics", "orphan-updated"), { recursive: true });
+        writeFileSync(orphanPath, "# Orphan Updated\n", "utf-8");
+        utimesSync(orphanPath, orphanMtime, orphanMtime);
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_pages (path, title, tags, summary, last_updated)
+        VALUES (?, ?, ?, ?, ?)
+      `).run("pages/topics/coerced-updated/index.md", "Coerced Updated", "[]", "Missing updated value", "");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/pages`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const pages = await response.json();
+        assert.equal(pages.find((page) => page.path === "pages/topics/coerced-updated/index.md")?.updated, indexedMtime.toISOString());
+        assert.equal(pages.find((page) => page.path === "pages/topics/orphan-updated/index.md")?.updated, orphanMtime.toISOString());
+    });
+});
+test("GET /api/wiki/pages returns a non-empty updated value for pages with frontmatter", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const pageDir = join(testRoot, ".chapterhouse", "wiki", "pages", "projects", "frontmatter-updated");
+        mkdirSync(pageDir, { recursive: true });
+        writeFileSync(join(pageDir, "index.md"), `---
+title: Frontmatter Updated
+summary: Has explicit metadata.
+updated: 2026-05-14
+---
+
+# Frontmatter Updated
+`, "utf-8");
+        const response = await fetch(`${baseUrl}/api/wiki/pages`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const pages = await response.json();
+        const page = pages.find((entry) => entry.path === "pages/projects/frontmatter-updated/index.md");
+        assert.ok(page, "expected frontmatter page to be listed");
+        assert.equal(typeof page.updated, "string");
+        assert.notEqual(page.updated, "");
+    });
+});
 test("server projects route returns an empty list when the registry is missing", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
         const response = await fetch(`${baseUrl}/api/projects`, {
@@ -1469,8 +1627,157 @@ test("GET /api/wiki/korg/sessions returns grouped active research sessions", asy
                     id: "compiler-research",
                     name: "Compiler research",
                     source_count: 2,
-                    open_questions: 0,
-                    last_activity: "2026-05-14T22:00:00.000Z",
+                    open_questions_count: 0,
+                    last_activity_at: "2026-05-14T22:00:00.000Z",
+                },
+            ],
+        });
+    });
+});
+test("GET /api/wiki/sources returns an empty sources payload when no sources exist", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/wiki/sources`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        assert.deepEqual(body, { sources: [] });
+        assert.ok(wikiSourcesResponseSchema.safeParse(body).success, "response should match WikiSourcesResponseSchema");
+    });
+});
+test("GET /api/wiki/sources filters sources by page", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_sources (id, source_type, origin, title, ingested_at, raw_path, parsed_content, pages_updated, status, session_id, session_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run("src-filter-match", "pdf", "https://example.com/roadmap.pdf", "Roadmap", "2026-05-15T10:00:00.000Z", "sources/roadmap.pdf", "roadmap body", JSON.stringify(["pages/projects/wiki-api/index.md"]), "complete", "sess-1", "Wiki API");
+            db.prepare(`
+        INSERT INTO wiki_sources (id, source_type, origin, title, ingested_at, raw_path, parsed_content, pages_updated, status, session_id, session_name)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run("src-filter-miss", "text", "notes about another page", "Other", "2026-05-15T11:00:00.000Z", "sources/other.md", "other body", JSON.stringify(["pages/projects/other/index.md"]), "active", null, null);
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/sources?page=${encodeURIComponent("pages/projects/wiki-api/index.md")}`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        const parsed = wikiSourcesResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            assert.fail(parsed.error.message);
+        }
+        assert.deepEqual(parsed.data, {
+            sources: [
+                {
+                    source_url: "https://example.com/roadmap.pdf",
+                    path: "sources/roadmap.pdf",
+                    kind: "pdf",
+                    status: "complete",
+                    session_id: "sess-1",
+                    ingested_at: "2026-05-15T10:00:00.000Z",
+                },
+            ],
+        });
+    });
+});
+test("GET /api/wiki/links returns all links when no page filter is provided", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/projects/wiki-api/index.md", "pages/topics/contracts/index.md", "references", "2026-05-15T12:00:00.000Z");
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/people/trinity/index.md", "pages/projects/wiki-api/index.md", "implements", "2026-05-15T12:01:00.000Z");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/links`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        const parsed = wikiLinkResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            assert.fail(parsed.error.message);
+        }
+        assert.deepEqual(parsed.data, {
+            links: [
+                {
+                    source_slug: "trinity",
+                    target_slug: "wiki-api",
+                    link_type: "implements",
+                },
+                {
+                    source_slug: "wiki-api",
+                    target_slug: "contracts",
+                    link_type: "references",
+                },
+            ],
+        });
+    });
+});
+test("GET /api/wiki/links returns an empty typed links payload when a page has no graph edges", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/wiki/links?page=${encodeURIComponent("pages/projects/wiki-api/index.md")}`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        assert.deepEqual(body, { links: [] });
+        assert.ok(wikiLinkResponseSchema.safeParse(body).success, "response should match WikiLinksResponseSchema");
+    });
+});
+test("GET /api/wiki/links filters incoming and outgoing links for a page", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(getProjectDbPath(testRoot));
+        try {
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/projects/wiki-api/index.md", "pages/topics/contracts/index.md", "references", "2026-05-15T12:00:00.000Z");
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/people/trinity/index.md", "pages/projects/wiki-api/index.md", "implements", "2026-05-15T12:01:00.000Z");
+            db.prepare(`
+        INSERT INTO wiki_links (from_page, to_page, link_type, extracted_at)
+        VALUES (?, ?, ?, ?)
+      `).run("pages/projects/other/index.md", "pages/topics/unrelated/index.md", "references", "2026-05-15T12:02:00.000Z");
+        }
+        finally {
+            db.close();
+        }
+        const response = await fetch(`${baseUrl}/api/wiki/links?page=${encodeURIComponent("pages/projects/wiki-api/index.md")}`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const body = await response.json();
+        const parsed = wikiLinkResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            assert.fail(parsed.error.message);
+        }
+        assert.deepEqual(parsed.data, {
+            links: [
+                {
+                    source_slug: "trinity",
+                    target_slug: "wiki-api",
+                    link_type: "implements",
+                    direction: "incoming",
+                },
+                {
+                    source_slug: "wiki-api",
+                    target_slug: "contracts",
+                    link_type: "references",
+                    direction: "outgoing",
                 },
             ],
         });