gitnexus 1.6.6-rc.51 → 1.6.6-rc.53

package/dist/core/ingestion/finalize-orchestrator.js

@@ -94,6 +94,7 @@ export function finalizeScopeModel(parsedFiles, options = {}) {
         // AFTER `finalizeScopeModel` returns, before `resolveReferenceSites`
         // consumes the bundle. Most languages leave it empty.
         bindingAugmentations: new Map(),
+        workspaceFqnBindings: new Map(),
         referenceSites: Object.freeze([...allReferenceSites]),
         sccs: finalizeOut.sccs,
         stats: finalizeOut.stats,

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

@@ -33,10 +33,6 @@ function shouldEmitReadMember(memberNode) {
     if (parent === null)
         return true;
     switch (parent.type) {
-        case 'method_invocation':
-            // Don't emit read.member when the field_access is the object of a method_invocation
-            // (the method call already handles this relationship)
-            return parent.childForFieldName('object')?.id !== memberNode.id;
         case 'assignment_expression':
             return parent.childForFieldName('left')?.id !== memberNode.id;
         default:
@@ -142,11 +138,125 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(args.length));
                 const argTypes = args.map((arg) => inferArgType(arg));
                 grouped['@reference.parameter-types'] = syntheticCapture('@reference.parameter-types', callNode, JSON.stringify(argTypes));
+                const argNames = args.map((a) => (a.type === 'identifier' ? a.text : ''));
+                if (argNames.some((n) => n !== '')) {
+                    grouped['@reference.arg-names'] = syntheticCapture('@reference.arg-names', callNode, JSON.stringify(argNames));
+                }
             }
         }
         out.push(grouped);
     }
