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
3.0 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import { createRegistry } from "../../../src/core/install/registry.ts";
import type {
  InstallAdapter,
  InstallEnv,
  DetectResult,
  InstallPlan,
  ApplyResult,
  UninstallResult,
  VerifyResult,
} from "../../../src/core/install/types.ts";
import type { InstallTargetId } from "../../../src/core/runtime/host-facts.ts";

function makeFakeAdapter(target: InstallTargetId): InstallAdapter {
  return {
    target,
    label: target,
    // The seam is required on every adapter; a double that answers
    // `null` is a runtime with no session store, which is what a double is.
    sessionPaths(): null {
      return null;
    },
    detect(env: InstallEnv): DetectResult {
      void env;
      return { target, status: "not-installed", configPath: null, notes: [] };
    },
    plan(): InstallPlan {
      return { target, steps: [], postNotes: [] };
    },
    apply(): ApplyResult {
      return {
        target,
        steps_executed: 0,
        manifest: {
          target,
          applied_at: "2026-05-20T00:00:00.000Z",
          operation: "print",
          config_path: null,
        },
      };
    },
    uninstall(): UninstallResult {
      return { target, removed_keys: [], removed_paths: [], skipped: [] };
    },
    verify(): VerifyResult {
      return { target, status: "not-installed", details: [], fix_hint: null };
    },
  };
}

function makeEnv(): InstallEnv {
  return {
    vault: "/tmp/v",
    home: "/tmp/h",
    cwd: "/tmp/c",
    env: {},
    now: new Date("2026-05-20T00:00:00.000Z"),
  };
}

describe("install registry", () => {
  test("starts empty", () => {
    const reg = createRegistry();
    expect(reg.list()).toEqual([]);
    expect(reg.get("cursor")).toBeUndefined();
  });

  test("register + get round-trip", () => {
    const reg = createRegistry();
    const a = makeFakeAdapter("generic");
    reg.register(a);
    expect(reg.get("generic")).toBe(a);
    expect(reg.list().map((x) => x.target)).toEqual(["generic"]);
  });

  test("register rejects duplicate target", () => {
    const reg = createRegistry();
    reg.register(makeFakeAdapter("cursor"));
    expect(() => reg.register(makeFakeAdapter("cursor"))).toThrow(/duplicate/i);
  });

  test("detectAll returns one entry per registered adapter", () => {
    const reg = createRegistry();
    reg.register(makeFakeAdapter("aider"));
    reg.register(makeFakeAdapter("kiro"));
    const out = reg.detectAll(makeEnv());
    expect(out.map((d) => d.target).toSorted()).toEqual(["aider", "kiro"]);
  });

  test("list returns adapters in registration order", () => {
    const reg = createRegistry();
    reg.register(makeFakeAdapter("kiro"));
    reg.register(makeFakeAdapter("aider"));
    reg.register(makeFakeAdapter("grok"));
    expect(reg.list().map((x) => x.target)).toEqual(["kiro", "aider", "grok"]);
  });

  test("targets() returns target names only", () => {
    const reg = createRegistry();
    reg.register(makeFakeAdapter("aider"));
    reg.register(makeFakeAdapter("kiro"));
    expect(reg.targets()).toEqual(["aider", "kiro"]);
  });
});