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.8 KB
Raw Blame
import { describe, expect, test, beforeEach, afterEach } from "bun:test";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { Writable } from "node:stream";

import {
  bracketAiderSession,
  isInterruptedExit,
  renderAiderSidecar,
  type AiderSpawnResult,
  type BracketAiderDeps,
} from "../../../../src/core/install/adapters/aider-wrapper.ts";
import { aiderAdapter } from "../../../../src/core/install/adapters/aider.ts";
import { buildPayload } from "../../../../src/core/install/payload.ts";
import { extractPreCompactRecords } from "../../../../src/core/brain/pre-compact-extract.ts";
import { listContinuityRecords } from "../../../../src/core/brain/continuity/store.ts";

let vault: string;
let home: string;

beforeEach(() => {
  vault = mkdtempSync(join(tmpdir(), "osb-aiderwrap-v-"));
  // A legacy Brain/ tree: an unswitched machine (a vault without one is store-only).
  mkdirSync(join(vault, "Brain"), { recursive: true });
  home = mkdtempSync(join(tmpdir(), "osb-aiderwrap-h-"));
});
afterEach(() => {
  for (const p of [vault, home]) {
    try {
      rmSync(p, { recursive: true, force: true });
    } catch {}
  }
});

function env(now = new Date("2026-07-07T12:00:00.000Z"), envVars: Record<string, string> = {}) {
  return { vault, home, cwd: home, env: envVars, now };
}

function applyOpts(overrides: Record<string, unknown> = {}) {
  const sink = new Writable({
    write(_c, _e, cb) {
      cb();
    },
  });
  return {
    dryRun: false,
    force: false,
    stdout: sink as unknown as NodeJS.WriteStream,
    stderr: sink as unknown as NodeJS.WriteStream,
    ...overrides,
  };
}

const payload = buildPayload({ vault: "/v", agent_name: "claude-vps", timezone: "UTC" });

/** Deps that record phase ordering and let each test override behaviour. */
function makeDeps(
  over: Partial<BracketAiderDeps> & { exit?: AiderSpawnResult; transcript?: string } = {},
): { deps: BracketAiderDeps; log: string[]; persistInputs: unknown[] } {
  const log: string[] = [];
  const persistInputs: unknown[] = [];
  const exit = over.exit ?? { code: 0, signal: null };
  const transcript = over.transcript ?? "decision: adopt the wrapper\ncommitment: land E1\n";
  const deps: BracketAiderDeps = {
    loadContext:
      over.loadContext ??
      (() => {
        log.push("load");
        return join(vault, ".open-second-brain", "aider-context.md");
      }),
    spawnAider:
      over.spawnAider ??
      (async () => {
        log.push("spawn");
        return exit;
      }),
    captureTranscript: over.captureTranscript ?? (() => transcript),
    persist:
      over.persist ??
      ((input) => {
        log.push("persist");
        persistInputs.push(input);
        return extractPreCompactRecords(vault, input);
      }),
  };
  return { deps, log, persistInputs };
}

describe("aider session-bracketing wrapper", () => {
  test("load-half fires before Aider is spawned; persist-half fires after it exits", async () => {
    const { deps, log, persistInputs } = makeDeps();
    const result = await bracketAiderSession({ sessionId: "s1" }, deps);

    expect(log).toEqual(["load", "spawn", "persist"]);
    expect(result.phases).toEqual(["load", "spawn", "persist"]);
    // The load-half ran, then Aider, then the write-back persisted the session.
    expect(result.interrupted).toBe(false);
    expect((persistInputs[0] as { text: string }).text).toContain("decision: adopt the wrapper");
    // The captured session was persisted into the Brain (write-back closed).
    const records = listContinuityRecords(vault, { kind: "pre_compact_extract" });
    expect(records.length).toBeGreaterThan(0);
    expect(records.some((r) => r.payload["extract_type"] === "decision")).toBe(true);
  });

  test("live load-half regenerates the sidecar each session start", async () => {
    // The real load-half writes a fresh sidecar (live), unlike the static
    // install-time snapshot. renderAiderSidecar is the shared source of truth.
    const content = renderAiderSidecar(env(), payload);
    expect(content).toContain("@claude-vps");
    expect(content).toContain(vault);
  });

  test("static sidecar fallback path stays byte-identical (adapter output unchanged)", () => {
    // The wrapper reuses the adapter's snapshot logic (DRY). The adapter's
    // written sidecar must equal the shared renderer's output byte-for-byte.
    aiderAdapter.apply(aiderAdapter.plan(payload, env()), payload, env(), applyOpts());
    const sidecarPath = join(vault, ".open-second-brain", "aider-context.md");
    expect(existsSync(sidecarPath)).toBe(true);
    const written = readFileSync(sidecarPath, "utf8");
    expect(written).toBe(renderAiderSidecar(env(), payload));
  });

  test("interrupted session (non-zero exit) is captured honestly as interrupted", async () => {
    const { deps, persistInputs } = makeDeps({ exit: { code: 130, signal: null } });
    const result = await bracketAiderSession({ sessionId: "s-int" }, deps);

    expect(result.interrupted).toBe(true);
    expect((persistInputs[0] as { interrupted?: boolean }).interrupted).toBe(true);
    const records = listContinuityRecords(vault, { kind: "pre_compact_extract" });
    expect(records.length).toBeGreaterThan(0);
    expect(records.every((r) => r.payload["interrupted"] === true)).toBe(true);
  });

  test("interrupted session (signal) is captured honestly as interrupted", async () => {
    const { deps } = makeDeps({ exit: { code: null, signal: "SIGTERM" } });
    const result = await bracketAiderSession({ sessionId: "s-sig" }, deps);
    expect(result.interrupted).toBe(true);
  });

  test("clean exit persists without an interrupted flag (byte-identical continuity record)", async () => {
    const { deps, persistInputs } = makeDeps({ exit: { code: 0, signal: null } });
    await bracketAiderSession({ sessionId: "s-clean" }, deps);
    expect((persistInputs[0] as { interrupted?: boolean }).interrupted).toBeUndefined();
    const records = listContinuityRecords(vault, { kind: "pre_compact_extract" });
    expect(records.every((r) => r.payload["interrupted"] === undefined)).toBe(true);
  });

  test("an empty transcript persists nothing (no spurious records)", async () => {
    const { deps, log } = makeDeps({ transcript: "   \n  " });
    const result = await bracketAiderSession({ sessionId: "s-empty" }, deps);
    expect(log).toEqual(["load", "spawn"]);
    expect(result.persisted).toBeNull();
    expect(listContinuityRecords(vault, { kind: "pre_compact_extract" }).length).toBe(0);
  });

  test("isInterruptedExit: non-zero code or a signal is interrupted; clean zero is not", () => {
    expect(isInterruptedExit({ code: 0, signal: null })).toBe(false);
    expect(isInterruptedExit({ code: 1, signal: null })).toBe(true);
    expect(isInterruptedExit({ code: null, signal: "SIGINT" })).toBe(true);
    expect(isInterruptedExit({ code: null, signal: null })).toBe(true);
  });
});