gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/shadow-harness.js

@@ -1,148 +0,0 @@
-/**
- * Shadow-mode parity harness — dual-run observability for the RFC #909
- * registry rollout (RFC §6.3; Ring 2 PKG #923).
- *
- * ## What it does
- *
- *   - Exposes `record({ language, callsite, legacy, newResult })` for
- *     every call site where the caller has BOTH a legacy-DAG resolution
- *     and a new `Registry.lookup` resolution.
- *   - Computes a `ShadowDiff` per record via shared `diffResolutions`
- *     (#918) and accumulates them in a per-language bucket.
- *   - At the end of a run, aggregates into a `ShadowParityReport` via
- *     shared `aggregateDiffs` (#918) — per-language parity %,
- *     evidence-kind breakdown of divergences, grand-total overall row.
- *   - Optionally persists the report as JSON under
- *     `.gitnexus/shadow-parity/` so the static dashboard at
- *     `gitnexus/shadow-parity-dashboard/` can render it offline.
- *
- * ## What it does NOT do
- *
- *   - **Invoke either resolution path itself.** The caller must run
- *     legacy + `Registry.lookup` and pass results in. The harness is a
- *     side-car, not a dispatcher — this keeps call-processor integration
- *     surgical when it lands (tracked as a follow-up; the shared model
- *     doesn't dual-invoke on its own).
- *   - **Flip anything.** `REGISTRY_PRIMARY_<LANG>` lives in
- *     `registry-primary-flag.ts` (#924); the harness records the
- *     caller-supplied "which side is primary" bit for each record so the
- *     dashboard can label rows, but it does not consult the flag itself.
- *
- * ## Activation
- *
- * `GITNEXUS_SHADOW_MODE=1` (or `'true'`, `'yes'`, case-insensitive,
- * trimmed) enables the harness. When disabled, `record()` is a cheap
- * no-op: no accumulation, no allocation beyond the harness object
- * itself. Callers can always construct a harness and hand it through;
- * the "off" overhead is near-zero.
- *
- * ## Persistence shape
- *
- * When `persist()` is called, the harness writes TWO files:
- *
- *   - `<outputDir>/<runId>.json` — the timestamped snapshot (immutable)
- *   - `<outputDir>/latest.json`  — a pointer that the dashboard reads
- *
- * Both files contain the same `PersistedShadowReport` payload:
- *
- *   {
- *     schemaVersion: 1,
- *     runId: "<iso-8601>-<rand>",
- *     generatedAt: "<iso-8601>",
- *     primaryByLanguage: { [lang]: "legacy" | "registry" },
- *     report: <ShadowParityReport>
- *   }
- *
- * Schema-version-gated so future format changes don't silently confuse
- * older dashboards. The dashboard renders `report.perLanguage` rows and
- * annotates each with `primaryByLanguage[lang]`.
- */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { aggregateDiffs, diffResolutions, } from '../../_shared/index.js';
-/**
- * Construct a harness. Reads `GITNEXUS_SHADOW_MODE` at construction time
- * (not per-`record()` call) so repeated no-op records don't re-check the
- * env var in the hot path.
- */
-export function createShadowHarness() {
-    const enabled = parseShadowModeEnv(process.env['GITNEXUS_SHADOW_MODE']);
-    const records = [];
-    const primaryByLanguage = {};
-    const recordImpl = (input) => {
-        if (!enabled)
-            return;
-        const diff = diffResolutions(input.callsite, input.legacy, input.newResult);
-        records.push({ language: input.language, diff });
-        // Primary per-language is resolved by last-write. In practice a run
-        // is single-threaded with respect to flag readings, so this is
-        // deterministic; a language's primary cannot change mid-run.
-        primaryByLanguage[input.language] = input.primary;
-    };
-    const snapshotImpl = (now = new Date()) => {
-        return aggregateDiffs(records, now);
-    };
-    const persistImpl = async (outputDir, now = new Date()) => {
-        await fs.mkdir(outputDir, { recursive: true });
-        const report = snapshotImpl(now);
-        const runId = makeRunId(now);
-        const payload = {
-            schemaVersion: 1,
-            runId,
-            generatedAt: now.toISOString(),
-            primaryByLanguage,
-            report,
-        };
-        const json = JSON.stringify(payload, null, 2);
-        const perRunPath = path.join(outputDir, `${runId}.json`);
-        const latestPath = path.join(outputDir, 'latest.json');
-        await fs.writeFile(perRunPath, json, 'utf8');
-        await fs.writeFile(latestPath, json, 'utf8');
-        return perRunPath;
-    };
-    const clearImpl = () => {
-        records.length = 0;
-        for (const key of Object.keys(primaryByLanguage)) {
-            delete primaryByLanguage[key];
-        }
-    };
-    return {
-        enabled,
-        record: recordImpl,
-        size: () => records.length,
-        snapshot: snapshotImpl,
-        persist: persistImpl,
-        clear: clearImpl,
-    };
-}
-// ─── Internal helpers ─────────────────────────────────────────────────────
-/**
- * Env-var parser for `GITNEXUS_SHADOW_MODE`. Accepts the same truthy
- * conventions as `REGISTRY_PRIMARY_<LANG>` from #924: `'true'` / `'1'` /
- * `'yes'`, case-insensitive, whitespace-trimmed. Anything else — including
- * `undefined`, `''`, `'false'`, `'off'`, typos — is false.
- */
-function parseShadowModeEnv(raw) {
-    if (raw === undefined)
-        return false;
-    const normalized = raw.trim().toLowerCase();
-    return normalized === 'true' || normalized === '1' || normalized === 'yes';
-}
-/**
- * Deterministic run id derived from the timestamp plus 4 random bytes
- * of entropy. The timestamp comes first so files sort chronologically;
- * the entropy suffix prevents collisions when multiple runs share a
- * clock-second. Shape: `YYYYMMDD-HHMMSS-xxxxxxxx`.
- */
-function makeRunId(now) {
-    const y = now.getUTCFullYear().toString().padStart(4, '0');
-    const m = (now.getUTCMonth() + 1).toString().padStart(2, '0');
-    const d = now.getUTCDate().toString().padStart(2, '0');
-    const h = now.getUTCHours().toString().padStart(2, '0');
-    const min = now.getUTCMinutes().toString().padStart(2, '0');
-    const s = now.getUTCSeconds().toString().padStart(2, '0');
-    const entropy = Math.floor(Math.random() * 0xffffffff)
-        .toString(16)
-        .padStart(8, '0');
-    return `${y}${m}${d}-${h}${min}${s}-${entropy}`;
-}

