gitnexus 1.6.6-rc.143 → 1.6.6-rc.145

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

@@ -161,7 +161,101 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         }
         out.push(grouped);
     }
-    return [...resolveVarTypeBindings(out), ...synthesizeJavaInheritanceReferences(tree.rootNode)];
+    return [
+        ...resolveVarTypeBindings(out),
+        ...synthesizeJavaInheritanceReferences(tree.rootNode),
+        ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
+    ];
+}
+/**
+ * Synthesize `@reference.call.constructor` captures for explicit constructor
+ * invocations — `super(...)` and `this(...)` (F38 #1928). tree-sitter-java
+ * models these as `explicit_constructor_invocation` nodes, which the scope
+ * query does not match, so the chained-constructor CALLS edges (subclass ctor →
+ * superclass ctor; ctor → sibling overload) were silently dropped.
+ *
+ * The grammar gives no constructor *name* at the call site (the child is a bare
+ * `(super)` / `(this)` token), so the target name is resolved structurally:
+ *   - `this(...)`  → the enclosing type's own simple name (constructor symbols
+ *                    are keyed by the declaring class name).
+ *   - `super(...)` → the enclosing class's superclass simple-name tail (reusing
+ *                    `javaBaseLookupNameNode` so qualified/generic supers reduce
+ *                    to the bare class name, matching the EXTENDS synth). An
+ *                    implicit `Object` super (no `superclass` field) has no
+ *                    in-graph symbol, so it is skipped rather than emitting a
+ *                    dangling reference.
+ * Arity is attached so overloaded constructors disambiguate downstream, mirroring
+ * the call-site arity synthesized for `new X(...)`.
+ */
+function synthesizeJavaExplicitConstructorReferences(root) {
+    const out = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'explicit_constructor_invocation') {
+            emitJavaExplicitConstructorRef(out, node);
+        }
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    return out;
+}
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'enum_declaration',
+    'record_declaration',
+]);
+function emitJavaExplicitConstructorRef(out, node) {
+    const ctor = node.childForFieldName('constructor');
+    if (ctor === null)
+        return;
+    const enclosingType = findEnclosingTypeDeclaration(node);
+    if (enclosingType === null)
+        return;
+    let targetNameNode = null;
+    if (ctor.type === 'this') {
+        targetNameNode = enclosingType.childForFieldName('name');
+    }
+    else if (ctor.type === 'super') {
+        // Only class_declaration carries a `superclass` field; enum/record cannot
+        // declare an explicit superclass, so `super(...)` there has no resolvable
+        // target symbol.
+        const superclass = enclosingType.childForFieldName('superclass');
+        if (superclass === null)
+            return;
+        for (const base of superclass.namedChildren) {
+            if (base === null)
+                continue;
+            const nameNode = javaBaseLookupNameNode(base);
+            if (nameNode !== null) {
+                targetNameNode = nameNode;
+                break;
+            }
+        }
+    }
+    if (targetNameNode === null)
+        return;
+    const argList = node.childForFieldName('arguments');
+    const args = argList === null
+        ? []
+        : argList.namedChildren.filter((c) => c !== null && c.type !== 'block_comment' && c.type !== 'line_comment');
+    out.push({
+        '@reference.call.constructor': nodeToCapture('@reference.call.constructor', node),
+        '@reference.name': nodeToCapture('@reference.name', targetNameNode),
+        '@reference.arity': syntheticCapture('@reference.arity', node, String(args.length)),
+    });
+}
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
 }
 /**
  * Synthesize `@reference.inherits` captures from Java class heritage so the

package/dist/core/ingestion/languages/java/interpret.js

@@ -67,10 +67,14 @@ export function interpretJavaTypeBinding(captures) {
     const typeCap = captures['@type-binding.type'];
     if (nameCap === undefined || typeCap === undefined)
         return null;
-    // Strip qualifier first so that `com.example.BaseModel<T>` becomes
-    // `BaseModel<T>` before stripGeneric — the JVM-erasure fallback pattern
-    // requires an unqualified identifier at the start of the string.
-    const rawType = stripGeneric(stripQualifier(typeCap.text.trim()));
+    // Strip generics BEFORE the qualifier (F41 #1928). Stripping the qualifier
+    // first uses `lastIndexOf('.')`, which for a qualified *type argument*
+    // (`Map<String, com.example.User>`) cuts inside the generic and yields a
+    // corrupted `User>`. Unwrapping generics first reduces the string to a single
+    // (possibly qualified) class name, then the qualifier strip leaves the bare
+    // simple name. `stripGeneric`'s erasure fallback is qualifier-tolerant so a
+    // qualified generic base (`com.example.BaseModel<T>`) still reduces correctly.
+    const rawType = stripQualifier(stripGeneric(typeCap.text.trim()));
     // Skip `var` — tree-sitter-java parses `var` as type_identifier with
     // text "var". When used without a constructor initializer, there's no
     // concrete type to bind.
@@ -120,8 +124,10 @@ function stripGeneric(text) {
     // `BaseModel<T>` → `BaseModel`, `Builder<Self>` → `Builder`.
     // This mirrors JVM type erasure — the raw class name is the resolvable symbol.
     // The pattern matches up to the first `<` to handle nested generics safely
-    // (e.g. `BaseModel<List<String>>` → `BaseModel`).
-    const fallback = text.match(/^([A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
+    // (e.g. `BaseModel<List<String>>` → `BaseModel`). The base is allowed to be
+    // qualified (`com.example.BaseModel<T>` → `com.example.BaseModel`) since the
+    // caller strips the qualifier afterwards (F41 #1928).
+    const fallback = text.match(/^((?:[A-Za-z_$][A-Za-z0-9_$]*\.)*[A-Za-z_$][A-Za-z0-9_$]*)<.+>$/s);
     if (fallback !== null)
         return fallback[1].trim();
     return text;

package/dist/core/ingestion/languages/java/query.js

@@ -212,8 +212,23 @@ const JAVA_SCOPE_QUERY = `
   type: (generic_type
     (type_identifier) @reference.name)) @reference.call.constructor
 
+;; References — qualified constructor calls: new pkg.Foo(), new a.b.Foo() (F35 #1928)
+;; tree-sitter-java parses \`pkg.Foo\` as a scoped_type_identifier whose final
+;; child is the simple type. Bind that tail as @reference.name (trailing \`.\`
+;; anchor = last child) so resolution targets \`Foo\`, not the raw \`pkg.Foo\` text.
+;; Mirrors the TS/JS new-expression qualified-constructor capture.
 (object_creation_expression
-  type: (scoped_type_identifier) @reference.call.constructor.qualified) @reference.call.constructor
+  type: (scoped_type_identifier
+    (type_identifier) @reference.name .) @reference.call.constructor.qualified) @reference.call.constructor
+
+;; References — qualified + generic constructor calls: new pkg.Box<T>() (F35 #1928)
+;; The base is a generic_type whose first child is a scoped_type_identifier, so
+;; neither the simple-generic nor the plain-scoped arm above matches it. Bind the
+;; scoped tail as @reference.name.
+(object_creation_expression
+  type: (generic_type
+    (scoped_type_identifier
+      (type_identifier) @reference.name .) @reference.call.constructor.qualified)) @reference.call.constructor
 
 ;; References — method references: User::getName, obj::method
 (method_reference

package/dist/core/ingestion/scope-resolution/graph-bridge/ids.js

@@ -48,6 +48,15 @@ function isCallerAnchorLabel(label) {
         label === 'Struct' ||
         label === 'Enum');
 }
+/**
+ * Callables whose same-name overloads occupy distinct graph nodes keyed by
+ * parameter types / shape. Must mirror `isOverloadableCallable` in
+ * `node-lookup.ts` so registration and lookup agree (Constructor included —
+ * #1928 F38).
+ */
+function isOverloadableCallable(label) {
+    return label === 'Function' || label === 'Method' || label === 'Constructor';
+}
 /**
  * Look up a `SymbolDefinition` in the graph node lookup.
  *
@@ -83,7 +92,7 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
             if (cHit !== undefined)
                 return cHit;
         }
-        if ((def.type === 'Function' || def.type === 'Method') &&
+        if (isOverloadableCallable(def.type) &&
             def.parameterTypes !== undefined &&
             def.parameterTypeClasses !== undefined) {
             const shapeTag = parameterShapeIdTag(def.parameterTypes, def.parameterTypeClasses);
@@ -96,8 +105,11 @@ export function resolveDefGraphId(filePath, def, nodeLookup) {
         }
         // Overload disambiguation: when the def carries parameter types,
         // try the parameter-typed key first so same-name same-arity
-        // overloads route to their distinct graph nodes.
-        if ((def.type === 'Function' || def.type === 'Method') &&
+        // overloads route to their distinct graph nodes. Constructors are
+        // included so a `this(int)`/`super(int)` chain or `new Foo(int)`
+        // resolves to the matching ctor overload instead of first-wins
+        // collapsing onto another `Foo` ctor (a self-loop) — #1928 F38.
+        if (isOverloadableCallable(def.type) &&
             def.parameterTypes !== undefined &&
             def.parameterTypes.length > 0) {
             const pKey = qualifiedKey(filePath, def.type, `${qn}~${def.parameterTypes.join(',')}`);

package/dist/core/ingestion/scope-resolution/graph-bridge/node-lookup.js

@@ -87,9 +87,7 @@ export function buildGraphNodeLookup(graph) {
             // a parameter-types-suffixed key so resolveDefGraphId can find
             // the right overload by matching its def's parameterTypes.
             const pTypes = props.parameterTypes;
-            if (pTypes !== undefined &&
-                pTypes.length > 0 &&
-                (node.label === 'Function' || node.label === 'Method')) {
+            if (pTypes !== undefined && pTypes.length > 0 && isOverloadableCallable(node.label)) {
                 const pKey = qualifiedKey(props.filePath, node.label, `${keyQualified}~${pTypes.join(',')}`);
                 // Each overload is unique — set unconditionally.
                 if (!lookup.has(pKey))
@@ -98,7 +96,7 @@ export function buildGraphNodeLookup(graph) {
             const pClasses = props
                 .parameterTypeClasses;
             const shapeTag = parameterShapeIdTag(pTypes, pClasses);
-            if (shapeTag !== '' && (node.label === 'Function' || node.label === 'Method')) {
+            if (shapeTag !== '' && isOverloadableCallable(node.label)) {
                 const shapeKey = qualifiedKey(props.filePath, node.label, `${keyQualified}${shapeTag}`);
                 if (!lookup.has(shapeKey))
                     lookup.set(shapeKey, node.id);
@@ -136,6 +134,17 @@ export function buildGraphNodeLookup(graph) {
     }
     return lookup;
 }
+/**
+ * Callables whose same-name overloads must route to distinct graph nodes via
+ * the parameter-types / shape key. Constructors belong here too: a class with
+ * `Foo()` and `Foo(int)` mints distinct `#0`/`#1` Constructor nodes, and a
+ * `this(...)`/`super(...)` edge (or any `new Foo(args)`) must reach the right
+ * one. Without the overload key both ctor nodes collapse onto the first-wins
+ * qualified/simple key, turning a `this()` chain into a self-loop (#1928 F38).
+ */
+function isOverloadableCallable(label) {
+    return label === 'Function' || label === 'Method' || label === 'Constructor';
+}
 export function isLinkableLabel(label) {
     return (label === 'Function' ||
         label === 'Method' ||

package/dist/core/lbug/pool-adapter.d.ts

@@ -15,25 +15,6 @@
  * from the same Database is the officially supported concurrency pattern.
  */
 import lbug from '@ladybugdb/core';
-/**
- * Probe whether a Windows FTS extension binary is locally installed under
- * ~/.lbdb/extension/<any-version>/win_amd64/fts/. Returns true on the first
- * version dir whose libfts.lbug_extension exists on disk; false if the
- * extension root is missing or contains no FTS binary.
- *
- * Gates the Windows skip-FTS-load guard below so we only skip the load
- * when no extension binary is present. When at least one binary exists,
- * loadFTSExtension is called with policy: 'load-only' — LadybugDB resolves
- * LOAD EXTENSION fts to its version-specific path internally, and the
- * ExtensionManager's tryLoad try/catch handles version-mismatch errors
- * cleanly without ever attempting dlopen of a stale binary. The install
- * path that the #1199/#1217 SIGSEGV documented is never exercised at
- * query time.
- *
- * Exported so unit tests can exercise the probe directly against a
- * temp-dir plus spied `os.homedir()` — see lbug-pool-win-fts-probe.test.ts.
- */
-export declare function hasLocalWinFtsExtension(): Promise<boolean>;
 /**
  * Listeners notified when a pool entry is torn down (LRU eviction, idle
  * timeout, explicit close). Used by upper layers (e.g. the BM25 search

package/dist/core/lbug/pool-adapter.js

@@ -15,49 +15,10 @@
  * from the same Database is the officially supported concurrency pattern.
  */
 import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
 import lbug from '@ladybugdb/core';
 import { isReadOnlyDbError, loadFTSExtension } from './lbug-adapter.js';
 import { createLbugDatabase, isWalCorruptionError, toNativeSafePath, WAL_RECOVERY_SUGGESTION, } from './lbug-config.js';
 import { isMissingFsError, isMissingShadowSidecarError, isReadOnlyShadowReplayError, preflightLbugSidecars, quarantineWalForMissingShadow, renameFailureMessage, statIfExists, } from './sidecar-recovery.js';
-/**
- * Probe whether a Windows FTS extension binary is locally installed under
- * ~/.lbdb/extension/<any-version>/win_amd64/fts/. Returns true on the first
- * version dir whose libfts.lbug_extension exists on disk; false if the
- * extension root is missing or contains no FTS binary.
- *
- * Gates the Windows skip-FTS-load guard below so we only skip the load
- * when no extension binary is present. When at least one binary exists,
- * loadFTSExtension is called with policy: 'load-only' — LadybugDB resolves
- * LOAD EXTENSION fts to its version-specific path internally, and the
- * ExtensionManager's tryLoad try/catch handles version-mismatch errors
- * cleanly without ever attempting dlopen of a stale binary. The install
- * path that the #1199/#1217 SIGSEGV documented is never exercised at
- * query time.
- *
- * Exported so unit tests can exercise the probe directly against a
- * temp-dir plus spied `os.homedir()` — see lbug-pool-win-fts-probe.test.ts.
- */
-export async function hasLocalWinFtsExtension() {
-    try {
-        const extRoot = path.join(os.homedir(), '.lbdb', 'extension');
-        const versions = await fs.readdir(extRoot);
-        for (const v of versions) {
-            try {
-                await fs.stat(path.join(extRoot, v, 'win_amd64', 'fts', 'libfts.lbug_extension'));
-                return true;
-            }
-            catch {
-                /* missing for this version, keep looking */
-            }
-        }
-    }
-    catch {
-        /* no .lbdb/extension dir */
-    }
-    return false;
-}
 const pool = new Map();
 const poolCloseListeners = new Set();
 /**
@@ -522,28 +483,7 @@ async function doInitLbug(repoId, dbPath) {
     // install; analyze owns extension installation. If LOAD fails, search
     // features degrade gracefully and the user-facing query path proceeds.
     if (!shared.ftsLoaded) {
-        // Windows guard: LOAD EXTENSION fts crashes with SIGSEGV on Windows during
-        // *install* — the @ladybugdb/core out-of-process installer hits an unhandled
-        // error path that signals SIGSEGV instead of throwing (see #1199, #1217).
-        // The previous unconditional skip was over-broad: it also disabled FTS on
-        // hosts where the binary was already on disk and only needed LOAD, leaving
-        // BM25 silently degraded with no error path (see #1690).
-        //
-        // Probe ~/.lbdb/extension/*/win_amd64/fts/ first. If any binary is on disk
-        // we run loadFTSExtension(..., 'load-only'); the install path is never
-        // exercised, and LadybugDB's version-specific resolution + ExtensionManager
-        // try/catch handle stale/zero-byte siblings cleanly (verified empirically
-        // on Win10 + Node 22.19 + gitnexus 1.6.5 + @ladybugdb/core 0.16.1). With
-        // no binary at all, we fall back to the upstream skip so install-time
-        // SIGSEGV continues to be avoided.
-        if (process.platform === 'win32') {
-            shared.ftsLoaded = (await hasLocalWinFtsExtension())
-                ? await loadFTSExtension(available[0], { policy: 'load-only' })
-                : true;
-        }
-        else {
-            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
-        }
+        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
     // Register pool entry only after all connections are pre-warmed and FTS is
     // loaded.  Concurrent executeQuery calls see either "not initialized"
@@ -599,16 +539,8 @@ export async function initLbugWithDb(repoId, existingDb, dbPath) {
     // Load FTS extension if not already loaded on this Database.
     // policy: 'load-only' — same contract as initLbug above; the read pool
     // must not block on a network install during query execution.
-    // Windows guard: same probe-then-load policy as doInitLbug above.
     if (!shared.ftsLoaded) {
-        if (process.platform === 'win32') {
-            shared.ftsLoaded = (await hasLocalWinFtsExtension())
-                ? await loadFTSExtension(available[0], { policy: 'load-only' })
-                : true;
-        }
-        else {
-            shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
-        }
+        shared.ftsLoaded = await loadFTSExtension(available[0], { policy: 'load-only' });
     }
     pool.set(repoId, {
         db: existingDb,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.143",
+  "version": "1.6.6-rc.145",
   "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",

package/scripts/cross-platform-tests.ts

@@ -33,7 +33,7 @@ const PLATFORM_LOGIC = [
   'test/unit/resolve-invocation.test.ts',
   'test/unit/platform-capabilities.test.ts',
   'test/unit/worker-pool-windows-quarantine.test.ts',
-  'test/unit/lbug-pool-win-fts-probe.test.ts',
+  'test/unit/lbug-pool-fts-load.test.ts',
   'test/unit/repo-manager.test.ts',
   'test/unit/repo-manager-finalize-invariant.test.ts',
   'test/unit/hooks.test.ts',