nlm-memory 0.4.0

package/tests/integration/hook-claude-settings.test.ts

@@ -0,0 +1,205 @@
+import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  addHook,
+  buildHookCommand,
+  removeHook,
+  shellQuote,
+  smokeTestHookCommand,
+} from "../../src/core/hook/claude-settings.js";
+
+interface Settings {
+  hooks?: {
+    UserPromptSubmit?: Array<{ hooks: Array<{ type: string; command: string }> }>;
+    PostToolUse?: Array<{ hooks: Array<{ type: string; command: string }> }>;
+    SessionEnd?: Array<{ hooks: Array<{ type: string; command: string }> }>;
+    [event: string]: Array<{ hooks: Array<{ type: string; command: string }> }> | undefined;
+  };
+}
+
+describe("claude-settings hook editor", () => {
+  let tmp: string;
+  let settingsPath: string;
+  const CMD = "NLM_HOOK_MODE=shadow node /abs/dist/hook/prompt-recall-hook.js";
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "nlm-settings-"));
+    settingsPath = join(tmp, "settings.json");
+  });
+
+  afterEach(() => rmSync(tmp, { recursive: true, force: true }));
+
+  it("creates settings.json with the hook entry when the file is absent", () => {
+    addHook(settingsPath, CMD);
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
+    const entries = s.hooks?.UserPromptSubmit ?? [];
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.hooks[0]?.command).toBe(CMD);
+  });
+
+  it("preserves unrelated existing settings and hooks", () => {
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({
+        model: "sonnet",
+        hooks: { UserPromptSubmit: [{ hooks: [{ type: "command", command: "other-tool" }] }] },
+      }),
+      "utf8",
+    );
+    addHook(settingsPath, CMD);
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings & { model?: string };
+    expect(s.model).toBe("sonnet");
+    const cmds = (s.hooks?.UserPromptSubmit ?? []).flatMap((e) => e.hooks.map((h) => h.command));
+    expect(cmds).toContain("other-tool");
+    expect(cmds).toContain(CMD);
+  });
+
+  it("is idempotent — re-adding does not duplicate the nlm entry", () => {
+    addHook(settingsPath, CMD);
+    addHook(settingsPath, "NLM_HOOK_MODE=live node /abs/dist/hook/prompt-recall-hook.js");
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
+    const cmds = (s.hooks?.UserPromptSubmit ?? []).flatMap((e) => e.hooks.map((h) => h.command));
+    const nlmCmds = cmds.filter((c) => c.includes("prompt-recall-hook.js"));
+    expect(nlmCmds).toHaveLength(1);
+    expect(nlmCmds[0]).toContain("NLM_HOOK_MODE=live");
+  });
+
+  it("removeHook removes only the nlm entry and leaves others intact", () => {
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({
+        hooks: { UserPromptSubmit: [{ hooks: [{ type: "command", command: "other-tool" }] }] },
+      }),
+      "utf8",
+    );
+    addHook(settingsPath, CMD);
+    removeHook(settingsPath);
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
+    const cmds = (s.hooks?.UserPromptSubmit ?? []).flatMap((e) => e.hooks.map((h) => h.command));
+    expect(cmds).toEqual(["other-tool"]);
+  });
+
+  it("removeHook is a no-op when settings.json does not exist", () => {
+    expect(() => removeHook(settingsPath)).not.toThrow();
+  });
+
+  it("removeHook of the only nlm entry leaves no empty UserPromptSubmit litter", () => {
+    addHook(settingsPath, CMD);
+    removeHook(settingsPath);
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
+    expect(s.hooks?.UserPromptSubmit).toBeUndefined();
+  });
+
+  function shEcho(s: string): string {
+    return spawnSync("sh", ["-c", `echo ${s}`], { encoding: "utf8" }).stdout.trim();
+  }
+
+  it("shellQuote wraps paths with spaces so sh -c keeps them as one arg", () => {
+    const pathWithSpace = "/Users/echalupa/Documents/Coding Projects/foo/bar.js";
+    expect(shEcho(shellQuote(pathWithSpace))).toBe(pathWithSpace);
+  });
+
+  it("shellQuote escapes embedded single quotes", () => {
+    const tricky = "/path/with'quote/file.js";
+    expect(shEcho(shellQuote(tricky))).toBe(tricky);
+  });
+
+  it("buildHookCommand quotes both paths", () => {
+    const cmd = buildHookCommand(
+      "/usr/local/bin/node",
+      "/Users/echalupa/Documents/Coding Projects/nlm/dist/hook/prompt-recall-hook.js",
+      "shadow",
+    );
+    expect(cmd).toBe(
+      "NLM_HOOK_MODE=shadow '/usr/local/bin/node' '/Users/echalupa/Documents/Coding Projects/nlm/dist/hook/prompt-recall-hook.js'",
+    );
+  });
+
+  it("smokeTestHookCommand reports failure when command exits nonzero", () => {
+    const logPath = join(tmp, "hook-log.jsonl");
+    const result = smokeTestHookCommand("exit 1", logPath);
+    expect(result.ok).toBe(false);
+    expect(result.reason).toContain("exit code 1");
+  });
+
+  it("smokeTestHookCommand reports failure when log does not gain an entry", () => {
+    const logPath = join(tmp, "hook-log.jsonl");
+    const result = smokeTestHookCommand("true", logPath);
+    expect(result.ok).toBe(false);
+    expect(result.reason).toContain("no entry appended");
+  });
+
+  it("smokeTestHookCommand passes when command writes to the log", () => {
+    const logPath = join(tmp, "hook-log.jsonl");
+    const result = smokeTestHookCommand(
+      `printf '{"ts":"x"}\\n' >> ${shellQuote(logPath)}`,
+      logPath,
+    );
+    expect(result.ok).toBe(true);
+    expect(statSync(logPath).size).toBeGreaterThan(0);
+  });
+
+  it("addHook preserves an unrelated hook event key", () => {
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({
+        hooks: { PostToolUse: [{ hooks: [{ type: "command", command: "other-event" }] }] },
+      }),
+      "utf8",
+    );
+    addHook(settingsPath, CMD);
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
+    expect(s.hooks?.PostToolUse).toHaveLength(1);
+    const ups = s.hooks?.UserPromptSubmit ?? [];
+    const cmds = ups.flatMap((e) => e.hooks.map((h) => h.command));
+    expect(cmds).toContain(CMD);
+  });
+
+  it("addHook installs under a non-default event when specified", () => {
+    const sessionEndCmd = "node /abs/dist/hook/session-end-hook.js";
+    addHook(settingsPath, sessionEndCmd, "SessionEnd");
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings & {
+      hooks?: { SessionEnd?: Array<{ hooks: Array<{ command: string }> }> };
+    };
+    expect(s.hooks?.UserPromptSubmit).toBeUndefined();
+    expect(s.hooks?.SessionEnd).toHaveLength(1);
+    expect(s.hooks?.SessionEnd?.[0]?.hooks[0]?.command).toBe(sessionEndCmd);
+  });
+
+  it("addHook can hold separate NLM entries on two event keys without collision", () => {
+    addHook(settingsPath, CMD, "UserPromptSubmit");
+    const sessionEndCmd = "node /abs/dist/hook/session-end-hook.js";
+    addHook(settingsPath, sessionEndCmd, "SessionEnd");
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings & {
+      hooks?: { SessionEnd?: Array<{ hooks: Array<{ command: string }> }> };
+    };
+    expect(s.hooks?.UserPromptSubmit).toHaveLength(1);
+    expect(s.hooks?.SessionEnd).toHaveLength(1);
+  });
+
+  it("removeHook with event='*' clears the NLM entry from every event", () => {
+    addHook(settingsPath, CMD, "UserPromptSubmit");
+    const sessionEndCmd = "node /abs/dist/hook/session-end-hook.js";
+    addHook(settingsPath, sessionEndCmd, "SessionEnd");
+    // Also add an unrelated PostToolUse entry to confirm we don't touch it.
+    writeFileSync(
+      settingsPath,
+      JSON.stringify({
+        hooks: {
+          UserPromptSubmit: [{ hooks: [{ type: "command", command: CMD }] }],
+          SessionEnd: [{ hooks: [{ type: "command", command: sessionEndCmd }] }],
+          PostToolUse: [{ hooks: [{ type: "command", command: "other-tool" }] }],
+        },
+      }),
+      "utf8",
+    );
+    removeHook(settingsPath, "*");
+    const s = JSON.parse(readFileSync(settingsPath, "utf8")) as Settings;
+    expect(s.hooks?.UserPromptSubmit).toBeUndefined();
+    expect(s.hooks?.SessionEnd).toBeUndefined();
+    expect(s.hooks?.PostToolUse).toHaveLength(1);
+  });
+});