package/dist/core/ingestion/utils/ruby-self-call.d.ts

@@ -1,52 +0,0 @@
-/**
- * Ruby bare-call self-inference helper.
- *
- * Ruby makes `self` implicit for method calls inside instance and class bodies:
- * `serialize` inside `Account#call_serialize` means `self.serialize`. Other
- * supported languages make the receiver explicit in source (`this.x`, `self.x`),
- * so tree-sitter produces a member call directly. Ruby's bare identifier
- * produces either `callForm === 'free'` or `callForm === undefined` (body_statement
- * identifier captures where the @call node IS the @call.name node), and
- * `resolveFreeCall` does a global tiered name lookup — no MRO walk.
- *
- * This helper is a pure decision function consumed by the Ruby language
- * provider's `inferImplicitReceiver` hook. Shared pipeline code never imports
- * it directly — only `languages/ruby.ts` does.
- */
-import type { SyntaxNode } from './ast-helpers.js';
-import type { LanguageProvider } from '../language-provider.js';
-/**
- * Rewrite suggestion returned by `maybeRewriteRubyBareCallToSelf`.
- *
- * `callForm` is always `'member'`; `receiverName` is always `'self'`.
- * `dispatchKind` controls the stage-4 ancestry view:
- * - `'instance'` → prepend → direct → include (normal MRO)
- * - `'singleton'` → extend providers only, no file-scoped fallback
- *
- * Consumed by `languages/ruby.ts § inferImplicitReceiver` (wraps into
- * `ImplicitReceiverOverride`; `dispatchKind` becomes the `hint` field).
- */
-export interface SelfCallRewrite {
-    readonly callForm: 'member';
-    readonly receiverName: 'self';
-    readonly receiverTypeName: string;
-    /** `'singleton'` when the enclosing method is `def self.foo` / inside a
-     *  `singleton_class` body; `'instance'` otherwise. Controls MRO ancestry
-     *  view selection in stage-4 dispatch. */
-    readonly dispatchKind: 'instance' | 'singleton';
-}
-/**
- * Pure decision function: should a bare Ruby call be rewritten as `self.method`?
- *
- * Returns a `SelfCallRewrite` when all gates pass; null otherwise.
- * Gates (all required): `callForm` is `'free'` or `undefined`, strategy is
- * `'ruby-mixin'`, `enclosingClassName` is non-null, name is not `'super'`,
- * name is not a built-in.
- *
- * Note: Ruby body-statement identifiers produce `callForm === undefined` because
- * the @call node IS the @call.name node in tree-sitter-ruby.
- *
- * Example: `calledName='serialize'` in `Account` instance method →
- * `{callForm:'member', receiverName:'self', receiverTypeName:'Account', dispatchKind:'instance'}`
- */
-export declare function maybeRewriteRubyBareCallToSelf(calledName: string, callForm: 'free' | 'member' | 'constructor' | undefined, callNode: SyntaxNode, enclosingClassName: string | null, provider: Pick<LanguageProvider, 'isBuiltInName' | 'mroStrategy'>): SelfCallRewrite | null;

