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/python-scope-capture-tripwire.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

73 lines
3.0 KiB
TypeScript

/**
* Python scope-capture O(n^2) regression tripwire.
*
* NOT gated behind GITNEXUS_BENCH and needs no compiled worker — it runs in
* normal CI and is the actual guard against an O(n^2) re-regression of
* `emitPythonScopeCaptures`. It calls the hotpath directly on a ~400-entity
* generated source. The O(n) path (threading the tree-sitter query's captured
* node) does this in a few hundred ms; the old findNodeAtRange-from-root
* behaviour took ~25s+ at this size. The budget is a coarse tripwire (huge
* margin over the fixed path, far below a quadratic regression), not a
* microbenchmark — keep it generous so it never flakes on a loaded CI runner.
*
* Mirrors test/integration/go-pipeline-benchmark.test.ts's "O(n^2) regression
* tripwire" suite (issue #1848).
*/
import { describe, it, expect } from 'vitest';
import { emitPythonScopeCaptures } from '../../src/core/ingestion/languages/python/index.js';
describe('Python scope-capture O(n^2) regression tripwire', () => {
/**
* DAO-style source: top-level imports + N classes (each with methods) + N
* module functions. Maximizes top-level children AND function matches, which
* is exactly the O(matches x rootChildren) shape the fix removed.
*/
function generatePythonDaoSource(entityCount: number): string {
const lines: string[] = [];
for (let i = 0; i < 12; i++) {
lines.push(`from pkg.mod${i} import alpha${i}, beta${i}, gamma${i} as g${i}`);
lines.push(`import top.level.module${i}`);
}
lines.push('');
for (let i = 0; i < entityCount; i++) {
const n = String(i).padStart(4, '0');
lines.push(
`class Entity${n}:`,
` def __init__(self, id: int, name: str):`,
` self.id = id`,
` self.name = name`,
` def get_id(self) -> int:`,
` return self.id`,
` def set_name(self, name: str) -> None:`,
` self.name = name`,
` @classmethod`,
` def make(cls, id: int):`,
` return cls(id, "x")`,
'',
`def build_entity${n}(id: int, name: str) -> Entity${n}:`,
` return Entity${n}(id, name)`,
'',
);
}
return lines.join('\n');
}
it('parses a 400-entity file in well under the O(n^2) tripwire budget', () => {
const ENTITY_COUNT = 400;
const BUDGET_MS = 10_000; // coarse: ~30x the fixed path, far under a quadratic regression
const src = generatePythonDaoSource(ENTITY_COUNT);
emitPythonScopeCaptures(src, 'tripwire-warmup.py'); // warm up the parser/query JIT
const start = Date.now();
const matches = emitPythonScopeCaptures(src, 'tripwire.py');
const elapsedMs = Date.now() - start;
// Sanity: the captures are actually produced (each entity emits many capture
// groups), so a fast-but-empty result can't pass.
expect(matches.length).toBeGreaterThan(ENTITY_COUNT * 10);
// The actual regression guard: a re-regression to O(n^2) blows this budget.
expect(elapsedMs).toBeLessThan(BUDGET_MS);
}, 30_000);
});