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
7.1 KB
Raw Blame
/**
 * Git history ingest orchestration: full + incremental runs, release
 * attribution, watermark advance, digest rendering
 * (Project History Suite, t_c812752c).
 */

import { afterEach, beforeEach, expect, setDefaultTimeout, test } from "bun:test";
import { execFileSync } from "node:child_process";
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { repoKey } from "../../../../src/core/brain/git/identity.ts";
import { GitIngestError, ingestGitHistory } from "../../../../src/core/brain/git/ingest.ts";
import {
  gitStoreDir,
  listGitCommits,
  listGitTags,
  readGitState,
  writeGitState,
} from "../../../../src/core/brain/git/store.ts";
import { CLI_SPAWN_BUDGET_MS } from "../../../helpers/cli-timeout.ts";

// Tests here spawn processes; see tests/helpers/cli-timeout.ts.
setDefaultTimeout(CLI_SPAWN_BUDGET_MS);

let tmp: string;
let repo: string;
let vault: string;

function git(...args: string[]): string {
  return execFileSync(
    "git",
    [
      "-C",
      repo,
      "-c",
      "user.name=Fixture Author",
      "-c",
      "[email protected]",
      "-c",
      "commit.gpgsign=false",
      "-c",
      "tag.gpgsign=false",
      ...args,
    ],
    { encoding: "utf8", env: { ...process.env, GIT_CONFIG_GLOBAL: "/dev/null" } },
  ).trim();
}

function commitFile(relPath: string, content: string, message: string): string {
  const abs = join(repo, relPath);
  mkdirSync(join(abs, ".."), { recursive: true });
  writeFileSync(abs, content);
  git("add", "--", relPath);
  git("commit", "-q", "-m", message);
  return git("rev-parse", "HEAD");
}

beforeEach(() => {
  tmp = mkdtempSync(join(tmpdir(), "o2b-git-ingest-"));
  repo = join(tmp, "fixture-repo");
  mkdirSync(repo, { recursive: true });
  git("init", "-q", "-b", "main");
  vault = join(tmp, "vault");
  mkdirSync(join(vault, "Brain"), { recursive: true });
});

afterEach(() => {
  rmSync(tmp, { recursive: true, force: true });
});

test("initial ingest stores commits, tags, release edges, watermark, and digest", () => {
  commitFile("src/a.ts", "1", "feat: first");
  const second = commitFile("src/b.ts", "2", "fix: second");
  git("tag", "v1.0.0");
  const third = commitFile("src/a.ts", "3", "feat: post-release work");

  const res = ingestGitHistory(vault, repo);
  expect(res.mode).toBe("initial");
  expect(res.newCommits).toBe(3);
  expect(res.newTags).toBe(1);
  expect(res.warning).toBeNull();
  expect(res.repoKey).toBe(repoKey(repo));

  const key = res.repoKey;
  const commits = listGitCommits(vault, key);
  expect(commits).toHaveLength(3);
  // Release attribution: commits up to the tag carry v1.0.0, later ones null.
  expect(commits[0]!.release).toBe("v1.0.0");
  expect(commits[1]!.release).toBe("v1.0.0");
  expect(commits[2]!.release).toBeNull();
  expect(commits[1]!.sha).toBe(second);
  expect(listGitTags(vault, key)).toHaveLength(1);

  const state = readGitState(vault, key);
  expect(state.state!.lastSha).toBe(third);
  expect(state.state!.repoPath).toBe(repo);

  const digest = readFileSync(join(gitStoreDir(vault, key), "digest.md"), "utf8");
  expect(digest).toContain("kind: git-digest");
  expect(digest).toContain("v1.0.0");
  expect(digest).toContain("feat: post-release work");
  expect(digest).toContain("src/a.ts");
});

