gitnexus 1.6.10-rc.164 → 1.6.10-rc.166

package/dist/core/ingestion/languages/typescript/captures.js

@@ -629,8 +629,12 @@ export function emitTsScopeCaptures(sourceText, filePath, cachedTree) {
  * matching arms (member_expression for extends, nested_type_identifier plain +
  * generic-wrapped for implements).
  *
- * `interface_declaration` / `abstract_class_declaration` heritage is NOT emitted
- * by the synth. The EXTENDS-vs-IMPLEMENTS split is decided downstream from the
+ * `interface_declaration` and `abstract_class_declaration` heritage IS emitted
+ * (#2842 review; both were silently skipped before, so `interface B extends A`
+ * and `abstract class X implements I` produced no edge and every dispatch walk
+ * dead-ended on a bodiless declaration). They reach their bases by different
+ * shapes: an abstract class carries the same `class_heritage` child a concrete
+ * one does, while an interface's bases hang off `extends_type_clause` directly. The EXTENDS-vs-IMPLEMENTS split is decided downstream from the
  * resolved target's symbol kind in `preEmitInheritanceEdges` (class-extends →
  * EXTENDS, implements-interface / interface-target → IMPLEMENTS), so all bases
  * are emitted with the same `inherits` kind here. The base lookup name is
@@ -647,7 +651,26 @@ function synthesizeTsInheritanceReferences(root, out) {
             if (child !== null)
                 stack.push(child);
         }
-        if (node.type !== 'class_declaration')
+        // `interface B extends A, C` hangs its bases off an `extends_type_clause`
+        // DIRECTLY on the interface — there is no `class_heritage` wrapper, so the
+        // class path below cannot reach them (#2842 review). The clause's `type`
+        // field is `multiple: true`, so `childForFieldName('type')` would silently
+        // return only `A` and drop `C`; iterate the named children instead.
+        if (node.type === 'interface_declaration') {
+            for (const child of node.namedChildren) {
+                if (child === null || child.type !== 'extends_type_clause')
+                    continue;
+                for (const base of child.namedChildren) {
+                    emitTsInheritanceBase(base, out);
+                }
+            }
+            continue;
+        }
+        // `abstract class X implements I` carries an identical `class_heritage`
+        // child, so the existing body handles it once the node type is admitted.
+        // Omitting it severed the only link between an interface and the concrete
+        // classes below an abstract base — a whole subtree, not a leaf.
+        if (node.type !== 'class_declaration' && node.type !== 'abstract_class_declaration')
             continue;
         // Find the `class_heritage` child (holds extends / implements clauses).
         let heritage = null;

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -114,13 +114,23 @@
  *          languages that set `resolveThisViaEnclosingClass === true`;
  *          it intercepts every bare-`this` call/read/write site ahead of
  *          Case 4 and does NOT emit the interface-dispatch fan-out that
