hippocamp 0.2.2 → 0.2.4

package/test/memory-efficiency.test.cjs

@@ -346,3 +346,155 @@ test("parallel appends keep every event", async (t) => {
   assert.equal(new Set(ids).size, 20);
   assert.equal(new Set(results.map((result) => result.timestamp)).size, 20);
 });
+
+test("search favors events from a month named in the query", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-month-search-"));
+  const projectRoot = path.join(tempRoot, "month-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 });
+  });
+
+  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"],
+      date: timestamp.slice(0, 10),
+      projectRoot,
+      scope: "project",
+      sync: false,
+      timestamp,
+      title: "Android release",
+    });
+  }
+
+  const byMonth = await memory.searchMemory({ projectRoot, query: "android build in august", scope: "project" });
+  const byDay = await memory.searchMemory({ projectRoot, query: "android build 2026-05-02", scope: "project" });
+
+  assert.equal(byMonth.results[0].id, "2026-08-05T10:00:00.000Z");
+  assert.equal(byDay.results[0].id, "2026-05-02T08:00:00.000Z");
+});
+
+test("search favors events from a relative date named in the query", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-relative-date-"));
+  const projectRoot = path.join(tempRoot, "relative-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 });
+  });
+
+  // Seven days ago is always in last calendar week; one day ago is yesterday.
+  const daysAgo = (days) => new Date(Date.now() - days * 86_400_000).toISOString();
+  const timestamps = { yesterday: daysAgo(1), lastWeek: daysAgo(7), older: daysAgo(30) };
+
+  for (const [key, timestamp] of Object.entries(timestamps)) {
+    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"],
+      date: timestamp.slice(0, 10),
+      projectRoot,
+      scope: "project",
+      sync: false,
+      timestamp,
+      title: "Deploy key rotation",
+    });
+  }
+
+  const ids = async (phrase) =>
+    (await memory.searchMemory({ projectRoot, query: `deploy key rotation ${phrase}`, scope: "project" })).results.map(
+      (result) => result.id,
+    );
+
+  assert.deepEqual(await ids("yesterday"), [timestamps.yesterday]);
+  // On a Monday, yesterday is also in last week.
+  const lastWeek = await ids("last week");
+  assert.ok(lastWeek.includes(timestamps.lastWeek));
+  assert.ok(!lastWeek.includes(timestamps.older));
+  assert.deepEqual(await ids("today"), []);
+});
+
+test("search returns a snippet for a long event matched only by its date", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-date-only-"));
+  const projectRoot = path.join(tempRoot, "date-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 });
+  });
+
+  await memory.appendEvent({
+    content: Array(30).fill("The weekly sync covered routine updates.").join("\n\n"),
+    cues: ["sync"],
+    date: "2026-08-05",
+    projectRoot,
+    scope: "project",
+    sync: false,
+    timestamp: "2026-08-05T10:00:00.000Z",
+    title: "Weekly sync",
+  });
+
+  const search = await memory.searchMemory({ projectRoot, query: "2026-08-05", scope: "project" });
+
+  assert.equal(search.results.length, 1);
+  assert.match(search.results[0].snippet, /^The weekly sync covered routine updates\./);
+  assert.ok(search.results[0].snippet.length <= 1200);
+});
+
+test("search returns nothing when no memory is about the question", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-unrelated-"));
+  const projectRoot = path.join(tempRoot, "unrelated-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 });
+  });
+
+  for (const [title, content] of [
+    ["Backend deploy", "The backend deploys to Cloud Run after the build passes."],
+    ["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 });
+  }
+
+  const unrelated = await memory.searchMemory({ projectRoot, query: "which kubernetes namespace does the backend deploy to", scope: "project" });
+  const related = await memory.searchMemory({ projectRoot, query: "where does the backend deploy", scope: "project" });
+
+  const monthOnly = await memory.searchMemory({ projectRoot, query: "deploy in august", scope: "project" });
+
+  assert.deepEqual(unrelated.results, []);
+  assert.equal(related.results[0].heading, "Backend deploy");
+  // No event is from August; the month name must not count as a missing topic word.
+  assert.ok(monthOnly.results.length > 0);
+});

package/test/sync-memory.test.cjs

@@ -0,0 +1,67 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { execFileSync } = require("node:child_process");
+const fs = require("node:fs/promises");
+const os = require("node:os");
+const path = require("node:path");
+const memory = require("../scripts/hippocamp-memory.cjs");
+
+test("sync commits when the Lagoon path goes through a symlink", async (t) => {
+  const originalRoot = process.env.HIPPOCAMP_GLOBAL_ROOT;
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "hippocamp-symlink-"));
+  const realLagoon = path.join(tempRoot, "real-lagoon");
+  const linkedLagoon = path.join(tempRoot, "linked-lagoon");
+  const projectRoot = path.join(tempRoot, "linked-project");
+  const git = (args) => execFileSync("git", args, { cwd: realLagoon }).toString().trim();
+
+  // CI runners have no Git identity; set one for this test only.
+  const identity = { GIT_AUTHOR_NAME: "Test", GIT_AUTHOR_EMAIL: "test@example.com", GIT_COMMITTER_NAME: "Test", GIT_COMMITTER_EMAIL: "test@example.com" };
+  const saved = Object.fromEntries(Object.keys(identity).map((key) => [key, process.env[key]]));
+  Object.assign(process.env, identity);
+  t.after(() => {
+    for (const [key, value] of Object.entries(saved)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  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"]);
+  process.env.HIPPOCAMP_GLOBAL_ROOT = linkedLagoon;
+  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, maxRetries: 5 });
+  });
+
+  const result = await memory.appendEvent({
+    content: "Use advisory locks.",
+    cues: ["locks"],
+    projectRoot,
+    scope: "project",
+    title: "Queue decision",
+  });
+
+  assert.equal(result.sync.committed, true);
+  assert.match(git(["log", "--format=%s", "-1"]), /append project event/);
+
+  // 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" }),
+    /escapes the memory root/,
+  );
+});