package/tests/integration/hook-log.test.ts

@@ -0,0 +1,54 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { appendHookLog, type HookLogEntry } from "../../src/core/hook/hook-log.js";
+
+const entry = (over: Partial<HookLogEntry> = {}): HookLogEntry => ({
+  ts: "2026-05-20T12:00:00.000Z",
+  conversationId: "conv-1",
+  promptPreview: "what did we decide about pgvector",
+  gate: "evaluate",
+  hits: [{ id: "sess_a", score: 0.9 }],
+  wouldInject: ["sess_a"],
+  estTokens: 42,
+  mode: "shadow",
+  ...over,
+});
+
+describe("appendHookLog", () => {
+  let tmp: string;
+  let logPath: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "nlm-hooklog-"));
+    logPath = join(tmp, "hook-log.jsonl");
+    process.env["NLM_HOOK_LOG"] = logPath;
+  });
+
+  afterEach(() => {
+    delete process.env["NLM_HOOK_LOG"];
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("appends one JSON line per call", () => {
+    appendHookLog(entry());
+    appendHookLog(entry({ conversationId: "conv-2" }));
+    const lines = readFileSync(logPath, "utf8").trim().split("\n");
+    expect(lines).toHaveLength(2);
+    const first = JSON.parse(lines[0] ?? "");
+    expect(first.conversationId).toBe("conv-1");
+    expect(first.wouldInject).toEqual(["sess_a"]);
+    expect(first.estTokens).toBe(42);
+  });
+
+  it("creates the parent directory if missing", () => {
+    process.env["NLM_HOOK_LOG"] = join(tmp, "nested", "deep", "hook-log.jsonl");
+    appendHookLog(entry());
+    const lines = readFileSync(
+      join(tmp, "nested", "deep", "hook-log.jsonl"),
+      "utf8",
+    ).trim().split("\n");
+    expect(lines).toHaveLength(1);
+  });
+});