package/dist/core/ingestion/utils/ruby-self-call.js

@@ -1,59 +0,0 @@
-// gitnexus/src/core/ingestion/utils/ruby-self-call.ts
-/** Maximum parent-walk depth to prevent runaway traversal. */
-const MAX_PARENT_DEPTH = 50;
-/**
- * Returns true if `callNode` is inside a `singleton_method` or `singleton_class`.
- * Stops at `class`/`module` boundary or MAX_PARENT_DEPTH (50) to bound traversal.
- */
-function isInsideSingletonMethod(callNode) {
-    let current = callNode.parent;
-    let depth = 0;
-    while (current && depth++ < MAX_PARENT_DEPTH) {
-        if (current.type === 'singleton_method')
-            return true;
-        if (current.type === 'singleton_class')
-            return true;
-        if (current.type === 'class' || current.type === 'module')
-            return false;
-        current = current.parent;
-    }
-    return false;
-}
-/**
- * Pure decision function: should a bare Ruby call be rewritten as `self.method`?
- *
- * Returns a `SelfCallRewrite` when all gates pass; null otherwise.
- * Gates (all required): `callForm` is `'free'` or `undefined`, strategy is
- * `'ruby-mixin'`, `enclosingClassName` is non-null, name is not `'super'`,
- * name is not a built-in.
- *
- * Note: Ruby body-statement identifiers produce `callForm === undefined` because
- * the @call node IS the @call.name node in tree-sitter-ruby.
- *
- * Example: `calledName='serialize'` in `Account` instance method →
- * `{callForm:'member', receiverName:'self', receiverTypeName:'Account', dispatchKind:'instance'}`
- */
-export function maybeRewriteRubyBareCallToSelf(calledName, callForm, callNode, enclosingClassName, provider) {
-    // Body-statement bare identifiers produce `callForm === undefined` because
-    // the @call node IS the @call.name node in tree-sitter-ruby. Treat both
-    // undefined and 'free' as qualifying.
-    if (callForm !== 'free' && callForm !== undefined)
-        return null;
-    if (provider.mroStrategy !== 'ruby-mixin')
-        return null;
-    if (!enclosingClassName)
-        return null;
-    if (calledName === 'super')
-        return null;
-    if (provider.isBuiltInName(calledName))
-        return null;
-    const dispatchKind = isInsideSingletonMethod(callNode)
-        ? 'singleton'
-        : 'instance';
-    return {
-        callForm: 'member',
-        receiverName: 'self',
-        receiverTypeName: enclosingClassName,
-        dispatchKind,
-    };
-}

package/scripts/ci-list-migrated-languages.ts

@@ -1,24 +0,0 @@
-/**
- * CI helper — emits the `MIGRATED_LANGUAGES` set as a JSON matrix array for
- * GitHub Actions (`.github/workflows/ci-scope-parity.yml`).
- *
- * Consumed by the `discover` job in that workflow. Each entry has:
- *   - `slug`: lowercase language id, matching `test/integration/resolvers/<slug>.test.ts`.
- *   - `envvar`: uppercase suffix used to build the `REGISTRY_PRIMARY_<envvar>` toggle.
- *
- * Run with `npx tsx scripts/ci-list-migrated-languages.ts`. The script
- * writes a single JSON array to stdout (no wrapper object) so the
- * workflow can pipe it straight into `$GITHUB_OUTPUT`.
- */
-
-import { MIGRATED_LANGUAGES } from '../src/core/ingestion/registry-primary-flag.js';
-
-const entries = [...MIGRATED_LANGUAGES].map((slug) => {
-  const s = String(slug);
-  return {
-    slug: s,
-    envvar: s.toUpperCase().replace(/-/g, '_'),
-  };
-});
-
-process.stdout.write(JSON.stringify(entries));

