chapterhouse 0.13.1 → 0.14.1

package/dist/memory/hooks.js

@@ -1,149 +0,0 @@
-import { childLogger } from "../util/logger.js";
-import { config } from "../config.js";
-import { getActiveScope } from "./active-scope.js";
-import { recordObservation } from "./observations.js";
-import { getScope } from "./scopes.js";
-const log = childLogger("memory.hooks");
-// ---------------------------------------------------------------------------
-// Env knob
-// ---------------------------------------------------------------------------
-function isHooksEnabled() {
-    return config.memoryHooksEnabled;
-}
-// ---------------------------------------------------------------------------
-// Dispatcher
-// ---------------------------------------------------------------------------
-export class MemoryHookDispatcher {
-    handlers = new Map();
-    register(event, handler) {
-        const bucket = this.handlers.get(event) ?? [];
-        bucket.push(handler);
-        this.handlers.set(event, bucket);
-    }
-    async dispatch(event, payload) {
-        if (!isHooksEnabled()) {
-            log.debug({ event }, "memory.hooks.skip.disabled");
-            return;
-        }
-        const bucket = this.handlers.get(event) ?? [];
-        if (bucket.length === 0) {
-            log.debug({ event }, "memory.hooks.no_handlers");
-            return;
-        }
-        log.info({ event, handlerCount: bucket.length }, "memory.hooks.dispatch");
-        for (const handler of bucket) {
-            try {
-                await handler(payload);
-            }
-            catch (err) {
-                log.error({ err, event }, "memory.hooks.handler_error");
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Singleton dispatcher — shared across the process
-// ---------------------------------------------------------------------------
-export const hookDispatcher = new MemoryHookDispatcher();
-// ---------------------------------------------------------------------------
-// Built-in handler: git:commit → observation in active scope
-// ---------------------------------------------------------------------------
-function buildGitCommitContent(payload) {
-    const lines = [`Git commit: ${payload.message}`];
-    if (payload.stat?.trim()) {
-        lines.push("", "Changed files:", payload.stat.trim());
-    }
-    return lines.join("\n");
-}
-function resolveGlobalOrActiveScope() {
-    const active = getActiveScope();
-    if (active)
-        return active;
-    return getScope("global") ?? null;
-}
-export async function handleGitCommitHook(payload) {
-    if (!isHooksEnabled()) {
-        log.debug("memory.hooks.git_commit.disabled");
-        return { observation_id: "disabled" };
-    }
-    const scope = resolveGlobalOrActiveScope();
-    if (!scope) {
-        throw new Error("No active or global memory scope found. Create a scope before using memory hooks.");
-    }
-    const content = buildGitCommitContent(payload);
-    const observation = recordObservation({
-        scope_id: scope.id,
-        content,
-        source: "git:commit",
-        tier: "warm",
-        confidence: 1.0,
-    });
-    log.info({ scope: scope.slug, observation_id: observation.id }, "memory.hooks.git_commit.recorded");
-    return { observation_id: String(observation.id) };
-}
-// ---------------------------------------------------------------------------
-// Built-in handler: pr:merge → observation
-// ---------------------------------------------------------------------------
-function buildPrMergeContent(payload) {
-    const lines = [`PR #${payload.number} merged: ${payload.title}`];
-    if (payload.body?.trim()) {
-        lines.push("", payload.body.trim());
-    }
-    if (payload.files_changed && payload.files_changed.length > 0) {
-        lines.push("", "Files changed:");
-        for (const file of payload.files_changed) {
-            lines.push(`  ${file}`);
-        }
-    }
-    return lines.join("\n");
-}
-export async function handlePrMergeHook(payload) {
-    if (!isHooksEnabled()) {
-        log.debug("memory.hooks.pr_merge.disabled");
-        return { observation_id: "disabled" };
-    }
-    const scope = resolveGlobalOrActiveScope();
-    if (!scope) {
-        throw new Error("No active or global memory scope found. Create a scope before using memory hooks.");
-    }
-    const content = buildPrMergeContent(payload);
-    const observation = recordObservation({
-        scope_id: scope.id,
-        content,
-        source: "pr:merge",
-        tier: "warm",
-        confidence: 1.0,
-    });
-    log.info({ scope: scope.slug, observation_id: observation.id, pr: payload.number }, "memory.hooks.pr_merge.recorded");
-    return { observation_id: String(observation.id) };
-}
-// ---------------------------------------------------------------------------
-// Built-in handler: scope:created → observation in global scope
-// ---------------------------------------------------------------------------
-hookDispatcher.register("scope:created", async (payload) => {
-    const globalScope = getScope("global");
-    if (!globalScope) {
-        log.debug("memory.hooks.scope_created.no_global_scope");
-        return;
-    }
-    const content = `Scope '${payload.slug}' created: ${payload.description || payload.title}`;
-    const observation = recordObservation({
-        scope_id: globalScope.id,
-        content,
-        source: "scope:created",
-        tier: "warm",
-        confidence: 1.0,
-    });
-    log.info({ scope: payload.slug, observation_id: observation.id }, "memory.hooks.scope_created.recorded");
-});
-// ---------------------------------------------------------------------------
-// Built-in handler: memory:decision → structured log event
-// ---------------------------------------------------------------------------
-hookDispatcher.register("memory:decision", async (payload) => {
-    log.info({
-        decision_id: payload.id,
-        scope_id: payload.scope_id,
-        title: payload.title,
-    }, "memory.hooks.decision.recorded");
-});
-//# sourceMappingURL=hooks.js.map

package/dist/memory/hooks.test.js

@@ -1,325 +0,0 @@
-import assert from "node:assert/strict";
-import { spawn } from "node:child_process";
-import { mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, ".test-work", `memory-hooks-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(chapterhouseHome, { recursive: true });
-}
-async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
-    const hooksModule = await import(new URL(`./hooks.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, hooksModule };
-}
-function getFunction(module, name) {
-    const value = module[name];
-    assert.equal(typeof value, "function", `expected ${name} to be exported`);
-    return value;
-}
-test.beforeEach(async () => {
-    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-    delete process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    resetSandbox();
-});
-test.after(async () => {
-    delete process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-// ---------------------------------------------------------------------------
-// MemoryHookDispatcher — basic register/dispatch
-// ---------------------------------------------------------------------------
-test("MemoryHookDispatcher dispatches to registered handlers", async () => {
-    const { hooksModule } = await loadModules("dispatch-basic");
-    const MemoryHookDispatcher = hooksModule["MemoryHookDispatcher"];
-    assert.ok(MemoryHookDispatcher, "MemoryHookDispatcher should be exported");
-    const dispatcher = new MemoryHookDispatcher();
-    const received = [];
-    dispatcher.register("git:commit", async (payload) => { received.push(payload); });
-    await dispatcher.dispatch("git:commit", { message: "initial commit", stat: "1 file changed" });
-    assert.equal(received.length, 1);
-    assert.deepEqual(received[0], { message: "initial commit", stat: "1 file changed" });
-});
-test("MemoryHookDispatcher dispatches to multiple handlers for same event", async () => {
-    const { hooksModule } = await loadModules("dispatch-multi");
-    const MemoryHookDispatcher = hooksModule["MemoryHookDispatcher"];
-    const dispatcher = new MemoryHookDispatcher();
-    let callCount = 0;
-    dispatcher.register("pr:merge", async () => { callCount++; });
-    dispatcher.register("pr:merge", async () => { callCount++; });
-    await dispatcher.dispatch("pr:merge", { number: 42, title: "feat: something" });
-    assert.equal(callCount, 2);
-});
-test("MemoryHookDispatcher is no-op when CHAPTERHOUSE_MEMORY_HOOKS_ENABLED=false", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED = "false";
-    const { hooksModule } = await loadModules("dispatch-disabled-false");
-    const MemoryHookDispatcher = hooksModule["MemoryHookDispatcher"];
-    const dispatcher = new MemoryHookDispatcher();
-    let called = false;
-    dispatcher.register("git:commit", async () => { called = true; });
-    await dispatcher.dispatch("git:commit", { message: "disabled test" });
-    assert.equal(called, false);
-});
-test("MemoryHookDispatcher is no-op when CHAPTERHOUSE_MEMORY_HOOKS_ENABLED=0", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED = "0";
-    const { hooksModule } = await loadModules("dispatch-disabled-zero");
-    const MemoryHookDispatcher = hooksModule["MemoryHookDispatcher"];
-    const dispatcher = new MemoryHookDispatcher();
-    let called = false;
-    dispatcher.register("pr:merge", async () => { called = true; });
-    await dispatcher.dispatch("pr:merge", { number: 1, title: "test" });
-    assert.equal(called, false);
-});
-test("MemoryHookDispatcher handler errors don't propagate to caller", async () => {
-    const { hooksModule } = await loadModules("dispatch-error-swallow");
-    const MemoryHookDispatcher = hooksModule["MemoryHookDispatcher"];
-    const dispatcher = new MemoryHookDispatcher();
-    dispatcher.register("git:commit", async () => { throw new Error("handler blew up"); });
-    await assert.doesNotReject(dispatcher.dispatch("git:commit", { message: "safe?" }));
-});
-// ---------------------------------------------------------------------------
-// handleGitCommitHook — writes observation to DB
-// ---------------------------------------------------------------------------
-test("handleGitCommitHook records an observation in the active/global scope", async () => {
-    const { dbModule, memoryModule, hooksModule } = await loadModules("git-commit-hook");
-    dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const handleGitCommitHook = getFunction(hooksModule, "handleGitCommitHook");
-    const globalScope = getScope("global");
-    assert.ok(globalScope, "global scope must exist after DB init");
-    const result = await handleGitCommitHook({ message: "feat: add hooks", stat: "src/memory/hooks.ts | 5 ++" });
-    assert.ok(result.observation_id);
-    assert.notEqual(result.observation_id, "disabled");
-    const observations = listObservations({ scope_id: globalScope.id, limit: 10 });
-    const found = observations.find((obs) => obs.source === "git:commit" && obs.content.includes("feat: add hooks"));
-    assert.ok(found, "observation should be recorded with source git:commit");
-    assert.ok(found.content.includes("Changed files:"), "content should include changed files section");
-});
-test("handleGitCommitHook returns disabled when CHAPTERHOUSE_MEMORY_HOOKS_ENABLED=false", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED = "false";
-    const { dbModule, hooksModule } = await loadModules("git-commit-hook-disabled");
-    dbModule.getDb();
-    const handleGitCommitHook = getFunction(hooksModule, "handleGitCommitHook");
-    const result = await handleGitCommitHook({ message: "should not be recorded" });
-    assert.equal(result.observation_id, "disabled");
-});
-// ---------------------------------------------------------------------------
-// handlePrMergeHook
-// ---------------------------------------------------------------------------
-test("handlePrMergeHook records an observation with PR details", async () => {
-    const { dbModule, memoryModule, hooksModule } = await loadModules("pr-merge-hook");
-    dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const handlePrMergeHook = getFunction(hooksModule, "handlePrMergeHook");
-    const globalScope = getScope("global");
-    assert.ok(globalScope, "global scope must exist");
-    const result = await handlePrMergeHook({
-        number: 42,
-        title: "feat(memory): event hooks",
-        body: "Implements Sprint 1 Track A",
-        files_changed: ["src/memory/hooks.ts", "src/memory/index.ts"],
-    });
-    assert.ok(result.observation_id);
-    assert.notEqual(result.observation_id, "disabled");
-    const observations = listObservations({ scope_id: globalScope.id, limit: 10 });
-    const found = observations.find((obs) => obs.source === "pr:merge" && obs.content.includes("PR #42"));
-    assert.ok(found, "observation should record PR number");
-    assert.ok(found.content.includes("feat(memory): event hooks"), "content should include PR title");
-    assert.ok(found.content.includes("src/memory/hooks.ts"), "content should list changed files");
-});
-// ---------------------------------------------------------------------------
-// scope:created hook (fires from hookDispatcher after createScope)
-// ---------------------------------------------------------------------------
-test("scope:created handler writes observation to global scope", async () => {
-    const { dbModule, memoryModule, hooksModule } = await loadModules("scope-created");
-    dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const hookDispatcher = hooksModule["hookDispatcher"];
-    assert.ok(hookDispatcher, "hookDispatcher should be exported");
-    const globalScope = getScope("global");
-    assert.ok(globalScope, "global scope must exist");
-    await hookDispatcher.dispatch("scope:created", {
-        slug: "my-project",
-        title: "My Project",
-        description: "A test project scope",
-    });
-    const observations = listObservations({ scope_id: globalScope.id, limit: 10 });
-    const found = observations.find((obs) => obs.source === "scope:created" && obs.content.includes("my-project"));
-    assert.ok(found, "scope creation observation should be written to global scope");
-    assert.ok(found.content.includes("A test project scope"), "content should include description");
-});
-test("scope:created hook is no-op when CHAPTERHOUSE_MEMORY_HOOKS_ENABLED=0", async () => {
-    process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED = "0";
-    const { dbModule, memoryModule, hooksModule } = await loadModules("scope-created-disabled");
-    dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const listObservations = getFunction(memoryModule, "listObservations");
-    const hookDispatcher = hooksModule["hookDispatcher"];
-    const globalScope = getScope("global");
-    assert.ok(globalScope, "global scope must exist");
-    const before = listObservations({ scope_id: globalScope.id, limit: 100 });
-    await hookDispatcher.dispatch("scope:created", { slug: "silent", title: "Silent", description: "should not persist" });
-    const after = listObservations({ scope_id: globalScope.id, limit: 100 });
-    assert.equal(after.length, before.length, "no new observations when hooks disabled");
-});
-// ---------------------------------------------------------------------------
-// API endpoints — integration tests using a spawned server
-// ---------------------------------------------------------------------------
-async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
-    const testRoot = join(repoRoot, ".test-work", `hooks-api-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(testRoot, { recursive: true, force: true });
-    mkdirSync(testRoot, { recursive: true });
-    const port = await getFreePort();
-    const logs = [];
-    const child = spawn(process.execPath, [
-        "--input-type=module",
-        "-e",
-        "import { startApiServer } from './dist/api/server.js'; await startApiServer();",
-    ], {
-        cwd: repoRoot,
-        env: {
-            ...Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith("COPILOT_"))),
-            CHAPTERHOUSE_DISABLE_DOTENV: "1",
-            CHAPTERHOUSE_HOME: testRoot,
-            API_HOST: "127.0.0.1",
-            API_PORT: String(port),
-            API_TOKEN: "hooks-test-token",
-            ...extraEnv,
-        },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    child.stdout?.on("data", (chunk) => logs.push(String(chunk)));
-    child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
-    const baseUrl = `http://127.0.0.1:${port}`;
-    try {
-        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
-        await run({ baseUrl, authHeader: "Bearer hooks-test-token", testRoot });
-    }
-    finally {
-        await stopChild(child);
-        rmSync(testRoot, { recursive: true, force: true });
-    }
-}
-test("POST /api/memory/hooks/git-commit returns ok with observation_id", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/git-commit`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: authHeader },
-            body: JSON.stringify({ message: "feat: test commit", stat: "1 file changed, 5 insertions" }),
-        });
-        assert.equal(response.status, 200, `Expected 200, got ${response.status}`);
-        const body = await response.json();
-        assert.equal(body.ok, true);
-        assert.ok(typeof body.observation_id === "string" && body.observation_id.length > 0, "observation_id should be returned");
-    });
-});
-test("POST /api/memory/hooks/git-commit validates required message field", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/git-commit`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: authHeader },
-            body: JSON.stringify({ stat: "no message field" }),
-        });
-        assert.equal(response.status, 400, `Expected 400, got ${response.status}`);
-    });
-});
-test("POST /api/memory/hooks/pr-merge returns ok with observation_id", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/pr-merge`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: authHeader },
-            body: JSON.stringify({
-                number: 99,
-                title: "feat: test PR",
-                body: "Adds some feature",
-                files_changed: ["src/foo.ts", "src/bar.ts"],
-            }),
-        });
-        assert.equal(response.status, 200, `Expected 200, got ${response.status}`);
-        const body = await response.json();
-        assert.equal(body.ok, true);
-        assert.ok(typeof body.observation_id === "string" && body.observation_id.length > 0, "observation_id should be returned");
-    });
-});
-test("POST /api/memory/hooks/pr-merge validates required fields", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/pr-merge`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: authHeader },
-            body: JSON.stringify({ title: "missing number" }),
-        });
-        assert.equal(response.status, 400, `Expected 400, got ${response.status}`);
-    });
-});
-// ---------------------------------------------------------------------------
-// Auth enforcement on hook endpoints — Bug #334
-// ---------------------------------------------------------------------------
-test("POST /api/memory/hooks/git-commit returns 401 without auth token", async () => {
-    await withStartedServer(async ({ baseUrl }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/git-commit`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ message: "unauthorized commit" }),
-        });
-        assert.equal(response.status, 401, `Expected 401, got ${response.status}`);
-    });
-});
-test("POST /api/memory/hooks/git-commit returns 401 with wrong auth token", async () => {
-    await withStartedServer(async ({ baseUrl }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/git-commit`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: "Bearer wrong-token" },
-            body: JSON.stringify({ message: "bad token commit" }),
-        });
-        assert.equal(response.status, 401, `Expected 401, got ${response.status}`);
-    });
-});
-test("POST /api/memory/hooks/pr-merge returns 401 without auth token", async () => {
-    await withStartedServer(async ({ baseUrl }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/pr-merge`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ number: 1, title: "unauthorized PR" }),
-        });
-        assert.equal(response.status, 401, `Expected 401, got ${response.status}`);
-    });
-});
-test("POST /api/memory/hooks/pr-merge returns 401 with wrong auth token", async () => {
-    await withStartedServer(async ({ baseUrl }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/pr-merge`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: "Bearer wrong-token" },
-            body: JSON.stringify({ number: 1, title: "bad token PR" }),
-        });
-        assert.equal(response.status, 401, `Expected 401, got ${response.status}`);
-    });
-});
-test("POST /api/memory/hooks/git-commit is no-op when CHAPTERHOUSE_MEMORY_HOOKS_ENABLED=false", async () => {
-    await withStartedServer(async ({ baseUrl, authHeader }) => {
-        const response = await fetch(`${baseUrl}/api/memory/hooks/git-commit`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json", Authorization: authHeader },
-            body: JSON.stringify({ message: "should be disabled" }),
-        });
-        assert.equal(response.status, 200, `Expected 200, got ${response.status}`);
-        const body = await response.json();
-        assert.equal(body.ok, true);
-        assert.equal(body.observation_id, "disabled", "observation_id should be 'disabled' when hooks are off");
-    }, { CHAPTERHOUSE_MEMORY_HOOKS_ENABLED: "0" });
-});
-//# sourceMappingURL=hooks.test.js.map