gitnexus 1.6.6-rc.133 → 1.6.6-rc.134

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

@@ -56,5 +56,14 @@ export interface SymbolDefinition {
     isExplicit?: 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`)
+     *  tagged during the C++ resolution phase. Lets the graph bridge retry a
+     *  namespace-prefixed node-lookup key and lets the qualified-base resolver
+     *  break same-tail cross-namespace inheritance ties. A deliberate sidecar,
+     *  separate from `qualifiedName`: it does NOT participate in graph node
+     *  identity (node keys derive from filePath/type/qualifiedName) and leaves the
+     *  qualifiedName-keyed resolution index untouched. Absent for the common case
+     *  (non-namespace-nested defs and all non-C++ languages). */
+    namespacePrefix?: string;
 }
 //# sourceMappingURL=symbol-definition.d.ts.map

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

@@ -1 +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,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACjE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,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;4FACwF;IACxF,oBAAoB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;yEAKqE;IACrE,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;4DAEwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}
+{"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,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAAC;IACjE,4CAA4C;IAC5C,WAAW,EAAE,OAAO,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3E,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,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;4FACwF;IACxF,oBAAoB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IAC5C,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gGAAgG;IAChG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gGAAgG;IAChG,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B;;;;;yEAKqE;IACrE,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;4DAEwD;IACxD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;iEAO6D;IAC7D,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/core/ingestion/call-processor.d.ts

@@ -1,231 +1,46 @@
+/**
+ * Route / fetch edge emission + exported-type-map helpers.
+ *
+ * The legacy call-resolution DAG that previously lived here (per-file type
+ * inference → receiver inference → dispatch selection → MRO walk over the
+ * legacy heritage map) was deleted in RING4-1 (#942): all languages now resolve
+ * calls through the scope-resolution registry pipeline. What remains are the
+ * language-agnostic edge emitters that are NOT part of call resolution:
+ *
+ *   - `processRoutesFromExtracted` — CALLS edges from framework routes
+ *     (e.g. Laravel) to their controller methods.
+ *   - `processNextjsFetchRoutes` / `extractFetchCallsFromFiles` /
+ *     `extractConsumerAccessedKeys` — FETCHES edges from `fetch()` calls to
+ *     Next.js Route nodes.
+ *   - `buildExportedTypeMapFromGraph` — exported symbol → return/declared type
+ *     map, consumed by the cross-file enrichment pass.
+ */
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import type { SymbolDefinition } from '../../_shared/index.js';
-import type { SymbolTableReader, HeritageMap, ExtractedHeritage } from './model/index.js';
-import Parser from 'tree-sitter';
+import type { SymbolTableReader } from './model/index.js';
 import type { ResolutionContext } from './model/resolution-context.js';
-import type { TieredCandidates } from './model/resolution-context.js';
-import { SupportedLanguages } from '../../_shared/index.js';
-import type { TypeEnvironment } from './type-env.js';
-import type { BindingAccumulator } from './binding-accumulator.js';
-import type { ExtractedCall, ExtractedAssignment, ExtractedRoute, ExtractedFetchCall, FileConstructorBindings } from './workers/parse-worker.js';
-import type { LiteralTypeInferrer } from './type-extractors/types.js';
-import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { ExtractedRoute, ExtractedFetchCall } from './workers/parse-worker.js';
 /** Per-file resolved type bindings for exported symbols.
- *  Populated during call processing, consumed by Phase 14 re-resolution pass. */
+ *  Consumed by the cross-file re-resolution / enrichment pass. */
 export type ExportedTypeMap = Map<string, Map<string, string>>;
-/** Build a map of imported callee names → return types for cross-file call-result binding.
- *  Consulted ONLY when SymbolTable has no unambiguous local match (local-first principle).
- *
- *  Overlapping mechanism (1 of 3): this is the SymbolTable-backed path.
- *  See also:
- *    2. collectExportedBindings (~line 168) / enrichExportedTypeMap — TypeEnv + graph isExported
- *    3. Phase 9 fallback in verifyConstructorBindings (~line 563) — namedImportMap + BindingAccumulator
- *  A future cleanup should merge these into a single resolution pass. */
-export declare function buildImportedReturnTypes(filePath: string, namedImportMap: ReadonlyMap<string, ReadonlyMap<string, {
-    sourcePath: string;
-    exportedName: string;
-}>>, symbolTable: {
-    lookupExactFull(filePath: string, name: string): {
-        returnType?: string;
-    } | undefined;
-}): ReadonlyMap<string, string>;
-/** Build cross-file RAW return types for imported callables.
- *  Unlike buildImportedReturnTypes (which stores extractReturnTypeName output),
- *  this stores the raw declared return type string (e.g., 'User[]', 'List<User>').
- *  Used by lookupRawReturnType for for-loop element extraction via extractElementTypeFromString. */
-export declare function buildImportedRawReturnTypes(filePath: string, namedImportMap: ReadonlyMap<string, ReadonlyMap<string, {
-    sourcePath: string;
-    exportedName: string;
-}>>, symbolTable: {
-    lookupExactFull(filePath: string, name: string): {
-        returnType?: string;
-    } | undefined;
-}): ReadonlyMap<string, string>;
-/** Build ExportedTypeMap from graph nodes — used for worker path where TypeEnv
- *  is not available in the main thread. Collects returnType/declaredType from
- *  exported symbols that have callables with known return types. */
+/** Build ExportedTypeMap from graph nodes — used for the worker path where the
+ *  sequential TypeEnv is not available in the main thread. Collects
+ *  returnType/declaredType from exported symbols with known types. */
 export declare function buildExportedTypeMapFromGraph(graph: KnowledgeGraph, symbolTable: SymbolTableReader): ExportedTypeMap;
-/** Seed cross-file receiver types into pre-extracted call records.
- *  Fills missing receiverTypeName for single-hop imported variables
- *  using ExportedTypeMap + namedImportMap — zero disk I/O, zero AST re-parsing.
- *  Mutates calls in-place. Runs BEFORE processCallsFromExtracted. */
-export declare function seedCrossFileReceiverTypes(calls: ExtractedCall[], namedImportMap: ReadonlyMap<string, ReadonlyMap<string, {
-    sourcePath: string;
-    exportedName: string;
-}>>, exportedTypeMap: ReadonlyMap<string, ReadonlyMap<string, string>>): {
-    enrichedCount: number;
-};
-/**
- * Resolution result with confidence scoring
- */
-interface ResolveResult {
-    nodeId: string;
-    confidence: number;
-    reason: string;
-    returnType?: string;
-}
-export declare const processCalls: (graph: KnowledgeGraph, files: {
-    path: string;
-    content: string;
-}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, exportedTypeMap?: ExportedTypeMap, 
-/** Phase 14: pre-resolved cross-file bindings to seed into buildTypeEnv. Keyed by filePath → Map<localName, typeName>. */
-importedBindingsMap?: ReadonlyMap<string, ReadonlyMap<string, string>>, 
-/** Phase 14 E3: cross-file return types for imported callables. Keyed by filePath → Map<calleeName, returnType>.
- *  Consulted ONLY when SymbolTable has no unambiguous match (local-first principle). */
-importedReturnTypesMap?: ReadonlyMap<string, ReadonlyMap<string, string>>, 
-/** Phase 14 E3: cross-file RAW return types for for-loop element extraction. Keyed by filePath → Map<calleeName, rawReturnType>. */
-importedRawReturnTypesMap?: ReadonlyMap<string, ReadonlyMap<string, string>>, heritageMap?: HeritageMap, bindingAccumulator?: BindingAccumulator, 
-/**
- * Optional cache for compiled `Parser.Query` objects keyed by language name.
- * When provided, compiled queries are reused across calls instead of being
- * re-compiled from the query string for every file. Callers that invoke
- * `processCalls` many times with single-file batches (e.g. the cross-file
- * propagation phase) should pass a long-lived map here to avoid O(N)
- * query recompilation overhead.
- */
-compiledQueryCache?: Map<SupportedLanguages, Parser.Query>) => Promise<ExtractedHeritage[]>;
-/** Per-file cache for module-alias widening. Cleared between files. */
-type WidenCache = Map<string, readonly SymbolDefinition[]>;
-/**
- * Optional hints for overload disambiguation via argument literal types.
- * Only available on the sequential path (has AST); worker path passes undefined.
- *
- * @internal Exported so tests can exercise the D0 skip-condition path without
- *           constructing a real SyntaxNode. Do not use outside `call-processor.ts`
- *           and its unit tests.
- */
-export interface OverloadHints {
-    callNode: SyntaxNode;
-    inferLiteralType: LiteralTypeInferrer;
-    typeEnv?: TypeEnvironment;
-}
-/** @internal Exported for unit tests. Do not use outside tests. */
-export declare const _resolveCallTargetForTesting: (call: Pick<ExtractedCall, "calledName" | "argCount" | "callForm" | "receiverTypeName" | "receiverName">, currentFile: string, ctx: ResolutionContext, opts?: {
-    overloadHints?: OverloadHints;
-    widenCache?: WidenCache;
-    preComputedArgTypes?: (string | undefined)[];
-    heritageMap?: HeritageMap;
-}) => ResolveResult | null;
-/**
- * Resolve a member call using owner-scoped + MRO resolution only (no fuzzy lookup).
- * Used for `obj.method()` calls where the receiver type is known.
- *
- * Delegates to {@link resolveMethodByOwner} which performs an O(1) owner-scoped
- * method lookup and, when a {@link HeritageMap} is provided, walks the MRO chain
- * via {@link lookupMethodByOwnerWithMRO}.
- *
- * {@link resolveCallTarget} delegates here for member calls.
- *
- * **SEMANTIC CHANGE (2026-04-09):** The confidence tier reflects how the
- * owner TYPE was resolved, not how the method NAME was resolved globally.
- * more accurate for owner-scoped resolution (the discriminant IS the class,
- * not the method name). Downstream consumers that filter CALLS edges by
- * confidence threshold may see shifted values on otherwise-unchanged code.
- * See the "returns result with correct confidence tier" tests below for the
- * locked-in behavior.
- *
- * **Performance:** Callers that only need the return type (e.g. `walkMixedChain`)
- * should call {@link resolveMethodByOwner} directly and use the `.def.returnType`
- * field instead, to avoid building a throwaway `ResolveResult`.
- *
- * @param ownerType   - The receiver's type name (e.g. 'User')
- * @param methodName  - The method being called (e.g. 'save')
- * @param currentFile - File path of the call site
- * @param ctx         - Resolution context
- * @param heritageMap - Optional heritage map for MRO-aware ancestor walking
- */
-export declare const resolveMemberCall: (ownerType: string, methodName: string, currentFile: string, ctx: ResolutionContext, heritageMap?: HeritageMap, argCount?: number, ancestryView?: "instance" | "singleton") => ResolveResult | null;
-/**
- * Resolve a free-function call using `lookupExact` (same-file) + import-scoped
- * resolution via `ctx.resolve()`.
- *
- * Used for `foo()`, `doStuff()` — unqualified calls with no receiver.
- * Also handles implicit constructors (`User()` without `new`) by delegating
- * to {@link resolveStaticCall} when the tiered pool contains class-like
- * targets.
- *
- * {@link resolveCallTarget} delegates here for `callForm === 'free'`.
- *
- * `resolveFreeCall` does not take a `widenCache` parameter. Free calls
- * have no receiver type and rely exclusively on the tiered pool
- * from `ctx.resolve()`.
- *
- * @param calledName  - The called function name (e.g. 'doStuff')
- * @param filePath    - File path of the call site
- * @param ctx         - Resolution context
- * @param argCount    - Optional argument count for arity filtering
- * @param tieredOverride - Pre-computed tiered candidates from an upstream
- *                       `ctx.resolve` call. When provided, skips the redundant
- *                       lookup inside this function.
- * @param overloadHints  - Optional AST-based overload disambiguation hints
- * @param preComputedArgTypes - Optional pre-computed argument types (worker path)
- */
-export declare const resolveFreeCall: (calledName: string, filePath: string, ctx: ResolutionContext, argCount?: number, tieredOverride?: TieredCandidates, overloadHints?: OverloadHints, preComputedArgTypes?: (string | undefined)[]) => ResolveResult | null;
 /**
- * Resolve a constructor or static call using class-scoped lookup (no fuzzy lookup).
- * Used for `new User()` / `User()` calls where the calledName targets a class.
- *
- * Uses {@link TypeRegistry.lookupClassByName} for O(1) class lookup and
- * {@link MethodRegistry.lookupMethodByOwner} for constructor resolution.
- * {@link resolveCallTarget} delegates here for constructor and free-form calls
- * that target a class.
- *
- * Resolution strategy:
- *   1. `lookupClassByName(className)` — O(1) pre-check; bail early if no class exists.
- *   2. `ctx.resolve(className, currentFile)` — import-scoped tier for confidence.
- *   3. Filter to class-like candidates via `CLASS_LIKE_TYPES` and walk each
- *      with `lookupMethodByOwner(classNodeId, className, argCount)` — O(1)
- *      constructor lookup. Only accept results with `type === 'Constructor'`.
- *   4. If step 3 found nothing and the tiered pool contains ownerless
- *      `Constructor` nodes (common in some extractors), bail out so
- *      `filterCallableCandidates` downstream handles Constructor-vs-Class
- *      preference correctly.
- *   5. Class-node fallback: filter `classCandidates` through
- *      `INSTANTIABLE_CLASS_TYPES` and return the sole survivor when there is
- *      exactly one. Null-route on zero survivors (Interface / Trait / Impl
- *      stripped) or multiple (homonym ambiguity).
- *
- * @param className   - The class name (e.g. 'User'). Also used as the method
- *                       name for the `lookupMethodByOwner` scan, because the
- *                       only constructor-shaped call we handle today is
- *                       `ClassName(...)` / `new ClassName(...)`. Named
- *                       constructors like Dart `User.fromJson()` arrive as
- *                       member calls and route through `resolveMemberCall`,
- *                       so this function does not yet need a separate
- *                       `methodName` parameter. Revisit if a language surfaces
- *                       a static-method-shaped call with a distinct member
- *                       name.
- * @param currentFile - File path of the call site
- * @param ctx         - Resolution context
- * @param argCount    - Optional argument count for arity filtering
- * @param tieredOverride - Pre-computed tiered candidates for `className` from
- *                       an upstream `ctx.resolve` call. When provided, skips
- *                       the redundant lookup inside this function. Leave
- *                       unset for direct callers without a prior resolution.
+ * Create CALLS edges from extracted framework routes (e.g. Laravel) to their
+ * controller methods. Runs for all languages — independent of call resolution.
  */
-export declare const resolveStaticCall: (className: string, currentFile: string, ctx: ResolutionContext, argCount?: number, tieredOverride?: TieredCandidates, overloadHints?: OverloadHints, preComputedArgTypes?: (string | undefined)[]) => ResolveResult | null;
+export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
 /**
- * Fast path: resolve pre-extracted call sites from workers.
- * No AST parsing — workers already extracted calledName + sourceId.
+ * Extract property access keys from a consumer file's source code near fetch calls.
  *
- * @param bindingAccumulator  Phase 9: optional accumulator carrying file-scope
- *   TypeEnv bindings from all worker-processed files. When the SymbolTable has
- *   no return type for a cross-file callee, `verifyConstructorBindings` falls
- *   back to the accumulator via `namedImportMap` to bind the variable to the
- *   callee's resolved type (e.g. `var x = getUser()` → `x: User`).
+ * Looks for destructuring (`const { data } = await res.json()`), property access
+ * (`response.data`), and optional chaining (`data?.key`). Returns deduplicated
+ * top-level property names accessed on the response. Scans the whole file, so
+ * all accessed keys are attributed to each fetch — acceptable for regex-based
+ * extraction.
  */
-export declare const processCallsFromExtracted: (graph: KnowledgeGraph, extractedCalls: ExtractedCall[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, constructorBindings?: FileConstructorBindings[], heritageMap?: HeritageMap, bindingAccumulator?: BindingAccumulator) => Promise<void>;
-/**
- * Resolve pre-extracted field write assignments to ACCESSES {reason: 'write'} edges.
- * Accepts optional constructorBindings for return-type-aware receiver inference,
- * mirroring processCallsFromExtracted's verified binding lookup.
- */
-export declare const processAssignmentsFromExtracted: (graph: KnowledgeGraph, assignments: ExtractedAssignment[], ctx: ResolutionContext, constructorBindings?: FileConstructorBindings[], bindingAccumulator?: BindingAccumulator) => void;
-/**
- * Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods.
- */
-export declare const processRoutesFromExtracted: (graph: KnowledgeGraph, extractedRoutes: ExtractedRoute[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
 export declare const extractConsumerAccessedKeys: (content: string) => string[];
 /**
  * Create FETCHES edges from extracted fetch() calls to matching Route nodes.
@@ -243,4 +58,3 @@ export declare const extractFetchCallsFromFiles: (files: {
     path: string;
     content: string;
 }[], astCache: ASTCache) => Promise<ExtractedFetchCall[]>;
-export {};