gitnexus 1.6.2 → 1.6.3-rc.10

package/dist/_shared/scope-resolution/shadow/aggregate.js

@@ -0,0 +1,122 @@
+/**
+ * Shadow-mode aggregation — per-language parity %, per-evidence-kind
+ * breakdown of divergences. Consumed by the parity dashboard (RING2-PKG-5).
+ *
+ * Pure functions; no I/O. The harness persists per-run JSON; the dashboard
+ * reads `.gitnexus/shadow-parity/latest.json` and renders.
+ *
+ * Related types — `ShadowAgreement`, `ShadowCallsite`, `ShadowDiff` — are
+ * defined alongside `diffResolutions` in `./diff.ts` and re-exported
+ * through the top-level `gitnexus-shared` barrel. Consumers import all
+ * three from `gitnexus-shared`, not from this module.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #918.
+ */
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Aggregate a stream of `ShadowDiff` records into a `ShadowParityReport`,
+ * bucketed by language. Pure function.
+ *
+ * - `perLanguage` rows are sorted alphabetically by `SupportedLanguages`
+ *   value for stable JSON output (the dashboard reads
+ *   `.gitnexus/shadow-parity/latest.json` and diffing snapshots is useful).
+ * - `overall` is the column-wise sum across languages.
+ * - `generatedAt` is injected via the `now` parameter so tests stay
+ *   deterministic; production callers let it default to `new Date()`.
+ */
+export function aggregateDiffs(diffs, now = new Date()) {
+    const perLanguageMap = new Map();
+    for (const { language, diff } of diffs) {
+        let counts = perLanguageMap.get(language);
+        if (!counts) {
+            counts = makeEmptyCounts();
+            perLanguageMap.set(language, counts);
+        }
+        tallyDiff(counts, diff);
+    }
+    const perLanguage = Array.from(perLanguageMap.entries())
+        .map(([language, counts]) => buildRow(language, counts))
+        .sort((a, b) => a.language.localeCompare(b.language));
+    const overall = buildOverallRow(perLanguage);
+    return {
+        generatedAt: now.toISOString(),
+        perLanguage,
+        overall,
+    };
+}
+function makeEmptyCounts() {
+    return {
+        totalCalls: 0,
+        bothAgree: 0,
+        onlyLegacy: 0,
+        onlyNew: 0,
+        bothDisagree: 0,
+        bothEmpty: 0,
+        evidenceBreakdown: new Map(),
+    };
+}
+function tallyDiff(counts, diff) {
+    counts.totalCalls += 1;
+    incrementAgreement(counts, diff.agreement);
+    if (diff.agreement === 'both-agree' || diff.agreement === 'both-empty')
+        return;
+    for (const ev of diff.evidenceDelta) {
+        counts.evidenceBreakdown.set(ev.kind, (counts.evidenceBreakdown.get(ev.kind) ?? 0) + 1);
+    }
+}
+function incrementAgreement(counts, agreement) {
+    switch (agreement) {
+        case 'both-agree':
+            counts.bothAgree += 1;
+            return;
+        case 'only-legacy':
+            counts.onlyLegacy += 1;
+            return;
+        case 'only-new':
+            counts.onlyNew += 1;
+            return;
+        case 'both-disagree':
+            counts.bothDisagree += 1;
+            return;
+        case 'both-empty':
+            counts.bothEmpty += 1;
+            return;
+    }
+}
+function buildRow(language, counts) {
+    const resolved = counts.totalCalls - counts.bothEmpty;
+    const parity = resolved > 0 ? counts.bothAgree / resolved : 0;
+    return {
+        language,
+        totalCalls: counts.totalCalls,
+        bothAgree: counts.bothAgree,
+        onlyLegacy: counts.onlyLegacy,
+        onlyNew: counts.onlyNew,
+        bothDisagree: counts.bothDisagree,
+        bothEmpty: counts.bothEmpty,
+        parity,
+        // Freeze via `new Map` on a sorted-kind copy so downstream consumers
+        // can't mutate the aggregator's internal state.
+        evidenceBreakdown: new Map(Array.from(counts.evidenceBreakdown.entries()).sort(([a], [b]) => a.localeCompare(b))),
+    };
+}
+function buildOverallRow(perLanguage) {
+    let totalCalls = 0;
+    let bothAgree = 0;
+    let onlyLegacy = 0;
+    let onlyNew = 0;
+    let bothDisagree = 0;
+    let bothEmpty = 0;
+    for (const row of perLanguage) {
+        totalCalls += row.totalCalls;
+        bothAgree += row.bothAgree;
+        onlyLegacy += row.onlyLegacy;
+        onlyNew += row.onlyNew;
+        bothDisagree += row.bothDisagree;
+        bothEmpty += row.bothEmpty;
+    }
+    const resolved = totalCalls - bothEmpty;
+    const parity = resolved > 0 ? bothAgree / resolved : 0;
+    return { totalCalls, bothAgree, onlyLegacy, onlyNew, bothDisagree, bothEmpty, parity };
+}
+//# sourceMappingURL=aggregate.js.map

