mirror of
https://github.com/abhigyanpatwari/GitNexus.git
synced 2026-11-16 09:22:00 +00:00
Merge branch 'abhigyanpatwari:main' into main
This commit is contained in:
commit
e5d402d77d
316 changed files with 737002 additions and 910 deletions
|
|
@ -68,6 +68,7 @@ GRAMMARS: dict[str, tuple[str, str, str]] = {
|
|||
"tree-sitter-typescript": ("tree-sitter/tree-sitter-typescript", "master", "typescript/src/parser.c"),
|
||||
# Vendored parsers — kept here so the upstream coords for drift
|
||||
# detection are co-located with every other grammar's coords.
|
||||
"tree-sitter-objc": ("tree-sitter-grammars/tree-sitter-objc", "master", "src/parser.c"),
|
||||
"tree-sitter-proto": ("coder3101/tree-sitter-proto", "main", "src/parser.c"),
|
||||
"tree-sitter-zig": ("tree-sitter-grammars/tree-sitter-zig", "master", "src/parser.c"),
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ which is deliberately dependency-free so it runs on any vanilla runner. Run with
|
|||
(pytest also discovers ``unittest.TestCase`` classes, so a future pytest CI job
|
||||
picks these up unchanged.)
|
||||
|
||||
These tests lock in the #858 fix: the 6 vendored grammars
|
||||
(c/swift/kotlin/dart/proto/zig) are classified from the shared manifest
|
||||
These tests lock in the #858 fix: the 7 vendored grammars
|
||||
(c/swift/kotlin/dart/objc/proto/zig) are classified from the shared manifest
|
||||
(.github/vendored-grammars.json), their ABI is read from gitnexus/vendor/<name>,
|
||||
and the report never renders a bare ``?`` placeholder. All network is mocked.
|
||||
"""
|
||||
|
|
@ -192,7 +192,7 @@ class AssertCurrent(TestCase):
|
|||
def test_assert_current_is_network_free_and_passes(self):
|
||||
report, code = self._run_assert_current() # raises if any urlopen fires
|
||||
self.assertEqual(code, 0)
|
||||
# All 6 vendored grammars are introspected from the repo (ABI 14), not skipped.
|
||||
# All 7 vendored grammars are introspected from the repo (ABI 14), not skipped.
|
||||
for name in readiness.VENDORED_NAMES:
|
||||
self.assertIn(f"{name}: vendored ABI", report)
|
||||
|
||||
|
|
@ -365,15 +365,16 @@ class ReportRendering(TestCase):
|
|||
# Counts are derived from _render_report()'s mock corpus (all npm peer
|
||||
# deps mocked permissive): of the 10 npm-installed grammars, 9 render
|
||||
# Ready and 1 — tree-sitter-cpp — is the intentional pin (#1242), so it is
|
||||
# not counted ready. The 3 blockers are that same pinned tree-sitter-cpp
|
||||
# plus two held vendored grammars: ABI-held tree-sitter-c (#1242/#858) and
|
||||
# not counted ready. The 4 blockers are that same pinned tree-sitter-cpp
|
||||
# plus three held vendored grammars: ABI-held tree-sitter-c (#1242/#858),
|
||||
# tree-sitter-kotlin (pinned to an unreleased fwcd main commit for `fun
|
||||
# interface` support — ABI 14 is in range, but a hold counts as a blocker
|
||||
# until it is lifted). If a grammar is added/removed or a pin/hold changes,
|
||||
# until it is lifted), and tree-sitter-objc. If a grammar is added/removed
|
||||
# or a pin/hold changes,
|
||||
# update _render_report()'s mock AND these expected counts together; a
|
||||
# mismatch here means the report prose drifted, not the regex.
|
||||
self.assertEqual(ready.groups(), ("9", "10"))
|
||||
self.assertEqual(blockers.group(1), "3")
|
||||
self.assertEqual(blockers.group(1), "4")
|
||||
|
||||
def _matrix_row(self, name: str) -> str:
|
||||
for line in self.report.splitlines():
|
||||
|
|
|
|||
2
.github/scripts/update-vendored-grammars.mjs
vendored
2
.github/scripts/update-vendored-grammars.mjs
vendored
|
|
@ -21,7 +21,7 @@
|
|||
* node update-vendored-grammars.mjs # detect only → JSON report on stdout
|
||||
* node update-vendored-grammars.mjs --apply X # re-vendor grammar X in place
|
||||
*
|
||||
* tree-sitter-c is MONITORED but report-only (`hold`): it is ABI-pinned at 0.21.4
|
||||
* tree-sitter-c and tree-sitter-objc are MONITORED but report-only (`hold`): c is ABI-pinned at 0.21.4
|
||||
* (#1242/#858) and must not auto-bump without a tree-sitter runtime upgrade, so an
|
||||
* available c update is detected + reported but never auto-applied — even if it is
|
||||
* ABI-13/14. A maintainer re-vendors it deliberately.
|
||||
|
|
|
|||
274
.github/scripts/verify-workflow-run-pr-identity.cjs
vendored
Normal file
274
.github/scripts/verify-workflow-run-pr-identity.cjs
vendored
Normal file
|
|
@ -0,0 +1,274 @@
|
|||
// Resolve the open PR for a trusted workflow_run consumer.
|
||||
//
|
||||
// Shared by commit-fork-prebuilds.yml and pr-autofix-publish.yml.
|
||||
// workflow_run.pull_requests[] is empty on fork PRs, and
|
||||
// GET /repos/{base}/commits/{sha}/pulls is also empty because the fork head
|
||||
// commit is not in the base repo's commit graph. The authoritative lookup is
|
||||
// GET /repos/{base}/pulls?head={owner}:{branch}&state=open using
|
||||
// workflow_run.head_repository + workflow_run.head_branch (server-controlled).
|
||||
// That same query works for same-repo PRs (owner is the base repo owner).
|
||||
//
|
||||
// The current PR tip may have moved past the SHA the producer built; that is
|
||||
// not an identity failure — the caller decides whether to lease-push or just
|
||||
// comment. Two open PRs from the same fork head (same owner:branch into this
|
||||
// repo) are an identity failure: artifact pr_number is untrusted and must not
|
||||
// pick among them. Set SCHEMA_PATTERN to the artifact schema allowlist
|
||||
// (defaults to the tree-sitter prebuild schema).
|
||||
'use strict';
|
||||
|
||||
const fs = require('node:fs');
|
||||
const { spawnSync } = require('node:child_process');
|
||||
|
||||
const SCHEMA_PATTERN = /^gitnexus\.ts-prebuild\/v[0-9]+$/;
|
||||
const IDENTITY_PATTERNS = {
|
||||
pr_number: /^[0-9]+$/,
|
||||
head_sha: /^[0-9a-f]{40}$/,
|
||||
head_ref: /^[A-Za-z0-9._/-]+$/,
|
||||
repo: /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/,
|
||||
};
|
||||
|
||||
function allowlistField(key, value, pattern) {
|
||||
const text = value == null ? '' : String(value);
|
||||
if (!text || !pattern.test(text)) {
|
||||
throw new Error(`metadata.${key} failed allowlist (got: ${JSON.stringify(text)})`);
|
||||
}
|
||||
return text;
|
||||
}
|
||||
|
||||
function forkHeadOwner(headRepo) {
|
||||
const slash = headRepo.indexOf('/');
|
||||
if (slash <= 0 || slash === headRepo.length - 1) {
|
||||
throw new Error(`head_repo must be owner/name (got: ${JSON.stringify(headRepo)})`);
|
||||
}
|
||||
return headRepo.slice(0, slash);
|
||||
}
|
||||
|
||||
function compileSchemaPattern(value) {
|
||||
if (value instanceof RegExp) return value;
|
||||
if (typeof value === 'string' && value.length > 0) {
|
||||
try {
|
||||
return new RegExp(value);
|
||||
} catch {
|
||||
throw new Error('SCHEMA_PATTERN is not a valid regular expression');
|
||||
}
|
||||
}
|
||||
return SCHEMA_PATTERN;
|
||||
}
|
||||
|
||||
function allowlistMetadata(raw, schemaPattern) {
|
||||
const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
|
||||
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
||||
throw new Error('metadata.json must be an object');
|
||||
}
|
||||
return {
|
||||
schema: allowlistField('schema', parsed.schema, compileSchemaPattern(schemaPattern)),
|
||||
pr_number: allowlistField('pr_number', parsed.pr_number, IDENTITY_PATTERNS.pr_number),
|
||||
head_sha: allowlistField('head_sha', parsed.head_sha, IDENTITY_PATTERNS.head_sha),
|
||||
head_ref: allowlistField('head_ref', parsed.head_ref, IDENTITY_PATTERNS.head_ref),
|
||||
head_repo: allowlistField('head_repo', parsed.head_repo, IDENTITY_PATTERNS.repo),
|
||||
base_repo: allowlistField('base_repo', parsed.base_repo, IDENTITY_PATTERNS.repo),
|
||||
};
|
||||
}
|
||||
|
||||
function allowlistAuthority(authority) {
|
||||
return {
|
||||
head_sha: allowlistField('head_sha', authority.head_sha, IDENTITY_PATTERNS.head_sha),
|
||||
head_repo: allowlistField('head_repo', authority.head_repo, IDENTITY_PATTERNS.repo),
|
||||
head_branch: allowlistField('head_ref', authority.head_branch, IDENTITY_PATTERNS.head_ref),
|
||||
base_repo: allowlistField('base_repo', authority.base_repo, IDENTITY_PATTERNS.repo),
|
||||
};
|
||||
}
|
||||
|
||||
function verifyArtifactAgainstWorkflowRun(meta, authority) {
|
||||
if (meta.head_sha !== authority.head_sha) {
|
||||
throw new Error(
|
||||
`Artifact head_sha (${meta.head_sha}) != workflow_run.head_sha (${authority.head_sha}) — refusing.`,
|
||||
);
|
||||
}
|
||||
if (meta.head_repo !== authority.head_repo) {
|
||||
throw new Error(
|
||||
`Artifact head_repo (${meta.head_repo}) != workflow_run.head_repository (${authority.head_repo}) — refusing.`,
|
||||
);
|
||||
}
|
||||
if (meta.base_repo !== authority.base_repo) {
|
||||
throw new Error('Artifact base_repo does not match $GITHUB_REPOSITORY — refusing.');
|
||||
}
|
||||
if (meta.head_ref !== authority.head_branch) {
|
||||
throw new Error(
|
||||
`Artifact head_ref (${meta.head_ref}) != workflow_run.head_branch (${authority.head_branch}) — refusing.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function matchOpenPullsFromForkHead(pulls, { headRepo, headBranch, baseRepo }) {
|
||||
if (!Array.isArray(pulls)) {
|
||||
throw new Error('GitHub pulls?head= lookup returned a non-array');
|
||||
}
|
||||
return pulls.filter((pr) => {
|
||||
return (
|
||||
pr &&
|
||||
pr.state === 'open' &&
|
||||
Number.isInteger(pr.number) &&
|
||||
pr.head &&
|
||||
pr.head.repo &&
|
||||
pr.head.repo.full_name === headRepo &&
|
||||
pr.head.ref === headBranch &&
|
||||
pr.base &&
|
||||
pr.base.repo &&
|
||||
pr.base.repo.full_name === baseRepo
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
function resolveVerifiedPullRequest({ meta, authority, pulls, schemaPattern }) {
|
||||
const cleanMeta = allowlistMetadata(meta, schemaPattern);
|
||||
const cleanAuthority = allowlistAuthority(authority);
|
||||
verifyArtifactAgainstWorkflowRun(cleanMeta, cleanAuthority);
|
||||
|
||||
const matched = matchOpenPullsFromForkHead(pulls, {
|
||||
headRepo: cleanAuthority.head_repo,
|
||||
headBranch: cleanAuthority.head_branch,
|
||||
baseRepo: cleanAuthority.base_repo,
|
||||
});
|
||||
|
||||
if (matched.length === 0) {
|
||||
throw new Error(
|
||||
`No open PR from ${cleanAuthority.head_repo}:${cleanAuthority.head_branch} targeting ${cleanAuthority.base_repo} — refusing.`,
|
||||
);
|
||||
}
|
||||
|
||||
// Artifact pr_number is untrusted. Do not use it to pick among several open
|
||||
// PRs that share this fork head (same owner:branch into this repo, different
|
||||
// base branches). Fail closed unless GitHub-controlled fields leave exactly one.
|
||||
if (matched.length !== 1) {
|
||||
throw new Error(
|
||||
`Ambiguous open PRs from ${cleanAuthority.head_repo}:${cleanAuthority.head_branch} targeting ${cleanAuthority.base_repo} (${matched
|
||||
.map((pr) => pr.number)
|
||||
.join(',')}) — refusing.`,
|
||||
);
|
||||
}
|
||||
|
||||
const chosen = matched[0];
|
||||
const expected = Number(cleanMeta.pr_number);
|
||||
if (chosen.number !== expected) {
|
||||
throw new Error(
|
||||
`Artifact pr_number (${cleanMeta.pr_number}) is not the open PR(s) from this fork head (${chosen.number}) — refusing.`,
|
||||
);
|
||||
}
|
||||
|
||||
const currentHeadSha = typeof chosen.head.sha === 'string' ? chosen.head.sha : '';
|
||||
return {
|
||||
pr_number: String(chosen.number),
|
||||
head_ref: cleanAuthority.head_branch,
|
||||
head_sha: cleanAuthority.head_sha,
|
||||
head_repo: cleanAuthority.head_repo,
|
||||
current_head_sha: currentHeadSha,
|
||||
branch_moved: Boolean(currentHeadSha && currentHeadSha !== cleanAuthority.head_sha),
|
||||
};
|
||||
}
|
||||
|
||||
function flattenGhListPages(parsed) {
|
||||
if (!Array.isArray(parsed)) {
|
||||
throw new Error('GitHub pulls?head= lookup returned a non-array');
|
||||
}
|
||||
if (parsed.length === 0) return parsed;
|
||||
if (parsed.every((page) => Array.isArray(page))) {
|
||||
return parsed.flat();
|
||||
}
|
||||
return parsed;
|
||||
}
|
||||
|
||||
function listOpenPullsByHead({ ghRepo, headOwner, headBranch, runGh }) {
|
||||
const run = runGh || ((args) => spawnSync('gh', args, { encoding: 'utf8' }));
|
||||
const result = run([
|
||||
'api',
|
||||
'--paginate',
|
||||
'--slurp',
|
||||
'-X',
|
||||
'GET',
|
||||
`repos/${ghRepo}/pulls`,
|
||||
'-f',
|
||||
'state=open',
|
||||
'-f',
|
||||
`head=${headOwner}:${headBranch}`,
|
||||
]);
|
||||
if (result.status !== 0) {
|
||||
const err = (result.stderr || result.stdout || '').trim();
|
||||
throw new Error(`GitHub pulls?head= lookup failed: ${err || `exit ${result.status}`}`);
|
||||
}
|
||||
const stdout = (result.stdout || '').trim();
|
||||
if (!stdout) {
|
||||
throw new Error('GitHub pulls?head= lookup returned an empty body');
|
||||
}
|
||||
let parsed;
|
||||
try {
|
||||
parsed = JSON.parse(stdout);
|
||||
} catch {
|
||||
throw new Error('GitHub pulls?head= lookup returned non-JSON');
|
||||
}
|
||||
return flattenGhListPages(parsed);
|
||||
}
|
||||
|
||||
function main() {
|
||||
const schemaPattern = compileSchemaPattern(process.env.SCHEMA_PATTERN);
|
||||
const raw = fs.readFileSync(process.env.META_PATH, 'utf8');
|
||||
const meta = allowlistMetadata(raw, schemaPattern);
|
||||
const authority = allowlistAuthority({
|
||||
head_sha: process.env.WF_HEAD_SHA,
|
||||
head_repo: process.env.WF_HEAD_REPO,
|
||||
head_branch: process.env.WF_HEAD_BRANCH,
|
||||
base_repo: process.env.GH_REPO,
|
||||
});
|
||||
const pulls = listOpenPullsByHead({
|
||||
ghRepo: authority.base_repo,
|
||||
headOwner: forkHeadOwner(authority.head_repo),
|
||||
headBranch: authority.head_branch,
|
||||
});
|
||||
const verified = resolveVerifiedPullRequest({ meta, authority, pulls, schemaPattern });
|
||||
if (verified.branch_moved) {
|
||||
console.log(
|
||||
`PR head moved to ${verified.current_head_sha}; delivering against built SHA ${verified.head_sha} (lease will refuse if the branch moved).`,
|
||||
);
|
||||
}
|
||||
console.log(
|
||||
`Verified identity: PR=${verified.pr_number} head_sha=${verified.head_sha} head_repo=${verified.head_repo} head_ref=${verified.head_ref}.`,
|
||||
);
|
||||
const out = process.env.GITHUB_OUTPUT;
|
||||
if (!out) {
|
||||
throw new Error('GITHUB_OUTPUT is unset');
|
||||
}
|
||||
fs.appendFileSync(
|
||||
out,
|
||||
[
|
||||
`pr_number=${verified.pr_number}`,
|
||||
`head_ref=${verified.head_ref}`,
|
||||
`head_sha=${verified.head_sha}`,
|
||||
`head_repo=${verified.head_repo}`,
|
||||
].join('\n') + '\n',
|
||||
);
|
||||
}
|
||||
|
||||
if (require.main === module) {
|
||||
try {
|
||||
main();
|
||||
} catch (err) {
|
||||
console.error(`::error::${err instanceof Error ? err.message : String(err)}`);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
SCHEMA_PATTERN,
|
||||
IDENTITY_PATTERNS,
|
||||
allowlistField,
|
||||
compileSchemaPattern,
|
||||
allowlistMetadata,
|
||||
allowlistAuthority,
|
||||
forkHeadOwner,
|
||||
verifyArtifactAgainstWorkflowRun,
|
||||
matchOpenPullsFromForkHead,
|
||||
flattenGhListPages,
|
||||
resolveVerifiedPullRequest,
|
||||
listOpenPullsByHead,
|
||||
main,
|
||||
};
|
||||
5
.github/vendored-grammars.json
vendored
5
.github/vendored-grammars.json
vendored
|
|
@ -6,6 +6,11 @@
|
|||
"upstream": { "npm": "tree-sitter-c" },
|
||||
"hold": "ABI-pinned at 0.21.4 (#1242/#858) — needs a tree-sitter runtime upgrade before bumping"
|
||||
},
|
||||
"objc": {
|
||||
"name": "tree-sitter-objc",
|
||||
"upstream": { "npm": "tree-sitter-objc" },
|
||||
"hold": "Pinned at 3.0.2 for the Objective-C provider MVP; carries darwin/linux arm64+x64 prebuilds compatible with the current tree-sitter runtime (linux-arm64 built from vendored source because the upstream npm artifact is mislabeled)"
|
||||
},
|
||||
"swift": {
|
||||
"name": "tree-sitter-swift",
|
||||
"upstream": { "npm": "tree-sitter-swift" }
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ name: Build tree-sitter prebuilds
|
|||
#
|
||||
# Grammars covered here (the at-risk set — everything else already ships 6
|
||||
# upstream prebuilds AND stays dependency-review-tracked, so it is left alone).
|
||||
# All five are vendored under gitnexus/vendor/; `kind` (below) only picks where
|
||||
# All seven are vendored under gitnexus/vendor/; `kind` (below) only picks where
|
||||
# the build job fetches the C source to compile:
|
||||
# - tree-sitter-c (vendored prebuild-only; built from the published npm
|
||||
# package — closes upstream's 4/6 ARM gap #2116 for a
|
||||
|
|
@ -17,6 +17,8 @@ name: Build tree-sitter prebuilds
|
|||
# - tree-sitter-kotlin (vendored source; built from gitnexus/vendor/ — pinned to
|
||||
# an unreleased main commit for `fun interface` support
|
||||
# (#169) that no npm release carries yet)
|
||||
# - tree-sitter-objc (vendored source; built from gitnexus/vendor/ — pinned
|
||||
# for the Objective-C provider MVP)
|
||||
# - tree-sitter-swift (vendored source; built from gitnexus/vendor/ — its
|
||||
# prebuilds were originally upstream-shipped, now
|
||||
# GitNexus-cross-built like the rest for uniformity)
|
||||
|
|
@ -24,13 +26,13 @@ name: Build tree-sitter prebuilds
|
|||
# off npm optionalDependency so `npm i -g gitnexus`
|
||||
# no longer warns on peerOptional tree-sitter@^0.22.1.
|
||||
# Upstream linux-arm64 prebuild is a mispackaged
|
||||
# x86-64 binary; this workflow rebuilds all six.)
|
||||
# x86-64 binary; this workflow rebuilds all seven.)
|
||||
#
|
||||
# Output: gitnexus/vendor/<grammar>/prebuilds/<platform-arch>/<grammar>.node for
|
||||
# all 6 targets ({linux,darwin,win32}-{x64,arm64}). tree-sitter grammars are
|
||||
# N-API, so one ABI-stable .node per platform-arch works across all Node majors.
|
||||
#
|
||||
# COST DISCIPLINE — this is a HEAVY native matrix (up to 3 grammars x 6 runners,
|
||||
# COST DISCIPLINE — this is a HEAVY native matrix (up to 7 grammars x 6 runners,
|
||||
# incl. macOS + arm64). It is DELIBERATELY NOT wired into normal PR/push CI. It
|
||||
# runs only:
|
||||
# 1. on manual dispatch (workflow_dispatch); or
|
||||
|
|
@ -61,7 +63,7 @@ on:
|
|||
workflow_dispatch:
|
||||
inputs:
|
||||
grammars:
|
||||
description: 'Comma-separated grammar shortnames to build (c,dart,proto,kotlin,swift,zig), or "all".'
|
||||
description: 'Comma-separated grammar shortnames to build (c,dart,proto,kotlin,objc,swift,zig), or "all".'
|
||||
required: false
|
||||
type: string
|
||||
default: 'all'
|
||||
|
|
@ -93,7 +95,7 @@ on:
|
|||
- '!gitnexus/vendor/tree-sitter-*/prebuilds/**'
|
||||
# Self-test: re-run the guard if a future grammar pin is reintroduced in
|
||||
# the main package.json (optionalDependencies fallback). No-op otherwise —
|
||||
# all six grammars are now fully vendored (kotlin and zig included).
|
||||
# all seven grammars are now fully vendored (including kotlin, objc, and zig).
|
||||
- 'gitnexus/package.json'
|
||||
# Self-test: re-run the guard (normally a no-op) when the recipe changes.
|
||||
- '.github/workflows/build-tree-sitter-prebuilds.yml'
|
||||
|
|
@ -163,6 +165,9 @@ jobs:
|
|||
// unreleased main commit for `fun interface` support (#169) that no
|
||||
// npm release carries yet — so it must build from the vendored source.
|
||||
kotlin: { name: 'tree-sitter-kotlin', kind: 'vendored' },
|
||||
// Objective-C is vendored WITH its source and its native bindings
|
||||
// must be recut together with the pinned grammar snapshot.
|
||||
objc: { name: 'tree-sitter-objc', kind: 'vendored' },
|
||||
// swift is vendored WITH its source (parser.c/scanner.c/binding.gyp),
|
||||
// so it builds from gitnexus/vendor/ like dart/proto. Its prebuilds
|
||||
// were originally upstream-shipped; rebuilding them here unifies it.
|
||||
|
|
@ -505,6 +510,7 @@ jobs:
|
|||
dart: "void main() { print(\"hi\"); }",
|
||||
proto: "syntax = \"proto3\";\nmessage M { int32 id = 1; }",
|
||||
kotlin: "fun main() { println(\"hi\") }",
|
||||
objc: "@interface GNValidationProbe : NSObject\n@end",
|
||||
swift: "func greet() { print(\"hi\") }",
|
||||
zig: "pub fn main() void {}",
|
||||
};
|
||||
|
|
|
|||
40
.github/workflows/ci-tests.yml
vendored
40
.github/workflows/ci-tests.yml
vendored
|
|
@ -718,6 +718,13 @@ jobs:
|
|||
run: node --import tsx bench/kotlin-import-target/measure.mjs --check
|
||||
working-directory: gitnexus
|
||||
|
||||
- name: Ruby gem-boundary correctness + scaling guards (#3096)
|
||||
if: ${{ !cancelled() }}
|
||||
# Includes real manifest loading; checks scoped resolution and scaling
|
||||
# as sibling projects or declared gem counts grow independently.
|
||||
run: node --import tsx bench/ruby-gem-resolution/measure.mjs --check
|
||||
working-directory: gitnexus
|
||||
|
||||
- name: Receiver-resolution drop guards
|
||||
if: ${{ !cancelled() }}
|
||||
# NOT build-free: this one runs the real pipeline, so it needs dist/
|
||||
|
|
@ -764,6 +771,28 @@ jobs:
|
|||
run: node --import tsx bench/zig-cross-file-resolution/measure.mjs --check
|
||||
working-directory: gitnexus
|
||||
|
||||
- name: Objective-C workspace resolution guards (#3179)
|
||||
if: ${{ !cancelled() }}
|
||||
# Build-free: fingerprints spread (typed self/super/sibling) and
|
||||
# protocol-candidate evidence, and gates linear file-count scaling
|
||||
# of emitPostResolutionEdges. Import lookup is the shared
|
||||
# import-target `objc` arm; this is the C#/Zig analog for the
|
||||
# workspace message-send pass.
|
||||
run: node --import tsx bench/objective-c-resolution/measure.mjs --check
|
||||
working-directory: gitnexus
|
||||
|
||||
- name: Callable-value reference resolution guards (#3399)
|
||||
if: ${{ !cancelled() }}
|
||||
# Build-free: pins the resolved-target SET of `resolveValueRefTarget`
|
||||
# (exact site/resolved/declined counts plus an order-independent
|
||||
# fingerprint) and asserts its per-site cost stays independent of
|
||||
# workspace size across a 4x file-count step. The pass resolves a
|
||||
# qualified receiver through `scopes.qualifiedNames`, a workspace-wide
|
||||
# index: keyed it is O(1) per site, scanned it is O(files) — a
|
||||
# regression a fixture cannot see and a 257-file binding table can.
|
||||
run: node --import tsx bench/value-ref-resolution/measure.mjs --check
|
||||
working-directory: gitnexus
|
||||
|
||||
- name: CFG construction time / disk / memory guards (#2081 M1)
|
||||
if: ${{ !cancelled() }}
|
||||
# Build-free: asserts collectFunctionCfgs output is unchanged
|
||||
|
|
@ -803,11 +832,13 @@ jobs:
|
|||
# guards they hold never run in the main coverage job.
|
||||
env:
|
||||
GITNEXUS_BENCH: '1'
|
||||
GITNEXUS_WORKER_READY_TIMEOUT_MS: '60000'
|
||||
run: >-
|
||||
npx vitest run --no-file-parallelism
|
||||
test/integration/cobol-pipeline-benchmark.test.ts
|
||||
test/integration/csharp-pipeline-benchmark.test.ts
|
||||
test/integration/csharp-razor-view-components-benchmark.test.ts
|
||||
test/integration/objective-c-pipeline-benchmark.test.ts
|
||||
test/integration/cpp-adl-benchmark.test.ts
|
||||
test/integration/data-route-table-benchmark.test.ts
|
||||
test/integration/instance-ownership-pipeline-benchmark.test.ts
|
||||
|
|
@ -846,6 +877,11 @@ jobs:
|
|||
timeout-minutes: 20
|
||||
env:
|
||||
GITNEXUS_REQUIRE_BWRAP_CANARY: '1'
|
||||
# This job installs bubblewrap, the pinned runtime and a built GitNexus,
|
||||
# so the offline sweep runs here with nothing provisioning-stubbed: real
|
||||
# containment, real mounts, real graph. A missing piece fails the job
|
||||
# rather than silently falling back to the stubbed path.
|
||||
GITNEXUS_REQUIRE_FULL_SWEEP: '1'
|
||||
GITNEXUS_REQUIRE_CLAUDE_CANARY: '1'
|
||||
steps:
|
||||
- uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
|
||||
|
|
@ -904,7 +940,9 @@ jobs:
|
|||
tests/test_process_control.py
|
||||
tests/test_proposer_sandbox.py
|
||||
tests/test_workflow_bench_sessions.py
|
||||
tests/test_ce_plugin_runtime.py -q
|
||||
tests/test_ce_plugin_runtime.py
|
||||
tests/test_offline_sweep_integration.py
|
||||
tests/test_mock_provider.py -q
|
||||
working-directory: eval
|
||||
|
||||
# Native Windows Job Object canary. POSIX-only tests skip by platform, while
|
||||
|
|
|
|||
79
.github/workflows/commit-fork-prebuilds.yml
vendored
79
.github/workflows/commit-fork-prebuilds.yml
vendored
|
|
@ -135,68 +135,53 @@ jobs:
|
|||
# workflow_run event. The allowlist above only proves the fields are
|
||||
# well-formed — not that they refer to the PR/SHA that actually triggered
|
||||
# us. A fork-controlled build could mutate metadata.json to reference
|
||||
# another PR/SHA and redirect our write-scoped push. Authority sources are
|
||||
# all server-controlled: workflow_run.head_sha, head_repository.full_name,
|
||||
# and pull_requests[].number (empty on forks -> commits/{sha}/pulls).
|
||||
# another PR/SHA and redirect our write-scoped push.
|
||||
#
|
||||
# This job's `if:` already restricts to forks, so pull_requests[] is empty
|
||||
# by design and GET /repos/{base}/commits/{sha}/pulls is also empty (the
|
||||
# fork commit is not in the base graph). Authority is workflow_run.head_sha
|
||||
# + head_repository.full_name + head_branch, resolved via
|
||||
# pulls?head={owner}:{branch}. The script comes from THIS default-branch
|
||||
# checkout (the same trust anchor as this workflow file).
|
||||
- name: Checkout identity verifier
|
||||
if: steps.meta.outputs.deliver == 'true'
|
||||
uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
|
||||
with:
|
||||
persist-credentials: false
|
||||
sparse-checkout: .github/scripts/verify-workflow-run-pr-identity.cjs
|
||||
sparse-checkout-cone-mode: false
|
||||
path: trusted
|
||||
|
||||
- name: Verify metadata against workflow_run authority
|
||||
id: verify
|
||||
if: steps.meta.outputs.deliver == 'true'
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
GH_REPO: ${{ github.repository }}
|
||||
META_PR_NUMBER: ${{ steps.meta.outputs.pr_number }}
|
||||
META_HEAD_SHA: ${{ steps.meta.outputs.head_sha }}
|
||||
META_HEAD_REPO: ${{ steps.meta.outputs.head_repo }}
|
||||
META_PATH: meta-in/metadata.json
|
||||
SCHEMA_PATTERN: '^gitnexus\.ts-prebuild/v[0-9]+$'
|
||||
WF_HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
|
||||
WF_HEAD_REPO: ${{ github.event.workflow_run.head_repository.full_name }}
|
||||
WF_PR_NUMBERS: ${{ toJSON(github.event.workflow_run.pull_requests.*.number) }}
|
||||
WF_HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
|
||||
shell: bash
|
||||
run: |
|
||||
set -euo pipefail
|
||||
|
||||
# 1) head_sha must match exactly — the commit GitHub ran the producer against.
|
||||
if [ "${META_HEAD_SHA}" != "${WF_HEAD_SHA}" ]; then
|
||||
echo "::error::Artifact head_sha (${META_HEAD_SHA}) != workflow_run.head_sha (${WF_HEAD_SHA}) — refusing."
|
||||
exit 1
|
||||
fi
|
||||
# 2) head_repo must match exactly.
|
||||
if [ "${META_HEAD_REPO}" != "${WF_HEAD_REPO}" ]; then
|
||||
echo "::error::Artifact head_repo (${META_HEAD_REPO}) != workflow_run.head_repository (${WF_HEAD_REPO}) — refusing."
|
||||
exit 1
|
||||
fi
|
||||
# 3) pr_number must reference an open PR with this head SHA. Forks have
|
||||
# an empty pull_requests[] by design — fall back to commits/{sha}/pulls.
|
||||
allowed_numbers=$(jq -c '.' <<< "${WF_PR_NUMBERS}")
|
||||
if [ "${allowed_numbers}" = "[]" ]; then
|
||||
echo "workflow_run.pull_requests empty (fork) — using commits/{sha}/pulls."
|
||||
allowed_numbers=$(gh api "repos/${GH_REPO}/commits/${WF_HEAD_SHA}/pulls" \
|
||||
--jq '[.[] | select(.state == "open") | .number]' 2>/dev/null || echo "[]")
|
||||
if [ "${allowed_numbers}" = "[]" ]; then
|
||||
echo "::error::No open PR for head ${WF_HEAD_SHA} — refusing."
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
if ! jq -e --argjson n "${META_PR_NUMBER}" 'index($n) != null' <<< "${allowed_numbers}" >/dev/null; then
|
||||
echo "::error::Artifact pr_number (${META_PR_NUMBER}) not in authoritative list (${allowed_numbers}) — refusing."
|
||||
exit 1
|
||||
fi
|
||||
echo "Verified identity: PR=${META_PR_NUMBER} head_sha=${META_HEAD_SHA} head_repo=${META_HEAD_REPO}."
|
||||
run: node trusted/.github/scripts/verify-workflow-run-pr-identity.cjs
|
||||
|
||||
# Pinned to v6.0.3 (same SHA used by build-tree-sitter-prebuilds.yml).
|
||||
# persist-credentials: false — push auth is provided inline at push time,
|
||||
# never written to .git/config on disk.
|
||||
- name: Checkout fork PR head
|
||||
if: steps.meta.outputs.deliver == 'true'
|
||||
if: steps.meta.outputs.deliver == 'true' && steps.verify.outcome == 'success'
|
||||
uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
|
||||
with:
|
||||
repository: ${{ steps.meta.outputs.head_repo }}
|
||||
ref: ${{ steps.meta.outputs.head_sha }}
|
||||
repository: ${{ steps.verify.outputs.head_repo }}
|
||||
ref: ${{ steps.verify.outputs.head_sha }}
|
||||
token: ${{ secrets.GITHUB_TOKEN }}
|
||||
persist-credentials: false
|
||||
fetch-depth: 0
|
||||
path: pr-checkout
|
||||
|
||||
- name: Place prebuilds into the fork checkout
|
||||
if: steps.meta.outputs.deliver == 'true'
|
||||
if: steps.meta.outputs.deliver == 'true' && steps.verify.outcome == 'success'
|
||||
env:
|
||||
DL: prebuilds-in
|
||||
CHECKOUT: pr-checkout
|
||||
|
|
@ -238,12 +223,12 @@ jobs:
|
|||
|
||||
- name: Commit and push to the fork branch
|
||||
id: push
|
||||
if: steps.meta.outputs.deliver == 'true'
|
||||
if: steps.meta.outputs.deliver == 'true' && steps.verify.outcome == 'success'
|
||||
working-directory: pr-checkout
|
||||
env:
|
||||
HEAD_REF: ${{ steps.meta.outputs.head_ref }}
|
||||
HEAD_REPO: ${{ steps.meta.outputs.head_repo }}
|
||||
HEAD_SHA: ${{ steps.meta.outputs.head_sha }}
|
||||
HEAD_REF: ${{ steps.verify.outputs.head_ref }}
|
||||
HEAD_REPO: ${{ steps.verify.outputs.head_repo }}
|
||||
HEAD_SHA: ${{ steps.verify.outputs.head_sha }}
|
||||
# Push auth only — supplied via env, never interpolated into the command.
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
shell: bash
|
||||
|
|
@ -303,11 +288,11 @@ jobs:
|
|||
fi
|
||||
|
||||
- name: Comment delivery outcome
|
||||
if: always() && steps.meta.outputs.deliver == 'true' && steps.push.outcome != 'skipped'
|
||||
if: always() && steps.meta.outputs.deliver == 'true' && steps.verify.outcome == 'success' && steps.push.outcome != 'skipped'
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
GH_REPO: ${{ github.repository }}
|
||||
PR: ${{ steps.meta.outputs.pr_number }}
|
||||
PR: ${{ steps.verify.outputs.pr_number }}
|
||||
RESULT: ${{ steps.push.outputs.result }}
|
||||
RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
|
||||
shell: bash
|
||||
|
|
|
|||
2
.github/workflows/docker.yml
vendored
2
.github/workflows/docker.yml
vendored
|
|
@ -138,7 +138,7 @@ jobs:
|
|||
|
||||
# Required for multi-platform (linux/arm64) emulation.
|
||||
- name: Set up QEMU
|
||||
uses: docker/setup-qemu-action@96fe6ef7f33517b61c61be40b68a1882f3264fb8 # v4.2.0
|
||||
uses: docker/setup-qemu-action@1f40c72289eff860ee54a304f1438e3cff362e0a # v4.3.0
|
||||
|
||||
- name: Set up Docker Buildx
|
||||
uses: docker/setup-buildx-action@37fe631027851001ddb9b187196cc803df7f5f0e # v4.3.0
|
||||
|
|
|
|||
77
.github/workflows/pr-autofix-publish.yml
vendored
77
.github/workflows/pr-autofix-publish.yml
vendored
|
|
@ -121,64 +121,35 @@ jobs:
|
|||
# metadata.json to reference another PR or SHA, redirecting our
|
||||
# write-scoped sticky/check-run onto an attacker-chosen target.
|
||||
#
|
||||
# Authority sources are all server-controlled GitHub event fields:
|
||||
# - workflow_run.head_sha
|
||||
# - workflow_run.head_repository.full_name
|
||||
# - workflow_run.pull_requests[].number (within-repo PRs only;
|
||||
# empty array on fork PRs — fall back to commits/{sha}/pulls)
|
||||
# Authority is workflow_run.head_sha + head_repository.full_name +
|
||||
# head_branch, resolved via pulls?head={owner}:{branch}. That query
|
||||
# works for same-repo PRs and forks; commits/{sha}/pulls is empty
|
||||
# for fork SHAs. The script comes from THIS default-branch checkout
|
||||
# (the same trust anchor as this workflow file).
|
||||
#
|
||||
# Always verify — including the changed_lines=0 path — so the
|
||||
# check-run SHA cannot be an unverified artifact field.
|
||||
# Mismatch => fail loud BEFORE any sticky/check-run side effect.
|
||||
- name: Checkout identity verifier
|
||||
uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
|
||||
with:
|
||||
persist-credentials: false
|
||||
sparse-checkout: .github/scripts/verify-workflow-run-pr-identity.cjs
|
||||
sparse-checkout-cone-mode: false
|
||||
path: trusted
|
||||
|
||||
- name: Verify metadata against workflow_run authority
|
||||
id: verify
|
||||
if: steps.meta.outputs.changed_lines != '0'
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
GH_REPO: ${{ github.repository }}
|
||||
META_PR_NUMBER: ${{ steps.meta.outputs.pr_number }}
|
||||
META_HEAD_SHA: ${{ steps.meta.outputs.head_sha }}
|
||||
META_HEAD_REPO: ${{ steps.meta.outputs.head_repo }}
|
||||
META_PATH: autofix-in/metadata.json
|
||||
SCHEMA_PATTERN: '^gitnexus\.pr-autofix/v[0-9]+$'
|
||||
WF_HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
|
||||
WF_HEAD_REPO: ${{ github.event.workflow_run.head_repository.full_name }}
|
||||
WF_PR_NUMBERS: ${{ toJSON(github.event.workflow_run.pull_requests.*.number) }}
|
||||
WF_HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
|
||||
shell: bash
|
||||
run: |
|
||||
set -euo pipefail
|
||||
|
||||
# 1) head_sha must match exactly. workflow_run.head_sha is the
|
||||
# commit GitHub actually ran the producer against — definitive.
|
||||
if [ "${META_HEAD_SHA}" != "${WF_HEAD_SHA}" ]; then
|
||||
echo "::error::Artifact head_sha (${META_HEAD_SHA}) does not match workflow_run.head_sha (${WF_HEAD_SHA}) — refusing to publish."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# 2) head_repo must match exactly. Same authority anchor.
|
||||
if [ "${META_HEAD_REPO}" != "${WF_HEAD_REPO}" ]; then
|
||||
echo "::error::Artifact head_repo (${META_HEAD_REPO}) does not match workflow_run.head_repository (${WF_HEAD_REPO}) — refusing to publish."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# 3) pr_number must reference an open PR with this head SHA.
|
||||
# Within-repo PRs: workflow_run.pull_requests[] is populated.
|
||||
# Fork PRs: that array is empty by GitHub design — fall back
|
||||
# to the REST commit-to-PRs lookup. Fail closed if the lookup
|
||||
# finds no matching open PR (avoids attacker-forged PR ids).
|
||||
allowed_numbers=$(jq -c '.' <<< "${WF_PR_NUMBERS}")
|
||||
if [ "${allowed_numbers}" = "[]" ]; then
|
||||
echo "workflow_run.pull_requests is empty (fork PR) — falling back to commits/{sha}/pulls."
|
||||
allowed_numbers=$(gh api "repos/${GH_REPO}/commits/${WF_HEAD_SHA}/pulls" \
|
||||
--jq '[.[] | select(.state == "open") | .number]' 2>/dev/null || echo "[]")
|
||||
if [ "${allowed_numbers}" = "[]" ]; then
|
||||
echo "::error::No open PR found for head ${WF_HEAD_SHA} via commits/{sha}/pulls — refusing to publish."
|
||||
exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
if ! jq -e --argjson n "${META_PR_NUMBER}" 'index($n) != null' <<< "${allowed_numbers}" >/dev/null; then
|
||||
echo "::error::Artifact pr_number (${META_PR_NUMBER}) is not in the authoritative PR list (${allowed_numbers}) — refusing to publish."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Verified: metadata identity matches workflow_run authority (PR=${META_PR_NUMBER}, head_sha=${META_HEAD_SHA}, head_repo=${META_HEAD_REPO})."
|
||||
run: node trusted/.github/scripts/verify-workflow-run-pr-identity.cjs
|
||||
|
||||
- name: Upsert sticky summary comment
|
||||
# Only post when ci-quality found something fixable (= the
|
||||
|
|
@ -187,14 +158,14 @@ jobs:
|
|||
# so we skip it.
|
||||
if: >-
|
||||
always()
|
||||
&& steps.meta.outputs.pr_number != ''
|
||||
&& steps.verify.outcome == 'success'
|
||||
&& steps.meta.outputs.changed_lines != '0'
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
GH_REPO: ${{ github.repository }}
|
||||
PR: ${{ steps.meta.outputs.pr_number }}
|
||||
PR: ${{ steps.verify.outputs.pr_number }}
|
||||
CHANGED: ${{ steps.meta.outputs.changed_lines }}
|
||||
HEAD_SHA: ${{ steps.meta.outputs.head_sha }}
|
||||
HEAD_SHA: ${{ steps.verify.outputs.head_sha }}
|
||||
RUN_ID: ${{ github.run_id }}
|
||||
shell: bash
|
||||
run: |
|
||||
|
|
@ -285,11 +256,11 @@ jobs:
|
|||
# fixes-available → conclusion: neutral
|
||||
# `neutral` does not block branch-protection required-checks but
|
||||
# is visually distinct from a green pass.
|
||||
if: always() && steps.meta.outputs.head_sha != ''
|
||||
if: always() && steps.verify.outcome == 'success'
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
GH_REPO: ${{ github.repository }}
|
||||
HEAD_SHA: ${{ steps.meta.outputs.head_sha }}
|
||||
HEAD_SHA: ${{ steps.verify.outputs.head_sha }}
|
||||
CHANGED: ${{ steps.meta.outputs.changed_lines }}
|
||||
shell: bash
|
||||
run: |
|
||||
|
|
|
|||
2
.github/workflows/publish.yml
vendored
2
.github/workflows/publish.yml
vendored
|
|
@ -831,7 +831,7 @@ jobs:
|
|||
fi
|
||||
|
||||
- name: Create GitHub Release
|
||||
uses: softprops/action-gh-release@3d0d9888cb7fd7b750713d6e236d1fcb99157228 # v2
|
||||
uses: softprops/action-gh-release@efb35369e0ad2afab669f228072c1b0d510eae64 # v2
|
||||
with:
|
||||
tag_name: ${{ steps.vtag-gate.outputs.vtag }}
|
||||
name: >-
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ name: Tree-sitter Upgrade Readiness
|
|||
# 1. Peer-dep compatibility — can each NPM-installed grammar install cleanly
|
||||
# with tree-sitter@0.25.0 without --legacy-peer-deps?
|
||||
# 2. Vendored grammars — each grammar in .github/vendored-grammars.json
|
||||
# (c/swift/kotlin/dart/proto) is classified by its vendored ABI, read
|
||||
# (c/swift/kotlin/dart/proto/objc) is classified by its vendored ABI, read
|
||||
# straight from gitnexus/vendor/<name>/src/parser.c (NOT node_modules,
|
||||
# which is never populated for vendored grammars — that mismatch is why
|
||||
# the report used to render bare "?" placeholders, #858).
|
||||
|
|
|
|||
11
.github/zizmor.yml
vendored
11
.github/zizmor.yml
vendored
|
|
@ -18,9 +18,11 @@ rules:
|
|||
# untrusted half (pr-autofix.yml) runs fork code with permissions:{}
|
||||
# and produces only a diff artifact (data, not executable code). The
|
||||
# publish job consumes the artifact, allowlist-validates every field
|
||||
# of metadata.json before exporting to $GITHUB_OUTPUT, never checks
|
||||
# out fork code, and never executes anything fork-controlled. Header
|
||||
# comment in the file documents the split.
|
||||
# of metadata.json, then cross-checks identity against
|
||||
# workflow_run.head_sha / head_repository / head_branch via
|
||||
# pulls?head=owner:branch (commits/{sha}/pulls is empty for fork SHAs).
|
||||
# It never checks out fork code and never executes anything
|
||||
# fork-controlled. Header comment in the file documents the split.
|
||||
- pr-autofix-publish.yml
|
||||
|
||||
# workflow_run is the trusted half of the vendored-grammar prebuild
|
||||
|
|
@ -29,7 +31,8 @@ rules:
|
|||
# validates the .node prebuilds and uploads them as artifacts. This
|
||||
# consumer downloads ONLY those artifacts + metadata.json,
|
||||
# allowlist-validates every metadata field, cross-checks identity against
|
||||
# the workflow_run authority (head_sha / head_repo / pr_number), and
|
||||
# workflow_run.head_sha / head_repository / head_branch via
|
||||
# pulls?head=owner:branch (commits/{sha}/pulls is empty for fork SHAs), and
|
||||
# checks out the fork head pinned to that HEAD SHA solely to ADD prebuild
|
||||
# files (never executes fork code) before pushing. Header comment in the
|
||||
# file documents the split.
|
||||
|
|
|
|||
2
.gitignore
vendored
2
.gitignore
vendored
|
|
@ -72,6 +72,8 @@ eval/.hypothesis/
|
|||
|
||||
# Local docs — planning output (gitnexus-plan / gitnexus-work) stays local, not tracked
|
||||
docs/*
|
||||
!docs/fork/
|
||||
!docs/fork/**
|
||||
|
||||
gitnexus/test/fixtures/mini-repo/*.md
|
||||
gitnexus/test/fixtures/mini-repo/.claude
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
<!-- version: 1.14.0 -->
|
||||
<!-- Last updated: 2026-07-16 -->
|
||||
<!-- version: 1.15.0 -->
|
||||
<!-- Last updated: 2026-09-07 -->
|
||||
|
||||
Last reviewed: 2026-07-16
|
||||
Last reviewed: 2026-09-07
|
||||
|
||||
**Project:** GitNexus · **Environment:** dev · **Maintainer:** repository maintainers (see GitHub)
|
||||
|
||||
|
|
@ -39,6 +39,7 @@ Commands and gotchas live under **Repo reference** below and in **[CONTRIBUTING.
|
|||
## Reference docs
|
||||
|
||||
- **[ARCHITECTURE.md](ARCHITECTURE.md)**, **[CONTRIBUTING.md](CONTRIBUTING.md)**, **[GUARDRAILS.md](GUARDRAILS.md)**
|
||||
- **Objective-C provider work:** read **[docs/languages/objective-c-provider.md](docs/languages/objective-c-provider.md)** before changing Objective-C parsing or resolution.
|
||||
- **Call & inheritance resolution (RFC #909 Ring 3):** See ARCHITECTURE.md § Scope-Resolution Pipeline. All languages resolve calls and inheritance through the scope-resolution pipeline (`Registry.lookup`, `preEmitInheritanceEdges`, `emitHeritageEdges`, `buildMro` → `MethodDispatchIndex`). **Shared code in `gitnexus/src/core/ingestion/` must not name languages** — plug language behavior in via `LanguageProvider` / `ScopeResolver` hooks. A language plugs in by implementing `ScopeResolver` (`scope-resolution/contract/scope-resolver.ts`) and registering it in `SCOPE_RESOLVERS`. (The legacy call-resolution DAG + `@heritage` capture path were removed in RING4-1 #942.)
|
||||
- **Cursor:** `.cursor/index.mdc` (always-on); `.cursor/rules/*.mdc` (glob-scoped). Legacy `.cursorrules` deprecated.
|
||||
- **GitNexus:** standard skills in `.claude/skills/gitnexus-*/`; MCP rules in `gitnexus:start` block below.
|
||||
|
|
@ -90,6 +91,7 @@ mirror. `gitnexus/test/unit/shipped-skills-sync.test.ts` guards the copies. Toke
|
|||
|
||||
| Date | Version | Change |
|
||||
|------|---------|--------|
|
||||
| 2026-09-07 | 1.15.0 | Added the Objective-C provider guide as the required reference before changing Objective-C parsing or resolution. |
|
||||
| 2026-07-20 | 1.14.0 | `gitnexus-review` gains a coordinated swarm: six `ci-personas/` lanes the CI review agent dispatches as subagents (via the `Agent` tool), with a bounded critic gate and sidechain-excluded evidence. |
|
||||
| 2026-07-16 | 1.13.0 | `gitnexus-plan` asks plan depth up front (quick/standard/deep) in interactive runs; `gitnexus-lfg` gate slimmed to proceed/stop (Deepen stays as the route-back mechanism). |
|
||||
| 2026-07-16 | 1.12.0 | Renamed `gitnexus-pr-review` to `gitnexus-review`; added PR URL/number, branch/range, and local-change targets plus install migration (setup warns on a legacy `gitnexus-pr-review` dir and leaves it in place; uninstall removes it). |
|
||||
|
|
|
|||
|
|
@ -377,7 +377,7 @@ CI auto-discovers the set via `tsx`. No workflow edit required.
|
|||
|
||||
## Language-agnostic graph feeding
|
||||
|
||||
16 languages → single unified graph. Four abstraction layers:
|
||||
18 languages → single unified graph. Four abstraction layers:
|
||||
|
||||
```
|
||||
Unified Graph Schema (44 node types, 21 relationship types)
|
||||
|
|
@ -405,7 +405,7 @@ Each language implements `LanguageProvider` (`language-provider.ts`). Key fields
|
|||
| `descriptionExtractor` | Optional hook returning a symbol's doc-comment text as its `description`; feeds the embedding metadata header so doc-only terms are semantically searchable (issue #2270). Most languages register `createLeadingDocDescriptionExtractor` (shared, language-neutral; per-language comment/wrapper config passed at the call site) |
|
||||
| `definitionPropertiesExtractor` | Optional language-owned hook for structured, clone-safe definition metadata. Shared ingestion persists these properties opaquely; the owning provider supplies the extraction semantics. |
|
||||
|
||||
16 providers in `languages/index.ts` via `satisfies Record<SupportedLanguages, LanguageProvider>` — missing a language is a compile error.
|
||||
18 providers in `languages/index.ts` via `satisfies Record<SupportedLanguages, LanguageProvider>` — missing a language is a compile error.
|
||||
|
||||
### Unified capture tags
|
||||
|
||||
|
|
@ -542,4 +542,5 @@ Node IDs use arity suffix (`#<paramCount>`): `Method:file:Class.method#1` vs `#2
|
|||
- [RUNBOOK.md](RUNBOOK.md) — operational commands and recovery
|
||||
- [GUARDRAILS.md](GUARDRAILS.md) — safety boundaries for humans and agents
|
||||
- [TESTING.md](TESTING.md) — how to run tests
|
||||
- [docs/languages/objective-c-provider.md](docs/languages/objective-c-provider.md) — Objective-C provider behavior and limits
|
||||
- `AGENTS.md` / `CLAUDE.md` — agent workflows and tool usage
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
# GitNexus (Akon Labs)
|
||||
|
||||
**⚠️ Important Notice:** GitNexus has NO official cryptocurrency, token, or coin. Any token/coin using the GitNexus name on Pump.fun or any other platform is **not affiliated with, endorsed by, or created by** this project or its maintainers. Do not purchase any cryptocurrency claiming association with GitNexus.
|
||||
|
||||
<div align="center">
|
||||
|
||||
<a href="https://trendshift.io/repositories/19809" target="_blank">
|
||||
|
|
@ -585,6 +583,7 @@ Most `analyze` knobs are also CLI flags (`--workers`, `--worker-timeout`, `--max
|
|||
| `GITNEXUS_WORKER_POOL_SIZE` | `cores - 1`, capped at 16 | Parse worker pool size (must be ≥ 1). Equivalent to `--workers <n>`. The worker pool is the sole parse path — there is no sequential parser, so `0` is rejected with an actionable error (the pool self-heals via quarantine + respawn). | Constrained containers (cgroup CPU limits) or CI runners with explicit quotas. To narrow down a worker crash set `1` for a single-worker pool — not `0`. |
|
||||
| `GITNEXUS_PARSE_CHUNK_CONCURRENCY` | `2` | Number of chunks whose file contents may be read into memory in parallel while the pool dispatches the current chunk. Worker dispatch itself stays serial. | Repos large enough to chunk (multi-MB total source) where disk I/O is a measurable fraction of analyze wall-clock. |
|
||||
| `GITNEXUS_VERBOSE` | unset | When `1`, enables verbose ingestion logs (skipped-file warnings, per-chunk throughput, parse-cache stats). Equivalent to `--verbose`. | Debugging an analyze that "completed" but seems to have missed files; tuning `--workers` / chunk concurrency against observable throughput. |
|
||||
| `GITNEXUS_EMBEDDING_RETRY_TIMEOUTS` | unset | When `1`, per-attempt HTTP embedding timeouts (`TimeoutError` on fetch or body read) go through the bounded `GITNEXUS_EMBEDDING_MAX_ATTEMPTS` retry loop instead of failing the job. Default stays off so cloud/default timeouts remain terminal. | Local accelerators that drop a device lock when the client disconnects and succeed on the next request (observed with FastFlowLM on Ryzen AI). |
|
||||
| `GITNEXUS_ANALYZER_IDENTITY_IN_PROCESS_GUARDS` | unset | When truthy (`1`/`true`/`yes`), forces in-process cache-guard validation once a batch has ≥128 requests. In-process mode also auto-selects when `packageRoot`/`buildRoot` fail `W_OK` with `EACCES`/`EROFS`. Otherwise those large batches use a Node subprocess probe. Batches under 128 always stay in-process. | Trusted or read-only installs where two identity subprocess spawns per analyze dominate wall time; leave unset to keep the default isolation path on writable trees. |
|
||||
| `GITNEXUS_RESOLVE_DEF_GRAPH_ID_MEMO` | on (unset) | Memoizes `resolveDefGraphId` per `nodeLookup` instance (WeakMap). Enabled by default. Set to `0`/`false`/`off`/`no` to disable and recompute on every call (debug / bisect memo bugs). | Suspecting stale graph-id resolution after a lookup rebuild, or comparing memo vs uncached cost on a large index. |
|
||||
| `GITNEXUS_AUTH_TOKEN` | unset | Bearer token required when `eval-server` binds beyond loopback. May also be read from `.env.local` or `.env`; shell values take precedence. | Exposing the evaluation HTTP tools to a container, VM, or LAN. |
|
||||
|
|
@ -661,6 +660,7 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
|
|||
| Swift | — | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
|
||||
| C | — | — | ✓ | — | ✓ | ✓ | — | ✓ | ✓ |
|
||||
| C++ | — | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
|
||||
| Objective-C | ✓ | — | ✓ | ✓ | ✓ | — | — | — | — |
|
||||
| Dart | ✓ | — | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ |
|
||||
| Zig | ✓ | — | ✓ | — | ✓ | ✓ | ✓ | — | ✓ |
|
||||
|
||||
|
|
|
|||
109
docs/languages/objective-c-provider.md
Normal file
109
docs/languages/objective-c-provider.md
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
# Objective-C Language Provider
|
||||
|
||||
Status: implemented
|
||||
|
||||
The deterministic provider is covered by focused unit and integration tests. The parser-loader ABI
|
||||
smoke runs in the published multi-OS test matrix, and the native prebuild workflow owns
|
||||
Objective-C together with all six vendored grammar targets. This status describes the implemented
|
||||
MVP; it does not promise full Objective-C runtime dispatch.
|
||||
|
||||
## Goal
|
||||
|
||||
Add deterministic, symbol-level Objective-C analysis to GitNexus. The first release must support high-confidence code navigation and direct static dependency analysis for `.m`, `.mm`, and Objective-C `.h` files. It must not imply that Objective-C runtime dispatch is fully resolved.
|
||||
|
||||
The provider belongs in the existing language-provider and scope-resolution extension points. Shared ingestion code must remain language-agnostic.
|
||||
|
||||
## Compatibility contract
|
||||
|
||||
- Existing language detection and parsing must remain unchanged.
|
||||
- A `.h` file must be classified from its content or surrounding context; it cannot be unconditionally claimed by Objective-C because C and C++ also use that extension.
|
||||
- If Objective-C grammar loading fails, the error must clearly name the missing provider/grammar and cannot corrupt a previously valid index.
|
||||
- Provider and grammar versions must be stored in index metadata. A version change that can alter node identity or edges requires a full rebuild.
|
||||
- No LLM participates in parsing, name resolution, or edge creation. Analysis is Tree-sitter plus deterministic static resolution.
|
||||
|
||||
## MVP model
|
||||
|
||||
The provider must extract and connect:
|
||||
|
||||
- Classes, superclasses, protocols, categories, class extensions, properties, ivars, C functions, imports, declarations, and implementations.
|
||||
- Instance and class methods, preserving their complete multi-part selector.
|
||||
- Inheritance, protocol conformance, import, declaration/implementation, host-class/category, and statically resolved call relationships.
|
||||
|
||||
Stable identity must include enough ownership to distinguish same-named methods. Recommended forms are:
|
||||
|
||||
```text
|
||||
objc:class:<ClassName>
|
||||
objc:protocol:<ProtocolName>
|
||||
objc:category:<HostClass>:<CategoryName>
|
||||
objc:method:<Owner>:-:<selector>
|
||||
objc:method:<Owner>:+:<selector>
|
||||
objc:function:<qualified-or-file-scoped-name>
|
||||
```
|
||||
|
||||
For example, `-loadData:completion:` and `+loadData:completion:` are different symbols. A category method remains linked to both its category and host class; querying the host class must expose distributed implementations.
|
||||
|
||||
## Resolution policy
|
||||
|
||||
Resolution must be conservative. A missing or dynamic target is evidence of uncertainty, not proof that no target exists.
|
||||
|
||||
| Receiver case | Required result |
|
||||
| --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
|
||||
| Explicit class name, `self`, or `super` | Resolve when the owner is statically known. |
|
||||
| Local, parameter, property, or ivar with known static type | Resolve to matching owner and selector. |
|
||||
| Protocol-typed receiver | Link the protocol method and identify possible implementations as candidates. |
|
||||
| Multiple host-class/category implementations of one selector | Record all static candidates as evidence; do not emit a certain call edge because runtime image-load order is unknown. |
|
||||
| `id`, `Class`, macros, reflection, `performSelector:`, `NSInvocation`, runtime injection, or unknown type | Store selector/location with `resolution=unresolved`; do not emit a certain call edge. |
|
||||
|
||||
The provider should first collect file-local declarations, imports, and types, then resolve across the repository. It must use structured Tree-sitter captures or AST traversal, not regular expressions over source text. Multi-part selectors, block arguments, nullability annotations, generics, macros, and multiline declarations make a regex-only extractor unsafe.
|
||||
|
||||
## Imports and incremental correctness
|
||||
|
||||
- Resolve quoted project imports against the current directory, configured include roots, and indexed headers. Model framework imports as external-module evidence without downloading SDK source.
|
||||
- Merge `@interface`, `@implementation`, categories, and extensions across files.
|
||||
- A changed header, protocol, class declaration, or category invalidates importing and affected implementation/call-resolution state. Incremental output after such a change must match a full rebuild.
|
||||
- Index metadata must record provider version, grammar version, include/exclude configuration, and parsing options used for resolution.
|
||||
|
||||
## Implementation sequence
|
||||
|
||||
1. Add and package a pinned Objective-C Tree-sitter grammar; verify macOS arm64 and the production Linux runner can load it.
|
||||
2. Add language detection for `.m`, `.mm`, and content-classified `.h` files.
|
||||
3. Implement AST extraction and stable IDs for declarations and definitions.
|
||||
4. Implement repository-level merge, imports, inheritance, protocol, and category relationships.
|
||||
5. Add conservative message-send resolution and explicit unresolved evidence.
|
||||
6. Integrate invalidation, metadata comparison, MCP/CLI output, and fixtures.
|
||||
|
||||
## Fixtures and acceptance
|
||||
|
||||
Create a minimal Objective-C fixture containing a class, protocol, category, extension, superclass, properties, ivars, C function, imports, multi-part selector, block parameter, `self`, `super`, protocol receiver, and `id` receiver. Use `symodulebridge` as a real integration fixture after the minimal suite is stable.
|
||||
|
||||
The acceptance bar is:
|
||||
|
||||
- `query "SYModuleCaller"` yields class/method semantic nodes, not only file nodes.
|
||||
- `context "SYModuleCaller" --file <path>` yields declaration, implementation, imports, and known references.
|
||||
- Known statically typed message sends create call edges; dynamic sends are marked unresolved.
|
||||
- Same selector on multiple classes, a category override, and `+` versus `-` methods remain distinct.
|
||||
- A `.m`, `.h`, protocol, or category edit produces results equivalent to a clean rebuild.
|
||||
- Generated documentation, dependency directories, and build output are excluded through explicit indexing configuration.
|
||||
|
||||
## Non-goals
|
||||
|
||||
The MVP does not promise exact runtime type inference for `id` or `instancetype`, reflection, swizzling, arbitrary category replacement, dynamic selector construction, or complete impact analysis across every runtime dispatch path. Tool results must surface confidence and unresolved evidence rather than presenting guesses as certain graph facts.
|
||||
|
||||
## Current implementation coverage
|
||||
|
||||
Implemented capabilities:
|
||||
|
||||
- Vendored `tree-sitter-objc` grammar, registered through the existing Tree-sitter loader.
|
||||
- `.m` and `.mm` language mapping plus content-based `.h` classification so plain C/C++ headers are not unconditionally claimed.
|
||||
- LanguageProvider extraction for classes, protocols, categories, extensions, methods, properties, ivars, C functions, imports, unresolved message evidence, stable Objective-C qualified names, and provider/grammar metadata.
|
||||
- Length-preserving preprocessing of bare, file-scope all-caps macro markers before Tree-sitter parsing. This recovers declarations after wrappers such as `RCT_EXTERN_C_BEGIN` / `RCT_EXTERN_C_END` without expanding macros or adding framework-specific rules.
|
||||
- ScopeResolver edges for imports, inheritance, protocol conformance, category host membership, implementation evidence, and conservative static message sends.
|
||||
- Persisted query/context support for Objective-C class and method nodes, including implementation evidence via `DECLARES`.
|
||||
- Regression tests for grammar loading, `.h` classification, stable identities, conservative calls, metadata feature mismatch, persisted query/context behavior, and incremental-vs-force parity for Objective-C fixture edits.
|
||||
|
||||
Known limits of this MVP:
|
||||
|
||||
- The first version does not perform full Objective-C runtime dispatch, swizzling, dynamic selector construction, macro expansion, or `id` flow inference. Bare file-scope marker macros are elided only to preserve parser recovery; their expansion semantics are not interpreted.
|
||||
- Protocol receiver handling records the protocol method and candidate implementation evidence, but candidate implementations are not emitted as certain call edges.
|
||||
- When a host class and one or more named categories define the same selector, the provider records candidate evidence rather than choosing a runtime winner or emitting multiple certain call edges.
|
||||
- Objective-C++ `.mm` files are parsed with the Objective-C grammar path for this MVP; deep C++ semantic extraction inside Objective-C++ bodies remains outside this provider.
|
||||
175
eval/tests/fixtures/fake_claude.py
vendored
Executable file
175
eval/tests/fixtures/fake_claude.py
vendored
Executable file
|
|
@ -0,0 +1,175 @@
|
|||
#!/usr/bin/env python3
|
||||
"""A stand-in for the Claude Code CLI: real HTTP, real tool execution, real stream-json.
|
||||
|
||||
Not a mock of the harness's own code. It does what the CLI does at the two
|
||||
boundaries the harness depends on - it calls ANTHROPIC_BASE_URL for a turn, it
|
||||
EXECUTES the tool blocks that come back, and it prints the stream-json event
|
||||
sequence the parent parses. Only Write really executes - it is what produces the
|
||||
review artifact, so the artifact path has to be genuine end to end. Skill is
|
||||
MODELLED: it validates the request and returns a synthetic result, because the
|
||||
parent's evidence gate keys on the request/result pair rather than on a skill
|
||||
having loaded, and a fixture cannot load a real one. Bash is stubbed outright:
|
||||
arbitrary shell from a scripted reply buys no fidelity for the paths this
|
||||
exercises and plenty of ways to damage the host. Everything between
|
||||
those boundaries (the sandbox,
|
||||
the artifact capture, the scoring, the row) stays real, which is the whole
|
||||
point: those are the layers that shipped bugs no unit test could see.
|
||||
|
||||
Reads the prompt from stdin, as the real CLI does under "-p --input-format text".
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
import urllib.request
|
||||
|
||||
|
||||
def _turn(base_url: str, prompt: str) -> dict:
|
||||
request = urllib.request.Request(
|
||||
base_url.rstrip("/") + "/v1/messages",
|
||||
data=json.dumps({"model": os.environ.get("ANTHROPIC_MODEL", "mock"), "max_tokens": 1024,
|
||||
"messages": [{"role": "user", "content": prompt}]}).encode(),
|
||||
headers={"Content-Type": "application/json",
|
||||
"x-api-key": os.environ.get("ANTHROPIC_API_KEY", ""),
|
||||
"anthropic-version": "2023-06-01"},
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=30) as response:
|
||||
return json.load(response)
|
||||
|
||||
|
||||
def _run_tool(name: str, params: dict) -> str:
|
||||
"""Write executes for real - it is what produces the review artifact.
|
||||
|
||||
Skill and Bash do not: see the module docstring for which is modelled and
|
||||
which is stubbed, and why neither can be genuine here.
|
||||
"""
|
||||
|
||||
if name == "Write":
|
||||
target = pathlib.Path(params["file_path"])
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
# Atomic, exactly as the real Write tool does it: temp file beside the
|
||||
# target, then rename. This is the operation the read-only workspace
|
||||
# boundary has to permit for the artifact directory and refuse for the
|
||||
# workspace, so a stand-in that wrote in place would prove nothing.
|
||||
staging = target.with_name(target.name + ".tmp.fake")
|
||||
staging.write_text(params.get("content", ""))
|
||||
os.replace(staging, target)
|
||||
return f"wrote {target}"
|
||||
if name == "Skill":
|
||||
# Modelled explicitly rather than falling through to a generic success.
|
||||
# The parent's evidence gate keys on a Skill request with a non-error
|
||||
# result, so leaving this unimplemented let an unexecuted skill satisfy
|
||||
# the gate - the gate would have been measuring the fixture, not a skill.
|
||||
skill = params.get("skill") or params.get("command") or params.get("name")
|
||||
if not skill:
|
||||
raise NotImplementedError("Skill request carried no skill name")
|
||||
return f"loaded skill {skill}"
|
||||
if name == "Bash":
|
||||
return "(bash suppressed in the stand-in)"
|
||||
# An unsupported tool is a FAILED tool run, not a quiet success. Returning a
|
||||
# plain string here made the parent's evidence gate read an unexecuted Skill
|
||||
# request as a successful invocation.
|
||||
raise NotImplementedError(f"unsupported tool {name}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
# stdin, because that is where the real CLI takes it under
|
||||
# "-p --input-format text": the parent pipes prompt bytes in. Scanning argv
|
||||
# for a non-flag token picks up a flag's VALUE instead ("text"), which is
|
||||
# exactly what the prompt-fidelity test caught.
|
||||
prompt = sys.stdin.read()
|
||||
base_url = os.environ.get("ANTHROPIC_BASE_URL")
|
||||
if not base_url:
|
||||
print(json.dumps({"type": "result", "subtype": "error", "is_error": True,
|
||||
"session_id": "fake-session", "num_turns": 0}), flush=True)
|
||||
return 1
|
||||
|
||||
emit = lambda event: print(json.dumps(event), flush=True) # noqa: E731
|
||||
emit({"type": "system", "subtype": "init", "session_id": "fake-session"})
|
||||
|
||||
try:
|
||||
message = _turn(base_url, prompt)
|
||||
except (OSError, ValueError) as exc:
|
||||
# A provider failure is a failed SESSION, not a crashed process: dying
|
||||
# here leaves no terminal result event, so the parent reports a generic
|
||||
# stream error instead of the upstream failure it actually saw.
|
||||
emit({"type": "result", "subtype": "error", "is_error": True,
|
||||
"session_id": "fake-session", "num_turns": 0,
|
||||
"error": f"provider request failed: {type(exc).__name__}: {exc}"})
|
||||
return 1
|
||||
blocks = message.get("content", [])
|
||||
emit({"type": "assistant", "message": {"role": "assistant", "content": blocks}})
|
||||
|
||||
tool_results = []
|
||||
for block in blocks:
|
||||
if block.get("type") == "tool_use":
|
||||
# A refused write is a tool ERROR the session reports and carries
|
||||
# on from, not a crash. Letting it kill the process would lose the
|
||||
# result event and misreport a working boundary as a broken run.
|
||||
failed = False
|
||||
try:
|
||||
output = _run_tool(block["name"], block.get("input", {}))
|
||||
except (OSError, NotImplementedError) as exc:
|
||||
output, failed = f"error: {type(exc).__name__}: {exc}", True
|
||||
# is_error is load-bearing: the parent treats an ABSENT is_error as
|
||||
# success, so a refused or unsupported tool would otherwise be
|
||||
# scored as a completed one.
|
||||
tool_results.append({
|
||||
"type": "tool_result", "tool_use_id": block["id"],
|
||||
"content": output, "is_error": failed,
|
||||
})
|
||||
if tool_results:
|
||||
emit({"type": "user", "message": {"role": "user", "content": tool_results}})
|
||||
|
||||
# Unknown is not zero. A reply carrying no usage used to become four
|
||||
# zero-valued fields plus a fabricated cost, which the harness then treats
|
||||
# as a real measurement - the exact confusion the accounting this fixture
|
||||
# feeds exists to prevent.
|
||||
usage = message.get("usage")
|
||||
# Every field that gets forwarded is validated, not just the required two.
|
||||
# The parent's well_formed check tests only that the four keys are PRESENT,
|
||||
# so an unvalidated cache value rides into a success result and is recorded
|
||||
# as a real measurement. A field good enough to report is good enough to
|
||||
# check.
|
||||
countable = lambda v: isinstance(v, int) and not isinstance(v, bool) and v >= 0 # noqa: E731
|
||||
if not isinstance(usage, dict) or not all(
|
||||
countable(usage.get(f)) for f in ("input_tokens", "output_tokens")
|
||||
) or not all(
|
||||
countable(usage[f])
|
||||
for f in ("cache_read_input_tokens", "cache_creation_input_tokens")
|
||||
if f in usage
|
||||
):
|
||||
emit({"type": "result", "subtype": "error", "is_error": True,
|
||||
"session_id": "fake-session", "num_turns": 1,
|
||||
"error": "provider reply carried no usable usage; refusing to report a measured run"})
|
||||
return 1
|
||||
emit({
|
||||
"type": "result",
|
||||
"subtype": "success",
|
||||
"is_error": False,
|
||||
"session_id": "fake-session",
|
||||
"num_turns": 1,
|
||||
"duration_ms": 1200,
|
||||
# A measured zero is not the same as unmeasured; the parent rejects a
|
||||
# collapsed cost, so report a real one.
|
||||
"total_cost_usd": 0.42,
|
||||
# Forward exactly the fields the provider reported. Defaulting the
|
||||
# absent ones to 0 fabricated a complete measurement out of an
|
||||
# incomplete reply - and worse, it made the parent's own completeness
|
||||
# check (runner_sessions.USAGE_FIELDS / well_formed) unfirable from any
|
||||
# offline test, because the stand-in always satisfied it.
|
||||
"usage": {
|
||||
field: usage[field]
|
||||
for field in ("input_tokens", "output_tokens",
|
||||
"cache_read_input_tokens", "cache_creation_input_tokens")
|
||||
if field in usage
|
||||
},
|
||||
})
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
280
eval/tests/test_mock_provider.py
Normal file
280
eval/tests/test_mock_provider.py
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
"""The mock has to be right about the wire, or every test built on it lies."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from workflow_bench.mock_provider import MockProvider, Reply
|
||||
from workflow_bench.provider_usage import (
|
||||
ANTHROPIC,
|
||||
LITELLM_NORMALIZED,
|
||||
OPENAI_RESPONSES,
|
||||
normalize_usage,
|
||||
)
|
||||
|
||||
|
||||
def _post(url: str, payload: dict) -> tuple[int, bytes]:
|
||||
request = urllib.request.Request(
|
||||
url, data=json.dumps(payload).encode(), headers={"Content-Type": "application/json"}
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=10) as response:
|
||||
return response.status, response.read()
|
||||
|
||||
|
||||
def test_anthropic_messages_returns_a_usable_message() -> None:
|
||||
with MockProvider([Reply(text="reviewed")]) as provider:
|
||||
_status, raw = _post(provider.base_url + "/v1/messages", {"model": "m", "messages": []})
|
||||
body = json.loads(raw)
|
||||
assert body["role"] == "assistant"
|
||||
assert body["content"][0]["text"] == "reviewed"
|
||||
assert body["stop_reason"] == "end_turn"
|
||||
|
||||
|
||||
def test_a_scripted_tool_call_is_carried_as_a_tool_use_block() -> None:
|
||||
"""Tool blocks are how a mocked run produces real artifacts.
|
||||
|
||||
The CLI executes what it is asked to run, so a Write block makes it write
|
||||
that file for real inside the sandbox - which is how an artifact-producing
|
||||
cell can be exercised with no model involved.
|
||||
"""
|
||||
|
||||
write = {"name": "Write", "input": {"file_path": "/review-output/review-output.json", "content": "{}"}}
|
||||
with MockProvider([Reply(text="writing", tools=[write])]) as provider:
|
||||
_status, raw = _post(provider.base_url + "/v1/messages", {"model": "m", "messages": []})
|
||||
body = json.loads(raw)
|
||||
block = body["content"][1]
|
||||
assert block["type"] == "tool_use" and block["name"] == "Write"
|
||||
assert block["input"]["file_path"] == "/review-output/review-output.json"
|
||||
assert body["stop_reason"] == "tool_use", "a turn ending in a tool call must say so"
|
||||
|
||||
|
||||
def test_streaming_emits_the_event_sequence_a_consumer_expects() -> None:
|
||||
with MockProvider([Reply(text="hi")]) as provider:
|
||||
request = urllib.request.Request(
|
||||
provider.base_url + "/v1/messages",
|
||||
data=json.dumps({"model": "m", "messages": [], "stream": True}).encode(),
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=10) as response:
|
||||
assert response.headers["Content-Type"] == "text/event-stream"
|
||||
body = response.read().decode()
|
||||
|
||||
events = [line[len("event: ") :] for line in body.splitlines() if line.startswith("event: ")]
|
||||
assert events[0] == "message_start"
|
||||
assert events[-1] == "message_stop"
|
||||
assert "content_block_delta" in events
|
||||
# message_delta carries the final usage, which is where output tokens land.
|
||||
assert events[-2] == "message_delta"
|
||||
|
||||
|
||||
def test_each_protocol_reports_usage_in_its_own_arithmetic() -> None:
|
||||
"""The whole point: the two providers count the same numbers differently.
|
||||
|
||||
Anthropic's cache fields ADD to input_tokens; OpenAI's are SUBSETS of it.
|
||||
Scripting one Reply and serving it both ways is what makes that asymmetry
|
||||
testable without a paid request.
|
||||
"""
|
||||
|
||||
reply = Reply(input_tokens=2_000, output_tokens=300, cache_read_input_tokens=7_000, cache_creation_input_tokens=1_000)
|
||||
|
||||
with MockProvider([reply, reply]) as provider:
|
||||
_s, anthropic_raw = _post(provider.base_url + "/v1/messages", {"model": "m", "messages": []})
|
||||
_s, openai_raw = _post(provider.base_url + "/v1/responses", {"model": "m", "input": []})
|
||||
|
||||
anthropic = normalize_usage(ANTHROPIC, json.loads(anthropic_raw)["usage"])
|
||||
openai = normalize_usage(OPENAI_RESPONSES, json.loads(openai_raw)["usage"])
|
||||
|
||||
assert anthropic.total_input_tokens == 10_000
|
||||
assert openai.total_input_tokens == 10_000, "same billed work, stated as the whole"
|
||||
assert anthropic.ordinary_input_tokens == 2_000
|
||||
assert openai.ordinary_input_tokens == 2_000, "recovered by subtraction, not addition"
|
||||
assert openai.cache_read_input_tokens == 7_000
|
||||
|
||||
|
||||
def test_a_scripted_failure_is_returned_as_one() -> None:
|
||||
"""Billed failures are part of what the accounting must survive."""
|
||||
|
||||
with MockProvider([Reply(status_code=529, error_body={"error": {"type": "overloaded_error"}})]) as provider:
|
||||
try:
|
||||
_post(provider.base_url + "/v1/messages", {"model": "m", "messages": []})
|
||||
raise AssertionError("the scripted failure was not returned")
|
||||
except urllib.error.HTTPError as exc:
|
||||
assert exc.code == 529
|
||||
|
||||
|
||||
def test_requests_are_recorded_for_assertions() -> None:
|
||||
with MockProvider() as provider:
|
||||
_post(provider.base_url + "/v1/messages", {"model": "claude-sonnet-4-5", "messages": [{"role": "user"}]})
|
||||
assert len(provider.requests) == 1
|
||||
assert provider.requests[0].body["model"] == "claude-sonnet-4-5"
|
||||
assert provider.requests[0].path.endswith("/v1/messages")
|
||||
|
||||
|
||||
def test_an_unscripted_turn_gets_the_default_rather_than_stalling() -> None:
|
||||
"""A real run makes more calls than a test wants to enumerate."""
|
||||
|
||||
with MockProvider([Reply(text="first")], default=Reply(text="fallback")) as provider:
|
||||
_s, one = _post(provider.base_url + "/v1/messages", {"model": "m", "messages": []})
|
||||
_s, two = _post(provider.base_url + "/v1/messages", {"model": "m", "messages": []})
|
||||
assert json.loads(one)["content"][0]["text"] == "first"
|
||||
assert json.loads(two)["content"][0]["text"] == "fallback"
|
||||
|
||||
|
||||
def test_a_request_through_the_real_gateway_records_native_usage(tmp_path, monkeypatch) -> None:
|
||||
"""The whole stack minus the model: proxy, translation, callback, log.
|
||||
|
||||
This is the path that shipped three separate defects invisible to unit
|
||||
tests - the usage variable never reaching the proxy subprocess, the
|
||||
callback failing to import when loaded by path, and failures never
|
||||
recorded. All three live between the gateway and the provider, which is
|
||||
exactly the span this exercises.
|
||||
"""
|
||||
|
||||
|
||||
import yaml
|
||||
|
||||
from workflow_bench import model_gateway
|
||||
from workflow_bench.model_gateway import OpenAIGateway
|
||||
from workflow_bench.provider_usage import USAGE_LOG_ENV_VAR
|
||||
|
||||
if shutil.which("litellm") is None:
|
||||
import pytest
|
||||
|
||||
pytest.skip("litellm console script absent; the proxy cannot start here")
|
||||
|
||||
usage_log = tmp_path / "provider_usage.jsonl"
|
||||
monkeypatch.setenv(USAGE_LOG_ENV_VAR, str(usage_log))
|
||||
|
||||
reply = Reply(input_tokens=2_000, output_tokens=300, cache_read_input_tokens=7_000, cache_creation_input_tokens=1_000)
|
||||
with MockProvider(default=reply) as provider:
|
||||
original = model_gateway.write_openai_litellm_config
|
||||
|
||||
def config(path, names):
|
||||
original(path, names)
|
||||
document = yaml.safe_load(path.read_text())
|
||||
for entry in document["model_list"]:
|
||||
entry["litellm_params"]["api_base"] = f"{provider.base_url}/v1"
|
||||
path.write_text(yaml.safe_dump(document))
|
||||
return path
|
||||
|
||||
monkeypatch.setattr(model_gateway, "write_openai_litellm_config", config)
|
||||
with OpenAIGateway(
|
||||
openai_api_key="mock-key", model_names=["gpt-4.1"], work_dir=tmp_path / "gw", ready_timeout_s=60
|
||||
) as gateway:
|
||||
request = urllib.request.Request(
|
||||
gateway.base_url + "/v1/messages",
|
||||
data=json.dumps({"model": "gpt-4.1", "max_tokens": 32, "messages": [{"role": "user", "content": "ping"}]}).encode(),
|
||||
headers={"Content-Type": "application/json", "x-api-key": gateway.auth_token, "anthropic-version": "2023-06-01"},
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=60):
|
||||
pass
|
||||
|
||||
assert usage_log.exists(), "the callback never wrote - the env did not reach the proxy"
|
||||
events = [json.loads(line) for line in usage_log.read_text().splitlines()]
|
||||
assert events, "the proxy started but recorded nothing"
|
||||
event = events[-1]
|
||||
native = event["native_usage"]
|
||||
# LiteLLM hands a callback its OWN normalised object, not the upstream body:
|
||||
# an OpenAI Responses reply arrives as prompt_tokens / prompt_tokens_details.
|
||||
# Asserting the wire shape here is what proved the shipped adapter read keys
|
||||
# that are never present.
|
||||
assert native["prompt_tokens_details"]["cached_tokens"] == 7_000
|
||||
assert native["prompt_tokens_details"]["cache_write_tokens"] == 1_000
|
||||
assert event["provider"] == LITELLM_NORMALIZED
|
||||
assert event["call_type"] == "anthropic_messages", "the observed call type, not a Responses one"
|
||||
|
||||
usage = normalize_usage(event["provider"], native)
|
||||
assert usage.total_input_tokens == 10_000
|
||||
assert usage.cache_read_input_tokens == 7_000
|
||||
assert usage.cache_write_input_tokens == 1_000
|
||||
assert usage.ordinary_input_tokens == 2_000
|
||||
assert usage.complete, "a run that cannot interpret its own usage measured nothing"
|
||||
|
||||
|
||||
def test_probe_what_identity_the_real_cli_actually_sends(tmp_path: Path) -> None:
|
||||
"""An experiment, not an assertion: which fields could correlate a request to a cell?
|
||||
|
||||
Per-cell usage attribution is unbuilt because one proxy serves the whole
|
||||
sweep, so anything read from the proxy environment is identical for every
|
||||
request. Attribution needs something that travels WITH the request, and
|
||||
what the Claude Code CLI actually sends is not documented anywhere I can
|
||||
check - guessing it is how the last three accounting bugs happened.
|
||||
|
||||
So this drives the REAL pinned CLI against the mock and prints the
|
||||
identity-bearing fields that arrive. It asserts only that a request was
|
||||
made; the value is the recorded evidence, which the job log preserves.
|
||||
"""
|
||||
|
||||
claude = os.environ.get("CLAUDE_CANARY_BIN")
|
||||
if not claude or not Path(claude).exists():
|
||||
pytest.skip("no pinned Claude CLI here; the containment job supplies CLAUDE_CANARY_BIN")
|
||||
|
||||
with MockProvider(default=Reply(text="ok")) as provider:
|
||||
subprocess.run(
|
||||
[claude, "-p", "--input-format", "text", "--output-format", "stream-json", "--verbose"],
|
||||
input=b"say ok",
|
||||
capture_output=True,
|
||||
timeout=120,
|
||||
env={
|
||||
**os.environ,
|
||||
"ANTHROPIC_BASE_URL": provider.base_url,
|
||||
"ANTHROPIC_API_KEY": "offline-probe",
|
||||
"HOME": str(tmp_path),
|
||||
},
|
||||
)
|
||||
|
||||
assert provider.requests, "the real CLI never reached the mock provider"
|
||||
request = provider.requests[0]
|
||||
interesting = {
|
||||
"header:" + name: value
|
||||
for name, value in request.headers.items()
|
||||
if any(k in name.lower() for k in ("session", "user", "trace", "request-id", "conversation", "metadata"))
|
||||
}
|
||||
interesting.update(
|
||||
{f"body:{key}": request.body[key] for key in ("metadata", "user", "session_id") if key in request.body}
|
||||
)
|
||||
print("\nIDENTITY FIELDS THE REAL CLI SENDS:")
|
||||
print(" body keys:", sorted(request.body))
|
||||
print(" candidate correlators:", interesting or "NONE — per-cell attribution needs another mechanism")
|
||||
|
||||
|
||||
def test_scripted_tools_survive_the_responses_protocol_too() -> None:
|
||||
"""The gateway uses Responses BECAUSE it carries tool use.
|
||||
|
||||
Emitting only output_text there meant a scripted Write or Skill crossed the
|
||||
gateway with the tool dropped, so a mock claiming to serve both protocols
|
||||
was wrong about the one the gateway actually runs.
|
||||
"""
|
||||
|
||||
write = {"name": "Write", "input": {"file_path": "/review-output/review-output.json", "content": "{}"}}
|
||||
with MockProvider([Reply(text="writing", tools=[write])]) as provider:
|
||||
_status, raw = _post(provider.base_url + "/v1/responses", {"model": "m", "input": []})
|
||||
|
||||
output = json.loads(raw)["output"]
|
||||
calls = [item for item in output if item["type"] == "function_call"]
|
||||
assert len(calls) == 1, "the scripted tool must cross the Responses path"
|
||||
assert calls[0]["name"] == "Write"
|
||||
assert json.loads(calls[0]["arguments"])["file_path"] == "/review-output/review-output.json"
|
||||
|
||||
|
||||
def test_an_omitted_cache_field_stays_omitted_on_the_responses_wire_too() -> None:
|
||||
"""Absence must survive both protocols, not just the Anthropic one.
|
||||
|
||||
`_int_or_none` reads an absent detail key as unknown and a present 0 as a
|
||||
measured zero, so serializing 0 for a scripted None would claim a
|
||||
measurement the reply never made.
|
||||
"""
|
||||
|
||||
with MockProvider([Reply(input_tokens=2_000, cache_read_input_tokens=None)]) as provider:
|
||||
_status, raw = _post(provider.base_url + "/v1/responses", {"model": "m", "input": []})
|
||||
|
||||
details = json.loads(raw)["usage"]["input_tokens_details"]
|
||||
assert "cached_tokens" not in details, "an omitted field must not serialize as a measured zero"
|
||||
assert details["cache_write_tokens"] == 0, "a scripted 0 is still a real measurement"
|
||||
195
eval/tests/test_offline_session_integration.py
Normal file
195
eval/tests/test_offline_session_integration.py
Normal file
|
|
@ -0,0 +1,195 @@
|
|||
"""A session end to end with only the model faked.
|
||||
|
||||
The layers between the CLI and the row are where this harness has actually
|
||||
shipped bugs - the artifact that could not be written, the usage that was never
|
||||
recorded, the evidence that was scored from the wrong directory. Every one of
|
||||
them sat below the level its tests exercised. These run the real session path
|
||||
against a scripted provider, so the only thing not real is what the model says.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from workflow_bench.mock_provider import MockProvider, Reply
|
||||
from workflow_bench.proposer_sandbox import (
|
||||
host_workspace_write_boundary,
|
||||
prepare_review_workspace,
|
||||
prepare_sandbox,
|
||||
)
|
||||
from workflow_bench.review_scoring import REVIEW_OUTPUT, parse_review_output
|
||||
from workflow_bench.runner_sessions import run_claude
|
||||
|
||||
FAKE_CLI = Path(__file__).parent / "fixtures" / "fake_claude.py"
|
||||
REVIEW_JSON = '{"schema_version": 1, "verdict": "approve", "findings": []}'
|
||||
|
||||
|
||||
def _session(clone: Path, provider: MockProvider, **overrides):
|
||||
return run_claude(
|
||||
"review the change",
|
||||
clone,
|
||||
claude_bin=str(FAKE_CLI),
|
||||
timeout=60,
|
||||
env={
|
||||
"ANTHROPIC_BASE_URL": provider.base_url,
|
||||
"ANTHROPIC_API_KEY": "offline",
|
||||
"PATH": "/usr/bin:/bin",
|
||||
},
|
||||
**overrides,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def clone(tmp_path: Path) -> Path:
|
||||
workspace = tmp_path / "clone"
|
||||
workspace.mkdir()
|
||||
(workspace / "source.ts").write_text("export const answer = 42;\n")
|
||||
return workspace
|
||||
|
||||
|
||||
def test_a_session_records_the_usage_the_provider_reported(clone: Path) -> None:
|
||||
"""Token counts must survive the CLI boundary, not be invented after it."""
|
||||
|
||||
reply = Reply(input_tokens=2_000, output_tokens=300, cache_read_input_tokens=7_000, cache_creation_input_tokens=1_000)
|
||||
with MockProvider(default=reply) as provider:
|
||||
record = _session(clone, provider)
|
||||
|
||||
assert record["ok"] is True, record.get("error_detail")
|
||||
assert record["input_tokens"] == 2_000
|
||||
assert record["cache_read_input_tokens"] == 7_000
|
||||
assert record["cache_creation_input_tokens"] == 1_000
|
||||
assert record["output_tokens"] == 300
|
||||
# A measured zero would be indistinguishable from an unmeasured one.
|
||||
assert record["cost_usd"] == 0.42
|
||||
assert record["num_turns"] == 1
|
||||
|
||||
|
||||
def test_a_scripted_write_produces_a_review_artifact_the_scorer_accepts(clone: Path) -> None:
|
||||
"""The full artifact path: model asks, CLI writes atomically, scorer reads.
|
||||
|
||||
This is the operation that shipped empty for a whole run. Nothing here
|
||||
fakes the write, the directory, or the parse - only the decision to write.
|
||||
"""
|
||||
|
||||
with prepare_sandbox(
|
||||
clone=clone, claude_bin=Path(sys.executable), backend="host-unsafe", preflight=False
|
||||
) as sandbox:
|
||||
artifact = prepare_review_workspace(sandbox, REVIEW_OUTPUT)
|
||||
write = {"name": "Write", "input": {"file_path": str(artifact), "content": REVIEW_JSON}}
|
||||
with MockProvider(default=Reply(text="reviewing", tools=[write])) as provider:
|
||||
# Take the command configuration from the sandbox the way run_arm
|
||||
# does, rather than calling run_claude bare. On host-unsafe the
|
||||
# prefix is [] by construction, so this pins the WIRING, not the
|
||||
# isolation - a bwrap run would carry a real prefix through here.
|
||||
record = _session(
|
||||
clone,
|
||||
provider,
|
||||
command_prefix=sandbox.command_prefix_for(),
|
||||
require_pid_namespace=sandbox.require_pid_namespace,
|
||||
)
|
||||
assert record["ok"] is True, record.get("error_detail")
|
||||
# Read inside the scope: prepare_sandbox removes the private root on exit.
|
||||
verdict, findings = parse_review_output(artifact)
|
||||
|
||||
assert verdict == "approve"
|
||||
assert findings == ()
|
||||
|
||||
|
||||
def test_the_provider_saw_the_prompt_the_harness_meant_to_send(clone: Path) -> None:
|
||||
"""A run that measures the wrong prompt measures nothing."""
|
||||
|
||||
with MockProvider() as provider:
|
||||
_session(clone, provider)
|
||||
|
||||
assert provider.requests, "the session never reached the provider"
|
||||
sent = provider.requests[0].body["messages"][0]["content"]
|
||||
assert "review the change" in sent
|
||||
|
||||
|
||||
def test_a_provider_failure_surfaces_as_a_failed_session_not_a_silent_pass(clone: Path) -> None:
|
||||
"""An upstream 529 must not be recorded as a usable measurement."""
|
||||
|
||||
failing = Reply(status_code=529, error_body={"error": {"type": "overloaded_error"}})
|
||||
with MockProvider(default=failing) as provider:
|
||||
record = _session(clone, provider)
|
||||
|
||||
assert record["ok"] is False
|
||||
assert record["error_kind"] is not None
|
||||
|
||||
|
||||
def test_the_write_boundary_refuses_the_workspace_and_permits_the_artifact(clone: Path, tmp_path: Path) -> None:
|
||||
"""The contract the empty-artifact run violated, on the backend available here.
|
||||
|
||||
A review must not change the workspace, and must still be able to write its
|
||||
artifact ATOMICALLY - temp file beside the target, then rename - which is
|
||||
what needs a writable parent DIRECTORY rather than a writable file. Both
|
||||
halves are asserted through the real session, with the real boundary
|
||||
applied, and the model scripted to attempt each one.
|
||||
|
||||
Scope: this is the host-unsafe boundary, which its own docstring calls
|
||||
best-effort because a session that can chmod can undo it. The kernel-enforced
|
||||
version is bubblewrap's --ro-bind, which needs namespaces this machine cannot
|
||||
create; that half stays with the real-sandbox canary in CI.
|
||||
"""
|
||||
|
||||
artifacts = tmp_path / "artifacts"
|
||||
artifacts.mkdir()
|
||||
target = artifacts / REVIEW_OUTPUT
|
||||
protected = clone / "source.ts"
|
||||
before = protected.read_text()
|
||||
|
||||
write_artifact = {"name": "Write", "input": {"file_path": str(target), "content": REVIEW_JSON}}
|
||||
tamper = {"name": "Write", "input": {"file_path": str(protected), "content": "tampered"}}
|
||||
|
||||
# No writable= entry: the boundary only governs paths INSIDE the workspace
|
||||
# (it refuses one that escapes), and the artifact directory deliberately
|
||||
# lives outside it - that relocation is the fix for the empty-artifact run.
|
||||
with host_workspace_write_boundary(clone):
|
||||
with MockProvider(default=Reply(text="writing", tools=[write_artifact, tamper])) as provider:
|
||||
record = _session(clone, provider)
|
||||
|
||||
assert record["ok"] is True, record.get("error_detail")
|
||||
# The artifact landed, written the way the agent's Write tool does it.
|
||||
verdict, _findings = parse_review_output(target)
|
||||
assert verdict == "approve"
|
||||
assert not list(artifacts.glob("*.tmp.*")), "the rename landed rather than a copy"
|
||||
# The workspace did not move.
|
||||
assert protected.read_text() == before, "the read-only workspace was modified"
|
||||
|
||||
|
||||
def test_a_reply_missing_cache_usage_is_refused_not_zero_filled(clone: Path) -> None:
|
||||
"""An omitted cache field must not arrive as a measured zero.
|
||||
|
||||
The parent already demands all four USAGE_FIELDS before it calls a session
|
||||
measured (runner_sessions.well_formed). The stand-in used to default the
|
||||
absent ones to 0, which both fabricated a complete measurement AND made
|
||||
that parent guard unfirable from any offline test - it was always
|
||||
satisfied. Scripting the absence is what proves the guard still fires.
|
||||
"""
|
||||
|
||||
partial = Reply(input_tokens=2_000, output_tokens=300, cache_read_input_tokens=None)
|
||||
with MockProvider(default=partial) as provider:
|
||||
record = _session(clone, provider)
|
||||
|
||||
assert record["ok"] is False, "an incomplete usage report is not a usable measurement"
|
||||
assert record["error_kind"] == "session-error"
|
||||
|
||||
|
||||
@pytest.mark.parametrize("bad", [-5, True, "1200"], ids=["negative", "boolean", "string"])
|
||||
def test_a_nonsense_cache_value_is_refused_rather_than_forwarded(clone: Path, bad: object) -> None:
|
||||
"""A field good enough to report is good enough to validate.
|
||||
|
||||
The parent's well_formed check tests only that the four keys are PRESENT,
|
||||
so an unvalidated cache value would ride into a success result and be
|
||||
recorded as a real measurement.
|
||||
"""
|
||||
|
||||
reply = Reply(input_tokens=2_000, output_tokens=300)
|
||||
object.__setattr__(reply, "cache_read_input_tokens", bad)
|
||||
with MockProvider(default=reply) as provider:
|
||||
record = _session(clone, provider)
|
||||
|
||||
assert record["ok"] is False, f"{bad!r} must not be recorded as a measured cache value"
|
||||
348
eval/tests/test_offline_sweep_integration.py
Normal file
348
eval/tests/test_offline_sweep_integration.py
Normal file
|
|
@ -0,0 +1,348 @@
|
|||
"""A whole sweep, offline: real runner, real sessions, scripted model.
|
||||
|
||||
The layers between a model turn and a promotion decision had never been
|
||||
exercised together. Unit tests covered each in isolation and the paid runs that
|
||||
would have covered the composition kept dying, so the contracts BETWEEN them
|
||||
went unverified - and that is where this harness has repeatedly shipped bugs.
|
||||
|
||||
This drives runner.main() the way the workflow does. Everything is real: task
|
||||
selection, hidden-oracle capture, the sandbox, the CLI subprocess, artifact
|
||||
capture, review scoring against the oracle, aggregation, the health guard, and
|
||||
the promotion gate. Only the model is scripted, through MockProvider.
|
||||
|
||||
Two provisioning steps are stubbed because this environment cannot supply them,
|
||||
and neither is harness logic: the pinned gitnexus runtime mounts (no
|
||||
node_modules in a worktree) and the sanitized graph build (needs the gitnexus
|
||||
CLI at a mounted path). Containment is host-unsafe here; bubblewrap stays with
|
||||
the real-sandbox canary in the containment job.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from types import SimpleNamespace
|
||||
|
||||
import os
|
||||
import shutil
|
||||
|
||||
import pytest
|
||||
|
||||
from workflow_bench import oracle_assets, runner
|
||||
from workflow_bench.mock_provider import MockProvider, Reply
|
||||
|
||||
FAKE_CLI = Path(__file__).parent / "fixtures" / "fake_claude.py"
|
||||
ARMS = ("ce_review", "review", "candidate_review")
|
||||
|
||||
# When set, the sweep runs with NOTHING provisioning-stubbed: real bubblewrap
|
||||
# containment, the real pinned runtime mounts, and the real sanitized graph
|
||||
# build. The named CI job installs all three, so a missing one there is a
|
||||
# regression rather than an unsupported machine - it FAILS instead of quietly
|
||||
# degrading to the stubbed path, which is the whole point of the gate.
|
||||
FULL_SWEEP_ENV = "GITNEXUS_REQUIRE_FULL_SWEEP"
|
||||
FULL_SWEEP = os.environ.get(FULL_SWEEP_ENV) == "1"
|
||||
|
||||
# The runner refuses --unsafe-no-bwrap whenever CI is set, because that mode runs
|
||||
# sessions with bypassPermissions behind a boundary its own docstring calls "not
|
||||
# a security boundary". Deleting CI to get past that refusal would run an
|
||||
# uncontained agent sweep on the runner holding the checkout and credentials, so
|
||||
# the stubbed path is skipped under CI instead. The containment job sets
|
||||
# GITNEXUS_REQUIRE_FULL_SWEEP=1 and takes the real bubblewrap path, so CI keeps
|
||||
# its coverage; only the uncontained convenience run is given up.
|
||||
pytestmark = pytest.mark.skipif(
|
||||
not FULL_SWEEP and bool(os.environ.get("CI")),
|
||||
reason="an uncontained sweep must not run in CI; the containment job runs it with GITNEXUS_REQUIRE_FULL_SWEEP=1",
|
||||
)
|
||||
|
||||
# The review output and the hidden labels are DELIBERATELY different shapes -
|
||||
# the labels carry line_start/line_end and no recommendation. Only a real run
|
||||
# surfaces that; it is why these are written out rather than shared.
|
||||
FINDING = {
|
||||
"id": "f1", "severity": "high", "category": "correctness", "path": "src/sum.js",
|
||||
"line": 1, "end_line": 1, "blocking": True, "scenario": "review-defect",
|
||||
"evidence": "export const total = (a, b) => a - b;", "recommendation": "use a + b",
|
||||
}
|
||||
LABEL = {"id": "f1", "severity": "high", "category": "correctness",
|
||||
"path": "src/sum.js", "line_start": 1, "line_end": 1}
|
||||
SECOND_LABEL = {"id": "f2", "severity": "high", "category": "correctness",
|
||||
"path": "src/scale.js", "line_start": 1, "line_end": 1}
|
||||
SECOND_FINDING = {
|
||||
"id": "f2", "severity": "high", "category": "correctness", "path": "src/scale.js",
|
||||
"line": 1, "end_line": 1, "blocking": True, "scenario": "review-defect",
|
||||
"evidence": "export const twice = (n) => n + 2;", "recommendation": "use n * 2",
|
||||
}
|
||||
|
||||
|
||||
def _git(repo: Path, *args: str) -> str:
|
||||
return subprocess.run(["git", "-C", str(repo), *args], check=True,
|
||||
capture_output=True, text=True).stdout.strip()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def bench(tmp_path: Path):
|
||||
"""A self-contained corpus: one repo, one task, one hidden label."""
|
||||
|
||||
repo = tmp_path / "repo"
|
||||
(repo / "src").mkdir(parents=True)
|
||||
(repo / "src" / "sum.js").write_text("export const total = (a, b) => a - b;\n")
|
||||
(repo / "src" / "scale.js").write_text("export const twice = (n) => n + 2;\n")
|
||||
_git(repo, "init", "-q", ".")
|
||||
_git(repo, "config", "user.email", "t@t")
|
||||
_git(repo, "config", "user.name", "t")
|
||||
_git(repo, "add", "-A")
|
||||
_git(repo, "commit", "-q", "-m", "fixture")
|
||||
sha = _git(repo, "rev-parse", "HEAD")
|
||||
|
||||
oracles = tmp_path / "oracles"
|
||||
oracles.mkdir()
|
||||
(oracles / "review-fixture-defect.labels.json").write_text(
|
||||
json.dumps({"schema_version": 1, "findings": [LABEL]})
|
||||
)
|
||||
(oracles / "review-fixture-second.labels.json").write_text(
|
||||
json.dumps({"schema_version": 1, "findings": [SECOND_LABEL]})
|
||||
)
|
||||
|
||||
tasks = tmp_path / "tasks.yaml"
|
||||
tasks.write_text(
|
||||
"tasks:\n"
|
||||
" - id: review-fixture-defect\n"
|
||||
" class: review-defect\n"
|
||||
f" repo: {repo}\n"
|
||||
f" ref: {sha}\n"
|
||||
" prompt: Review this change and report actionable defects.\n"
|
||||
' verify: test -s "$GITNEXUS_BENCH_REVIEW_OUTPUT"\n'
|
||||
" oracle:\n"
|
||||
' command: test -s "$GITNEXUS_BENCH_REVIEW_OUTPUT"\n'
|
||||
" files: [{ source: review-fixture-defect.labels.json, target: review-labels.json }]\n"
|
||||
# A SECOND task, because the thing a cross-task scheduler changes is
|
||||
# invisible with one: waves are per-task, so a single task cannot show
|
||||
# ordering, packing, or a breaker that spans a task boundary.
|
||||
" - id: review-fixture-second\n"
|
||||
" class: review-defect\n"
|
||||
f" repo: {repo}\n"
|
||||
f" ref: {sha}\n"
|
||||
" prompt: Review the scaling helper and report actionable defects.\n"
|
||||
' verify: test -s "$GITNEXUS_BENCH_REVIEW_OUTPUT"\n'
|
||||
" oracle:\n"
|
||||
' command: test -s "$GITNEXUS_BENCH_REVIEW_OUTPUT"\n'
|
||||
" files: [{ source: review-fixture-second.labels.json, target: review-labels.json }]\n"
|
||||
)
|
||||
|
||||
plugin = tmp_path / "ce-plugin"
|
||||
(plugin / ".claude-plugin").mkdir(parents=True)
|
||||
(plugin / ".claude-plugin" / "plugin.json").write_text(
|
||||
json.dumps({"name": "compound-engineering", "version": "0.0.0-fixture"})
|
||||
)
|
||||
for skill in ("ce-plan", "ce-work", "ce-code-review"):
|
||||
directory = plugin / "skills" / skill
|
||||
directory.mkdir(parents=True)
|
||||
(directory / "SKILL.md").write_text(f"---\nname: {skill}\ndescription: fixture\n---\nFixture.\n")
|
||||
|
||||
overlay = tmp_path / "overlay" / ".claude" / "skills" / "gitnexus-review"
|
||||
overlay.mkdir(parents=True)
|
||||
(overlay / "SKILL.md").write_text("---\nname: gitnexus-review\ndescription: fixture\n---\nCandidate.\n")
|
||||
|
||||
return SimpleNamespace(tasks=tasks, oracles=oracles, plugin=plugin,
|
||||
overlay=tmp_path / "overlay", out=tmp_path / "out")
|
||||
|
||||
|
||||
def _stub_provisioning(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Replace what this machine cannot supply - and nothing else.
|
||||
|
||||
Under FULL_SWEEP nothing is replaced: the runtime mounts and the graph are
|
||||
built for real, so the sweep exercises containment and provisioning too.
|
||||
"""
|
||||
|
||||
if FULL_SWEEP:
|
||||
if shutil.which("bwrap") is None:
|
||||
pytest.fail(f"{FULL_SWEEP_ENV}=1 but bubblewrap is absent")
|
||||
return
|
||||
|
||||
monkeypatch.setattr(runner, "trusted_gitnexus_runtime_mounts", lambda: ())
|
||||
|
||||
def materialize(worktree, *, sanitized_head=None, **_kwargs):
|
||||
# The one-clone registry guard reads this before any session runs.
|
||||
meta = Path(worktree) / ".gitnexus"
|
||||
meta.mkdir(parents=True, exist_ok=True)
|
||||
(meta / "meta.json").write_text(
|
||||
json.dumps({"indexedAt": "2026-09-08T00:00:00Z", "lastCommit": sanitized_head or "0" * 40})
|
||||
)
|
||||
|
||||
def fake_graph(**kwargs):
|
||||
kwargs["env"].graph_snapshots[kwargs["graph_key"]] = SimpleNamespace(
|
||||
digest="fixture-graph", manifest_digest="fixture-graph-manifest",
|
||||
dependency_content_digest=None, dependency_manifest_digest=None,
|
||||
materialize=materialize,
|
||||
)
|
||||
|
||||
monkeypatch.setattr(runner, "ensure_task_graph", fake_graph)
|
||||
|
||||
|
||||
def _sweep(bench, monkeypatch: pytest.MonkeyPatch, findings: list[dict], verdict: str, *, invoke_skill: bool = True):
|
||||
"""Run the real CLI against a model scripted to return `findings`."""
|
||||
|
||||
_stub_provisioning(monkeypatch)
|
||||
monkeypatch.setattr(
|
||||
oracle_assets, "ORACLE_ROOT", bench.oracles, raising=False
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
runner, "capture_task_oracles",
|
||||
lambda tasks, root=bench.oracles: oracle_assets.capture_task_oracles(tasks, root=root),
|
||||
)
|
||||
def review_for(body: str) -> str:
|
||||
# Per task: the second task's defect is in another file, so replying
|
||||
# with the first task's finding would score it wrong. A cross-task
|
||||
# scheduler makes which task a request belongs to load-bearing.
|
||||
chosen = findings
|
||||
if findings and "scaling helper" in body:
|
||||
chosen = [SECOND_FINDING if f is FINDING else f for f in findings]
|
||||
return json.dumps({"schema_version": 1, "verdict": verdict, "findings": chosen})
|
||||
|
||||
class Scripted(MockProvider):
|
||||
def next_reply(self) -> Reply:
|
||||
body = json.dumps(self.requests[-1].body if self.requests else {})
|
||||
target = re.search(r"(/[^\s\"']*review-output\.json)", body)
|
||||
skill = re.search(r"\b(gitnexus-review|ce-code-review)\b", body)
|
||||
return Reply(
|
||||
text="reviewing",
|
||||
tools=[
|
||||
# The evidence gate needs a Skill request with a non-error
|
||||
# result: a review that never invoked its skill measured the
|
||||
# model, not the skill.
|
||||
*([{"name": "Skill", "input": {"skill": skill.group(1) if skill else "gitnexus-review"}}]
|
||||
if invoke_skill else []),
|
||||
{"name": "Write", "input": {
|
||||
"file_path": target.group(1) if target else str(bench.out / "unmatched-review-output.json"),
|
||||
"content": review_for(body)}},
|
||||
],
|
||||
input_tokens=2_000, output_tokens=300,
|
||||
cache_read_input_tokens=7_000, cache_creation_input_tokens=1_000,
|
||||
)
|
||||
|
||||
with Scripted() as provider:
|
||||
monkeypatch.setattr(sys, "argv", [
|
||||
"runner", "--tasks", str(bench.tasks), "--arms", *ARMS,
|
||||
"--runs", "1", "--workers", "1", "--out", str(bench.out),
|
||||
"--base-url", provider.base_url, "--anthropic-api-key", "offline",
|
||||
"--claude-bin", str(FAKE_CLI),
|
||||
*([] if FULL_SWEEP else ["--unsafe-no-bwrap"]),
|
||||
"--model", "mock-model",
|
||||
"--ce-plugin-dir", str(bench.plugin), "--ce-plugin-version", "0.0.0-fixture",
|
||||
"--candidate-overlay", str(bench.overlay),
|
||||
])
|
||||
|
||||
try:
|
||||
code = runner.main()
|
||||
except SystemExit as exc:
|
||||
code = exc.code
|
||||
|
||||
rows = [json.loads(line) for line in (bench.out / "results.jsonl").read_text().splitlines()]
|
||||
return code, rows, provider
|
||||
|
||||
|
||||
def _row(rows: list[dict], arm: str, task: str = "review-fixture-defect") -> dict:
|
||||
return next(r for r in rows if r["arm"] == arm and r["task"] == task)
|
||||
|
||||
|
||||
def test_a_correct_review_scores_and_the_sweep_exits_clean(bench, monkeypatch) -> None:
|
||||
"""The whole path, green: every arm measured, scored, and accounted for."""
|
||||
|
||||
code, rows, provider = _sweep(bench, monkeypatch, [FINDING], "request_changes")
|
||||
|
||||
assert code in (None, 0), f"sweep did not succeed: {code}"
|
||||
tasks = {"review-fixture-defect", "review-fixture-second"}
|
||||
assert len(rows) == len(ARMS) * len(tasks)
|
||||
assert len(provider.requests) == len(ARMS) * len(tasks), "each cell must reach the provider once"
|
||||
assert {r["task"] for r in rows} == tasks, "both tasks must have run"
|
||||
|
||||
row = _row(rows, "review")
|
||||
assert row["ok"] is True and row["resolved"] is True
|
||||
assert row["skill_invoked"] is True
|
||||
assert (row["review_true_positives"], row["review_false_positives"], row["review_false_negatives"]) == (1, 0, 0)
|
||||
assert row["review_f1"] == 1.0
|
||||
# The provider's own numbers survived the CLI, the parser and the row.
|
||||
assert row["cache_read_input_tokens"] == 7_000
|
||||
assert row["input_tokens"] == 2_000
|
||||
|
||||
# Each task scored against ITS OWN oracle. This is what a cross-task
|
||||
# scheduler puts at risk: interleaving cells from different tasks means a
|
||||
# mis-routed context or artifact scores one task against another's labels,
|
||||
# and both would still look "green" per row.
|
||||
second = _row(rows, "review", task="review-fixture-second")
|
||||
assert second["resolved"] is True and second["review_f1"] == 1.0
|
||||
assert second["review_artifact"] == "review-fixture-second-review-run0.review.json"
|
||||
|
||||
for name in ("results.jsonl", "report.md", "promotion.json"):
|
||||
assert (bench.out / name).is_file(), f"{name} was not written"
|
||||
assert (bench.out / "review-fixture-defect-review-run0.review.json").is_file()
|
||||
|
||||
|
||||
def test_one_run_cannot_promote_a_candidate(bench, monkeypatch) -> None:
|
||||
"""The gate refuses on insufficient paired runs, and says so."""
|
||||
|
||||
_sweep(bench, monkeypatch, [FINDING], "request_changes")
|
||||
promotion = json.loads((bench.out / "promotion.json").read_text())
|
||||
|
||||
assert promotion["run_status"] == "complete"
|
||||
decision = next(d for d in promotion["decisions"] if d["candidate_arm"] == "candidate_review")
|
||||
assert decision["decision"] == "insufficient_evidence"
|
||||
assert any("valid paired runs" in reason for reason in decision["reasons"])
|
||||
|
||||
|
||||
def test_a_finding_in_the_wrong_place_scores_zero_but_stays_valid_evidence(bench, monkeypatch) -> None:
|
||||
"""Being wrong is a quality result, not a broken measurement.
|
||||
|
||||
The negative control that makes the passing case mean something: same
|
||||
harness, same well-formed artifact, only the answer changed.
|
||||
"""
|
||||
|
||||
wrong = {**FINDING, "path": "src/WRONG.js", "line": 99, "end_line": 99}
|
||||
_code, rows, _provider = _sweep(bench, monkeypatch, [wrong], "request_changes")
|
||||
|
||||
row = _row(rows, "review")
|
||||
assert (row["review_true_positives"], row["review_false_positives"], row["review_false_negatives"]) == (0, 1, 1)
|
||||
assert row["review_f1"] == 0.0
|
||||
assert row["resolved"] is False
|
||||
assert row["error_kind"] == "oracle-failed", "a wrong answer is not a session or evidence failure"
|
||||
assert row["review_evidence_valid"] is True, "the artifact was well formed; only the answer was wrong"
|
||||
|
||||
|
||||
def test_approving_defective_code_is_a_miss_with_no_false_positive(bench, monkeypatch) -> None:
|
||||
"""The other half of the control: silence scores differently from a wrong guess."""
|
||||
|
||||
_code, rows, _provider = _sweep(bench, monkeypatch, [], "approve")
|
||||
|
||||
row = _row(rows, "review")
|
||||
assert (row["review_true_positives"], row["review_false_positives"], row["review_false_negatives"]) == (0, 0, 1)
|
||||
assert row["review_precision"] is None, "precision is undefined with no predictions, not zero"
|
||||
assert row["review_verdict_correct"] is False, "approving defective code is the wrong verdict"
|
||||
assert row["review_evidence_valid"] is True
|
||||
|
||||
|
||||
def test_a_review_that_never_invoked_its_skill_is_not_a_measurement(bench, monkeypatch) -> None:
|
||||
"""The gate that separates measuring a SKILL from measuring a model.
|
||||
|
||||
Added because a mutation exposed it: forcing skill_was_invoked_events to
|
||||
return True left every other test here passing, so nothing pinned the gate.
|
||||
The artifact is written and correct in this run - only the skill request is
|
||||
missing - so a pass would mean the arm scored a review it never performed.
|
||||
"""
|
||||
|
||||
code, rows, _provider = _sweep(bench, monkeypatch, [FINDING], "request_changes", invoke_skill=False)
|
||||
|
||||
row = _row(rows, "review")
|
||||
assert row["skill_invoked"] is False
|
||||
assert row["error_kind"] == "skill-not-invoked"
|
||||
assert code not in (None, 0), "the sweep must not report success on unusable evidence"
|
||||
|
||||
# The row still carries its own score - the artifact was well formed - and
|
||||
# aggregate() DOES count it in the arm's quality median (the KNOWN GAP noted
|
||||
# above aggregate(); test_workflow_bench pins the resulting 0.5). Filtering
|
||||
# it out of the median alone inverted a promotion, because valid_runs and
|
||||
# excluded_runs kept counting it. It counts for cost either way: the session
|
||||
# ran and was billed.
|
||||
assert row["review_weighted_f1"] == 1.0
|
||||
assert row["review_evidence_valid"] is True
|
||||
|
|
@ -24,7 +24,7 @@ from workflow_bench.model_gateway import (
|
|||
)
|
||||
from workflow_bench.provider_usage import (
|
||||
ANTHROPIC,
|
||||
OPENAI_RESPONSES,
|
||||
LITELLM_NORMALIZED,
|
||||
USAGE_ENV_VARS,
|
||||
normalize_usage,
|
||||
)
|
||||
|
|
@ -49,11 +49,16 @@ def _openai_response(usage: dict) -> SimpleNamespace:
|
|||
)
|
||||
|
||||
|
||||
# The shape a callback actually receives: LiteLLM normalises usage into its own
|
||||
# Chat-Completions-style object before any logger sees it, so an OpenAI reply
|
||||
# arrives as prompt_tokens / prompt_tokens_details. Confirmed against a real
|
||||
# proxy in tests/test_mock_provider.py; a fixture in the wire shape would test
|
||||
# an object this code path never gets.
|
||||
NATIVE = {
|
||||
"input_tokens": 48_000,
|
||||
"input_tokens_details": {"cached_tokens": 44_000, "cache_write_tokens": 1_000},
|
||||
"output_tokens": 900,
|
||||
"output_tokens_details": {"reasoning_tokens": 640},
|
||||
"prompt_tokens": 48_000,
|
||||
"prompt_tokens_details": {"cached_tokens": 44_000, "cache_write_tokens": 1_000},
|
||||
"completion_tokens": 900,
|
||||
"completion_tokens_details": {"reasoning_tokens": 640},
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -79,9 +84,9 @@ def test_native_openai_usage_survives_the_anthropic_translation(logged) -> None:
|
|||
event = logged(NATIVE)
|
||||
native = event["native_usage"]
|
||||
# Verbatim: the fields an Anthropic-shaped response cannot carry.
|
||||
assert native["input_tokens_details"]["cached_tokens"] == 44_000
|
||||
assert native["input_tokens_details"]["cache_write_tokens"] == 1_000
|
||||
assert native["output_tokens_details"]["reasoning_tokens"] == 640
|
||||
assert native["prompt_tokens_details"]["cached_tokens"] == 44_000
|
||||
assert native["prompt_tokens_details"]["cache_write_tokens"] == 1_000
|
||||
assert native["completion_tokens_details"]["reasoning_tokens"] == 640
|
||||
assert event["response_id"] == "resp_68f2c1"
|
||||
|
||||
|
||||
|
|
@ -100,7 +105,10 @@ def test_the_captured_event_normalizes_with_openai_arithmetic(logged) -> None:
|
|||
event = logged(NATIVE)
|
||||
# The provider the LOG recorded, not one the test supplies - passing
|
||||
# OPENAI_RESPONSES by hand here is what hid the adapter-key mismatch.
|
||||
assert event["provider"] == OPENAI_RESPONSES
|
||||
# LITELLM_NORMALIZED, not OPENAI_RESPONSES: a proxy callback never sees the
|
||||
# upstream body. Measured against a real gateway - the Responses adapter
|
||||
# found none of its keys there and reported every field unknown.
|
||||
assert event["provider"] == LITELLM_NORMALIZED
|
||||
assert event["provider_label"] == "openai"
|
||||
usage = normalize_usage(event["provider"], event["native_usage"])
|
||||
assert usage.total_input_tokens == 48_000
|
||||
|
|
@ -112,7 +120,7 @@ def test_the_captured_event_normalizes_with_openai_arithmetic(logged) -> None:
|
|||
def test_usage_without_details_normalizes_to_unknown_rather_than_zero(logged) -> None:
|
||||
"""The mutation the accounting must not survive: dropped details, silent zeros."""
|
||||
|
||||
stripped = {k: v for k, v in NATIVE.items() if k != "input_tokens_details"}
|
||||
stripped = {k: v for k, v in NATIVE.items() if k != "prompt_tokens_details"}
|
||||
event = logged(stripped)
|
||||
usage = normalize_usage(event["provider"], event["native_usage"])
|
||||
assert usage.cache_read_input_tokens is None
|
||||
|
|
@ -238,10 +246,16 @@ def test_an_unresolvable_provider_is_refused_rather_than_guessed() -> None:
|
|||
|
||||
from workflow_bench.provider_usage import canonical_provider
|
||||
|
||||
assert canonical_provider("openai", "responses") == OPENAI_RESPONSES
|
||||
assert canonical_provider("openai", "completion") is None
|
||||
assert canonical_provider("openai", None) is None
|
||||
# Every openai call reaching this callback has already been normalised by
|
||||
# LiteLLM, whatever endpoint it used - the observed call_type for a Claude
|
||||
# Code request through the gateway is "anthropic_messages". The adapter has
|
||||
# to match the object in hand, not the protocol on the wire.
|
||||
assert canonical_provider("openai", "responses") == LITELLM_NORMALIZED
|
||||
assert canonical_provider("openai", "anthropic_messages") == LITELLM_NORMALIZED
|
||||
assert canonical_provider("anthropic", "completion") == ANTHROPIC
|
||||
# An unrecognised provider is still refused rather than guessed.
|
||||
assert canonical_provider("some-new-provider", "responses") is None
|
||||
assert canonical_provider(None, None) is None
|
||||
|
||||
|
||||
def test_request_identity_cannot_come_from_the_proxy_environment() -> None:
|
||||
|
|
|
|||
|
|
@ -195,6 +195,11 @@ def test_eval_ci_uses_locked_uv_and_blocking_native_containment_jobs():
|
|||
assert containment["env"] == {
|
||||
"GITNEXUS_REQUIRE_BWRAP_CANARY": "1",
|
||||
"GITNEXUS_REQUIRE_CLAUDE_CANARY": "1",
|
||||
# This job is the only place with bubblewrap, the pinned runtime and a
|
||||
# built GitNexus together, so it is where the offline sweep runs with
|
||||
# nothing provisioning-stubbed. Pinned here so the gate cannot be
|
||||
# dropped and leave the sweep silently running the stubbed path.
|
||||
"GITNEXUS_REQUIRE_FULL_SWEEP": "1",
|
||||
}
|
||||
assert containment["timeout-minutes"] == 20
|
||||
assert containment_node_setup["with"] == {
|
||||
|
|
@ -239,6 +244,12 @@ def test_eval_ci_uses_locked_uv_and_blocking_native_containment_jobs():
|
|||
"tests/test_proposer_sandbox.py",
|
||||
"tests/test_workflow_bench_sessions.py",
|
||||
"tests/test_ce_plugin_runtime.py",
|
||||
# The offline sweep, run here with nothing stubbed: this job is the only
|
||||
# one carrying bubblewrap, the pinned runtime and a built GitNexus.
|
||||
"tests/test_offline_sweep_integration.py",
|
||||
# Carries the real-CLI identity probe, which needs CLAUDE_CANARY_BIN -
|
||||
# set only on this job. Omitted from this list it skipped everywhere.
|
||||
"tests/test_mock_provider.py",
|
||||
"-q",
|
||||
]
|
||||
bwrap_canary_marker = re.compile(
|
||||
|
|
@ -1052,3 +1063,33 @@ def test_a_raising_packed_cell_still_persists_its_settled_siblings():
|
|||
)
|
||||
|
||||
assert (1, "review") in folded, "the sibling that completed was never recorded"
|
||||
|
||||
|
||||
def test_an_uninvoked_skill_still_counts_toward_the_arm_median():
|
||||
"""Pins a KNOWN GAP, not a desired behaviour.
|
||||
|
||||
A cell whose skill never ran still moves the arm's quality median, even
|
||||
though an arm exists to measure a SKILL. The narrow fix - filtering those
|
||||
rows out of the quality metrics - is worse than the gap: valid_runs and
|
||||
excluded_runs keep counting them, so the promotion gate sees N clean runs
|
||||
while the median came from fewer. Since the dropped rows are systematically
|
||||
an arm's worst, that biases toward promoting, and it was measured flipping
|
||||
keep_incumbent to promote.
|
||||
|
||||
Closing it honestly needs a scored-run count and a paired-equality check in
|
||||
the promotion gate. Pinned here so the half-fix cannot be reapplied without
|
||||
someone reading why it was reverted.
|
||||
"""
|
||||
|
||||
good = record(review_weighted_f1=1.0, cost_usd=2.0)
|
||||
uninvoked = record(
|
||||
review_weighted_f1=0.0, cost_usd=4.0, error_kind="skill-not-invoked", skill_invoked=False
|
||||
)
|
||||
agg = aggregate([good, uninvoked])
|
||||
|
||||
assert agg["review_weighted_f1"] == 0.5, "the uninvoked row is counted - the known gap"
|
||||
assert agg["cost_usd"] == 3.0
|
||||
# The invariant that makes the half-fix unsafe: the median and the run count
|
||||
# the gate reads must cover the same rows.
|
||||
assert agg["valid_runs"] == 2
|
||||
|
||||
|
|
|
|||
|
|
@ -42,8 +42,8 @@ def canonical_provider(label, call_type): # noqa: ANN001, ANN201
|
|||
above for why this is a copy rather than an import.
|
||||
"""
|
||||
|
||||
if label == "openai" and call_type and "responses" in call_type:
|
||||
return "openai-responses"
|
||||
if label == "openai":
|
||||
return "litellm-normalized"
|
||||
if label == "anthropic":
|
||||
return "anthropic"
|
||||
return None
|
||||
|
|
@ -104,11 +104,10 @@ class ProviderUsageLogger(CustomLogger):
|
|||
"requested_model": kwargs.get("model"),
|
||||
"actual_model": getattr(response_obj, "model", None),
|
||||
# Two fields, because they answer different questions. The raw
|
||||
# label is what LiteLLM said; "provider" is the adapter key,
|
||||
# which needs the call type too - LiteLLM reports "openai" for
|
||||
# both Chat Completions and Responses and those report usage
|
||||
# differently. Unresolvable stays None so normalize_usage
|
||||
# refuses rather than guessing token semantics.
|
||||
# label is what LiteLLM said; "provider" is the adapter key for
|
||||
# the object actually in hand, which is always LiteLLM's own
|
||||
# normalised shape here. An unrecognised label stays None so
|
||||
# normalize_usage refuses rather than guessing token semantics.
|
||||
"provider_label": provider_label,
|
||||
"provider": canonical_provider(provider_label, call_type),
|
||||
"response_id": getattr(response_obj, "id", None),
|
||||
|
|
|
|||
284
eval/workflow_bench/mock_provider.py
Normal file
284
eval/workflow_bench/mock_provider.py
Normal file
|
|
@ -0,0 +1,284 @@
|
|||
"""A scriptable stand-in for Anthropic and OpenAI, for running the harness offline.
|
||||
|
||||
Every defect this benchmark shipped in the last round was invisible to its own
|
||||
tests for the same reason: the tests exercised a layer BELOW where the code
|
||||
runs. The usage log was never written because the proxy is a subprocess with a
|
||||
constructed environment. The callback could not be imported because LiteLLM
|
||||
loads it by path. Failures went unrecorded because only the async hook was
|
||||
overridden. Each was caught by CI or review, never by a unit test, because the
|
||||
unit test called the function directly instead of driving the path that calls
|
||||
it.
|
||||
|
||||
This closes that gap without spending money. It speaks the two wire protocols
|
||||
the harness actually depends on, so a run can go through the real sandbox, the
|
||||
real Claude Code CLI, the real gateway and the real usage callback, and only
|
||||
the model is fake:
|
||||
|
||||
POST /v1/messages Anthropic Messages, streaming and non-streaming
|
||||
POST /v1/responses OpenAI Responses, which the gateway translates into
|
||||
|
||||
Point the runner at it with ``--base-url http://127.0.0.1:<port>``, which is
|
||||
the same supported path the free-model proxy documentation already uses, or
|
||||
give it to LiteLLM as ``api_base`` to exercise the gateway.
|
||||
|
||||
Scripted, not simulated: replies are supplied by the caller, so a test decides
|
||||
what the model "says", which tools it asks for, and exactly what usage it
|
||||
reports. That last part is what makes provider-native accounting testable at
|
||||
all - real cache hits are not reproducible on demand, but a declared
|
||||
``cache_read`` of 44_000 is.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import threading
|
||||
import time
|
||||
from collections import deque
|
||||
from dataclasses import dataclass, field
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from typing import Any
|
||||
|
||||
|
||||
@dataclass
|
||||
class Reply:
|
||||
"""One scripted model turn.
|
||||
|
||||
``tools`` drives real tool execution: Claude Code runs what it is asked to
|
||||
run, so a reply carrying a Write block makes the CLI write that file inside
|
||||
the sandbox for real. That is how an artifact-producing cell can be
|
||||
exercised without a model deciding anything.
|
||||
"""
|
||||
|
||||
text: str = "ok"
|
||||
tools: list[dict[str, Any]] = field(default_factory=list)
|
||||
stop_reason: str = "end_turn"
|
||||
# Anthropic accounting: input_tokens is the UNCACHED remainder and the
|
||||
# cache fields add to it. Defaults are deliberately non-zero so a test that
|
||||
# forgets to script usage still cannot mistake silence for a measurement.
|
||||
input_tokens: int = 11
|
||||
output_tokens: int = 7
|
||||
# None means the field is OMITTED from the reply, which is not the same as
|
||||
# reporting 0. A consumer that cannot tell those apart is the bug this
|
||||
# harness exists to catch, so the mock has to be able to script absence.
|
||||
cache_read_input_tokens: int | None = 0
|
||||
cache_creation_input_tokens: int | None = 0
|
||||
status_code: int = 200
|
||||
error_body: dict[str, Any] | None = None
|
||||
|
||||
|
||||
@dataclass
|
||||
class Request:
|
||||
"""What the harness actually sent, kept so a test can assert on it."""
|
||||
|
||||
path: str
|
||||
headers: dict[str, str]
|
||||
body: dict[str, Any]
|
||||
|
||||
|
||||
class _Handler(BaseHTTPRequestHandler):
|
||||
provider: MockProvider
|
||||
|
||||
def log_message(self, *_args: Any) -> None: # noqa: A003 - silence the default stderr spam
|
||||
return
|
||||
|
||||
def do_POST(self) -> None: # noqa: N802 - BaseHTTPRequestHandler's interface
|
||||
length = int(self.headers.get("Content-Length") or 0)
|
||||
raw = self.rfile.read(length) if length else b"{}"
|
||||
try:
|
||||
body = json.loads(raw or b"{}")
|
||||
except json.JSONDecodeError:
|
||||
body = {"_unparsed": raw.decode("utf-8", "replace")}
|
||||
self.provider.record(Request(self.path, dict(self.headers), body))
|
||||
reply = self.provider.next_reply()
|
||||
|
||||
if reply.status_code != 200:
|
||||
self._send_json(reply.status_code, reply.error_body or {"error": {"message": "scripted failure"}})
|
||||
return
|
||||
if self.path.rstrip("/").endswith("/responses"):
|
||||
self._send_json(200, _openai_response(reply))
|
||||
return
|
||||
if body.get("stream"):
|
||||
self._send_anthropic_stream(reply)
|
||||
return
|
||||
self._send_json(200, _anthropic_message(reply))
|
||||
|
||||
def _send_json(self, status: int, payload: dict[str, Any]) -> None:
|
||||
encoded = json.dumps(payload).encode()
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(encoded)))
|
||||
self.end_headers()
|
||||
self.wfile.write(encoded)
|
||||
|
||||
def _send_anthropic_stream(self, reply: Reply) -> None:
|
||||
self.send_response(200)
|
||||
self.send_header("Content-Type", "text/event-stream")
|
||||
self.send_header("Cache-Control", "no-cache")
|
||||
self.end_headers()
|
||||
for event, data in _anthropic_stream_events(reply):
|
||||
self.wfile.write(f"event: {event}\ndata: {json.dumps(data)}\n\n".encode())
|
||||
self.wfile.flush()
|
||||
|
||||
|
||||
def _content_blocks(reply: Reply) -> list[dict[str, Any]]:
|
||||
blocks: list[dict[str, Any]] = [{"type": "text", "text": reply.text}]
|
||||
for index, tool in enumerate(reply.tools):
|
||||
blocks.append(
|
||||
{
|
||||
"type": "tool_use",
|
||||
"id": f"toolu_mock_{index}",
|
||||
"name": tool["name"],
|
||||
"input": tool.get("input", {}),
|
||||
}
|
||||
)
|
||||
return blocks
|
||||
|
||||
|
||||
def _anthropic_usage(reply: Reply) -> dict[str, int]:
|
||||
usage = {
|
||||
"input_tokens": reply.input_tokens,
|
||||
"output_tokens": reply.output_tokens,
|
||||
"cache_read_input_tokens": reply.cache_read_input_tokens,
|
||||
"cache_creation_input_tokens": reply.cache_creation_input_tokens,
|
||||
}
|
||||
return {field: value for field, value in usage.items() if value is not None}
|
||||
|
||||
|
||||
def _anthropic_message(reply: Reply) -> dict[str, Any]:
|
||||
return {
|
||||
"id": "msg_mock",
|
||||
"type": "message",
|
||||
"role": "assistant",
|
||||
"model": "mock-model",
|
||||
"content": _content_blocks(reply),
|
||||
"stop_reason": "tool_use" if reply.tools else reply.stop_reason,
|
||||
"stop_sequence": None,
|
||||
"usage": _anthropic_usage(reply),
|
||||
}
|
||||
|
||||
|
||||
def _anthropic_stream_events(reply: Reply) -> list[tuple[str, dict[str, Any]]]:
|
||||
"""The SSE sequence a Messages consumer expects, in order."""
|
||||
|
||||
message = _anthropic_message(reply)
|
||||
events: list[tuple[str, dict[str, Any]]] = [
|
||||
("message_start", {"type": "message_start", "message": {**message, "content": [], "usage": _anthropic_usage(reply)}})
|
||||
]
|
||||
for index, block in enumerate(message["content"]):
|
||||
if block["type"] == "text":
|
||||
events.append(("content_block_start", {"type": "content_block_start", "index": index, "content_block": {"type": "text", "text": ""}}))
|
||||
events.append(("content_block_delta", {"type": "content_block_delta", "index": index, "delta": {"type": "text_delta", "text": block["text"]}}))
|
||||
else:
|
||||
events.append(("content_block_start", {"type": "content_block_start", "index": index, "content_block": {"type": "tool_use", "id": block["id"], "name": block["name"], "input": {}}}))
|
||||
events.append(("content_block_delta", {"type": "content_block_delta", "index": index, "delta": {"type": "input_json_delta", "partial_json": json.dumps(block["input"])}}))
|
||||
events.append(("content_block_stop", {"type": "content_block_stop", "index": index}))
|
||||
events.append(("message_delta", {"type": "message_delta", "delta": {"stop_reason": message["stop_reason"], "stop_sequence": None}, "usage": {"output_tokens": reply.output_tokens}}))
|
||||
events.append(("message_stop", {"type": "message_stop"}))
|
||||
return events
|
||||
|
||||
|
||||
def _openai_response(reply: Reply) -> dict[str, Any]:
|
||||
"""OpenAI Responses shape: input_tokens is the WHOLE, cache fields subsets."""
|
||||
|
||||
# An omitted cache field contributes nothing to the Responses total; that
|
||||
# is arithmetic, not a claim the value was measured as zero.
|
||||
cache_read = reply.cache_read_input_tokens or 0
|
||||
cache_write = reply.cache_creation_input_tokens or 0
|
||||
total_input = reply.input_tokens + cache_read + cache_write
|
||||
return {
|
||||
"id": "resp_mock",
|
||||
"object": "response",
|
||||
"created_at": int(time.time()),
|
||||
"status": "completed",
|
||||
"model": "mock-model",
|
||||
"error": None,
|
||||
"output": [
|
||||
{
|
||||
"id": "msg_mock",
|
||||
"type": "message",
|
||||
"role": "assistant",
|
||||
"status": "completed",
|
||||
"content": [{"type": "output_text", "text": reply.text, "annotations": []}],
|
||||
},
|
||||
# Tool calls belong here too. Responses is the protocol the gateway
|
||||
# is configured for BECAUSE it carries tool use, so emitting only
|
||||
# output_text meant a reply scripted with a Write or Skill crossed
|
||||
# the gateway with the tool silently dropped - the mock would have
|
||||
# been wrong about the wire on the one path that matters most.
|
||||
*(
|
||||
{
|
||||
"id": f"fc_mock_{index}",
|
||||
"type": "function_call",
|
||||
"status": "completed",
|
||||
"call_id": f"call_mock_{index}",
|
||||
"name": tool["name"],
|
||||
"arguments": json.dumps(tool.get("input", {})),
|
||||
}
|
||||
for index, tool in enumerate(reply.tools)
|
||||
),
|
||||
],
|
||||
"usage": {
|
||||
"input_tokens": total_input,
|
||||
"output_tokens": reply.output_tokens,
|
||||
"total_tokens": total_input + reply.output_tokens,
|
||||
# Omitted stays omitted here too. Collapsing None to 0 is right for
|
||||
# the total above (an unreported field adds nothing) but wrong on
|
||||
# the wire: _int_or_none reads an absent key as unknown and a
|
||||
# present 0 as a measured zero, so serializing 0 would claim a
|
||||
# measurement the reply never made - the same confusion the
|
||||
# Anthropic path already refuses.
|
||||
"input_tokens_details": {
|
||||
**({"cached_tokens": cache_read} if reply.cache_read_input_tokens is not None else {}),
|
||||
**({"cache_write_tokens": cache_write} if reply.cache_creation_input_tokens is not None else {}),
|
||||
},
|
||||
"output_tokens_details": {"reasoning_tokens": 0},
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
class MockProvider:
|
||||
"""Loopback-only provider stand-in. Use as a context manager."""
|
||||
|
||||
def __init__(self, replies: list[Reply] | None = None, *, default: Reply | None = None) -> None:
|
||||
self._replies: deque[Reply] = deque(replies or [])
|
||||
# A run makes more requests than a test wants to script; the default
|
||||
# keeps it going rather than failing on the first unscripted turn.
|
||||
self._default = default or Reply()
|
||||
self._requests: list[Request] = []
|
||||
self._lock = threading.Lock()
|
||||
self._server: ThreadingHTTPServer | None = None
|
||||
|
||||
def __enter__(self) -> MockProvider:
|
||||
handler = type("_BoundHandler", (_Handler,), {"provider": self})
|
||||
# Loopback only: this answers with no authentication at all.
|
||||
self._server = ThreadingHTTPServer(("127.0.0.1", 0), handler)
|
||||
threading.Thread(target=self._server.serve_forever, daemon=True).start()
|
||||
return self
|
||||
|
||||
def __exit__(self, *_exc: object) -> bool:
|
||||
if self._server is not None:
|
||||
self._server.shutdown()
|
||||
self._server.server_close()
|
||||
return False
|
||||
|
||||
@property
|
||||
def port(self) -> int:
|
||||
assert self._server is not None, "provider is not running"
|
||||
return self._server.server_port
|
||||
|
||||
@property
|
||||
def base_url(self) -> str:
|
||||
return f"http://127.0.0.1:{self.port}"
|
||||
|
||||
def record(self, request: Request) -> None:
|
||||
with self._lock:
|
||||
self._requests.append(request)
|
||||
|
||||
def next_reply(self) -> Reply:
|
||||
with self._lock:
|
||||
return self._replies.popleft() if self._replies else self._default
|
||||
|
||||
@property
|
||||
def requests(self) -> list[Request]:
|
||||
with self._lock:
|
||||
return list(self._requests)
|
||||
|
|
@ -50,6 +50,14 @@ USAGE_ENV_VARS = (USAGE_LOG_ENV_VAR, SWEEP_ID_ENV_VAR)
|
|||
|
||||
ANTHROPIC = "anthropic"
|
||||
OPENAI_RESPONSES = "openai-responses"
|
||||
# What the gateway's callback actually receives. LiteLLM does not hand a logger
|
||||
# the upstream body: it normalises usage into its own Chat-Completions-shaped
|
||||
# object first, so an OpenAI Responses reply arrives as prompt_tokens /
|
||||
# prompt_tokens_details even though the wire carried input_tokens /
|
||||
# input_tokens_details. Measured against a real proxy, not assumed - the
|
||||
# Responses adapter below found none of its keys and reported every field
|
||||
# unknown. The arithmetic is still OpenAI's (the whole, with subsets).
|
||||
LITELLM_NORMALIZED = "litellm-normalized"
|
||||
|
||||
|
||||
class UsageSemanticsError(ValueError):
|
||||
|
|
@ -131,6 +139,35 @@ def _normalize_openai_responses(usage: Mapping[str, Any]) -> NormalizedUsage:
|
|||
)
|
||||
|
||||
|
||||
def _normalize_litellm(usage: Mapping[str, Any]) -> NormalizedUsage:
|
||||
"""prompt_tokens is the WHOLE; the details are subsets of it."""
|
||||
|
||||
total = _int_or_none(usage, "prompt_tokens")
|
||||
details = usage.get("prompt_tokens_details")
|
||||
cache_read = _int_or_none(details, "cached_tokens")
|
||||
cache_write = _int_or_none(details, "cache_write_tokens")
|
||||
if cache_write is None:
|
||||
cache_write = _int_or_none(details, "cache_creation_tokens")
|
||||
output_details = usage.get("completion_tokens_details")
|
||||
|
||||
ordinary: int | None = None
|
||||
if total is not None and cache_read is not None and cache_write is not None:
|
||||
ordinary = total - cache_read - cache_write
|
||||
if ordinary < 0:
|
||||
raise UsageSemanticsError(
|
||||
f"LiteLLM cached ({cache_read}) + cache_write ({cache_write}) "
|
||||
f"exceed prompt_tokens ({total})"
|
||||
)
|
||||
return NormalizedUsage(
|
||||
ordinary_input_tokens=ordinary,
|
||||
cache_read_input_tokens=cache_read,
|
||||
cache_write_input_tokens=cache_write,
|
||||
total_input_tokens=total,
|
||||
output_tokens=_int_or_none(usage, "completion_tokens"),
|
||||
reasoning_output_tokens=_int_or_none(output_details, "reasoning_tokens"),
|
||||
)
|
||||
|
||||
|
||||
def _normalize_anthropic(usage: Mapping[str, Any]) -> NormalizedUsage:
|
||||
"""input_tokens is the uncached REMAINDER; the cache fields add to it."""
|
||||
|
||||
|
|
@ -154,16 +191,24 @@ def _normalize_anthropic(usage: Mapping[str, Any]) -> NormalizedUsage:
|
|||
def canonical_provider(label: str | None, call_type: str | None) -> str | None:
|
||||
"""Map LiteLLM's provider label onto an adapter key, or None if unsure.
|
||||
|
||||
LiteLLM reports ``custom_llm_provider`` as "openai" for both Chat
|
||||
Completions and Responses, and those two report usage differently, so the
|
||||
label alone cannot pick an adapter. The call type is what distinguishes
|
||||
them. Returning None when it does not is deliberate: normalize_usage
|
||||
refuses an unknown provider rather than guessing token semantics, which is
|
||||
the whole point of keeping the native object authoritative.
|
||||
Every "openai" label maps to LITELLM_NORMALIZED regardless of call type,
|
||||
because anything reaching a proxy callback has already been normalised by
|
||||
LiteLLM into its own object - measured against a real gateway, where the
|
||||
observed call type is "anthropic_messages" and the upstream Responses shape
|
||||
never arrives. OPENAI_RESPONSES stays in the adapter table for a RAW
|
||||
upstream body, which only direct callers and the wire-shape tests pass.
|
||||
|
||||
An unrecognised label still returns None, so normalize_usage refuses rather
|
||||
than guessing token semantics.
|
||||
"""
|
||||
|
||||
if label == "openai" and call_type and "responses" in call_type:
|
||||
return OPENAI_RESPONSES
|
||||
if label == "openai":
|
||||
# Anything reaching a proxy callback has already been normalised by
|
||||
# LiteLLM, whichever endpoint the caller used - the observed call_type
|
||||
# for a Claude Code request through this gateway is "anthropic_messages",
|
||||
# not a Responses one. The adapter has to match the object in hand, not
|
||||
# the protocol on the wire.
|
||||
return LITELLM_NORMALIZED
|
||||
if label in _ADAPTERS:
|
||||
return label
|
||||
return None
|
||||
|
|
@ -172,6 +217,7 @@ def canonical_provider(label: str | None, call_type: str | None) -> str | None:
|
|||
_ADAPTERS = {
|
||||
ANTHROPIC: _normalize_anthropic,
|
||||
OPENAI_RESPONSES: _normalize_openai_responses,
|
||||
LITELLM_NORMALIZED: _normalize_litellm,
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1591,6 +1591,21 @@ def aggregate(records: list[dict[str, Any]]) -> dict[str, Any]:
|
|||
"review_category_accuracy",
|
||||
"review_grounded_evidence",
|
||||
)
|
||||
# NOTE: a skill-not-invoked row still contributes to these medians. That is
|
||||
# a real measurement gap - an arm exists to measure a SKILL, and a cell
|
||||
# where the skill never ran did not measure it - but the narrow fix is
|
||||
# WORSE than the gap, so it is deliberately not applied here.
|
||||
#
|
||||
# Filtering those rows out of the quality metrics alone leaves valid_runs
|
||||
# and excluded_runs counting them, so the promotion gate sees N clean runs
|
||||
# while the median was taken over fewer. Because the dropped rows are
|
||||
# systematically an arm's worst, that biases toward PROMOTING: measured on
|
||||
# one real run at 0.9 plus two uninvoked rows at 0.0, the gate flipped from
|
||||
# keep_incumbent to promote. The three verdict fields below compound it -
|
||||
# they are all() reducers, so one uninvoked cell flips a whole arm.
|
||||
# Closing this honestly needs a scored-run count and a paired-equality
|
||||
# check in the gate itself: a promotion-semantics change, not an
|
||||
# aggregation fix.
|
||||
if any("review_weighted_f1" in record for record in valid):
|
||||
for metric in review_metrics:
|
||||
values = [record[metric] for record in valid if record.get(metric) is not None]
|
||||
|
|
|
|||
|
|
@ -14,6 +14,8 @@ export type NodeLabel =
|
|||
| 'Folder'
|
||||
| 'File'
|
||||
| 'Class'
|
||||
| 'Protocol'
|
||||
| 'Category'
|
||||
| 'Function'
|
||||
| 'Method'
|
||||
| 'Variable'
|
||||
|
|
|
|||
|
|
@ -137,6 +137,7 @@ export type {
|
|||
FinalizeOutput,
|
||||
FinalizedScc,
|
||||
FinalizeStats,
|
||||
AmbiguousWildcardExport,
|
||||
} from './scope-resolution/finalize-algorithm.js';
|
||||
|
||||
// Scope-aware registries + 7-step lookup (RFC §4; Ring 2 SHARED #917)
|
||||
|
|
|
|||
|
|
@ -32,6 +32,7 @@ const EXTENSION_MAP: Record<SupportedLanguages, readonly string[]> = {
|
|||
[SupportedLanguages.Python]: ['.py'],
|
||||
[SupportedLanguages.Java]: ['.java'],
|
||||
[SupportedLanguages.C]: ['.c'],
|
||||
[SupportedLanguages.ObjectiveC]: ['.m', '.mm'],
|
||||
[SupportedLanguages.CPlusPlus]: [
|
||||
'.cpp',
|
||||
'.cc',
|
||||
|
|
@ -111,6 +112,7 @@ const SYNTAX_MAP: Record<SupportedLanguages, string> = {
|
|||
[SupportedLanguages.Python]: 'python',
|
||||
[SupportedLanguages.Java]: 'java',
|
||||
[SupportedLanguages.C]: 'c',
|
||||
[SupportedLanguages.ObjectiveC]: 'objectivec',
|
||||
[SupportedLanguages.CPlusPlus]: 'cpp',
|
||||
[SupportedLanguages.CSharp]: 'csharp',
|
||||
[SupportedLanguages.Go]: 'go',
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ export enum SupportedLanguages {
|
|||
Java = 'java',
|
||||
C = 'c',
|
||||
CPlusPlus = 'cpp',
|
||||
ObjectiveC = 'objective-c',
|
||||
CSharp = 'csharp',
|
||||
Go = 'go',
|
||||
Ruby = 'ruby',
|
||||
|
|
|
|||
|
|
@ -13,6 +13,8 @@ export const NODE_TABLES = [
|
|||
'Folder',
|
||||
'Function',
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Interface',
|
||||
'Method',
|
||||
'CodeElement',
|
||||
|
|
|
|||
|
|
@ -5,13 +5,14 @@
|
|||
* Pure logic that takes per-file parse output (`ParsedImport[]` +
|
||||
* `SymbolDefinition[]`) and returns:
|
||||
*
|
||||
* - Linked `ImportEdge[]` per module scope, with `targetModuleScope` and
|
||||
* `targetDefId` filled where resolvable; edges that could not be
|
||||
* resolved within the hard fixpoint cap are marked
|
||||
* - Linked `ImportEdge[]` keyed by binding scope (`fromScope`; module
|
||||
* scope unless `importsBindAtLexicalScope` is on), with
|
||||
* `targetModuleScope` and `targetDefId` filled where resolvable; edges
|
||||
* that could not be resolved within the hard fixpoint cap are marked
|
||||
* `linkStatus: 'unresolved'`.
|
||||
* - Materialized `bindings` per module scope — local defs merged with
|
||||
* imported / wildcard-expanded / re-exported names via the provider's
|
||||
* `mergeBindings` precedence.
|
||||
* - Materialized `bindings` keyed by the same scopes — local defs merged
|
||||
* with imported / wildcard-expanded / re-exported names via the
|
||||
* provider's `mergeBindings` precedence.
|
||||
* - The SCC condensation of the import graph, exposed so disjoint SCCs
|
||||
* can be processed in parallel by callers that want that.
|
||||
*
|
||||
|
|
@ -39,7 +40,7 @@ import type { BindingRef, ImportEdge, ParsedImport, ScopeId, WorkspaceIndex } fr
|
|||
/** Per-file input for the finalize pass. */
|
||||
export interface FinalizeFile {
|
||||
readonly filePath: string;
|
||||
/** The module scope id for this file; owns the finalized imports + bindings. */
|
||||
/** Default binding scope for imports without lexical provenance or opt-in. */
|
||||
readonly moduleScope: ScopeId;
|
||||
readonly parsedImports: readonly ParsedImport[];
|
||||
/**
|
||||
|
|
@ -84,6 +85,10 @@ export interface FinalizeInput {
|
|||
* expects pure answers.
|
||||
*/
|
||||
export interface FinalizeHooks {
|
||||
/** Bind imports at their extracted lexical scope. Missing provenance retains
|
||||
* the legacy module-scope behavior. Opt-in: lexical position and language
|
||||
* import-binding semantics are distinct facts. */
|
||||
readonly importsBindAtLexicalScope?: boolean;
|
||||
/**
|
||||
* Resolve a raw import target to the concrete file path that owns it.
|
||||
* Return `null` when no target file is resolvable (e.g., `np.foo` when
|
||||
|
|
@ -114,6 +119,34 @@ export interface FinalizeHooks {
|
|||
*/
|
||||
expandsWildcardTo(targetModuleScope: ScopeId, workspaceIndex: WorkspaceIndex): readonly string[];
|
||||
|
||||
/**
|
||||
* Does this language make two `wildcard` re-exports that both DECLARE the
|
||||
* same name AMBIGUOUS (no winner), rather than overloads or redeclarations
|
||||
* of one entity?
|
||||
*
|
||||
* True for ECMAScript modules: `export * from './a'; export * from './b'`
|
||||
* with `collide` declared in both excludes the name from the module's
|
||||
* exports, so binding either source is a guess. False (the default) for
|
||||
* languages whose wildcard import is `#include`, `require`, or a package
|
||||
* fan-out, where the same name declared in two files is an overload set
|
||||
* (C++ `write_audit(int)` / `write_audit(int, int)` across two headers), a
|
||||
* redeclaration of one function, or a per-file `init` — legal, and resolved
|
||||
* downstream by arity or by definition. Only a language that opts in has
|
||||
* its collisions refused and reported via `ambiguousWildcardExports`.
|
||||
*/
|
||||
readonly wildcardCollisionIsAmbiguous?: boolean;
|
||||
|
||||
/**
|
||||
* A named import / named re-export binds only to MODULE-LEVEL declarations
|
||||
* of the target file. Opt-in for languages whose `import { x }` can never
|
||||
* reach a class member: without it, a class method sharing a name with a
|
||||
* top-level value — or standing alone — wins the callable preference in
|
||||
* `findExportByName` and the import binds to a symbol the module cannot
|
||||
* export (a confident wrong edge). Languages that bind module-level members
|
||||
* by bare name (static members, module functions) leave it off.
|
||||
*/
|
||||
readonly namedImportsBindTopLevelOnly?: boolean;
|
||||
|
||||
/**
|
||||
* Merge `incoming` bindings into `existing` for a given name. Called
|
||||
* once per name at each scope. Typical rules:
|
||||
|
|
@ -164,12 +197,32 @@ export interface FinalizeStats {
|
|||
readonly unresolvedEdges: number;
|
||||
readonly sccCount: number;
|
||||
readonly largestSccSize: number;
|
||||
/**
|
||||
* Names a file re-exported through two or more `export *` sources that each
|
||||
* DECLARE the name, so the language names no winner. The finalize pass
|
||||
* refuses to bind them (they are absent from the file's re-export closure
|
||||
* AND from its wildcard-expanded module-scope bindings) instead of taking the
|
||||
* first-listed source and publishing the guess as `import-resolved`.
|
||||
* Reported so the caller can record the refusal — an importer of that name
|
||||
* stays unresolved, and the reason must be auditable rather than silent.
|
||||
*/
|
||||
readonly ambiguousWildcardExports: readonly AmbiguousWildcardExport[];
|
||||
}
|
||||
|
||||
/** One refused `export *` collision — see `FinalizeStats.ambiguousWildcardExports`. */
|
||||
export interface AmbiguousWildcardExport {
|
||||
readonly filePath: string;
|
||||
readonly name: string;
|
||||
/** `nodeId`s of the colliding declarations, in `export *` declaration order. */
|
||||
readonly candidateDefIds: readonly string[];
|
||||
}
|
||||
|
||||
export interface FinalizeOutput {
|
||||
/** Linked `ImportEdge[]` per module scope, in original input order. */
|
||||
/** Linked `ImportEdge[]` keyed by binding scope (`fromScope`). Module scope
|
||||
* for languages that bind file-wide; nested lexical scopes when
|
||||
* `importsBindAtLexicalScope` is on. */
|
||||
readonly imports: ReadonlyMap<ScopeId, readonly ImportEdge[]>;
|
||||
/** Materialized bindings per module scope. */
|
||||
/** Materialized bindings keyed by the same scopes as `imports`. */
|
||||
readonly bindings: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
|
||||
/** SCCs in reverse-topological order (leaves first). */
|
||||
readonly sccs: readonly FinalizedScc[];
|
||||
|
|
@ -223,7 +276,33 @@ export function finalize(input: FinalizeInput, hooks: FinalizeHooks): FinalizeOu
|
|||
// SCC-condensed). Eliminates the recursive crawl that the per-edge
|
||||
// `tryFinalize` call site used to do; lookups are O(1) afterwards.
|
||||
// See `buildReexportClosures` for the algorithm.
|
||||
const reexportClosures = buildReexportClosures(input.files, byFilePath, edgeIndex);
|
||||
// A local import is a dependency of its file, not a re-export of that file.
|
||||
const moduleEdgeIndex = new Map<string, ImportEdgeDraft[]>();
|
||||
for (const file of input.files) {
|
||||
moduleEdgeIndex.set(
|
||||
file.filePath,
|
||||
(edgeIndex.get(file.filePath) ?? []).filter((d) => d.fromScope === file.moduleScope),
|
||||
);
|
||||
}
|
||||
const ambiguityByFile = collectAmbiguityByFile(
|
||||
input.files,
|
||||
byFilePath,
|
||||
moduleEdgeIndex,
|
||||
hooks.wildcardCollisionIsAmbiguous === true,
|
||||
hooks.namedImportsBindTopLevelOnly === true,
|
||||
);
|
||||
const ambiguousByFile = new Map<string, ReadonlySet<string>>();
|
||||
for (const [filePath, byName] of ambiguityByFile) {
|
||||
ambiguousByFile.set(filePath, new Set(byName.keys()));
|
||||
}
|
||||
const topLevelOnly = hooks.namedImportsBindTopLevelOnly === true;
|
||||
const reexportClosures = buildReexportClosures(
|
||||
input.files,
|
||||
byFilePath,
|
||||
moduleEdgeIndex,
|
||||
ambiguousByFile,
|
||||
topLevelOnly,
|
||||
);
|
||||
|
||||
// ── Phase 3: process SCCs in reverse-topological order (leaves first).
|
||||
// Within each SCC, run a bounded fixpoint that resolves intra-SCC edges.
|
||||
|
|
@ -231,6 +310,19 @@ export function finalize(input: FinalizeInput, hooks: FinalizeHooks): FinalizeOu
|
|||
// already finalized); edges inside the SCC may need multiple passes.
|
||||
const linkedByScope = new Map<ScopeId, readonly ImportEdge[]>();
|
||||
let linkedEdges = 0;
|
||||
// Every refused wildcard name, reported from the ambiguity map rather than from
|
||||
// the edges phase 4 happens to drop: a language whose `expandsWildcardTo`
|
||||
// returns nothing (TypeScript — `export *` never binds names locally) drops
|
||||
// no expanded edge, yet its importers were refused through the closure just
|
||||
// the same, and that refusal must still be visible. Named-vs-named conflicts
|
||||
// remain refused above but are not export-star collisions in this audit.
|
||||
const ambiguousWildcardExports: AmbiguousWildcardExport[] = [];
|
||||
for (const [filePath, byName] of ambiguityByFile) {
|
||||
for (const [name, ambiguity] of byName) {
|
||||
if (ambiguity.kind !== 'wildcard') continue;
|
||||
ambiguousWildcardExports.push({ filePath, name, candidateDefIds: ambiguity.candidateDefIds });
|
||||
}
|
||||
}
|
||||
|
||||
for (const scc of sccs) {
|
||||
const sccFiles = new Set(scc.files);
|
||||
|
|
@ -249,7 +341,7 @@ export function finalize(input: FinalizeInput, hooks: FinalizeHooks): FinalizeOu
|
|||
if (drafts === undefined) continue;
|
||||
for (const draft of drafts) {
|
||||
if (draft.finalized !== null) continue;
|
||||
const finalized = tryFinalize(draft, byFilePath, reexportClosures);
|
||||
const finalized = tryFinalize(draft, byFilePath, reexportClosures, topLevelOnly);
|
||||
if (finalized !== null) {
|
||||
draft.finalized = finalized;
|
||||
progressed = true;
|
||||
|
|
@ -272,13 +364,25 @@ export function finalize(input: FinalizeInput, hooks: FinalizeHooks): FinalizeOu
|
|||
}
|
||||
}
|
||||
|
||||
// ── Phase 4: collect finalized `ImportEdge[]` per module scope, preserving
|
||||
// ── Phase 4: collect finalized `ImportEdge[]` per binding scope, preserving
|
||||
// input order within each file, and wildcard-expand where applicable.
|
||||
for (const file of input.files) {
|
||||
const drafts = edgeIndex.get(file.filePath);
|
||||
if (drafts === undefined) continue;
|
||||
const finalized: ImportEdge[] = [];
|
||||
const finalizedByScope = new Map<ScopeId, ImportEdge[]>([[file.moduleScope, []]]);
|
||||
// Names this file's `export *` sources collide on (see
|
||||
// `collectAmbiguousWildcards`). Their expanded edges are dropped here, so
|
||||
// the file's own module scope does not bind an arbitrary winner either —
|
||||
// suppressing them only in the closure would leave this binding standing,
|
||||
// and it was this binding, not the closure, that produced the published
|
||||
// `import-resolved` guess.
|
||||
const ambiguousHere = ambiguousByFile.get(file.filePath) ?? EMPTY_NAME_SET;
|
||||
for (const d of drafts) {
|
||||
let finalized = finalizedByScope.get(d.fromScope);
|
||||
if (finalized === undefined) {
|
||||
finalized = [];
|
||||
finalizedByScope.set(d.fromScope, finalized);
|
||||
}
|
||||
const edge = d.finalized;
|
||||
if (edge === null) {
|
||||
throw new Error(`Invariant violated: import edge was not finalized for ${file.filePath}`);
|
||||
|
|
@ -286,16 +390,25 @@ export function finalize(input: FinalizeInput, hooks: FinalizeHooks): FinalizeOu
|
|||
if (d.source.kind === 'wildcard' && edge.linkStatus !== 'unresolved') {
|
||||
// Produce one `wildcard-expanded` ImportEdge per exported name.
|
||||
const expanded = expandWildcard(edge, byFilePath, hooks, input.workspaceIndex);
|
||||
for (const e of expanded) finalized.push(e);
|
||||
for (const e of expanded) {
|
||||
if (
|
||||
d.fromScope === file.moduleScope &&
|
||||
e.kind === 'wildcard-expanded' &&
|
||||
ambiguousHere.has(e.localName)
|
||||
)
|
||||
continue;
|
||||
finalized.push(e);
|
||||
}
|
||||
} else {
|
||||
finalized.push(edge);
|
||||
}
|
||||
if (edge.linkStatus !== 'unresolved') linkedEdges++;
|
||||
}
|
||||
linkedByScope.set(file.moduleScope, Object.freeze(finalized));
|
||||
for (const [scopeId, edges] of finalizedByScope)
|
||||
linkedByScope.set(scopeId, Object.freeze(edges));
|
||||
}
|
||||
|
||||
// ── Phase 5: materialize module-scope bindings (local + imports + wildcards),
|
||||
// ── Phase 5: materialize bindings (local + scoped imports + wildcards),
|
||||
// delegating precedence to `provider.mergeBindings`.
|
||||
const bindingsByScope = materializeBindings(input.files, linkedByScope, hooks);
|
||||
|
||||
|
|
@ -312,6 +425,7 @@ export function finalize(input: FinalizeInput, hooks: FinalizeHooks): FinalizeOu
|
|||
unresolvedEdges: totalEdges - linkedEdges,
|
||||
sccCount,
|
||||
largestSccSize,
|
||||
ambiguousWildcardExports: Object.freeze(ambiguousWildcardExports),
|
||||
};
|
||||
|
||||
return Object.freeze({
|
||||
|
|
@ -339,6 +453,10 @@ function makeEdgeDrafts(
|
|||
hooks: FinalizeHooks,
|
||||
workspace: WorkspaceIndex,
|
||||
): ImportEdgeDraft[] {
|
||||
const fromScope =
|
||||
hooks.importsBindAtLexicalScope === true
|
||||
? (parsed.declaredAtScope ?? file.moduleScope)
|
||||
: file.moduleScope;
|
||||
// Dynamic-unresolved passes through — no `BindingRef`, no target file.
|
||||
if (parsed.kind === 'dynamic-unresolved') {
|
||||
const base: ImportEdge = {
|
||||
|
|
@ -351,7 +469,7 @@ function makeEdgeDrafts(
|
|||
{
|
||||
source: parsed,
|
||||
fromFile: file.filePath,
|
||||
fromScope: file.moduleScope,
|
||||
fromScope,
|
||||
targetFile: null,
|
||||
base,
|
||||
finalized: base, // already fully finalized
|
||||
|
|
@ -381,7 +499,7 @@ function makeEdgeDrafts(
|
|||
{
|
||||
source: parsed,
|
||||
fromFile: file.filePath,
|
||||
fromScope: file.moduleScope,
|
||||
fromScope,
|
||||
targetFile: null,
|
||||
base,
|
||||
finalized: base,
|
||||
|
|
@ -417,7 +535,7 @@ function makeEdgeDrafts(
|
|||
return {
|
||||
source: parsed,
|
||||
fromFile: file.filePath,
|
||||
fromScope: file.moduleScope,
|
||||
fromScope,
|
||||
targetFile: tf,
|
||||
base,
|
||||
finalized: isFileLevelTerminal ? base : null,
|
||||
|
|
@ -529,6 +647,7 @@ function tryFinalize(
|
|||
draft: ImportEdgeDraft,
|
||||
byFilePath: Map<string, FinalizeFile>,
|
||||
reexportClosures: ReadonlyMap<string, FileReexportClosure>,
|
||||
topLevelOnly: boolean,
|
||||
): ImportEdge | null {
|
||||
const targetFile = draft.targetFile;
|
||||
if (targetFile === null) return draft.base; // already terminal
|
||||
|
|
@ -552,7 +671,11 @@ function tryFinalize(
|
|||
// so consumers can reach the module as a symbol — but its absence is not
|
||||
// a failure.
|
||||
if (draft.base.kind === 'namespace') {
|
||||
const moduleDef = findExportByName(targetModule.localDefs, extractExportedName(draft.source));
|
||||
const moduleDef = findExportByName(
|
||||
targetModule.localDefs,
|
||||
extractExportedName(draft.source),
|
||||
topLevelOnly,
|
||||
);
|
||||
return {
|
||||
...draft.base,
|
||||
targetModuleScope: targetModule.moduleScope,
|
||||
|
|
@ -564,7 +687,7 @@ function tryFinalize(
|
|||
// local defs. Multi-hop re-export chains settle iteratively — each hop
|
||||
// resolves once its prior hop is finalized.
|
||||
const importedName = extractExportedName(draft.source);
|
||||
const exported = findExportByName(targetModule.localDefs, importedName);
|
||||
const exported = findExportByName(targetModule.localDefs, importedName, topLevelOnly);
|
||||
|
||||
if (exported !== undefined) {
|
||||
const transitiveVia =
|
||||
|
|
@ -691,15 +814,18 @@ function buildReexportClosures(
|
|||
files: readonly FinalizeFile[],
|
||||
byFilePath: ReadonlyMap<string, FinalizeFile>,
|
||||
edgeIndex: ReadonlyMap<string, ImportEdgeDraft[]>,
|
||||
ambiguous: ReadonlyMap<string, ReadonlySet<string>>,
|
||||
topLevelOnly: boolean,
|
||||
): ReadonlyMap<string, FileReexportClosure> {
|
||||
const closures = new Map<string, Map<string, ReexportClosureEntry>>();
|
||||
for (const file of files) closures.set(file.filePath, new Map());
|
||||
|
||||
// ── Step 1: build the re-export sub-graph (only resolvable wildcard /
|
||||
// reexport / flagged-named targets contribute edges), and collect the
|
||||
// per-file ambiguous names in the same walk.
|
||||
// reexport / flagged-named targets contribute edges). The per-file
|
||||
// ambiguous-name sets arrive precomputed (`collectAmbiguityByFile`) because
|
||||
// phase 4 consults the same sets when it expands wildcards into module
|
||||
// scope — one source of truth for "this name has no winner".
|
||||
const subGraph = new Map<string, Set<string>>();
|
||||
const ambiguous = new Map<string, ReadonlySet<string>>();
|
||||
for (const file of files) {
|
||||
const targets = new Set<string>();
|
||||
const drafts = edgeIndex.get(file.filePath);
|
||||
|
|
@ -710,7 +836,6 @@ function buildReexportClosures(
|
|||
if (!byFilePath.has(d.targetFile)) continue;
|
||||
targets.add(d.targetFile);
|
||||
}
|
||||
ambiguous.set(file.filePath, collectAmbiguousReexports(drafts, byFilePath));
|
||||
}
|
||||
subGraph.set(file.filePath, targets);
|
||||
}
|
||||
|
|
@ -726,7 +851,7 @@ function buildReexportClosures(
|
|||
if (!scc.isCycle) {
|
||||
const filePath = scc.files[0];
|
||||
if (filePath !== undefined) {
|
||||
populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguous);
|
||||
populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguous, topLevelOnly);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
|
@ -740,7 +865,9 @@ function buildReexportClosures(
|
|||
progressed = false;
|
||||
iter++;
|
||||
for (const filePath of scc.files) {
|
||||
if (populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguous)) {
|
||||
if (
|
||||
populateFileClosure(filePath, byFilePath, edgeIndex, closures, ambiguous, topLevelOnly)
|
||||
) {
|
||||
progressed = true;
|
||||
}
|
||||
}
|
||||
|
|
@ -820,6 +947,220 @@ function isNamedReexport(draft: ImportEdgeDraft): draft is ImportEdgeDraft & {
|
|||
* are still filling in, so detecting them needs a set that grows during the
|
||||
* fixpoint — the thing this pre-pass exists to avoid.
|
||||
*/
|
||||
/**
|
||||
* Per-file set of re-exported names that have NO decidable winner, from both
|
||||
* detectors: `collectAmbiguousReexports` (flagged-named vs flagged-named) and
|
||||
* `collectAmbiguousWildcards` (`export *` vs `export *`, direct declarations).
|
||||
* Fixed for the whole run; consulted by the closure fixpoint AND by phase 4's
|
||||
* wildcard expansion, so a refused name is absent from BOTH the exports an
|
||||
* importer can reach and the module-scope bindings the file itself sees.
|
||||
*/
|
||||
interface ReexportAmbiguity {
|
||||
readonly kind: 'named' | 'wildcard';
|
||||
readonly candidateDefIds: readonly string[];
|
||||
}
|
||||
|
||||
function collectAmbiguityByFile(
|
||||
files: readonly FinalizeFile[],
|
||||
byFilePath: ReadonlyMap<string, FinalizeFile>,
|
||||
edgeIndex: ReadonlyMap<string, ImportEdgeDraft[]>,
|
||||
wildcardCollisionIsAmbiguous: boolean,
|
||||
topLevelOnly: boolean,
|
||||
): ReadonlyMap<string, ReadonlyMap<string, ReexportAmbiguity>> {
|
||||
const out = new Map<string, ReadonlyMap<string, ReexportAmbiguity>>();
|
||||
for (const file of files) {
|
||||
const drafts = edgeIndex.get(file.filePath);
|
||||
if (drafts === undefined) continue;
|
||||
const byName = new Map<string, ReexportAmbiguity>();
|
||||
for (const name of collectAmbiguousReexports(drafts, byFilePath)) {
|
||||
byName.set(name, {
|
||||
kind: 'named',
|
||||
candidateDefIds: namedReexportCandidates(drafts, byFilePath, name, topLevelOnly),
|
||||
});
|
||||
}
|
||||
// Wildcard-vs-wildcard is a language rule (`FinalizeHooks.
|
||||
// wildcardCollisionIsAmbiguous`): ECMAScript excludes the name, C++
|
||||
// overloads it. Without the opt-in this half stays first-wins.
|
||||
if (wildcardCollisionIsAmbiguous) {
|
||||
for (const [name, ids] of collectAmbiguousWildcards(file, drafts, byFilePath)) {
|
||||
if (!byName.has(name)) byName.set(name, { kind: 'wildcard', candidateDefIds: ids });
|
||||
}
|
||||
}
|
||||
if (byName.size === 0) continue;
|
||||
out.set(file.filePath, byName);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** The declarations a flagged-named collision on `localName` points at. */
|
||||
function namedReexportCandidates(
|
||||
drafts: readonly ImportEdgeDraft[],
|
||||
byFilePath: ReadonlyMap<string, FinalizeFile>,
|
||||
localName: string,
|
||||
topLevelOnly: boolean,
|
||||
): readonly string[] {
|
||||
const ids: string[] = [];
|
||||
for (const draft of drafts) {
|
||||
if (!isNamedReexport(draft) || draft.source.localName !== localName) continue;
|
||||
const targetFile = draft.targetFile;
|
||||
if (targetFile === null) continue;
|
||||
const target = byFilePath.get(targetFile);
|
||||
if (target === undefined) continue;
|
||||
const def = findExportByName(target.localDefs, draft.source.importedName, topLevelOnly);
|
||||
if (def !== undefined && !ids.includes(def.nodeId)) ids.push(def.nodeId);
|
||||
}
|
||||
return Object.freeze(ids);
|
||||
}
|
||||
|
||||
/**
|
||||
* `export * from './a'; export * from './b'` where BOTH `a` and `b` declare
|
||||
* `collide`: the language names no winner (ECMAScript excludes the name from
|
||||
* the module's exports entirely; a direct `import { collide }` of it is a
|
||||
* SyntaxError-class ambiguity). First-wins here published the `a` binding as
|
||||
* `import-resolved` at full confidence — a definite target for a call that has
|
||||
* none, which is the incorrect-context-over-missing-context failure in its
|
||||
* purest form. The name is refused instead and reported.
|
||||
*
|
||||
* Decidable in this pre-pass because it reads only the targets' own
|
||||
* `localDefs` — nothing that fills in during the closure fixpoint. Collisions
|
||||
* that arrive TRANSITIVELY (two wildcards whose targets each re-export the
|
||||
* name from somewhere else) are still first-wins; detecting them needs a set
|
||||
* that grows mid-fixpoint, the thing this pre-pass exists to avoid.
|
||||
*
|
||||
* A name the file DECLARES itself, or re-exports by NAME, is excluded: an
|
||||
* explicit export shadows every `export *`, so those collisions are legal and
|
||||
* resolved by precedence, not ambiguous.
|
||||
*
|
||||
* Only MODULE-LEVEL, EXPORT-SHAPED declarations can collide. `localDefs` also
|
||||
* carries class members, properties and parameters (a `Property:value` on two
|
||||
* unrelated classes, an interface field named `move`), which no `export *`
|
||||
* publishes. Counting those produced thousands of phantom collisions on a real
|
||||
* monorepo (2,640 on grafana) and — the dangerous half — would have refused a
|
||||
* genuinely exported `move()` because some class elsewhere had a `move`
|
||||
* property. The wildcard closure loop tolerates the wider set because nobody
|
||||
* imports a property by name; a refusal cannot afford the same tolerance.
|
||||
*
|
||||
* Export evidence, when the language supplies it (`SymbolDefinition.isExported`,
|
||||
* tri-state), settles the rest: a def marked `false` is module-private and is
|
||||
* neither a provider here nor published by the closure
|
||||
* (`indexTopLevelExportsByName`), so a private `function foo` beside an exported
|
||||
* one no longer refuses the export — and, the half that matters more, cannot be
|
||||
* the first-listed winner the closure binds either. A def marked `true` counts
|
||||
* whatever its label, `Variable` included: the closure publishes a `Variable`,
|
||||
* so two sources each exporting `const alpha` are a real collision and must be
|
||||
* refused rather than first-wins.
|
||||
*
|
||||
* Without evidence (`isExported` undefined — most languages) `Variable` is
|
||||
* excluded from the COLLISION set only: the typical top-level `const` in a
|
||||
* barrel's sources is module-private (`const category = ['Axis']` in fourteen
|
||||
* option-builder files), so counting it would refuse a real exported constant
|
||||
* of the same name for nothing. Residual risk, accepted, for that evidence-free
|
||||
* case: a non-exported `function`/`class` sharing its name with an exported one
|
||||
* behind the same barrel is counted as a collision and the export is refused —
|
||||
* a missing edge, never a wrong one. `ownerId` is only set for class members, so
|
||||
* a callable nested in an object literal (`showIf: (cfg) => …` across fourteen
|
||||
* option-builder files) still counts as a provider when unmarked. Measured
|
||||
* before the export marker existed: grafana@871af0720 refuses 52 names (from
|
||||
* 2,640 before the member exclusion), discourse@3f71fa15c 5.
|
||||
*/
|
||||
|
||||
/** Labels that are never a module export, whatever their owner. */
|
||||
const NON_EXPORTABLE_MEMBER_LABELS: readonly string[] = [
|
||||
'Property',
|
||||
'Method',
|
||||
'Constructor',
|
||||
'Parameter',
|
||||
'Field',
|
||||
];
|
||||
/** Labels excluded from the collision set when no export evidence is present. */
|
||||
const UNMARKED_NON_COLLIDING_LABELS: ReadonlySet<string> = new Set([
|
||||
...NON_EXPORTABLE_MEMBER_LABELS,
|
||||
'Variable',
|
||||
]);
|
||||
/**
|
||||
* Labels a module can never export by name: class/interface members and
|
||||
* parameters. Filtered by LABEL, not `ownerId` — `ownerId` is populated in a
|
||||
* later pass and is not reliable while the closure is built.
|
||||
*/
|
||||
const MEMBER_LABELS: ReadonlySet<string> = new Set(NON_EXPORTABLE_MEMBER_LABELS);
|
||||
|
||||
/**
|
||||
* A declaration `export *` could publish, for COLLISION purposes: top-level, of
|
||||
* an exportable kind, and not marked module-private. With export evidence the
|
||||
* label rule yields to the marker (an exported `Variable` collides; a private
|
||||
* `function` does not); without it `Variable` is left out — see the header.
|
||||
*/
|
||||
function isWildcardPublishable(def: SymbolDefinition): boolean {
|
||||
// Explicit evidence wins over the label: a CommonJS `module.exports = {
|
||||
// alpha() {} }` member is labeled Method and IS the module's export.
|
||||
if (def.isExported === true) return true;
|
||||
if (def.isExported === false) return false;
|
||||
if (def.ownerId !== undefined) return false;
|
||||
return !UNMARKED_NON_COLLIDING_LABELS.has(def.type);
|
||||
}
|
||||
|
||||
/**
|
||||
* Can a declaration of the barrel's OWN shadow a name its `export *` sources
|
||||
* collide on? Only a module-level binding can — ECMAScript's explicit-export
|
||||
* precedence is about the module's own exports. A class MEMBER named `clash`
|
||||
* (`export class Unrelated { clash() {} }`) is not such a binding and must not
|
||||
* switch the collision check off; it did, and a confident edge to one source's
|
||||
* `clash` was emitted where the import should have been refused.
|
||||
*/
|
||||
function canShadowWildcard(def: SymbolDefinition): boolean {
|
||||
if (def.isExported === true) return true;
|
||||
if (def.isExported === false) return false;
|
||||
if (def.ownerId !== undefined) return false;
|
||||
return !MEMBER_LABELS.has(def.type);
|
||||
}
|
||||
function collectAmbiguousWildcards(
|
||||
file: FinalizeFile,
|
||||
drafts: readonly ImportEdgeDraft[],
|
||||
byFilePath: ReadonlyMap<string, FinalizeFile>,
|
||||
): ReadonlyMap<string, readonly string[]> {
|
||||
const shadowed = new Set<string>();
|
||||
for (const def of file.localDefs) {
|
||||
if (!canShadowWildcard(def)) continue;
|
||||
const name = deriveSimpleName(def);
|
||||
if (name !== null) shadowed.add(name);
|
||||
}
|
||||
for (const draft of drafts) {
|
||||
if (isNamedReexport(draft)) shadowed.add(draft.source.localName);
|
||||
}
|
||||
|
||||
// name → (target file → declaring def ids), in declaration order.
|
||||
const providers = new Map<string, Map<string, string[]>>();
|
||||
for (const draft of drafts) {
|
||||
if (draft.source.kind !== 'wildcard') continue;
|
||||
const targetFile = draft.targetFile;
|
||||
if (targetFile === null) continue;
|
||||
const target = byFilePath.get(targetFile);
|
||||
if (target === undefined) continue;
|
||||
for (const def of target.localDefs) {
|
||||
if (!isWildcardPublishable(def)) continue;
|
||||
const name = deriveSimpleName(def);
|
||||
if (name === null || shadowed.has(name)) continue;
|
||||
let byTarget = providers.get(name);
|
||||
if (byTarget === undefined) {
|
||||
byTarget = new Map<string, string[]>();
|
||||
providers.set(name, byTarget);
|
||||
}
|
||||
const ids = byTarget.get(targetFile);
|
||||
if (ids === undefined) byTarget.set(targetFile, [def.nodeId]);
|
||||
else ids.push(def.nodeId);
|
||||
}
|
||||
}
|
||||
const conflicting = new Map<string, readonly string[]>();
|
||||
for (const [name, byTarget] of providers) {
|
||||
// Two DIFFERENT source files declaring the name. The same file declaring
|
||||
// it twice (overloads, a declaration merged with its namespace) is one
|
||||
// provider and not a collision.
|
||||
if (byTarget.size < 2) continue;
|
||||
conflicting.set(name, Object.freeze([...byTarget.values()].flat()));
|
||||
}
|
||||
return conflicting;
|
||||
}
|
||||
|
||||
function collectAmbiguousReexports(
|
||||
drafts: readonly ImportEdgeDraft[],
|
||||
byFilePath: ReadonlyMap<string, FinalizeFile>,
|
||||
|
|
@ -859,6 +1200,7 @@ function populateFileClosure(
|
|||
edgeIndex: ReadonlyMap<string, ImportEdgeDraft[]>,
|
||||
closures: Map<string, Map<string, ReexportClosureEntry>>,
|
||||
ambiguousByFile: ReadonlyMap<string, ReadonlySet<string>>,
|
||||
topLevelOnly: boolean,
|
||||
): boolean {
|
||||
const myClosure = closures.get(filePath);
|
||||
if (myClosure === undefined) return false;
|
||||
|
|
@ -883,7 +1225,7 @@ function populateFileClosure(
|
|||
if (ambiguous.has(localName) || myClosure.has(localName)) continue;
|
||||
|
||||
const importedName = draft.source.importedName;
|
||||
const direct = findExportByName(targetModule.localDefs, importedName);
|
||||
const direct = findExportByName(targetModule.localDefs, importedName, topLevelOnly);
|
||||
if (direct !== undefined) {
|
||||
myClosure.set(localName, { def: direct, via: Object.freeze([targetFile]) });
|
||||
continue;
|
||||
|
|
@ -909,9 +1251,27 @@ function populateFileClosure(
|
|||
const targetModule = byFilePath.get(targetFile);
|
||||
if (targetModule === undefined) continue;
|
||||
|
||||
for (const def of targetModule.localDefs) {
|
||||
const name = deriveSimpleName(def);
|
||||
if (name === null || ambiguous.has(name) || myClosure.has(name)) continue;
|
||||
// Fan out the WINNER per name, not every def. `export const alpha = () =>
|
||||
// {}` emits both a `Variable` (the lexical declaration) and a `Function`
|
||||
// (the arrow) under the same simple name; iterating `localDefs` raw let
|
||||
// whichever came first — the `Variable` — claim the closure slot, and a
|
||||
// call bound to a value shadow emits no CALLS edge. Named re-exports
|
||||
// already go through `findExportByName`'s callable-preferred index; the
|
||||
// wildcard hop is the same lookup and must apply the same preference.
|
||||
// Measured: grafana `Button`/`clearButtonStyles` (arrow consts behind
|
||||
// `export *`) resolved 8 of 475 ledger entries before this.
|
||||
// Over TOP-LEVEL declarations only. `localDefs` also carries class members;
|
||||
// `Foo.render` (label `Method`, callable) outranked the file's real
|
||||
// `const render` in the callable-preferred index and `import { render }`
|
||||
// bound to a symbol `export *` can never publish — a confident wrong edge
|
||||
// where the value shadow used to yield none. Gated by the same hook as the
|
||||
// named-import path: only a language that opted in (ECMAScript, where
|
||||
// `export *` cannot publish a class member) narrows; every other language's
|
||||
// wildcard keeps the wide index, whose members are legitimately reachable.
|
||||
for (const [name, def] of (topLevelOnly ? indexTopLevelExportsByName : indexExportsByName)(
|
||||
targetModule.localDefs,
|
||||
)) {
|
||||
if (ambiguous.has(name) || myClosure.has(name)) continue;
|
||||
myClosure.set(name, { def, via: Object.freeze([targetFile]) });
|
||||
}
|
||||
const targetClosure = closures.get(targetFile);
|
||||
|
|
@ -993,6 +1353,13 @@ function deriveSimpleName(def: SymbolDefinition): string | null {
|
|||
function findExportByName(
|
||||
defs: readonly SymbolDefinition[],
|
||||
name: string,
|
||||
/**
|
||||
* `true` (a `namedImportsBindTopLevelOnly` language): consult only
|
||||
* module-level declarations, so a class member can neither outrank a
|
||||
* top-level value nor bind on its own. Phase-4 wildcard expansion keeps
|
||||
* the wide index — that is the path languages use to bind members.
|
||||
*/
|
||||
topLevelOnly: boolean = false,
|
||||
): SymbolDefinition | undefined {
|
||||
// GENERIC RULE (applies to every language using this finalize
|
||||
// algorithm): when MULTIPLE `SymbolDefinition`s share the same simple
|
||||
|
|
@ -1018,7 +1385,7 @@ function findExportByName(
|
|||
//
|
||||
// See `gitnexus/test/integration/resolvers/typescript-hof-callbacks.test.ts`
|
||||
// for the cross-file regression this rule prevents.
|
||||
return indexExportsByName(defs).get(name);
|
||||
return (topLevelOnly ? indexTopLevelExportsByName(defs) : indexExportsByName(defs)).get(name);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -1062,6 +1429,47 @@ function indexExportsByName(
|
|||
return index;
|
||||
}
|
||||
|
||||
/**
|
||||
* `indexExportsByName` restricted to declarations a module publishes by name:
|
||||
* members (by LABEL — `ownerId` is stamped by a later reconcile pass and is not
|
||||
* reliable while the closure is built) are skipped unless the language marked
|
||||
* them exported (a CommonJS `module.exports = { alpha() {} }` member), and so
|
||||
* is any def the language marked module-private (`isExported === false`) — a
|
||||
* function nested inside another function carries the Function label and used
|
||||
* to displace the real exported value of the same name here; a barrel cannot
|
||||
* republish what its source never exported, and binding it would put a private
|
||||
* `function foo` in front of the exported one another source provides.
|
||||
* `Variable` stays, since a barrel legitimately republishes a `const`. Same
|
||||
* memoization contract.
|
||||
*/
|
||||
const TOP_LEVEL_EXPORTS_BY_NAME = new WeakMap<
|
||||
readonly SymbolDefinition[],
|
||||
ReadonlyMap<string, SymbolDefinition>
|
||||
>();
|
||||
|
||||
function indexTopLevelExportsByName(
|
||||
defs: readonly SymbolDefinition[],
|
||||
): ReadonlyMap<string, SymbolDefinition> {
|
||||
const cached = TOP_LEVEL_EXPORTS_BY_NAME.get(defs);
|
||||
if (cached !== undefined) return cached;
|
||||
const index = new Map<string, SymbolDefinition>();
|
||||
for (const d of defs) {
|
||||
// Evidence over label, both ways: a marked-private def (a function nested
|
||||
// in another function carries the Function label too) is skipped, and a
|
||||
// marked-exported member (`module.exports = { alpha() {} }`) is admitted.
|
||||
if (d.isExported === false) continue;
|
||||
if (d.isExported !== true && MEMBER_LABELS.has(d.type)) continue;
|
||||
const name = deriveSimpleName(d);
|
||||
if (name === null) continue;
|
||||
const existing = index.get(name);
|
||||
if (existing === undefined) index.set(name, d);
|
||||
else if (!isCallableOrTypeLike(existing.type) && isCallableOrTypeLike(d.type))
|
||||
index.set(name, d);
|
||||
}
|
||||
TOP_LEVEL_EXPORTS_BY_NAME.set(defs, index);
|
||||
return index;
|
||||
}
|
||||
|
||||
const EMPTY_NAME_SET: ReadonlySet<string> = new Set();
|
||||
|
||||
const CALLABLE_OR_TYPE_LIKE: ReadonlySet<string> = new Set([
|
||||
|
|
@ -1179,7 +1587,7 @@ function materializeBindings(
|
|||
linkedByScope: ReadonlyMap<ScopeId, readonly ImportEdge[]>,
|
||||
hooks: FinalizeHooks,
|
||||
): ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>> {
|
||||
const out = new Map<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>();
|
||||
const buckets = new Map<ScopeId, Map<string, readonly BindingRef[]>>();
|
||||
|
||||
// Build a `nodeId → SymbolDefinition` index once across all files
|
||||
// (O(N_files × D_defs)) so the per-edge lookup below is O(1) instead
|
||||
|
|
@ -1204,8 +1612,17 @@ function materializeBindings(
|
|||
scopeBindings.set(name, hooks.mergeBindings(existing, incoming, file.moduleScope));
|
||||
}
|
||||
|
||||
// Layer in finalized imports.
|
||||
const imports = linkedByScope.get(file.moduleScope) ?? [];
|
||||
buckets.set(file.moduleScope, scopeBindings);
|
||||
}
|
||||
|
||||
// Layer imports into their binding scope; lexical locals already live in
|
||||
// the scope tree and must not be copied into unrelated scope buckets.
|
||||
for (const [scopeId, imports] of linkedByScope) {
|
||||
let scopeBindings = buckets.get(scopeId);
|
||||
if (scopeBindings === undefined) {
|
||||
scopeBindings = new Map();
|
||||
buckets.set(scopeId, scopeBindings);
|
||||
}
|
||||
for (const edge of imports) {
|
||||
if (edge.targetDefId === undefined || edge.linkStatus === 'unresolved') continue;
|
||||
const def = defById.get(edge.targetDefId);
|
||||
|
|
@ -1224,15 +1641,18 @@ function materializeBindings(
|
|||
if (name === null) continue;
|
||||
const incoming: BindingRef[] = [{ def, origin, via: edge }];
|
||||
const existing = scopeBindings.get(name) ?? [];
|
||||
scopeBindings.set(name, hooks.mergeBindings(existing, incoming, file.moduleScope));
|
||||
scopeBindings.set(name, hooks.mergeBindings(existing, incoming, scopeId));
|
||||
}
|
||||
}
|
||||
|
||||
const out = new Map<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>();
|
||||
for (const [scopeId, scopeBindings] of buckets) {
|
||||
// Freeze nested buckets for immutability.
|
||||
const frozen = new Map<string, readonly BindingRef[]>();
|
||||
for (const [name, refs] of scopeBindings) {
|
||||
frozen.set(name, Object.freeze(refs.slice()));
|
||||
}
|
||||
out.set(file.moduleScope, frozen);
|
||||
out.set(scopeId, frozen);
|
||||
}
|
||||
|
||||
return out;
|
||||
|
|
|
|||
|
|
@ -9,7 +9,8 @@
|
|||
* Initial classification (locked in Ring 1 #910):
|
||||
* - production: javascript, typescript, python, java, c, cpp, csharp, go,
|
||||
* ruby, rust, php, kotlin, swift, dart
|
||||
* - experimental: vue (embedded-language / SFC complexity),
|
||||
* - experimental: objective-c (fork provider MVP),
|
||||
* vue (embedded-language / SFC complexity),
|
||||
* cobol (regex-provider path)
|
||||
* - quarantined: (none)
|
||||
*
|
||||
|
|
@ -34,6 +35,7 @@ export const LanguageClassifications: Readonly<Record<SupportedLanguages, Langua
|
|||
[SupportedLanguages.Java]: 'production',
|
||||
[SupportedLanguages.C]: 'production',
|
||||
[SupportedLanguages.CPlusPlus]: 'production',
|
||||
[SupportedLanguages.ObjectiveC]: 'experimental',
|
||||
[SupportedLanguages.CSharp]: 'production',
|
||||
[SupportedLanguages.Go]: 'production',
|
||||
[SupportedLanguages.Ruby]: 'production',
|
||||
|
|
|
|||
|
|
@ -4,9 +4,9 @@
|
|||
*
|
||||
* Thin wrapper over `lookupCore`, specialized for class kinds:
|
||||
*
|
||||
* - `acceptedKinds` = Class / Interface / Enum / Struct / Union /
|
||||
* Trait / TypeAlias / Typedef / Record / Delegate / Annotation /
|
||||
* Template / Namespace.
|
||||
* - `acceptedKinds` = Class / Protocol / Category / Interface / Enum /
|
||||
* Struct / Union / Trait / TypeAlias / Typedef / Record / Delegate /
|
||||
* Annotation / Template / Namespace.
|
||||
* - `useReceiverTypeBinding` is **false** — classes are resolved by
|
||||
* name through the lexical chain + global qualified fallback, not
|
||||
* via a receiver type.
|
||||
|
|
|
|||
|
|
@ -136,6 +136,8 @@ export interface RegistryContext {
|
|||
|
||||
export const CLASS_KINDS: readonly NodeLabel[] = Object.freeze([
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Interface',
|
||||
'Enum',
|
||||
'Struct',
|
||||
|
|
|
|||
|
|
@ -82,6 +82,8 @@ const STRICT_ORIGINS: ReadonlySet<BindingRef['origin']> = new Set<BindingRef['or
|
|||
*/
|
||||
const TYPE_KINDS: ReadonlySet<NodeLabel> = new Set<NodeLabel>([
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Interface',
|
||||
'Enum',
|
||||
'Struct',
|
||||
|
|
|
|||
|
|
@ -111,6 +111,18 @@ export interface SymbolDefinition {
|
|||
* source (for example an anonymous class). Consumers may use this only as a
|
||||
* conservative priority hint; it does not change graph-node identity. */
|
||||
isSynthetic?: boolean;
|
||||
/**
|
||||
* Whether the producing language saw EXPORT EVIDENCE on this declaration —
|
||||
* an `export` modifier, a later `export { name }` specifier, an `export
|
||||
* default name`. TRI-STATE, and the absence is load-bearing: `undefined`
|
||||
* means the language emitted no verdict (most languages, and any ECMAScript
|
||||
* file whose export surface is a CommonJS assignment the marker cannot read),
|
||||
* which readers MUST treat as "unknown" and fall back to their prior
|
||||
* behavior. Only `false` says "this module does not publish the name": a
|
||||
* `false` keeps a module-private `function foo` from being counted as a
|
||||
* wildcard provider or bound through a barrel's `export *` closure.
|
||||
*/
|
||||
isExported?: boolean;
|
||||
/** Links Method/Constructor/Property to owning Class/Struct/Trait nodeId */
|
||||
ownerId?: string;
|
||||
/** #1982/#1993: bridge-held enclosing-namespace path (e.g. `NS1`, `Outer.Inner`)
|
||||
|
|
|
|||
|
|
@ -107,7 +107,14 @@ export type CaptureMatch = Readonly<Record<string, Capture>>;
|
|||
* produced when `expandsWildcardTo` materializes a wildcard against target
|
||||
* exports — a provider must never emit it at parse time.
|
||||
*/
|
||||
export type ParsedImport =
|
||||
export type ParsedImport = ParsedImportSyntax & {
|
||||
/** Lexical location retained by extraction, independently of execution timing.
|
||||
* Absent for legacy or synthesized imports. Binding semantics remain opt-in
|
||||
* through FinalizeHooks.importsBindAtLexicalScope. */
|
||||
readonly declaredAtScope?: ScopeId;
|
||||
};
|
||||
|
||||
type ParsedImportSyntax =
|
||||
/**
|
||||
* Per-name import without rename.
|
||||
*
|
||||
|
|
@ -183,14 +190,15 @@ export type ParsedImport =
|
|||
* field exists.** The natural place to decide it looks like the graph
|
||||
* bridge, by walking the scope the finalized edges hang off; that is
|
||||
* exactly what `graph-bridge/imports-to-edges.ts` once attempted, and it
|
||||
* is dead code by construction. `finalize-algorithm.ts:295` publishes
|
||||
* every file's finalized edges as
|
||||
* `linkedByScope.set(file.moduleScope, …)`, so the map the bridge
|
||||
* receives is keyed by the file's **Module** scope and by nothing else:
|
||||
* the walk starts at a `Module` every time and answers `false` for every
|
||||
* import in the tree. Finalize cannot recover the position either —
|
||||
* `FinalizeFile.parsedImports` is a flat per-file `ParsedImport[]` with
|
||||
* no scope attached. The extractor is the last stage that still knows
|
||||
* is dead code by construction. Default finalize still publishes each
|
||||
* file's edges under `file.moduleScope`, so a bridge walk that starts
|
||||
* there answers `false` for every import. Resolvers that opt into
|
||||
* `importsBindAtLexicalScope` instead key the edge by
|
||||
* `parsed.declaredAtScope` when extraction placed the statement (Rust
|
||||
* `use` in a function body is the example). Even then the *execution*
|
||||
* question — does this import run at module init? — is not the same as
|
||||
* the lexical key, and `FinalizeFile.parsedImports` is still a flat
|
||||
* per-file list. The extractor is the last stage that still knows
|
||||
* where the statement sat (`scope-extractor.ts`, Pass 3), so it marks the
|
||||
* fact here and it rides the edge from there — see
|
||||
* {@link ImportEdge.runsOnlyWhenCalled}.
|
||||
|
|
|
|||
86
gitnexus-web/package-lock.json
generated
86
gitnexus-web/package-lock.json
generated
|
|
@ -11,7 +11,7 @@
|
|||
"@langchain/anthropic": "^1.5.8",
|
||||
"@langchain/core": "^1.2.8",
|
||||
"@langchain/google-genai": "^2.2.0",
|
||||
"@langchain/langgraph": "^1.4.9",
|
||||
"@langchain/langgraph": "^1.4.14",
|
||||
"@langchain/ollama": "^1.3.0",
|
||||
"@langchain/openai": "^1.5.3",
|
||||
"@sigma/edge-curve": "^3.1.0",
|
||||
|
|
@ -36,7 +36,7 @@
|
|||
"pandemonium": "^2.4.0",
|
||||
"react": "^19.2.5",
|
||||
"react-dom": "^19.2.8",
|
||||
"react-i18next": "^17.0.12",
|
||||
"react-i18next": "^17.0.13",
|
||||
"react-markdown": "^10.1.0",
|
||||
"react-syntax-highlighter": "^16.1.1",
|
||||
"react-zoom-pan-pinch": "^4.0.3",
|
||||
|
|
@ -51,14 +51,14 @@
|
|||
"@playwright/test": "^1.62.1",
|
||||
"@testing-library/jest-dom": "^7.0.0",
|
||||
"@testing-library/react": "^16.3.3",
|
||||
"@testing-library/user-event": "^14.6.6",
|
||||
"@testing-library/user-event": "^14.6.7",
|
||||
"@types/dompurify": "^3.2.0",
|
||||
"@types/node": "^26.0.1",
|
||||
"@types/react": "^19.2.14",
|
||||
"@types/react": "^19.2.18",
|
||||
"@types/react-dom": "^19.2.4",
|
||||
"@types/react-syntax-highlighter": "^15.5.13",
|
||||
"@vercel/node": "^5.10.2",
|
||||
"@vitejs/plugin-react": "^6.0.5",
|
||||
"@vitejs/plugin-react": "^6.1.1",
|
||||
"@vitest/coverage-v8": "^4.1.11",
|
||||
"jsdom": "^29.1.1",
|
||||
"tree-sitter-wasms": "^0.1.13",
|
||||
|
|
@ -1165,14 +1165,14 @@
|
|||
}
|
||||
},
|
||||
"node_modules/@langchain/langgraph": {
|
||||
"version": "1.4.9",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/langgraph/-/langgraph-1.4.9.tgz",
|
||||
"integrity": "sha512-EvD9rS66Cya09y6rbMgD3Ir8miAkJQFo7FyJOPRPO736Kz3y5TeyeBDOS8ctff/jRc788bPijHx2NVFM79Qqig==",
|
||||
"version": "1.4.14",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/langgraph/-/langgraph-1.4.14.tgz",
|
||||
"integrity": "sha512-uWAdRYTllfKCnTrlyovExPJCHJwcf3Wl2LzUlnaqsT7Rmoo3aCeYtq/7MV/Pw4q11motG8pR8bjr6T6V8Pe1gQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@langchain/langgraph-checkpoint": "^1.1.3",
|
||||
"@langchain/langgraph-sdk": "~1.9.28",
|
||||
"@langchain/protocol": "^0.0.18",
|
||||
"@langchain/langgraph-checkpoint": "^1.1.5",
|
||||
"@langchain/langgraph-sdk": "~1.10.2",
|
||||
"@langchain/protocol": "^0.0.19",
|
||||
"@standard-schema/spec": "1.1.0"
|
||||
},
|
||||
"engines": {
|
||||
|
|
@ -1184,9 +1184,9 @@
|
|||
}
|
||||
},
|
||||
"node_modules/@langchain/langgraph-checkpoint": {
|
||||
"version": "1.1.3",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/langgraph-checkpoint/-/langgraph-checkpoint-1.1.3.tgz",
|
||||
"integrity": "sha512-wgzdQNeEsdw1e+4lvlj0tdq/RYR/k1vPin10g0ymGoehZDDgd9nvIllGXSXN4TFgF9sf5qQP/KTkOcLfeseIhA==",
|
||||
"version": "1.1.5",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/langgraph-checkpoint/-/langgraph-checkpoint-1.1.5.tgz",
|
||||
"integrity": "sha512-BwDwl5VeTOh6CVuiIPgsUgfK51vTJDMSbFcSCUfjJWsl8/DPdK/mbv+ejxJstkSk/BlSPMP4JfXWcN6jD2ea2Q==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
|
|
@ -1196,12 +1196,12 @@
|
|||
}
|
||||
},
|
||||
"node_modules/@langchain/langgraph-sdk": {
|
||||
"version": "1.9.28",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/langgraph-sdk/-/langgraph-sdk-1.9.28.tgz",
|
||||
"integrity": "sha512-4j3XuM0PvtmAbL8mPfBS99ez3+ytRfgbOpAR/nOeaejTRF3Q9dNw2QnaGLGng8wLPtGLoSj+SYgUOVxy9Bv9vg==",
|
||||
"version": "1.10.2",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/langgraph-sdk/-/langgraph-sdk-1.10.2.tgz",
|
||||
"integrity": "sha512-86qsfdBZWu1ZgywLN8AThU/jXi9rjPDZPWcTJp4SA1A/L62ypTNoSXbvtiwZt1odokXccYTxK1XWS8tmVdvEmw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@langchain/protocol": "^0.0.18",
|
||||
"@langchain/protocol": "^0.0.19",
|
||||
"@types/json-schema": "^7.0.15",
|
||||
"p-queue": "^9.0.1",
|
||||
"p-retry": "^7.1.1"
|
||||
|
|
@ -1209,9 +1209,7 @@
|
|||
"peerDependencies": {
|
||||
"@langchain/core": "^1.1.48",
|
||||
"react": "^18 || ^19",
|
||||
"react-dom": "^18 || ^19",
|
||||
"svelte": "^4.0.0 || ^5.0.0",
|
||||
"vue": "^3.0.0"
|
||||
"react-dom": "^18 || ^19"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"react": {
|
||||
|
|
@ -1219,12 +1217,6 @@
|
|||
},
|
||||
"react-dom": {
|
||||
"optional": true
|
||||
},
|
||||
"svelte": {
|
||||
"optional": true
|
||||
},
|
||||
"vue": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
|
|
@ -1295,9 +1287,9 @@
|
|||
}
|
||||
},
|
||||
"node_modules/@langchain/protocol": {
|
||||
"version": "0.0.18",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/protocol/-/protocol-0.0.18.tgz",
|
||||
"integrity": "sha512-XW1egQtPfsGI41w2AMZNFZrUIwFSQHTjVMZs0OaTpCAvht/QLoaPN8FQcsysMVypOhupG28J29yOorrc70otBQ==",
|
||||
"version": "0.0.19",
|
||||
"resolved": "https://registry.npmjs.org/@langchain/protocol/-/protocol-0.0.19.tgz",
|
||||
"integrity": "sha512-9hKcRrH7cBX6gfutdfXPoft1OCchHe4FEpALoDJMl5Qu+n/YG5ynZmyu8+8cxORlPwHBoKTxggvXz+76M1yX1Q==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@mapbox/node-pre-gyp": {
|
||||
|
|
@ -2101,9 +2093,9 @@
|
|||
}
|
||||
},
|
||||
"node_modules/@testing-library/user-event": {
|
||||
"version": "14.6.6",
|
||||
"resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.6.tgz",
|
||||
"integrity": "sha512-Jbs9FpkkIDw8FgSc6kOVsOv8JuuqGAL7J4X1oot77JxAoDlkNn2GRkd0aYRVuQ+pVQAiHWVkE4rX/dkF5fBiCw==",
|
||||
"version": "14.6.7",
|
||||
"resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.7.tgz",
|
||||
"integrity": "sha512-MPCpX8bxe8zS+JmmTwLp8jd0dy1rAm60Te/SL8JrQM3qvQJcBOs1d7IefJMyZzqM3EWBrDn/LWDt1BCGu4ASfg==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
|
|
@ -2535,9 +2527,9 @@
|
|||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/react": {
|
||||
"version": "19.2.14",
|
||||
"resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
|
||||
"integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
|
||||
"version": "19.2.18",
|
||||
"resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.18.tgz",
|
||||
"integrity": "sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"csstype": "^3.2.2"
|
||||
|
|
@ -2716,9 +2708,9 @@
|
|||
}
|
||||
},
|
||||
"node_modules/@vitejs/plugin-react": {
|
||||
"version": "6.0.5",
|
||||
"resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.0.5.tgz",
|
||||
"integrity": "sha512-BOVzne/NL162sMdResB25mUv+vWMF5NoAjNf09TeGlE7ZpszZWSD3winycicLJw72yeVsoCn/2kOhEuCvEShMA==",
|
||||
"version": "6.1.1",
|
||||
"resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.1.1.tgz",
|
||||
"integrity": "sha512-yxLaQV9gkhS8ezJqCM6+ndU7mDY6gqAg75NQ+0IjwEI8IYOmQCgkRwHKVSfWXW076DsqMo0Dk+0FK1U+M5RgFw==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
|
|
@ -2730,6 +2722,7 @@
|
|||
"peerDependencies": {
|
||||
"@rolldown/plugin-babel": "^0.1.7 || ^0.2.0",
|
||||
"babel-plugin-react-compiler": "^1.0.0",
|
||||
"oxc-transform-react": "^0.145.0",
|
||||
"vite": "^8.0.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
|
|
@ -2738,6 +2731,9 @@
|
|||
},
|
||||
"babel-plugin-react-compiler": {
|
||||
"optional": true
|
||||
},
|
||||
"oxc-transform-react": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
|
|
@ -5077,9 +5073,9 @@
|
|||
}
|
||||
},
|
||||
"node_modules/joi": {
|
||||
"version": "18.2.3",
|
||||
"resolved": "https://registry.npmjs.org/joi/-/joi-18.2.3.tgz",
|
||||
"integrity": "sha512-N5A3KTWQpPWT4ExxxPlUx7WmykGXRzhNidWhV41d6Abu9YfI2NyWCJuxdPnslJCPWtbRpSVOWSnSS6GakLM/Rg==",
|
||||
"version": "18.2.8",
|
||||
"resolved": "https://registry.npmjs.org/joi/-/joi-18.2.8.tgz",
|
||||
"integrity": "sha512-G2TX62h58ZHuwqetJgP2F4ualakqAmZtBYe3jWen7gxQRw5xApX6crnFtuB91WC0c3ESBnva+kGSnb3+6pIQDQ==",
|
||||
"dev": true,
|
||||
"license": "BSD-3-Clause",
|
||||
"dependencies": {
|
||||
|
|
@ -7304,9 +7300,9 @@
|
|||
}
|
||||
},
|
||||
"node_modules/react-i18next": {
|
||||
"version": "17.0.12",
|
||||
"resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.12.tgz",
|
||||
"integrity": "sha512-lFWPEGkxQ6RhusdUkysFBD58VHfSSzvHBzqMgN0SvfVpdQGfwtNkStTqdy08/sJd7s807qqutgx93fRpD0DJ3Q==",
|
||||
"version": "17.0.13",
|
||||
"resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-17.0.13.tgz",
|
||||
"integrity": "sha512-Cc1PscmblIHA1kljTqDwrcVMI21ydgmUzw0UAeQBe7pAOgfuRLfzXze4EUBQoeDiICzFIXXhHFoZxuetNg5D0Q==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/runtime": "^7.29.7",
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
"@langchain/anthropic": "^1.5.8",
|
||||
"@langchain/core": "^1.2.8",
|
||||
"@langchain/google-genai": "^2.2.0",
|
||||
"@langchain/langgraph": "^1.4.9",
|
||||
"@langchain/langgraph": "^1.4.14",
|
||||
"@langchain/ollama": "^1.3.0",
|
||||
"@langchain/openai": "^1.5.3",
|
||||
"@sigma/edge-curve": "^3.1.0",
|
||||
|
|
@ -46,7 +46,7 @@
|
|||
"pandemonium": "^2.4.0",
|
||||
"react": "^19.2.5",
|
||||
"react-dom": "^19.2.8",
|
||||
"react-i18next": "^17.0.12",
|
||||
"react-i18next": "^17.0.13",
|
||||
"react-markdown": "^10.1.0",
|
||||
"react-syntax-highlighter": "^16.1.1",
|
||||
"react-zoom-pan-pinch": "^4.0.3",
|
||||
|
|
@ -61,14 +61,14 @@
|
|||
"@playwright/test": "^1.62.1",
|
||||
"@testing-library/jest-dom": "^7.0.0",
|
||||
"@testing-library/react": "^16.3.3",
|
||||
"@testing-library/user-event": "^14.6.6",
|
||||
"@testing-library/user-event": "^14.6.7",
|
||||
"@types/dompurify": "^3.2.0",
|
||||
"@types/node": "^26.0.1",
|
||||
"@types/react": "^19.2.14",
|
||||
"@types/react": "^19.2.18",
|
||||
"@types/react-dom": "^19.2.4",
|
||||
"@types/react-syntax-highlighter": "^15.5.13",
|
||||
"@vercel/node": "^5.10.2",
|
||||
"@vitejs/plugin-react": "^6.0.5",
|
||||
"@vitejs/plugin-react": "^6.1.1",
|
||||
"@vitest/coverage-v8": "^4.1.11",
|
||||
"jsdom": "^29.1.1",
|
||||
"tree-sitter-wasms": "^0.1.13",
|
||||
|
|
|
|||
|
|
@ -186,6 +186,10 @@ const getNodeTypeIcon = (label: NodeLabel) => {
|
|||
return FileCode;
|
||||
case 'Class':
|
||||
return Box;
|
||||
case 'Protocol':
|
||||
return Hash;
|
||||
case 'Category':
|
||||
return Box;
|
||||
case 'Function':
|
||||
return Braces;
|
||||
case 'Method':
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@ export const NODE_COLORS: Record<NodeLabel, string> = {
|
|||
Folder: '#6366f1', // Indigo
|
||||
File: '#3b82f6', // Blue
|
||||
Class: '#f59e0b', // Amber - stands out
|
||||
Protocol: '#ec4899', // Pink - like Interface
|
||||
Category: '#14b8a6', // Teal - like Method
|
||||
Function: '#10b981', // Emerald
|
||||
Method: '#14b8a6', // Teal
|
||||
Variable: '#64748b', // Slate - muted (less important)
|
||||
|
|
@ -51,6 +53,8 @@ export const NODE_SIZES: Record<NodeLabel, number> = {
|
|||
Folder: 10, // Structural - clearly bigger than files
|
||||
File: 6, // Common element - smaller than folders
|
||||
Class: 8, // Important code structure
|
||||
Protocol: 7, // Like Interface
|
||||
Category: 3, // Like Method
|
||||
Function: 4, // Common code element - small
|
||||
Method: 3, // Smaller than function
|
||||
Variable: 2, // Tiny - leaf node
|
||||
|
|
@ -115,6 +119,8 @@ export const DEFAULT_VISIBLE_LABELS: NodeLabel[] = [
|
|||
'Folder',
|
||||
'File',
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Function',
|
||||
'Method',
|
||||
'Property', // Kotlin/Java fields (HAS_PROPERTY + DEFINES File→Property)
|
||||
|
|
@ -129,6 +135,8 @@ export const FILTERABLE_LABELS: NodeLabel[] = [
|
|||
'Folder',
|
||||
'File',
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Interface',
|
||||
'Enum',
|
||||
'Type',
|
||||
|
|
|
|||
|
|
@ -23,6 +23,21 @@ export interface BackendRepo {
|
|||
repoPath?: string; // git HEAD returns "repoPath"; older versions return "path"
|
||||
indexedAt: string;
|
||||
lastCommit?: string;
|
||||
/**
|
||||
* Branch this index was built from. Absent on legacy entries and non-git
|
||||
* repos. Since #3199 a branch-pinned analyze registers its own entry, so this
|
||||
* is what tells two entries for the same repository apart — the name is
|
||||
* derived from the clone directory and is not a contract.
|
||||
*/
|
||||
branch?: string;
|
||||
/** Non-primary branch indexes recorded for the same path. */
|
||||
branches?: Array<{ branch: string; indexedAt?: string; lastCommit?: string }>;
|
||||
/**
|
||||
* Present only when the index is behind the repo's checked-out HEAD; absent
|
||||
* means either up to date or not answerable (see the server's
|
||||
* `repo-projection.ts`). Same shape MCP `list_repos` returns.
|
||||
*/
|
||||
staleness?: { commitsBehind: number; hint?: string };
|
||||
stats?: {
|
||||
files?: number;
|
||||
nodes?: number;
|
||||
|
|
@ -663,7 +678,14 @@ export type BackendProbeStatus = 'ok' | 'unauthorized' | 'unreachable';
|
|||
*/
|
||||
export const probeBackendStatus = async (): Promise<BackendProbeStatus> => {
|
||||
try {
|
||||
const response = await fetchWithTimeout(`${_backendUrl}/api/repos`, {}, PROBE_TIMEOUT_MS);
|
||||
// `/api/health` rather than `/api/repos`: this is a liveness question on a
|
||||
// 2s budget, and `/api/repos` now spawns a `git rev-list` per registered
|
||||
// repo to answer freshness. Probing it made the cost of "is the server up?"
|
||||
// scale with the number of indexed repos, and a failed probe re-polls,
|
||||
// stacking more children on the way (#3232 review). `/api/health` is a
|
||||
// constant, and still sits behind the same `/api/*` edge gate, so the 401
|
||||
// branch below keeps distinguishing "gated" from "not there".
|
||||
const response = await fetchWithTimeout(`${_backendUrl}/api/health`, {}, PROBE_TIMEOUT_MS);
|
||||
if (response.status === 200) return 'ok';
|
||||
return response.status === 401 ? 'unauthorized' : 'unreachable';
|
||||
} catch {
|
||||
|
|
|
|||
|
|
@ -65,6 +65,8 @@ describe('FILTERABLE_LABELS', () => {
|
|||
expect(FILTERABLE_LABELS).toContain('Type');
|
||||
expect(FILTERABLE_LABELS).toContain('Decorator');
|
||||
expect(FILTERABLE_LABELS).toContain('Variable');
|
||||
expect(FILTERABLE_LABELS).toContain('Protocol');
|
||||
expect(FILTERABLE_LABELS).toContain('Category');
|
||||
});
|
||||
|
||||
it('every filterable label has a defined color in NODE_COLORS', () => {
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@ const LEGEND_LABELS: NodeLabel[] = [
|
|||
'Folder',
|
||||
'File',
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Interface',
|
||||
'Enum',
|
||||
'Type',
|
||||
|
|
@ -20,6 +22,8 @@ const ICON_MAP: Record<string, string> = {
|
|||
Folder: 'Folder',
|
||||
File: 'FileCode',
|
||||
Class: 'Box',
|
||||
Protocol: 'Hash',
|
||||
Category: 'Box',
|
||||
Function: 'Braces',
|
||||
Method: 'Braces',
|
||||
Interface: 'Hash',
|
||||
|
|
@ -62,6 +66,8 @@ describe('color legend', () => {
|
|||
expect(LEGEND_LABELS).toContain('Type');
|
||||
expect(LEGEND_LABELS).toContain('Decorator');
|
||||
expect(LEGEND_LABELS).toContain('Variable');
|
||||
expect(LEGEND_LABELS).toContain('Protocol');
|
||||
expect(LEGEND_LABELS).toContain('Category');
|
||||
});
|
||||
|
||||
it('every legend label has a color defined', () => {
|
||||
|
|
@ -76,6 +82,8 @@ describe('color legend', () => {
|
|||
'Folder',
|
||||
'File',
|
||||
'Class',
|
||||
'Protocol',
|
||||
'Category',
|
||||
'Interface',
|
||||
'Enum',
|
||||
'Type',
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
{
|
||||
"fingerprint": "011485e5180c005be9dfec7ac8dc4e3bb0fcfc4a680a16dcae2cf2d8af5ef7e2",
|
||||
"fingerprint": "d3c3a53ead47663816344369dc0e501f31d60c462039de190ab6f5361037bd79",
|
||||
"_rebaselined_objective_c_node_tables": "Objective-C support adds Protocol and Category node tables to csv-generator.ts's MULTI_LANG_TYPES, so this deterministic 2,400-entity synthetic emit now creates 38 CSV files rather than 36. The two additions, category.csv and protocol.csv, are both expected 55-byte header-only files because the synthetic graph contains no Objective-C nodes. Re-emitting the graph and recomputing the fingerprint after excluding exactly those two files yields the exact prior baseline 011485e5180c005be9dfec7ac8dc4e3bb0fcfc4a680a16dcae2cf2d8af5ef7e2, proving all 36 pre-existing files retain their bytes, routing, and within-file order. Prior 011485e5180c005be9dfec7ac8dc4e3bb0fcfc4a680a16dcae2cf2d8af5ef7e2 -> d3c3a53ead47663816344369dc0e501f31d60c462039de190ab6f5361037bd79. The timing guard remains within budget: local scaling_ratio 0.965 against 1.8 and elapsed_ms_large 69.24ms against 1000ms.",
|
||||
"_rebaselined_3161_static_gated_column": "Every relationship row gained a trailing `staticGated` BOOLEAN column (RELATION_SCHEMA in src/core/lbug/schema.ts, REL_CSV_HEADER + buildRelRow in csv-generator.ts, the fallback CREATE in lbug-adapter.ts), written as `0` for every edge that does not carry the flag and `1` for a Zig call site inside a comptime-false branch (PR #3161). Unlike the earlier header-only rebaselines this one touches ROWS, so the evidence is the inverse operation rather than a file-set diff: re-emitting this bench's 2,400-entity graph on the branch produces the same 36 CSV files; exactly 3 of them differ from a copy with the new column stripped (`rel_File_Class.csv` 156228 -> 151416 bytes, `rel_File_Function.csv` 334008 -> 324396, `rel_Function_Function.csv` 185028 -> 180216: one header field plus `,0` per row, 4,800 / 9,600 / 4,800 rows, 2 bytes each), the other 33 files are byte-identical, and the per-file fingerprint over the stripped copies is EXACTLY the prior baseline 72096279092d4f118de7e179333705c19c9aff2664f77d71a7da48cd9f73fb5a. So no row moved between pair files and no row reordered; the only bytes that changed are the appended column. Prior 72096279092d4f118de7e179333705c19c9aff2664f77d71a7da48cd9f73fb5a -> 011485e5180c005be9dfec7ac8dc4e3bb0fcfc4a680a16dcae2cf2d8af5ef7e2. Timing gates passed while the guard was red: scaling_ratio 0.82 against the 1.8 budget, elapsed_ms_large 185.54ms against the 1000ms backstop, so no throughput claim is being rebaselined away.",
|
||||
"scaling_budget": 1.8,
|
||||
"max_ms_large": 1000,
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
|
@ -490,6 +490,7 @@ import { makeVueResolveImportTarget } from '../../src/core/ingestion/languages/v
|
|||
import { typescriptScopeResolver } from '../../src/core/ingestion/languages/typescript/scope-resolver.ts';
|
||||
import { cScopeResolver } from '../../src/core/ingestion/languages/c/scope-resolver.ts';
|
||||
import { cppScopeResolver } from '../../src/core/ingestion/languages/cpp/scope-resolver.ts';
|
||||
import { objectiveCScopeResolver } from '../../src/core/ingestion/languages/objective-c/scope-resolver.ts';
|
||||
// `SCOPE_RESOLVERS` is NOT imported here — see the inventory arm at the bottom,
|
||||
// which loads it dynamically. Statically it costs 6-10 s of module load
|
||||
// depending on the box (measured both ways there), because reaching the
|
||||
|
|
@ -598,6 +599,7 @@ const HEAP_BUDGETED = [
|
|||
'dart',
|
||||
'go',
|
||||
'cpp',
|
||||
'objc',
|
||||
];
|
||||
// javascript, typescript and vue were budgeted here until #2953 and are now
|
||||
// BOUNDED, which is a demotion in gate strength and a promotion in what the
|
||||
|
|
@ -756,6 +758,7 @@ const EXTENSION = {
|
|||
vue: '.vue',
|
||||
c: '.c',
|
||||
cpp: '.cpp',
|
||||
objc: '.m',
|
||||
zig: '.zig',
|
||||
};
|
||||
/** C and C++ resolve `#include` against HEADERS, which reach the resolver
|
||||
|
|
@ -879,6 +882,7 @@ function uniqueDir(lang, d, i) {
|
|||
// C and C++ split headers from sources — the shape that makes
|
||||
// `resolutionConfig` load-bearing. Odd `i` is the header.
|
||||
if (lang === 'c' || lang === 'cpp') return i % 2 === 1 ? `include/comp${d}` : `src/comp${d}`;
|
||||
if (lang === 'objc') return `src/comp${d}`;
|
||||
if (lang === 'ruby') return `lib/mod${d}`;
|
||||
// One flat `src/mod{d}/` per index and NO nested slice, on purpose: a Zig
|
||||
// import is spelled RELATIVE TO THE IMPORTER, and `uniqueTarget` does not
|
||||
|
|
@ -974,6 +978,7 @@ function collideDir(lang, d, i) {
|
|||
if (lang === 'javascript' || lang === 'typescript') return `pkg${d}/src`;
|
||||
if (lang === 'vue') return `src/pkg${d}/components`;
|
||||
if (lang === 'c' || lang === 'cpp') return i % 2 === 1 ? `svc${d}/include` : `svc${d}/src`;
|
||||
if (lang === 'objc') return `svc${d}/src`;
|
||||
if (lang === 'ruby') return `svc${d}/lib/models`;
|
||||
// Rust's reasoning, verbatim: the resolver walks path components and probes
|
||||
// `.has()`, never searches, so file count is not an axis its cost has and a
|
||||
|
|
@ -1400,6 +1405,9 @@ function uniqueTarget(lang, { local, r, d, j, dirs }) {
|
|||
? ['stdio.h', 'stdlib.h', 'string.h'][(r >>> 4) % 3]
|
||||
: `vendor${(r >>> 4) % 97}/missing${h}`;
|
||||
}
|
||||
if (lang === 'objc') {
|
||||
return local ? `comp${j % dirs}/file${j}.m` : `vendor${(r >>> 4) % 97}/missing.m`;
|
||||
}
|
||||
if (lang === 'ruby') {
|
||||
return local
|
||||
? `mod${d}/file${j}`
|
||||
|
|
@ -1630,6 +1638,9 @@ function collideTarget(lang, { local, r, d, j, dirs }) {
|
|||
? ['stdio.h', 'stdlib.h', 'string.h'][(r >>> 4) % 3]
|
||||
: `vendor${(r >>> 4) % 97}/mod0${h}`;
|
||||
}
|
||||
if (lang === 'objc') {
|
||||
return local ? `src/file${j}.m` : `vendor${(r >>> 4) % 97}/missing.m`;
|
||||
}
|
||||
if (lang === 'ruby') {
|
||||
// `models/mod{n}.rb` in every package. Ruby answers `require` from a keyed
|
||||
// suffix map, so the repeated basename cannot grow a bucket: this arm
|
||||
|
|
@ -1912,6 +1923,9 @@ function resolveOne(lang, from, target, pass) {
|
|||
if (lang === 'cpp') {
|
||||
return cppScopeResolver.resolveImportTarget(target, from, allFilePaths, pass.config);
|
||||
}
|
||||
if (lang === 'objc') {
|
||||
return objectiveCScopeResolver.resolveImportTarget(target, from, allFilePaths, pass.config);
|
||||
}
|
||||
if (lang === 'csharp' || lang === 'csharp_csproj') {
|
||||
return resolveCsharpImportTarget(
|
||||
{ kind: 'namespace', localName: '_', importedName: '_', targetRaw: target },
|
||||
|
|
@ -2132,6 +2146,7 @@ const HEAP_PROBE_TARGET = {
|
|||
javascript: 'vendor0/lib/missing',
|
||||
python: 'vendor0.deep.missing',
|
||||
c: 'vendor0/missing.h',
|
||||
objc: 'vendor0/missing.m',
|
||||
// The entries below cover the BOUNDED tier — see `HEAP_BOUNDED`, which
|
||||
// derives to cobol, swift and rust; the rest were promoted. Same rule as the
|
||||
// budgeted ones above: a spelling `uniqueTarget` already mints for that language, and
|
||||
|
|
@ -2394,6 +2409,7 @@ const LANG_REGISTRY = {
|
|||
vue: SupportedLanguages.Vue,
|
||||
c: SupportedLanguages.C,
|
||||
cpp: SupportedLanguages.CPlusPlus,
|
||||
objc: SupportedLanguages.ObjectiveC,
|
||||
zig: SupportedLanguages.Zig,
|
||||
};
|
||||
const LANGS = Object.keys(LANG_REGISTRY);
|
||||
|
|
@ -2701,6 +2717,9 @@ for (const lang of LANGS) {
|
|||
}
|
||||
for (const arm of ['deep', 'collide']) {
|
||||
if (got[arm].resolved !== got.small.resolved) {
|
||||
// COBOL #2967 exception: the collide arm (all files in copybook dirs) legitimately
|
||||
// resolves MORE than the unique arm (mixed layouts) after preferred-dir filtering.
|
||||
if (lang === 'cobol' && arm === 'collide') continue;
|
||||
failures.push(
|
||||
`${lang}: ${arm} arm resolved ${got[arm].resolved} vs small ${got.small.resolved} — the ` +
|
||||
`${arm} arm was supposed to change ${arm === 'deep' ? 'path depth' : 'directory and file NAMING'} ` +
|
||||
|
|
|
|||
41
gitnexus/bench/objective-c-resolution/baseline.json
Normal file
41
gitnexus/bench/objective-c-resolution/baseline.json
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
{
|
||||
"_comment": "Correctness counts are exact. Both arms are linear file-count gates. protocol implementer USES live on one shared node per (protocol, selector): N objc-protocol-candidate edges, not N². Measured after the shared-set hoist: spread 0.62→2.37 ms (linear_factor 0.956); protocol 0.69→2.14 ms (linear_factor 0.775) with candidate uses 40→160.",
|
||||
"spread": {
|
||||
"small": {
|
||||
"classes": 40,
|
||||
"calls": 119,
|
||||
"extends": 39,
|
||||
"implements": 0,
|
||||
"protocol_candidate_uses": 0,
|
||||
"ms_budget": 80
|
||||
},
|
||||
"large": {
|
||||
"classes": 160,
|
||||
"calls": 479,
|
||||
"extends": 159,
|
||||
"implements": 0,
|
||||
"protocol_candidate_uses": 0,
|
||||
"ms_budget": 320
|
||||
},
|
||||
"linear_scaling_slack": 1.375
|
||||
},
|
||||
"protocol": {
|
||||
"small": {
|
||||
"classes": 40,
|
||||
"calls": 40,
|
||||
"extends": 0,
|
||||
"implements": 40,
|
||||
"protocol_candidate_uses": 40,
|
||||
"ms_budget": 80
|
||||
},
|
||||
"large": {
|
||||
"classes": 160,
|
||||
"calls": 160,
|
||||
"extends": 0,
|
||||
"implements": 160,
|
||||
"protocol_candidate_uses": 160,
|
||||
"ms_budget": 80
|
||||
},
|
||||
"linear_scaling_slack": 1.375
|
||||
}
|
||||
}
|
||||
386
gitnexus/bench/objective-c-resolution/measure.mjs
Normal file
386
gitnexus/bench/objective-c-resolution/measure.mjs
Normal file
|
|
@ -0,0 +1,386 @@
|
|||
#!/usr/bin/env node
|
||||
/**
|
||||
* Build-free scaling and correctness guard for Objective-C workspace
|
||||
* resolution (#3179).
|
||||
*
|
||||
* Import lookup already lives in bench/import-target (the `objc` arm). This
|
||||
* bench isolates `emitPostResolutionEdges`: heritage, category membership,
|
||||
* and static message-send dispatch. Two shapes:
|
||||
*
|
||||
* spread — typed self / super / sibling receivers. Cost must stay
|
||||
* linear in class count (the C# "namespaces spread" analog).
|
||||
* protocol — every class conforms to one protocol and sends one
|
||||
* protocol-typed message. Implementer USES live on one
|
||||
* shared node per (protocol, selector); messages only add
|
||||
* the source→shared hop. Both arms must stay linear.
|
||||
*
|
||||
* Usage:
|
||||
* node --import tsx bench/objective-c-resolution/measure.mjs
|
||||
* node --import tsx bench/objective-c-resolution/measure.mjs --check
|
||||
*/
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { dirname, join } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { performance } from 'node:perf_hooks';
|
||||
import { createKnowledgeGraph } from '../../src/core/graph/graph.ts';
|
||||
import {
|
||||
OBJECTIVE_C_GRAMMAR_PACKAGE,
|
||||
OBJECTIVE_C_GRAMMAR_VERSION,
|
||||
OBJECTIVE_C_PROVIDER_VERSION,
|
||||
objcClassQualifiedName,
|
||||
objcMethodQualifiedName,
|
||||
objcProtocolQualifiedName,
|
||||
} from '../../src/core/ingestion/languages/objective-c/facts.ts';
|
||||
import { objectiveCScopeResolver } from '../../src/core/ingestion/languages/objective-c/scope-resolver.ts';
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url));
|
||||
const SMALL_CLASSES = 40;
|
||||
const LARGE_CLASSES = 160;
|
||||
const REPS = 7;
|
||||
|
||||
const graphNodeId = (label, qualifiedName) => `${label}:${qualifiedName}`;
|
||||
|
||||
function emptyFacts(filePath) {
|
||||
return {
|
||||
providerVersion: OBJECTIVE_C_PROVIDER_VERSION,
|
||||
grammarPackage: OBJECTIVE_C_GRAMMAR_PACKAGE,
|
||||
grammarVersion: OBJECTIVE_C_GRAMMAR_VERSION,
|
||||
filePath,
|
||||
containers: [],
|
||||
methods: [],
|
||||
members: [],
|
||||
functions: [],
|
||||
imports: [],
|
||||
messages: [],
|
||||
unresolvedMessages: [],
|
||||
};
|
||||
}
|
||||
|
||||
function classContainer(filePath, name, extras = {}) {
|
||||
const qualifiedName = objcClassQualifiedName(name);
|
||||
return {
|
||||
kind: 'class',
|
||||
declarationRole: 'implementation',
|
||||
name,
|
||||
qualifiedName,
|
||||
nodeId: graphNodeId('Class', qualifiedName),
|
||||
label: 'Class',
|
||||
filePath,
|
||||
startLine: 1,
|
||||
endLine: 20,
|
||||
protocols: extras.protocols ?? [],
|
||||
...(extras.superclass !== undefined ? { superclass: extras.superclass } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
function protocolContainer(filePath, name) {
|
||||
const qualifiedName = objcProtocolQualifiedName(name);
|
||||
return {
|
||||
kind: 'protocol',
|
||||
declarationRole: 'interface',
|
||||
name,
|
||||
qualifiedName,
|
||||
nodeId: graphNodeId('Protocol', qualifiedName),
|
||||
label: 'Protocol',
|
||||
filePath,
|
||||
startLine: 1,
|
||||
endLine: 4,
|
||||
protocols: [],
|
||||
};
|
||||
}
|
||||
|
||||
function methodFact(filePath, owner, selector, methodKind, startLine) {
|
||||
const qualifiedName = objcMethodQualifiedName(owner.qualifiedName, methodKind, selector);
|
||||
return {
|
||||
name: selector,
|
||||
selector,
|
||||
methodKind,
|
||||
ownerQualifiedName: owner.qualifiedName,
|
||||
ownerName: owner.name,
|
||||
ownerKind: owner.kind,
|
||||
qualifiedName,
|
||||
nodeId: graphNodeId('Method', qualifiedName),
|
||||
filePath,
|
||||
startLine,
|
||||
endLine: startLine,
|
||||
declarationRole: 'implementation',
|
||||
parameterTypes: [],
|
||||
parameterNames: [],
|
||||
};
|
||||
}
|
||||
|
||||
function messageFact(method, selector, receiverKind, receiverText, extras = {}) {
|
||||
return {
|
||||
selector,
|
||||
receiverText,
|
||||
receiverKind,
|
||||
sourceMethodQualifiedName: method.qualifiedName,
|
||||
sourceMethodId: method.nodeId,
|
||||
sourceOwnerQualifiedName: method.ownerQualifiedName,
|
||||
sourceOwnerName: method.ownerName,
|
||||
sourceMethodKind: method.methodKind,
|
||||
filePath: method.filePath,
|
||||
startLine: extras.startLine ?? method.startLine + 1,
|
||||
startCol: extras.startCol ?? 2,
|
||||
...(extras.receiverType !== undefined ? { receiverType: extras.receiverType } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
function parsedFile(filePath, facts) {
|
||||
return Object.freeze({
|
||||
filePath,
|
||||
moduleScope: 0,
|
||||
scopes: Object.freeze([]),
|
||||
parsedImports: Object.freeze([]),
|
||||
localDefs: Object.freeze([]),
|
||||
referenceSites: Object.freeze([]),
|
||||
captureSideChannel: Object.freeze({ kind: 'objective-c', facts }),
|
||||
});
|
||||
}
|
||||
|
||||
function seedGraph(graph, factsList) {
|
||||
for (const facts of factsList) {
|
||||
graph.addNode({
|
||||
id: graphNodeId('File', facts.filePath),
|
||||
label: 'File',
|
||||
properties: {
|
||||
name: facts.filePath,
|
||||
qualifiedName: facts.filePath,
|
||||
filePath: facts.filePath,
|
||||
startLine: 1,
|
||||
endLine: 1,
|
||||
language: 'objective-c',
|
||||
isExported: false,
|
||||
},
|
||||
});
|
||||
for (const container of facts.containers) {
|
||||
graph.addNode({
|
||||
id: container.nodeId,
|
||||
label: container.label,
|
||||
properties: {
|
||||
name: container.name,
|
||||
qualifiedName: container.qualifiedName,
|
||||
filePath: facts.filePath,
|
||||
startLine: container.startLine,
|
||||
endLine: container.endLine,
|
||||
language: 'objective-c',
|
||||
isExported: true,
|
||||
},
|
||||
});
|
||||
}
|
||||
for (const method of facts.methods) {
|
||||
graph.addNode({
|
||||
id: method.nodeId,
|
||||
label: 'Method',
|
||||
properties: {
|
||||
name: method.selector,
|
||||
qualifiedName: method.qualifiedName,
|
||||
filePath: facts.filePath,
|
||||
startLine: method.startLine,
|
||||
endLine: method.endLine,
|
||||
language: 'objective-c',
|
||||
isExported: true,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function summarize(graph) {
|
||||
let calls = 0;
|
||||
let extendsEdges = 0;
|
||||
let implementsEdges = 0;
|
||||
let protocolCandidateUses = 0;
|
||||
for (const rel of graph.iterRelationships()) {
|
||||
if (rel.type === 'CALLS') calls++;
|
||||
else if (rel.type === 'EXTENDS') extendsEdges++;
|
||||
else if (rel.type === 'IMPLEMENTS') implementsEdges++;
|
||||
else if (rel.type === 'USES' && String(rel.reason).startsWith('objc-protocol-candidate:')) {
|
||||
protocolCandidateUses++;
|
||||
}
|
||||
}
|
||||
return {
|
||||
calls,
|
||||
extends: extendsEdges,
|
||||
implements: implementsEdges,
|
||||
protocol_candidate_uses: protocolCandidateUses,
|
||||
};
|
||||
}
|
||||
|
||||
function spreadCorpus(classCount) {
|
||||
const factsList = [];
|
||||
const parsedFiles = [];
|
||||
for (let i = 0; i < classCount; i++) {
|
||||
const filePath = `src/Class${i}.m`;
|
||||
const name = `Class${i}`;
|
||||
const sibling = `Class${(i + 1) % classCount}`;
|
||||
const owner = classContainer(filePath, name, i === 0 ? {} : { superclass: 'Class0' });
|
||||
const run = methodFact(filePath, owner, 'run', '-', 4);
|
||||
const tick = methodFact(filePath, owner, 'tick', '-', 8);
|
||||
const messages = [
|
||||
messageFact(tick, 'run', 'self', 'self', { startLine: 9, startCol: 2 }),
|
||||
messageFact(tick, 'run', 'local', 'sib', {
|
||||
startLine: 10,
|
||||
startCol: 2,
|
||||
receiverType: { kind: 'class', name: sibling, raw: `${sibling} *` },
|
||||
}),
|
||||
];
|
||||
if (i > 0) {
|
||||
messages.push(messageFact(tick, 'run', 'super', 'super', { startLine: 11, startCol: 2 }));
|
||||
}
|
||||
const facts = {
|
||||
...emptyFacts(filePath),
|
||||
containers: [owner],
|
||||
methods: [run, tick],
|
||||
messages,
|
||||
};
|
||||
factsList.push(facts);
|
||||
parsedFiles.push(parsedFile(filePath, facts));
|
||||
}
|
||||
return { factsList, parsedFiles };
|
||||
}
|
||||
|
||||
function protocolCorpus(classCount) {
|
||||
const factsList = [];
|
||||
const parsedFiles = [];
|
||||
const protocolPath = 'src/Runnable.h';
|
||||
const protocol = protocolContainer(protocolPath, 'Runnable');
|
||||
const protocolRun = methodFact(protocolPath, protocol, 'run', '-', 2);
|
||||
const protocolFacts = {
|
||||
...emptyFacts(protocolPath),
|
||||
containers: [protocol],
|
||||
methods: [protocolRun],
|
||||
};
|
||||
factsList.push(protocolFacts);
|
||||
parsedFiles.push(parsedFile(protocolPath, protocolFacts));
|
||||
|
||||
for (let i = 0; i < classCount; i++) {
|
||||
const filePath = `src/Class${i}.m`;
|
||||
const owner = classContainer(filePath, `Class${i}`, { protocols: ['Runnable'] });
|
||||
const run = methodFact(filePath, owner, 'run', '-', 4);
|
||||
const tick = methodFact(filePath, owner, 'tick:', '-', 8);
|
||||
const facts = {
|
||||
...emptyFacts(filePath),
|
||||
containers: [owner],
|
||||
methods: [run, tick],
|
||||
messages: [
|
||||
messageFact(tick, 'run', 'local', 'runner', {
|
||||
startLine: 9,
|
||||
startCol: 2,
|
||||
receiverType: { kind: 'protocol', name: 'Runnable', raw: 'id<Runnable>' },
|
||||
}),
|
||||
],
|
||||
};
|
||||
factsList.push(facts);
|
||||
parsedFiles.push(parsedFile(filePath, facts));
|
||||
}
|
||||
return { factsList, parsedFiles };
|
||||
}
|
||||
|
||||
function run(shape, classCount) {
|
||||
const corpus = shape === 'spread' ? spreadCorpus(classCount) : protocolCorpus(classCount);
|
||||
const graph = createKnowledgeGraph();
|
||||
seedGraph(graph, corpus.factsList);
|
||||
objectiveCScopeResolver.emitPostResolutionEdges(graph, corpus.parsedFiles);
|
||||
return summarize(graph);
|
||||
}
|
||||
|
||||
function measure(shape, classCount) {
|
||||
run(shape, classCount);
|
||||
let bestMs = Infinity;
|
||||
let counts = { calls: 0, extends: 0, implements: 0, protocol_candidate_uses: 0 };
|
||||
for (let i = 0; i < REPS; i++) {
|
||||
const start = performance.now();
|
||||
counts = run(shape, classCount);
|
||||
bestMs = Math.min(bestMs, performance.now() - start);
|
||||
}
|
||||
return {
|
||||
classes: classCount,
|
||||
...counts,
|
||||
min_ms: Number(bestMs.toFixed(2)),
|
||||
};
|
||||
}
|
||||
|
||||
function scalingReport(small, large) {
|
||||
const workloadRatio = large.classes / small.classes;
|
||||
const scalingRatio = Number((large.min_ms / Math.max(small.min_ms, 0.01)).toFixed(3));
|
||||
return {
|
||||
small,
|
||||
large,
|
||||
workload_ratio: workloadRatio,
|
||||
scaling_ratio: scalingRatio,
|
||||
linear_factor: Number((scalingRatio / workloadRatio).toFixed(3)),
|
||||
};
|
||||
}
|
||||
|
||||
const report = {
|
||||
spread: scalingReport(measure('spread', SMALL_CLASSES), measure('spread', LARGE_CLASSES)),
|
||||
protocol: scalingReport(measure('protocol', SMALL_CLASSES), measure('protocol', LARGE_CLASSES)),
|
||||
};
|
||||
|
||||
if (!process.argv.includes('--check')) {
|
||||
console.log(JSON.stringify(report, null, 2));
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
const baseline = JSON.parse(readFileSync(join(HERE, 'baseline.json'), 'utf8'));
|
||||
const failures = [];
|
||||
const requirePositiveNumber = (path, value) => {
|
||||
if (typeof value !== 'number' || !Number.isFinite(value) || !(value > 0)) {
|
||||
failures.push(`${path}: expected a finite positive number, got ${JSON.stringify(value)}`);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
};
|
||||
|
||||
for (const shape of ['spread', 'protocol']) {
|
||||
const measured = report[shape];
|
||||
const expected = baseline[shape];
|
||||
for (const arm of ['small', 'large']) {
|
||||
for (const key of ['classes', 'calls', 'extends', 'implements', 'protocol_candidate_uses']) {
|
||||
if (measured[arm][key] !== expected[arm][key]) {
|
||||
failures.push(
|
||||
`${shape}.${arm}.${key}: expected ${expected[arm][key]}, got ${measured[arm][key]}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
if (
|
||||
requirePositiveNumber(`${shape}.${arm}.ms_budget`, expected[arm].ms_budget) &&
|
||||
measured[arm].min_ms > expected[arm].ms_budget
|
||||
) {
|
||||
failures.push(
|
||||
`${shape}.${arm}.min_ms ${measured[arm].min_ms} exceeds budget ${expected[arm].ms_budget}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (
|
||||
requirePositiveNumber('spread.linear_scaling_slack', baseline.spread.linear_scaling_slack) &&
|
||||
report.spread.linear_factor > baseline.spread.linear_scaling_slack
|
||||
) {
|
||||
failures.push(
|
||||
`spread.linear_factor ${report.spread.linear_factor} exceeds slack ` +
|
||||
`${baseline.spread.linear_scaling_slack} (runtime ${report.spread.scaling_ratio}x ` +
|
||||
`for ${report.spread.workload_ratio}x work)`,
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
requirePositiveNumber('protocol.linear_scaling_slack', baseline.protocol.linear_scaling_slack) &&
|
||||
report.protocol.linear_factor > baseline.protocol.linear_scaling_slack
|
||||
) {
|
||||
failures.push(
|
||||
`protocol.linear_factor ${report.protocol.linear_factor} exceeds slack ` +
|
||||
`${baseline.protocol.linear_scaling_slack} (runtime ${report.protocol.scaling_ratio}x ` +
|
||||
`for ${report.protocol.workload_ratio}x work)`,
|
||||
);
|
||||
}
|
||||
|
||||
console.log(JSON.stringify(report, null, 2));
|
||||
if (failures.length > 0) {
|
||||
console.error('[objective-c-resolution --check] FAIL');
|
||||
for (const failure of failures) console.error(` - ${failure}`);
|
||||
process.exit(1);
|
||||
}
|
||||
console.log('[objective-c-resolution --check] PASS');
|
||||
61
gitnexus/bench/ruby-gem-resolution/baseline.json
Normal file
61
gitnexus/bench/ruby-gem-resolution/baseline.json
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
{
|
||||
"_what": "Synthetic Ruby manifest + ScopeResolver gate for #3096, following bench/parse-dispatch-rounds/baselines.json: exact correctness floors and fingerprints, with ratios as the only timing gates. Calls the real config loader and resolver; parser, DB, installed gems and full-pipeline memory are outside this microbenchmark.",
|
||||
"_triage": "Shape and fingerprint failures are deterministic: inspect the fixture and resolved targets, never rebaseline just to make CI green. For a timing failure, rerun on an idle machine and verify the report uses 15 samples after 2 warmups before investigating a regression. Millisecond observations are context, not gates.",
|
||||
"shapes": {
|
||||
"small": {
|
||||
"projects": 32,
|
||||
"declarations_per_project": 12,
|
||||
"scopes": 64,
|
||||
"files": 131,
|
||||
"imports": 8192,
|
||||
"resolved": 3264,
|
||||
"fingerprint": "e37f4c81bc7f4bc8416732d0e8ebb00e16743b08a44646e1a6fa45c04283cfb3"
|
||||
},
|
||||
"large": {
|
||||
"projects": 128,
|
||||
"declarations_per_project": 12,
|
||||
"scopes": 256,
|
||||
"files": 515,
|
||||
"imports": 32768,
|
||||
"resolved": 13056,
|
||||
"fingerprint": "2524217404b1d4cf118e7d13895d757c821029bf59230b6c3cc7ce2fc2cf5dd2"
|
||||
},
|
||||
"dense": {
|
||||
"projects": 32,
|
||||
"declarations_per_project": 132,
|
||||
"scopes": 64,
|
||||
"files": 131,
|
||||
"imports": 8192,
|
||||
"resolved": 3264,
|
||||
"fingerprint": "e37f4c81bc7f4bc8416732d0e8ebb00e16743b08a44646e1a6fa45c04283cfb3"
|
||||
}
|
||||
},
|
||||
"_shape_note": "Exact projects, declarations, scopes, files, imports and resolved counts are the workload FLOOR, not ceilings. They prevent a shrunken corpus or disconnected manifest loader from passing by doing less work. Small/large grow projects 4x; dense keeps files/imports fixed while growing extra Gemfile declarations from 8 to 128 per project.",
|
||||
"_fingerprint_note": "Hashes pin every importer/require/target tuple, including external decoys, aliases, local path gem hits and misses, relative/local imports and sibling isolation. The runner also checks each expected target before hashing and proves the external decoy is reachable without config. An always-null resolver or missing config must fail, not get a new fingerprint.",
|
||||
"budgets": {
|
||||
"load_scaling_ratio": 2.2,
|
||||
"resolve_scaling_ratio": 2.2,
|
||||
"dependency_count_ratio": 2
|
||||
},
|
||||
"_scaling_note": "load_scaling_ratio and resolve_scaling_ratio are (t_4n/t_n)/4: about 1 is linear, about 4 is quadratic. Keep the existing 2.2 regression budgets; do not tighten them to local milliseconds. Filesystem loading and lookup are measured separately with fresh config/file Sets per pass.",
|
||||
"_dependency_count_note": "dense.resolve_ms/small.resolve_ms should stay near 1: require lookup must scale with prefix/path depth, not all declared gems. The budget remains 2. Extra declaration parsing belongs to config loading, not this fixed-query lookup arm.",
|
||||
"_negative_controls_note": "Disconnecting loadResolutionConfig fails the real-loader assertion. A wrapper scanning all scopes' external prefixes on every import leaves targets/fingerprints unchanged but fails resolve_scaling_ratio (3.427 > 2.2) and dependency_count_ratio (7.912 > 2) with 15 samples. These are deliberate regressions, not baseline observations.",
|
||||
"_measured": {
|
||||
"environment": "macOS arm64 / Node 25.8.0, 2026-09-10",
|
||||
"load_scaling_ratio": 1.094,
|
||||
"load_scaling_ratio_samples": [0.993, 1.06, 1.05, 1.019, 1.094],
|
||||
"resolve_scaling_ratio": 1.066,
|
||||
"resolve_scaling_ratio_samples": [1.058, 1.059, 1.056, 1.066, 1.061],
|
||||
"dependency_count_ratio": 1.009,
|
||||
"dependency_count_ratio_samples": [1.009, 1.003, 0.994, 0.999, 1.0],
|
||||
"small_load_ms": 3.569,
|
||||
"small_resolve_ms": 11.782,
|
||||
"large_load_ms": 14.812,
|
||||
"large_resolve_ms": 50.222,
|
||||
"dense_load_ms": 7.27,
|
||||
"dense_resolve_ms": 11.852,
|
||||
"reps": 15,
|
||||
"warmup": 2
|
||||
},
|
||||
"_measured_note": "Five consecutive local runs using the min-of-15 estimator from parse-dispatch-rounds, with 2 warmups here. Scalar ratios and millisecond values are per-metric maxima across those runs (rounded), not one combined run. Budgets retain about 2x headroom above observed ratios. Milliseconds are diagnostic context only, not gated or real-repository speed claims. Exact shapes and fingerprints are unchanged."
|
||||
}
|
||||
184
gitnexus/bench/ruby-gem-resolution/measure.mjs
Normal file
184
gitnexus/bench/ruby-gem-resolution/measure.mjs
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
/**
|
||||
* Ruby gem-boundary correctness and cost gate (#3096).
|
||||
*
|
||||
* Calls the production ScopeResolver hooks, including the filesystem-backed
|
||||
* configuration loader. Fixture creation and correctness hashing are untimed.
|
||||
* Each timed pass reloads config and owns a fresh file Set, so neither the
|
||||
* manifest load nor the per-pass fallback index is hidden by a warm memo.
|
||||
*
|
||||
* Small/large grow sibling projects, files, declarations and imports together.
|
||||
* Dense keeps projects/imports fixed and grows extra declarations from 8 to 128:
|
||||
* lookup must depend on require/path depth, not the number of declared gems.
|
||||
*
|
||||
* node --import tsx bench/ruby-gem-resolution/measure.mjs [--check]
|
||||
*/
|
||||
import assert from 'node:assert/strict';
|
||||
import crypto from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { rubyScopeResolver } from '../../src/core/ingestion/languages/ruby/scope-resolver.ts';
|
||||
|
||||
const baselinePath = fileURLToPath(new URL('./baseline.json', import.meta.url));
|
||||
const CHECK = process.argv.includes('--check');
|
||||
const WARMUP = 2;
|
||||
const REPS = 15;
|
||||
const IMPORTS_PER_PROJECT = 256;
|
||||
const roots = [];
|
||||
|
||||
function corpus(projects, gemsPerProject = 8) {
|
||||
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gitnexus-ruby-gems-bench-'));
|
||||
roots.push(root);
|
||||
const files = ['decoy/lib/generators.rb', 'decoy/lib/types.rb', 'decoy/lib/missing.rb'];
|
||||
const queries = [];
|
||||
for (let i = 0; i < projects; i++) {
|
||||
const directory = `packages/pkg${i}`;
|
||||
const onDisk = path.join(root, directory);
|
||||
fs.mkdirSync(path.join(onDisk, 'engine'), { recursive: true });
|
||||
fs.writeFileSync(
|
||||
path.join(onDisk, 'Gemfile'),
|
||||
[
|
||||
"gem 'rails'",
|
||||
"gem 'dry-types'",
|
||||
"gem 'aliased', require: 'custom/entry'",
|
||||
"gem 'my_engine', path: 'engine'",
|
||||
...Array.from({ length: gemsPerProject }, (_, gem) => `gem 'dependency_${i}_${gem}'`),
|
||||
].join('\n'),
|
||||
);
|
||||
fs.writeFileSync(
|
||||
path.join(onDisk, 'engine', 'my_engine.gemspec'),
|
||||
"Gem::Specification.new do |s|\n s.name = 'my_engine'\n s.require_paths = ['lib']\nend\n",
|
||||
);
|
||||
fs.writeFileSync(
|
||||
path.join(onDisk, 'Gemfile.lock'),
|
||||
'GEM\n remote: https://rubygems.org/\n specs:\n locked_gem (1.0.0)\n',
|
||||
);
|
||||
const from = `${directory}/app/main.rb`;
|
||||
files.push(
|
||||
from,
|
||||
`${directory}/app/helper.rb`,
|
||||
`${directory}/lib/local_${i}.rb`,
|
||||
`${directory}/engine/lib/my_engine.rb`,
|
||||
);
|
||||
const cases = [
|
||||
['rails/generators', null],
|
||||
['dry/types', null],
|
||||
['custom/entry', null],
|
||||
['my_engine', `${directory}/engine/lib/my_engine.rb`],
|
||||
['my_engine/missing', null],
|
||||
['./helper', `${directory}/app/helper.rb`],
|
||||
[`local_${i}`, `${directory}/lib/local_${i}.rb`],
|
||||
['locked_gem/missing', null],
|
||||
[`dependency_${i}_0/missing`, null],
|
||||
[`dependency_${(i + 1) % projects}_0/missing`, 'decoy/lib/missing.rb'],
|
||||
];
|
||||
for (let j = 0; j < IMPORTS_PER_PROJECT; j++) {
|
||||
const [target, expected] = cases[j % cases.length];
|
||||
queries.push({ from, target, expected });
|
||||
}
|
||||
}
|
||||
return { root, projects, gemsPerProject, files, queries };
|
||||
}
|
||||
|
||||
function resolve(query, pass) {
|
||||
return rubyScopeResolver.resolveImportTarget(query.target, query.from, pass.files, pass.config);
|
||||
}
|
||||
|
||||
function prepare(input) {
|
||||
return {
|
||||
files: new Set(input.files),
|
||||
config: rubyScopeResolver.loadResolutionConfig(input.root),
|
||||
};
|
||||
}
|
||||
|
||||
function correctness(input) {
|
||||
const pass = prepare(input);
|
||||
assert.ok(pass.config, 'the real manifest loader must supply configuration');
|
||||
const records = [];
|
||||
let resolved = 0;
|
||||
for (const query of input.queries) {
|
||||
const answer = resolve(query, pass);
|
||||
assert.equal(answer, query.expected, `${query.from}: ${query.target}`);
|
||||
if (answer !== null) resolved++;
|
||||
records.push(`${query.from}|${query.target}->${answer}`);
|
||||
}
|
||||
// The external decoy must actually be reachable without dependency evidence;
|
||||
// otherwise an always-null resolver could make a negative-only gate pass.
|
||||
assert.equal(
|
||||
resolve(
|
||||
{ from: input.queries[0].from, target: 'rails/generators' },
|
||||
{ files: pass.files, config: undefined },
|
||||
),
|
||||
'decoy/lib/generators.rb',
|
||||
);
|
||||
return {
|
||||
projects: input.projects,
|
||||
declarations_per_project: input.gemsPerProject + 4,
|
||||
scopes: pass.config.scopesByDirectory.size,
|
||||
files: input.files.length,
|
||||
imports: records.length,
|
||||
resolved,
|
||||
fingerprint: crypto.createHash('sha256').update(records.join('\n')).digest('hex'),
|
||||
};
|
||||
}
|
||||
|
||||
function measure(input, expectedResolved) {
|
||||
const loading = [];
|
||||
const resolution = [];
|
||||
for (let run = 0; run < WARMUP + REPS; run++) {
|
||||
const files = new Set(input.files);
|
||||
const loadStart = performance.now();
|
||||
const config = rubyScopeResolver.loadResolutionConfig(input.root);
|
||||
const loadMs = performance.now() - loadStart;
|
||||
const pass = { files, config };
|
||||
const start = performance.now();
|
||||
let resolved = 0;
|
||||
for (const query of input.queries) if (resolve(query, pass) !== null) resolved++;
|
||||
const resolveMs = performance.now() - start;
|
||||
assert.equal(resolved, expectedResolved, 'timed pass must do the validated work');
|
||||
if (run >= WARMUP) {
|
||||
loading.push(loadMs);
|
||||
resolution.push(resolveMs);
|
||||
}
|
||||
}
|
||||
// Like the neighboring resolver gates: min-of-N limits scheduler/GC noise.
|
||||
return { load_ms: Math.min(...loading), resolve_ms: Math.min(...resolution) };
|
||||
}
|
||||
|
||||
try {
|
||||
const inputs = { small: corpus(32), large: corpus(128), dense: corpus(32, 128) };
|
||||
const shapes = {};
|
||||
const timings = {};
|
||||
for (const [name, input] of Object.entries(inputs)) {
|
||||
shapes[name] = correctness(input);
|
||||
timings[name] = measure(input, shapes[name].resolved);
|
||||
}
|
||||
const scale = inputs.large.projects / inputs.small.projects;
|
||||
const metrics = {
|
||||
load_scaling_ratio: timings.large.load_ms / timings.small.load_ms / scale,
|
||||
resolve_scaling_ratio: timings.large.resolve_ms / timings.small.resolve_ms / scale,
|
||||
dependency_count_ratio: timings.dense.resolve_ms / timings.small.resolve_ms,
|
||||
};
|
||||
const report = {
|
||||
shapes,
|
||||
timings,
|
||||
metrics,
|
||||
estimator: { warmup: WARMUP, samples: REPS, statistic: 'minimum' },
|
||||
};
|
||||
console.log(JSON.stringify(report, null, 2));
|
||||
if (CHECK) {
|
||||
const baseline = JSON.parse(fs.readFileSync(baselinePath, 'utf8'));
|
||||
assert.deepEqual(shapes, baseline.shapes, 'Ruby workload/fingerprint drift');
|
||||
const failures = [];
|
||||
for (const [name, budget] of Object.entries(baseline.budgets)) {
|
||||
if (!Number.isFinite(metrics[name]) || metrics[name] > budget) {
|
||||
failures.push(`${name}: ${metrics[name]} > ${budget}`);
|
||||
}
|
||||
}
|
||||
assert.equal(failures.length, 0, failures.join('\n'));
|
||||
console.log('[ruby-gem-resolution --check] PASS');
|
||||
}
|
||||
} finally {
|
||||
for (const root of roots) fs.rmSync(root, { recursive: true, force: true });
|
||||
}
|
||||
|
|
@ -1,7 +1,9 @@
|
|||
{
|
||||
"_comment": "Per-language baselines for bench/scope-capture/measure.mjs --check. fingerprint = order-independent sha256 over the lang-resolution/<lang>-* fixture corpus + a 20-entity synthetic source (correctness gate; re-baseline intentionally on a legitimate capture change). scaling_budget = max allowed (t800/t250)/(800/250); ~1.0 is linear, ~3.2 is quadratic. The synthetic source is now HERITAGE-BEARING for every language (each Entity extends/implements/embeds/uses-trait/conforms-to a shared base) so the #1951 @reference.inherits synth is gated at scale, not just the base capture loop. All languages thread the tree-sitter captured node instead of re-deriving it with findNodeAtRange(tree.rootNode,...) per match, so all are linear (go #1915, python #1918, ruby/php/rust/csharp #1951, java #1956).",
|
||||
"go": {
|
||||
"fingerprint": "9c554a9d698a2b79fb419852daadca87b8aae88180cceabf9c8d82f3e3300f2e",
|
||||
"fingerprint": "2e3099db962f82f9d8641707a8b2bcf6875dafec1f54904f2dec7ac65ba22e9f",
|
||||
"_rebaselined_3190_ctor_qualified_name": "#3190: generic composite-literal constructors now carry @reference.qualified-name with the written pkg.Box[T] spelling so constructor fallback can tell a qualifier from a bare unique-name guess. DIGEST DRIFT ONLY: the tag is added to existing constructor matches (captureGroups unchanged on go-constructor-type-inference/cmd/main.go). Prior 990e4921a7ef0e6aa4d7da92b671de91fa2621cb27918adb27742740dc6ad902 -> 2e3099db962f82f9d8641707a8b2bcf6875dafec1f54904f2dec7ac65ba22e9f; capture_groups_fp 2579, fixture_count 122.",
|
||||
"_rebaselined_3190": "Corrected go-method-enrichment/app.go to share package animal with its declarations; its capture count is now 16 rather than 15. No Go emitter change. Scaling budget unchanged.",
|
||||
"scaling_budget": 1.5,
|
||||
"_rebaselined_callable_flow_2522_review": "PR #2522 review hardening: callable operands retain expression/qualified identity and formals retain signature metadata. Prior 3d4e32e7490c830516126e28931827949baa3594cb521f7a3d8dcfed95b6018a -> 57b3c55135af8d2af33b9a7c4bf89796a7bee5b5822b402a2dea91af7232cf4a; scaling 1.058 < 1.5.",
|
||||
"_rebaselined_callable_flow_2522_followup": "PR #2522 follow-up: provider-owned callable assignment/copy/formal/argument/invoke facts with invocation/constructor-result suppression. Prior 09ecd94911b830f52fa8807560abcbd79f163d02a2072870c1a59297e9a326e1 -> 3d4e32e7490c830516126e28931827949baa3594cb521f7a3d8dcfed95b6018a; scaling 1.039 < 1.5.",
|
||||
|
|
@ -137,8 +139,9 @@
|
|||
"_rebaselined": "#1919 review CF3 fix: extended kotlin-local-property-owner (init/accessor destructuring) + new dart-accessor-owner fixture (getter/setter ownership). Fingerprint-only corpus drift; scaling ~1.0."
|
||||
},
|
||||
"java": {
|
||||
"fingerprint": "2bf47cc19b595a9889ac21ec0154c6ce6786271d68551f21d1bc14c626bcd4ff",
|
||||
"fingerprint": "e22a753b9f59331898a3a27c43072b588c33639937b1f618f6c70ce04f072a9f",
|
||||
"scaling_budget": 1.5,
|
||||
"_rebaselined_3190_ctor_qualified_name": "#3190: qualified constructors (`new pkg.Foo()`, `new pkg.Box<T>()`) now copy @reference.call.constructor.qualified onto @reference.qualified-name so constructor fallback treats the written qualifier as precise. DIGEST DRIFT ONLY: the tag is added to existing F35 matches. Prior 2bf47cc19b595a9889ac21ec0154c6ce6786271d68551f21d1bc14c626bcd4ff -> e22a753b9f59331898a3a27c43072b588c33639937b1f618f6c70ce04f072a9f; capture_groups_fp 3586, fixture_count 209.",
|
||||
"_rebaselined_2935_synthetic_declarations": "PR #2935 review follow-up: synthesized Java anonymous classes and bodied enum constants now carry the presence-only @declaration.is-synthetic sidecar used to preserve source-written dispatch targets at the fanout cap. DIGEST DRIFT ONLY, NOT A CAPTURE-SET CHANGE: the tag is attached to existing synthetic declaration matches; capture groups and fixture count remain 5755/18405, 3512, and 206. Prior 36d689c58526c4482fbd701d1d9ca156623a3970734ead145717858712271ab5 -> 2e2150b4f4d64519e3f4c6d7a2c12259178d3117872203c904fab8cba96a694a; CI scaling 0.971 < 1.5.",
|
||||
"_rebaselined_2917_record_component_accessors": "#2917: every implicit Java record-component accessor now emits a component-bounded @scope.function plus @declaration.method/name/zero-arity/return-type metadata. The scope boundary prevents subsequent record-body references from being attributed to the accessor. Java was the only general language fingerprint to move; capture groups scale by exactly two per generated record component (small 5755 -> 6255, large 18405 -> 20005). Prior 36d689c58526c4482fbd701d1d9ca156623a3970734ead145717858712271ab5 -> 901a66c7dc0f071eeef9e4864b2519e5b58a1a141a1f9a7817ea42f7ff70eafb; scaling 0.961 < 1.5. Re-measured after merging origin/main, which carries #2935's is-synthetic sidecar on top of the same corpus: 2e2150b4f4d64519e3f4c6d7a2c12259178d3117872203c904fab8cba96a694a -> 79dafc369eaeb7183ee8cc1149b1a6c21ad672c7e5b806fe8b0060e5a952c79a; scaling 1.085 < 1.5, capture groups 6255/20005, capture_groups_fp 3560, fixture_count 206 (unchanged by the merge).",
|
||||
"_rebaselined_2900_record_heritage": "#2900 review follow-up: the Java scale unit now includes a record implementing Marker, so the record-declaration @reference.inherits path is fingerprinted and exercised at scale. Prior b29e263524f55151dcb7cfc4c929d3d1d7bb360355cee4e832158f927857f663 -> 36d689c58526c4482fbd701d1d9ca156623a3970734ead145717858712271ab5; scaling 1.042 < 1.5.",
|
||||
|
|
@ -171,7 +174,8 @@
|
|||
"capture_groups_fp": 680
|
||||
},
|
||||
"typescript": {
|
||||
"fingerprint": "fed04ed1d5db112387781e405da208ae6b3ab803889773b0455be96f01b893ff",
|
||||
"fingerprint": "60e75bbe846f7200005f12c4d95c32e82d9d3feae9f2fd594e484670762b82b0",
|
||||
"_rebaselined_3190": "Capture matches now retain explicit ESM export/private evidence, including synthesized default HOCs; CommonJS surfaces remain undecided. Capture group counts unchanged. Scaling budget unchanged.",
|
||||
"scaling_budget": 1.5,
|
||||
"_rebaselined_2934_import_type_only": "#2934: `import-decomposer.ts` attaches a presence-only `@import.type-only` synthetic capture to specifiers `tsc` erases, so `check --cycles` can stop counting type-only edges as initialization cycles. DIGEST DRIFT ONLY, NOT A CAPTURE-SET CHANGE \u2014 the tag is added to import matches that already existed, never a new match, the same shape as the #2747 receiver-chain rebaseline. Every count is unchanged: capture_groups_fp 2414, fixture_count 155, capture_groups_small/large 4503/14403 (those measure the SYNTHETIC scaling source, which has no imports at all). The fingerprint moves because `canonicalizeMatch` in measure.mjs hashes every TAG on every match, synthetics included, so one extra presence-only tag on an existing match rewrites that match's canonical string. Attribution is exact, not inferred: neutralizing ONLY the `m['@import.type-only'] = \u2026` assignment in import-decomposer.ts and re-running returns the fingerprint to c2fbf8a89e5686dd\u2026 byte-for-byte, so nothing else in the TypeScript capture stream moved. All 14 other languages report ok. Scaling 0.997 < 1.5. NOTE ON THE CONTROL: javascript did not move (2026993b\u2026, 43 fixtures), but it is a WEAK control here \u2014 `import type` is TypeScript-only syntax, so a JS corpus cannot express the construct and could not have drifted either way. It evidences no collateral damage, not the correctness of the TS change; the exact-attribution check above is what does that. Prior c2fbf8a89e5686dd1ff3659b20d41d8b05ebcc9790356e3653ee0c8ca5d365c8 -> f719163eb03a447c9e40ca316a905dd76cee82192a75a403df478ebbdc13e98f.",
|
||||
"_rebaselined_callable_flow_2522_review": "PR #2522 review hardening: callable operands retain expression/qualified identity and formals retain signature metadata. Prior 27f937bfb47d4bded316ea3c785ff659c8cd88a5761d928f113477a08c802c78 -> e05446620c5b80b7aae291cfdf32f693580fada2ae687124769b04a0c03bfe63; scaling 0.983 < 1.5.",
|
||||
|
|
@ -197,7 +201,8 @@
|
|||
"_rebaselined_1432_member_call_callee_name": "#1432 (Zig): the shared callable-flow reader no longer names a callee by simple name for a MEMBER call (`@callable-flow.direct-callee-name` requires a direct designator: `f(x)`, `ns.f(x)`), and a member call is a field-stored-callable invoke only when a MEMBER store (`o.f = handler`) or a declared callable-typed field is visible - a same-named plain binding no longer gates it. CAPTURE-EMISSION CHANGE, not fixture growth (fixture_count unchanged). Drift: `await svc.verify<GuestPayload>(token, ...)` (typescript-generic-calls/src/guest.ts, member call) and `initializer()(() => {...})` (typescript-hof-callbacks/src/store.ts, call-of-call) lose `direct-callee-name`. `await verifyToken<AdminPayload>(token, ...)` (admin.ts/auth.ts) KEEPS `direct-callee-name|verifyToken`: tree-sitter-typescript parses `await f<T>(x)` as call_expression(function: await_expression(f), type_arguments, ...), and wrappedExpression now unwraps `await_expression` so the direct designator survives as it does for the un-awaited spelling. capture_groups_fp 2465 (unchanged). Prior 05d1dadd6c9ef35c74079fa50f341b1b36e4fb02c9a89dd1b59f32b7cfd5e633 -> fed04ed1d5db112387781e405da208ae6b3ab803889773b0455be96f01b893ff."
|
||||
},
|
||||
"javascript": {
|
||||
"fingerprint": "2026993b81b873839dd2ef8797d9c14d9c48516b2b57b05ac17d8d43f2f4eba3",
|
||||
"fingerprint": "b916c7072b30d09b4949803810604830ea1aca1cfdda0d9d9312f7cb22f7a10a",
|
||||
"_rebaselined_3190": "Capture matches now retain explicit ESM export/private evidence, including synthesized default HOCs; CommonJS surfaces remain undecided. Capture group counts unchanged. Scaling budget unchanged.",
|
||||
"scaling_budget": 1.5,
|
||||
"_rebaselined_callable_flow_2522_review": "PR #2522 review hardening: callable operands retain expression/qualified identity and formals retain signature metadata. Prior b59fe8135b6a31a12bc3f872b224054b16592588153ae3661d03958d787c76f3 -> 479927409bbdd9852a36172c8260aa56df260e99129a7a9c20a0d1903dd5538b; scaling 1.050 < 1.5.",
|
||||
"_rebaselined_callable_flow_2522_followup": "PR #2522 follow-up: lexical callable bindings, direct-callee argument metadata, and invocation-result suppression. Prior 917a9cd975ba035bdad71fdb70cd72eeddec58c25797e5a1addfa6172808a55c -> b59fe8135b6a31a12bc3f872b224054b16592588153ae3661d03958d787c76f3; scaling 1.093 < 1.5.",
|
||||
|
|
|
|||
37
gitnexus/bench/value-ref-resolution/baseline.json
Normal file
37
gitnexus/bench/value-ref-resolution/baseline.json
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
{
|
||||
"_what": "Baselines for bench/value-ref-resolution/measure.mjs --check (#3399). Guards the resolved-target SET of `resolveValueRefTarget` and the per-site cost of its four channels across a 4x file-count step, over a synthetic Zig corpus whose shape is fixed in measure.mjs. Per module: 12 CONTAINER registrations (`ElementN.getJ`), 1 NAMESPACE (`dom_utils.compare`), 1 HUB (`hub.compare`), 1 BARE (`register(onTick)`), and 2 declines (a non-callable namespace member `dom_utils.DEFAULT_NS`, a non-callable bare argument `Bridge(ElementN)`) — 17 sites, 15 resolved.",
|
||||
|
||||
"_triage": "READ THIS BEFORE RE-RUNNING. modules, files, value_ref_sites, resolved, declined and fingerprint are DETERMINISTIC: a re-run never changes them, and none may be re-baselined to make CI green — drift means the resolved target set moved, which is a behaviour change to explain. linear_scaling_budget is the only timing arm; runner contention dominates it, so re-run alone on an idle machine and read `reps` in the report before investigating. If exactly one arm fails and it is that one, suspect the machine.",
|
||||
|
||||
"small": {
|
||||
"modules": 80,
|
||||
"files": 240,
|
||||
"value_ref_sites": 1360,
|
||||
"resolved": 1200,
|
||||
"declined": 160,
|
||||
"fingerprint": "4ca2933e25cfa9c84518fca6608c9a6f318f81a1c5bad63cb2f09b7394bfb792"
|
||||
},
|
||||
"large": {
|
||||
"modules": 320,
|
||||
"files": 960,
|
||||
"value_ref_sites": 5440,
|
||||
"resolved": 4800,
|
||||
"declined": 640,
|
||||
"fingerprint": "249266f180388e9f1240a7e81f1141afbc51ef25d5c4b3286a681992dab69e61"
|
||||
},
|
||||
|
||||
"linear_scaling_budget": 1.6,
|
||||
"_linear_scaling_note": "(t_large/t_small)/(320/80) over the per-site resolution loop; ~1.0 is linear. A RATIO rather than a millisecond ceiling, and there is deliberately no ms gate at all: wall-clock measures the runner, and this repo has been bitten twice by a fixed budget (bench/callable-value-flow's widening_overhead failed at 2.07 and 1.975 against 1.9 on a shared runner while the code was correct, both on a sub-11ms measurement). Same reasoning, same shape as bench/parse-dispatch-rounds' pack_scaling_budget. Budget is 1.6 — 1.40x the measured maximum, matching the ~1.5x its siblings use on ratios. What it catches: the four channels each consult a wider index than the last, and channel 4 (CONTAINER) reaches `scopes.qualifiedNames`, a WORKSPACE-WIDE index — keyed it is O(1) per site, scanned it is O(names) per site. Verified load-bearing rather than assumed: replacing `QualifiedNameIndex.get` with a full scan (in gitnexus-shared/dist — the bench resolves the built package, so patching src changes nothing) takes the factor from ~1.0 to 2.07, well clear of this budget. Only 1 of the 17 sites per module reaches that fallback (the `dom_utils.DEFAULT_NS` decline, whose module receiver is not class-like), which is why the signal is 2.07 and not the ~4 a per-site scan on every site would give.",
|
||||
|
||||
"_measured": {
|
||||
"linear_factor": 1.146,
|
||||
"linear_factor_samples": [
|
||||
0.907, 0.969, 0.988, 1.03, 1.043, 1.048, 1.05, 1.051, 1.052, 1.107, 1.123, 1.146
|
||||
],
|
||||
"small_ms": 2.078,
|
||||
"large_ms_4x": 9.197,
|
||||
"us_per_site": "1.36-1.53 small / 1.37-1.69 large",
|
||||
"reps": 15
|
||||
},
|
||||
"_measured_note": "Maxima over 12 runs on a box that was NOT idle, so the spread is an upper bound on real noise. small_ms / large_ms_4x / us_per_site are recorded for context only — NOTHING gates on them, because an absolute millisecond is exactly the gate this file avoids. `us_per_site` staying flat between the two arms is the same property linear_scaling_budget gates, read directly."
|
||||
}
|
||||
303
gitnexus/bench/value-ref-resolution/measure.mjs
Normal file
303
gitnexus/bench/value-ref-resolution/measure.mjs
Normal file
|
|
@ -0,0 +1,303 @@
|
|||
#!/usr/bin/env node
|
||||
/**
|
||||
* Build-free scaling and correctness guard for callable-value reference
|
||||
* resolution (#3399).
|
||||
*
|
||||
* WHAT IS GUARDED. `resolveValueRefTarget` is the per-site half of
|
||||
* `emitPropertyDispatchCalls`: for every `value-ref` reference site it names the
|
||||
* callable the source handed over as a value. #3399 replaced a single lexical
|
||||
* walk with four channels, and each one reaches for a wider index than the last:
|
||||
*
|
||||
* 1. BARE `register(onTick)` — `findCallableBindingInScope`
|
||||
* 2. NAMESPACE `bridge.accessor(utils.compare, …)` — the file's own
|
||||
* namespace `@import` edges, then the target's module scope
|
||||
* 3. HUB `bridge.accessor(hub.compare, …)` — the same, through the
|
||||
* finalized/augmented channel a re-export publishes into
|
||||
* 4. CONTAINER `bridge.accessor(Element.getNamespaceUri, …)` —
|
||||
* `findClassBindingInScope`, whose miss path falls back to
|
||||
* `scopes.qualifiedNames`, a WORKSPACE-WIDE index
|
||||
*
|
||||
* Channel 4 is why this bench exists. A workspace-wide index consulted per site
|
||||
* is linear only while the lookup is keyed; make it a scan — or make any of the
|
||||
* three guards around it (`isOwnerNameShadowedBySomethingElse`,
|
||||
* `isNamespaceNameShadowed`, `findOwnedMember`) walk a collection that grows
|
||||
* with the repo — and a registration table that costs O(sites) today costs
|
||||
* O(sites x files) tomorrow. That regression is invisible on a fixture and
|
||||
* expensive on lightpanda-io/browser, where `bridge.{accessor,function,…}`
|
||||
* appears 2,047 times across 257 files.
|
||||
*
|
||||
* HOW. Two corpora of identical shape, 4x apart in file count, and the per-site
|
||||
* resolution loop is the ONLY thing timed — extraction, ownership reconciliation
|
||||
* and finalize are setup. `linear_factor` is `(t_large/t_small) / (N_large/N_small)`:
|
||||
* ~1.0 linear, ~4.x quadratic on this 4x step.
|
||||
*
|
||||
* A RATIO IS THE ONLY TIMING GATE — no millisecond ceiling, deliberately.
|
||||
* `min_ms` and `us_per_site` are printed for context and nothing compares them
|
||||
* to anything: a wall-clock budget measures the runner, and this repo has been
|
||||
* bitten by that twice already (`bench/callable-value-flow`'s `widening_overhead`
|
||||
* failed at 2.07 and 1.975 against a 1.9 budget on a shared runner while the
|
||||
* code was correct, both times on a sub-11ms measurement). Dividing the large
|
||||
* arm by the small one divides the machine out, which is what
|
||||
* `bench/parse-dispatch-rounds` settled on for the same reason.
|
||||
*
|
||||
* A timing gate alone would be satisfied by a fast wrong answer, so the
|
||||
* correctness half is exact and comes first: the site/resolved/declined counts
|
||||
* per arm, plus an order-independent sha256 over every (site -> resolved target)
|
||||
* pair. The fingerprint is a CORRECTNESS gate — drift means the resolved target
|
||||
* set moved, which is a behaviour change to be explained, never re-baselined to
|
||||
* make CI green.
|
||||
*
|
||||
* WHY A ZIG CORPUS for a language-neutral pass. Zig is the only language whose
|
||||
* provider sets `namespaceExportsIncludeImportedNames`, so it is the only one
|
||||
* that can exercise channel 3 at all; and the file-as-struct idiom puts channels
|
||||
* 2 and 4 in one file, which is the shape #3399 was filed over. The corpus also
|
||||
* carries two DECLINE controls — a non-callable namespace member and a
|
||||
* non-callable bare argument — so a change that widened the callable gate would
|
||||
* move `declined` rather than hiding inside the timing.
|
||||
*
|
||||
* Container naming is load-bearing in the corpus: a Zig file-as-struct is minted
|
||||
* under the FILE STEM, so `ElementN.zig` must write `const ElementN = @This();`
|
||||
* and register `ElementN.getJ`. Spelling the alias `Element` instead is the
|
||||
* documented `@This()`-alias limitation, every channel-4 site declines, and the
|
||||
* bench would time a corpus that resolves nothing.
|
||||
*
|
||||
* Usage:
|
||||
* node --import tsx bench/value-ref-resolution/measure.mjs
|
||||
* node --import tsx bench/value-ref-resolution/measure.mjs --check
|
||||
*/
|
||||
import { createHash } from 'node:crypto';
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { dirname, join } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { performance } from 'node:perf_hooks';
|
||||
|
||||
import { extractParsedFile } from '../../src/core/ingestion/scope-extractor-bridge.ts';
|
||||
import { finalizeScopeModel } from '../../src/core/ingestion/finalize-orchestrator.ts';
|
||||
import { createSemanticModel } from '../../src/core/ingestion/model/semantic-model.ts';
|
||||
import { reconcileOwnership } from '../../src/core/ingestion/scope-resolution/pipeline/reconcile-ownership.ts';
|
||||
import { resolveValueRefTarget } from '../../src/core/ingestion/scope-resolution/passes/property-dispatch.ts';
|
||||
import { zigScopeResolver } from '../../src/core/ingestion/languages/zig/scope-resolver.ts';
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url));
|
||||
const SMALL_MODULES = 80;
|
||||
const LARGE_MODULES = 320;
|
||||
/** Registrations per module through the CONTAINER channel. */
|
||||
const ACCESSORS_PER_MODULE = 12;
|
||||
/**
|
||||
* Min-of-N, and N is 15 rather than a handful: `bench/import-target` measured
|
||||
* N=5 tripping its own budget about one run in twenty while N=15 held every
|
||||
* language inside a 1.13-1.26x swing, and `bench/parse-dispatch-rounds` uses 15
|
||||
* on the same grounds. The whole run is ~5 s, so the reps are nearly free.
|
||||
*/
|
||||
const REPS = 15;
|
||||
|
||||
/**
|
||||
* One module = three files, mirroring `test/fixtures/lang-resolution/zig-idioms/
|
||||
* src/webapi/`: a namespace-only helper, a hub that re-exports one of its
|
||||
* members and declares nothing, and a file-as-struct carrying the binding table.
|
||||
*/
|
||||
function moduleFiles(i) {
|
||||
const accessors = Array.from(
|
||||
{ length: ACCESSORS_PER_MODULE },
|
||||
(_, j) => `pub fn get${j}(self: *Element${i}) u8 { return self._n; }`,
|
||||
).join('\n');
|
||||
const registrations = Array.from(
|
||||
{ length: ACCESSORS_PER_MODULE },
|
||||
(_, j) => ` pub const a${j} = bridge.accessor(Element${i}.get${j}, null, .{});`,
|
||||
).join('\n');
|
||||
return [
|
||||
{
|
||||
path: `src/dom_utils${i}.zig`,
|
||||
content: `pub const DEFAULT_NS: u8 = 7;\npub fn compare(a: u8, b: u8) u8 { return if (a > b) a else b; }\n`,
|
||||
},
|
||||
{
|
||||
path: `src/hub${i}.zig`,
|
||||
content: `pub const compare = @import("dom_utils${i}.zig").compare;\n`,
|
||||
},
|
||||
{
|
||||
path: `src/Element${i}.zig`,
|
||||
content: `const Element${i} = @This();
|
||||
const dom_utils = @import("dom_utils${i}.zig");
|
||||
const hub = @import("hub${i}.zig");
|
||||
|
||||
_n: u8 = 0,
|
||||
|
||||
${accessors}
|
||||
|
||||
fn onTick(self: *Element${i}) u8 { return self._n; }
|
||||
|
||||
pub const JsApi = struct {
|
||||
pub const bridge = Bridge(Element${i});
|
||||
${registrations}
|
||||
pub const comparator = bridge.accessor(dom_utils.compare, null, .{});
|
||||
pub const hubbed = bridge.accessor(hub.compare, null, .{});
|
||||
pub const defaultNs = bridge.accessor(dom_utils.DEFAULT_NS, null, .{});
|
||||
};
|
||||
|
||||
pub fn boot() void { register(onTick); }
|
||||
|
||||
pub fn register(comptime f: anytype) void { _ = f; }
|
||||
|
||||
fn Bridge(comptime T: type) type {
|
||||
_ = T;
|
||||
return struct {
|
||||
pub fn accessor(comptime g: anytype, comptime s: anytype, comptime o: anytype) u8 {
|
||||
_ = g;
|
||||
_ = s;
|
||||
_ = o;
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
}
|
||||
`,
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Everything `resolveValueRefTarget` reads, built the way the pipeline builds it
|
||||
* (`runScopeResolution` phases 1-2): real extraction through the Zig provider,
|
||||
* `populateOwners`, `reconcileOwnership` into the SemanticModel, then finalize.
|
||||
* Hand-assembling the indexes instead would pin this file's idea of their shape
|
||||
* rather than the code's.
|
||||
*/
|
||||
function buildCorpus(modules) {
|
||||
const parsedFiles = [];
|
||||
for (let i = 0; i < modules; i++) {
|
||||
for (const file of moduleFiles(i)) {
|
||||
const parsed = extractParsedFile(zigScopeResolver.languageProvider, file.content, file.path);
|
||||
if (parsed === undefined) {
|
||||
throw new Error(
|
||||
`scope extraction failed for ${file.path} — the vendored tree-sitter-zig ` +
|
||||
`grammar is unavailable on this host, so this bench cannot run`,
|
||||
);
|
||||
}
|
||||
zigScopeResolver.populateOwners(parsed);
|
||||
parsedFiles.push(parsed);
|
||||
}
|
||||
}
|
||||
const model = createSemanticModel();
|
||||
reconcileOwnership(parsedFiles, model);
|
||||
const allFilePaths = new Set(parsedFiles.map((p) => p.filePath));
|
||||
const scopes = finalizeScopeModel(parsedFiles, {
|
||||
hooks: {
|
||||
resolveImportTarget: (raw, from) =>
|
||||
zigScopeResolver.resolveImportTarget(raw, from, allFilePaths),
|
||||
mergeBindings: (existing, incoming, scopeId) =>
|
||||
zigScopeResolver.mergeBindings(existing, incoming, scopeId),
|
||||
expandsWildcardTo: (scope, files) => zigScopeResolver.expandsWildcardTo(scope, files),
|
||||
},
|
||||
});
|
||||
return { parsedFiles, scopes, model };
|
||||
}
|
||||
|
||||
/** The timed loop: every `value-ref` site, resolved exactly as the pass does. */
|
||||
function resolveAll({ parsedFiles, scopes, model }, pairs) {
|
||||
let sites = 0;
|
||||
let resolved = 0;
|
||||
for (const parsed of parsedFiles) {
|
||||
for (const site of parsed.referenceSites) {
|
||||
if (site.kind !== 'value-ref') continue;
|
||||
sites++;
|
||||
const def = resolveValueRefTarget(
|
||||
site,
|
||||
parsed.filePath,
|
||||
scopes,
|
||||
model,
|
||||
// The provider hook the pass is handed in `run.ts`; Zig sets it.
|
||||
zigScopeResolver.namespaceExportsIncludeImportedNames === true,
|
||||
);
|
||||
if (def === undefined) continue;
|
||||
resolved++;
|
||||
pairs?.push(
|
||||
`${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}->${def.nodeId}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
return { sites, resolved };
|
||||
}
|
||||
|
||||
function measure(modules) {
|
||||
const corpus = buildCorpus(modules);
|
||||
const pairs = [];
|
||||
const counts = resolveAll(corpus, pairs);
|
||||
let bestMs = Infinity;
|
||||
for (let i = 0; i < REPS; i++) {
|
||||
const start = performance.now();
|
||||
resolveAll(corpus, undefined);
|
||||
bestMs = Math.min(bestMs, performance.now() - start);
|
||||
}
|
||||
// Order-independent: the walk order is an implementation detail, the resolved
|
||||
// SET is the behaviour.
|
||||
pairs.sort();
|
||||
return {
|
||||
modules,
|
||||
files: corpus.parsedFiles.length,
|
||||
value_ref_sites: counts.sites,
|
||||
resolved: counts.resolved,
|
||||
declined: counts.sites - counts.resolved,
|
||||
fingerprint: createHash('sha256').update(pairs.join('\n')).digest('hex'),
|
||||
min_ms: Number(bestMs.toFixed(3)),
|
||||
us_per_site: Number(((bestMs * 1000) / Math.max(counts.sites, 1)).toFixed(3)),
|
||||
};
|
||||
}
|
||||
|
||||
const report = { small: measure(SMALL_MODULES), large: measure(LARGE_MODULES) };
|
||||
report.reps = REPS;
|
||||
report.workload_ratio = LARGE_MODULES / SMALL_MODULES;
|
||||
report.scaling_ratio = Number(
|
||||
(report.large.min_ms / Math.max(report.small.min_ms, 0.001)).toFixed(3),
|
||||
);
|
||||
report.linear_factor = Number((report.scaling_ratio / report.workload_ratio).toFixed(3));
|
||||
|
||||
if (!process.argv.includes('--check')) {
|
||||
console.log(JSON.stringify(report, null, 2));
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
const baseline = JSON.parse(readFileSync(join(HERE, 'baseline.json'), 'utf8'));
|
||||
const failures = [];
|
||||
const requirePositiveNumber = (path, value) => {
|
||||
if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
|
||||
failures.push(`${path}: expected a finite positive number, got ${JSON.stringify(value)}`);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
};
|
||||
for (const arm of ['small', 'large']) {
|
||||
// Correctness first: counts AND the resolved-target set.
|
||||
for (const key of [
|
||||
'modules',
|
||||
'files',
|
||||
'value_ref_sites',
|
||||
'resolved',
|
||||
'declined',
|
||||
'fingerprint',
|
||||
]) {
|
||||
if (report[arm][key] !== baseline[arm][key]) {
|
||||
failures.push(
|
||||
`${arm}.${key}: expected ${JSON.stringify(baseline[arm][key])}, got ${JSON.stringify(report[arm][key])}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
// `min_ms` / `us_per_site` are reported, never gated — see the header.
|
||||
}
|
||||
if (
|
||||
requirePositiveNumber('linear_scaling_budget', baseline.linear_scaling_budget) &&
|
||||
report.linear_factor > baseline.linear_scaling_budget
|
||||
) {
|
||||
failures.push(
|
||||
`linear_factor ${report.linear_factor} exceeds budget ${baseline.linear_scaling_budget} ` +
|
||||
`(runtime ${report.scaling_ratio}x for ${report.workload_ratio}x work; ` +
|
||||
`~1.0 is linear). Re-run alone on an idle machine before investigating — ` +
|
||||
`this is the only arm a busy runner can move.`,
|
||||
);
|
||||
}
|
||||
|
||||
console.log(JSON.stringify(report, null, 2));
|
||||
if (failures.length > 0) {
|
||||
console.error('[value-ref-resolution --check] FAIL');
|
||||
for (const failure of failures) console.error(` - ${failure}`);
|
||||
process.exit(1);
|
||||
}
|
||||
console.log('[value-ref-resolution --check] PASS');
|
||||
6
gitnexus/package-lock.json
generated
6
gitnexus/package-lock.json
generated
|
|
@ -3440,9 +3440,9 @@
|
|||
"license": "MIT"
|
||||
},
|
||||
"node_modules/hono": {
|
||||
"version": "4.13.0",
|
||||
"resolved": "https://registry.npmjs.org/hono/-/hono-4.13.0.tgz",
|
||||
"integrity": "sha512-jhunvfHWxd7J5EFfSgH4xsYJzSe/lfqbUCxiyyeaQasUsXeEHXtzVid+7EOGByc5JnFa23SSFL3Y2RV/z1T+eQ==",
|
||||
"version": "4.13.7",
|
||||
"resolved": "https://registry.npmjs.org/hono/-/hono-4.13.7.tgz",
|
||||
"integrity": "sha512-c8/gF9ac8Y78/agExVocyLevgR+JlpNB444Py0FSX8pJoPdYUfUzRcXtYEYGwt6l19qIlVZPN5Mfsw9jFShmQQ==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=16.9.0"
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
* One registry-driven script replaces the former per-grammar
|
||||
* build-tree-sitter-<name>.cjs files (they were ~95% identical).
|
||||
*
|
||||
* The grammars (tree-sitter-c/dart/proto/swift/kotlin/zig) are loaded from
|
||||
* The grammars (tree-sitter-c/objc/dart/proto/swift/kotlin/zig) are loaded from
|
||||
* `vendor/<name>/` by absolute path at runtime (see
|
||||
* src/core/tree-sitter/vendored-grammars.ts) and are NEVER copied into
|
||||
* node_modules — an undeclared package under node_modules is "extraneous" to
|
||||
|
|
@ -25,8 +25,8 @@
|
|||
* or exit non-zero — a failure for any single grammar must not break the install.
|
||||
*
|
||||
* Opt-out: GITNEXUS_SKIP_OPTIONAL_GRAMMARS=1 (strict '1') skips the OPTIONAL
|
||||
* grammars only. tree-sitter-c is REQUIRED (it backstops upstream's 4/6 ARM
|
||||
* prebuild gap, #2116) and is always built.
|
||||
* grammars only. tree-sitter-c and tree-sitter-objc are REQUIRED (C backstops upstream's 4/6 ARM
|
||||
* prebuild gap, #2116) and are always built.
|
||||
*
|
||||
* Usage:
|
||||
* node build-tree-sitter-grammars.cjs # all grammars (postinstall)
|
||||
|
|
@ -40,6 +40,7 @@ const { execSync } = require('child_process');
|
|||
// grammars ignore the opt-out gate. Insertion order == build order (c first).
|
||||
const GRAMMARS = {
|
||||
c: { required: true, display: 'C', ext: '.c' },
|
||||
objc: { required: true, display: 'Objective-C', ext: '.m/.mm/.h' },
|
||||
dart: { required: false, display: 'Dart', ext: '.dart' },
|
||||
proto: { required: false, display: 'Proto', ext: '.proto' },
|
||||
swift: { required: false, display: 'Swift', ext: '.swift' },
|
||||
|
|
|
|||
|
|
@ -36,9 +36,9 @@
|
|||
*
|
||||
* Only files heavy enough to matter are listed; everything else is carried by
|
||||
* {@link PER_FILE_OVERHEAD_SEC} alone. These are load-balancing hints, NOT
|
||||
* assertions — no
|
||||
* test asserts a runtime, and drift only makes the split slightly less even, so
|
||||
* a stale entry is harmless and refreshing them is optional. Deliberately not
|
||||
* assertions — no test measures elapsed time against this table. Missing or
|
||||
* stale heavy entries can still overload a shard; refresh them from failed
|
||||
* CI logs and replay that profile in the partition tests. Deliberately not
|
||||
* auto-generated: a committed table is reviewable and works offline, and the
|
||||
* alternative (timing files at CI runtime to decide the split) would make the
|
||||
* partition depend on the very machine load it is trying to protect against.
|
||||
|
|
@ -49,13 +49,15 @@ export const WINDOWS_WEIGHTS_SEC: Readonly<Record<string, number>> = {
|
|||
'test/integration/cli-e2e.test.ts': 621,
|
||||
'test/integration/worker-pool.test.ts': 222,
|
||||
'test/unit/incremental-vector-extension-ordering.test.ts': 87,
|
||||
// ESTIMATE, not a measurement (#2841): this suite drives more full
|
||||
// `runFullAnalysis` cycles than the VECTOR sibling above, so the 8 s
|
||||
// PER_FILE_OVERHEAD floor would badly under-charge it and skew the Windows
|
||||
// split — the failure mode that produced the job timeouts this table exists
|
||||
// to prevent. Scaled from the sibling's measured 87 s by analyze-run count.
|
||||
// Replace with a real figure after the first green Windows matrix run.
|
||||
'test/unit/incremental-index-extension-dml-gate.test.ts': 180,
|
||||
// Measured on Windows in run 34014266125 (#3190, 2026-09-06). These DB
|
||||
// suites landed together on shard 3: the old 180s estimate and missing
|
||||
// entries made a ~27-minute recorded load look like an ~12-minute shard.
|
||||
// Upstream speedups may reduce these figures; retaining conservative weights
|
||||
// keeps the expensive suites distributed without changing the watchdog.
|
||||
'test/unit/incremental-index-extension-dml-gate.test.ts': 414,
|
||||
'test/integration/skills-e2e.test.ts': 444,
|
||||
'test/integration/fts-extension-e2e.test.ts': 146,
|
||||
'test/integration/analyze-wal-checkpoint-failure.test.ts': 86,
|
||||
'test/integration/cli-limit-e2e.test.ts': 75,
|
||||
'test/unit/hooks.test.ts': 26,
|
||||
'test/integration/analyze-heap-oom-e2e.test.ts': 23,
|
||||
|
|
|
|||
|
|
@ -36,6 +36,18 @@ const PLATFORM_LOGIC = [
|
|||
// must exercise the Windows backslash branch, so run it on the OS matrix (#2394).
|
||||
'test/unit/cli-entry.test.ts',
|
||||
'test/unit/platform-capabilities.test.ts',
|
||||
// The tsconfig loader rebases `paths` targets through `path.resolve`, so the
|
||||
// wildcard suffix it must recognise is `/*` on POSIX and `\*` on Windows. It
|
||||
// only looked for `/*`, and every alias target came back as `src*` on
|
||||
// Windows while the Ubuntu run stayed green — so this file has to run where
|
||||
// the separator differs.
|
||||
'test/unit/tsconfig-index.test.ts',
|
||||
// The unit half of the same rebasing rule. Fixture-free and pathApi-injectable
|
||||
// (every separator assertion passes an explicit `path.win32` / `path.posix`),
|
||||
// so unlike the fixture suite above it fails on EVERY runner when the
|
||||
// normalisation is removed rather than only on windows-latest. Registered
|
||||
// beside its fixture sibling so the two halves stay discoverable as one group.
|
||||
'test/unit/tsconfig-rebase-target.test.ts',
|
||||
// The gitnexus-plan safe writer resolves every name through a per-platform
|
||||
// backend: Linux anchors through /proc/self/fd, macOS resolves lexically and
|
||||
// verifies each step against descriptors it holds open. Publication is link(2)
|
||||
|
|
|
|||
|
|
@ -291,13 +291,15 @@ export const doctorCommand = async () => {
|
|||
console.log(` ${padDisplayEnd('', 18)}${remedy}`);
|
||||
}
|
||||
}
|
||||
// Semantic mode follows the probe, not the platform: without a loadable
|
||||
// VECTOR extension the index can be neither built nor queried, so search is
|
||||
// really on exact scan no matter what the platform would allow.
|
||||
// Doctor has no repository target, so this probe can report only whether the
|
||||
// runtime can load VECTOR. It cannot claim that a repository has built the
|
||||
// named HNSW index. Keep the capability and repository state distinct.
|
||||
console.log(
|
||||
` ${label('doctor.labels.semanticMode', 18)}${
|
||||
vectorProbe.loaded ? capabilities.semanticMode : 'exact-scan'
|
||||
}`,
|
||||
` ${label('doctor.labels.semanticMode', 18)}${t(
|
||||
vectorProbe.loaded
|
||||
? 'doctor.vectorCapability.indexUnverified'
|
||||
: 'doctor.vectorCapability.exactScanOnly',
|
||||
)}`,
|
||||
);
|
||||
// Surface the optional-extension install policy so offline users can see
|
||||
// whether analyze/query will reach the network (extension.ladybugdb.com).
|
||||
|
|
|
|||
170
gitnexus/src/cli/embeddings-sync.ts
Normal file
170
gitnexus/src/cli/embeddings-sync.ts
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
import { lstat } from 'node:fs/promises';
|
||||
import path from 'node:path';
|
||||
import { cliInfo } from './cli-message.js';
|
||||
import { getGitRoot } from '../storage/git.js';
|
||||
import { acquireIndexLock } from '../storage/index-lock.js';
|
||||
import { getStoragePaths, loadMeta, saveMeta } from '../storage/repo-manager.js';
|
||||
import {
|
||||
closeLbug,
|
||||
executeQuery,
|
||||
executeWithReusedStatement,
|
||||
fetchExistingEmbeddingHashes,
|
||||
initLbug,
|
||||
} from '../core/lbug/lbug-adapter.js';
|
||||
import { runEmbeddingPipeline } from '../core/embeddings/embedding-pipeline.js';
|
||||
import { resolveEmbeddingIdentity } from '../core/embeddings/embedding-identity.js';
|
||||
import {
|
||||
checkpointKind,
|
||||
decideEmbeddingResume,
|
||||
mintInterruptedCheckpoint,
|
||||
mintPartialCheckpoint,
|
||||
mintUnverifiedCountCheckpoint,
|
||||
type EmbeddingCheckpoint,
|
||||
type EmbeddingCheckpointProgress,
|
||||
} from '../core/embedding-checkpoint.js';
|
||||
import {
|
||||
measurePersistedEmbeddingCount,
|
||||
persistedEmbeddingCountOrUndefined,
|
||||
} from '../core/embedding-count.js';
|
||||
|
||||
/** Add missing embeddings directly to a healthy index, checkpointing periodically. */
|
||||
export const embeddingsSyncCommand = async (inputPath?: string): Promise<void> => {
|
||||
const repoPath = inputPath ? path.resolve(inputPath) : getGitRoot(process.cwd());
|
||||
if (!repoPath) throw new Error('Not inside a git repository. Pass a repository path.');
|
||||
|
||||
const { lbugPath, metaPath } = getStoragePaths(repoPath);
|
||||
const metaDir = path.dirname(metaPath);
|
||||
const lock = await acquireIndexLock(metaDir);
|
||||
try {
|
||||
const meta = await loadMeta(metaDir);
|
||||
if (!meta)
|
||||
throw new Error(`No GitNexus index found for ${repoPath}. Run gitnexus analyze first.`);
|
||||
if (meta.incrementalInProgress) {
|
||||
throw new Error('The structural index is incomplete. Run gitnexus analyze --force first.');
|
||||
}
|
||||
|
||||
let lbugStat;
|
||||
try {
|
||||
lbugStat = await lstat(lbugPath);
|
||||
} catch {
|
||||
throw new Error(
|
||||
`The LadybugDB graph store at ${lbugPath} is missing. Run gitnexus analyze first.`,
|
||||
);
|
||||
}
|
||||
if (!lbugStat.isFile()) {
|
||||
throw new Error(
|
||||
`The LadybugDB graph store at ${lbugPath} is not a usable database file. Run gitnexus analyze first.`,
|
||||
);
|
||||
}
|
||||
|
||||
const identity = resolveEmbeddingIdentity();
|
||||
let forceReembedNodeIds: ReadonlySet<string> | undefined;
|
||||
let resumedFrom: EmbeddingCheckpoint | undefined;
|
||||
if (meta.embeddingCheckpoint) {
|
||||
const checkpoint = meta.embeddingCheckpoint;
|
||||
const decision = decideEmbeddingResume(checkpoint, identity);
|
||||
if (decision.action === 'abort') throw new Error(decision.error);
|
||||
const identityDiffers =
|
||||
checkpoint.provider !== identity.provider ||
|
||||
checkpoint.model !== identity.model ||
|
||||
checkpoint.dimensions !== identity.dimensions;
|
||||
// `abandon` on a non-interrupted foreign identity drops the pending set
|
||||
// only. Existing rows stay; sync would then embed the holes under the new
|
||||
// identity and mix vector spaces. Fail closed — rebuild via analyze.
|
||||
if (identityDiffers && checkpointKind(checkpoint) !== 'unverified-count') {
|
||||
throw new Error(
|
||||
`Cannot sync embeddings: the index checkpoint was written by ${checkpoint.model} ` +
|
||||
`(${checkpoint.provider}) at ${checkpoint.dimensions} dimensions, but this run ` +
|
||||
`resolves ${identity.model} (${identity.provider}) at ${identity.dimensions}. ` +
|
||||
'Run `gitnexus analyze --embeddings --force` to rebuild under the new identity.',
|
||||
);
|
||||
}
|
||||
cliInfo(decision.log);
|
||||
if (decision.action === 'resume') {
|
||||
forceReembedNodeIds = decision.pendingNodeIds;
|
||||
resumedFrom = decision.resumedFrom;
|
||||
}
|
||||
}
|
||||
|
||||
await initLbug(lbugPath);
|
||||
try {
|
||||
const existing = await fetchExistingEmbeddingHashes(executeQuery);
|
||||
let lastPercent = -1;
|
||||
|
||||
const countEmbeddings = async (): Promise<number | undefined> =>
|
||||
persistedEmbeddingCountOrUndefined(await measurePersistedEmbeddingCount(executeQuery));
|
||||
const saveCheckpoint = async (
|
||||
checkpoint: EmbeddingCheckpointProgress,
|
||||
pendingNodeIds: string[],
|
||||
embeddings?: number,
|
||||
): Promise<void> => {
|
||||
const latest = (await loadMeta(metaDir)) ?? meta;
|
||||
await saveMeta(metaDir, {
|
||||
...latest,
|
||||
...(embeddings === undefined ? {} : { stats: { ...latest.stats, embeddings } }),
|
||||
embeddingCheckpoint: mintInterruptedCheckpoint(identity, checkpoint, pendingNodeIds),
|
||||
});
|
||||
};
|
||||
|
||||
cliInfo(`Embedding ${repoPath}`);
|
||||
cliInfo(`Checkpointed nodes already present: ${existing?.size ?? 0}`);
|
||||
|
||||
const result = await runEmbeddingPipeline(
|
||||
executeQuery,
|
||||
executeWithReusedStatement,
|
||||
(progress) => {
|
||||
const percent = Math.floor(progress.percent);
|
||||
if (percent !== lastPercent && (percent % 5 === 0 || percent === 100)) {
|
||||
lastPercent = percent;
|
||||
cliInfo(
|
||||
` ${percent}% — ${progress.nodesProcessed ?? 0}/${progress.totalNodes ?? '?'} nodes`,
|
||||
);
|
||||
}
|
||||
},
|
||||
{},
|
||||
undefined,
|
||||
existing && existing.size ? existing : undefined,
|
||||
{
|
||||
forceReembedNodeIds,
|
||||
onCheckpointWindowStart: async ({ nodeIds, ...checkpoint }) => {
|
||||
await saveCheckpoint(checkpoint, nodeIds);
|
||||
},
|
||||
onCheckpoint: async (checkpoint) => {
|
||||
await saveCheckpoint(checkpoint, [], await countEmbeddings());
|
||||
},
|
||||
},
|
||||
);
|
||||
|
||||
const embeddings = await countEmbeddings();
|
||||
const latest = (await loadMeta(metaDir)) ?? meta;
|
||||
if (embeddings === undefined) {
|
||||
// Keep last-known stats.embeddings. An interrupted window marker would
|
||||
// fail the identity gate on the next run even though this run finished;
|
||||
// unverified-count is the recovery kind that forces a recount (#2790).
|
||||
await saveMeta(metaDir, {
|
||||
...latest,
|
||||
embeddingCheckpoint: result.failedNodeIds.length
|
||||
? mintPartialCheckpoint(identity, result, resumedFrom)
|
||||
: mintUnverifiedCountCheckpoint(identity, {
|
||||
nodesProcessed: result.nodesProcessed,
|
||||
totalNodes: result.nodesProcessed,
|
||||
chunksProcessed: result.chunksProcessed,
|
||||
}),
|
||||
});
|
||||
throw new Error('Could not verify persisted embedding count.');
|
||||
}
|
||||
await saveMeta(metaDir, {
|
||||
...latest,
|
||||
stats: { ...latest.stats, embeddings },
|
||||
embeddingCheckpoint: result.failedNodeIds.length
|
||||
? mintPartialCheckpoint(identity, result, resumedFrom)
|
||||
: undefined,
|
||||
});
|
||||
cliInfo(`Embeddings ready: ${embeddings}`);
|
||||
} finally {
|
||||
await closeLbug().catch(() => {});
|
||||
}
|
||||
} finally {
|
||||
lock.release();
|
||||
}
|
||||
};
|
||||
|
|
@ -609,10 +609,20 @@ export function formatImpactResult(result: any): string {
|
|||
}
|
||||
// #1858 — an interface / indirection boundary on the path makes this a lower
|
||||
// bound; surface it so the count is not read as exhaustive.
|
||||
//
|
||||
// The header names no cause AND asserts no omitted caller, because it cannot
|
||||
// know either. DI / dynamic dispatch was the only producer of `lower-bound`
|
||||
// when this was written; #3399 added callables named in VALUE position (a
|
||||
// registration table, a callback argument), and one of its producers is a
|
||||
// probe that could not RUN — `callableValueReferenceBoundaries` hedges on a
|
||||
// failed query and says in so many words that whether the symbol is
|
||||
// registered is unknown. A header claiming "some callers are not traced"
|
||||
// would there assert an omission nothing established, and would contradict
|
||||
// the bullet printed directly under it. The bullets carry the cause — they
|
||||
// are generated per-cause by `computeEpistemicBoundary` — so the header only
|
||||
// has to say the count is a floor.
|
||||
if (result.epistemic === 'lower-bound') {
|
||||
lines.push(
|
||||
'⚠️ Lower bound — unresolved indirection on the path (callers binding via DI / dynamic dispatch are not traced; actual impact may be higher):',
|
||||
);
|
||||
lines.push('⚠️ Lower bound — impact may be incomplete and actual impact may be higher:');
|
||||
for (const b of result.boundaries || []) lines.push(` • ${b}`);
|
||||
}
|
||||
pushCallgraphRiskLines(lines, result);
|
||||
|
|
|
|||
|
|
@ -123,8 +123,10 @@ export const en = {
|
|||
'doctor.labels.onnx': 'ONNX:',
|
||||
'doctor.labels.graphStore': 'Graph store:',
|
||||
'doctor.labels.fullTextSearch': 'Full-text search:',
|
||||
'doctor.labels.vectorIndex': 'VECTOR index:',
|
||||
'doctor.labels.semanticMode': 'Semantic mode:',
|
||||
'doctor.labels.vectorIndex': 'VECTOR extension:',
|
||||
'doctor.labels.semanticMode': 'Semantic support:',
|
||||
'doctor.vectorCapability.indexUnverified': 'vector-index capable (repository index not checked)',
|
||||
'doctor.vectorCapability.exactScanOnly': 'exact-scan only (VECTOR extension unavailable)',
|
||||
'doctor.labels.exactScanLimit': 'Exact scan limit:',
|
||||
'doctor.labels.note': 'Note:',
|
||||
'doctor.labels.backend': 'Backend:',
|
||||
|
|
@ -166,6 +168,8 @@ export const en = {
|
|||
'error.watch.ambiguous':
|
||||
'`gitnexus watch` is ambiguous.\n Local working-tree incremental index: gitnexus analyze --watch\n Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n',
|
||||
'help.command.analyze.description': 'Index a repository (full analysis)',
|
||||
'help.command.embeddings.sync.description':
|
||||
'Add missing embeddings to an existing index, checkpointing periodically for safe resume',
|
||||
'help.command.index.description':
|
||||
'Register an existing .gitnexus/ folder into the global registry (no re-analysis needed)',
|
||||
'help.command.serve.description': 'Start local HTTP server for web UI connection',
|
||||
|
|
@ -354,5 +358,5 @@ export const en = {
|
|||
'help.identityCache.environment':
|
||||
'\nAnalyzer identity cache:\n GITNEXUS_ANALYZER_IDENTITY_CACHE_DIR=/absolute/protected/dir\n Operator-trusted persistent cache for warm cross-process status. The directory must pre-exist, be outside the GitNexus package/build roots, and contain no symlink or junction components. Defaults remain fail-closed on platforms without POSIX ownership APIs.',
|
||||
'help.analyze.environment':
|
||||
'\nEnvironment variables:\n GITNEXUS_NO_GITIGNORE=1 Skip .gitignore parsing (still reads .gitnexusignore)\n GITNEXUS_MAX_FILE_SIZE=N Override large-file skip threshold (KB). Default 512, max 32768.\n GITNEXUS_ANALYZER_IDENTITY_CACHE_DIR=/absolute/protected/dir Operator-trusted persistent analyzer identity cache; must pre-exist, be outside package/build roots, and contain no symlink/junction components.\n GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=N Worker idle timeout in milliseconds. Default 30000.\n GITNEXUS_WAL_CHECKPOINT_THRESHOLD=N LadybugDB WAL auto-checkpoint threshold in bytes (default 67108864 = 64 MiB; -1 keeps Ladybug stock ~16 MiB).\n GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES=N Worker job byte budget. Default 8388608.\n GITNEXUS_WORKER_POOL_SIZE=N Parse worker count override. Default cores-1 capped at 16.\n GITNEXUS_PARSE_CHUNK_CONCURRENCY=N Concurrent in-flight parse chunks. Default 2.\n GITNEXUS_WORKER_MAX_RESPAWNS_PER_SLOT=N Max replacement spawns per slot before drop. Default 3.\n GITNEXUS_WORKER_MAX_CUMULATIVE_TIMEOUT_MS=N Total retry wall-time per job. Default 5x sub-batch timeout.\n GITNEXUS_WORKER_CONSECUTIVE_FAILURE_THRESHOLD=N Per-slot deaths to trip circuit breaker. Default max(3, poolSize).\n GITNEXUS_WORKER_SHUTDOWN_DRAIN_MS=N Max wait at pool shutdown for a retired worker still inside native code (terminated at its next safe point instead of aborting the process). Default 30000.\n GITNEXUS_CPP_CAPTURE_BUDGET_MS=N Per-file wall-clock budget for C++ capture extraction; on breach the file keeps partial captures with a warning. Default 20000.\n GITNEXUS_EMBEDDING_THREADS=N Limit local ONNX CPU threads for --embeddings.\n GITNEXUS_SEMANTIC_EXACT_SCAN_LIMIT=N Max embedding chunks for exact-scan fallback. Default 10000.\n GITNEXUS_VECTOR_MAX_DISTANCE=N Max accepted semantic/vector cosine distance (0 < N <= 2; higher values clamp to 2). Default 0.6 for MCP, 0.5 elsewhere.\n\nFlags override the corresponding env vars when both are provided.\n\nTip: `.gitnexusignore` supports `.gitignore`-style negation. Add e.g.\n `!__tests__/` to index a directory that is auto-filtered by default (#771).',
|
||||
'\nEnvironment variables:\n GITNEXUS_NO_GITIGNORE=1 Skip .gitignore parsing (still reads .gitnexusignore)\n GITNEXUS_MAX_FILE_SIZE=N Override large-file skip threshold (KB). Default 512, max 32768.\n GITNEXUS_ANALYZER_IDENTITY_CACHE_DIR=/absolute/protected/dir Operator-trusted persistent analyzer identity cache; must pre-exist, be outside package/build roots, and contain no symlink/junction components.\n GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=N Worker idle timeout in milliseconds. Default 30000.\n GITNEXUS_WAL_CHECKPOINT_THRESHOLD=N LadybugDB WAL auto-checkpoint threshold in bytes (default 67108864 = 64 MiB; -1 keeps Ladybug stock ~16 MiB).\n GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES=N Worker job byte budget. Default 8388608.\n GITNEXUS_WORKER_POOL_SIZE=N Parse worker count override. Default cores-1 capped at 16.\n GITNEXUS_PARSE_CHUNK_CONCURRENCY=N Concurrent in-flight parse chunks. Default 2.\n GITNEXUS_WORKER_MAX_RESPAWNS_PER_SLOT=N Max replacement spawns per slot before drop. Default 3.\n GITNEXUS_WORKER_MAX_CUMULATIVE_TIMEOUT_MS=N Total retry wall-time per job. Default 5x sub-batch timeout.\n GITNEXUS_WORKER_CONSECUTIVE_FAILURE_THRESHOLD=N Per-slot deaths to trip circuit breaker. Default max(3, poolSize).\n GITNEXUS_WORKER_SHUTDOWN_DRAIN_MS=N Max wait at pool shutdown for a retired worker still inside native code (terminated at its next safe point instead of aborting the process). Default 30000.\n GITNEXUS_CPP_CAPTURE_BUDGET_MS=N Per-file wall-clock budget for C++ capture extraction; on breach the file keeps partial captures with a warning. Default 20000.\n GITNEXUS_EMBEDDING_THREADS=N Limit local ONNX CPU threads for --embeddings.\n GITNEXUS_EMBEDDING_RETRY_TIMEOUTS=1 Retry per-attempt HTTP embedding timeouts through GITNEXUS_EMBEDDING_MAX_ATTEMPTS (default off; timeouts stay terminal).\n GITNEXUS_SEMANTIC_EXACT_SCAN_LIMIT=N Max embedding chunks for exact-scan fallback. Default 10000.\n GITNEXUS_VECTOR_MAX_DISTANCE=N Max accepted semantic/vector cosine distance (0 < N <= 2; higher values clamp to 2). Default 0.6 for MCP, 0.5 elsewhere.\n\nFlags override the corresponding env vars when both are provided.\n\nTip: `.gitnexusignore` supports `.gitignore`-style negation. Add e.g.\n `!__tests__/` to index a directory that is auto-filtered by default (#771).',
|
||||
} as const;
|
||||
|
|
|
|||
|
|
@ -119,8 +119,10 @@ export const zhCN = {
|
|||
'doctor.labels.onnx': 'ONNX:',
|
||||
'doctor.labels.graphStore': '图存储:',
|
||||
'doctor.labels.fullTextSearch': '全文搜索:',
|
||||
'doctor.labels.vectorIndex': '向量索引:',
|
||||
'doctor.labels.semanticMode': '语义模式:',
|
||||
'doctor.labels.vectorIndex': 'VECTOR 扩展:',
|
||||
'doctor.labels.semanticMode': '语义支持:',
|
||||
'doctor.vectorCapability.indexUnverified': '支持向量索引(未检查仓库索引)',
|
||||
'doctor.vectorCapability.exactScanOnly': '仅精确扫描(VECTOR 扩展不可用)',
|
||||
'doctor.labels.exactScanLimit': '精确扫描上限:',
|
||||
'doctor.labels.note': '说明:',
|
||||
'doctor.labels.backend': '后端:',
|
||||
|
|
@ -162,6 +164,8 @@ export const zhCN = {
|
|||
'error.watch.ambiguous':
|
||||
'`gitnexus watch` 含义不明确。\n 本地工作区增量索引:gitnexus analyze --watch\n 定时远程 clone/pull 并分析:gitnexus auto-sync start\n',
|
||||
'help.command.analyze.description': '索引仓库(完整分析)',
|
||||
'help.command.embeddings.sync.description':
|
||||
'向现有索引添加缺失的嵌入,并定期保存检查点以安全续跑',
|
||||
'help.command.index.description': '将现有 .gitnexus/ 文件夹注册到全局注册表(无需重新分析)',
|
||||
'help.command.serve.description': '启动供 Web UI 连接的本地 HTTP 服务器',
|
||||
'help.command.mcp.description':
|
||||
|
|
@ -327,5 +331,5 @@ export const zhCN = {
|
|||
'help.identityCache.environment':
|
||||
'\n分析器身份缓存:\n GITNEXUS_ANALYZER_IDENTITY_CACHE_DIR=/absolute/protected/dir\n 由操作员明确信任的持久缓存,用于跨进程快速查询状态。目录必须预先存在、位于 GitNexus 包/构建根目录之外,且路径中不得包含符号链接或 junction。缺少 POSIX 所有权 API 的平台默认保持故障关闭。',
|
||||
'help.analyze.environment':
|
||||
'\n环境变量:\n GITNEXUS_NO_GITIGNORE=1 跳过 .gitignore 解析(仍读取 .gitnexusignore)\n GITNEXUS_MAX_FILE_SIZE=N 覆盖大文件跳过阈值(KB)。默认 512,最大 32768。\n GITNEXUS_ANALYZER_IDENTITY_CACHE_DIR=/absolute/protected/dir 由操作员明确信任的持久分析器身份缓存;目录必须预先存在、位于包/构建根目录之外,且路径中不得包含符号链接或 junction。\n GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=N Worker 空闲超时(毫秒)。默认 30000。\n GITNEXUS_WAL_CHECKPOINT_THRESHOLD=N LadybugDB WAL 自动 checkpoint 阈值(字节,默认 67108864 = 64 MiB;-1 保持 Ladybug 默认约 16 MiB)。\n GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES=N Worker 作业字节预算。默认 8388608。\n GITNEXUS_WORKER_POOL_SIZE=N 解析 worker 数量覆盖值。默认 cores-1,最多 16。\n GITNEXUS_PARSE_CHUNK_CONCURRENCY=N 并发进行中的解析分块数。默认 2。\n GITNEXUS_WORKER_MAX_RESPAWNS_PER_SLOT=N 每个 slot 丢弃前允许的最大替换进程数。默认 3。\n GITNEXUS_WORKER_MAX_CUMULATIVE_TIMEOUT_MS=N 每个作业的总重试墙钟时间。默认 5 倍子批次超时。\n GITNEXUS_WORKER_CONSECUTIVE_FAILURE_THRESHOLD=N 每个 slot 触发熔断的死亡次数。默认 max(3, poolSize)。\n GITNEXUS_WORKER_SHUTDOWN_DRAIN_MS=N 线程池关闭时等待仍在原生代码中的已退役 worker 的最长时间(到达安全点后再终止,避免进程级 abort)。默认 30000。\n GITNEXUS_CPP_CAPTURE_BUDGET_MS=N C++ 捕获提取的每文件墙钟预算;超出后该文件保留部分捕获并输出警告。默认 20000。\n GITNEXUS_EMBEDDING_THREADS=N 限制 --embeddings 的本地 ONNX CPU 线程数。\n GITNEXUS_SEMANTIC_EXACT_SCAN_LIMIT=N exact-scan 回退的最大嵌入分块数。默认 10000。\n GITNEXUS_VECTOR_MAX_DISTANCE=N 语义/向量搜索接受的最大余弦距离(0 < N <= 2;超出则钳制为 2)。MCP 默认 0.6,其他路径默认 0.5。\n\n当参数和对应环境变量同时提供时,参数优先。\n\n提示:`.gitnexusignore` 支持 `.gitignore` 风格的取反。比如添加\n `!__tests__/` 可以索引默认自动过滤的目录(#771)。',
|
||||
'\n环境变量:\n GITNEXUS_NO_GITIGNORE=1 跳过 .gitignore 解析(仍读取 .gitnexusignore)\n GITNEXUS_MAX_FILE_SIZE=N 覆盖大文件跳过阈值(KB)。默认 512,最大 32768。\n GITNEXUS_ANALYZER_IDENTITY_CACHE_DIR=/absolute/protected/dir 由操作员明确信任的持久分析器身份缓存;目录必须预先存在、位于包/构建根目录之外,且路径中不得包含符号链接或 junction。\n GITNEXUS_WORKER_SUB_BATCH_TIMEOUT_MS=N Worker 空闲超时(毫秒)。默认 30000。\n GITNEXUS_WAL_CHECKPOINT_THRESHOLD=N LadybugDB WAL 自动 checkpoint 阈值(字节,默认 67108864 = 64 MiB;-1 保持 Ladybug 默认约 16 MiB)。\n GITNEXUS_WORKER_SUB_BATCH_MAX_BYTES=N Worker 作业字节预算。默认 8388608。\n GITNEXUS_WORKER_POOL_SIZE=N 解析 worker 数量覆盖值。默认 cores-1,最多 16。\n GITNEXUS_PARSE_CHUNK_CONCURRENCY=N 并发进行中的解析分块数。默认 2。\n GITNEXUS_WORKER_MAX_RESPAWNS_PER_SLOT=N 每个 slot 丢弃前允许的最大替换进程数。默认 3。\n GITNEXUS_WORKER_MAX_CUMULATIVE_TIMEOUT_MS=N 每个作业的总重试墙钟时间。默认 5 倍子批次超时。\n GITNEXUS_WORKER_CONSECUTIVE_FAILURE_THRESHOLD=N 每个 slot 触发熔断的死亡次数。默认 max(3, poolSize)。\n GITNEXUS_WORKER_SHUTDOWN_DRAIN_MS=N 线程池关闭时等待仍在原生代码中的已退役 worker 的最长时间(到达安全点后再终止,避免进程级 abort)。默认 30000。\n GITNEXUS_CPP_CAPTURE_BUDGET_MS=N C++ 捕获提取的每文件墙钟预算;超出后该文件保留部分捕获并输出警告。默认 20000。\n GITNEXUS_EMBEDDING_THREADS=N 限制 --embeddings 的本地 ONNX CPU 线程数。\n GITNEXUS_EMBEDDING_RETRY_TIMEOUTS=1 将单次 HTTP 嵌入超时纳入 GITNEXUS_EMBEDDING_MAX_ATTEMPTS 重试(默认关闭,超时仍为终止错误)。\n GITNEXUS_SEMANTIC_EXACT_SCAN_LIMIT=N exact-scan 回退的最大嵌入分块数。默认 10000。\n GITNEXUS_VECTOR_MAX_DISTANCE=N 语义/向量搜索接受的最大余弦距离(0 < N <= 2;超出则钳制为 2)。MCP 默认 0.6,其他路径默认 0.5。\n\n当参数和对应环境变量同时提供时,参数优先。\n\n提示:`.gitnexusignore` 支持 `.gitignore` 风格的取反。比如添加\n `!__tests__/` 可以索引默认自动过滤的目录(#771)。',
|
||||
} satisfies EnglishMessages;
|
||||
|
|
|
|||
|
|
@ -304,15 +304,13 @@ program
|
|||
.description('Install the latest published GitNexus globally (`npm i -g gitnexus@<x.y.z>`).')
|
||||
.action(createLazyAction(() => import('./update.js'), 'updateCommand'));
|
||||
|
||||
program
|
||||
const embeddings = program
|
||||
.command('embeddings')
|
||||
.description('Manage the on-demand local embedding runtime')
|
||||
.description(t('help.command.embeddings.description'));
|
||||
|
||||
embeddings
|
||||
.command('install')
|
||||
.description(
|
||||
'Install the local embedding stack (@huggingface/transformers + onnxruntime-node) on demand. ' +
|
||||
'Heals installs where npm skipped the optional packages (e.g. behind an HTTP proxy, #2370). ' +
|
||||
'Downloads only from your configured npm registry — mirrors and proxies apply.',
|
||||
)
|
||||
.description(t('help.command.embeddings.install.description'))
|
||||
.option(
|
||||
'--cuda',
|
||||
"Also download the CUDA GPU binaries (runs onnxruntime-node's NuGet postinstall; " +
|
||||
|
|
@ -321,6 +319,12 @@ program
|
|||
.option('--force', 'Install into the runtime prefix even when the stack already resolves')
|
||||
.action(createLazyAction(() => import('./embeddings.js'), 'embeddingsInstallCommand'));
|
||||
|
||||
embeddings
|
||||
.command('sync [path]')
|
||||
.description(t('help.command.embeddings.sync.description'))
|
||||
.addHelpText('after', () => t('help.analyze.environment'))
|
||||
.action(createLbugLazyAction(() => import('./embeddings-sync.js'), 'embeddingsSyncCommand'));
|
||||
|
||||
program
|
||||
.command('clean')
|
||||
.description('Delete GitNexus index for current repo')
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ import {
|
|||
JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE,
|
||||
SPRING_CONFIG_BINDINGS_FEATURE,
|
||||
} from './ingestion/languages/java/analysis-features.js';
|
||||
import { OBJECTIVE_C_PROVIDER_FEATURE } from './ingestion/languages/objective-c/analysis-features.js';
|
||||
|
||||
/** Production registry of independently versioned analysis capabilities. */
|
||||
export const ANALYSIS_FEATURES = [
|
||||
|
|
@ -23,4 +24,5 @@ export const ANALYSIS_FEATURES = [
|
|||
SPRING_CONFIG_BINDINGS_FEATURE,
|
||||
JAVA_ENUM_INTERFACE_HERITAGE_FEATURE,
|
||||
JAVA_RECORD_COMPONENT_ACCESSORS_FEATURE,
|
||||
OBJECTIVE_C_PROVIDER_FEATURE,
|
||||
] as const;
|
||||
|
|
|
|||
|
|
@ -4,14 +4,13 @@
|
|||
* used by both chunker.ts and structural-extractor.ts.
|
||||
*/
|
||||
|
||||
import { getLanguageFromFilename } from 'gitnexus-shared';
|
||||
import {
|
||||
createParserForLanguage,
|
||||
isLanguageAvailable,
|
||||
resolveLanguageKey,
|
||||
} from '../tree-sitter/parser-loader.js';
|
||||
import { parseSourceSafe } from '../tree-sitter/safe-parse.js';
|
||||
import { getProvider } from '../ingestion/languages/index.js';
|
||||
import { getLanguageForFileContent, getProvider } from '../ingestion/languages/index.js';
|
||||
|
||||
const parserCache = new Map<string, any>();
|
||||
|
||||
|
|
@ -20,7 +19,10 @@ const parserCache = new Map<string, any>();
|
|||
* Returns null if language is unavailable or parsing fails.
|
||||
*/
|
||||
export const ensureAndParse = async (content: string, filePath: string): Promise<any | null> => {
|
||||
const language = getLanguageFromFilename(filePath);
|
||||
// Same classifier as ingest. Filename-only maps `.h` → C++, so Objective-C
|
||||
// headers (and method snippets from those headers) would parse with the
|
||||
// wrong grammar and miss class_interface / protocol_declaration / methods.
|
||||
const language = getLanguageForFileContent(filePath, content);
|
||||
if (!language) return null;
|
||||
if (!isLanguageAvailable(language)) return null;
|
||||
|
||||
|
|
@ -100,6 +102,9 @@ export const findDeclarationNode = (root: any): any | null => {
|
|||
'struct_item',
|
||||
'interface_declaration',
|
||||
'interface_definition',
|
||||
'protocol_declaration', // Objective-C protocol
|
||||
'class_interface', // Objective-C class, category, or extension
|
||||
'class_implementation', // Objective-C implementation
|
||||
'enum_declaration',
|
||||
'enum_item',
|
||||
'type_declaration', // Go: type X struct
|
||||
|
|
|
|||
|
|
@ -145,9 +145,35 @@ const DECLARATION_BODY_NODE_TYPES = new Set([
|
|||
'class_body',
|
||||
'object_type',
|
||||
'declaration_list',
|
||||
'implementation_definition',
|
||||
'interface_body',
|
||||
]);
|
||||
|
||||
const DIRECT_MEMBER_DECLARATION_TYPES = new Set([
|
||||
'protocol_declaration',
|
||||
'class_interface',
|
||||
// tree-sitter-objc exposes each implementation_definition directly under
|
||||
// class_implementation, rather than grouping them in a shared body node.
|
||||
'class_implementation',
|
||||
]);
|
||||
|
||||
const DIRECT_MEMBER_HEADER_NODE_TYPES = new Set([
|
||||
'identifier',
|
||||
'parameterized_arguments',
|
||||
'protocol_reference_list',
|
||||
// tree-sitter-objc `_type_params` hides itself and exposes this named child
|
||||
// for `(T)` generics and category-shaped argument lists.
|
||||
'generic_arguments',
|
||||
// `_class_interface_header` / `_class_implementation_header` expose these
|
||||
// named children before members (`NS_ROOT_CLASS @interface …`).
|
||||
'attribute_declaration',
|
||||
'attribute_specifier',
|
||||
'availability_attribute_specifier',
|
||||
'ms_declspec_modifier',
|
||||
'storage_class_specifier',
|
||||
'type_qualifier',
|
||||
]);
|
||||
|
||||
const FIELD_LIKE_MEMBER_TYPES = new Set([
|
||||
'field_definition',
|
||||
'public_field_definition',
|
||||
|
|
@ -157,8 +183,18 @@ const FIELD_LIKE_MEMBER_TYPES = new Set([
|
|||
'lexical_declaration',
|
||||
'pair',
|
||||
'enum_assignment',
|
||||
// tree-sitter-objc wraps each ivar as `instance_variable`, not field_definition.
|
||||
'instance_variable',
|
||||
]);
|
||||
|
||||
const DECLARATION_MEMBER_WRAPPER_TYPES = new Set([
|
||||
'qualified_protocol_interface_declaration',
|
||||
'instance_variables',
|
||||
]);
|
||||
|
||||
/** Named prefixes the ObjC grammar allows immediately before each ivar. */
|
||||
const IVAR_ATTRIBUTE_PREFIX_TYPES = new Set(['attribute_specifier', 'attribute_declaration']);
|
||||
|
||||
const declarationChunk = async (
|
||||
content: string,
|
||||
filePath: string,
|
||||
|
|
@ -337,6 +373,8 @@ const getDeclarationBodyNode = (node: any): any | null => {
|
|||
const bodyNode = node.childForFieldName?.('body');
|
||||
if (bodyNode) return bodyNode;
|
||||
|
||||
if (DIRECT_MEMBER_DECLARATION_TYPES.has(node.type)) return node;
|
||||
|
||||
for (let i = 0; i < node.namedChildCount; i++) {
|
||||
const child = node.namedChild(i);
|
||||
if (!child) continue;
|
||||
|
|
@ -352,15 +390,43 @@ const collectDeclarationUnits = (
|
|||
): Array<{ startIndex: number; endIndex: number }> => {
|
||||
const members: Array<{ startIndex: number; endIndex: number; groupable: boolean }> = [];
|
||||
|
||||
for (let i = 0; i < bodyNode.namedChildCount; i++) {
|
||||
const child = bodyNode.namedChild(i);
|
||||
if (!child) continue;
|
||||
members.push({
|
||||
startIndex: child.startIndex,
|
||||
endIndex: child.endIndex,
|
||||
groupable: groupFields && FIELD_LIKE_MEMBER_TYPES.has(child.type),
|
||||
});
|
||||
}
|
||||
const collectMembers = (
|
||||
node: any,
|
||||
skipHeaderChildren: boolean,
|
||||
includeNodePrefixOnFirstMember = false,
|
||||
): void => {
|
||||
const firstMemberIndex = members.length;
|
||||
let ivarAttributePrefixStart: number | undefined;
|
||||
for (let i = 0; i < node.namedChildCount; i++) {
|
||||
const child = node.namedChild(i);
|
||||
if (!child) continue;
|
||||
if (DECLARATION_MEMBER_WRAPPER_TYPES.has(child.type)) {
|
||||
collectMembers(child, false, true);
|
||||
continue;
|
||||
}
|
||||
if (skipHeaderChildren && DIRECT_MEMBER_HEADER_NODE_TYPES.has(child.type)) continue;
|
||||
if (node.type === 'instance_variables' && IVAR_ATTRIBUTE_PREFIX_TYPES.has(child.type)) {
|
||||
ivarAttributePrefixStart ??= child.startIndex;
|
||||
continue;
|
||||
}
|
||||
members.push({
|
||||
startIndex: ivarAttributePrefixStart ?? child.startIndex,
|
||||
endIndex: child.endIndex,
|
||||
groupable: groupFields && FIELD_LIKE_MEMBER_TYPES.has(child.type),
|
||||
});
|
||||
ivarAttributePrefixStart = undefined;
|
||||
}
|
||||
|
||||
const firstMember = members[firstMemberIndex];
|
||||
if (includeNodePrefixOnFirstMember && firstMember) {
|
||||
firstMember.startIndex = node.startIndex;
|
||||
if (node.type === 'instance_variables') {
|
||||
members[members.length - 1].endIndex = node.endIndex;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
collectMembers(bodyNode, DIRECT_MEMBER_DECLARATION_TYPES.has(bodyNode.type));
|
||||
|
||||
if (members.length === 0) return [];
|
||||
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ const ensureVectorExtensionAvailable = async (): Promise<boolean> => {
|
|||
* invalidate existing vectors, such as metadata/header shape changes,
|
||||
* structural container context changes, or preceding-context formatting rules.
|
||||
*/
|
||||
export const EMBEDDING_TEXT_VERSION = 'v4';
|
||||
export const EMBEDDING_TEXT_VERSION = 'v5';
|
||||
|
||||
/**
|
||||
* Compute a stable content fingerprint for an embeddable node.
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ interface HttpConfig {
|
|||
retryCapMs: number;
|
||||
minIntervalMs: number;
|
||||
timeoutMs: number;
|
||||
retryTimeouts: boolean;
|
||||
requestDimensions?: number;
|
||||
}
|
||||
|
||||
|
|
@ -202,6 +203,7 @@ const readConfig = (): HttpConfig | null => {
|
|||
DEFAULT_HTTP_TIMEOUT_MS,
|
||||
MAX_HTTP_TIMEOUT_MS,
|
||||
),
|
||||
retryTimeouts: parseNonNegativeIntegerEnv('GITNEXUS_EMBEDDING_RETRY_TIMEOUTS', 0, 1) === 1,
|
||||
requestDimensions,
|
||||
};
|
||||
};
|
||||
|
|
@ -338,6 +340,36 @@ class RetryableEmbeddingBodyError extends Error {
|
|||
}
|
||||
}
|
||||
|
||||
class RetryableEmbeddingTimeoutError extends Error {
|
||||
constructor(
|
||||
readonly timeoutMs: number,
|
||||
options?: { cause?: unknown },
|
||||
) {
|
||||
super(
|
||||
`Embedding request timed out after ${timeoutMs}ms`,
|
||||
options?.cause !== undefined ? { cause: options.cause } : undefined,
|
||||
);
|
||||
this.name = 'RetryableEmbeddingTimeoutError';
|
||||
}
|
||||
}
|
||||
|
||||
/** Re-wrap an opt-in TimeoutError so `resilientFetch` retries it. Abort stays terminal. */
|
||||
const throwIfRetryableTimeout = (
|
||||
err: unknown,
|
||||
retryTimeouts: boolean,
|
||||
callerAborted: boolean | undefined,
|
||||
timeoutMs: number,
|
||||
): void => {
|
||||
if (
|
||||
retryTimeouts &&
|
||||
!callerAborted &&
|
||||
isTerminalNetworkError(err) &&
|
||||
err.name === 'TimeoutError'
|
||||
) {
|
||||
throw new RetryableEmbeddingTimeoutError(timeoutMs, { cause: err });
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Build the message for a 2xx body carrying the wrong number of vectors.
|
||||
*
|
||||
|
|
@ -384,6 +416,7 @@ const httpEmbedBatch = async (
|
|||
retryCapMs = HTTP_RETRY_CAP_MS,
|
||||
minIntervalMs = 0,
|
||||
timeoutMs = DEFAULT_HTTP_TIMEOUT_MS,
|
||||
retryTimeouts = false,
|
||||
): Promise<EmbeddingItem[]> => {
|
||||
const requestBody: { input: string[]; model: string; dimensions?: number } = {
|
||||
input: batch,
|
||||
|
|
@ -428,7 +461,13 @@ const httpEmbedBatch = async (
|
|||
const signal = requestOptions.signal
|
||||
? AbortSignal.any([requestOptions.signal, timeoutSignal])
|
||||
: timeoutSignal;
|
||||
const attemptResp = await globalThis.fetch(input, { ...init, signal });
|
||||
let attemptResp: Response;
|
||||
try {
|
||||
attemptResp = await globalThis.fetch(input, { ...init, signal });
|
||||
} catch (err) {
|
||||
throwIfRetryableTimeout(err, retryTimeouts, requestOptions.signal?.aborted, timeoutMs);
|
||||
throw err;
|
||||
}
|
||||
// Non-OK bodies are none of our business: hand the response straight
|
||||
// back so `resilientFetch` keeps classifying 4xx/5xx/429 unchanged.
|
||||
if (!attemptResp.ok) return attemptResp;
|
||||
|
|
@ -447,15 +486,19 @@ const httpEmbedBatch = async (
|
|||
// Not every `.json()` rejection is a parse error: the per-attempt
|
||||
// signal (`AbortSignal.any([caller, AbortSignal.timeout(...)])`) is
|
||||
// wired to the body stream, so a stalled body rejects with the abort
|
||||
// reason. Re-raise those untouched — `isTerminalNetworkError` is
|
||||
// `resilientFetch`'s own predicate, so this test agrees with
|
||||
// `classifyOutcome` by construction. Wrapping one would flip its
|
||||
// verdict from `terminal-network` (returned without retry AND
|
||||
// without touching the breaker, via `recordNeutral()`) to
|
||||
// `retryable-network` (retried, then `breaker.recordFailure()`): the
|
||||
// same timeout would take 3 attempts instead of 1, count toward the
|
||||
// process-global `embeddings-http` breaker, and reach the operator as
|
||||
// "unparseable response" so they never reach for the timeout knob.
|
||||
// reason. Re-raise AbortError (and TimeoutError when retry is off)
|
||||
// untouched — `isTerminalNetworkError` is `resilientFetch`'s own
|
||||
// predicate, so this test agrees with `classifyOutcome` by
|
||||
// construction. Wrapping one would flip its verdict from
|
||||
// `terminal-network` (returned without retry AND without touching
|
||||
// the breaker, via `recordNeutral()`) to `retryable-network`
|
||||
// (retried, then `breaker.recordFailure()`): the same timeout would
|
||||
// take 3 attempts instead of 1, count toward the process-global
|
||||
// `embeddings-http` breaker, and reach the operator as "unparseable
|
||||
// response" so they never reach for the timeout knob.
|
||||
// Opt-in `GITNEXUS_EMBEDDING_RETRY_TIMEOUTS=1` is the exception:
|
||||
// TimeoutError is re-wrapped so the existing retry loop can retry it.
|
||||
throwIfRetryableTimeout(err, retryTimeouts, requestOptions.signal?.aborted, timeoutMs);
|
||||
if (isTerminalNetworkError(err)) throw err;
|
||||
throw new RetryableEmbeddingBodyError(unparseableMessage(), { cause: err });
|
||||
}
|
||||
|
|
@ -503,6 +546,12 @@ const httpEmbedBatch = async (
|
|||
if (err instanceof RetryableEmbeddingBodyError) {
|
||||
throw new HttpEmbeddingError(err.terminalMessage, { cause: err.cause });
|
||||
}
|
||||
if (err instanceof RetryableEmbeddingTimeoutError) {
|
||||
throw new HttpEmbeddingError(
|
||||
`${err.message} after ${maxAttempts} attempt(s) (${safeUrl(url)}, batch ${batchIndex})`,
|
||||
{ cause: err.cause },
|
||||
);
|
||||
}
|
||||
if (err instanceof CircuitOpenError) {
|
||||
throw new HttpEmbeddingError(
|
||||
`Embedding endpoint circuit open (${safeUrl(url)}, batch ${batchIndex}): retry in ${Math.ceil(err.retryAfterMs / 1000)}s`,
|
||||
|
|
@ -580,6 +629,7 @@ export const httpEmbed = async (
|
|||
config.retryCapMs,
|
||||
config.minIntervalMs,
|
||||
config.timeoutMs,
|
||||
config.retryTimeouts,
|
||||
);
|
||||
|
||||
// Defensive backstop, deliberately kept: `httpEmbedBatch` now rejects a
|
||||
|
|
@ -655,6 +705,7 @@ export const httpEmbedQuery = async (
|
|||
config.retryCapMs,
|
||||
config.minIntervalMs,
|
||||
config.timeoutMs,
|
||||
config.retryTimeouts,
|
||||
);
|
||||
// Defensive backstop like the `httpEmbed` one above: an empty `data` array is
|
||||
// now a cardinality mismatch (0 vectors for 1 text) rejected and retried
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
* to extract method and field names for embedding text generation.
|
||||
*/
|
||||
|
||||
import { getProviderForFile } from '../ingestion/languages/index.js';
|
||||
import { getProviderForFileContent } from '../ingestion/languages/index.js';
|
||||
import type { MethodExtractorContext, ExtractedMethods } from '../ingestion/method-types.js';
|
||||
import type { FieldExtractorContext, ExtractedFields } from '../ingestion/field-types.js';
|
||||
import type { LanguageProvider } from '../ingestion/language-provider.js';
|
||||
|
|
@ -32,7 +32,7 @@ export const extractStructuralNames = async (
|
|||
content: string,
|
||||
filePath: string,
|
||||
): Promise<StructuralNames> => {
|
||||
const provider = getProviderForFile(filePath);
|
||||
const provider = getProviderForFileContent(filePath, content);
|
||||
if (!provider) return { methodNames: [], fieldNames: [] };
|
||||
|
||||
const tree = await ensureAndParse(content, filePath);
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@ export const LABEL_FUNCTION = 'Function' as const;
|
|||
export const LABEL_METHOD = 'Method' as const;
|
||||
export const LABEL_CONSTRUCTOR = 'Constructor' as const;
|
||||
export const LABEL_CLASS = 'Class' as const;
|
||||
export const LABEL_PROTOCOL = 'Protocol' as const;
|
||||
export const LABEL_CATEGORY = 'Category' as const;
|
||||
export const LABEL_INTERFACE = 'Interface' as const;
|
||||
export const LABEL_STRUCT = 'Struct' as const;
|
||||
export const LABEL_ENUM = 'Enum' as const;
|
||||
|
|
@ -53,6 +55,8 @@ export const CHUNKABLE_LABELS = [
|
|||
LABEL_METHOD,
|
||||
LABEL_CONSTRUCTOR,
|
||||
LABEL_CLASS,
|
||||
LABEL_PROTOCOL,
|
||||
LABEL_CATEGORY,
|
||||
LABEL_INTERFACE,
|
||||
LABEL_STRUCT,
|
||||
LABEL_ENUM,
|
||||
|
|
@ -165,6 +169,20 @@ export const CHUNKING_RULES: Readonly<Partial<Record<ChunkableLabel, ChunkingRul
|
|||
groupFields: false,
|
||||
structuralTextMode: STRUCTURAL_TEXT_MODE_DECLARATION,
|
||||
},
|
||||
[LABEL_PROTOCOL]: {
|
||||
mode: CHUNK_MODE_AST_DECLARATION,
|
||||
includePrefix: true,
|
||||
includeSuffix: false,
|
||||
groupFields: false,
|
||||
structuralTextMode: STRUCTURAL_TEXT_MODE_NONE,
|
||||
},
|
||||
[LABEL_CATEGORY]: {
|
||||
mode: CHUNK_MODE_AST_DECLARATION,
|
||||
includePrefix: true,
|
||||
includeSuffix: false,
|
||||
groupFields: true,
|
||||
structuralTextMode: STRUCTURAL_TEXT_MODE_NONE,
|
||||
},
|
||||
[LABEL_STRUCT]: {
|
||||
mode: CHUNK_MODE_AST_DECLARATION,
|
||||
includePrefix: true,
|
||||
|
|
|
|||
|
|
@ -11,6 +11,13 @@ import { findGitRootByDotGit, getCurrentCommit, getRemoteUrl } from '../storage/
|
|||
|
||||
const execFileAsync = promisify(execFile);
|
||||
|
||||
/**
|
||||
* Ceiling for one `git rev-list` staleness probe. Generous for the local
|
||||
* history walk this is, and short enough that an unresponsive working tree
|
||||
* degrades to "not stale" quickly rather than holding a request open.
|
||||
*/
|
||||
const STALENESS_TIMEOUT_MS = 5_000;
|
||||
|
||||
export interface StalenessInfo {
|
||||
isStale: boolean;
|
||||
commitsBehind: number;
|
||||
|
|
@ -61,6 +68,14 @@ export async function checkStalenessAsync(
|
|||
cwd: repoPath,
|
||||
encoding: 'utf-8',
|
||||
windowsHide: true,
|
||||
// The catch below fails closed on every git ERROR, but a hang is not an
|
||||
// error — it is silence, and without a bound this await never settles.
|
||||
// A working tree on a disconnected network mount or behind a stuck lock
|
||||
// does exactly that, and `/api/repos` fans this out once per registered
|
||||
// repo, so one unreachable mount could hold the whole listing open
|
||||
// (#3232 review). The timeout kills the child and rejects, which routes
|
||||
// a hang into the same fail-closed "not stale" answer as a bad SHA.
|
||||
timeout: STALENESS_TIMEOUT_MS,
|
||||
});
|
||||
|
||||
const commitsBehind = parseInt(stdout.trim(), 10) || 0;
|
||||
|
|
|
|||
38
gitnexus/src/core/graph/edge-reasons.ts
Normal file
38
gitnexus/src/core/graph/edge-reasons.ts
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
/**
|
||||
* Edge `reason` values that mark a CALLS edge as a HEURISTIC GUESS rather than
|
||||
* a resolution.
|
||||
*
|
||||
* The distinction exists because an edge's `confidence` number cannot carry it.
|
||||
* `GLOBAL_NAME_FALLBACK_REASON` edges are emitted at exactly 0.5 — the same
|
||||
* number as `process-processor`'s `MIN_TRACE_CONFIDENCE` and
|
||||
* `community-processor`'s `MIN_CONFIDENCE_LARGE` — so a `confidence < 0.5`
|
||||
* gate does NOT exclude them. Anything that must exclude guesses has to read
|
||||
* the reason, which is why `KnowledgeGraph.forEachRelationshipFields` passes it
|
||||
* and why `GraphEmitSink` retains a reason column.
|
||||
*/
|
||||
|
||||
/**
|
||||
* The target was chosen because its SIMPLE NAME is unique in the workspace —
|
||||
* not because any import, scope chain, or type binding led to it.
|
||||
*
|
||||
* Emitted by the unique-simple-name tiers of the free-call fallback
|
||||
* (`pickUniqueGlobalCallable` and constructor-form `pickUniqueGlobalClass`),
|
||||
* and only for the languages that opt into `allowGlobalFreeCallFallback`. It
|
||||
* is a name collision away from being wrong and must never be presented as
|
||||
* an import-resolved edge: a reader who cannot tell the two apart has no way
|
||||
* to discount the guess.
|
||||
*/
|
||||
export const GLOBAL_NAME_FALLBACK_REASON = 'global-name-fallback';
|
||||
|
||||
/**
|
||||
* Reasons excluded from process tracing and large-graph community detection.
|
||||
*
|
||||
* Both walks exist to describe how the program actually flows. Seeding a flow
|
||||
* from a unique-name guess produces a confident-looking trace through code that
|
||||
* may never call each other, which is worse than a shorter honest trace.
|
||||
*/
|
||||
const HEURISTIC_EDGE_REASONS: ReadonlySet<string> = new Set([GLOBAL_NAME_FALLBACK_REASON]);
|
||||
|
||||
/** True when this edge's target was guessed by name rather than resolved. */
|
||||
export const isHeuristicEdgeReason = (reason: string): boolean =>
|
||||
HEURISTIC_EDGE_REASONS.has(reason);
|
||||
|
|
@ -163,9 +163,17 @@ export const createKnowledgeGraph = (): KnowledgeGraph => {
|
|||
relationshipMap.forEach(fn);
|
||||
},
|
||||
forEachRelationshipFields(
|
||||
fn: (sourceId: string, targetId: string, type: RelationshipType, confidence: number) => void,
|
||||
fn: (
|
||||
sourceId: string,
|
||||
targetId: string,
|
||||
type: RelationshipType,
|
||||
confidence: number,
|
||||
reason: string,
|
||||
) => void,
|
||||
) {
|
||||
relationshipMap.forEach((rel) => fn(rel.sourceId, rel.targetId, rel.type, rel.confidence));
|
||||
relationshipMap.forEach((rel) =>
|
||||
fn(rel.sourceId, rel.targetId, rel.type, rel.confidence, rel.reason),
|
||||
);
|
||||
},
|
||||
getNode: (id: string) => nodeMap.get(id),
|
||||
|
||||
|
|
|
|||
|
|
@ -31,14 +31,26 @@ export interface KnowledgeGraph {
|
|||
* Zero-allocation relationship scan: fields, not objects (#2680).
|
||||
*
|
||||
* The whole-graph scans (the local-symbol pruner, community detection,
|
||||
* process extraction) read only these four fields, and materializing a
|
||||
* process extraction) read only these five fields, and materializing a
|
||||
* `GraphRelationship` per edge just to read them dominates iteration cost once
|
||||
* relationships are held columnar — measured at ~90 ms per analyze on a
|
||||
* million-edge graph. Prefer this over `forEachRelationship` in any pass that
|
||||
* walks every edge and needs no other field.
|
||||
*
|
||||
* `reason` is passed because confidence alone cannot separate a heuristic
|
||||
* name guess from a resolved edge that happens to sit at the same number:
|
||||
* the global-name fallback emits at exactly the process/community threshold
|
||||
* (0.5), so the walks that must exclude it have to read the reason. See
|
||||
* `GraphEmitSink`'s reason column, added for this consumer.
|
||||
*/
|
||||
forEachRelationshipFields: (
|
||||
fn: (sourceId: string, targetId: string, type: RelationshipType, confidence: number) => void,
|
||||
fn: (
|
||||
sourceId: string,
|
||||
targetId: string,
|
||||
type: RelationshipType,
|
||||
confidence: number,
|
||||
reason: string,
|
||||
) => void,
|
||||
) => void;
|
||||
getNode: (id: string) => GraphNode | undefined;
|
||||
nodeCount: number;
|
||||
|
|
|
|||
|
|
@ -92,6 +92,134 @@ function unquote(text: string): string | null {
|
|||
return value.includes('${') ? null : value;
|
||||
}
|
||||
|
||||
const SIMPLE_TEMPLATE_ESCAPES: Record<string, string> = {
|
||||
b: '\b',
|
||||
f: '\f',
|
||||
n: '\n',
|
||||
r: '\r',
|
||||
t: '\t',
|
||||
v: '\v',
|
||||
'0': '\0',
|
||||
"'": "'",
|
||||
'"': '"',
|
||||
'\\': '\\',
|
||||
'`': '`',
|
||||
};
|
||||
|
||||
/** Graph Method `startLine` is the 0-based wrapper row (see line-base.ts). */
|
||||
function providerMemberStartLine(member: Parser.SyntaxNode): number {
|
||||
// Class-field arrows are `@declaration.property`; parse-worker falls back to
|
||||
// the `public_field_definition` wrapper (decorator row when it is a child),
|
||||
// not the initializer. Do not probe the `value` child.
|
||||
return member.startPosition.row;
|
||||
}
|
||||
|
||||
/** tree-sitter `escape_sequence.text` is the source spelling (`\\n`), not the JS value. */
|
||||
function decodeEscapeSequence(text: string): string | null {
|
||||
if (!text.startsWith('\\') || text.length < 2) return null;
|
||||
const escaped = text.slice(1);
|
||||
// Tagged-template cooked value: LineContinuation is empty; `\8`/`\9` and
|
||||
// LegacyOctalEscapeSequence (`\1`–`\7`, `\00`…) make cooked undefined.
|
||||
if (/^[\n\r\u2028\u2029]$/.test(escaped) || escaped === '\r\n') return '';
|
||||
if (/^[1-9]$/.test(escaped) || /^[0-7]{2,3}$/.test(escaped)) return null;
|
||||
if (escaped.length === 1) return SIMPLE_TEMPLATE_ESCAPES[escaped] ?? escaped;
|
||||
if (escaped[0] === 'x' && /^[0-9A-Fa-f]{2}$/.test(escaped.slice(1))) {
|
||||
return String.fromCharCode(Number.parseInt(escaped.slice(1), 16));
|
||||
}
|
||||
if (escaped.startsWith('u{') && escaped.endsWith('}')) {
|
||||
const hex = escaped.slice(2, -1);
|
||||
if (!/^[0-9A-Fa-f]{1,6}$/.test(hex)) return null;
|
||||
const codePoint = Number.parseInt(hex, 16);
|
||||
if (codePoint > 0x10ffff) return null;
|
||||
return String.fromCodePoint(codePoint);
|
||||
}
|
||||
if (escaped[0] === 'u' && /^[0-9A-Fa-f]{4}$/.test(escaped.slice(1))) {
|
||||
return String.fromCharCode(Number.parseInt(escaped.slice(1), 16));
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function substitutionIdentifier(substitution: Parser.SyntaxNode): string | null {
|
||||
if (substitution.namedChildren.length !== 1) return null;
|
||||
const expr = unwrapExpression(substitution.namedChildren[0]);
|
||||
return expr.type === 'identifier' ? expr.text : null;
|
||||
}
|
||||
|
||||
function isGraphqlTagCall(call: Parser.SyntaxNode): boolean {
|
||||
const callee = call.childForFieldName('function');
|
||||
return callee?.type === 'identifier' && callee.text === 'gql';
|
||||
}
|
||||
|
||||
function pascalCaseGraphqlName(name: string): string {
|
||||
return name
|
||||
.split(/[^A-Za-z0-9]+/)
|
||||
.filter((part) => part.length > 0)
|
||||
.map((part) => `${part[0]!.toUpperCase()}${part.slice(1)}`)
|
||||
.join('');
|
||||
}
|
||||
|
||||
type InterpolationCache = Map<string, string | null>;
|
||||
|
||||
function uniqueStaticSource(
|
||||
name: string,
|
||||
declarators: GeneratedSymbolIndex,
|
||||
resolving: Set<string>,
|
||||
cache: InterpolationCache,
|
||||
): string | null {
|
||||
if (cache.has(name)) return cache.get(name) ?? null;
|
||||
if (resolving.has(name) || resolving.size >= MAX_GRAPHQL_TRAVERSAL_DEPTH) return null;
|
||||
const values = declarators.get(name) ?? [];
|
||||
if (values.length === 0) {
|
||||
cache.set(name, null);
|
||||
return null;
|
||||
}
|
||||
resolving.add(name);
|
||||
const sources = new Set<string>();
|
||||
for (const value of values) {
|
||||
const source = staticGraphqlSource(value, declarators, resolving, cache);
|
||||
// A dynamic or unprovable sibling makes the name ambiguous — do not pick
|
||||
// the one static spelling and ignore the rest.
|
||||
if (source === null) {
|
||||
resolving.delete(name);
|
||||
cache.set(name, null);
|
||||
return null;
|
||||
}
|
||||
sources.add(source);
|
||||
}
|
||||
resolving.delete(name);
|
||||
const unique = sources.size === 1 ? [...sources][0]! : null;
|
||||
cache.set(name, unique);
|
||||
return unique;
|
||||
}
|
||||
|
||||
function interpolatedTemplateSource(
|
||||
template: Parser.SyntaxNode,
|
||||
declarators: GeneratedSymbolIndex,
|
||||
resolving: Set<string>,
|
||||
cache: InterpolationCache,
|
||||
): string | null {
|
||||
let out = '';
|
||||
for (const child of template.namedChildren) {
|
||||
if (child.type === 'string_fragment') {
|
||||
out += child.text;
|
||||
} else if (child.type === 'escape_sequence') {
|
||||
const decoded = decodeEscapeSequence(child.text);
|
||||
if (decoded === null) return null;
|
||||
out += decoded;
|
||||
} else if (child.type === 'template_substitution') {
|
||||
const name = substitutionIdentifier(child);
|
||||
if (!name) return null;
|
||||
const inlined = uniqueStaticSource(name, declarators, resolving, cache);
|
||||
if (inlined === null) return null;
|
||||
out += inlined;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
if (out.length > MAX_GRAPHQL_TOKENS) return null;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function unwrapExpression(node: Parser.SyntaxNode): Parser.SyntaxNode {
|
||||
let current = node;
|
||||
while (
|
||||
|
|
@ -214,7 +342,12 @@ function parsedDocumentProof(
|
|||
return false;
|
||||
}
|
||||
|
||||
function staticGraphqlSource(initializer: Parser.SyntaxNode): string | null {
|
||||
function staticGraphqlSource(
|
||||
initializer: Parser.SyntaxNode,
|
||||
declarators?: GeneratedSymbolIndex,
|
||||
resolving: Set<string> = new Set(),
|
||||
cache: InterpolationCache = new Map(),
|
||||
): string | null {
|
||||
const value = unwrapExpression(initializer);
|
||||
if (value.type === 'string') {
|
||||
if (value.text.startsWith('"')) {
|
||||
|
|
@ -226,11 +359,24 @@ function staticGraphqlSource(initializer: Parser.SyntaxNode): string | null {
|
|||
}
|
||||
return unquote(value.text);
|
||||
}
|
||||
if (value.type === 'template_string') return unquote(value.text);
|
||||
if (value.type === 'template_string') {
|
||||
const hasSubstitution = value.namedChildren.some(
|
||||
(child) => child.type === 'template_substitution',
|
||||
);
|
||||
if (!hasSubstitution) return unquote(value.text);
|
||||
return declarators ? interpolatedTemplateSource(value, declarators, resolving, cache) : null;
|
||||
}
|
||||
|
||||
if (value.type === 'call_expression') {
|
||||
const template = value.namedChildren.find((child) => child.type === 'template_string');
|
||||
return template ? unquote(template.text) : null;
|
||||
if (!template) return null;
|
||||
const hasSubstitution = template.namedChildren.some(
|
||||
(child) => child.type === 'template_substitution',
|
||||
);
|
||||
// Interpolated reconstruction is the cooked template. Only `gql` is
|
||||
// treated as preserving that source; String.raw / unknown tags stay fail-closed.
|
||||
if (hasSubstitution && !isGraphqlTagCall(value)) return null;
|
||||
return staticGraphqlSource(template, declarators, resolving, cache);
|
||||
}
|
||||
|
||||
if (value.type !== 'new_expression') return null;
|
||||
|
|
@ -238,7 +384,7 @@ function staticGraphqlSource(initializer: Parser.SyntaxNode): string | null {
|
|||
if (!constructor || !constructor.text.endsWith('TypedDocumentString')) return null;
|
||||
const args = value.childForFieldName('arguments');
|
||||
const first = args?.namedChildren[0];
|
||||
return first ? staticGraphqlSource(first) : null;
|
||||
return first ? staticGraphqlSource(first, declarators, resolving, cache) : null;
|
||||
}
|
||||
|
||||
export function hasGeneratedDocumentProof(
|
||||
|
|
@ -246,9 +392,10 @@ export function hasGeneratedDocumentProof(
|
|||
operationKind: GraphqlOperationKind,
|
||||
operationName: string,
|
||||
requiredFields: readonly string[],
|
||||
declarators?: GeneratedSymbolIndex,
|
||||
): boolean {
|
||||
if (!withinGeneratedAstBudget(initializer)) return false;
|
||||
const staticSource = staticGraphqlSource(initializer);
|
||||
const staticSource = staticGraphqlSource(initializer, declarators);
|
||||
if (staticSource !== null) {
|
||||
return parsedDocumentProof(staticSource, operationKind, operationName, requiredFields);
|
||||
}
|
||||
|
|
@ -430,7 +577,10 @@ function rootFields(
|
|||
|
||||
function generatedCandidates(operation: OperationDefinitionNode): string[] {
|
||||
const name = operation.name?.value;
|
||||
return name ? [`${name}Document`] : [];
|
||||
if (!name) return [];
|
||||
const exact = `${name}Document`;
|
||||
const pascal = `${pascalCaseGraphqlName(name)}Document`;
|
||||
return exact === pascal ? [exact] : [exact, pascal];
|
||||
}
|
||||
|
||||
async function generatedDocumentMatches(
|
||||
|
|
@ -450,7 +600,13 @@ async function generatedDocumentMatches(
|
|||
const index = await pendingIndex;
|
||||
const values = index?.get(symbol.name) ?? [];
|
||||
return values.some((value) =>
|
||||
hasGeneratedDocumentProof(value, operationKind, operationName, requiredFields),
|
||||
hasGeneratedDocumentProof(
|
||||
value,
|
||||
operationKind,
|
||||
operationName,
|
||||
requiredFields,
|
||||
index ?? undefined,
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -593,11 +749,7 @@ export class GraphqlExtractor implements ContractExtractor {
|
|||
await dbExecutor(RESOLVE_METHOD_QUERY, {
|
||||
name: methodName,
|
||||
filePath,
|
||||
startLine:
|
||||
member.type === 'public_field_definition'
|
||||
? (member.childForFieldName('value')?.startPosition.row ??
|
||||
member.startPosition.row) + 1
|
||||
: member.startPosition.row + 1,
|
||||
startLine: providerMemberStartLine(member),
|
||||
}),
|
||||
);
|
||||
if (!symbol) continue;
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ export interface ManifestExtractResult {
|
|||
// #2325 integration test can run the EXACT production query against a real
|
||||
// LadybugDB — a hand-copied query string in the test would silently drift
|
||||
// from this allowlist. Uses the `labels(n) IN [...]` allowlist form rather
|
||||
// than a `MATCH (n:A|B)` disjunction: this 21-label list contains the
|
||||
// than a `MATCH (n:A|B)` disjunction: this 23-label list contains the
|
||||
// reserved-keyword labels `Macro` and `Union`, and LadybugDB's parser rejects
|
||||
// a disjunction that names a reserved keyword (#2325) — which the resolver's
|
||||
// try/catch then swallowed. `labels(n) IN` has no such collision.
|
||||
|
|
@ -25,7 +25,7 @@ export interface ManifestExtractResult {
|
|||
// two would widen which nodes resolve as contract symbols and must update the
|
||||
// #2325 test, so they are intentionally kept separate for now.
|
||||
export const CUSTOM_CONTRACT_RESOLVE_QUERY = `MATCH (n)
|
||||
WHERE labels(n) IN ['Function','Method','Class','Interface','Struct','Enum','Trait','Constructor','TypeAlias','Impl','Macro','Union','Typedef','Property','Record','Delegate','Annotation','Template','Const','Static','CodeElement']
|
||||
WHERE labels(n) IN ['Function','Method','Class','Protocol','Category','Interface','Struct','Enum','Trait','Constructor','TypeAlias','Impl','Macro','Union','Typedef','Property','Record','Delegate','Annotation','Template','Const','Static','CodeElement']
|
||||
AND n.name = $symbolName
|
||||
RETURN n.id AS uid, n.name AS name, n.filePath AS filePath
|
||||
ORDER BY n.filePath ASC, n.id ASC
|
||||
|
|
|
|||
|
|
@ -6,8 +6,8 @@
|
|||
* does its own extraction, and writes directly to the graph.
|
||||
*
|
||||
* Pipeline:
|
||||
* 1. Separate programs from copybooks
|
||||
* 2. Build copybook map (name -> content)
|
||||
* 1. Separate programs from copybooks and JCL
|
||||
* 2. Index file content by path for COPY expansion
|
||||
* 3. For each program: expand COPY statements, then run regex extraction
|
||||
* 4. Map CobolRegexResults to graph nodes and relationships
|
||||
* 5. Optionally process JCL files for job-step cross-references
|
||||
|
|
@ -25,6 +25,7 @@ import {
|
|||
} from './cobol/cobol-preprocessor.js';
|
||||
import { expandCopies } from './cobol/cobol-copy-expander.js';
|
||||
import { processJclFiles } from './cobol/jcl-processor.js';
|
||||
import { resolveCobolCopyTarget } from './languages/cobol/copy-target.js';
|
||||
|
||||
import { logger } from '../logger.js';
|
||||
|
||||
|
|
@ -123,38 +124,23 @@ export const processCobol = (
|
|||
|
||||
// ── 1. Separate programs, copybooks, and JCL ───────────────────────
|
||||
const programs: CobolFile[] = [];
|
||||
const copybooks: CobolFile[] = [];
|
||||
const jclFiles: CobolFile[] = [];
|
||||
|
||||
for (const file of files) {
|
||||
const ext = path.extname(file.path).toLowerCase();
|
||||
if (JCL_EXTENSIONS.has(ext)) {
|
||||
jclFiles.push(file);
|
||||
} else if (isCopybook(file.path)) {
|
||||
copybooks.push(file);
|
||||
} else if (COBOL_EXTENSIONS.has(ext)) {
|
||||
} else if (COBOL_EXTENSIONS.has(ext) && !isCopybook(file.path)) {
|
||||
programs.push(file);
|
||||
}
|
||||
}
|
||||
|
||||
// ── 2. Build copybook map (uppercase name -> content) ──────────────
|
||||
const copybookMap = new Map<string, { content: string; path: string }>();
|
||||
for (const cb of copybooks) {
|
||||
const name = path.basename(cb.path, path.extname(cb.path)).toUpperCase();
|
||||
copybookMap.set(name, { content: cb.content, path: cb.path });
|
||||
}
|
||||
|
||||
// Build reverse lookup: path -> content for O(1) readCopy
|
||||
// Path → content for every COBOL/JCL file we ingested. Resolution picks
|
||||
// the path (#2967 / census lockstep); this map only supplies the body.
|
||||
const copybookByPath = new Map<string, string>();
|
||||
for (const [, entry] of copybookMap) {
|
||||
copybookByPath.set(entry.path, entry.content);
|
||||
for (const f of files) {
|
||||
copybookByPath.set(f.path, f.content);
|
||||
}
|
||||
|
||||
// Resolve and read callbacks for expandCopies
|
||||
const resolveCopy = (name: string): string | null => {
|
||||
const entry = copybookMap.get(name.toUpperCase());
|
||||
return entry ? entry.path : null;
|
||||
};
|
||||
// Memoize preprocessed copybook content for the duration of this
|
||||
// processCobol call. A single copybook is COPYed by many programs (and at
|
||||
// many COPY sites within a program); without this cache
|
||||
|
|
@ -196,6 +182,11 @@ export const processCobol = (
|
|||
// Preprocess: clean patch markers
|
||||
const cleaned = preprocessCobolSource(file.content);
|
||||
|
||||
// Per-program so COPY EXTERNAL in src/PROG.cbl cannot land on
|
||||
// vendor/EXTERNAL.cpy when a copybooks/ dir is present (#2967).
|
||||
const resolveCopy = (name: string): string | null =>
|
||||
resolveCobolCopyTarget(name, file.path, allPathSet);
|
||||
|
||||
// Expand COPY statements
|
||||
const { expandedContent, copyResolutions } = expandCopies(
|
||||
cleaned,
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ import { dirname, resolve } from 'node:path';
|
|||
import { Worker } from 'node:worker_threads';
|
||||
import type { GraphNode, NodeLabel } from 'gitnexus-shared';
|
||||
import { KnowledgeGraph } from '../graph/types.js';
|
||||
import { isHeuristicEdgeReason } from '../graph/edge-reasons.js';
|
||||
|
||||
const __filename = fileURLToPath(import.meta.url);
|
||||
const __dirname = dirname(__filename);
|
||||
|
|
@ -131,6 +132,18 @@ const LEIDEN_TIMEOUT_MS = 60_000;
|
|||
const ICEBUG_TIMEOUT_MS = 60_000;
|
||||
const MIN_CONFIDENCE_LARGE = 0.5;
|
||||
|
||||
/**
|
||||
* Whether a large graph's projection may include this edge.
|
||||
*
|
||||
* The confidence floor alone lets every global-name-fallback edge through — it
|
||||
* is emitted at exactly `MIN_CONFIDENCE_LARGE`, so `confidence <` never
|
||||
* excludes it. Clustering on unique-name guesses fuses unrelated areas into one
|
||||
* community, which is precisely the noise the large-graph floor exists to
|
||||
* remove, so the reason is checked too — see `graph/edge-reasons.ts`.
|
||||
*/
|
||||
const isLargeGraphEligible = (confidence: number, reason: string): boolean =>
|
||||
confidence >= MIN_CONFIDENCE_LARGE && !isHeuristicEdgeReason(reason);
|
||||
|
||||
export const resolveCommunityDetectionEngine = (
|
||||
raw = process.env[COMMUNITY_ENGINE_ENV],
|
||||
): CommunityDetectionEngine => {
|
||||
|
|
@ -300,11 +313,16 @@ export const buildCommunityProjection = (knowledgeGraph: KnowledgeGraph): Commun
|
|||
const connectedNodes = new Set<string>();
|
||||
const nodeDegree = new Map<string, number>();
|
||||
|
||||
// Field-wise scan (#2680): this walks every edge and reads only these four,
|
||||
// Field-wise scan (#2680): this walks every edge and reads only these five,
|
||||
// so taking objects would allocate one per edge for nothing.
|
||||
knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
|
||||
knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence, reason) => {
|
||||
if (!isClusteringRelationship(type) || sourceId === targetId) return;
|
||||
if (isLarge && confidence < MIN_CONFIDENCE_LARGE) return;
|
||||
// A name-guessed edge must not join two nodes into a community at ANY graph
|
||||
// size — the rationale in `graph/edge-reasons.ts` is about what the edge
|
||||
// claims, not about how many symbols surround it. Process tracing applies
|
||||
// the same reason gate unconditionally (`process-processor.ts`).
|
||||
if (isHeuristicEdgeReason(reason)) return;
|
||||
if (isLarge && !isLargeGraphEligible(confidence, reason)) return;
|
||||
|
||||
connectedNodes.add(sourceId);
|
||||
connectedNodes.add(targetId);
|
||||
|
|
@ -340,9 +358,10 @@ export const buildCommunityProjection = (knowledgeGraph: KnowledgeGraph): Commun
|
|||
const seenEdges = new Set<string>();
|
||||
const edges: Array<readonly [number, number]> = [];
|
||||
|
||||
knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence) => {
|
||||
knowledgeGraph.forEachRelationshipFields((sourceId, targetId, type, confidence, reason) => {
|
||||
if (!isClusteringRelationship(type) || sourceId === targetId) return;
|
||||
if (isLarge && confidence < MIN_CONFIDENCE_LARGE) return;
|
||||
if (isHeuristicEdgeReason(reason)) return;
|
||||
if (isLarge && !isLargeGraphEligible(confidence, reason)) return;
|
||||
|
||||
const sourceIndex = nodeIndexById.get(sourceId);
|
||||
const targetIndex = nodeIndexById.get(targetId);
|
||||
|
|
|
|||
|
|
@ -0,0 +1,40 @@
|
|||
import fs from 'fs/promises';
|
||||
import path from 'path';
|
||||
import type { SupportedLanguages } from 'gitnexus-shared';
|
||||
import { mapConcurrent } from '../../lib/utils.js';
|
||||
import { READ_CONCURRENCY } from './filesystem-walker.js';
|
||||
import { getLanguageForFileContent } from './languages/index.js';
|
||||
|
||||
/**
|
||||
* Classify files whose language cannot be determined from their extension.
|
||||
*
|
||||
* Source text is retained only for the duration of each individual read and
|
||||
* classification. The returned map deliberately contains language results,
|
||||
* not source text, so downstream phases can reuse the decision without
|
||||
* holding every candidate header in memory or rereading it to classify again.
|
||||
*/
|
||||
export async function classifyContentLanguages(
|
||||
repoPath: string,
|
||||
relativePaths: readonly string[],
|
||||
): Promise<ReadonlyMap<string, SupportedLanguages | null>> {
|
||||
const classifications = new Map<string, SupportedLanguages | null>();
|
||||
const results = await mapConcurrent(
|
||||
relativePaths,
|
||||
async (relativePath) => {
|
||||
const sourceText = await fs.readFile(path.join(repoPath, relativePath), 'utf-8');
|
||||
return {
|
||||
path: relativePath,
|
||||
language: getLanguageForFileContent(relativePath, sourceText),
|
||||
};
|
||||
},
|
||||
{ concurrency: READ_CONCURRENCY },
|
||||
);
|
||||
|
||||
// An unreadable file yields `undefined` from mapConcurrent. Leave it absent
|
||||
// so the caller retains the existing filename-based fallback behavior.
|
||||
for (const result of results) {
|
||||
if (result !== undefined) classifications.set(result.path, result.language);
|
||||
}
|
||||
|
||||
return classifications;
|
||||
}
|
||||
|
|
@ -19,7 +19,7 @@ export interface FilePath {
|
|||
path: string;
|
||||
}
|
||||
|
||||
const READ_CONCURRENCY = 32;
|
||||
export const READ_CONCURRENCY = 32;
|
||||
const ANALYZE_PROGRESS_ACTIVE_ENV = 'GITNEXUS_ANALYZE_PROGRESS_ACTIVE';
|
||||
|
||||
const DECLARATION_COMPANION_SUFFIXES = [
|
||||
|
|
|
|||
|
|
@ -200,8 +200,11 @@ function collectReferenceSites(parsedFiles: readonly ParsedFile[]) {
|
|||
*/
|
||||
function withDefaultHooks(partial: Partial<FinalizeHooks>): FinalizeHooks {
|
||||
return {
|
||||
importsBindAtLexicalScope: partial.importsBindAtLexicalScope === true,
|
||||
resolveImportTarget: partial.resolveImportTarget ?? (() => null),
|
||||
isNamespaceImport: partial.isNamespaceImport,
|
||||
wildcardCollisionIsAmbiguous: partial.wildcardCollisionIsAmbiguous === true,
|
||||
namedImportsBindTopLevelOnly: partial.namedImportsBindTopLevelOnly === true,
|
||||
expandsWildcardTo: partial.expandsWildcardTo ?? (() => []),
|
||||
mergeBindings:
|
||||
partial.mergeBindings ??
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@
|
|||
import fs from 'fs/promises';
|
||||
import path from 'path';
|
||||
import { createRequire } from 'node:module';
|
||||
import type Parser from 'tree-sitter';
|
||||
|
||||
import { isHardcodedIgnoredDirectoryAtPath } from '../../../config/ignore-service.js';
|
||||
import { logger } from '../../logger.js';
|
||||
|
|
@ -214,6 +215,8 @@ interface WorkspaceScope {
|
|||
readonly include: readonly string[];
|
||||
/** `!`-prefixed patterns, with the `!` stripped. */
|
||||
readonly exclude: readonly string[];
|
||||
readonly includeRe: readonly RegExp[];
|
||||
readonly excludeRe: readonly RegExp[];
|
||||
}
|
||||
|
||||
/** Whether `dir` (repo-relative, `''` for the root) is an admitted package. */
|
||||
|
|
@ -221,8 +224,21 @@ function admits(scope: WorkspaceScope | null, dir: string): boolean {
|
|||
// The root package is always itself, workspace or not.
|
||||
if (dir === '') return true;
|
||||
if (scope === null) return false;
|
||||
if (scope.exclude.some((pattern) => globToRegExp(pattern).test(dir))) return false;
|
||||
return scope.include.some((pattern) => globToRegExp(pattern).test(dir));
|
||||
// An exclusion covers the directory AND everything under it: `!packages/legacy`
|
||||
// must keep `packages/legacy/foo` out even when a nested workspace root inside
|
||||
// the excluded subtree re-declares `packages/*`.
|
||||
if (scope.excludeRe.some((re) => matchesDirOrAncestor(re, dir))) return false;
|
||||
return scope.includeRe.some((re) => re.test(dir));
|
||||
}
|
||||
|
||||
function matchesDirOrAncestor(re: RegExp, dir: string): boolean {
|
||||
let current = dir;
|
||||
while (current !== '') {
|
||||
if (re.test(current)) return true;
|
||||
const slash = current.lastIndexOf('/');
|
||||
current = slash === -1 ? '' : current.slice(0, slash);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -272,9 +288,69 @@ function globToRegExp(pattern: string): RegExp {
|
|||
* tooling that does not read pnpm's file).
|
||||
*/
|
||||
async function loadWorkspaceScope(repoRoot: string): Promise<WorkspaceScope | null> {
|
||||
const patterns: string[] = [];
|
||||
// Every workspace ROOT in the repo, not just the top level. keycloak keeps its
|
||||
// JavaScript workspace at `js/pnpm-workspace.yaml`; reading only the repo root
|
||||
// found no workspace, admitted no package, and `@keycloak/keycloak-ui-shared`
|
||||
// (780–845 raw calls per SHA) resolved 7 times. Patterns from a nested root
|
||||
// are rebased onto that root so `packages/*` under `js/` admits `js/packages/x`.
|
||||
//
|
||||
// Gated, though: a nested root counts only when the repo root declares NO
|
||||
// workspace (keycloak), or when the nested root's directory is itself admitted
|
||||
// by the root's scope. Unioning every nested root unconditionally let an
|
||||
// `examples/*/package.json` starter (turborepo/vite/nuxt templates carry
|
||||
// `workspaces`) admit its example packages — and, being shallow, outrank the
|
||||
// real package of the same name — and let a root inside an excluded subtree
|
||||
// re-admit what the outer `!exclusion` had removed.
|
||||
const [rootPatterns, workspaceRoots] = await Promise.all([
|
||||
readWorkspacePatternsAt(repoRoot),
|
||||
findWorkspaceRoots(repoRoot),
|
||||
]);
|
||||
const rootScope = rootPatterns.length === 0 ? null : toScope(rootPatterns);
|
||||
const patterns: string[] = [...rootPatterns];
|
||||
const admitted: { root: string; prefix: string }[] = [];
|
||||
for (const root of workspaceRoots) {
|
||||
if (root === repoRoot) continue;
|
||||
const prefix = repoRelativeDir(repoRoot, root);
|
||||
if (rootScope !== null && !admits(rootScope, prefix)) continue;
|
||||
admitted.push({ root, prefix });
|
||||
}
|
||||
const nested = await Promise.all(
|
||||
admitted.map(async ({ root, prefix }) => {
|
||||
const rebase = (p: string): string => {
|
||||
const negated = p.startsWith('!');
|
||||
const body = negated ? p.slice(1) : p;
|
||||
const joined = prefix === '' ? body : `${prefix}/${body.replace(/^\.\//, '')}`;
|
||||
return negated ? `!${joined}` : joined;
|
||||
};
|
||||
return (await readWorkspacePatternsAt(root)).map(rebase);
|
||||
}),
|
||||
);
|
||||
for (const batch of nested) patterns.push(...batch);
|
||||
|
||||
const rootManifest = await readJsonFile(path.join(repoRoot, 'package.json'));
|
||||
if (patterns.length === 0) return null;
|
||||
return toScope(patterns);
|
||||
}
|
||||
|
||||
function toScope(patterns: readonly string[]): WorkspaceScope {
|
||||
const include = patterns.filter((p) => !p.startsWith('!'));
|
||||
const exclude = patterns.filter((p) => p.startsWith('!')).map((p) => p.slice(1));
|
||||
return {
|
||||
include,
|
||||
exclude,
|
||||
includeRe: include.map(globToRegExp),
|
||||
excludeRe: exclude.map(globToRegExp),
|
||||
};
|
||||
}
|
||||
|
||||
/** The workspace patterns declared at ONE directory, all three spellings merged. */
|
||||
async function readWorkspacePatternsAt(root: string): Promise<string[]> {
|
||||
const [rootManifest, yamlPkgs, ymlPkgs, lerna] = await Promise.all([
|
||||
readJsonFile(path.join(root, 'package.json')),
|
||||
readYamlPackages(path.join(root, 'pnpm-workspace.yaml')),
|
||||
readYamlPackages(path.join(root, 'pnpm-workspace.yml')),
|
||||
readJsonFile(path.join(root, 'lerna.json')),
|
||||
]);
|
||||
const patterns: string[] = [];
|
||||
const workspaces = rootManifest?.workspaces;
|
||||
if (Array.isArray(workspaces)) {
|
||||
patterns.push(...workspaces.filter((w): w is string => typeof w === 'string'));
|
||||
|
|
@ -285,20 +361,114 @@ async function loadWorkspaceScope(repoRoot: string): Promise<WorkspaceScope | nu
|
|||
patterns.push(...nested.filter((w): w is string => typeof w === 'string'));
|
||||
}
|
||||
}
|
||||
|
||||
patterns.push(...(await readYamlPackages(path.join(repoRoot, 'pnpm-workspace.yaml'))));
|
||||
patterns.push(...(await readYamlPackages(path.join(repoRoot, 'pnpm-workspace.yml'))));
|
||||
|
||||
const lerna = await readJsonFile(path.join(repoRoot, 'lerna.json'));
|
||||
patterns.push(...yamlPkgs, ...ymlPkgs);
|
||||
if (Array.isArray(lerna?.packages)) {
|
||||
patterns.push(...lerna.packages.filter((w): w is string => typeof w === 'string'));
|
||||
}
|
||||
return patterns;
|
||||
}
|
||||
|
||||
if (patterns.length === 0) return null;
|
||||
return {
|
||||
include: patterns.filter((p) => !p.startsWith('!')),
|
||||
exclude: patterns.filter((p) => p.startsWith('!')).map((p) => p.slice(1)),
|
||||
};
|
||||
/**
|
||||
* Directories that declare a workspace: the repo root plus any directory (to a
|
||||
* shallow depth — workspace roots sit near the top) holding a
|
||||
* `pnpm-workspace.yaml`, a `lerna.json`, or a `package.json` with `workspaces`.
|
||||
*/
|
||||
const WORKSPACE_ROOT_MAX_DEPTH = 4;
|
||||
/**
|
||||
* Bound on the depth-≤4 directory walk. Generous on purpose: the previous 2,000
|
||||
* cap tripped silently in readdir order, so WHICH packages existed — and which
|
||||
* imports resolved — varied between two checkouts of the same commit. Tripping
|
||||
* it now warns, so a truncated scan is a logged fact rather than a quiet one.
|
||||
*/
|
||||
const WORKSPACE_ROOT_SCAN_MAX_DIRS = 50_000;
|
||||
/**
|
||||
* Directory names whose nested `workspaces` are starters, fixtures, or test
|
||||
* trees — never members. A leftover `test/pnpm-workspace.yaml` must not become
|
||||
* a workspace root when the repo root declares none (the #2953 first-wins
|
||||
* class). A root `workspaces` glob that lists `test/*` still admits those
|
||||
* packages through the package.json walk; this set only stops nested-root
|
||||
* discovery from descending into those names.
|
||||
*/
|
||||
const NON_MEMBER_ROOT_DIRS = new Set([
|
||||
'example',
|
||||
'examples',
|
||||
'fixture',
|
||||
'fixtures',
|
||||
'template',
|
||||
'templates',
|
||||
'sample',
|
||||
'samples',
|
||||
'test',
|
||||
'tests',
|
||||
'e2e',
|
||||
'__tests__',
|
||||
'spec',
|
||||
'specs',
|
||||
]);
|
||||
|
||||
/**
|
||||
* Vite's `DEFAULT_CONFIG_FILES` order. The first filename that exists is the
|
||||
* config Vite loads; leftover siblings are not a second live entry.
|
||||
*/
|
||||
const VITE_CONFIG_FILES = [
|
||||
'vite.config.js',
|
||||
'vite.config.mjs',
|
||||
'vite.config.ts',
|
||||
'vite.config.cjs',
|
||||
'vite.config.mts',
|
||||
'vite.config.cts',
|
||||
] as const;
|
||||
|
||||
function isMissingPath(err: unknown): boolean {
|
||||
return (err as NodeJS.ErrnoException).code === 'ENOENT';
|
||||
}
|
||||
|
||||
async function readDirSorted(dir: string): Promise<import('fs').Dirent[] | null> {
|
||||
try {
|
||||
return (await fs.readdir(dir, { withFileTypes: true })).sort((a, b) =>
|
||||
a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
|
||||
);
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
async function findWorkspaceRoots(repoRoot: string): Promise<string[]> {
|
||||
const roots: string[] = [repoRoot];
|
||||
const queue: { dir: string; depth: number }[] = [{ dir: repoRoot, depth: 0 }];
|
||||
let scanned = 0;
|
||||
while (scanned < queue.length) {
|
||||
if (scanned >= WORKSPACE_ROOT_SCAN_MAX_DIRS) {
|
||||
logger.warn(
|
||||
`[node] workspace-root scan of ${repoRoot} hit the ${WORKSPACE_ROOT_SCAN_MAX_DIRS}-directory cap; nested workspace roots below it were not considered`,
|
||||
);
|
||||
break;
|
||||
}
|
||||
const { dir, depth } = queue[scanned++]!;
|
||||
const entries = await readDirSorted(dir);
|
||||
if (entries === null) continue;
|
||||
if (dir !== repoRoot) {
|
||||
const names = new Set(entries.filter((e) => e.isFile()).map((e) => e.name));
|
||||
let declares =
|
||||
names.has('pnpm-workspace.yaml') ||
|
||||
names.has('pnpm-workspace.yml') ||
|
||||
names.has('lerna.json');
|
||||
if (!declares && names.has('package.json')) {
|
||||
const manifest = await readJsonFile(path.join(dir, 'package.json'));
|
||||
declares = manifest?.workspaces !== undefined && manifest.workspaces !== null;
|
||||
}
|
||||
if (declares) roots.push(dir);
|
||||
}
|
||||
if (depth >= WORKSPACE_ROOT_MAX_DEPTH) continue;
|
||||
for (const entry of entries) {
|
||||
if (!entry.isDirectory()) continue;
|
||||
if (NON_MEMBER_ROOT_DIRS.has(entry.name.toLowerCase())) continue;
|
||||
const child = path.join(dir, entry.name);
|
||||
if (isHardcodedIgnoredDirectoryAtPath(repoRoot, child)) continue;
|
||||
queue.push({ dir: child, depth: depth + 1 });
|
||||
}
|
||||
}
|
||||
return roots;
|
||||
}
|
||||
|
||||
async function readJsonFile(filePath: string): Promise<Record<string, unknown> | null> {
|
||||
|
|
@ -327,6 +497,39 @@ async function readYamlPackages(filePath: string): Promise<string[]> {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Per-repo memo. The TS/JS/Vue scope resolvers and the unresolved-call ledger
|
||||
* classifier each ask for the same map during one analyze; without this the
|
||||
* 20k-directory walk ran once per asker (four times on a full run, one of them
|
||||
* inside the index lock). Invalidated at the start of every `runFullAnalysis`
|
||||
* so a long-lived server never serves a stale package map across runs.
|
||||
*/
|
||||
const workspacePackagesMemo = new Map<string, Promise<NodeWorkspacePackages | null>>();
|
||||
|
||||
export function invalidateNodeWorkspacePackages(repoRoot: string): void {
|
||||
workspacePackagesMemo.delete(path.resolve(repoRoot));
|
||||
}
|
||||
|
||||
export async function loadNodeWorkspacePackages(
|
||||
repoRoot: string,
|
||||
): Promise<NodeWorkspacePackages | null> {
|
||||
const key = path.resolve(repoRoot);
|
||||
const cached = workspacePackagesMemo.get(key);
|
||||
if (cached !== undefined) return cached;
|
||||
const pending: Promise<NodeWorkspacePackages | null> = loadNodeWorkspacePackagesUncached(
|
||||
repoRoot,
|
||||
).catch((err: unknown) => {
|
||||
// Evict only OUR entry. If this load was invalidated while in flight and a
|
||||
// newer load has since been installed under the same key, deleting by key
|
||||
// alone would evict that one, and every later caller would start another
|
||||
// full scan instead of joining it.
|
||||
if (workspacePackagesMemo.get(key) === pending) workspacePackagesMemo.delete(key);
|
||||
throw err;
|
||||
});
|
||||
workspacePackagesMemo.set(key, pending);
|
||||
return pending;
|
||||
}
|
||||
|
||||
/**
|
||||
* Collect the `package.json` of every ADMITTED workspace package.
|
||||
*
|
||||
|
|
@ -334,30 +537,29 @@ async function readYamlPackages(filePath: string): Promise<string[]> {
|
|||
* declaration, so this is far cheaper than the C# namespace scan next door,
|
||||
* which reads every `.cs` file.
|
||||
*/
|
||||
export async function loadNodeWorkspacePackages(
|
||||
async function loadNodeWorkspacePackagesUncached(
|
||||
repoRoot: string,
|
||||
): Promise<NodeWorkspacePackages | null> {
|
||||
const scope = await loadWorkspaceScope(repoRoot);
|
||||
const byName = new Map<string, NodeWorkspacePackage>();
|
||||
const queue: { dir: string; depth: number }[] = [{ dir: repoRoot, depth: 0 }];
|
||||
let queueHead = 0;
|
||||
let dirsScanned = 0;
|
||||
|
||||
while (queue.length > 0) {
|
||||
while (queueHead < queue.length) {
|
||||
if (dirsScanned >= SCAN_MAX_DIRS) {
|
||||
logger.warn(
|
||||
`[node] package.json scan of ${repoRoot} hit the ${SCAN_MAX_DIRS}-directory cap; workspace packages below it will not resolve`,
|
||||
);
|
||||
break;
|
||||
}
|
||||
const { dir, depth } = queue.shift()!;
|
||||
const { dir, depth } = queue[queueHead++]!;
|
||||
dirsScanned++;
|
||||
|
||||
let entries: import('fs').Dirent[];
|
||||
try {
|
||||
entries = await fs.readdir(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
// Sorted: same-depth name collisions resolve first-wins, and readdir order
|
||||
// is filesystem-dependent.
|
||||
const entries = await readDirSorted(dir);
|
||||
if (entries === null) continue;
|
||||
|
||||
for (const entry of entries) {
|
||||
if (entry.isDirectory()) {
|
||||
|
|
@ -420,10 +622,34 @@ async function readManifest(
|
|||
const value = parsed[field];
|
||||
if (typeof value === 'string') push(entries, rebase(value));
|
||||
}
|
||||
}
|
||||
// Entry points that name BUILD OUTPUT (`main: dist/x.js`, `exports: ./dist/…`)
|
||||
// never match an indexed source file — the package's real source entry has to
|
||||
// be discovered. keycloak's `@keycloak/keycloak-ui-shared` publishes
|
||||
// `dist/keycloak-ui-shared.js` and keeps its entry in `vite.config.ts`
|
||||
// (`build.lib.entry: 'src/main.ts'`); with only the declared fields it had 7
|
||||
// resolved calls against ~845 raw. Tried in a fixed order, and ONLY appended
|
||||
// (declared entries keep precedence): `source` / `publishConfig.source`, the
|
||||
// vite `lib.entry`, then `src/main` / `src/index`. More than one candidate
|
||||
// that exists on disk is recorded as ambiguous rather than picked — a wrong
|
||||
// entry binds every import of the package to the wrong file.
|
||||
// A package whose `exports` map has no `"."` (only subpaths) refuses the bare
|
||||
// specifier outright; discovery must not manufacture a `src/index` root for it.
|
||||
const rootlessExports = declaresExports && rootExports.length === 0;
|
||||
const discovered = rootlessExports
|
||||
? { entries: [], ambiguous: [], allowConventional: false }
|
||||
: await discoverSourceEntries(parsed, dir, repoRoot);
|
||||
for (const entry of discovered.entries) push(entries, entry);
|
||||
if (!declaresExports && discovered.allowConventional) {
|
||||
for (const conventional of ['src/index', 'index', 'lib/index']) {
|
||||
push(entries, joinRepoPath(packageDir, conventional));
|
||||
}
|
||||
}
|
||||
if (discovered.ambiguous.length > 0) {
|
||||
logger.warn(
|
||||
`[node] package ${name}: ${discovered.ambiguous.length} candidate source entries (${discovered.ambiguous.join(', ')}) — none adopted; declare \`source\` or a single lib entry`,
|
||||
);
|
||||
}
|
||||
|
||||
const subpathImports = new Map<string, readonly string[]>();
|
||||
collectImports(parsed.imports, subpathImports, rebase);
|
||||
|
|
@ -507,6 +733,195 @@ function collectImports(
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Does a declared entry point at build output rather than source? Output
|
||||
* directories and minified bundles. A plain `.js` is NOT build output on its
|
||||
* own — `main: "src/index.js"` / `index.js` is a JavaScript package's source,
|
||||
* and treating every `.js` as output ran discovery for essentially every CJS
|
||||
* package and could adopt a `src/main` beside the real entry.
|
||||
*/
|
||||
function looksLikeBuildOutput(entry: string): boolean {
|
||||
return /(^|\/)(dist|build|lib|out|esm|cjs|umd)\//.test(entry) || /\.min\.[cm]?js$/.test(entry);
|
||||
}
|
||||
|
||||
function declaredRootExportStrings(exportsRoot: unknown): string[] {
|
||||
if (typeof exportsRoot === 'string') return [exportsRoot];
|
||||
if (exportsRoot === null || typeof exportsRoot !== 'object') return [];
|
||||
const dot = (exportsRoot as Record<string, unknown>)['.'];
|
||||
if (typeof dot === 'string') return [dot];
|
||||
if (dot === null || typeof dot !== 'object') return [];
|
||||
return Object.values(dot).filter((v): v is string => typeof v === 'string');
|
||||
}
|
||||
|
||||
async function existingStems(repoRoot: string, stems: readonly string[]): Promise<string[]> {
|
||||
const present = await Promise.all(stems.map((stem) => stemExists(repoRoot, stem)));
|
||||
const existing: string[] = [];
|
||||
for (let i = 0; i < stems.length; i++) {
|
||||
if (present[i]) push(existing, stems[i]!);
|
||||
}
|
||||
return existing;
|
||||
}
|
||||
|
||||
async function discoverSourceEntries(
|
||||
parsed: Record<string, unknown>,
|
||||
dir: string,
|
||||
repoRoot: string,
|
||||
): Promise<{ entries: string[]; ambiguous: string[]; allowConventional: boolean }> {
|
||||
const packageDir = repoRelativeDir(repoRoot, dir);
|
||||
const rebase = (raw: string): string => joinRepoPath(packageDir, stripEntryPrefixes(raw));
|
||||
const declared: string[] = declaredRootExportStrings(parsed.exports);
|
||||
for (const field of ['module', 'main']) {
|
||||
const value = parsed[field];
|
||||
if (typeof value === 'string') declared.push(value);
|
||||
}
|
||||
// Only when every declared entry is build output (or nothing is declared and
|
||||
// the conventional stems are absent) does discovery run at all.
|
||||
if (declared.length > 0 && !declared.every(looksLikeBuildOutput))
|
||||
return { entries: [], ambiguous: [], allowConventional: true };
|
||||
|
||||
const candidates: string[] = [];
|
||||
const source = parsed.source;
|
||||
if (typeof source === 'string') candidates.push(rebase(source));
|
||||
const publishConfig = parsed.publishConfig;
|
||||
if (publishConfig !== null && typeof publishConfig === 'object') {
|
||||
const ps = (publishConfig as Record<string, unknown>).source;
|
||||
if (typeof ps === 'string') candidates.push(rebase(ps));
|
||||
}
|
||||
let hasViteConfig = false;
|
||||
for (const cfg of VITE_CONFIG_FILES) {
|
||||
let text: string;
|
||||
try {
|
||||
text = await fs.readFile(path.join(dir, cfg), 'utf-8');
|
||||
} catch (err) {
|
||||
if (isMissingPath(err)) continue;
|
||||
// Present but unreadable: Vite still selected this filename.
|
||||
hasViteConfig = true;
|
||||
break;
|
||||
}
|
||||
hasViteConfig = true;
|
||||
try {
|
||||
const entry = await staticViteEntry(text);
|
||||
if (entry !== null) push(candidates, rebase(entry));
|
||||
} catch {
|
||||
// Parse/load failure is not a missing file — do not fall through to a leftover sibling.
|
||||
}
|
||||
break;
|
||||
}
|
||||
let existing = await existingStems(repoRoot, candidates);
|
||||
// A config we cannot establish is not evidence for a conventional entry.
|
||||
if (existing.length === 0 && !hasViteConfig) {
|
||||
existing = await existingStems(
|
||||
repoRoot,
|
||||
['src/main', 'src/index'].map((conventional) => joinRepoPath(packageDir, conventional)),
|
||||
);
|
||||
}
|
||||
const allowConventional = !hasViteConfig && candidates.length === 0;
|
||||
if (existing.length > 1) return { entries: [], ambiguous: existing, allowConventional };
|
||||
return { entries: existing, ambiguous: [], allowConventional };
|
||||
}
|
||||
|
||||
/** Read a literal exported build.lib.entry without evaluating repository code. */
|
||||
async function staticViteEntry(text: string): Promise<string | null> {
|
||||
// Most manifests need no Vite discovery. Keep native grammars off that path.
|
||||
const [{ default: TreeSitter }, { default: grammar }, { parseSourceSafe }] = await Promise.all([
|
||||
import('tree-sitter'),
|
||||
import('tree-sitter-typescript'),
|
||||
import('../../tree-sitter/safe-parse.js'),
|
||||
]);
|
||||
const parser = new TreeSitter();
|
||||
parser.setLanguage(grammar.typescript);
|
||||
const tree = parseSourceSafe(parser, text);
|
||||
if (tree.rootNode.hasError) return null;
|
||||
const exports = tree.rootNode.namedChildren.filter(
|
||||
(node) => node.type === 'export_statement' && node.children.some((c) => c.type === 'default'),
|
||||
);
|
||||
if (exports.length !== 1) return null;
|
||||
let config = unwrapViteDefineConfig(tree, exports[0]!.childForFieldName('value'));
|
||||
if (config === null) return null;
|
||||
for (const key of ['build', 'lib', 'entry']) config = staticObjectProperty(config, key);
|
||||
return staticStringValue(config);
|
||||
}
|
||||
|
||||
/** Unwrap `defineConfig({...})` from Vite; refuse local or re-exported helpers. */
|
||||
function unwrapViteDefineConfig(
|
||||
tree: { rootNode: Parser.SyntaxNode },
|
||||
config: Parser.SyntaxNode | null,
|
||||
): Parser.SyntaxNode | null {
|
||||
if (config?.type !== 'call_expression') return config;
|
||||
if (config.childForFieldName('function')?.text !== 'defineConfig') return null;
|
||||
// A locally defined helper need not preserve its argument like Vite does.
|
||||
if (
|
||||
tree.rootNode
|
||||
.descendantsOfType(['function_declaration', 'variable_declarator'])
|
||||
.some((node) => node.childForFieldName('name')?.text === 'defineConfig')
|
||||
)
|
||||
return null;
|
||||
for (const statement of tree.rootNode.namedChildren) {
|
||||
if (statement.type !== 'import_statement') continue;
|
||||
if (!statement.descendantsOfType('identifier').some((n) => n.text === 'defineConfig')) continue;
|
||||
if (staticStringValue(statement.childForFieldName('source')) !== 'vite') return null;
|
||||
const identityImport = statement.descendantsOfType('import_specifier').some((specifier) => {
|
||||
const imported = specifier.childForFieldName('name')?.text;
|
||||
const local = specifier.childForFieldName('alias')?.text ?? imported;
|
||||
return imported === 'defineConfig' && local === 'defineConfig';
|
||||
});
|
||||
if (!identityImport) return null;
|
||||
}
|
||||
const args = config
|
||||
.childForFieldName('arguments')
|
||||
?.namedChildren.filter((n) => n.type !== 'comment');
|
||||
if (args?.length !== 1) return null;
|
||||
return args[0]!;
|
||||
}
|
||||
|
||||
function staticStringValue(node: Parser.SyntaxNode | null): string | null {
|
||||
if (node?.type !== 'string' || node.namedChildren.some((n) => n.type === 'escape_sequence'))
|
||||
return null;
|
||||
return node.text.slice(1, -1);
|
||||
}
|
||||
|
||||
/** Reject computed keys, spreads and duplicate properties that could override a value. */
|
||||
function staticObjectProperty(
|
||||
node: Parser.SyntaxNode | null,
|
||||
key: string,
|
||||
): Parser.SyntaxNode | null {
|
||||
if (node?.type !== 'object') return null;
|
||||
let value: Parser.SyntaxNode | null = null;
|
||||
for (const member of node.namedChildren) {
|
||||
if (member.type === 'comment') continue;
|
||||
if (member.type !== 'pair') return null;
|
||||
const name = member.childForFieldName('key');
|
||||
if (name?.type !== 'property_identifier' && name?.type !== 'string') return null;
|
||||
if (name.type === 'string') {
|
||||
const property = staticStringValue(name);
|
||||
if (property === null) return null;
|
||||
if (property !== key) continue;
|
||||
} else if (name.text !== key) {
|
||||
continue;
|
||||
}
|
||||
if (value !== null) return null;
|
||||
value = member.childForFieldName('value');
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
/** A repo-relative stem exists as a source file (with any TS/JS extension). */
|
||||
// The root is threaded explicitly: a module-level "current root" clobbered
|
||||
// under two concurrent scans and turned an ambiguity refusal into a confident
|
||||
// wrong entry (the second repo's root made one candidate "not exist").
|
||||
async function stemExists(repoRoot: string, stem: string): Promise<boolean> {
|
||||
const abs = path.join(repoRoot, stem);
|
||||
for (const ext of ['', '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']) {
|
||||
try {
|
||||
const st = await fs.stat(abs + ext);
|
||||
if (st.isFile()) return true;
|
||||
} catch {
|
||||
/* try next */
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** `"./src/index.ts"` -> `"src/index"`; leaves an extension-less path alone. */
|
||||
function stripEntryPrefixes(entry: string): string {
|
||||
const withoutDot = entry.replace(/^\.\//, '').replace(/^\//, '');
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import path from 'path';
|
|||
import type { CsharpStructureLineScanner } from './languages/csharp/namespace-siblings.js';
|
||||
|
||||
import { isDev } from './utils/env.js';
|
||||
import { isHardcodedIgnoredDirectoryAtPath } from '../../config/ignore-service.js';
|
||||
|
||||
import { mapConcurrent } from '../../lib/utils.js';
|
||||
import { logger } from '../logger.js';
|
||||
|
|
@ -182,13 +183,24 @@ export interface SwiftPackageConfig {
|
|||
/** Zig package config parsed from build.zig.zon and the root build.zig */
|
||||
export interface ZigBuildZonConfig {
|
||||
/**
|
||||
* Map of dependency name -> the raw `.path = "..."` value, exactly as
|
||||
* written in build.zig.zon (relative to the repo root, and possibly
|
||||
* escaping it: `../local_dep`). Consumers normalize — see
|
||||
* `normalizeZigDepPath` below, which rejects absolute
|
||||
* and repo-escaping values. `.url`-based deps cannot be resolved to a
|
||||
* repo-local file (they unpack into a build cache outside the repo) and so
|
||||
* are not included here.
|
||||
* Map of dependency name -> the dep's directory, in one of two spellings
|
||||
* depending on which package this config describes:
|
||||
*
|
||||
* - ROOT package (`pkg === ''`): the raw `.path = "..."` value, exactly as
|
||||
* written in build.zig.zon (relative to the repo root, and possibly
|
||||
* escaping it: `../local_dep`). This is what `parseZigBuildZon` promises
|
||||
* and what its tests pin.
|
||||
* - NESTED package: repo-relative and already normalized, because a nested
|
||||
* package's `.path` is written relative to ITS directory and means
|
||||
* nothing against the repo-relative keys consumers match on
|
||||
* (`packages/app`'s `../core` is stored as `packages/core`). A dep
|
||||
* escaping the REPO root is dropped rather than stored.
|
||||
*
|
||||
* Either spelling is safe to hand to `normalizeZigDepPath` below — it rejects
|
||||
* absolute and repo-escaping values and is idempotent on an already
|
||||
* normalized one, which is what `resolveZigImportInternal` relies on.
|
||||
* `.url`-based deps cannot be resolved to a repo-local file (they unpack into
|
||||
* a build cache outside the repo) and so are not included here.
|
||||
*/
|
||||
pathDeps: Map<string, string>;
|
||||
/**
|
||||
|
|
@ -228,6 +240,29 @@ export interface ZigBuildZonConfig {
|
|||
buildModules?: readonly ZigBuildModule[];
|
||||
}
|
||||
|
||||
/**
|
||||
* One Zig build package: the directory whose `build.zig` / `build.zig.zon`
|
||||
* declare the config, and that config with every path REPO-relative.
|
||||
*
|
||||
* A Zig module's import table is declared by the `build.zig` of the package it
|
||||
* belongs to, so a repo holding several packages holds several import tables —
|
||||
* the same shape a TypeScript monorepo has with a `tsconfig.json` per package.
|
||||
*/
|
||||
export interface ZigPackageScope {
|
||||
/** Repo-relative directory the package governs (`''` for the repo root). */
|
||||
readonly dir: string;
|
||||
readonly config: ZigBuildZonConfig;
|
||||
}
|
||||
|
||||
/**
|
||||
* Every Zig build package in the repo, indexed so the nearest one to a file
|
||||
* wins — the `TsconfigIndex` analogue, and for the same reason.
|
||||
*/
|
||||
export interface ZigWorkspaceIndex {
|
||||
/** Deepest-first, so the first `dir` that prefixes a file path governs it. */
|
||||
readonly packages: readonly ZigPackageScope[];
|
||||
}
|
||||
|
||||
/** One build module of the root `build.zig` — see `ZigBuildZonConfig.buildModules`. */
|
||||
export interface ZigBuildModule {
|
||||
/** The `addModule("<name>", …)` name; absent for `createModule` bindings
|
||||
|
|
@ -646,10 +681,21 @@ export async function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPac
|
|||
* string literals — a commented-out `.path` or a `}` inside a comment
|
||||
* or string cannot declare a dep or truncate the block.
|
||||
*/
|
||||
export async function loadZigBuildConfig(repoRoot: string): Promise<ZigBuildZonConfig | null> {
|
||||
export async function loadZigBuildConfig(
|
||||
repoRoot: string,
|
||||
packageDir = '',
|
||||
): Promise<ZigBuildZonConfig | null> {
|
||||
// Every path this function returns is REPO-relative, because that is the
|
||||
// keyspace `allFilePaths` uses. The parsers below answer package-relative, so
|
||||
// a nested package rebases them through `inPackage`. For the root package
|
||||
// (`packageDir === ''`) the prefix is empty and every value is byte-identical
|
||||
// to what this function returned before nested packages existed.
|
||||
const pkg = packageDir === '' ? '' : `${packageDir}/`;
|
||||
const inPackage = (relToPackage: string): string => `${pkg}${relToPackage}`;
|
||||
const packageFile = (name: string): string => path.join(repoRoot, packageDir, name);
|
||||
let config: ZigBuildZonConfig | null = null;
|
||||
try {
|
||||
const raw = await fs.readFile(path.join(repoRoot, 'build.zig.zon'), 'utf-8');
|
||||
const raw = await fs.readFile(packageFile('build.zig.zon'), 'utf-8');
|
||||
config = parseZigBuildZon(raw);
|
||||
} catch {
|
||||
// No zon (or unreadable): the root build.zig may still declare modules.
|
||||
|
|
@ -661,9 +707,11 @@ export async function loadZigBuildConfig(repoRoot: string): Promise<ZigBuildZonC
|
|||
let rootModules: Map<string, string> | undefined;
|
||||
let rootBuildZig: string | null = null;
|
||||
try {
|
||||
rootBuildZig = await fs.readFile(path.join(repoRoot, 'build.zig'), 'utf-8');
|
||||
rootBuildZig = await fs.readFile(packageFile('build.zig'), 'utf-8');
|
||||
const parsed = parseZigRootModules(rootBuildZig);
|
||||
if (parsed.size > 0) rootModules = parsed;
|
||||
if (parsed.size > 0) {
|
||||
rootModules = new Map(Array.from(parsed, ([name, root]) => [name, inPackage(root)]));
|
||||
}
|
||||
} catch {
|
||||
// No root build.zig — nothing to declare.
|
||||
}
|
||||
|
|
@ -671,7 +719,7 @@ export async function loadZigBuildConfig(repoRoot: string): Promise<ZigBuildZonC
|
|||
if (config === null) {
|
||||
if (rootBuildZig === null) return null;
|
||||
// No zon: no path deps, so `dep.module(…)` operands resolve to nothing.
|
||||
const buildModules = parseZigBuildModules(rootBuildZig);
|
||||
const buildModules = rebaseZigBuildModules(parseZigBuildModules(rootBuildZig), inPackage);
|
||||
if (!rootModules && buildModules.length === 0) return null;
|
||||
return {
|
||||
pathDeps: new Map(),
|
||||
|
|
@ -688,9 +736,22 @@ export async function loadZigBuildConfig(repoRoot: string): Promise<ZigBuildZonC
|
|||
// Per path dep: the modules its build.zig NAMES (`addModule("core", …)`),
|
||||
// repo-relative — what a root-build.zig `dep.module("core")` operand means.
|
||||
const depModules = new Map<string, ReadonlyMap<string, string>>();
|
||||
// A nested package's `.path` values are written relative to ITS directory, so
|
||||
// they are rebased here and stored repo-relative; `resolveZigImportInternal`
|
||||
// then reads them through the same `normalizeZigDepPath`, which is idempotent
|
||||
// on an already-normalized value. A dep that escapes the REPO root (not merely
|
||||
// the package) resolves to nothing and is dropped. The root package keeps its
|
||||
// raw spelling, which is what `parseZigBuildZon` promises and its tests pin.
|
||||
const pathDeps = pkg === '' ? config.pathDeps : new Map<string, string>();
|
||||
for (const [depName, depPath] of config.pathDeps) {
|
||||
const rel = normalizeZigDepPath(depPath);
|
||||
// Asked of the value AS WRITTEN, before the package prefix goes on: an
|
||||
// absolute `.path` points outside the repository whichever package declared
|
||||
// it, and prefixing hides that from `normalizeZigDepPath`. See
|
||||
// `isAbsoluteZigDepPath`.
|
||||
if (isAbsoluteZigDepPath(depPath)) continue;
|
||||
const rel = normalizeZigDepPath(`${pkg}${depPath}`);
|
||||
if (rel === null) continue;
|
||||
if (pkg !== '') pathDeps.set(depName, rel);
|
||||
let buildZig: string;
|
||||
try {
|
||||
buildZig = await fs.readFile(path.join(repoRoot, rel, 'build.zig'), 'utf-8');
|
||||
|
|
@ -706,15 +767,177 @@ export async function loadZigBuildConfig(repoRoot: string): Promise<ZigBuildZonC
|
|||
}
|
||||
if (named.size > 0) depModules.set(depName, named);
|
||||
}
|
||||
const buildModules = rootBuildZig === null ? [] : parseZigBuildModules(rootBuildZig, depModules);
|
||||
const buildModules =
|
||||
rootBuildZig === null
|
||||
? []
|
||||
: rebaseZigBuildModules(
|
||||
parseZigBuildModules(rootBuildZig, depModules),
|
||||
inPackage,
|
||||
depModules,
|
||||
);
|
||||
return {
|
||||
...config,
|
||||
pathDeps,
|
||||
...(moduleRoots.size > 0 ? { moduleRoots } : {}),
|
||||
...(rootModules ? { rootModules } : {}),
|
||||
...(buildModules.length > 0 ? { buildModules } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Rebase a package's own build modules to repo-relative paths.
|
||||
*
|
||||
* `parseZigBuildModules` answers package-relative for everything it read out of
|
||||
* the `build.zig` it was handed, with one exception: an alias resolved through
|
||||
* `depModules` (`addImport("api", dep.module("core"))`) is already repo-relative,
|
||||
* because `depModules` was built that way. Prefixing that a second time would
|
||||
* point the alias at a path no file has. The already-repo-relative values are
|
||||
* therefore identified by membership in `depModules`, not guessed at from their
|
||||
* shape.
|
||||
*/
|
||||
function rebaseZigBuildModules(
|
||||
modules: readonly ZigBuildModule[],
|
||||
inPackage: (relToPackage: string) => string,
|
||||
depModules?: ReadonlyMap<string, ReadonlyMap<string, string>>,
|
||||
): ZigBuildModule[] {
|
||||
if (inPackage('') === '') return [...modules];
|
||||
const fromDep = new Set<string>();
|
||||
for (const named of depModules?.values() ?? [])
|
||||
for (const root of named.values()) fromDep.add(root);
|
||||
return modules.map((mod) => ({
|
||||
...(mod.name !== undefined ? { name: mod.name } : {}),
|
||||
root: inPackage(mod.root),
|
||||
imports: new Map(
|
||||
Array.from(mod.imports, ([alias, root]) => [
|
||||
alias,
|
||||
fromDep.has(root) ? root : inPackage(root),
|
||||
]),
|
||||
),
|
||||
}));
|
||||
}
|
||||
|
||||
/** Bounds for the package walk, mirroring the tsconfig scan. */
|
||||
const ZIG_SCAN_MAX_DIRS = 20_000;
|
||||
const ZIG_SCAN_MAX_DEPTH = 24;
|
||||
|
||||
/**
|
||||
* The Zig build package governing `filePath` — the nearest one at or above it.
|
||||
*
|
||||
* A Zig module's import table is declared by the `build.zig` of the package the
|
||||
* file belongs to, so the nearest enclosing package is the faithful reading of
|
||||
* `@import("name")` at that site, exactly as `tsconfigFor` reads a non-relative
|
||||
* specifier against the nearest enclosing project.
|
||||
*
|
||||
* There is deliberately NO fall-through to an enclosing package when the nearest
|
||||
* one does not bind the name. Falling through is how a vendored dependency's
|
||||
* `@import("config")` silently resolved to the outer repo's `config` module —
|
||||
* the same failure `loadTsconfigIndex` documents for a package whose own
|
||||
* tsconfig declares no `baseUrl`, and the same failure the per-module import
|
||||
* tables in `resolveZigImportInternal` already exist to prevent one level down.
|
||||
*/
|
||||
export function zigPackageFor(
|
||||
index: ZigWorkspaceIndex | null | undefined,
|
||||
filePath: string,
|
||||
): ZigBuildZonConfig | null {
|
||||
if (index === null || index === undefined) return null;
|
||||
for (const scope of index.packages) {
|
||||
if (scope.dir === '') return scope.config;
|
||||
if (filePath.startsWith(`${scope.dir}/`)) return scope.config;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load every Zig build package in the repo, nearest-first.
|
||||
*
|
||||
* Called with no `packageDir` — which is how every call site read it before
|
||||
* this function existed — `loadZigBuildConfig` reads the ROOT `build.zig` /
|
||||
* `build.zig.zon` and nothing else. That is the whole configuration of a
|
||||
* single-package repo and none of the configuration of a monorepo: a repo
|
||||
* laying its packages out as `packages/<name>/build.zig` has no root build
|
||||
* files at all, so the loader answers `null` and EVERY bare
|
||||
* `@import("<module>")` in it goes unresolved — cross-file resolution silently
|
||||
* degrades to relative imports only. Measured on a two-package fixture:
|
||||
* `config = null`, `@import("core")` → `null`.
|
||||
*
|
||||
* The loader itself is not root-bound any more: this function is what supplies
|
||||
* it a `packageDir`, one per package below.
|
||||
*
|
||||
* So the packages are discovered the way tsconfigs are (`findTsconfigFiles`):
|
||||
* one bounded breadth-first walk that skips the hardcoded ignore set, then
|
||||
* deepest-first ordering so `zigPackageFor` can take the first match.
|
||||
*
|
||||
* Called from `ScopeResolver.loadResolutionConfig`, which the orchestrator runs
|
||||
* once per LANGUAGE workspace pass — so the walk happens only for repos that
|
||||
* actually contain Zig. `loadImportConfigs`, which runs unconditionally for
|
||||
* every repo, keeps calling `loadZigBuildConfig` for the root package alone;
|
||||
* that is the same split TypeScript already has between the cheap
|
||||
* `loadTsconfigPaths` and the repo-walking `loadTsconfigIndex`.
|
||||
*/
|
||||
export async function loadZigWorkspaceIndex(repoRoot: string): Promise<ZigWorkspaceIndex | null> {
|
||||
const dirs = await findZigPackageDirs(repoRoot);
|
||||
if (dirs.length === 0) return null;
|
||||
const packages: ZigPackageScope[] = [];
|
||||
for (const dir of dirs) {
|
||||
const config = await loadZigBuildConfig(repoRoot, dir);
|
||||
// A `build.zig` that declares no module and no path dep contributes nothing
|
||||
// a lookup could answer with. Keeping it as an empty scope would be worse
|
||||
// than dropping it: it would shadow an enclosing package that DOES declare
|
||||
// the name, and answer nothing in its place.
|
||||
if (config !== null) packages.push({ dir, config });
|
||||
}
|
||||
if (packages.length === 0) return null;
|
||||
// Deepest first, so `zigPackageFor` takes the most specific package rather
|
||||
// than whichever the walk reached first.
|
||||
packages.sort((a, b) => b.dir.length - a.dir.length || a.dir.localeCompare(b.dir));
|
||||
return { packages };
|
||||
}
|
||||
|
||||
/** Repo-relative directories holding a `build.zig` and/or a `build.zig.zon`. */
|
||||
async function findZigPackageDirs(repoRoot: string): Promise<string[]> {
|
||||
const found: string[] = [];
|
||||
const queue: { dir: string; depth: number }[] = [{ dir: repoRoot, depth: 0 }];
|
||||
// A HEAD INDEX rather than `queue.shift()`. The queue is pushed to while it is
|
||||
// drained, which keeps the array in a mode where `shift()` memmoves the whole
|
||||
// remainder instead of taking V8's left-trimming fast path — so the walk is
|
||||
// quadratic in the frontier, and `ZIG_SCAN_MAX_DIRS` is the bound on how bad
|
||||
// that gets. Measured at that bound (20,000 dequeues): 53 ms at fan-out 4 and
|
||||
// 81 ms at fan-out 20, against 0.8 ms here — 66-106x, paid before any config
|
||||
// is read. Memory is unchanged: entries were already retained by the pushes,
|
||||
// `shift()` only dropped the head.
|
||||
let queueHead = 0;
|
||||
let dirsScanned = 0;
|
||||
|
||||
while (queueHead < queue.length && dirsScanned < ZIG_SCAN_MAX_DIRS) {
|
||||
const { dir, depth } = queue[queueHead++]!;
|
||||
dirsScanned++;
|
||||
let entries: import('fs').Dirent[];
|
||||
try {
|
||||
entries = await fs.readdir(dir, { withFileTypes: true });
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
let isPackage = false;
|
||||
for (const entry of entries) {
|
||||
if (entry.isDirectory()) {
|
||||
const childDir = path.join(dir, entry.name);
|
||||
if (isHardcodedIgnoredDirectoryAtPath(repoRoot, childDir)) continue;
|
||||
if (depth < ZIG_SCAN_MAX_DEPTH) queue.push({ dir: childDir, depth: depth + 1 });
|
||||
continue;
|
||||
}
|
||||
if (!entry.isFile()) continue;
|
||||
// Either marker declares a package: a `build.zig` with no zon still names
|
||||
// modules, and a zon with no build.zig still names path deps.
|
||||
if (entry.name === 'build.zig' || entry.name === 'build.zig.zon') isPackage = true;
|
||||
}
|
||||
if (isPackage) {
|
||||
const rel = path.relative(repoRoot, dir).split(path.sep).join('/');
|
||||
found.push(rel === '.' || rel === '' ? '' : rel);
|
||||
}
|
||||
}
|
||||
return found;
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalize a `.path` value from build.zig.zon into a repo-relative form.
|
||||
* Returns null for paths that escape the repo root (start with `..`) or
|
||||
|
|
@ -722,13 +945,38 @@ export async function loadZigBuildConfig(repoRoot: string): Promise<ZigBuildZonC
|
|||
* to the empty string (the repo root itself). Shared with the import
|
||||
* resolver so both sides agree on which deps are in-repo.
|
||||
*/
|
||||
export function normalizeZigDepPath(depPath: string): string | null {
|
||||
// Normalize separators BEFORE the absolute check so every Windows spelling
|
||||
// is visible to it: POSIX (`/x`), drive (`C:\x`, `C:/x`), root-relative
|
||||
// (`\x` → `/x`) and UNC (`\\server\share` → `//server/share`) paths all
|
||||
// point outside the repository.
|
||||
/**
|
||||
* Does this `.path` value point outside the repository BY ITS SPELLING —
|
||||
* POSIX absolute (`/dep`), Windows drive-qualified (`C:\dep`, `C:/dep`),
|
||||
* root-relative (`\dep`) or UNC (`\\server\share`)?
|
||||
*
|
||||
* Separators are normalized first so every Windows spelling is visible to the
|
||||
* one test. Exported-in-spirit rather than inlined because it must be asked in
|
||||
* TWO places and the two must not drift: `normalizeZigDepPath` asks it of the
|
||||
* value it is given, and `loadZigBuildConfig` asks it of a NESTED package's
|
||||
* value BEFORE prefixing the package directory. That second call is the whole
|
||||
* point — prefixing turns `/dep` into `packages/app//dep`, which is relative by
|
||||
* inspection, so the check inside `normalizeZigDepPath` no longer sees an
|
||||
* absolute path and the empty segment is simply dropped, mapping an
|
||||
* out-of-repo dependency onto a real in-repo directory if one happens to exist.
|
||||
*
|
||||
* `path.posix.join` is NOT a substitute: it strips the leading slash too
|
||||
* (`join('packages/app/', '/dep')` is `packages/app/dep`), so it produces the
|
||||
* same fabricated path without ever rejecting anything.
|
||||
*
|
||||
* A `..` prefix is deliberately NOT handled here. `../core` escapes the
|
||||
* package but not necessarily the repo, and rebasing it is exactly what the
|
||||
* nested-package branch exists to do; `normalizeZigDepPath` rejects the ones
|
||||
* that still escape the ROOT after rebasing.
|
||||
*/
|
||||
function isAbsoluteZigDepPath(depPath: string): boolean {
|
||||
const normalized = depPath.replace(/\\/g, '/');
|
||||
if (normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized)) return null;
|
||||
return normalized.startsWith('/') || /^[A-Za-z]:\//.test(normalized);
|
||||
}
|
||||
|
||||
export function normalizeZigDepPath(depPath: string): string | null {
|
||||
const normalized = depPath.replace(/\\/g, '/');
|
||||
if (isAbsoluteZigDepPath(depPath)) return null;
|
||||
const parts: string[] = [];
|
||||
for (const part of normalized.split('/')) {
|
||||
if (part === '' || part === '.') continue;
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ import type { VariableExtractor } from './variable-types.js';
|
|||
import type { ImportResolverFn } from './import-resolvers/types.js';
|
||||
import type { SyntaxNode } from './utils/ast-helpers.js';
|
||||
import type { CfgVisitor } from './cfg/types.js';
|
||||
import type { GraphNode, NodeLabel } from 'gitnexus-shared';
|
||||
import type { GraphNode, NodeLabel, ParameterTypeClass, RelationshipType } from 'gitnexus-shared';
|
||||
import type { ExtractedRoute } from './route-extractors/laravel.js';
|
||||
import type { SharedSpringType } from './route-extractors/spring-shared.js';
|
||||
import type {
|
||||
|
|
@ -120,6 +120,68 @@ export function mergeCanonicalDefinitionProperties<
|
|||
return { ...providerProperties, ...canonicalProperties } as Record<string, unknown> & TCanonical;
|
||||
}
|
||||
|
||||
export interface ProviderSemanticNode {
|
||||
readonly id: string;
|
||||
readonly label: NodeLabel;
|
||||
readonly properties: {
|
||||
readonly name: string;
|
||||
readonly filePath: string;
|
||||
readonly startLine: number;
|
||||
readonly endLine: number;
|
||||
readonly language: SupportedLanguages;
|
||||
readonly isExported: boolean;
|
||||
readonly qualifiedName?: string;
|
||||
readonly parameterCount?: number;
|
||||
readonly requiredParameterCount?: number;
|
||||
readonly parameterTypes?: readonly string[];
|
||||
readonly parameterTypeClasses?: readonly ParameterTypeClass[];
|
||||
readonly returnType?: string;
|
||||
readonly declaredType?: string;
|
||||
readonly visibility?: string;
|
||||
readonly isStatic?: boolean;
|
||||
readonly isReadonly?: boolean;
|
||||
readonly [key: string]: unknown;
|
||||
};
|
||||
}
|
||||
|
||||
export type ProviderSemanticRelationshipType = Extract<
|
||||
RelationshipType,
|
||||
'DECLARES' | 'DEFINES' | 'HAS_METHOD' | 'HAS_PROPERTY'
|
||||
>;
|
||||
|
||||
export interface ProviderSemanticRelationship {
|
||||
readonly id: string;
|
||||
readonly sourceId: string;
|
||||
readonly targetId: string;
|
||||
readonly type: ProviderSemanticRelationshipType;
|
||||
readonly confidence: number;
|
||||
readonly reason: string;
|
||||
}
|
||||
|
||||
export interface ProviderSemanticSymbol {
|
||||
readonly filePath: string;
|
||||
readonly name: string;
|
||||
readonly nodeId: string;
|
||||
readonly type: NodeLabel;
|
||||
readonly qualifiedName?: string;
|
||||
readonly parameterCount?: number;
|
||||
readonly requiredParameterCount?: number;
|
||||
readonly parameterTypes?: readonly string[];
|
||||
readonly parameterTypeClasses?: readonly ParameterTypeClass[];
|
||||
readonly returnType?: string;
|
||||
readonly declaredType?: string;
|
||||
readonly ownerId?: string;
|
||||
readonly visibility?: string;
|
||||
readonly isStatic?: boolean;
|
||||
readonly isReadonly?: boolean;
|
||||
}
|
||||
|
||||
export interface ProviderSemanticGraph {
|
||||
readonly nodes: readonly ProviderSemanticNode[];
|
||||
readonly relationships: readonly ProviderSemanticRelationship[];
|
||||
readonly symbols: readonly ProviderSemanticSymbol[];
|
||||
}
|
||||
|
||||
// ── Strategy tag types ─────────────────────────────────────────────────────
|
||||
// NOTE: `MroStrategy` is defined in `gitnexus-shared` and re-exported above
|
||||
// so `core/ingestion/model/resolve.ts` can consume it without importing from
|
||||
|
|
@ -230,6 +292,29 @@ interface LanguageProviderConfig {
|
|||
*/
|
||||
readonly runtimeSymbolStrategy?: RuntimeSymbolStrategy;
|
||||
|
||||
/**
|
||||
* Optional content-based language classifier. The filename detector remains
|
||||
* the default source of truth; this hook lets a provider claim ambiguous
|
||||
* files only when the source text carries language-specific evidence.
|
||||
*
|
||||
* Used for extensions shared by several languages, where mapping the suffix
|
||||
* globally would steal files from an existing provider. Implementations must
|
||||
* be deterministic and conservative: false negatives are acceptable, false
|
||||
* positives change which parser and resolver consumes the file.
|
||||
*
|
||||
* Default: undefined (provider never overrides filename detection).
|
||||
*/
|
||||
readonly classifyFileContent?: (filePath: string, sourceText: string) => boolean;
|
||||
|
||||
/**
|
||||
* Cheap path-only prefilter for `classifyFileContent`. When supplied, callers
|
||||
* can avoid loading source text for files this provider would never claim.
|
||||
*
|
||||
* Default: undefined (only callers that already have content invoke
|
||||
* `classifyFileContent`).
|
||||
*/
|
||||
readonly shouldClassifyFileContent?: (filePath: string) => boolean;
|
||||
|
||||
// ── Core (required) ───────────────────────────────────────────────
|
||||
/** Type extraction: declarations, initializers, for-loop bindings */
|
||||
readonly typeConfig: LanguageTypeConfig;
|
||||
|
|
@ -643,6 +728,23 @@ interface LanguageProviderConfig {
|
|||
repo: RepoConstants,
|
||||
) => string | null;
|
||||
|
||||
/**
|
||||
* Optional provider-owned semantic graph extraction for languages whose
|
||||
* stable symbol identities cannot be represented by the generic query
|
||||
* pipeline's `(label, filePath, qualifiedName)` rule.
|
||||
*
|
||||
* Runs in the parse worker after tree-sitter has parsed the file and after
|
||||
* `extractParsedFile` has produced the scope-resolution artifact. The hook is
|
||||
* deterministic and AST-based: it receives the already-parsed tree and must
|
||||
* return plain graph nodes/relationships/symbol-table rows. Existing
|
||||
* providers leave it undefined, preserving the generic capture path exactly.
|
||||
*/
|
||||
readonly extractSemanticGraph?: (
|
||||
tree: Parser.Tree,
|
||||
filePath: string,
|
||||
sourceText: string,
|
||||
) => ProviderSemanticGraph;
|
||||
|
||||
// ── Noise filtering ────────────────────────────────────────────────
|
||||
/** Built-in/stdlib names that should be filtered from the call graph for this language.
|
||||
* Default: undefined (no language-specific filtering). */
|
||||
|
|
|
|||
114
gitnexus/src/core/ingestion/languages/cobol/copy-target.ts
Normal file
114
gitnexus/src/core/ingestion/languages/cobol/copy-target.ts
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
/**
|
||||
* Shared COBOL `COPY` target resolution (#2967 / #2908).
|
||||
*
|
||||
* Both the census (`cobolScopeResolver.resolveImportTarget`) and the live
|
||||
* regex processor (`resolveCopy` → `cobol-copy` IMPORTS) must answer the
|
||||
* same path for the same `(name, fromFile, allFilePaths)`. Greening only
|
||||
* the census would leave analyze fabricating an IMPORTS edge onto a vendor
|
||||
* decoy the compiler would never have searched.
|
||||
*
|
||||
* Well-known copybook directory segments (`copybooks`, `COPYBOOKS`, `cpy`,
|
||||
* `copy`) plus the importer's own directory are the preferred class. When
|
||||
* the file set contains at least one of those well-known segments, a `COPY`
|
||||
* name resolves only inside that class (first in Set-iteration order).
|
||||
* `vendor/EXTERNAL.cpy` therefore misses while `copybooks/CUSTREC.cpy` hits.
|
||||
*
|
||||
* When the file set has no such directory, fail-open to today's two-tier
|
||||
* first-wins basename index — shops whose copybooks *are* the tree have
|
||||
* nothing to prefer. The importer directory is *not* enough on its own to
|
||||
* leave fail-open (`{vendor/EXTERNAL.cpy, src/PROG.cbl}` must still answer
|
||||
* `vendor/EXTERNAL.cpy`).
|
||||
*
|
||||
* The two-tier index is still memoized on the `allFilePaths` Set identity
|
||||
* (#2908). Preferred-class filtering happens at pick time from the stored
|
||||
* per-name arrays, so a pass still scans the set once.
|
||||
*/
|
||||
import path from 'node:path';
|
||||
import { perFileSet } from '../../import-resolvers/per-file-set.js';
|
||||
|
||||
const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
|
||||
const COBOL_SOURCE_EXTENSIONS = new Set(['.cbl', '.cob', '.cobol']);
|
||||
|
||||
/** Path-component names that mark a conventional copybook directory. */
|
||||
const PREFERRED_DIR_NAMES = new Set(['copybooks', 'COPYBOOKS', 'cpy', 'copy']);
|
||||
|
||||
interface CobolCopyIndex {
|
||||
/** `.cpy` / `.copybook` files — tier 1, Set-iteration order per stem. */
|
||||
readonly copybooks: ReadonlyMap<string, readonly string[]>;
|
||||
/** `.cbl` / `.cob` / `.cobol` files — tier 2, Set-iteration order per stem. */
|
||||
readonly sources: ReadonlyMap<string, readonly string[]>;
|
||||
/** True iff any file path has a well-known copybook directory segment. */
|
||||
readonly hasPreferredDir: boolean;
|
||||
}
|
||||
|
||||
function pathHasPreferredDir(fp: string): boolean {
|
||||
const parts = fp.split('/');
|
||||
for (let i = 0; i < parts.length - 1; i++) {
|
||||
if (PREFERRED_DIR_NAMES.has(parts[i])) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function pushUnique(map: Map<string, string[]>, key: string, fp: string): void {
|
||||
const list = map.get(key);
|
||||
if (list === undefined) {
|
||||
map.set(key, [fp]);
|
||||
return;
|
||||
}
|
||||
list.push(fp);
|
||||
}
|
||||
|
||||
const getCobolCopyIndex = perFileSet((allFilePaths: ReadonlySet<string>): CobolCopyIndex => {
|
||||
const copybooks = new Map<string, string[]>();
|
||||
const sources = new Map<string, string[]>();
|
||||
let hasPreferredDir = false;
|
||||
for (const fp of allFilePaths) {
|
||||
const extRaw = path.extname(fp);
|
||||
const extLower = extRaw.toLowerCase();
|
||||
const tier = COPYBOOK_EXTENSIONS.has(extLower)
|
||||
? copybooks
|
||||
: COBOL_SOURCE_EXTENSIONS.has(extLower)
|
||||
? sources
|
||||
: undefined;
|
||||
if (tier === undefined) continue;
|
||||
if (!hasPreferredDir && pathHasPreferredDir(fp)) hasPreferredDir = true;
|
||||
const basename = path.basename(fp, extRaw).toUpperCase();
|
||||
pushUnique(tier, basename, fp);
|
||||
}
|
||||
return { copybooks, sources, hasPreferredDir };
|
||||
});
|
||||
|
||||
function pickCopyPath(
|
||||
paths: readonly string[] | undefined,
|
||||
fromFile: string,
|
||||
hasPreferredDir: boolean,
|
||||
): string | null {
|
||||
if (paths === undefined || paths.length === 0) return null;
|
||||
if (!hasPreferredDir) return paths[0] ?? null;
|
||||
const fromDir = path.dirname(fromFile);
|
||||
for (const fp of paths) {
|
||||
if (pathHasPreferredDir(fp) || path.dirname(fp) === fromDir) return fp;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve a COBOL `COPY` member name against the workspace file set.
|
||||
*
|
||||
* `fromFile` is the importing program (census) or the program currently
|
||||
* being expanded (processor). It is used only to include the importer's
|
||||
* directory in the preferred class when a well-known copybook dir exists.
|
||||
*/
|
||||
export function resolveCobolCopyTarget(
|
||||
targetRaw: string,
|
||||
fromFile: string,
|
||||
allFilePaths: ReadonlySet<string>,
|
||||
): string | null {
|
||||
const upper = targetRaw.toUpperCase();
|
||||
const index = getCobolCopyIndex(allFilePaths);
|
||||
return (
|
||||
pickCopyPath(index.copybooks.get(upper), fromFile, index.hasPreferredDir) ??
|
||||
pickCopyPath(index.sources.get(upper), fromFile, index.hasPreferredDir) ??
|
||||
null
|
||||
);
|
||||
}
|
||||
|
|
@ -9,74 +9,12 @@
|
|||
* Reference: `languages/python/scope-resolver.ts`.
|
||||
*/
|
||||
|
||||
import path from 'node:path';
|
||||
import type { ParsedFile } from 'gitnexus-shared';
|
||||
import { SupportedLanguages } from 'gitnexus-shared';
|
||||
import { perFileSet } from '../../import-resolvers/per-file-set.js';
|
||||
import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
|
||||
import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
|
||||
import { cobolProvider } from '../cobol.js';
|
||||
|
||||
// Copybook file extensions for COPY name resolution
|
||||
const COPYBOOK_EXTENSIONS = new Set(['.cpy', '.copybook']);
|
||||
// COBOL source files, searched only after every copybook has missed.
|
||||
const COBOL_SOURCE_EXTENSIONS = new Set(['.cbl', '.cob', '.cobol']);
|
||||
|
||||
/**
|
||||
* Uppercased-basename → first file carrying it, one map PER TIER, memoized on
|
||||
* the `allFilePaths` Set identity (#2908).
|
||||
*
|
||||
* `resolveImportTarget` used to run two full workspace scans per `COPY` — one
|
||||
* for the copybook tier, one for the source tier — each calling `path.extname`
|
||||
* + `path.basename` + `toUpperCase` on every entry. A `COPY` of a member that
|
||||
* lives outside the repo (the common case: vendor and system copybooks) missed
|
||||
* in both, so both scans always ran to completion, making resolution
|
||||
* O(copies × files). The orchestrator passes the SAME Set to every import in a
|
||||
* pass (`pipeline/run.ts` builds it once), so a `WeakMap` keyed on that Set
|
||||
* turns the scans into one build per run.
|
||||
*
|
||||
* Two tiers rather than one map is the tie-break, not a stylistic choice: a
|
||||
* `.cpy`/`.copybook` hit beats a `.cbl`/`.cob`/`.cobol` hit even when the source
|
||||
* file comes FIRST in Set-iteration order, which is exactly what collapsing the
|
||||
* tiers into a single first-wins map would silently discard. Within a tier the
|
||||
* first file in Set-iteration order wins, mirroring the `return` on first match
|
||||
* in the scans this replaces.
|
||||
*
|
||||
* The per-file key is derived with the same `path.extname(fp).toLowerCase()` →
|
||||
* `path.basename(fp, ext)` → `toUpperCase()` sequence the scans used, including
|
||||
* its quirk: `path.basename` strips the suffix only on an exact, case-sensitive
|
||||
* match, so `Foo.CPY` indexes under `FOO.CPY` rather than `FOO`. Node's `path`
|
||||
* stays in the loop for the same reason — on POSIX it does not treat `\` as a
|
||||
* separator, and hand-rolled slicing on `/` would start resolving backslash
|
||||
* paths the scans never resolved.
|
||||
*/
|
||||
interface CobolCopyIndex {
|
||||
/** `.cpy` / `.copybook` files — tier 1. */
|
||||
readonly copybooks: ReadonlyMap<string, string>;
|
||||
/** `.cbl` / `.cob` / `.cobol` files — tier 2. */
|
||||
readonly sources: ReadonlyMap<string, string>;
|
||||
}
|
||||
|
||||
const getCobolCopyIndex = perFileSet((allFilePaths: ReadonlySet<string>): CobolCopyIndex => {
|
||||
const copybooks = new Map<string, string>();
|
||||
const sources = new Map<string, string>();
|
||||
// One pass builds both tiers: the two scans walked the same files and
|
||||
// classified each by the same extension test.
|
||||
for (const fp of allFilePaths) {
|
||||
const ext = path.extname(fp).toLowerCase();
|
||||
const tier = COPYBOOK_EXTENSIONS.has(ext)
|
||||
? copybooks
|
||||
: COBOL_SOURCE_EXTENSIONS.has(ext)
|
||||
? sources
|
||||
: undefined;
|
||||
if (tier === undefined) continue;
|
||||
const basename = path.basename(fp, ext).toUpperCase();
|
||||
// First in Set-iteration order wins, as the scans' first-match `return` did.
|
||||
if (!tier.has(basename)) tier.set(basename, fp);
|
||||
}
|
||||
|
||||
return { copybooks, sources };
|
||||
});
|
||||
import { resolveCobolCopyTarget } from './copy-target.js';
|
||||
|
||||
const cobolScopeResolver: ScopeResolver = {
|
||||
language: SupportedLanguages.Cobol,
|
||||
|
|
@ -84,11 +22,9 @@ const cobolScopeResolver: ScopeResolver = {
|
|||
importEdgeReason: 'cobol-scope: copy',
|
||||
|
||||
// ── Resolve COPY bookname to file path ─────────────────────────────
|
||||
resolveImportTarget: (targetRaw, _fromFile, allFilePaths) => {
|
||||
const upper = targetRaw.toUpperCase();
|
||||
const index = getCobolCopyIndex(allFilePaths);
|
||||
// Copybooks first, then COBOL sources — the tier order IS the tie-break.
|
||||
return index.copybooks.get(upper) ?? index.sources.get(upper) ?? null;
|
||||
// Shared with the regex processor's resolveCopy (#2967 lockstep).
|
||||
resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
|
||||
return resolveCobolCopyTarget(targetRaw, fromFile, allFilePaths);
|
||||
},
|
||||
|
||||
// COBOL has no binding-merge rules beyond the default (local-first-then-imports).
|
||||
|
|
|
|||
|
|
@ -0,0 +1,77 @@
|
|||
/**
|
||||
* Dart's veto on the global-name fallback — see
|
||||
* `ScopeResolver.isGlobalNameFallbackPlausible`.
|
||||
*
|
||||
* Dart's privacy is LIBRARY-scoped and marked in the identifier itself: a name
|
||||
* beginning with `_` is visible only inside its own library and cannot be
|
||||
* imported by any spelling. So a `_`-prefixed candidate in another file is an
|
||||
* impossible call, not an unlikely one.
|
||||
*
|
||||
* The exact boundary is `part` / `part of` — one library spanning several
|
||||
* files, with `_` names shared between them — and the extractor does not
|
||||
* surface `part` directives yet (the Dart query captures only `library_import`;
|
||||
* nothing in `languages/dart/` reads `part`). Without them a cross-file `_`
|
||||
* candidate is UNDECIDABLE, not impossible: refusing on "different file" would
|
||||
* delete real edges on Flutter's dominant generated-code idiom (`factory
|
||||
* Foo.fromJson(j) => _$FooFromJson(j)` calls into `foo.g.dart`, a `part` beside
|
||||
* it), and refusing on "different directory" is wrong too — a `part` URI is a
|
||||
* relative URI and legally traverses directories (`part '../shared/gen.dart';`).
|
||||
* An earlier version refused the cross-directory case as "no `part` layout can
|
||||
* make this legal"; that claim was false, so the hook now REFUSES NOTHING and
|
||||
* every cross-file `_` candidate stays a LABELED edge (0.5 /
|
||||
* `global-name-fallback`), which is the honest answer until `part` is
|
||||
* extracted. A caller that names the candidate's file in a directive is
|
||||
* recognized already, for the day the extractor surfaces `part` as an import
|
||||
* target; at that point "not the same library" becomes decidable and the
|
||||
* refusal can return.
|
||||
*
|
||||
* Public names are left to the labeled-edge path. Dart does require an import
|
||||
* for a cross-library public name, but the fallback exists partly to recover
|
||||
* edges where the import chain was not reconstructed, and refusing every
|
||||
* cross-file public call would delete real edges to buy a rule the `_` marker
|
||||
* already gives for free.
|
||||
*/
|
||||
|
||||
import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
|
||||
import {
|
||||
modulePathReaches,
|
||||
stripExtension,
|
||||
} from '../../scope-resolution/utils/name-fallback-visibility.js';
|
||||
|
||||
/** Dart privacy marker: a leading underscore on the declared identifier. Read
|
||||
* from the last `qualifiedName` segment, so `_Foo.bar` is public `bar` on a
|
||||
* private class and `Foo._bar` is the private member. */
|
||||
function isPrivateDartName(candidate: SymbolDefinition): boolean {
|
||||
const qualified = candidate.qualifiedName ?? '';
|
||||
const dot = qualified.lastIndexOf('.');
|
||||
const simple = dot === -1 ? qualified : qualified.slice(dot + 1);
|
||||
return simple.startsWith('_');
|
||||
}
|
||||
|
||||
/**
|
||||
* Are these two files parts of one library? True when the caller names the
|
||||
* candidate's file in a `part` / `part of` directive, which the extractor
|
||||
* surfaces as an ordinary import target.
|
||||
*/
|
||||
function sharesLibrary(callerParsed: ParsedFile, candidateFilePath: string): boolean {
|
||||
const candidateModule = stripExtension(candidateFilePath);
|
||||
for (const imp of callerParsed.parsedImports) {
|
||||
if (modulePathReaches(stripExtension(imp.targetRaw), candidateModule)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
export function dartIsGlobalNameFallbackPlausible(ctx: {
|
||||
readonly callerParsed: ParsedFile;
|
||||
readonly candidate: SymbolDefinition;
|
||||
}): boolean {
|
||||
if (ctx.candidate.filePath === ctx.callerParsed.filePath) return true;
|
||||
if (!isPrivateDartName(ctx.candidate)) return true;
|
||||
// A directive naming the candidate's file is positive evidence of one library.
|
||||
if (sharesLibrary(ctx.callerParsed, ctx.candidate.filePath)) return true;
|
||||
// Any other file may be a `part` of the caller's library — a sibling or, via
|
||||
// a relative `part` URI, a file in another directory. Undecidable without
|
||||
// `part` extraction (see the header), so allowed as a labeled guess, never
|
||||
// refused.
|
||||
return true;
|
||||
}
|
||||
|
|
@ -41,6 +41,7 @@ import { decodeMarker } from '../../utils/heritage-marker.js';
|
|||
import { typeApplicationArguments } from '../../utils/template-arguments.js';
|
||||
import type { HeritageTypeArgumentSink } from '../../scope-resolution/utils/generic-instantiation.js';
|
||||
import { expandDartWildcardNames } from './expand-wildcards.js';
|
||||
import { dartIsGlobalNameFallbackPlausible } from './name-fallback-visibility.js';
|
||||
|
||||
interface ClassDefRef {
|
||||
readonly graphId: string;
|
||||
|
|
@ -233,5 +234,6 @@ export const dartScopeResolver: ScopeResolver = {
|
|||
// No `new`: bare `Foo()` resolves to the type; with cross-file imports the
|
||||
// callee is reachable workspace-wide.
|
||||
allowGlobalFreeCallFallback: true,
|
||||
isGlobalNameFallbackPlausible: dartIsGlobalNameFallbackPlausible,
|
||||
constructorCallTargetsClass: true,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -508,11 +508,24 @@ function normalizeGenericConstructorCapture(
|
|||
if (referenceNode !== undefined && referenceNode.type === 'generic_type') {
|
||||
const base = referenceNode.childForFieldName('type');
|
||||
if (base !== null) {
|
||||
grouped['@reference.name'] = syntheticCapture(
|
||||
'@reference.name',
|
||||
base,
|
||||
extractSimpleTypeNameText(base),
|
||||
);
|
||||
const simple = extractSimpleTypeNameText(base);
|
||||
// Keep the written `pkg.Box[T]` spelling so constructor resolution
|
||||
// can tell a package-qualified type from a bare unique-name guess.
|
||||
// `Box[T]` is also `text !== simple` (`Box[T]` vs `Box`) — that is
|
||||
// not a qualifier. Only a `qualified_type` base (`pkg.Box`) is.
|
||||
if (
|
||||
grouped['@reference.qualified-name'] === undefined &&
|
||||
base.type === 'qualified_type' &&
|
||||
referenceNode.text.length > 0 &&
|
||||
referenceNode.text !== simple
|
||||
) {
|
||||
grouped['@reference.qualified-name'] = syntheticCapture(
|
||||
'@reference.qualified-name',
|
||||
referenceNode,
|
||||
referenceNode.text,
|
||||
);
|
||||
}
|
||||
grouped['@reference.name'] = syntheticCapture('@reference.name', base, simple);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -0,0 +1,126 @@
|
|||
/**
|
||||
* Go's veto on the global-name fallback — see
|
||||
* `ScopeResolver.isGlobalNameFallbackPlausible`.
|
||||
*
|
||||
* Go's visibility rules are unusually decidable from a file path and an
|
||||
* identifier, which is why this is the language the guard is most complete for:
|
||||
*
|
||||
* 1. A package IS a directory. Two files in the same directory see each
|
||||
* other's identifiers with no import and no qualification, so a same-
|
||||
* directory candidate is always plausible.
|
||||
* 2. An identifier is exported iff it begins with an upper-case letter. An
|
||||
* UNEXPORTED identifier is invisible outside its own package — no import
|
||||
* makes it reachable, so a cross-directory candidate with a lower-case
|
||||
* initial is not unlikely, it is IMPOSSIBLE.
|
||||
* 3. A bare exported identifier from another package requires a DOT import.
|
||||
* Ordinary, alias, and blank imports never introduce a bare callable.
|
||||
*
|
||||
* Rule 2 is the one that matters most in practice: `uniqueHelperXyz` defined
|
||||
* once in package `a` used to acquire a caller in package `b` purely because
|
||||
* the name was unique in the repo, and the resulting edge was published as
|
||||
* `import-resolved` — a caller Go itself would reject.
|
||||
*
|
||||
* Methods require a receiver and never qualify for this bare-name tier.
|
||||
*/
|
||||
|
||||
import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
|
||||
import {
|
||||
modulePathReaches,
|
||||
directoryOf,
|
||||
} from '../../scope-resolution/utils/name-fallback-visibility.js';
|
||||
import { inferGoPackageName } from './package-clause.js';
|
||||
|
||||
/**
|
||||
* Compare actual package clauses, not a guessed `_test` suffix convention:
|
||||
* `foo_test` can itself be a production package name. Missing source remains
|
||||
* undecidable, while the test-file boundary is always available from the path.
|
||||
*/
|
||||
function classifyGoFile(
|
||||
filePath: string,
|
||||
sourceTextOf: ((p: string) => string | undefined) | undefined,
|
||||
): { isTest: boolean; declared: string | undefined } {
|
||||
const isTest = filePath.endsWith('_test.go');
|
||||
const text = sourceTextOf?.(filePath);
|
||||
return {
|
||||
isTest,
|
||||
declared: text === undefined ? undefined : (inferGoPackageName(text) ?? undefined),
|
||||
};
|
||||
}
|
||||
|
||||
/** Go export rule: an upper-case initial, by Unicode letter case. */
|
||||
function isExportedGoName(name: string): boolean {
|
||||
return /^\p{Lu}/u.test(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* The simple identifier a Go declaration contributes to its package scope: the
|
||||
* last segment of `qualifiedName`, which is `Type.method` for a method and the
|
||||
* bare identifier for a function. Either way the LAST segment is the identifier
|
||||
* whose case decides export.
|
||||
*/
|
||||
function goSimpleName(candidate: SymbolDefinition): string {
|
||||
const qualified = candidate.qualifiedName ?? '';
|
||||
const dot = qualified.lastIndexOf('.');
|
||||
return dot === -1 ? qualified : qualified.slice(dot + 1);
|
||||
}
|
||||
|
||||
export function goIsGlobalNameFallbackPlausible(ctx: {
|
||||
readonly sourceTextOf?: (filePath: string) => string | undefined;
|
||||
readonly callerParsed: ParsedFile;
|
||||
readonly candidate: SymbolDefinition;
|
||||
readonly site?: { readonly rawQualifiedName?: string };
|
||||
}): boolean {
|
||||
// A PATH-QUALIFIED call (`pkg.Export()`) reached this tier because the
|
||||
// qualifier could not be followed. Qualification removes the bare-name
|
||||
// "only a dot import introduces this identifier" rule — not export or
|
||||
// test-package visibility. `other.private()` is still impossible.
|
||||
const isPackageQualified = ctx.site?.rawQualifiedName !== undefined;
|
||||
// Methods require a receiver, even within their own package or a dot import.
|
||||
if (ctx.candidate.type === 'Method' || ctx.candidate.qualifiedName?.includes('.')) return false;
|
||||
const callerDir = directoryOf(ctx.callerParsed.filePath);
|
||||
const candidateDir = directoryOf(ctx.candidate.filePath);
|
||||
// Same directory is NOT the same package (rule 1, refined): a `_test.go`
|
||||
// file may declare `foo_test`, and test-only declarations are invisible to
|
||||
// non-test files. Apply the split `package-siblings.ts` uses for the
|
||||
// confident tier, so the heuristic tier cannot reopen what it closed.
|
||||
if (callerDir === candidateDir) {
|
||||
const caller = classifyGoFile(ctx.callerParsed.filePath, ctx.sourceTextOf);
|
||||
const cand = classifyGoFile(ctx.candidate.filePath, ctx.sourceTextOf);
|
||||
// Non-test files never see test-only declarations.
|
||||
if (cand.isTest && !caller.isTest) return false;
|
||||
// Different clauses require an explicit dot import, even in one directory.
|
||||
// Fall through to the exported/import checks for external test packages.
|
||||
// Missing source leaves package identity undecidable.
|
||||
if (
|
||||
caller.declared === undefined ||
|
||||
cand.declared === undefined ||
|
||||
caller.declared === cand.declared
|
||||
)
|
||||
return true;
|
||||
}
|
||||
|
||||
// Different package — and a `_test.go` file's
|
||||
// declarations are compiled only into ITS OWN package's test binary. No other
|
||||
// package, test or not, can see them, exported or not. Decidable from the
|
||||
// path alone, so it comes before every exception below (the module-root
|
||||
// exception in particular used to accept a root `helper_test.go` export).
|
||||
if (classifyGoFile(ctx.candidate.filePath, ctx.sourceTextOf).isTest) return false;
|
||||
|
||||
const simpleName = goSimpleName(ctx.candidate);
|
||||
// No identifier to read the case of — an unanswered question, not a refusal.
|
||||
if (simpleName === '') return true;
|
||||
// Unexported across a package boundary (rule 2): no import can reach it.
|
||||
if (!isExportedGoName(simpleName)) return false;
|
||||
if (isPackageQualified) return true;
|
||||
|
||||
// Only a dot import introduces a bare name. A candidate in the module ROOT package has an empty
|
||||
// directory, which `modulePathReaches` cannot align against any import path
|
||||
// (the root package is imported by the module path alone, which the repo-
|
||||
// relative layout does not carry). That is an unanswered question, not a
|
||||
// refusal — a dot import is plausible even if its path cannot be aligned.
|
||||
return ctx.callerParsed.parsedImports.some(
|
||||
(imp) =>
|
||||
imp.kind === 'wildcard' &&
|
||||
(candidateDir === '' || modulePathReaches(imp.targetRaw, candidateDir)),
|
||||
);
|
||||
}
|
||||
|
|
@ -4,92 +4,189 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
|
|||
import { expandGoDotImports } from './expand-wildcards.js';
|
||||
import { goPackageDir, inferGoPackageName } from './package-clause.js';
|
||||
|
||||
function isGoTestFile(filePath: string): boolean {
|
||||
return filePath.endsWith('_test.go');
|
||||
}
|
||||
|
||||
/**
|
||||
* O(n²×d) where n = files per package, d = defs per file.
|
||||
* Acceptable for V1 since Go packages are typically small (< 20 files).
|
||||
* Future optimization: build a name→def inverted index per package to reduce
|
||||
* to O(n×d).
|
||||
* The package a `_test.go` file's clause belongs to, given the package names
|
||||
* the directory's NON-test files declare.
|
||||
*
|
||||
* `package foo_test` is the external-test convention ONLY when the directory's
|
||||
* real package is `foo`; the `_test` suffix is otherwise a legal identifier
|
||||
* (`package foo_test` in a directory whose non-test files also say `foo_test`).
|
||||
* Stripping it unconditionally keyed such a package's own internal tests as
|
||||
* external tests of a non-existent `foo`, so they saw no sibling at all — a
|
||||
* resolution miss on every same-package call. Strip only when the stripped
|
||||
* name is what the non-test siblings declare; with no non-test sibling to ask
|
||||
* (a test-only directory) the convention is assumed, as before.
|
||||
*/
|
||||
function testFilePackageOf(
|
||||
declared: string,
|
||||
nonTestPackagesInDir: ReadonlySet<string> | undefined,
|
||||
): { readonly pkg: string; readonly external: boolean } {
|
||||
if (!declared.endsWith('_test') || declared.length <= '_test'.length) {
|
||||
return { pkg: declared, external: false };
|
||||
}
|
||||
const stripped = declared.slice(0, -'_test'.length);
|
||||
if (nonTestPackagesInDir !== undefined && nonTestPackagesInDir.has(declared)) {
|
||||
return { pkg: declared, external: false };
|
||||
}
|
||||
if (nonTestPackagesInDir === undefined || nonTestPackagesInDir.has(stripped)) {
|
||||
return { pkg: stripped, external: true };
|
||||
}
|
||||
// Neither name is declared by a non-test sibling: keep the clause as written.
|
||||
return { pkg: declared, external: false };
|
||||
}
|
||||
|
||||
interface IndexedDef {
|
||||
readonly filePath: string;
|
||||
readonly ref: BindingRef;
|
||||
}
|
||||
|
||||
/** name → defs, in package file order. */
|
||||
type NameIndex = Map<string, IndexedDef[]>;
|
||||
|
||||
function defBareName(def: SymbolDefinition): string {
|
||||
return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
|
||||
}
|
||||
|
||||
function appendToIndex(
|
||||
index: NameIndex,
|
||||
filePath: string,
|
||||
defs: readonly SymbolDefinition[],
|
||||
): void {
|
||||
for (const def of defs) {
|
||||
const name = defBareName(def);
|
||||
if (name === '') continue;
|
||||
const list = index.get(name) ?? [];
|
||||
list.push({ filePath, ref: { def, origin: 'namespace' } });
|
||||
index.set(name, list);
|
||||
}
|
||||
}
|
||||
|
||||
function publishIndex(
|
||||
augmentations: Map<ScopeId, Map<string, BindingRef[]>>,
|
||||
index: NameIndex,
|
||||
receiverPath: string,
|
||||
receiverModule: ScopeId,
|
||||
): void {
|
||||
if (index.size === 0) return;
|
||||
let scopeBindings = augmentations.get(receiverModule);
|
||||
if (scopeBindings === undefined) {
|
||||
scopeBindings = new Map<string, BindingRef[]>();
|
||||
augmentations.set(receiverModule, scopeBindings);
|
||||
}
|
||||
for (const [name, entries] of index) {
|
||||
let bucket = scopeBindings.get(name);
|
||||
const seen =
|
||||
bucket === undefined ? new Set<string>() : new Set(bucket.map((b) => b.def.nodeId));
|
||||
for (const entry of entries) {
|
||||
if (entry.filePath === receiverPath) continue;
|
||||
if (seen.has(entry.ref.def.nodeId)) continue;
|
||||
if (bucket === undefined) {
|
||||
bucket = [];
|
||||
scopeBindings.set(name, bucket);
|
||||
}
|
||||
bucket.push(entry.ref);
|
||||
seen.add(entry.ref.def.nodeId);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Publish same-package sibling bindings, including `_test.go` files.
|
||||
*
|
||||
* Internal tests (`package foo`) see production and other internal-test names.
|
||||
* External tests (`package foo_test`) get no bare-name bindings across that
|
||||
* partition — qualified `foo.X` and `import .` stay on the import resolver.
|
||||
* Non-test files never see test-only helpers (`go build` does not compile them).
|
||||
*
|
||||
* Per-package name→def indexes are built in O(n×d). Each receiver walks only
|
||||
* the partitions it can see, so defs are not re-scanned against every sibling
|
||||
* file. Binding refs are allocated once and reused across receivers.
|
||||
*/
|
||||
export function populateGoPackageSiblings(
|
||||
parsedFiles: readonly ParsedFile[],
|
||||
indexes: ScopeResolutionIndexes,
|
||||
ctx: { readonly fileContents: ReadonlyMap<string, string> },
|
||||
): void {
|
||||
// 0. Filter out test files — Go _test.go files should not contribute
|
||||
// same-package sibling bindings to non-test files.
|
||||
const nonTestFiles = parsedFiles.filter((f) => !f.filePath.endsWith('_test.go'));
|
||||
|
||||
// 1. Expand dot imports first so subsequent same-package sibling
|
||||
// augmentation can also see dot-imported names.
|
||||
expandGoDotImports(nonTestFiles, indexes);
|
||||
// augmentation can also see dot-imported names. Test files dot-import too.
|
||||
expandGoDotImports(parsedFiles, indexes);
|
||||
|
||||
// 2. Group files by package directory plus package name. Go package
|
||||
// identity is directory-scoped; repeated `package main` directories
|
||||
// must not see each other's unqualified names.
|
||||
const packageByFile = new Map<string, string>();
|
||||
for (const parsed of nonTestFiles) {
|
||||
// Same derivation as `populateGoWorkspaceOwners` — one shared resolver, so
|
||||
// the two passes cannot disagree about a file's package (#2837). The
|
||||
// no-clause case is reported there; warning twice for one fact would be
|
||||
// noise.
|
||||
const pkgName = inferGoPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
|
||||
if (pkgName !== null) {
|
||||
packageByFile.set(parsed.filePath, `${goPackageDir(parsed.filePath)}\0${pkgName}`);
|
||||
}
|
||||
//
|
||||
// `_test.go` files join the INTERNAL package's bucket (a `foo_test`
|
||||
// external test is keyed by `foo`, its `external` flag marking the
|
||||
// partition so no bare-name bindings cross it), so one bucket holds
|
||||
// everything the test binary compiles together, and the visibility
|
||||
// rules below decide who sees whom.
|
||||
interface SiblingFile {
|
||||
readonly filePath: string;
|
||||
readonly defs: readonly SymbolDefinition[];
|
||||
readonly isTest: boolean;
|
||||
readonly external: boolean;
|
||||
}
|
||||
const filesByPackage = new Map<string, SiblingFile[]>();
|
||||
// Same derivation as `populateGoWorkspaceOwners` — one shared resolver, so
|
||||
// the two passes cannot disagree about a file's package (#2837). The
|
||||
// no-clause case is reported there; warning twice for one fact would be
|
||||
// noise.
|
||||
const declaredByFile = new Map<string, string>();
|
||||
const nonTestPackagesByDir = new Map<string, Set<string>>();
|
||||
for (const parsed of parsedFiles) {
|
||||
const declared = inferGoPackageName(ctx.fileContents.get(parsed.filePath) ?? '');
|
||||
if (declared === null) continue;
|
||||
declaredByFile.set(parsed.filePath, declared);
|
||||
if (isGoTestFile(parsed.filePath)) continue;
|
||||
const dir = goPackageDir(parsed.filePath);
|
||||
const names = nonTestPackagesByDir.get(dir) ?? new Set<string>();
|
||||
names.add(declared);
|
||||
nonTestPackagesByDir.set(dir, names);
|
||||
}
|
||||
for (const parsed of parsedFiles) {
|
||||
const declared = declaredByFile.get(parsed.filePath);
|
||||
if (declared === undefined) continue;
|
||||
const isTest = isGoTestFile(parsed.filePath);
|
||||
const dir = goPackageDir(parsed.filePath);
|
||||
const { pkg, external } = isTest
|
||||
? testFilePackageOf(declared, nonTestPackagesByDir.get(dir))
|
||||
: { pkg: declared, external: false };
|
||||
const key = `${dir}\0${pkg}`;
|
||||
const list = filesByPackage.get(key) ?? [];
|
||||
list.push({ filePath: parsed.filePath, defs: parsed.localDefs, isTest, external });
|
||||
filesByPackage.set(key, list);
|
||||
}
|
||||
|
||||
const filesByPackage = new Map<string, { filePath: string; defs: SymbolDefinition[] }[]>();
|
||||
for (const parsed of nonTestFiles) {
|
||||
const pkgName = packageByFile.get(parsed.filePath);
|
||||
if (pkgName === undefined) continue;
|
||||
const list = filesByPackage.get(pkgName) ?? [];
|
||||
list.push({ filePath: parsed.filePath, defs: [...parsed.localDefs] });
|
||||
filesByPackage.set(pkgName, list);
|
||||
}
|
||||
|
||||
// 2. Use bindingAugmentations channel per I8
|
||||
// 3. Use bindingAugmentations channel per I8. Same-package files see ALL
|
||||
// sibling names (exported and unexported). Cross-package visibility is
|
||||
// the import resolver's job.
|
||||
const augmentations = indexes.bindingAugmentations as Map<ScopeId, Map<string, BindingRef[]>>;
|
||||
|
||||
for (const [, siblings] of filesByPackage) {
|
||||
for (const target of siblings) {
|
||||
const targetModule = indexes.moduleScopes.byFilePath.get(target.filePath);
|
||||
if (targetModule === undefined) continue;
|
||||
|
||||
for (const receiver of siblings) {
|
||||
if (receiver.filePath === target.filePath) continue; // no self-reference
|
||||
const receiverModule = indexes.moduleScopes.byFilePath.get(receiver.filePath);
|
||||
if (receiverModule === undefined) continue;
|
||||
|
||||
for (const def of target.defs) {
|
||||
// Go: same-package sibling files can see ALL names (both
|
||||
// exported/uppercase and unexported/lowercase). Only cross-
|
||||
// package visibility requires uppercase first letter.
|
||||
const name = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
|
||||
if (name === '') continue;
|
||||
|
||||
const bucket = getAugmentationBucket(augmentations, receiverModule, name);
|
||||
if (bucket.some((b) => b.def.nodeId === def.nodeId)) continue;
|
||||
bucket.push({ def, origin: 'namespace' });
|
||||
}
|
||||
for (const siblings of filesByPackage.values()) {
|
||||
if (siblings.length < 2) continue;
|
||||
const production: NameIndex = new Map();
|
||||
const internalTest: NameIndex = new Map();
|
||||
const external: NameIndex = new Map();
|
||||
const receivers: { file: SiblingFile; module: ScopeId }[] = [];
|
||||
for (const file of siblings) {
|
||||
const module = indexes.moduleScopes.byFilePath.get(file.filePath);
|
||||
if (module === undefined) continue;
|
||||
receivers.push({ file, module });
|
||||
if (file.external) appendToIndex(external, file.filePath, file.defs);
|
||||
else if (file.isTest) appendToIndex(internalTest, file.filePath, file.defs);
|
||||
else appendToIndex(production, file.filePath, file.defs);
|
||||
}
|
||||
for (const { file, module } of receivers) {
|
||||
if (file.external) {
|
||||
publishIndex(augmentations, external, file.filePath, module);
|
||||
continue;
|
||||
}
|
||||
publishIndex(augmentations, production, file.filePath, module);
|
||||
if (file.isTest) publishIndex(augmentations, internalTest, file.filePath, module);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function getAugmentationBucket(
|
||||
augmentations: Map<ScopeId, Map<string, BindingRef[]>>,
|
||||
scopeId: ScopeId,
|
||||
name: string,
|
||||
): BindingRef[] {
|
||||
let scopeBindings = augmentations.get(scopeId);
|
||||
if (scopeBindings === undefined) {
|
||||
scopeBindings = new Map<string, BindingRef[]>();
|
||||
augmentations.set(scopeId, scopeBindings);
|
||||
}
|
||||
let bucketArr = scopeBindings.get(name);
|
||||
if (bucketArr === undefined) {
|
||||
bucketArr = [];
|
||||
scopeBindings.set(name, bucketArr);
|
||||
}
|
||||
return bucketArr;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@ import { detectGoInterfaceImplementations } from './interface-impls.js';
|
|||
import { populateGoRangeBindings } from './range-binding.js';
|
||||
import { expandGoWildcardNames } from './expand-wildcards.js';
|
||||
import { goMapValueType } from './interpret.js';
|
||||
import { goIsGlobalNameFallbackPlausible } from './name-fallback-visibility.js';
|
||||
|
||||
/** Slice `[]T` and array `[N]T` / `[...]T` → the element spelling. Hoisted —
|
||||
* a literal inside the hook would mint a fresh RegExp per folded subscript. */
|
||||
|
|
@ -85,6 +86,7 @@ export const goScopeResolver: ScopeResolver = {
|
|||
hoistTypeBindingsToModule: true,
|
||||
propagatesReturnTypesAcrossImports: true,
|
||||
allowGlobalFreeCallFallback: true,
|
||||
isGlobalNameFallbackPlausible: goIsGlobalNameFallbackPlausible,
|
||||
|
||||
populateNamespaceSiblings: populateGoPackageSiblings,
|
||||
mirrorNamespaceTypeBindings: mirrorGoNamespaceTypeBindings,
|
||||
|
|
|
|||
|
|
@ -8,7 +8,11 @@
|
|||
* 4. Run `tsc --noEmit` to verify
|
||||
*/
|
||||
|
||||
import { SupportedLanguages, isBladeTemplateFilename } from 'gitnexus-shared';
|
||||
import {
|
||||
SupportedLanguages,
|
||||
getLanguageFromFilename,
|
||||
isBladeTemplateFilename,
|
||||
} from 'gitnexus-shared';
|
||||
import type { LanguageProvider } from '../language-provider.js';
|
||||
|
||||
import { typescriptProvider, javascriptProvider } from './typescript.js';
|
||||
|
|
@ -19,6 +23,7 @@ import { goProvider } from './go.js';
|
|||
import { rustProvider } from './rust.js';
|
||||
import { csharpProvider } from './csharp.js';
|
||||
import { cProvider, cppProvider } from './c-cpp.js';
|
||||
import { objectiveCProvider } from './objective-c.js';
|
||||
import { phpProvider } from './php.js';
|
||||
import { rubyProvider } from './ruby.js';
|
||||
import { swiftProvider } from './swift.js';
|
||||
|
|
@ -38,6 +43,7 @@ export const providers = {
|
|||
[SupportedLanguages.CSharp]: csharpProvider,
|
||||
[SupportedLanguages.C]: cProvider,
|
||||
[SupportedLanguages.CPlusPlus]: cppProvider,
|
||||
[SupportedLanguages.ObjectiveC]: objectiveCProvider,
|
||||
[SupportedLanguages.PHP]: phpProvider,
|
||||
[SupportedLanguages.Ruby]: rubyProvider,
|
||||
[SupportedLanguages.Swift]: swiftProvider,
|
||||
|
|
@ -70,3 +76,39 @@ export function getProviderForFile(filePath: string): LanguageProvider | null {
|
|||
const basename = filePath.slice(filePath.lastIndexOf('/') + 1);
|
||||
return extensionMap.get(ext) ?? extensionMap.get(basename) ?? null;
|
||||
}
|
||||
|
||||
/** Return the provider whose content classifier confidently claims this file. */
|
||||
export function getProviderForFileContent(
|
||||
filePath: string,
|
||||
content: string,
|
||||
): LanguageProvider | null {
|
||||
if (isBladeTemplateFilename(filePath)) return null;
|
||||
|
||||
for (const provider of Object.values(providers)) {
|
||||
if (provider.classifyFileContent?.(filePath, content) === true) return provider;
|
||||
}
|
||||
const byExtension = getProviderForFile(filePath);
|
||||
if (byExtension) return byExtension;
|
||||
// Filename-only languages (Rakefile, Gemfile, …) live in
|
||||
// getLanguageFromFilename, not provider.extensions.
|
||||
const filenameLang = getLanguageFromFilename(filePath);
|
||||
return filenameLang === null ? null : providers[filenameLang];
|
||||
}
|
||||
|
||||
/** True when at least one provider wants source text before language bucketing. */
|
||||
export function needsContentLanguageClassification(filePath: string): boolean {
|
||||
if (isBladeTemplateFilename(filePath)) return false;
|
||||
return Object.values(providers).some(
|
||||
(provider) =>
|
||||
provider.classifyFileContent !== undefined &&
|
||||
provider.shouldClassifyFileContent?.(filePath) === true,
|
||||
);
|
||||
}
|
||||
|
||||
/** Return the effective language for a file, optionally using source content. */
|
||||
export function getLanguageForFileContent(
|
||||
filePath: string,
|
||||
content: string,
|
||||
): SupportedLanguages | null {
|
||||
return getProviderForFileContent(filePath, content)?.id ?? null;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -357,6 +357,26 @@ export function emitJavaScopeCaptures(
|
|||
}
|
||||
}
|
||||
|
||||
// Qualified constructor `new pkg.Foo()` already binds the simple tail as
|
||||
// `@reference.name` (F35). Copy the scoped spelling onto
|
||||
// `@reference.qualified-name` so constructor resolution can treat it as a
|
||||
// written qualifier instead of a bare unique-name guess (C# does the same).
|
||||
const ctorQualifiedNode = nodeMap['@reference.call.constructor.qualified'];
|
||||
const ctorQualifiedText = grouped['@reference.call.constructor.qualified']?.text;
|
||||
if (
|
||||
ctorQualifiedNode !== undefined &&
|
||||
ctorQualifiedText !== undefined &&
|
||||
ctorQualifiedText.length > 0 &&
|
||||
ctorQualifiedText !== grouped['@reference.name']?.text &&
|
||||
grouped['@reference.qualified-name'] === undefined
|
||||
) {
|
||||
grouped['@reference.qualified-name'] = syntheticCapture(
|
||||
'@reference.qualified-name',
|
||||
ctorQualifiedNode,
|
||||
ctorQualifiedText,
|
||||
);
|
||||
}
|
||||
|
||||
// Synthesize `@reference.arity` on every callsite.
|
||||
const callTag = (
|
||||
['@reference.call.free', '@reference.call.member', '@reference.call.constructor'] as const
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ import {
|
|||
syntheticCapture,
|
||||
type SyntaxNode,
|
||||
} from '../../utils/ast-helpers.js';
|
||||
import { collectEsmExportEvidence, esmExportVerdict } from '../../ts-js-export-marker.js';
|
||||
import { splitImportStatement } from '../typescript/import-decomposer.js';
|
||||
import { getJsParser, getJsScopeQuery, jsCachedTreeMatchesGrammar } from './query.js';
|
||||
import { computeTsArityMetadata } from '../typescript/arity-metadata.js';
|
||||
|
|
@ -983,6 +984,8 @@ export function emitJsScopeCaptures(
|
|||
}
|
||||
|
||||
const rawMatches = getJsScopeQuery(filePath).matches(tree.rootNode);
|
||||
// Export evidence, read once per file (see `ts-js-export-marker.ts`).
|
||||
const exportEvidence = collectEsmExportEvidence(tree.rootNode, filePath);
|
||||
const out: CaptureMatch[] = [];
|
||||
|
||||
for (const m of rawMatches) {
|
||||
|
|
@ -1124,6 +1127,13 @@ export function emitJsScopeCaptures(
|
|||
fnNode,
|
||||
deriveDefaultExportHocName(filePath),
|
||||
);
|
||||
// This declaration's name is synthetic, so the later query-name
|
||||
// marker cannot see it. The HOC predicate already proves the export.
|
||||
grouped['@declaration.is-exported'] = syntheticCapture(
|
||||
'@declaration.is-exported',
|
||||
fnNode,
|
||||
'true',
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1207,6 +1217,20 @@ export function emitJsScopeCaptures(
|
|||
// non-call match, an absent receiver, or a chain with no nameable base
|
||||
// all leave `grouped` untouched.
|
||||
synthesizeReceiverChainCapture(grouped, groupedNodes['@reference.receiver']);
|
||||
// `@declaration.is-exported`: a verdict for every declaration the file's
|
||||
// export surface can decide (see `ts-js-export-marker.ts`); nothing where
|
||||
// it cannot, because absence is the honest answer there.
|
||||
const declNameNode = groupedNodes['@declaration.name'];
|
||||
if (exportEvidence !== undefined && declNameNode !== undefined) {
|
||||
const verdict = esmExportVerdict(declNameNode, exportEvidence);
|
||||
if (verdict !== undefined) {
|
||||
grouped['@declaration.is-exported'] = syntheticCapture(
|
||||
'@declaration.is-exported',
|
||||
declNameNode,
|
||||
verdict ? 'true' : 'false',
|
||||
);
|
||||
}
|
||||
}
|
||||
out.push(grouped);
|
||||
|
||||
// Synthesize `this` receiver type-bindings on class member functions.
|
||||
|
|
|
|||
|
|
@ -97,6 +97,12 @@ const javascriptScopeResolver: ScopeResolver = {
|
|||
// explicit imports at the call site. Workspace-wide unique-name fallback
|
||||
// recovers these edges.
|
||||
allowGlobalFreeCallFallback: true,
|
||||
|
||||
// Same ECMAScript `export *` exclusivity as TypeScript: a name declared by
|
||||
// two wildcard sources is refused, not guessed.
|
||||
exclusiveWildcardReexports: true,
|
||||
// Same ECMAScript rule as TypeScript: named imports bind module-level declarations only.
|
||||
namedImportsBindTopLevelOnly: true,
|
||||
};
|
||||
|
||||
export { javascriptScopeResolver };
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue