chapterhouse 0.8.1 → 0.8.2

package/dist/api/server.js

@@ -16,8 +16,9 @@ import { createAuthMiddleware, getBootstrapAuthResponse } from "./auth.js";
 import { assertAgentEditAccess } from "./agent-edit-access.js";
 import { createConcurrentConnectionLimiter, createFixedWindowRateLimiter } from "./rate-limit.js";
 import { createTeamRouter } from "./team.js";
-import { writePage, deletePage, pageExists, listPages, ensureWikiStructure, assertPagePath, } from "../wiki/fs.js";
+import { writePage, deletePage, pageExists, listPages, ensureWikiStructure, assertPagePath, getWikiDir, } from "../wiki/fs.js";
 import { parseWikiFrontmatter } from "../wiki/frontmatter.js";
+import { normalizeWikiPath } from "../wiki/path-utils.js";
 import { loadRegistry, saveRegistry } from "../wiki/project-registry.js";
 import { getProjectRulesPath, listTopLevelSoftRules, loadProjectRules, loadProjectRuleSummary, renderInitialProjectRulesPage, saveProjectRulesHardFields, saveProjectRulesSoftRules, } from "../wiki/project-rules.js";
 import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
@@ -192,6 +193,78 @@ function createProjectDetailPayload(slug, cwd) {
         softRules: listTopLevelSoftRules(rules.soft),
     };
 }
+function coerceWikiPageUpdated(path, updated) {
+    const normalized = updated?.trim();
+    if (normalized) {
+        return normalized;
+    }
+    try {
+        return statSync(join(getWikiDir(), path)).mtime.toISOString();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function parseWikiSourcePages(value) {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed)
+            ? parsed.filter((entry) => typeof entry === "string").map((entry) => normalizeWikiPath(entry))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function listWikiSources(page) {
+    const rows = getDb().prepare(`
+    SELECT source_type, origin, raw_path, pages_updated, status, session_id, ingested_at
+    FROM wiki_sources
+    ORDER BY ingested_at DESC, id ASC
+  `).all();
+    return rows
+        .filter((row) => !page || parseWikiSourcePages(row.pages_updated).includes(page))
+        .map((row) => ({
+        source_url: row.origin,
+        path: row.raw_path ?? undefined,
+        kind: row.source_type,
+        status: row.status,
+        session_id: row.session_id,
+        ingested_at: row.ingested_at,
+    }));
+}
+function wikiPathToSlug(path) {
+    const segments = normalizeWikiPath(path).split("/").filter(Boolean);
+    const file = segments[segments.length - 1] ?? path;
+    const base = file.endsWith(".md") ? file.slice(0, -3) : file;
+    if (base === "index" && segments.length >= 2) {
+        return segments[segments.length - 2] ?? base;
+    }
+    return base;
+}
+function listWikiLinks(page) {
+    const rows = page
+        ? getDb().prepare(`
+      SELECT from_page, to_page, link_type
+      FROM wiki_links
+      WHERE from_page = ? OR to_page = ?
+      ORDER BY from_page ASC, to_page ASC, link_type ASC
+    `).all(page, page)
+        : getDb().prepare(`
+      SELECT from_page, to_page, link_type
+      FROM wiki_links
+      ORDER BY from_page ASC, to_page ASC, link_type ASC
+    `).all();
+    return rows.map((row) => ({
+        source_slug: wikiPathToSlug(row.from_page),
+        target_slug: wikiPathToSlug(row.to_page),
+        link_type: row.link_type,
+        ...(page ? { direction: row.from_page === page ? "outgoing" : "incoming" } : {}),
+    }));
+}
 // Load a configured API token when present; startup validation below enforces auth.
 let apiToken = null;
 try {
@@ -312,6 +385,13 @@ function readPathParam(req) {
     }
     return raw;
 }
+function readOptionalPageFilter(req) {
+    const raw = req.query.page;
+    if (typeof raw !== "string" || !raw.trim()) {
+        return undefined;
+    }
+    return normalizeWikiPath(raw.trim());
+}
 function assertValidPagePath(path) {
     try {
         assertPagePath(path);
@@ -1448,7 +1528,7 @@ app.get("/api/wiki/pages", async (req, res) => {
         summary: e.summary,
         section: e.section,
         tags: e.tags || [],
-        updated: e.updated || "",
+        updated: coerceWikiPageUpdated(e.path, e.updated),
         scope: getWikiPageScope(e.path),
     }));
     const orphanResults = listPages()
@@ -1459,11 +1539,19 @@ app.get("/api/wiki/pages", async (req, res) => {
         summary: "",
         section: "Unindexed",
         tags: [],
-        updated: "",
+        updated: coerceWikiPageUpdated(p, undefined),
         scope: getWikiPageScope(p),
     }));
     res.json([...indexedResults, ...orphanResults]);
 });
+app.get("/api/wiki/sources", async (req, res) => {
+    ensureWikiStructure();
+    res.json({ sources: listWikiSources(readOptionalPageFilter(req)) });
+});
+app.get("/api/wiki/links", async (req, res) => {
+    ensureWikiStructure();
+    res.json({ links: listWikiLinks(readOptionalPageFilter(req)) });
+});
 app.get("/api/wiki/page", async (req, res) => {
     const path = assertValidPagePath(readPathParam(req));
     const authorizationHeader = typeof req.headers.authorization === "string"

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");
 }
@@ -873,6 +891,60 @@ 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/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`, {
@@ -1476,4 +1548,153 @@ test("GET /api/wiki/korg/sessions returns grouped active research sessions", asy
         });
     });
 });
+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",
+                },
+            ],
+        });
+    });
+});
 //# sourceMappingURL=server.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"