package/tests/integration/hook-memo.test.ts

@@ -0,0 +1,68 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { clearSurfaced, loadSurfaced, recordSurfaced } from "../../src/core/hook/memo.js";
+
+describe("hook memo", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "nlm-memo-"));
+    process.env["NLM_HOOK_STATE_DIR"] = tmp;
+  });
+
+  afterEach(() => {
+    delete process.env["NLM_HOOK_STATE_DIR"];
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("returns an empty set for an unknown conversation", () => {
+    expect(loadSurfaced("conv-1").size).toBe(0);
+  });
+
+  it("records and reloads surfaced ids", () => {
+    recordSurfaced("conv-1", ["sess_a", "sess_b"]);
+    const got = loadSurfaced("conv-1");
+    expect([...got].sort()).toEqual(["sess_a", "sess_b"]);
+  });
+
+  it("accumulates across multiple records and dedups", () => {
+    recordSurfaced("conv-1", ["sess_a"]);
+    recordSurfaced("conv-1", ["sess_a", "sess_c"]);
+    expect([...loadSurfaced("conv-1")].sort()).toEqual(["sess_a", "sess_c"]);
+  });
+
+  it("isolates conversations from each other", () => {
+    recordSurfaced("conv-1", ["sess_a"]);
+    recordSurfaced("conv-2", ["sess_z"]);
+    expect([...loadSurfaced("conv-1")]).toEqual(["sess_a"]);
+    expect([...loadSurfaced("conv-2")]).toEqual(["sess_z"]);
+  });
+
+  it("loadSurfaced returns empty on a corrupt memo file rather than throwing", () => {
+    recordSurfaced("conv-1", ["sess_a"]);
+    // overwrite with garbage
+    writeFileSync(join(tmp, "conv-1.json"), "{not json", "utf8");
+    expect(loadSurfaced("conv-1").size).toBe(0);
+  });
+
+  it("clearSurfaced deletes the memo file and returns true", () => {
+    recordSurfaced("conv-1", ["sess_a"]);
+    expect(loadSurfaced("conv-1").size).toBe(1);
+    expect(clearSurfaced("conv-1")).toBe(true);
+    expect(loadSurfaced("conv-1").size).toBe(0);
+  });
+
+  it("clearSurfaced returns false when no memo file exists", () => {
+    expect(clearSurfaced("never-existed")).toBe(false);
+  });
+
+  it("clearSurfaced isolates conversations — only deletes the targeted one", () => {
+    recordSurfaced("conv-1", ["sess_a"]);
+    recordSurfaced("conv-2", ["sess_b"]);
+    clearSurfaced("conv-1");
+    expect(loadSurfaced("conv-1").size).toBe(0);
+    expect([...loadSurfaced("conv-2")]).toEqual(["sess_b"]);
+  });
+});

