This repository has been archived on 2026-11-17. You can view files and clone it, but cannot push or open issues or pull requests.
gitgram-ai/aitimemachine/gitnexus/test/integration/parse-impl-large-fixture.test.ts
caelum0x 49b183818c Unify gitgram + aitimemachine into the monorepo (de-submodule) and merge vendored engines
Convert gitgram/ and aitimemachine/ from embedded git repos (which showed as
opaque submodule gitlinks on GitHub) into fully-tracked first-party content.

AITM now merges its 7 vendored repos as first-party engines:
- memory: beads (Go task DAG) + context7 (docs SDK), unified into saved_contexts
- git: vendored C git (bundled binary) + gitnexus (in-process code intelligence)
- agentic: a2a (@a2a-js/sdk) + pal (AITM-managed Python subprocess)

Includes the full session's product build: Gitgram web/mobile/backend features,
AITM website/CLI/MCP, the unified memory layer, engine build tooling
(scripts/build-engines.sh, Dockerfile, CI), docs (README, ENGINES.md, ARCHITECTURE.md),
and extensive test suites.

Build artifacts, node_modules, external/, and gemini-cli are gitignored.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-23 14:14:09 +03:00

174 lines
7.0 KiB
TypeScript

/**
* U6 (B3 from PR #1693 review) — Multi-chunk pipeline integration with a
* wall-clock budget.
*
* The PR's headline claim is "analyze no longer hangs on TS-root-shaped
* loads". The unit suite already pins each resilience layer individually
* (worker-pool-resilience.test.ts), the deferred-extraction equivalence
* (parse-impl-deferred-extraction.test.ts — U7), and the chunk
* concurrency (parse-impl-chunk-concurrency.test.ts — U1). What was
* missing: a single end-to-end run that exercises the full chunked
* parse-and-resolve path on a multi-chunk fixture, BOUNDED by a
* wall-clock so a regression that re-introduces the hang fails this
* test loudly instead of slipping past via inequality assertions.
*
* This runs the real worker pool (the sole parse path since the sequential
* parser was removed) on a multi-chunk fixture, BOUNDED by a wall-clock so a
* regression that re-introduces the hang fails loudly instead of slipping past
* via inequality assertions. The load-bearing invariants — multi-chunk parsing
* completes within a bounded budget and produces all expected symbols — catch
* the bulk of the regressions B3 was concerned about. Needs the dist worker
* (integration tier).
*/
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
const ORIGINAL_BUDGET = process.env.GITNEXUS_CHUNK_BYTE_BUDGET;
const WALL_CLOCK_BUDGET_MS = 30_000;
function buildFixture(): Record<string, string> {
const fixture: Record<string, string> = {};
for (let i = 0; i < 15; i++) {
fixture[`mod${i}.ts`] = `export function fn${i}(): number {\n return ${i};\n}\n`;
}
// A "realistically dense" file — 30 functions + a class + an interface +
// a re-export. Stands in for the kind of file that previously stalled the
// serial-extraction chunk loop. Pure-TS so the parser doesn't choke.
const complexFnLines = Array.from(
{ length: 30 },
(_, i) => `export function complex${i}(c: Config): string { return c.name + String(${i}); }`,
).join('\n');
fixture['complex.ts'] = `
export interface Config { name: string; }
export class Service {
configure(c: Config): void { this.name = c.name; }
private name: string = '';
describe(): string { return this.name; }
}
${complexFnLines}
`;
fixture['index.ts'] =
'export { Service, type Config } from "./complex";\n' +
Array.from({ length: 15 }, (_, i) => `export { fn${i} } from "./mod${i}";`).join('\n') +
'\n';
return fixture;
}
async function runFixture(): Promise<{
nodeCount: number;
relationshipCount: number;
symbolNames: Set<string>;
elapsedMs: number;
}> {
const fixture = buildFixture();
// Force multi-chunk parsing on the small fixture by lowering the byte
// budget below each file's size. parse-impl reads the budget at module
// load — vi.resetModules() forces a fresh module so the env takes effect.
process.env.GITNEXUS_CHUNK_BYTE_BUDGET = '64';
vi.resetModules();
const { runChunkedParseAndResolve } =
await import('../../src/core/ingestion/pipeline-phases/parse-impl.js');
const { createKnowledgeGraph } = await import('../../src/core/graph/graph.js');
const repoPath = fs.mkdtempSync(path.join(os.tmpdir(), 'parse-impl-large-fixture-'));
try {
for (const [name, content] of Object.entries(fixture)) {
fs.writeFileSync(path.join(repoPath, name), content);
}
const files = Object.keys(fixture);
const scanned = files.map((rel) => ({
path: rel,
size: fs.statSync(path.join(repoPath, rel)).size,
}));
const graph = createKnowledgeGraph();
// Wrap the run in Promise.race so the wall-clock budget is enforced
// as an exception, not a >=/<= inequality assertion (DoD §2.7 — a
// bounds-only count is a regression-mask; a hard timeout is a
// hang-detector). If the run exceeds the budget, the rejection
// fails the test with a specific timeout error so the diagnostic
// surfaces the actual regression class.
const start = Date.now();
await Promise.race([
runChunkedParseAndResolve(graph, scanned, files, files.length, repoPath, start, () => {}, {}),
new Promise<never>((_, reject) =>
setTimeout(
() =>
reject(
new Error(
`runChunkedParseAndResolve exceeded ${WALL_CLOCK_BUDGET_MS}ms wall-clock budget — likely the hang B3 was meant to prevent`,
),
),
WALL_CLOCK_BUDGET_MS,
),
),
]);
const elapsedMs = Date.now() - start;
const symbolNames = new Set<string>();
for (const node of graph.nodes.values()) {
const name = (node.properties as { name?: string } | undefined)?.name;
if (typeof name === 'string') symbolNames.add(name);
}
return {
nodeCount: graph.nodeCount,
relationshipCount: graph.relationshipCount,
symbolNames,
elapsedMs,
};
} finally {
if (fs.existsSync(repoPath)) {
fs.rmSync(repoPath, { recursive: true, force: true });
}
}
}
describe('parse-impl wall-clock integration on multi-chunk fixture (U6 / B3)', () => {
beforeEach(() => {
vi.resetModules();
});
afterEach(() => {
if (ORIGINAL_BUDGET === undefined) {
delete process.env.GITNEXUS_CHUNK_BYTE_BUDGET;
} else {
process.env.GITNEXUS_CHUNK_BYTE_BUDGET = ORIGINAL_BUDGET;
}
});
it('completes a 17-file multi-chunk fixture within wall-clock and indexes every named symbol', async () => {
const result = await runFixture();
// Reaching this assertion means the Promise.race did NOT time out —
// the run completed in under WALL_CLOCK_BUDGET_MS. That alone is the
// primary B3 invariant: "does not hang on a multi-chunk workload";
// the race rejection already enforces it. The previous
// `Math.min(elapsedMs, BUDGET)` form here resolved to
// `expect(x).toBe(x)` — tautological and catching nothing. The
// load-bearing wall-clock check lives in the Promise.race above;
// the per-symbol assertions below catch silent mid-chunk crashes.
expect(typeof result.elapsedMs).toBe('number');
// All 15 plain function declarations must show up in the graph.
for (let i = 0; i < 15; i++) {
expect(result.symbolNames.has(`fn${i}`)).toBe(true);
}
// The complex.ts surfaces: Service class, Config interface, configure
// method, and a representative sampling of the complex0..complex29
// functions. Pin specific names (not just a count) so chunk-boundary
// truncation surfaces as a concrete missing-symbol failure with a
// specific diagnostic.
expect(result.symbolNames.has('Service')).toBe(true);
expect(result.symbolNames.has('Config')).toBe(true);
expect(result.symbolNames.has('configure')).toBe(true);
expect(result.symbolNames.has('describe')).toBe(true);
expect(result.symbolNames.has('complex0')).toBe(true);
expect(result.symbolNames.has('complex15')).toBe(true);
expect(result.symbolNames.has('complex29')).toBe(true);
});
});