- *          Cases 0 and 4 both perform (Case 0 gained it in #2829), so
- *          enabling the toggle for a language changes that language's
- *          `this` dispatch semantics (see the toggle's doc below)
+ *          Cases 0, 3b and 4 all perform (Case 0 gained it in #2829 and
+ *          Case 3b in #2832, leaving 0.5 the only INSTANCE-receiver case
+ *          that folds or walks to a receiver type without fanning out.
+ *          Read that narrowly: Case 2 also walks an MRO and its binding
+ *          admits `Interface`, but its receiver IS the type name, so the
+ *          site is static dispatch and a fan-out would be wrong; Cases 3
+ *          and 5 resolve by direct lookup rather than a fold or MRO walk,
+ *          and no language is known to reach Case 3 with an Interface —
+ *          every one that could strips the namespace qualifier first,
+ *          sending it to Case 4), so enabling the toggle
+ *          for a language changes that language's `this` dispatch
+ *          semantics (see the toggle's doc below)
  *       4. Case 1 namespace-receiver
  *       5. Case 2 class-name receiver
  *       6. Case 3 dotted typeBinding for namespace prefix
- *       7. Case 3b chain-typebinding (compound resolver)
+ *       7. Case 3b chain-typebinding (compound resolver + interface-dispatch
+ *          fan-out on an Interface fold, #2832)
  *       8. Case 4 simple typeBinding (MRO walk + findOwnedMember)
  *     Reordering or merging cases changes resolution semantics. The
  *     numbering is part of the contract — keep the comments.

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.js

@@ -114,13 +114,23 @@
  *          languages that set `resolveThisViaEnclosingClass === true`;
  *          it intercepts every bare-`this` call/read/write site ahead of
  *          Case 4 and does NOT emit the interface-dispatch fan-out that
- *          Cases 0 and 4 both perform (Case 0 gained it in #2829), so
- *          enabling the toggle for a language changes that language's
- *          `this` dispatch semantics (see the toggle's doc below)
+ *          Cases 0, 3b and 4 all perform (Case 0 gained it in #2829 and
+ *          Case 3b in #2832, leaving 0.5 the only INSTANCE-receiver case
+ *          that folds or walks to a receiver type without fanning out.
+ *          Read that narrowly: Case 2 also walks an MRO and its binding
+ *          admits `Interface`, but its receiver IS the type name, so the
+ *          site is static dispatch and a fan-out would be wrong; Cases 3
+ *          and 5 resolve by direct lookup rather than a fold or MRO walk,
+ *          and no language is known to reach Case 3 with an Interface —
+ *          every one that could strips the namespace qualifier first,
+ *          sending it to Case 4), so enabling the toggle
+ *          for a language changes that language's `this` dispatch
+ *          semantics (see the toggle's doc below)
  *       4. Case 1 namespace-receiver
  *       5. Case 2 class-name receiver
  *       6. Case 3 dotted typeBinding for namespace prefix
- *       7. Case 3b chain-typebinding (compound resolver)
+ *       7. Case 3b chain-typebinding (compound resolver + interface-dispatch
+ *          fan-out on an Interface fold, #2832)
  *       8. Case 4 simple typeBinding (MRO walk + findOwnedMember)
  *     Reordering or merging cases changes resolution semantics. The
  *     numbering is part of the contract — keep the comments.

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -18,8 +18,8 @@
  *      toggle unset skip this case entirely; their `this` sites fall
  *      through to Case 4 via the synthesized `this` typeBinding (which
  *      emits the interface-dispatch fan-out that this case does not —
- *      as does Case 0 since #2829; Case 0.5 remains the only resolving
- *      case without it).
+ *      as do Cases 0 since #2829 and 3b since #2832; Case 0.5 remains
+ *      the only fold-or-walk case without it).
  *   4. **Case 1 (namespace)** — receiver in `namespaceTargets` → exported def
  *   5. **Case 2 (class-name / static receiver)** — receiver resolves to a
  *      class-like binding (Class/Interface/Struct/Record/Enum/Trait) → MRO
@@ -29,7 +29,9 @@
  *   6. **Case 3 (dotted typeBinding for namespace prefix)** —
  *      `typeRef.rawName` like `models.User`
  *   7. **Case 3b (chain-typebinding)** — `typeRef.rawName` has a dot
- *      but not a namespace prefix → compound resolver
+ *      but not a namespace prefix → compound resolver. Also emits the
+ *      interface-dispatch fan-out when the folded receiver type is an
+ *      Interface (#2832) — same call Cases 0 and 4 make.
  *   8. **Case 4 (simple typeBinding)** — `typeRef.rawName` has no dot →
  *      MRO walk + `findOwnedMember`
  *   9. **Case 5 (value-receiver bridge)** — receiver is a `Const`/`Variable`

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -18,8 +18,8 @@
  *      toggle unset skip this case entirely; their `this` sites fall
  *      through to Case 4 via the synthesized `this` typeBinding (which
  *      emits the interface-dispatch fan-out that this case does not —
- *      as does Case 0 since #2829; Case 0.5 remains the only resolving
- *      case without it).
+ *      as do Cases 0 since #2829 and 3b since #2832; Case 0.5 remains
+ *      the only fold-or-walk case without it).
  *   4. **Case 1 (namespace)** — receiver in `namespaceTargets` → exported def
  *   5. **Case 2 (class-name / static receiver)** — receiver resolves to a
  *      class-like binding (Class/Interface/Struct/Record/Enum/Trait) → MRO
@@ -29,7 +29,9 @@
  *   6. **Case 3 (dotted typeBinding for namespace prefix)** —
  *      `typeRef.rawName` like `models.User`
  *   7. **Case 3b (chain-typebinding)** — `typeRef.rawName` has a dot
- *      but not a namespace prefix → compound resolver
+ *      but not a namespace prefix → compound resolver. Also emits the
+ *      interface-dispatch fan-out when the folded receiver type is an
+ *      Interface (#2832) — same call Cases 0 and 4 make.
  *   8. **Case 4 (simple typeBinding)** — `typeRef.rawName` has no dot →
  *      MRO walk + `findOwnedMember`
  *   9. **Case 5 (value-receiver bridge)** — receiver is a `Const`/`Variable`
@@ -306,6 +308,49 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             return false;
         return graph.getNode(graphId)?.properties.isAbstract === true;
     };
+    /**
+     * Can an INSTANCE-typed receiver reach this member? A static member cannot be,
+     * ever — `class C implements I { static save() {} }` does not satisfy `I`
+     * (TypeScript rejects it outright as TS2420, "Property 'save' is missing"), so
+     * an edge to it from an `I`-typed receiver names a target no dispatch can
+     * produce. Every comparable tool draws the same line: tsserver partitions
+     * static from instance results, clangd gates on `isVirtual()` (C++ forbids
+     * virtual statics), jdtls filters abstract-or-static, and class-hierarchy
+     * analysis expands only VIRTUAL call sites — a static call already has exactly
+     * one target and needs no fan-out.
+     *
+     * Two sources answer this, and the order matters:
+     *
+     *   1. `provider.isStaticOnly` when the language declares it. It is the
+     *      precise answer, because a language that needs the distinction defines
+     *      it exactly — Kotlin marks only COMPANION-promoted defs, so a Kotlin
+     *      `object Impl : Iface { override fun handle() }` is correctly kept: an
+     *      `object` is a singleton INSTANCE and its members really are reachable
+     *      through an `Iface`-typed receiver.
+     *   2. Otherwise the graph node's `isStatic`. For every language that does not
+     *      declare the hook, that flag comes from the member's own modifier (or,
+     *      for Ruby, from `singleton_class` — `def self.foo`, which is likewise
+     *      unreachable through an instance), so it means what we need here.
+     *
+     * Getting that order wrong is a live regression, not a hypothetical: the
+     * method extractor derives `isStatic` from the OWNER type as well as the
+     * member (`method-extractors/generic.ts`, `staticOwnerTypes`), and the JVM
+     * config lists `object_declaration`. Reading the flag first would delete
+     * Kotlin object implementations from the fan-out. A language that needs
+     * precision declares the hook; that is the upgrade path.
+     *
+     * Unresolvable defs fail open (treated as reachable), matching
+     * `isDeclarationOnly` and the rest of this pass.
+     */
+    const isUnreachableByInstanceDispatch = (def) => {
+        const staticOnly = provider.isStaticOnly;
+        if (staticOnly !== undefined)
+            return staticOnly(def) === true;
+        const graphId = resolveDefGraphId(def.filePath, def, nodeLookup);
+        if (graphId === undefined)
+            return false;
+        return graph.getNode(graphId)?.properties.isStatic === true;
+    };
     /**
      * Emit secondary CALLS edges with reason='interface-dispatch' when the primary
      * receiver-typed edge targeted an Interface's method.
@@ -357,6 +402,10 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 // implementation — keep descending past it rather than emitting to it.
                 if (isDeclarationOnly(implMember))
                     continue;
+                // Nor is a static member: no instance-typed receiver can reach one, so
+                // an edge to it is a target dispatch cannot produce (#2842 review).
+                if (isUnreachableByInstanceDispatch(implMember))
+                    continue;
                 targets.push(implMember);
             }
         }
@@ -958,6 +1007,43 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                         const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse, calleeCapture);
                         if (ok)
                             emitted++;
+                        // Interface dispatch, exactly as Cases 0 and 4 do it (#2832). Case
+                        // 3b folds a chain to a receiver type through the SAME
+                        // `resolveCompoundReceiverClass` call and the same MRO walk Case 0
+                        // uses, so when that fold lands on an Interface the primary edge
+                        // above names the interface's own bodiless DECLARATION and nothing
+                        // reaches the implementations.
+                        //
+                        // Leaving 3b out made the fan-out a property of how the receiver
+                        // was SPELLED rather than of what it resolved to: `d.repo.save()`
+                        // took Case 0 and fanned out, while binding the identical field to
+                        // a local first (`const r = d.repo; r.save()`) took Case 3b and
+                        // did not. #2829 closed that gap for Case 0 and left this half of
+                        // it open (#2832).
+                        //
+                        // `ownerDef` is the receiver's own folded type — matching Case 0's
+                        // `currentClass` and Case 4's `ownerDef` — NOT the owner of the
+                        // member the MRO walk settled on. That distinction matters: a
+                        // receiver that folds to a concrete class merely INHERITING an
+                        // interface method must not fan out, because its runtime type is
+                        // that class. `emitInterfaceDispatchFor` self-gates on
+                        // `ownerDef.type !== 'Interface'`, so this is inert for every
+                        // concrete receiver and needs no language check of its own.
+                        //
+                        // That gate is deliberately narrower than "the primary landed on
+                        // something bodiless": a chain folding to an ABSTRACT class also
+                        // dead-ends on a declaration-only member and does NOT fan out
+                        // here. Widening it to `|| isDeclarationOnly(memberDef)` would
+                        // cover that, but it changes Cases 0 and 4 identically and for
+                        // every language, so it is not #2832's to make.
+                        //
+                        // Confidence mirrors THIS case's own primary emit above — the 0.85
+                        // literal — so a site's dispatch edges never claim more certainty
+                        // than the edge they hang off. Case 4 passes a site.kind-dependent
+                        // value instead because ITS primary varies that way; Case 3b's
+                        // primary, like Case 0's, does not, so there is no 1.0 arm here to
+                        // mirror.
+                        emitted += emitInterfaceDispatchFor(ownerDef, memberName, memberDef, site, 0.85, calleeCapture);
                         // Always mark handled when the site was resolved, even
                         // if the edge was deduplicated (collapse mode), so
                         // `emitReferencesViaLookup` doesn't re-emit from the

package/dist/mcp/local/local-backend.d.ts

@@ -155,6 +155,7 @@ interface RepoHandle {
  * and cannot be changed mid-process.
  */
 export declare function resolveWorktreeCwd(repoPath: string, launchCwd: string): string;
+export declare function buildDetectChangesDiffArgs(scope: string, baseRef?: string): string[] | null;
 /**
  * Length of the path-derived suffix appended to a colliding repo id.
  * Exported so tests can pin the suffix shape without re-deriving the

package/dist/mcp/local/local-backend.js

@@ -544,6 +544,20 @@ export function resolveWorktreeCwd(repoPath, launchCwd) {
     }
     return repoPath;
 }
+export function buildDetectChangesDiffArgs(scope, baseRef) {
+    const args = ['diff', '--ignore-cr-at-eol'];
+    switch (scope) {
+        case 'staged':
+            return [...args, '--staged', '-U0'];
+        case 'all':
+            return [...args, 'HEAD', '-U0'];
+        case 'compare':
+            return baseRef ? [...args, baseRef, '-U0'] : null;
+        case 'unstaged':
+        default:
+            return [...args, '-U0'];
+    }
+}
 /**
  * Length of the path-derived suffix appended to a colliding repo id.
  * Exported so tests can pin the suffix shape without re-deriving the
@@ -3942,25 +3956,11 @@ export class LocalBackend {
         await this.ensureInitialized(repo);
         const scope = params.scope || 'unstaged';
         const { execFileSync } = await import('child_process');
-        // Build git diff args based on scope (using execFileSync to avoid shell injection)
-        let diffArgs;
-        switch (scope) {
-            case 'staged':
-                diffArgs = ['diff', '--staged', '-U0'];
-                break;
-            case 'all':
-                diffArgs = ['diff', 'HEAD', '-U0'];
-                break;
-            case 'compare':
-                if (!params.base_ref)
-                    return { error: 'base_ref is required for "compare" scope' };
-                diffArgs = ['diff', params.base_ref, '-U0'];
-                break;
-            case 'unstaged':
-            default:
-                diffArgs = ['diff', '-U0'];
-                break;
-        }
+        // Ignore CR-only EOL differences, while preserving meaningful whitespace changes.
+        // execFileSync receives an argv array, so refs never pass through a shell.
+        const diffArgs = buildDetectChangesDiffArgs(scope, params.base_ref);
+        if (!diffArgs)
+            return { error: 'base_ref is required for "compare" scope' };
         let diffOutput;
         try {
             // Resolve the cwd for git diff.

package/dist/storage/parse-cache.js

@@ -219,7 +219,13 @@ import { fileURLToPath } from 'url';
 // value is unchanged by the rebase — the reason it was chosen is simply now
 // visible in the history above. RE-CHECK AGAINST origin/main IMMEDIATELY
 // BEFORE MERGING; this file records eight prior collisions, two EXACT.
-const SCHEMA_BUMP = 43;
+// Moved 43 -> 44 for #2842's TypeScript heritage capture, which now emits
+// `@reference.inherits` for `interface_declaration` and
+// `abstract_class_declaration`. That is PARSE-TIME emission, so a v43 warm
+// cache would serve entries that are missing those matches entirely — the
+// exact failure a bump exists to prevent. Verified against origin/main at
+// a857f4c5a, which is still on 43, so 44 is free. RE-CHECK BEFORE MERGE.
+const SCHEMA_BUMP = 44;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.164",
+  "version": "1.6.10-rc.166",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",