test("incremental ingest appends only new commits and advances the watermark", () => {
  commitFile("a.txt", "1", "one");
  const first = ingestGitHistory(vault, repo);
  expect(first.newCommits).toBe(1);

  const second = commitFile("b.txt", "2", "two");
  git("tag", "v0.2.0");
  const res = ingestGitHistory(vault, repo);
  expect(res.mode).toBe("incremental");
  expect(res.newCommits).toBe(1);
  expect(res.newTags).toBe(1);
  expect(readGitState(vault, res.repoKey).state!.lastSha).toBe(second);
  expect(listGitCommits(vault, res.repoKey)).toHaveLength(2);

  // No-change re-run: zero new records, watermark untouched, no duplicates.
  const idle = ingestGitHistory(vault, repo);
  expect(idle.mode).toBe("incremental");
  expect(idle.newCommits).toBe(0);
  expect(listGitCommits(vault, idle.repoKey)).toHaveLength(2);
});

test("a watermark that no longer resolves triggers a clean full re-scan", () => {
  commitFile("a.txt", "1", "one");
  ingestGitHistory(vault, repo);
  // Simulate force-push: watermark sha not in object store anymore.
  writeGitState(vault, repoKey(repo), {
    repoPath: repo,
    lastSha: "0".repeat(40),
    lastIngestedAt: "2026-06-04T00:00:00Z",
  });
  commitFile("b.txt", "2", "two");
  const res = ingestGitHistory(vault, repo);
  expect(res.mode).toBe("rescan");
  expect(res.warning).toMatch(/watermark/i);
  // Dedup keeps the store duplicate-free across the re-scan.
  expect(listGitCommits(vault, res.repoKey)).toHaveLength(2);
});

test("a malformed watermark file triggers a re-scan with the probe error surfaced", () => {
  commitFile("a.txt", "1", "one");
  ingestGitHistory(vault, repo);
  writeFileSync(join(gitStoreDir(vault, repoKey(repo)), "state.json"), "{broken");
  const res = ingestGitHistory(vault, repo);
  expect(res.mode).toBe("rescan");
  expect(res.warning).toMatch(/not valid JSON/);
  expect(listGitCommits(vault, res.repoKey)).toHaveLength(1);
});

test("a zero-commit re-scan clears the stale watermark instead of looping", () => {
  // Watermark points at a sha that never existed; the repo has no
  // commits at all (orphaned after a force-push). Writing the stale sha
  // back would re-trigger rescan warnings on every later run.
  writeGitState(vault, repoKey(repo), {
    repoPath: repo,
    lastSha: "0".repeat(40),
    lastIngestedAt: "2026-06-04T00:00:00Z",
  });
  const res = ingestGitHistory(vault, repo);
  expect(res.mode).toBe("rescan");
  expect(res.watermark).toBeNull();
  // State cleared: the next run starts clean as an initial walk.
  expect(readGitState(vault, repoKey(repo))).toEqual({ state: null, error: null });
  expect(ingestGitHistory(vault, repo).mode).toBe("initial");
});

test("maxCount bounds the initial walk and surfaces the truncation", () => {
  for (let i = 0; i < 5; i += 1) commitFile(`f${i}.txt`, String(i), `commit ${i}`);
  const res = ingestGitHistory(vault, repo, { maxCount: 2 });
  expect(res.newCommits).toBe(2);
  const commits = listGitCommits(vault, res.repoKey);
  expect(commits.map((c) => c.subject)).toEqual(["commit 3", "commit 4"]);
  // A bounded initial walk must SAY it skipped older history.
  expect(res.warning).toMatch(/older history not ingested/);
});

test("non-repo paths raise a domain error; empty repos ingest cleanly", () => {
  const plain = join(tmp, "plain");
  mkdirSync(plain);
  expect(() => ingestGitHistory(vault, plain)).toThrow(GitIngestError);
  const res = ingestGitHistory(vault, repo); // zero commits yet
  expect(res.newCommits).toBe(0);
  expect(res.watermark).toBeNull();
});

test("digest is deterministic: same store, same bytes", () => {
  commitFile("src/a.ts", "1", "feat: first");
  git("tag", "v1.0.0");
  ingestGitHistory(vault, repo);
  const path = join(gitStoreDir(vault, repoKey(repo)), "digest.md");
  const first = readFileSync(path, "utf8");
  ingestGitHistory(vault, repo);
  expect(readFileSync(path, "utf8")).toBe(first);
});