Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* #2426 (bug 1) — write-through reaches git on durability-hardened repos.
*
* Bug class: `put_page` / capture / enrichment wrote `.md` into
* `sync.repo_path` but NOTHING ever committed it. The post-commit hook only
* fires after a commit — and write-through never made one — so write-through
* content accumulated uncommitted forever: never pushed, `last_sync_at`
* frozen (HEAD never moved), and silently deleted by a later `sync --full`
* delete-reconcile.
*
* Fix: `writePageThrough` best-effort commits the artifact (path-limited)
* when the repo carries the gbrain durability post-commit hook (i.e. the
* user opted in via `gbrain sources harden`); the hook then background-pushes.
* Unhardened repos keep the old write-only behavior.
*/
import { describe, test, expect, beforeAll, afterAll, beforeEach, afterEach } from 'bun:test';
import { mkdtempSync, writeFileSync, rmSync, mkdirSync, chmodSync } from 'fs';
import { execSync, execFileSync } from 'child_process';
import { tmpdir } from 'os';
import { join } from 'path';
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import { resetPgliteState } from './helpers/reset-pglite.ts';
import { writePageThrough } from '../src/core/write-through.ts';
let engine: PGLiteEngine;
let repo: string;
function git(cwd: string, ...args: string[]): string {
return execFileSync('git', ['-C', cwd, ...args], {
stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8',
}).trim();
}
/** Install a hook file carrying the gbrain durability banner (the detection
* key `isDurabilityHardened` looks for) with a no-op body so tests never
* attempt a real push. */
function installFakeDurabilityHook(repoPath: string): void {
const hooksDir = join(repoPath, '.git', 'hooks');
mkdirSync(hooksDir, { recursive: true });
const hookPath = join(hooksDir, 'post-commit');
writeFileSync(hookPath, [
'#!/usr/bin/env bash',
'# gbrain brain-durability post-commit hook (v0.42.44+)',
'exit 0',
'',
].join('\n'));
chmodSync(hookPath, 0o755);
}
async function seedPage(slug: string): Promise<void> {
await engine.putPage(slug, {
type: 'concept',
title: 'Write-through page',
compiled_truth: 'Content that must reach git.',
timeline: '',
frontmatter: { type: 'concept' },
});
}
describe('#2426 — writePageThrough auto-commit', () => {
beforeAll(async () => {
engine = new PGLiteEngine();
await engine.connect({});
await engine.initSchema();
}, 60_000);
afterAll(async () => {
if (engine) await engine.disconnect();
}, 60_000);
beforeEach(async () => {
await resetPgliteState(engine);
repo = mkdtempSync(join(tmpdir(), 'gbrain-wt-'));
execSync('git init', { cwd: repo, stdio: 'pipe' });
execSync('git config user.email "[email protected]"', { cwd: repo, stdio: 'pipe' });
execSync('git config user.name "T"', { cwd: repo, stdio: 'pipe' });
writeFileSync(join(repo, 'seed.md'), 'seed\n');
execSync('git add -A && git commit -m init', { cwd: repo, stdio: 'pipe' });
await engine.setConfig('sync.repo_path', repo);
});
afterEach(() => {
if (repo) rmSync(repo, { recursive: true, force: true });
});
test('on a hardened repo, the write-through artifact is committed (path-limited)', async () => {
installFakeDurabilityHook(repo);
// Unrelated dirty edit — must NOT be swept into the write-through commit.
writeFileSync(join(repo, 'seed.md'), 'dirty unrelated edit\n');
await seedPage('notes/hello');
const result = await writePageThrough(engine, 'notes/hello');
expect(result.written).toBe(true);
expect(result.committed).toBe(true);
// The artifact is committed…
expect(git(repo, 'log', '-1', '--format=%s')).toBe('gbrain: write-through notes/hello');
expect(git(repo, 'log', '-1', '--name-only', '--format=')).toBe('notes/hello.md');
expect(git(repo, 'status', '--porcelain', 'notes/hello.md')).toBe('');
// …and the unrelated edit stays uncommitted (explicit-path discipline).
expect(git(repo, 'status', '--porcelain', 'seed.md')).not.toBe('');
}, 60_000);
test('on an unhardened repo, the file is written but NOT committed (no behavior change)', async () => {
await seedPage('notes/plain');
const result = await writePageThrough(engine, 'notes/plain');
expect(result.written).toBe(true);
expect(result.committed).toBeUndefined();
// Untracked, uncommitted — the pre-existing contract.
expect(git(repo, 'status', '--porcelain', 'notes/plain.md')).toContain('?? notes/plain.md');
expect(git(repo, 'log', '-1', '--format=%s')).toBe('init');
}, 60_000);
});