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/bench/python-scope/import-target-fingerprint.mjs
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

203 lines
8.0 KiB
JavaScript

/**
* Resolver-output correctness fingerprint for `resolvePythonImportTarget`
* (ce-optimize: python-scope-capture, hypothesis H2).
*
* H2 replaces the per-import O(files) suffix scan + candidate scan in
* import-target.ts with a memoized index. The index MUST reproduce the exact
* resolution result (including the deterministic tie-break and the
* false-positive gating) for every input. This harness pins that: it runs
* resolvePythonImportTarget over an exhaustive branch matrix PLUS a large
* deterministic fuzz (varied repo layouts that force collisions / multi-match
* tie-breaks), and prints an order-independent sha256 over every
* `fromFile | targetRaw | result` triple.
*
* Build-free via tsx (static .ts import). Run:
* node --import tsx bench/python-scope/import-target-fingerprint.mjs
*
* The fingerprint before and after the H2 change MUST be identical.
*/
import crypto from 'node:crypto';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { resolvePythonImportTarget } from '../../src/core/ingestion/languages/python/import-target.ts';
function mkImport(targetRaw) {
return { kind: 'absolute', targetRaw, isRelative: false, names: [] };
}
function resolve(fromFile, files, targetRaw) {
const ctx = { fromFile, allFilePaths: new Set(files) };
return resolvePythonImportTarget(mkImport(targetRaw), ctx);
}
const lines = [];
let nonNull = 0;
function record(fromFile, files, targetRaw) {
const r = resolve(fromFile, files, targetRaw);
if (r !== null) nonNull++;
lines.push(`${fromFile}\t${targetRaw}\t${r === null ? 'NULL' : r}`);
}
// ---- 1. Exhaustive branch matrix ----------------------------------------
// direct root hit
record('app/main.py', ['services/sync.py', 'services/__init__.py'], 'services.sync');
// direct package (__init__) hit
record('app/main.py', ['services/__init__.py'], 'services');
// ancestor walk hit
record('backend/routers/cron.py', ['backend/services/sync.py'], 'services.sync');
// ancestor pkg hit
record('backend/routers/cron.py', ['backend/services/__init__.py'], 'services');
// suffix fallback single match (nested vendor layout)
record('app/main.py', ['pkg/__init__.py', 'vendor/pkg/thing.py'], 'pkg.thing');
// suffix fallback to __init__ (package)
record('app/main.py', ['pkg/__init__.py', 'x/pkg/subpkg/__init__.py'], 'pkg.subpkg');
// suffix multi-match tie-break: fewest segments wins
record('app/main.py', ['pkg/__init__.py', 'a/pkg/models.py', 'b/c/pkg/models.py'], 'pkg.models');
// suffix multi-match tie-break at SAME depth: lexicographic
record('app/main.py', ['pkg/__init__.py', 'z/pkg/models.py', 'a/pkg/models.py'], 'pkg.models');
// suffix file vs pkg same name, mixed — both candidate forms present
record(
'app/main.py',
['pkg/__init__.py', 'q/pkg/models.py', 'r/pkg/models/__init__.py'],
'pkg.models',
);
// hasRepoCandidate FALSE — external dotted import w/ colliding local basename (django.apps guard)
record('app/main.py', ['accounts/apps.py'], 'django.apps');
// hasRepoCandidate TRUE via top-level package, but no concrete file -> null
record('app/main.py', ['pkg/__init__.py'], 'pkg.ghost');
// hasRepoCandidate via nested ancestor namespace package
record('backend/routers/cron.py', ['backend/services/sync.py'], 'services.helpers.util');
// collision: accounts.models must NOT match billing/models.py
record('app/main.py', ['accounts/__init__.py', 'billing/models.py'], 'accounts.models');
// relative imports
record('app/main.py', ['app/sibling.py'], '.sibling');
record('app/pkg/mod.py', ['app/sibling.py'], '..sibling');
record('app/main.py', ['app/sibling.py'], '...way.too.far');
// single-segment bare import (no '/'): skips candidate gate
record('app/main.py', ['mod.py'], 'mod');
record('app/main.py', ['lib/mod.py'], 'mod');
record('app/pkg/main.py', ['app/pkg/local.py'], 'local');
// empty / dynamic
record('app/main.py', ['a.py'], '');
// windows-style backslash paths in the set
record('app\\main.py', ['svc\\sync.py', 'svc\\__init__.py'], 'svc.sync');
// ---- 2. Deterministic fuzz ----------------------------------------------
// LCG (no Math.random — deterministic + reproducible).
let seed = 0x9e3779b9;
function rnd() {
seed = (seed * 1664525 + 1013904223) >>> 0;
return seed / 0x100000000;
}
function pick(arr) {
return arr[Math.floor(rnd() * arr.length)];
}
const DIRS = ['', 'a', 'b', 'a/b', 'b/c', 'x/y/z', 'vendor', 'src', 'src/app', 'pkg'];
const SEGS = [
'pkg',
'services',
'models',
'sync',
'util',
'core',
'apps',
'sub',
'thing',
'helpers',
];
function randPath() {
const dir = pick(DIRS);
const base = pick(SEGS);
const isPkg = rnd() < 0.3;
const file = isPkg ? `${base}/__init__.py` : `${base}.py`;
return dir ? `${dir}/${file}` : file;
}
function randDotted() {
const n = 1 + Math.floor(rnd() * 3);
const parts = [];
for (let i = 0; i < n; i++) parts.push(pick(SEGS));
const rel = rnd() < 0.15 ? '.'.repeat(1 + Math.floor(rnd() * 2)) : '';
return rel + parts.join('.');
}
for (let repo = 0; repo < 400; repo++) {
const fileCount = 3 + Math.floor(rnd() * 14);
const files = [];
for (let i = 0; i < fileCount; i++) files.push(randPath());
const fromFile = randPath();
for (let imp = 0; imp < 25; imp++) {
record(fromFile, files, randDotted());
}
}
// ---- 3. Absolute-path coverage (PR #1918 review P3a) --------------------
// Production paths are repo-relative, but the index's prefix gating must
// reproduce the old `f.startsWith(prefix)` semantics for absolute paths too.
// The reviewer's exact case + a fuzz over leading-`/` file sets and absolute
// importer paths lock the absolute-path behavior end to end.
// The flagged case: an absolute file under the importer's own root.
record('/repo/app/main.py', ['/repo/svc/x.py'], 'svc.x');
record('/repo/app/main.py', ['/repo/svc/__init__.py', '/repo/svc/x.py'], 'svc.x');
// Absolute file NOT under the importer root — gate must not pass it.
record('/repo/app/main.py', ['/other/svc/x.py'], 'svc.x');
// Absolute vendored layout reachable only by suffix.
record('/repo/app/main.py', ['/repo/pkg/__init__.py', '/repo/vendor/pkg/thing.py'], 'pkg.thing');
// Absolute tie-break.
record(
'/repo/app/main.py',
['/repo/pkg/__init__.py', '/a/pkg/models.py', '/b/c/pkg/models.py'],
'pkg.models',
);
// Mixed absolute/relative file set.
record('/repo/app/main.py', ['/repo/pkg/__init__.py', 'pkg/models.py'], 'pkg.models');
function randAbsPath() {
// Reuse the relative generator under one of a few absolute roots.
const root = pick(['/repo', '/srv/app', '/']);
const rel = randPath();
return root === '/' ? `/${rel}` : `${root}/${rel}`;
}
for (let repo = 0; repo < 200; repo++) {
const fileCount = 3 + Math.floor(rnd() * 12);
const files = [];
for (let i = 0; i < fileCount; i++) files.push(randAbsPath());
const fromFile = randAbsPath();
for (let imp = 0; imp < 20; imp++) {
record(fromFile, files, randDotted());
}
}
const fingerprint = crypto
.createHash('sha256')
.update([...lines].sort().join('\n'))
.digest('hex');
const result = { fingerprint, cases: lines.length, non_null: nonNull };
if (!process.argv.includes('--check')) {
process.stdout.write(JSON.stringify(result) + '\n');
} else {
// CI gate: resolver output unchanged (fingerprint == committed baseline).
// Re-baseline a legitimate resolution change by running without --check and
// committing the new baseline-import-target-fingerprint.txt deliberately.
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const baseline = fs
.readFileSync(path.resolve(__dirname, 'baseline-import-target-fingerprint.txt'), 'utf8')
.trim();
process.stdout.write(JSON.stringify(result) + '\n');
if (result.fingerprint !== baseline) {
process.stderr.write(
`[import-target-fingerprint --check] FAIL: resolver fingerprint drift: got ` +
`${result.fingerprint}, expected ${baseline} (resolvePythonImportTarget output changed — ` +
`re-baseline intentionally if expected)\n`,
);
process.exit(1);
}
process.stderr.write('[import-target-fingerprint --check] PASS (resolver fingerprint)\n');
}