package/scripts/run-parity.ts

@@ -1,128 +0,0 @@
-/**
- * Consolidated scope-resolution parity runner.
- *
- * Replaces the per-language matrix in ci-scope-parity.yml with a single
- * job that runs all migrated languages sequentially in one process. This
- * eliminates 8× redundant checkout + npm ci + build cycles (the old
- * workflow created a separate GitHub Actions job per language).
- *
- * For each language in MIGRATED_LANGUAGES:
- *   1. Run its resolver test with REGISTRY_PRIMARY_<LANG>=0 (legacy DAG)
- *   2. Run its resolver test with REGISTRY_PRIMARY_<LANG>=1 (registry-primary)
- *
- * Both modes must pass. Failures are collected and reported at the end
- * so all regressions are visible in a single CI run (equivalent to the
- * old workflow's fail-fast: false behavior).
- *
- * Vitest output streams to the console in real time (stdio: 'inherit')
- * so CI logs show the actual test output directly. No per-invocation
- * timeout — the CI job-level timeout (30 min) is the outer guard.
- *
- * Usage:
- *   npx tsx scripts/run-parity.ts
- *   npx tsx scripts/run-parity.ts --language python   # single language
- */
-
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { MIGRATED_LANGUAGES } from '../src/core/ingestion/registry-primary-flag.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(__dirname, '..');
-
-interface ParityFailure {
-  lang: string;
-  mode: 'legacy' | 'registry-primary';
-}
-
-function envVarName(slug: string): string {
-  return `REGISTRY_PRIMARY_${slug.toUpperCase().replace(/-/g, '_')}`;
-}
-
-function testFilePath(slug: string): string {
-  return `test/integration/resolvers/${slug}.test.ts`;
-}
-
-function runVitest(testFile: string, env: Record<string, string>): boolean {
-  try {
-    execFileSync('npx', ['vitest', 'run', testFile], {
-      cwd: ROOT,
-      env: { ...process.env, ...env },
-      stdio: 'inherit',
-      shell: true,
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Parse CLI args
-const args = process.argv.slice(2);
-const langFlag = args.indexOf('--language');
-const singleLang = langFlag >= 0 ? args[langFlag + 1] : undefined;
-
-if (langFlag >= 0 && singleLang === undefined) {
-  console.error('--language requires a value');
-  process.exit(1);
-}
-
-const languages = singleLang ? [singleLang] : [...MIGRATED_LANGUAGES].map(String);
-
-// Verify test files exist before running
-const missingFiles: string[] = [];
-for (const lang of languages) {
-  const file = path.resolve(ROOT, testFilePath(lang));
-  try {
-    fs.accessSync(file);
-  } catch {
-    missingFiles.push(`${testFilePath(lang)} (${lang})`);
-  }
-}
-
-if (missingFiles.length > 0) {
-  console.error('Missing resolver test files:');
-  for (const f of missingFiles) console.error(`  ${f}`);
-  process.exit(1);
-}
-
-console.log(`Scope-resolution parity: ${languages.length} language(s)`);
-console.log(`Languages: ${languages.join(', ')}\n`);
-
-const failures: ParityFailure[] = [];
-
-for (const lang of languages) {
-  const file = testFilePath(lang);
-  const envVar = envVarName(lang);
-
-  console.log(`\n── ${lang} — legacy DAG (${envVar}=0) ──`);
-  if (!runVitest(file, { [envVar]: '0' })) {
-    failures.push({ lang, mode: 'legacy' });
-  }
-
-  console.log(`\n── ${lang} — registry-primary (${envVar}=1) ──`);
-  if (!runVitest(file, { [envVar]: '1' })) {
-    failures.push({ lang, mode: 'registry-primary' });
-  }
-}
-
-// Summary
-const total = languages.length * 2;
-const passed = total - failures.length;
-
-console.log('\n═══════════════════════════════════════');
-console.log('PARITY SUMMARY');
-console.log('═══════════════════════════════════════');
-console.log(`Passed: ${passed}/${total}`);
-
-if (failures.length > 0) {
-  console.log(`\nFAILURES (${failures.length}):`);
-  for (const f of failures) {
-    console.log(`  ✗ ${f.lang} [${f.mode}]`);
-  }
-  process.exit(1);
-}
-
-console.log('\nAll parity checks passed.');