Garry's Opinionated OpenClaw/Hermes Agent Brain
TypeScript
/**
* v0.20.0 Cathedral II Layer 11 (E1) — BrainBench code sub-categories.
*
* Pins the retrieval-quality metrics Layer 5 + Layer 6 should keep lifting:
* - call_graph_recall: given a chunk that calls foo(), do we surface
* that caller via getCallersOf('foo') after importCodeFile?
* - parent_scope_coverage: do nested-method chunks carry the expected
* parentSymbolPath after end-to-end importCodeFile?
*
* doc_comment_matching is deferred with A4 full extraction to v0.20.1.
* The FTS trigger from Layer 1b weights doc_comment 'A' as soon as the
* chunker populates it — the column exists; the value is blank today.
*
* These are unit-ish end-to-end tests against a fresh PGLite. They pin
* the retrieval-side behavior that lifts MRR on symbol queries vs
* v0.19.0's grep-class baseline.
*/
import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
import { importCodeFile } from '../src/core/import-file.ts';
describe('Cathedral II BrainBench — call_graph_recall', () => {
let engine: PGLiteEngine;
beforeAll(async () => {
engine = new PGLiteEngine();
await engine.connect({});
await engine.initSchema();
// Import two related files. A calls helper; B defines helper.
// Layer 5 edge extraction should capture the calls edge from A's
// body to 'helper'.
await importCodeFile(
engine,
'src/a.ts',
'export function runner() { return helper(); }\n',
{ noEmbed: true },
);
await importCodeFile(
engine,
'src/b.ts',
'export function helper() { return 42; }\n',
{ noEmbed: true },
);
});
afterAll(async () => {
await engine.disconnect();
}, 30_000);
test('getCallersOf("helper") returns runner as a caller', async () => {
const results = await engine.getCallersOf('helper', { allSources: true });
expect(results.length).toBeGreaterThanOrEqual(1);
const fromRunner = results.find(r => r.from_symbol_qualified === 'runner');
expect(fromRunner).toBeDefined();
expect(fromRunner!.edge_type).toBe('calls');
});
test('getCalleesOf("runner") returns helper as a callee', async () => {
const results = await engine.getCalleesOf('runner', { allSources: true });
expect(results.length).toBeGreaterThanOrEqual(1);
const toHelper = results.find(r => r.to_symbol_qualified === 'helper');
expect(toHelper).toBeDefined();
});
test('re-importing the same file is idempotent (no duplicate edges)', async () => {
const before = await engine.getCallersOf('helper', { allSources: true });
await importCodeFile(
engine,
'src/a.ts',
'export function runner() { return helper(); }\n',
{ noEmbed: true, force: true },
);
const after = await engine.getCallersOf('helper', { allSources: true });
// Per-chunk invalidation wipes then re-writes, so counts should match.
expect(after.length).toBe(before.length);
});
});
describe('Cathedral II BrainBench — parent_scope_coverage', () => {
let engine: PGLiteEngine;
beforeAll(async () => {
engine = new PGLiteEngine();
await engine.connect({});
await engine.initSchema();
// A class with 2 methods. Layer 6 A3 should emit 3 chunks: the
// class + each method. Each method chunk should carry the
// parentSymbolPath [ClassName].
await importCodeFile(
engine,
'src/brain.ts',
`export class BrainEngine {
searchKeyword(q: string) { return q; }
searchVector(emb: Float32Array) { return emb; }
}
`,
{ noEmbed: true },
);
});
afterAll(async () => {
await engine.disconnect();
}, 30_000);
test('nested method chunks persist parent_symbol_path', async () => {
const chunks = await engine.getChunks('src-brain-ts');
expect(chunks.length).toBeGreaterThanOrEqual(3);
const method = chunks.find(c => c.symbol_name === 'searchKeyword');
expect(method).toBeDefined();
expect(method!.parent_symbol_path).toEqual(['BrainEngine']);
const klass = chunks.find(c => c.symbol_name === 'BrainEngine');
expect(klass).toBeDefined();
// Class-level chunk: parent_symbol_path is null / empty (top-level).
const klassPath = klass!.parent_symbol_path as string[] | null;
expect(klassPath == null || klassPath.length === 0).toBe(true);
});
test('qualified symbol name resolves for nested methods', async () => {
const chunks = await engine.getChunks('src-brain-ts');
const method = chunks.find(c => c.symbol_name === 'searchKeyword');
expect(method!.symbol_name_qualified).toBe('BrainEngine.searchKeyword');
});
test('getCallersOf("searchKeyword") matches the bare short name', async () => {
// Add a caller that invokes searchKeyword so we can verify the
// short-name match path (Layer 5's unresolved capture).
await importCodeFile(
engine,
'src/caller.ts',
`import { BrainEngine } from './brain';
function demo() {
const e = new BrainEngine();
return e.searchKeyword('hi');
}
`,
{ noEmbed: true },
);
const callers = await engine.getCallersOf('searchKeyword', { allSources: true });
expect(callers.length).toBeGreaterThanOrEqual(1);
});
});