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>
203 lines
8.0 KiB
JavaScript
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');
|
|
}
|