package/tests/integration/hook-pre-compact.test.ts

@@ -0,0 +1,105 @@
+/**
+ * POST /api/hook/pre-compact endpoint integration.
+ * Verifies memo flush, compacted_at response, and hook-log append.
+ */
+
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { Hono } from "hono";
+import { RecallService } from "../../src/core/recall/recall-service.js";
+import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
+import { createApp } from "../../src/http/app.js";
+import type { EmbedResult, LLMClient } from "../../src/ports/llm-client.js";
+
+const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
+
+class FixedEmbedder implements LLMClient {
+  async embed(): Promise<EmbedResult> {
+    return { vector: new Float32Array(768), model: "fixed-test" };
+  }
+  async classify(): Promise<never> {
+    throw new Error("not used");
+  }
+}
+
+describe("POST /api/hook/pre-compact", () => {
+  let tmp: string;
+  let store: SqliteSessionStore;
+  let app: Hono;
+  let hookLogPath: string;
+  let hookStateDir: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "nlm-pre-compact-"));
+    store = new SqliteSessionStore({
+      dbPath: join(tmp, "canonical.sqlite"),
+      migrationsDir: MIGRATIONS_DIR,
+    });
+    const recall = new RecallService({ store, llm: new FixedEmbedder() });
+    hookLogPath = join(tmp, "hook-log.jsonl");
+    hookStateDir = join(tmp, "hook-state");
+    process.env["NLM_HOOK_LOG"] = hookLogPath;
+    process.env["NLM_HOOK_STATE_DIR"] = hookStateDir;
+    app = createApp({ recall, store, liveStore: store });
+  });
+
+  afterEach(() => {
+    store.close();
+    delete process.env["NLM_HOOK_LOG"];
+    delete process.env["NLM_HOOK_STATE_DIR"];
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("returns ok:true with flushed count and compacted_at", async () => {
+    const res = await app.request("/api/hook/pre-compact", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ conversation_id: "conv_abc123" }),
+    });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as Record<string, unknown>;
+    expect(json["ok"]).toBe(true);
+    expect(typeof json["flushed"]).toBe("number");
+    expect(typeof json["compacted_at"]).toBe("string");
+  });
+
+  it("flushes the surfaced-ID memo file for the conversation", async () => {
+    // Seed a memo file so there's something to flush.
+    mkdirSync(hookStateDir, { recursive: true });
+    writeFileSync(join(hookStateDir, "conv_abc123.json"), JSON.stringify(["sess_a", "sess_b"]), "utf8");
+
+    const res = await app.request("/api/hook/pre-compact", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ conversation_id: "conv_abc123" }),
+    });
+    const json = (await res.json()) as Record<string, unknown>;
+    expect(json["flushed"]).toBe(2);
+    expect(existsSync(join(hookStateDir, "conv_abc123.json"))).toBe(false);
+  });
+
+  it("appends a pre-compact entry to hook-log.jsonl", async () => {
+    await app.request("/api/hook/pre-compact", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ conversation_id: "conv_abc123" }),
+    });
+    expect(existsSync(hookLogPath)).toBe(true);
+    const lines = readFileSync(hookLogPath, "utf8").trim().split("\n");
+    const entry = JSON.parse(lines[0]!) as Record<string, unknown>;
+    expect(entry["kind"]).toBe("pre-compact");
+    expect(entry["conversationId"]).toBe("conv_abc123");
+    expect(typeof entry["flushed"]).toBe("number");
+  });
+
+  it("returns 400 when conversation_id is missing", async () => {
+    const res = await app.request("/api/hook/pre-compact", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    expect(res.status).toBe(400);
+  });
+});

