Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
6.2 KB
Raw Blame
/**
 * Task 3: `selectEvents(index, filters)` pure projection.
 *
 * Asserts that every supported filter (`prefId`, `topic`, `kind`,
 * `since`, `until`) narrows the index's events by the AND of all
 * predicates and that the result is frozen.
 */

import { describe, expect, test, beforeEach } from "bun:test";
import { mkdirSync, writeFileSync } from "node:fs";
import { join } from "node:path";

import { buildTimelineIndex } from "../../../../src/core/brain/temporal/build-index.ts";
import { selectEvents } from "../../../../src/core/brain/temporal/select-events.ts";
import { tempDirs } from "../../../helpers/temp-dir.ts";

const mkTemp = tempDirs();

function makeVault(): string {
  const dir = mkTemp("o2b-temporal-select-");
  mkdirSync(join(dir, "Brain", "log"), { recursive: true });
  mkdirSync(join(dir, "Brain", "preferences"), { recursive: true });
  mkdirSync(join(dir, "Brain", "retired"), { recursive: true });
  return dir;
}

interface FixtureEvent {
  readonly timestamp: string;
  readonly kind: string;
  readonly body: Record<string, string | ReadonlyArray<string>>;
}

function writeJsonlDay(vault: string, date: string, events: ReadonlyArray<FixtureEvent>): void {
  const lines = events
    .map((e) => JSON.stringify({ ts: e.timestamp, kind: e.kind, payload: e.body }))
    .join("\n");
  writeFileSync(join(vault, "Brain", "log", `${date}.jsonl`), lines + "\n");
}

let VAULT: string;
beforeEach(() => {
  VAULT = makeVault();
  writeJsonlDay(VAULT, "2026-05-20", [
    {
      timestamp: "2026-05-20T08:00:00Z",
      kind: "feedback",
      body: {
        signal: "[[sig-2026-05-20-foo]]",
        topic: "foo",
        sign: "positive",
        agent: "claude",
      },
    },
    {
      timestamp: "2026-05-20T10:00:00Z",
      kind: "apply-evidence",
      body: {
        preference: "[[pref-foo|Principle]]",
        artifact: "[[src/cli/main.ts]]",
        agent: "claude",
        result: "applied",
      },
    },
    {
      timestamp: "2026-05-20T12:00:00Z",
      kind: "apply-evidence",
      body: {
        preference: "[[pref-bar|Other]]",
        artifact: "[[src/cli/other.ts]]",
        agent: "claude",
        result: "violated",
      },
    },
  ]);
  writeJsonlDay(VAULT, "2026-05-21", [
    {
      timestamp: "2026-05-21T09:00:00Z",
      kind: "note",
      body: {
        text: "Release shipped",
        agent: "claude",
      },
    },
    {
      timestamp: "2026-05-21T11:00:00Z",
      kind: "apply-evidence",
      body: {
        preference: "[[pref-foo|Principle]]",
        artifact: "[[src/cli/again.ts]]",
        agent: "claude",
        result: "applied",
      },
    },
  ]);
});

describe("selectEvents", () => {
  test("no filter returns full event list frozen", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, {});
    expect(got.length).toBe(5);
    expect(Object.isFrozen(got)).toBe(true);
  });

  test("filter by prefId returns only events for that preference", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { prefId: "pref-foo" });
    expect(got.length).toBe(2);
    expect(got.every((e) => e.prefId === "pref-foo")).toBe(true);
  });

  test("filter by topic returns only events for that topic", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { topic: "foo" });
    expect(got.length).toBe(1);
    expect(got[0]!.kind).toBe("feedback");
  });

  test("filter by kind returns only events of that kind", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { kind: "apply-evidence" });
    expect(got.length).toBe(3);
    expect(got.every((e) => e.kind === "apply-evidence")).toBe(true);
  });

  test("filter by since narrows lower bound (inclusive)", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { since: "2026-05-21T00:00:00Z" });
    expect(got.length).toBe(2);
    expect(got[0]!.at).toBe("2026-05-21T09:00:00Z");
  });

  test("filter by until narrows upper bound (exclusive)", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { until: "2026-05-21T00:00:00Z" });
    expect(got.length).toBe(3);
    expect(got.every((e) => e.at < "2026-05-21T00:00:00Z")).toBe(true);
  });

  test("multiple filters combine with AND", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, {
      prefId: "pref-foo",
      kind: "apply-evidence",
      since: "2026-05-21T00:00:00Z",
    });
    expect(got.length).toBe(1);
    expect(got[0]!.at).toBe("2026-05-21T11:00:00Z");
  });

  test("filter with no matches returns empty frozen list", () => {
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { prefId: "pref-nonexistent" });
    expect(got.length).toBe(0);
    expect(Object.isFrozen(got)).toBe(true);
  });
});

describe("selectEvents bi-temporal frontmatter atoms", () => {
  test("retired event with valid_from/valid_until/recorded_at surfaces those slots", () => {
    writeFileSync(
      join(VAULT, "Brain", "retired", "ret-temporal.md"),
      `---\nid: ret-temporal\nprinciple: keep-fresh\ntopic: temporal\nretired_at: 2026-05-18T09:00:00Z\nreason: superseded\nstatus: retired\nvalid_from: 2026-01-01T00:00:00Z\nvalid_until: 2026-05-18T09:00:00Z\nrecorded_at: 2026-05-18T09:30:00Z\n---\n`,
    );
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { prefId: "ret-temporal" });
    expect(got.length).toBe(1);
    expect(got[0]!.validFrom).toBe("2026-01-01T00:00:00Z");
    expect(got[0]!.validUntil).toBe("2026-05-18T09:00:00Z");
    expect(got[0]!.recordedAt).toBe("2026-05-18T09:30:00Z");
  });

  test("retired event without the new slots leaves them undefined", () => {
    writeFileSync(
      join(VAULT, "Brain", "retired", "ret-legacy.md"),
      `---\nid: ret-legacy\nprinciple: old-rule\ntopic: legacy\nretired_at: 2026-05-19T09:00:00Z\nreason: stale-no-evidence\nstatus: retired\n---\n`,
    );
    const idx = buildTimelineIndex(VAULT, {});
    const got = selectEvents(idx, { prefId: "ret-legacy" });
    expect(got.length).toBe(1);
    expect(got[0]!.validFrom).toBeUndefined();
    expect(got[0]!.validUntil).toBeUndefined();
    expect(got[0]!.recordedAt).toBeUndefined();
  });
});