-    return out;
+    return resolveVarTypeBindings(out);
+}
+function resolveVarTypeBindings(matches) {
+    const returnTypes = new Map();
+    const varTypes = new Map();
+    const ambiguousReturns = new Set();
+    const ambiguousVars = new Set();
+    for (const m of matches) {
+        if (m['@type-binding.return'] !== undefined &&
+            m['@type-binding.type'] !== undefined &&
+            m['@type-binding.name'] !== undefined) {
+            const name = m['@type-binding.name'].text;
+            const type = m['@type-binding.type'].text;
+            const existing = returnTypes.get(name);
+            if (existing !== undefined && existing !== type) {
+                ambiguousReturns.add(name);
+                returnTypes.delete(name);
+            }
+            else if (!ambiguousReturns.has(name)) {
+                returnTypes.set(name, type);
+            }
+        }
+        if (m['@type-binding.annotation'] !== undefined &&
+            m['@type-binding.type'] !== undefined &&
+            m['@type-binding.name'] !== undefined) {
+            const name = m['@type-binding.name'].text;
+            const t = m['@type-binding.type'].text;
+            if (t !== 'var') {
+                const existing = varTypes.get(name);
+                if (existing !== undefined && existing !== t) {
+                    ambiguousVars.add(name);
+                    varTypes.delete(name);
+                }
+                else if (!ambiguousVars.has(name)) {
+                    varTypes.set(name, t);
+                }
+            }
+        }
+        if (m['@type-binding.constructor'] !== undefined &&
+            m['@type-binding.type'] !== undefined &&
+            m['@type-binding.name'] !== undefined) {
+            const name = m['@type-binding.name'].text;
+            const type = m['@type-binding.type'].text;
+            const existing = varTypes.get(name);
+            if (existing !== undefined && existing !== type) {
+                ambiguousVars.add(name);
+                varTypes.delete(name);
+            }
+            else if (!ambiguousVars.has(name)) {
+                varTypes.set(name, type);
+            }
+        }
+    }
+    const resolved = [];
+    for (const m of matches) {
+        if (m['@type-binding.call-result'] !== undefined && m['@type-binding.type'] !== undefined) {
+            const methodName = m['@type-binding.type'].text;
+            const resolvedType = returnTypes.get(methodName);
+            if (resolvedType !== undefined) {
+                const patched = { ...m };
+                patched['@type-binding.type'] = { ...m['@type-binding.type'], text: resolvedType };
+                patched['@type-binding.annotation'] = m['@type-binding.call-result'];
+                delete patched['@type-binding.call-result'];
+                resolved.push(patched);
+                continue;
+            }
+        }
+        if (m['@type-binding.alias'] !== undefined && m['@type-binding.type'] !== undefined) {
+            const sourceName = m['@type-binding.type'].text;
+            const resolvedType = varTypes.get(sourceName);
+            if (resolvedType !== undefined) {
+                const patched = { ...m };
+                patched['@type-binding.type'] = { ...m['@type-binding.type'], text: resolvedType };
+                patched['@type-binding.annotation'] = m['@type-binding.alias'];
+                delete patched['@type-binding.alias'];
+                resolved.push(patched);
+                continue;
+            }
+        }
+        if (m['@reference.arg-names'] !== undefined && m['@reference.parameter-types'] !== undefined) {
+            try {
+                const types = JSON.parse(m['@reference.parameter-types'].text);
+                const names = JSON.parse(m['@reference.arg-names'].text);
+                let patched = false;
+                for (let i = 0; i < types.length; i++) {
+                    if (types[i] === '' && names[i] !== undefined && names[i] !== '') {
+                        const rt = varTypes.get(names[i]);
+                        if (rt !== undefined) {
+                            types[i] = rt;
+                            patched = true;
+                        }
+                    }
+                }
+                if (patched) {
+                    const patchedMatch = { ...m };
+                    patchedMatch['@reference.parameter-types'] = {
+                        ...m['@reference.parameter-types'],
+                        text: JSON.stringify(types),
+                    };
+                    delete patchedMatch['@reference.arg-names'];
+                    resolved.push(patchedMatch);
+                    continue;
+                }
+            }
+            catch {
+                // pass through
+            }
+        }
+        resolved.push(m);
+    }
+    return resolved;
 }
 /** Infer a Java argument's static type from literal patterns. */
 function inferArgType(argNode) {

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

@@ -19,10 +19,11 @@ export function interpretJavaImport(captures) {
     switch (kind) {
         case 'named': {
             // `import com.example.User;`
+            const simpleName = sourceCap.text.split('.').pop() ?? sourceCap.text;
             return {
                 kind: 'named',
-                localName: nameCap?.text ?? sourceCap.text.split('.').pop() ?? sourceCap.text,
-                importedName: sourceCap.text,
+                localName: nameCap?.text ?? simpleName,
+                importedName: simpleName,
                 targetRaw: sourceCap.text,
             };
         }
@@ -35,17 +36,14 @@ export function interpretJavaImport(captures) {
         }
         case 'static': {
             // `import static com.example.Utils.format;`
-            // The source contains the full path including the member name
-            // (e.g. `com.example.Utils.format`).  For file resolution we need
-            // the class path (`com.example.Utils`), so strip the final member
-            // segment.  The local binding name is the member itself.
             const fullSource = sourceCap.text;
             const lastDot = fullSource.lastIndexOf('.');
+            const memberName = lastDot >= 0 ? fullSource.slice(lastDot + 1) : fullSource;
             const classPath = lastDot >= 0 ? fullSource.slice(0, lastDot) : fullSource;
             return {
                 kind: 'named',
-                localName: nameCap?.text ?? (lastDot >= 0 ? fullSource.slice(lastDot + 1) : fullSource),
-                importedName: fullSource,
+                localName: nameCap?.text ?? memberName,
+                importedName: memberName,
                 targetRaw: classPath,
             };
         }
@@ -83,6 +81,12 @@ export function interpretJavaTypeBinding(captures) {
         source = 'self';
     else if (captures['@type-binding.constructor'] !== undefined)
         source = 'constructor-inferred';
+    else if (captures['@type-binding.pattern'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.call-result'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.alias'] !== undefined)
+        source = 'annotation';
     else if (captures['@type-binding.annotation'] !== undefined)
         source = 'annotation';
     else if (captures['@type-binding.return'] !== undefined)

package/dist/core/ingestion/languages/java/package-siblings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Java package-scope implicit visibility.
+ *
+ * Classes in the same Java package see each other without explicit
+ * `import` statements.  This hook groups files by `package` declaration,
+ * then injects cross-file class defs into each file's module-scope
+ * `bindingAugmentations` and mirrors type-bindings across same-package
+ * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
+ */
+import type { ParsedFile } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+export declare function populateJavaPackageSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, ctx: {
+    readonly fileContents: ReadonlyMap<string, string>;
+    readonly treeCache?: {
+        get(filePath: string): unknown;
+    };
+}): void;

package/dist/core/ingestion/languages/java/package-siblings.js

@@ -0,0 +1,134 @@
+/**
+ * Java package-scope implicit visibility.
+ *
+ * Classes in the same Java package see each other without explicit
+ * `import` statements.  This hook groups files by `package` declaration,
+ * then injects cross-file class defs into each file's module-scope
+ * `bindingAugmentations` and mirrors type-bindings across same-package
+ * files — the Java equivalent of C#'s `populateNamespaceSiblings`.
+ */
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+import { getJavaParser } from './query.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { logger } from '../../../logger.js';
+function extractPackageName(content, cachedTree) {
+    const tree = cachedTree ??
+        parseSourceSafe(getJavaParser(), content);
+    for (const child of tree.rootNode.namedChildren) {
+        if (child.type === 'package_declaration') {
+            const scoped = child.namedChildren.find((c) => c.type === 'scoped_identifier' || c.type === 'identifier');
+            return scoped?.text ?? '';
+        }
+    }
+    return '';
+}
+export function populateJavaPackageSiblings(parsedFiles, indexes, ctx) {
+    const buckets = new Map();
+    for (const parsed of parsedFiles) {
+        const content = ctx.fileContents.get(parsed.filePath);
+        if (content === undefined)
+            continue;
+        const pkg = extractPackageName(content, ctx.treeCache?.get(parsed.filePath));
+        let bucket = buckets.get(pkg);
+        if (bucket === undefined) {
+            bucket = { parsed: [], moduleScopes: [] };
+            buckets.set(pkg, bucket);
+        }
+        bucket.parsed.push(parsed);
+        const ms = parsed.scopes.find((s) => s.kind === 'Module');
+        if (ms !== undefined) {
+            bucket.moduleScopes.push({ filePath: parsed.filePath, scope: ms });
+        }
+    }
+    const augmentations = indexes.bindingAugmentations;
+    const MAX_PACKAGE_FILES = 500;
+    for (const bucket of buckets.values()) {
+        if (bucket.moduleScopes.length < 2)
+            continue;
+        if (bucket.moduleScopes.length > MAX_PACKAGE_FILES) {
+            logger.warn(`[java-package-siblings] skipping package with ${bucket.moduleScopes.length} files (cap=${MAX_PACKAGE_FILES}); same-package implicit visibility disabled for this package`);
+            continue;
+        }
+        const classDefs = [];
+        for (const parsed of bucket.parsed) {
+            const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
+            const moduleScopeId = moduleScope?.id;
+            for (const scope of parsed.scopes) {
+                if (scope.kind !== 'Class')
+                    continue;
+                if (scope.parent !== moduleScopeId)
+                    continue;
+                for (const def of scope.ownedDefs) {
+                    if (isClassLike(def.type)) {
+                        classDefs.push({ def, filePath: parsed.filePath });
+                        break;
+                    }
+                }
+            }
+        }
+        for (const { filePath, scope } of bucket.moduleScopes) {
+            let scopeAug = augmentations.get(scope.id);
+            if (scopeAug === undefined) {
+                scopeAug = new Map();
+                augmentations.set(scope.id, scopeAug);
+            }
+            const candidates = classDefs.filter((d) => d.filePath !== filePath);
+            const proximityCache = new Map();
+            for (const c of candidates) {
+                if (!proximityCache.has(c.filePath)) {
+                    proximityCache.set(c.filePath, sharedSegmentCount(c.filePath, filePath));
+                }
+            }
+            const sorted = candidates.sort((a, b) => (proximityCache.get(b.filePath) ?? 0) - (proximityCache.get(a.filePath) ?? 0));
+            const injectedIds = new Set();
+            for (const { def } of sorted) {
+                if (injectedIds.has(def.nodeId))
+                    continue;
+                const qn = def.qualifiedName;
+                if (qn === undefined)
+                    continue;
+                injectedIds.add(def.nodeId);
+                const simpleName = qn.includes('.') ? qn.slice(qn.lastIndexOf('.') + 1) : qn;
+                let list = scopeAug.get(simpleName);
+                if (list === undefined) {
+                    list = [];
+                    scopeAug.set(simpleName, list);
+                }
+                list.push({ def, origin: 'namespace' });
+            }
+            const tb = scope.typeBindings;
+            for (const sibling of bucket.moduleScopes) {
+                if (sibling.filePath === filePath)
+                    continue;
+                for (const [name, ref] of sibling.scope.typeBindings) {
+                    if (tb.has(name))
+                        continue;
+                    tb.set(name, ref);
+                }
+            }
+            for (const sibParsed of bucket.parsed) {
+                if (sibParsed.filePath === filePath)
+                    continue;
+                for (const sibScope of sibParsed.scopes) {
+                    if (sibScope.kind !== 'Class')
+                        continue;
+                    for (const [name, ref] of sibScope.typeBindings) {
+                        if (ref.source === 'self')
+                            continue;
+                        if (tb.has(name))
+                            continue;
+                        tb.set(name, ref);
+                    }
+                }
+            }
+        }
+    }
+}
+function sharedSegmentCount(a, b) {
+    const sa = a.replace(/\\/g, '/').split('/');
+    const sb = b.replace(/\\/g, '/').split('/');
+    let i = 0;
+    while (i < sa.length && i < sb.length && sa[i] === sb[i])
+        i++;
+    return i;
+}

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

@@ -100,6 +100,47 @@ const JAVA_SCOPE_QUERY = `
   declarator: (variable_declarator
     name: (identifier) @type-binding.name)) @type-binding.annotation
 
+;; Type bindings — var u = svc.getUser(); (Java 10+ call-result inference)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (method_invocation
+      name: (identifier) @type-binding.type))) @type-binding.call-result
+
+;; Type bindings — var alias = u; (Java 10+ alias inference)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (identifier) @type-binding.type)) @type-binding.alias
+
+;; Type bindings — var addr = user.address; (Java 10+ field-access alias)
+(local_variable_declaration
+  type: (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  declarator: (variable_declarator
+    name: (identifier) @type-binding.name
+    value: (field_access
+      field: (identifier) @type-binding.type))) @type-binding.alias
+
+;; Type bindings — enhanced-for with var: for (var user : users)
+(enhanced_for_statement
+  (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  (identifier) @type-binding.name
+  (identifier) @type-binding.type) @type-binding.alias
+
+;; Enhanced-for with var + method iterable: for (var user : data.values())
+(enhanced_for_statement
+  (type_identifier) @_var_type
+  (#eq? @_var_type "var")
+  (identifier) @type-binding.name
+  (method_invocation
+    object: (identifier) @type-binding.type)) @type-binding.alias
+
 ;; Type bindings — var u = new User(); (Java 10+ local variable type inference)
 ;; tree-sitter-java parses \`var\` as a \`type_identifier\` with text "var".
 ;; The type-binding.constructor anchor fires when the rhs is an
@@ -141,6 +182,16 @@ const JAVA_SCOPE_QUERY = `
   type: (generic_type) @type-binding.type
   name: (identifier) @type-binding.name) @type-binding.annotation
 
+;; Type bindings — instanceof pattern (Java 16+): if (obj instanceof User user)
+(instanceof_expression
+  (type_identifier) @type-binding.type
+  (identifier) @type-binding.name) @type-binding.pattern
+
+;; Type bindings — switch case pattern (Java 21+): case User user ->
+(type_pattern
+  (type_identifier) @type-binding.type
+  (identifier) @type-binding.name) @type-binding.pattern
+
 ;; References — all method calls: foo() and obj.method()
 ;; tree-sitter-java's query engine drops negation-based \`!object\`
 ;; patterns when a positive \`object:\` pattern exists for the same
@@ -164,6 +215,30 @@ const JAVA_SCOPE_QUERY = `
 (object_creation_expression
   type: (scoped_type_identifier) @reference.call.constructor.qualified) @reference.call.constructor
 
+;; References — method references: User::getName, obj::method
+(method_reference
+  (identifier) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — this::method and super::method
+(method_reference
+  (this) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+(method_reference
+  (super) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — field_access::method: responseBuilder::buildResponse
+(method_reference
+  (field_access) @reference.receiver
+  (identifier) @reference.name) @reference.call.member
+
+;; References — constructor references: User::new
+(method_reference
+  (identifier) @reference.name
+  "new") @reference.call.constructor
+
 ;; References — field/property writes: obj.name = "x"
 (assignment_expression
   left: (field_access

package/dist/core/ingestion/languages/java/scope-resolver.d.ts

@@ -4,46 +4,12 @@
  *
  * ## Registry-primary parity status
  *
- * Java is **not** in `MIGRATED_LANGUAGES` — the scope-resolution
- * registry runs in shadow mode only.  Parity in forced registry mode
- * (`REGISTRY_PRIMARY_JAVA=1`) is 143/172 (83%).  The 29 gaps fall into:
+ * Java is in `MIGRATED_LANGUAGES` — the scope-resolution registry is
+ * the primary call-resolution path.  Parity: 178/178 (100%).
  *
- *   - switch pattern binding / sealed-class exhaustiveness
- *   - Map.values() / entrySet() iteration type propagation
- *   - assignment / method chain return-type propagation across files
- *   - virtual dispatch / interface default methods
- *
- * These are the same category of advanced-resolution gaps seen in prior
- * migrations (Python, C#, Go).  Parity is below the ≥99% flip threshold
- * per RFC §6.4.
- *
- * **CI visibility:** Because Java is absent from `MIGRATED_LANGUAGES`,
- * the parity CI workflow (`ci-scope-parity.yml`) does not run Java in
- * either `REGISTRY_PRIMARY_JAVA=0` or `=1` mode.  Regressions in forced
- * mode are only visible via manual `REGISTRY_PRIMARY_JAVA=1 npx vitest
- * run java.test.ts`.  Before flipping Java to registry-primary, a
- * non-required CI step should be added to run Java tests in forced mode
- * and report parity as a dashboard input.
- *
- * **Parity baseline (29 failures):** The 29 gaps in forced registry mode
- * are tracked in this PR (#1482) and this JSDoc.  If the gap count
- * changes (up or down), update this baseline accordingly.
- *
- * ### Known flip-blockers (must fix before adding to MIGRATED_LANGUAGES)
- *
- *   - Varargs arity: fixed-prefix count is now preserved, but no
- *     integration fixture exercises the 0-arg rejection path yet.
- *   - Static import resolution: `import static X.Y.m` now correctly
- *     resolves to `X/Y.java` (the class), not `X/Y/m.java` (the member).
- *     Edge cases with nested classes may remain.
- *   - Generic superclass receiver binding: `BaseModel<T>` now strips
- *     to `BaseModel` via JVM type-erasure fallback in `stripGeneric`.
- *   - Wildcard import (`import com.example.*`) file selection is
- *     nondeterministic when multiple classes share a package directory.
- *     May produce wrong-file edges in forced mode.
- *   - Qualified generic type parameters in field/parameter annotations
- *     (`com.example.BaseModel<T>`) — rare in practice but may miss
- *     resolution when the full qualifier is present with generics.
+ * **CI visibility:** The parity CI workflow (`ci-scope-parity.yml`)
+ * runs Java tests in both `REGISTRY_PRIMARY_JAVA=0` and `=1` modes
+ * automatically.
  */
 import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
 declare const javaScopeResolver: ScopeResolver;

package/dist/core/ingestion/languages/java/scope-resolver.js

@@ -4,52 +4,21 @@
  *
  * ## Registry-primary parity status
  *
- * Java is **not** in `MIGRATED_LANGUAGES` — the scope-resolution
- * registry runs in shadow mode only.  Parity in forced registry mode
- * (`REGISTRY_PRIMARY_JAVA=1`) is 143/172 (83%).  The 29 gaps fall into:
+ * Java is in `MIGRATED_LANGUAGES` — the scope-resolution registry is
+ * the primary call-resolution path.  Parity: 178/178 (100%).
  *
- *   - switch pattern binding / sealed-class exhaustiveness
- *   - Map.values() / entrySet() iteration type propagation
- *   - assignment / method chain return-type propagation across files
- *   - virtual dispatch / interface default methods
- *
- * These are the same category of advanced-resolution gaps seen in prior
- * migrations (Python, C#, Go).  Parity is below the ≥99% flip threshold
- * per RFC §6.4.
- *
- * **CI visibility:** Because Java is absent from `MIGRATED_LANGUAGES`,
- * the parity CI workflow (`ci-scope-parity.yml`) does not run Java in
- * either `REGISTRY_PRIMARY_JAVA=0` or `=1` mode.  Regressions in forced
- * mode are only visible via manual `REGISTRY_PRIMARY_JAVA=1 npx vitest
- * run java.test.ts`.  Before flipping Java to registry-primary, a
- * non-required CI step should be added to run Java tests in forced mode
- * and report parity as a dashboard input.
- *
- * **Parity baseline (29 failures):** The 29 gaps in forced registry mode
- * are tracked in this PR (#1482) and this JSDoc.  If the gap count
- * changes (up or down), update this baseline accordingly.
- *
- * ### Known flip-blockers (must fix before adding to MIGRATED_LANGUAGES)
- *
- *   - Varargs arity: fixed-prefix count is now preserved, but no
- *     integration fixture exercises the 0-arg rejection path yet.
- *   - Static import resolution: `import static X.Y.m` now correctly
- *     resolves to `X/Y.java` (the class), not `X/Y/m.java` (the member).
- *     Edge cases with nested classes may remain.
- *   - Generic superclass receiver binding: `BaseModel<T>` now strips
- *     to `BaseModel` via JVM type-erasure fallback in `stripGeneric`.
- *   - Wildcard import (`import com.example.*`) file selection is
- *     nondeterministic when multiple classes share a package directory.
- *     May produce wrong-file edges in forced mode.
- *   - Qualified generic type parameters in field/parameter annotations
- *     (`com.example.BaseModel<T>`) — rare in practice but may miss
- *     resolution when the full qualifier is present with generics.
+ * **CI visibility:** The parity CI workflow (`ci-scope-parity.yml`)
+ * runs Java tests in both `REGISTRY_PRIMARY_JAVA=0` and `=1` modes
+ * automatically.
  */
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
-import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { isClassLike, lookupBindingsAt, namesAtScope, populateClassOwnedMembers, } from '../../scope-resolution/scope/walkers.js';
+import { followChainPostFinalize } from '../../scope-resolution/passes/imported-return-types.js';
 import { javaProvider } from '../java.js';
 import { javaArityCompatibility, javaMergeBindings, resolveJavaImportTarget, } from './index.js';
+import { populateJavaPackageSiblings } from './package-siblings.js';
 const javaScopeResolver = {
     language: SupportedLanguages.Java,
     languageProvider: javaProvider,
@@ -60,15 +29,158 @@ const javaScopeResolver = {
     },
     mergeBindings: (existing, incoming) => [...javaMergeBindings([...existing, ...incoming])],
     arityCompatibility: (callsite, def) => javaArityCompatibility(def, callsite),
-    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    buildMro: buildJavaMro,
     populateOwners: (parsed) => populateClassOwnedMembers(parsed),
     isSuperReceiver: (text) => text.trim() === 'super',
-    // Java is statically typed — field-fallback heuristic stays off
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,
-    // Java doesn't collapse member calls
-    collapseMemberCallsByCallerTarget: false,
-    // Hoist return-type bindings to Module scope for cross-file propagation
+    collapseMemberCallsByCallerTarget: true,
     hoistTypeBindingsToModule: true,
+    populateNamespaceSiblings: populateJavaPackageSiblings,
+    populateRangeBindings: populateJavaCrossFileReturnTypes,
 };
 export { javaScopeResolver };
+function populateJavaCrossFileReturnTypes(parsedFiles, indexes) {
+    const moduleScopeByFile = new Map();
+    const classScopesByFile = new Map();
+    for (const parsed of parsedFiles) {
+        const ms = parsed.scopes.find((s) => s.kind === 'Module');
+        if (ms !== undefined)
+            moduleScopeByFile.set(parsed.filePath, ms);
+        const cs = parsed.scopes.filter((s) => s.kind === 'Class');
+        if (cs.length > 0)
+            classScopesByFile.set(parsed.filePath, cs);
+    }
+    for (const parsed of parsedFiles) {
+        const importerModule = moduleScopeByFile.get(parsed.filePath);
+        if (importerModule === undefined)
+            continue;
+        const ambiguousMirrors = new Set();
+        for (const name of namesAtScope(importerModule.id, indexes)) {
+            const refs = lookupBindingsAt(importerModule.id, name, indexes);
+            for (const ref of refs) {
+                if (ref.origin !== 'import' && ref.origin !== 'reexport')
+                    continue;
+                if (!isClassLike(ref.def.type))
+                    continue;
+                const sourceModule = moduleScopeByFile.get(ref.def.filePath);
+                if (sourceModule === undefined)
+                    continue;
+                const tb = importerModule.typeBindings;
+                for (const [srcName, srcRef] of sourceModule.typeBindings) {
+                    if (srcRef.source !== 'return-annotation')
+                        continue;
+                    if (ambiguousMirrors.has(srcName))
+                        continue;
+                    const existing = tb.get(srcName);
+                    if (existing !== undefined && existing.rawName !== srcRef.rawName) {
+                        ambiguousMirrors.add(srcName);
+                        tb.delete(srcName);
+                        continue;
+                    }
+                    if (existing === undefined)
+                        tb.set(srcName, srcRef);
+                }
+                for (const classScope of classScopesByFile.get(ref.def.filePath) ?? []) {
+                    for (const [srcName, srcRef] of classScope.typeBindings) {
+                        if (srcRef.source === 'self' || srcRef.source === 'parameter-annotation')
+                            continue;
+                        if (ambiguousMirrors.has(srcName))
+                            continue;
+                        const existing = tb.get(srcName);
+                        if (existing !== undefined && existing.rawName !== srcRef.rawName) {
+                            ambiguousMirrors.add(srcName);
+                            tb.delete(srcName);
+                            continue;
+                        }
+                        if (existing === undefined)
+                            tb.set(srcName, srcRef);
+                    }
+                }
+            }
+        }
+        for (const [name, ref] of importerModule.typeBindings) {
+            const resolved = followChainPostFinalize(ref, importerModule.id, indexes);
+            if (resolved !== ref) {
+                importerModule.typeBindings.set(name, resolved);
+            }
+        }
+    }
+    for (const parsed of parsedFiles) {
+        const moduleScopeId = moduleScopeByFile.get(parsed.filePath)?.id;
+        for (const scope of parsed.scopes) {
+            if (scope.id === moduleScopeId)
+                continue;
+            for (const [name, ref] of scope.typeBindings) {
+                const resolved = followChainPostFinalize(ref, scope.id, indexes);
+                if (resolved !== ref) {
+                    scope.typeBindings.set(name, resolved);
+                }
+            }
+        }
+    }
+}
+function buildJavaMro(graph, parsedFiles, nodeLookup) {
+    const mro = buildMro(graph, parsedFiles, nodeLookup, defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!isClassLike(def.type))
+                continue;
+            const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const directImpls = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const source = defIdByGraphId.get(rel.sourceId);
+        const target = defIdByGraphId.get(rel.targetId);
+        if (source === undefined || target === undefined)
+            continue;
+        let list = directImpls.get(source);
+        if (list === undefined) {
+            list = [];
+            directImpls.set(source, list);
+        }
+        if (!list.includes(target))
+            list.push(target);
+    }
+    for (const [classDefId, extendsMro] of mro) {
+        const ancestorChain = [classDefId, ...extendsMro];
+        const seeds = [];
+        for (const ancestorId of ancestorChain) {
+            for (const ifaceId of directImpls.get(ancestorId) ?? []) {
+                seeds.push(ifaceId);
+            }
+        }
+        if (seeds.length === 0)
+            continue;
+        const interfaces = closeInterfaces(seeds, directImpls);
+        mro.set(classDefId, [...extendsMro, ...interfaces.filter((i) => !extendsMro.includes(i))]);
+    }
+    for (const [classDefId, ifaces] of directImpls) {
+        if (mro.has(classDefId))
+            continue;
+        mro.set(classDefId, closeInterfaces([...ifaces], directImpls));
+    }
+    return mro;
+}
+function closeInterfaces(seeds, directImpls) {
+    const out = [];
+    const seen = new Set();
+    const queue = [...seeds];
+    let head = 0;
+    while (head < queue.length) {
+        const cur = queue[head++];
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        out.push(cur);
+        for (const next of directImpls.get(cur) ?? []) {
+            if (!seen.has(next))
+                queue.push(next);
+        }
+    }
+    return out;
+}

package/dist/core/ingestion/languages/php/namespace-siblings.d.ts

@@ -26,6 +26,30 @@
  */
 import type { ParsedFile } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+interface PhpFileStructure {
+    /** The declared namespace (backslash-separated), or '' for global namespace. */
+    readonly namespace: string;
+}
+/**
+ * Extract a PHP namespace declaration from raw source without tree-sitter.
+ *
+ * Single-pass line scanner that skips heredoc/nowdoc bodies, block
+ * comments, and single-line comments before matching. This avoids the
+ * false positives that a multiline regex produces when `namespace` appears
+ * inside a heredoc, nowdoc, string, or comment.
+ */
+export declare function extractNamespaceViaScanner(content: string): string;
+/**
+ * Extract the declared namespace from a PHP file's source.
+ * Uses the cached AST tree when available to avoid re-parsing.
+ *
+ * When no cached tree is available (worker-parsed files can't transfer
+ * native Tree objects across MessageChannels), uses a line scanner
+ * instead of re-parsing every file with tree-sitter. For 16K+ PHP files
+ * this eliminates ~16K tree-sitter re-parses during the namespace-siblings
+ * pass. See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+ */
+export declare function extractPhpFileStructure(content: string, cachedTree: unknown): PhpFileStructure;
 export interface PhpSiblingInputs {
     readonly fileContents: ReadonlyMap<string, string>;
     readonly treeCache?: {
@@ -49,3 +73,4 @@ export declare function getPhpNamespaceForFile(filePath: string): string;
  * explicit `use` imports (`origin: 'import'`) and local declarations.
  */
 export declare function populatePhpNamespaceSiblings(parsedFiles: readonly ParsedFile[], indexes: ScopeResolutionIndexes, inputs: PhpSiblingInputs): void;
+export {};

package/dist/core/ingestion/languages/php/namespace-siblings.js

@@ -24,22 +24,85 @@
  * to extract namespace declarations — same AST that `extractParsedFile`
  * already parsed, reused via `treeCache` to avoid double-parsing.
  */
-import { getPhpParser } from './query.js';
-import { getTreeSitterBufferSize } from '../../constants.js';
-import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+const NAMESPACE_RE = /^\s*namespace\s+([\w\\]+)\s*[;{]/i;
+const HEREDOC_START_RE = /<<<\s*['"]?(\w+)['"]?\s*$/;
+/**
+ * Extract a PHP namespace declaration from raw source without tree-sitter.
+ *
+ * Single-pass line scanner that skips heredoc/nowdoc bodies, block
+ * comments, and single-line comments before matching. This avoids the
+ * false positives that a multiline regex produces when `namespace` appears
+ * inside a heredoc, nowdoc, string, or comment.
+ */
+export function extractNamespaceViaScanner(content) {
+    const lines = content.split('\n');
+    let inBlockComment = false;
+    let heredocDelimiter = null;
+    for (const raw of lines) {
+        if (heredocDelimiter !== null) {
+            const trimmed = raw.trim();
+            if (trimmed === heredocDelimiter + ';' || trimmed === heredocDelimiter) {
+                heredocDelimiter = null;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (raw.includes('*/')) {
+                inBlockComment = false;
+            }
+            continue;
+        }
+        let line = raw;
+        const blockStart = line.indexOf('/*');
+        if (blockStart >= 0) {
+            const blockEnd = line.indexOf('*/', blockStart + 2);
+            if (blockEnd >= 0) {
+                line = line.slice(0, blockStart) + line.slice(blockEnd + 2);
+            }
+            else {
+                line = line.slice(0, blockStart);
+                inBlockComment = true;
+            }
+        }
+        const slashIdx = line.indexOf('//');
+        const hashIdx = line.indexOf('#');
+        if (slashIdx >= 0 && (hashIdx < 0 || slashIdx < hashIdx)) {
+            line = line.slice(0, slashIdx);
+        }
+        else if (hashIdx >= 0) {
+            line = line.slice(0, hashIdx);
+        }
+        const heredocMatch = raw.match(HEREDOC_START_RE);
+        if (heredocMatch) {
+            heredocDelimiter = heredocMatch[1];
+            continue;
+        }
+        const stripped = line.replace(/<\?php/gi, '').replace(/declare\s*\([^)]*\)\s*;?/gi, '');
+        const nsMatch = stripped.match(NAMESPACE_RE);
+        if (nsMatch) {
+            return nsMatch[1];
+        }
+    }
+    return '';
+}
 /**
  * Extract the declared namespace from a PHP file's source.
  * Uses the cached AST tree when available to avoid re-parsing.
+ *
+ * When no cached tree is available (worker-parsed files can't transfer
+ * native Tree objects across MessageChannels), uses a line scanner
+ * instead of re-parsing every file with tree-sitter. For 16K+ PHP files
+ * this eliminates ~16K tree-sitter re-parses during the namespace-siblings
+ * pass. See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
  */
-function extractPhpFileStructure(content, cachedTree) {
-    const tree = cachedTree ??
-        parseSourceSafe(getPhpParser(), content, undefined, {
-            bufferSize: getTreeSitterBufferSize(content),
-        });
+export function extractPhpFileStructure(content, cachedTree) {
+    if (!cachedTree) {
+        return { namespace: extractNamespaceViaScanner(content) };
+    }
     // Walk top-level nodes looking for namespace_definition.
     // PHP files have at most one namespace declaration (PSR-4 convention).
     // `namespace_definition` has a `name:` field of type `namespace_name`.
-    const root = tree.rootNode;
+    const root = cachedTree.rootNode;
     for (let i = 0; i < root.namedChildCount; i++) {
         const child = root.namedChild(i);
         if (child === null)
@@ -194,38 +257,31 @@ export function populatePhpNamespaceSiblings(parsedFiles, indexes, inputs) {
             }
         }
     }
-    // Step 3b: Inject fully-qualified-name bindings into every PHP file's
-    // Module scope. PHP `\App\Models\User` (leading-backslash FQN) and
-    // `App\Models\User` (already-qualified relative) on a parameter or
-    // typed receiver must resolve to the exact namespace-qualified class
-    // regardless of which simple-name `User` the caller's `use` imports
-    // shadowed. The shared `findClassBindingInScope` scope-chain walk
-    // consumes these augmentations via `lookupBindingsAt`, so adding the
-    // qualified key on every file's module scope routes FQN-receivers to
-    // the right def. Codex PR #1497 review, finding 1.
+    // Step 3b: Register FQN bindings in a workspace-level map instead of
+    // per-scope augmentations. PHP `\App\Models\User` and `App\Models\User`
+    // must resolve regardless of which file the lookup originates from.
+    // `lookupBindingsAt` consults `workspaceFqnBindings` as a third source.
     //
-    // Cost: O(PHP files × class-like defs in the workspace) augmentation
-    // entries. Bounded and acceptable in practice — typical PHP projects
-    // have hundreds of files and classes, not tens of thousands.
-    for (const parsed of parsedFiles) {
-        const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
-        if (moduleScope === undefined)
+    // Cost: O(class-like defs) entries — NOT O(files × classDefs). For 16K
+    // PHP files with 5K classes, this is 5K entries instead of 80M.
+    const fqnMap = indexes.workspaceFqnBindings;
+    for (const [ns, bucket] of buckets) {
+        if (ns === '')
             continue;
-        const moduleScopeId = moduleScope.id;
-        for (const [ns, bucket] of buckets) {
-            if (ns === '')
-                continue; // global-namespace classes have no qualified form to register
-            for (const def of bucket.classDefs) {
-                const q = def.qualifiedName ?? '';
-                const simpleName = q.includes('\\') ? q.slice(q.lastIndexOf('\\') + 1) : q;
-                if (simpleName === '')
-                    continue;
-                const fqn = `${ns}\\${simpleName}`;
-                const arr = getAugmentationBucket(augmentations, moduleScopeId, fqn);
-                if (arr.some((b) => b.def.nodeId === def.nodeId))
-                    continue;
-                arr.push({ def, origin: 'namespace' });
+        for (const def of bucket.classDefs) {
+            const q = def.qualifiedName ?? '';
+            const simpleName = q.includes('\\') ? q.slice(q.lastIndexOf('\\') + 1) : q;
+            if (simpleName === '')
+                continue;
+            const fqn = `${ns}\\${simpleName}`;
+            let arr = fqnMap.get(fqn);
+            if (arr === undefined) {
+                arr = [];
+                fqnMap.set(fqn, arr);
             }
+            if (arr.some((b) => b.def.nodeId === def.nodeId))
+                continue;
+            arr.push({ def, origin: 'namespace' });
         }
     }
     // Step 4: Mirror return-type bindings from same-namespace sibling files.

package/dist/core/ingestion/model/scope-resolution-indexes.d.ts

@@ -63,6 +63,12 @@ export interface ScopeResolutionIndexes {
      *  are returned first and win duplicate `def.nodeId` metadata, with
      *  unique augmentations appended after. See I8. */
     readonly bindingAugmentations: ReadonlyMap<ScopeId, ReadonlyMap<string, readonly BindingRef[]>>;
+    /** Workspace-level FQN binding lookup. Populated by PHP namespace-
+     *  siblings Step 3b as a shared map instead of per-scope duplication.
+     *  Consulted by `lookupBindingsAt` as a third source after finalized
+     *  and per-scope augmented bindings. Keys are backslash-separated FQNs
+     *  (e.g. `App\Models\User`). */
+    readonly workspaceFqnBindings: ReadonlyMap<string, readonly BindingRef[]>;
     /** Pre-resolution usage facts; consumed by the resolution phase. */
     readonly referenceSites: readonly ReferenceSite[];
     /** SCC condensation of the file-level import graph — callers that want

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -22,6 +22,7 @@ import { processHeritage, processHeritageFromExtracted, extractExtractedHeritage
 import { createResolutionContext } from '../model/resolution-context.js';
 import { createASTCache } from '../ast-cache.js';
 import { getLanguageFromFilename } from '../../../_shared/index.js';
+import { isRegistryPrimary } from '../registry-primary-flag.js';
 import { readFileContents } from '../filesystem-walker.js';
 import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js';
 import { createWorkerPool, WorkerPoolInitializationError } from '../workers/worker-pool.js';
@@ -461,14 +462,37 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                 if (chunkNeedsSynthesis[chunkIdx]) {
                     anyChunkNeedsWildcardSynth = true;
                 }
-                for (const item of chunkWorkerData.imports)
-                    deferredWorkerImports.push(item);
-                for (const item of chunkWorkerData.calls)
-                    deferredWorkerCalls.push(item);
-                for (const item of chunkWorkerData.heritage)
-                    deferredWorkerHeritage.push(item);
-                for (const item of chunkWorkerData.constructorBindings)
-                    deferredConstructorBindings.push(item);
+                const skipFile = new Set();
+                const checkFile = new Set();
+                const shouldAccumulate = (filePath) => {
+                    if (checkFile.has(filePath))
+                        return true;
+                    if (skipFile.has(filePath))
+                        return false;
+                    const lang = getLanguageFromFilename(filePath);
+                    if (lang !== null && isRegistryPrimary(lang)) {
+                        skipFile.add(filePath);
+                        return false;
+                    }
+                    checkFile.add(filePath);
+                    return true;
+                };
+                for (const item of chunkWorkerData.imports) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredWorkerImports.push(item);
+                }
+                for (const item of chunkWorkerData.calls) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredWorkerCalls.push(item);
+                }
+                for (const item of chunkWorkerData.heritage) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredWorkerHeritage.push(item);
+                }
+                for (const item of chunkWorkerData.constructorBindings) {
+                    if (shouldAccumulate(item.filePath))
+                        deferredConstructorBindings.push(item);
+                }
                 // Aggregate worker-produced ParsedFile artifacts so scope-
                 // resolution can use them as a re-extraction cache (skips its
                 // own tree-sitter re-parse on warm runs).
@@ -477,8 +501,10 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                         allParsedFiles.push(item);
                 }
                 if (chunkWorkerData.assignments?.length) {
-                    for (const item of chunkWorkerData.assignments)
-                        deferredAssignments.push(item);
+                    for (const item of chunkWorkerData.assignments) {
+                        if (shouldAccumulate(item.filePath))
+                            deferredAssignments.push(item);
+                    }
                 }
                 if (chunkWorkerData.fileScopeBindings?.length) {
                     for (const { filePath, bindings } of chunkWorkerData.fileScopeBindings) {

package/dist/core/ingestion/registry-primary-flag.js

@@ -75,6 +75,7 @@ export const MIGRATED_LANGUAGES = new Set([
     SupportedLanguages.PHP,
     SupportedLanguages.JavaScript,
     SupportedLanguages.Kotlin,
+    SupportedLanguages.Java,
 ]);
 /**
  * Return the env-var name that controls a given language's registry-

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -41,7 +41,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             if (site.callForm === 'constructor') {
                 const classDef = findClassBindingInScope(site.inScope, site.name, scopes);
                 if (classDef !== undefined) {
-                    fnDef = pickConstructorOrClass(classDef, workspaceIndex);
+                    fnDef = pickConstructorOrClass(classDef, workspaceIndex, scopes);
                 }
             }
             // Implicit-this overload narrowing: an unqualified call inside
@@ -449,7 +449,7 @@ function logicalCallableKey(def) {
  *  Class def itself when no explicit Constructor exists. Matches
  *  legacy behavior — tests assert targetLabel === 'Class' for implicit
  *  ctors and targetLabel === 'Constructor' for explicit ones. */
-function pickConstructorOrClass(classDef, workspaceIndex) {
+function pickConstructorOrClass(classDef, workspaceIndex, scopes) {
     const classScope = workspaceIndex.classScopeByDefId.get(classDef.nodeId);
     if (classScope === undefined)
         return classDef;
@@ -457,6 +457,17 @@ function pickConstructorOrClass(classDef, workspaceIndex) {
         if (def.type === 'Constructor')
             return def;
     }
+    if (scopes !== undefined) {
+        for (const childId of scopes.scopeTree.getChildren(classScope.id)) {
+            const childScope = scopes.scopeTree.getScope(childId);
+            if (childScope === undefined || childScope.kind === 'Class')
+                continue;
+            for (const def of childScope.ownedDefs) {
+                if (def.type === 'Constructor')
+                    return def;
+            }
+        }
+    }
     return classDef;
 }
 /** Walk up from the call-site scope to the enclosing class scope,

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -124,6 +124,15 @@ export const scopeResolutionPhase = {
                     }
                 },
             }, provider);
+            // Release file contents and pre-extracted entries after each language
+            // to reduce memory pressure. For large codebases (16K+ PHP files),
+            // holding all source code simultaneously with scope trees causes OOM.
+            // See: https://github.com/abhigyanpatwari/GitNexus/issues/1741
+            files.length = 0;
+            contents.clear();
+            for (const fp of filePaths) {
+                preExtractedByPath.delete(fp);
+            }
             anyRan = true;
             totalFiles += stats.filesProcessed;
             totalImports += stats.importsEmitted;

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -44,24 +44,40 @@ const EMPTY_BINDINGS = Object.freeze([]);
 export function lookupBindingsAt(scopeId, name, scopes) {
     const finalized = scopes.bindings.get(scopeId)?.get(name);
     const augmented = scopes.bindingAugmentations.get(scopeId)?.get(name);
+    const workspace = scopes.workspaceFqnBindings?.get(name);
     const fLen = finalized?.length ?? 0;
     const aLen = augmented?.length ?? 0;
-    if (fLen === 0 && aLen === 0)
+    const wLen = workspace?.length ?? 0;
+    if (fLen === 0 && aLen === 0 && wLen === 0)
         return EMPTY_BINDINGS;
-    if (aLen === 0)
+    if (aLen === 0 && wLen === 0)
         return finalized;
-    if (fLen === 0)
+    if (fLen === 0 && wLen === 0)
         return augmented;
+    if (fLen === 0 && aLen === 0)
+        return workspace;
     const seen = new Set();
     const out = [];
-    for (const r of finalized) {
-        seen.add(r.def.nodeId);
-        out.push(r);
+    if (fLen > 0) {
+        for (const r of finalized) {
+            seen.add(r.def.nodeId);
+            out.push(r);
+        }
     }
-    for (const r of augmented) {
-        if (seen.has(r.def.nodeId))
-            continue;
-        out.push(r);
+    if (aLen > 0) {
+        for (const r of augmented) {
+            if (seen.has(r.def.nodeId))
+                continue;
+            seen.add(r.def.nodeId);
+            out.push(r);
+        }
+    }
+    if (wLen > 0) {
+        for (const r of workspace) {
+            if (seen.has(r.def.nodeId))
+                continue;
+            out.push(r);
+        }
     }
     return out;
 }

package/package.json

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