package/tests/integration/hook-subagent-start.test.ts

@@ -0,0 +1,102 @@
+/**
+ * POST /api/hook/subagent-start endpoint integration.
+ * Verifies the parent→subagent link is appended to subagent-log.jsonl.
+ */
+
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { Hono } from "hono";
+import { RecallService } from "../../src/core/recall/recall-service.js";
+import { SqliteSessionStore } from "../../src/core/storage/sqlite-session-store.js";
+import { createApp } from "../../src/http/app.js";
+import type { EmbedResult, LLMClient } from "../../src/ports/llm-client.js";
+
+const MIGRATIONS_DIR = resolve(__dirname, "../../migrations");
+
+class FixedEmbedder implements LLMClient {
+  async embed(): Promise<EmbedResult> {
+    return { vector: new Float32Array(768), model: "fixed-test" };
+  }
+  async classify(): Promise<never> {
+    throw new Error("not used");
+  }
+}
+
+describe("POST /api/hook/subagent-start", () => {
+  let tmp: string;
+  let store: SqliteSessionStore;
+  let app: Hono;
+  let subagentLogPath: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "nlm-subagent-start-"));
+    store = new SqliteSessionStore({
+      dbPath: join(tmp, "canonical.sqlite"),
+      migrationsDir: MIGRATIONS_DIR,
+    });
+    const recall = new RecallService({ store, llm: new FixedEmbedder() });
+    subagentLogPath = join(tmp, "subagent-log.jsonl");
+    process.env["NLM_SUBAGENT_LOG"] = subagentLogPath;
+    app = createApp({ recall, store, liveStore: store });
+  });
+
+  afterEach(() => {
+    store.close();
+    delete process.env["NLM_SUBAGENT_LOG"];
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("returns ok:true and recorded:true", async () => {
+    const res = await app.request("/api/hook/subagent-start", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        parent_conversation_id: "conv_parent_001",
+        subagent_session_id: "conv_sub_abc123",
+        subagent_description: "Run the content audit skill",
+      }),
+    });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as Record<string, unknown>;
+    expect(json["ok"]).toBe(true);
+    expect(json["recorded"]).toBe(true);
+  });
+
+  it("appends the parent→subagent link to subagent-log.jsonl", async () => {
+    await app.request("/api/hook/subagent-start", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        parent_conversation_id: "conv_parent_001",
+        subagent_session_id: "conv_sub_abc123",
+        subagent_description: "Run the content audit skill",
+      }),
+    });
+    expect(existsSync(subagentLogPath)).toBe(true);
+    const lines = readFileSync(subagentLogPath, "utf8").trim().split("\n");
+    const entry = JSON.parse(lines[0]!) as Record<string, unknown>;
+    expect(entry["parent_conversation_id"]).toBe("conv_parent_001");
+    expect(entry["subagent_session_id"]).toBe("conv_sub_abc123");
+    expect(entry["subagent_description"]).toBe("Run the content audit skill");
+  });
+
+  it("returns 400 when parent_conversation_id is missing", async () => {
+    const res = await app.request("/api/hook/subagent-start", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ subagent_session_id: "conv_sub_abc123" }),
+    });
+    expect(res.status).toBe(400);
+  });
+
+  it("returns 400 when subagent_session_id is missing", async () => {
+    const res = await app.request("/api/hook/subagent-start", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ parent_conversation_id: "conv_parent_001" }),
+    });
+    expect(res.status).toBe(400);
+  });
+});