package/dist/_shared/scope-resolution/shadow/aggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.js","sourceRoot":"","sources":["../../../src/scope-resolution/shadow/aggregate.ts"],"names":[],"mappings":"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"}

package/dist/_shared/scope-resolution/shadow/diff.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shadow-mode diff logic — RFC §6.3.
+ *
+ * Pure comparison logic for shadow mode. Takes two `Resolution[]` (legacy
+ * DAG result + new scope-based registry result) and produces a structured
+ * diff record for the parity dashboard.
+ *
+ * Consumed by the Ring 2 PKG shadow harness (#923), which dual-runs each
+ * call through legacy + new paths, diffs results, and persists per-run JSON
+ * for the parity dashboard.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #918.
+ */
+import type { Resolution, ResolutionEvidence } from '../types.js';
+export type ShadowAgreement = 'both-agree' | 'only-legacy' | 'only-new' | 'both-disagree' | 'both-empty';
+export interface ShadowDiff {
+    readonly callsite: ShadowCallsite;
+    readonly legacy: Resolution | null;
+    readonly newResult: Resolution | null;
+    readonly agreement: ShadowAgreement;
+    /**
+     * Symmetric difference of the two top resolutions' `evidence` arrays,
+     * keyed on `ResolutionEvidence.kind`.
+     *
+     * - For `'both-agree'` and `'both-empty'` agreements, always empty.
+     * - For `'both-disagree'`, contains evidence kinds present on exactly one
+     *   side (not in both).
+     * - For `'only-legacy'`, contains all of legacy's top evidence.
+     * - For `'only-new'`, contains all of new's top evidence.
+     */
+    readonly evidenceDelta: readonly ResolutionEvidence[];
+}
+export interface ShadowCallsite {
+    readonly filePath: string;
+    readonly line: number;
+    readonly col: number;
+    readonly calledName: string;
+}
+/**
+ * Compare two `Resolution[]` arrays (top matches at `[0]`) and produce a
+ * `ShadowDiff`. Pure function.
+ *
+ * Agreement rules:
+ * - both arrays empty → `'both-empty'`, `evidenceDelta: []`
+ * - legacy empty, new non-empty → `'only-new'`, `evidenceDelta` = new's top evidence
+ * - legacy non-empty, new empty → `'only-legacy'`, `evidenceDelta` = legacy's top evidence
+ * - both non-empty, same top `def.nodeId` → `'both-agree'`, `evidenceDelta: []`
+ * - both non-empty, different top `def.nodeId` → `'both-disagree'`,
+ *   `evidenceDelta` = symmetric difference by `ResolutionEvidence.kind`
+ *   (first occurrence of a kind-only-on-legacy then kind-only-on-new; order
+ *   preserved from input arrays)
+ *
+ * Evidence-delta rationale: callers aggregating divergences want to know
+ * which signal kinds explain a disagreement. Keying on `kind` (not full
+ * equality over `weight`/`note`) avoids spurious deltas when the same
+ * signal fires with slightly different calibration weights on each side.
+ */
+export declare function diffResolutions(callsite: ShadowCallsite, legacy: readonly Resolution[], newResult: readonly Resolution[]): ShadowDiff;
+//# sourceMappingURL=diff.d.ts.map

package/dist/_shared/scope-resolution/shadow/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/scope-resolution/shadow/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAIlE,MAAM,MAAM,eAAe,GACvB,YAAY,GACZ,aAAa,GACb,UAAU,GACV,eAAe,GACf,YAAY,CAAC;AAEjB,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,UAAU,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;IACpC;;;;;;;;;OASG;IACH,QAAQ,CAAC,aAAa,EAAE,SAAS,kBAAkB,EAAE,CAAC;CACvD;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,SAAS,UAAU,EAAE,EAC7B,SAAS,EAAE,SAAS,UAAU,EAAE,GAC/B,UAAU,CAoBZ"}

package/dist/_shared/scope-resolution/shadow/diff.js

@@ -0,0 +1,79 @@
+/**
+ * Shadow-mode diff logic — RFC §6.3.
+ *
+ * Pure comparison logic for shadow mode. Takes two `Resolution[]` (legacy
+ * DAG result + new scope-based registry result) and produces a structured
+ * diff record for the parity dashboard.
+ *
+ * Consumed by the Ring 2 PKG shadow harness (#923), which dual-runs each
+ * call through legacy + new paths, diffs results, and persists per-run JSON
+ * for the parity dashboard.
+ *
+ * Part of RFC #909 Ring 2 SHARED — #918.
+ */
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Compare two `Resolution[]` arrays (top matches at `[0]`) and produce a
+ * `ShadowDiff`. Pure function.
+ *
+ * Agreement rules:
+ * - both arrays empty → `'both-empty'`, `evidenceDelta: []`
+ * - legacy empty, new non-empty → `'only-new'`, `evidenceDelta` = new's top evidence
+ * - legacy non-empty, new empty → `'only-legacy'`, `evidenceDelta` = legacy's top evidence
+ * - both non-empty, same top `def.nodeId` → `'both-agree'`, `evidenceDelta: []`
+ * - both non-empty, different top `def.nodeId` → `'both-disagree'`,
+ *   `evidenceDelta` = symmetric difference by `ResolutionEvidence.kind`
+ *   (first occurrence of a kind-only-on-legacy then kind-only-on-new; order
+ *   preserved from input arrays)
+ *
+ * Evidence-delta rationale: callers aggregating divergences want to know
+ * which signal kinds explain a disagreement. Keying on `kind` (not full
+ * equality over `weight`/`note`) avoids spurious deltas when the same
+ * signal fires with slightly different calibration weights on each side.
+ */
+export function diffResolutions(callsite, legacy, newResult) {
+    const legacyTop = legacy.length > 0 ? legacy[0] : null;
+    const newTop = newResult.length > 0 ? newResult[0] : null;
+    const agreement = (() => {
+        if (legacyTop === null && newTop === null)
+            return 'both-empty';
+        if (legacyTop === null)
+            return 'only-new';
+        if (newTop === null)
+            return 'only-legacy';
+        return legacyTop.def.nodeId === newTop.def.nodeId ? 'both-agree' : 'both-disagree';
+    })();
+    const evidenceDelta = computeEvidenceDelta(legacyTop, newTop, agreement);
+    return {
+        callsite,
+        legacy: legacyTop,
+        newResult: newTop,
+        agreement,
+        evidenceDelta,
+    };
+}
+// ─── Internal helpers ───────────────────────────────────────────────────────
+/**
+ * Symmetric difference of two evidence arrays, keyed on
+ * `ResolutionEvidence.kind`. Preserves input order: legacy-only signals
+ * first (in legacy's original order), then new-only signals (in new's order).
+ *
+ * For `'both-agree'` / `'both-empty'` the delta is empty by contract. For
+ * `'only-legacy'` / `'only-new'` one side's evidence is the delta (nothing to
+ * subtract against).
+ */
+function computeEvidenceDelta(legacy, newResult, agreement) {
+    if (agreement === 'both-agree' || agreement === 'both-empty')
+        return [];
+    if (agreement === 'only-legacy')
+        return legacy.evidence;
+    if (agreement === 'only-new')
+        return newResult.evidence;
+    // both-disagree: symmetric difference keyed on `kind`
+    const legacyKinds = new Set(legacy.evidence.map((e) => e.kind));
+    const newKinds = new Set(newResult.evidence.map((e) => e.kind));
+    const onlyInLegacy = legacy.evidence.filter((e) => !newKinds.has(e.kind));
+    const onlyInNew = newResult.evidence.filter((e) => !legacyKinds.has(e.kind));
+    return [...onlyInLegacy, ...onlyInNew];
+}
+//# sourceMappingURL=diff.js.map

package/dist/_shared/scope-resolution/shadow/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../src/scope-resolution/shadow/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAsCH,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,eAAe,CAC7B,QAAwB,EACxB,MAA6B,EAC7B,SAAgC;IAEhC,MAAM,SAAS,GAAsB,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC1E,MAAM,MAAM,GAAsB,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAE7E,MAAM,SAAS,GAAoB,CAAC,GAAG,EAAE;QACvC,IAAI,SAAS,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,YAAY,CAAC;QAC/D,IAAI,SAAS,KAAK,IAAI;YAAE,OAAO,UAAU,CAAC;QAC1C,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,aAAa,CAAC;QAC1C,OAAO,SAAS,CAAC,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,eAAe,CAAC;IACrF,CAAC,CAAC,EAAE,CAAC;IAEL,MAAM,aAAa,GAAG,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;IAEzE,OAAO;QACL,QAAQ;QACR,MAAM,EAAE,SAAS;QACjB,SAAS,EAAE,MAAM;QACjB,SAAS;QACT,aAAa;KACd,CAAC;AACJ,CAAC;AAED,+EAA+E;AAE/E;;;;;;;;GAQG;AACH,SAAS,oBAAoB,CAC3B,MAAyB,EACzB,SAA4B,EAC5B,SAA0B;IAE1B,IAAI,SAAS,KAAK,YAAY,IAAI,SAAS,KAAK,YAAY;QAAE,OAAO,EAAE,CAAC;IACxE,IAAI,SAAS,KAAK,aAAa;QAAE,OAAO,MAAO,CAAC,QAAQ,CAAC;IACzD,IAAI,SAAS,KAAK,UAAU;QAAE,OAAO,SAAU,CAAC,QAAQ,CAAC;IAEzD,sDAAsD;IACtD,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,MAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAEjE,MAAM,YAAY,GAAG,MAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3E,MAAM,SAAS,GAAG,SAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;IAE9E,OAAO,CAAC,GAAG,YAAY,EAAE,GAAG,SAAS,CAAC,CAAC;AACzC,CAAC"}

package/dist/_shared/scope-resolution/symbol-definition.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `SymbolDefinition` — the canonical shape of an indexed symbol record.
+ *
+ * Historically defined in `gitnexus/src/core/ingestion/model/symbol-table.ts`;
+ * moved into `gitnexus-shared` as part of RFC #909 Ring 1 (#910) so the
+ * scope-resolution types that reference it can live in the shared package
+ * alongside their consumers (`gitnexus/` and `gitnexus-web/`).
+ *
+ * Shape is unchanged from the prior local definition.
+ */
+import type { NodeLabel } from '../graph/types.js';
+export interface SymbolDefinition {
+    nodeId: string;
+    filePath: string;
+    type: NodeLabel;
+    /** Canonical dot-separated qualified type name for class-like symbols
+     *  (e.g. `App.Models.User`). Falls back to the simple symbol name when no
+     *  package/namespace/module scope exists or no explicit qualified metadata is provided. */
+    qualifiedName?: string;
+    parameterCount?: number;
+    /** Number of required (non-optional, non-default) parameters.
+     *  Enables range-based arity filtering: argCount >= requiredParameterCount && argCount <= parameterCount. */
+    requiredParameterCount?: number;
+    /** Per-parameter type names for overload disambiguation (e.g. ['int', 'String']).
+     *  Populated when parameter types are resolvable from AST (any typed language). */
+    parameterTypes?: string[];
+    /** Raw return type text extracted from AST (e.g. 'User', 'Promise<User>') */
+    returnType?: string;
+    /** Declared type for non-callable symbols — fields/properties (e.g. 'Address', 'List<User>') */
+    declaredType?: string;
+    /** Links Method/Constructor/Property to owning Class/Struct/Trait nodeId */
+    ownerId?: string;
+}
+//# sourceMappingURL=symbol-definition.d.ts.map

package/dist/_shared/scope-resolution/symbol-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-definition.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB;;+FAE2F;IAC3F,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iHAC6G;IAC7G,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;uFACmF;IACnF,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/_shared/scope-resolution/symbol-definition.js

@@ -0,0 +1,12 @@
+/**
+ * `SymbolDefinition` — the canonical shape of an indexed symbol record.
+ *
+ * Historically defined in `gitnexus/src/core/ingestion/model/symbol-table.ts`;
+ * moved into `gitnexus-shared` as part of RFC #909 Ring 1 (#910) so the
+ * scope-resolution types that reference it can live in the shared package
+ * alongside their consumers (`gitnexus/` and `gitnexus-web/`).
+ *
+ * Shape is unchanged from the prior local definition.
+ */
+export {};
+//# sourceMappingURL=symbol-definition.js.map

package/dist/_shared/scope-resolution/symbol-definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-definition.js","sourceRoot":"","sources":["../../src/scope-resolution/symbol-definition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}