hippocamp 0.2.5 → 0.2.7

package/test/memory-efficiency.test.cjs

@@ -76,7 +76,6 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
   const projectRoot = path.join(tempRoot, "search-project");
 
   process.env.HIPPOCAMP_GLOBAL_ROOT = lagoonRoot;
-  await fs.mkdir(projectRoot, { recursive: true });
   t.after(async () => {
     if (originalRoot === undefined) {
       delete process.env.HIPPOCAMP_GLOBAL_ROOT;
@@ -88,7 +87,7 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
 
   await memory.appendEvent({
     content: "Decision:\nUse indexed search only.",
-    cues: ["strict-index"],
+    keywords: ["strict-index"],
     date: "2026-09-21",
     projectRoot,
     scope: "project",
@@ -109,7 +108,7 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
 
   await memory.appendEvent({
     content: `Decision:\n${"x".repeat(1300)}`,
-    cues: ["oversized-metadata"],
+    keywords: ["oversized-metadata"],
     date: "2026-09-21",
     projectRoot,
     scope: "project",
@@ -124,7 +123,9 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
     scope: "project",
   });
 
-  assert.deepEqual(oversized.results, []);
+  // A keyword-only match still returns whole paragraphs; the oversized run is left out, never cropped.
+  assert.equal(oversized.results[0]?.heading, "Large metadata-only match");
+  assert.equal(oversized.results[0].snippet, "Decision:");
 
   const projectMemoryRoot = path.join(lagoonRoot, "projects", "search-project");
   await fs.writeFile(
@@ -145,7 +146,7 @@ test("search uses indexed events and returns coherent evidence", async (t) => {
   const eventsRoot = path.join(projectMemoryRoot, "events");
   await fs.writeFile(
     path.join(eventsRoot, "2026-09-20.md"),
-    "# Events: 2026-09-20\n\n## 09:00 — Hidden fallback\n\nCues:\n- quasar-velvet\n\nShould not be scanned.\n",
+    "# Events: 2026-09-20\n\n## 09:00 — Hidden fallback\n\nKeywords:\n- quasar-velvet\n\nShould not be scanned.\n",
     "utf8",
   );
 
@@ -174,11 +175,11 @@ test("search ranks indexed event bodies with typo tolerance", async (t) => {
     await fs.rm(tempRoot, { recursive: true, force: true });
   });
 
-  for (const [title, cues, content] of [
+  for (const [title, keywords, content] of [
     ["Deploy note", ["deploy"], "The zanzibar migration needs a rollback plan."],
     ["Unrelated note", ["billing"], "Invoices are generated monthly."],
   ]) {
-    await memory.appendEvent({ content, cues, projectRoot, scope: "project", sync: false, title });
+    await memory.appendEvent({ content, keywords, projectRoot, scope: "project", sync: false, title });
   }
 
   const search = await memory.searchMemory({ projectRoot, query: "zanzibr rollback", scope: "project" });
@@ -188,6 +189,42 @@ test("search ranks indexed event bodies with typo tolerance", async (t) => {
   assert.equal(search.results[0].match, "body");
 });
 
+test("search still matches events written with legacy Cues sections and indexes", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-legacy-cues-"));
+  const projectRoot = path.join(tempRoot, "legacy-project");
+  const eventsRoot = path.join(tempRoot, "lagoon", "projects", "legacy-project", "events");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = path.join(tempRoot, "lagoon");
+  await fs.mkdir(eventsRoot, { recursive: true });
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const id = "2026-09-01T09:00:00.000Z";
+  await fs.writeFile(
+    path.join(eventsRoot, "2026-09-01.md"),
+    `# Events — 2026-09-01\n\n## ${id} — Old note\n\nCues:\n- quasar-velvet\n\nOld body.\n`,
+    "utf8",
+  );
+  await fs.writeFile(
+    path.join(eventsRoot, "2026-09-01.index.json"),
+    JSON.stringify({ version: 1, path: "2026-09-01.md", events: [{ id, heading: "Old note", cues: ["quasar-velvet"] }] }),
+    "utf8",
+  );
+
+  const search = await memory.searchMemory({ projectRoot, query: "quasar velvet", scope: "project" });
+
+  assert.equal(search.results.length, 1);
+  assert.deepEqual(search.results[0].keywords, ["quasar-velvet"]);
+  assert.equal(search.results[0].match, "keywords");
+});
+
 test("search returns whole sentences from an oversized matching paragraph", async (t) => {
   const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
   const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-long-paragraph-"));
@@ -207,7 +244,7 @@ test("search returns whole sentences from an oversized matching paragraph", asyn
   const filler = "The weekly sync covered routine updates. ".repeat(40);
   await memory.appendEvent({
     content: `${filler}The kestrel database moved to eu-west-3. ${filler}`,
-    cues: ["infra"],
+    keywords: ["infra"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -246,7 +283,7 @@ test("search returns every matching paragraph that fits the excerpt budget", asy
   ];
   await memory.appendEvent({
     content: paragraphs.join("\n\n"),
-    cues: ["infra"],
+    keywords: ["infra"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -282,7 +319,7 @@ test("events appended in the same millisecond keep distinct ids and bodies", asy
   const timestamp = "2026-10-01T09:00:00.000Z";
   const first = await memory.appendEvent({
     content: "The zanzibar migration needs a rollback plan.",
-    cues: ["deploy"],
+    keywords: ["deploy"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -291,7 +328,7 @@ test("events appended in the same millisecond keep distinct ids and bodies", asy
   });
   const second = await memory.appendEvent({
     content: "Invoices are generated monthly.",
-    cues: ["billing"],
+    keywords: ["billing"],
     projectRoot,
     scope: "project",
     sync: false,
@@ -329,7 +366,7 @@ test("parallel appends keep every event", async (t) => {
     Array.from({ length: 20 }, (_, index) =>
       memory.appendEvent({
         content: `Parallel event ${index}.`,
-        cues: ["parallel"],
+        keywords: ["parallel"],
         date: "2026-10-01",
         projectRoot,
         scope: "project",
@@ -366,7 +403,7 @@ test("search favors events from a month named in the query", async (t) => {
   for (const timestamp of ["2026-05-02T08:00:00.000Z", "2026-08-05T10:00:00.000Z", "2026-09-01T09:00:00.000Z"]) {
     await memory.appendEvent({
       content: "Published the Android build to Google Play production.",
-      cues: ["android-release"],
+      keywords: ["android-release"],
       date: timestamp.slice(0, 10),
       projectRoot,
       scope: "project",
@@ -407,7 +444,7 @@ test("search favors events from a relative date named in the query", async (t) =
     await memory.appendEvent({
       // The old event matches the words better, so only the date words can rank the others first.
       content: key === "older" ? "Deploy key rotation: rotated the deploy key again." : "Rotated the key for staging.",
-      cues: ["deploy-key"],
+      keywords: ["deploy-key"],
       date: timestamp.slice(0, 10),
       projectRoot,
       scope: "project",
@@ -448,7 +485,7 @@ test("search returns a snippet for a long event matched only by its date", async
 
   await memory.appendEvent({
     content: Array(30).fill("The weekly sync covered routine updates.").join("\n\n"),
-    cues: ["sync"],
+    keywords: ["sync"],
     date: "2026-08-05",
     projectRoot,
     scope: "project",
@@ -485,7 +522,7 @@ test("search returns nothing when no memory is about the question", async (t) =>
     ["Deploy rollback", "A failed backend deploy rolls back to the previous revision."],
     ["Billing note", "Invoices are generated monthly."],
   ]) {
-    await memory.appendEvent({ content, cues: ["ops"], projectRoot, scope: "project", sync: false, title });
+    await memory.appendEvent({ content, keywords: ["ops"], projectRoot, scope: "project", sync: false, title });
   }
 
   const unrelated = await memory.searchMemory({ projectRoot, query: "which kubernetes namespace does the backend deploy to", scope: "project" });
@@ -498,3 +535,130 @@ test("search returns nothing when no memory is about the question", async (t) =>
   // No event is from August; the month name must not count as a missing topic word.
   assert.ok(monthOnly.results.length > 0);
 });
+
+test("search keeps an event matched only by a keyword its long body never repeats", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-keyword-only-"));
+  const projectRoot = path.join(tempRoot, "keyword-only-project");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = path.join(tempRoot, "lagoon");
+  await fs.mkdir(projectRoot, { recursive: true });
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const content = [
+    "Opened three hardening PRs after the security audit.",
+    "The backend PR rotates the cron secret and checks request signatures on every scheduled job. ".repeat(8),
+    "The website PR updates the content studio dependencies and removes an unused preview route. ".repeat(8),
+  ].join("\n\n");
+
+  assert.ok(content.length > 1200);
+  await memory.appendEvent({
+    content,
+    keywords: ["security-audit", "strava-oauth"],
+    projectRoot,
+    scope: "project",
+    sync: false,
+    title: "Security audit opened hardening PRs",
+  });
+
+  const search = await memory.searchMemory({ projectRoot, query: "Strava bug", scope: "project" });
+
+  assert.equal(search.results[0]?.heading, "Security audit opened hardening PRs");
+  assert.match(search.results[0].snippet, /^Opened three hardening PRs/);
+});
+
+test("search returns nothing when a rare word only resembles memory words", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-lookalike-"));
+  const projectRoot = path.join(tempRoot, "lookalike-project");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = path.join(tempRoot, "lagoon");
+  await fs.mkdir(projectRoot, { recursive: true });
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  await memory.appendEvent({
+    content: "Each worker instance reads the instruct prompt and its content before a sync.",
+    keywords: ["health-sync"],
+    projectRoot,
+    scope: "project",
+    sync: false,
+    title: "Apple Health sync banner hardening",
+  });
+
+  // "instinct" is one typo away from "instance" and "instruct" but means something else.
+  const lookalike = await memory.searchMemory({ projectRoot, query: "Instinct", scope: "project" });
+  const shared = await memory.searchMemory({ projectRoot, query: "context", scope: "project" });
+  const plural = await memory.searchMemory({ projectRoot, query: "worker instances", scope: "project" });
+
+  assert.deepEqual(lookalike.results, []);
+  assert.deepEqual(shared.results, []);
+  assert.equal(plural.results[0]?.heading, "Apple Health sync banner hardening");
+});
+
+test("an empty folder has no project and uses global memory", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-empty-folder-"));
+  const lagoonRoot = path.join(tempRoot, "lagoon");
+  const emptyRoot = path.join(tempRoot, "billowy-glove");
+  const codeRoot = path.join(tempRoot, "job-search");
+
+  process.env.HIPPOCAMP_GLOBAL_ROOT = lagoonRoot;
+  // Only .git, like a fresh session folder some agents create.
+  await fs.mkdir(path.join(emptyRoot, ".git"), { recursive: true });
+  await fs.mkdir(codeRoot, { recursive: true });
+  await fs.writeFile(path.join(codeRoot, "notes.md"), "Job search notes.\n", "utf8");
+  t.after(async () => {
+    if (originalRoot === undefined) {
+      delete process.env.HIPPOCAMP_GLOBAL_ROOT;
+    } else {
+      process.env.HIPPOCAMP_GLOBAL_ROOT = originalRoot;
+    }
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  });
+
+  const wake = await memory.wakeUp({ projectRoot: emptyRoot });
+  const event = await memory.appendEvent({
+    content: "Created the applying-to-jobs skill.",
+    keywords: ["applying-to-jobs"],
+    projectRoot: emptyRoot,
+    scope: "project",
+    sync: false,
+    title: "Job application skill created",
+  });
+  await memory.appendEvent({
+    content: "Created the applying-to-jobs tracker in Notion.",
+    keywords: ["applying-to-jobs-tracker"],
+    projectRoot: codeRoot,
+    scope: "project",
+    sync: false,
+    title: "Job tracker created",
+  });
+  const fromEmpty = await memory.searchMemory({ projectRoot: emptyRoot, query: "applying to jobs skill" });
+  const projectScope = await memory.searchMemory({ projectRoot: emptyRoot, query: "applying to jobs", scope: "project" });
+  const fromProject = await memory.searchMemory({ projectRoot: codeRoot, query: "applying to jobs skill" });
+
+  assert.equal(wake.projectSlug, null);
+  assert.equal(wake.projectMemoryRoot, lagoonRoot);
+  assert.equal(path.dirname(path.dirname(event.indexPath)), lagoonRoot);
+  // Global memory is searched once, and other projects stay out of it.
+  assert.deepEqual(fromEmpty.results.map((result) => result.heading), ["Job application skill created"]);
+  assert.deepEqual(projectScope.results.map((result) => result.heading), ["Job application skill created"]);
+  assert.equal(fromProject.results[0]?.heading, "Job application skill created");
+  assert.equal(memory.getProjectSlug(codeRoot), "job-search");
+  // A folder that does not exist keeps its name, as Dream's synthetic roots do.
+  assert.equal(memory.getProjectSlug(path.join(tempRoot, "missing")), "missing");
+});

package/test/package-paths.test.cjs

@@ -28,3 +28,15 @@ test("published files contain no local home directory paths", () => {
 
   assert.deepEqual(matches, []);
 });
+
+test("the README demo GIF stays out of the npm package", () => {
+  // The README loads it from GitHub; .npmignore keeps the 600 kB file out of every install.
+  const output = execFileSync("npm", ["pack", "--dry-run", "--json"], {
+    cwd: path.join(__dirname, ".."),
+    encoding: "utf8",
+    shell: process.platform === "win32",
+  });
+  const [pack] = JSON.parse(output);
+
+  assert.ok(!pack.files.some((file) => file.path.endsWith(".gif")));
+});

package/test/sync-memory.test.cjs

@@ -29,7 +29,6 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
   });
 
   await fs.mkdir(realLagoon);
-  await fs.mkdir(projectRoot);
   await fs.symlink(realLagoon, linkedLagoon);
   git(["init", "-q", "-b", "main"]);
   git(["commit", "-q", "--allow-empty", "-m", "init"]);
@@ -45,7 +44,7 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
 
   const result = await memory.appendEvent({
     content: "Use advisory locks.",
-    cues: ["locks"],
+    keywords: ["locks"],
     projectRoot,
     scope: "project",
     title: "Queue decision",
@@ -56,12 +55,11 @@ test("sync commits when the Lagoon path goes through a symlink", async (t) => {
 
   // A symlink inside the Lagoon pointing at another project must not be synced as this one.
   const otherProject = path.join(tempRoot, "other-project");
-  await fs.mkdir(otherProject);
   await fs.mkdir(path.join(realLagoon, "projects", "other-project"), { recursive: true });
   await fs.symlink(path.join(realLagoon, "projects", "linked-project", "events"), path.join(realLagoon, "projects", "other-project", "events"));
 
   await assert.rejects(
-    memory.appendEvent({ content: "Cross write.", cues: ["x"], projectRoot: otherProject, scope: "project", title: "Escape" }),
+    memory.appendEvent({ content: "Cross write.", keywords: ["x"], projectRoot: otherProject, scope: "project", title: "Escape" }),
     /escapes the memory root/,
   );
 });