nlm-memory 0.4.2 → 0.5.1

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

@@ -1,205 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,105 +0,0 @@
-/**
- * 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

@@ -1,102 +0,0 @@
-/**
- * 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);
-  });
-});