gitnexus 1.6.13-rc.77 → 1.6.13-rc.79

package/dist/core/augmentation/engine.js

@@ -108,7 +108,7 @@ export async function augment(pattern, cwd) {
             await initLbug(repoId, repo.lbugPath);
         }
         // Step 1: BM25 search (fast, no embeddings)
-        const { results: bm25Results, ftsAvailable } = await searchFTSFromLbug(pattern, 10, repoId);
+        const { results: bm25Results } = await searchFTSFromLbug(pattern, 10, repoId);
         // Step 2: Map BM25 file results to symbols
         const symbolMatches = [];
         for (const result of bm25Results.slice(0, 5)) {
@@ -135,14 +135,16 @@ export async function augment(pattern, cwd) {
                 /* skip */
             }
         }
-        // When FTS indexes are unavailable (read-only DB, first run before indexes are built),
-        // fall back to a direct name CONTAINS query so enrichment still works.
-        if (symbolMatches.length === 0 && !ftsAvailable) {
+        // FTS ranks files by mentions, so a widely referenced symbol's definition
+        // may not be present in the top file results. Fall back to graph names
+        // whenever those files produce no symbol match, regardless of FTS health.
+        if (symbolMatches.length === 0) {
             const fallbackRows = await executeQuery(repoId, `
         MATCH (n)
         WHERE n.name CONTAINS '${patternFirstWord}'
-        RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath
-        ORDER BY id
+        RETURN n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath,
+          CASE WHEN n.name = '${patternFirstWord}' THEN 0 ELSE 1 END AS exactRank
+        ORDER BY exactRank, id
         LIMIT 5
       `).catch(() => []);
             for (const sym of fallbackRows) {

package/dist/core/group/extractors/http-patterns/go.js

@@ -1,6 +1,6 @@
 import Go from 'tree-sitter-go';
 import { goImportPackageName } from '../../../ingestion/languages/go/import-package-name.js';
-import { stringLiteral } from '../../../ingestion/route-extractors/go-shared.js';
+import { isEchoImportPath, isGinImportPath, stringLiteral, } from '../../../ingestion/route-extractors/go-shared.js';
 import { compilePatterns, runCompiledPatterns, } from '../tree-sitter-scanner.js';
 /**
  * Go HTTP plugin. Handles:
@@ -54,7 +54,8 @@ const HANDLER_ARG_TYPES = new Set([
 ]);
 /**
  * The file's framework import aliases: which local qualifiers resolve to
- * echo and to gin. Matched on the import path rather than the local name, so
+ * echo and to gin. Matched on the EXACT import path (shared with ingestion via
+ * go-shared.ts) rather than the local name, so
  * an aliased import still counts; an unaliased import is keyed by its
  * conventional package name (`goImportPackageName`). `_` and `.` imports bind
  * no qualifier this file can route through. An empty set means the file
@@ -77,9 +78,9 @@ function readFrameworkImports(root) {
         const local = spec.childForFieldName('name')?.text ?? goImportPackageName(importPath);
         if (local === '_' || local === '.')
             continue;
-        if (importPath.includes('labstack/echo'))
+        if (isEchoImportPath(importPath))
             echo.add(local);
-        else if (importPath.includes('gin-gonic/gin'))
+        else if (isGinImportPath(importPath))
             gin.add(local);
     }
     return { echo, gin };
@@ -139,10 +140,22 @@ function asGroupCall(node) {
         return null;
     return { parent, prefix };
 }
+/** The `var_spec`s of a `var_declaration`, flattened out of a grouped `var (…)`. */
+function varSpecs(decl) {
+    return decl.namedChildren
+        .flatMap((c) => (c.type === 'var_spec_list' ? c.namedChildren : [c]))
+        .filter((spec) => spec.type === 'var_spec');
+}
 /** The expression `name` is assigned by `stmt` (`:=`, `=`, or `var`), if any. */
 function boundValue(stmt, name) {
     const pick = (names, values) => {
-        const i = names.findIndex((n) => n.type === 'identifier' && n.text === name);
+        // Go carries an assignment out left to right, so a repeated target leaves
+        // the LAST one in place (`g, g = a, b` ends with g == b).
+        let i = -1;
+        for (let k = 0; k < names.length; k++) {
+            if (names[k].type === 'identifier' && names[k].text === name)
+                i = k;
+        }
         if (i < 0)
             return undefined;
         return codeChildren(values)[i] ?? null;
@@ -154,10 +167,7 @@ function boundValue(stmt, name) {
         case 'var_spec':
             return pick(stmt.childrenForFieldName('name'), stmt.childForFieldName('value'));
         case 'var_declaration': {
-            const specs = stmt.namedChildren.flatMap((c) => c.type === 'var_spec_list' ? c.namedChildren : [c]);
-            for (const spec of specs) {
-                if (spec.type !== 'var_spec')
-                    continue;
+            for (const spec of varSpecs(stmt)) {
                 const value = pick(spec.childrenForFieldName('name'), spec.childForFieldName('value'));
                 if (value !== undefined)
                     return value;
@@ -196,20 +206,200 @@ function within(outer, inner) {
     return !!outer && outer.startIndex <= inner.startIndex && inner.endIndex <= outer.endIndex;
 }
 /**
- * Whether `stmt` writes `name` with a plain assignment somewhere inside it
- * (`g = …` in a nested block, branch, loop, or closure body). A nested `:=`
- * declares a new variable and is not a write to the outer one.
+ * Whether `node` is itself a write to `name`: a plain `assignment_statement`
+ * (`g = …`) or the `=` form of a range clause (`for _, g = range xs`) or a
+ * select receive (`case g = <-ch`), which tree-sitter parses as their own node
+ * types. A `:=` declares a new variable — loop- or case-local — and is not a
+ * write to the outer one.
+ */
+function isWriteTo(node, name) {
+    if (node.type === 'assignment_statement') {
+        return declaresName(node.childForFieldName('left'), name);
+    }
+    return ((node.type === 'range_clause' || node.type === 'receive_statement') &&
+        assignsExistingName(node) &&
+        declaresName(node.childForFieldName('left'), name));
+}
+/**
+ * Every write to `name` inside `scope` (a statement or a function literal).
+ * With `executedOnly`, a nested function literal is entered only through a
+ * call: one merely stored in a value does not run when its enclosing body
+ * runs.
+ */
+function writesInScope(scope, name, executedOnly) {
+    const out = [];
+    const walk = (node) => {
+        if (node.type === 'func_literal') {
+            if (executedOnly && !isInvokedLiteral(node))
+                return;
+            const body = node.childForFieldName('body');
+            if (body)
+                walk(body);
+            return;
+        }
+        if (isWriteTo(node, name))
+            out.push(node);
+        for (const child of node.namedChildren)
+            walk(child);
+    };
+    walk(scope);
+    return out;
+}
+/**
+ * Whether `scope` writes `name` through a binding declared OUTSIDE it: an
+ * assignment (or `=` range/receive) whose target resolves to a name the scope
+ * itself does not declare — a captured outer group rather than a local `:=`,
+ * `var`, or parameter. An unresolvable or conflicting write reaches out
+ * conservatively. With `executedOnly`, writes that only run if a nested
+ * function literal is later called are ignored.
+ */
+function writesOuterName(scope, name, executedOnly = false) {
+    for (const write of writesInScope(scope, name, executedOnly)) {
+        const ident = identifierNamed(write.childForFieldName('left'), name);
+        if (!ident)
+            continue;
+        // A range/receive `=` target resolves from OUTSIDE its clause: the
+        // clause's own binding logic describes the loop/case variable, not the
+        // existing name the `=` writes.
+        const from = write.type === 'range_clause' || write.type === 'receive_statement'
+            ? write.parent
+            : undefined;
+        const binding = lookupBinding(ident, from);
+        // null is a declaration without a traceable value; it carries no position
+        // to place, so a write through it reaches out conservatively.
+        if (binding === undefined || binding === null || binding === CONFLICT)
+            return true;
+        const declared = isParamBinding(binding) ? binding.param : binding;
+        if (!within(scope, declared))
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether `stmt` writes `name` through a binding declared outside it — a
+ * nested assignment, branch, loop, or closure body. A declaration that
+ * shadows `name` inside the statement (a nested `:=`, a parameter) writes the
+ * local, not the target the use would see, so it does not count.
  */
 function writesNameInside(stmt, name) {
-    return [stmt, ...stmt.descendantsOfType('assignment_statement')].some((a) => a.type === 'assignment_statement' && declaresName(a.childForFieldName('left'), name));
+    return writesOuterName(stmt, name);
 }
-/** Whether an identifier or expression_list (e.g. a range left side) declares `name`. */
-function declaresName(node, name) {
+/** A range clause or receive that assigns (`=`) rather than declares (`:=`). */
+function assignsExistingName(clause) {
+    return !clause.children.some((c) => c.type === ':=');
+}
+/**
+ * Whether `fn` is the callee of a call (`func(){ … }()`), ignoring
+ * parentheses, so its body is known to run.
+ */
+function isInvokedLiteral(fn) {
+    let callee = fn;
+    while (callee.parent?.type === 'parenthesized_expression')
+        callee = callee.parent;
+    const parent = callee.parent;
+    return (!!parent &&
+        parent.type === 'call_expression' &&
+        parent.childForFieldName('function')?.id === callee.id);
+}
+/**
+ * Whether evaluating `node` executes a write to `name`. A function literal is
+ * only entered when it is the callee of a call: `g := func(){ g = … }` merely
+ * stores the literal, so the outer `g` is untouched, while `func(){ … }()`
+ * runs its body (writes that resolve to the literal's own locals excepted).
+ */
+function executedWritesName(node, name) {
+    if (node.type === 'func_literal') {
+        return isInvokedLiteral(node) && writesOuterName(node, name, true);
+    }
+    if (isWriteTo(node, name))
+        return true;
+    return node.namedChildren.some((child) => executedWritesName(child, name));
+}
+/**
+ * Whether the initializer of the declaration that brings `name` into scope in
+ * a block writes the OUTER `name`. The right-hand side runs before the new
+ * variable exists, so `g := func(){ g = … }()` still writes the binding the
+ * use outside the block would inherit — but a literal only stored in a value
+ * never runs its body. Grouped `var` specs up to and including the declaring
+ * one are scanned; later specs read the new local.
+ */
+function initializerWritesName(decl, name) {
+    if (decl.type === 'short_var_declaration') {
+        const values = decl.childForFieldName('right');
+        return !!values && executedWritesName(values, name);
+    }
+    if (decl.type === 'var_declaration') {
+        for (const spec of varSpecs(decl)) {
+            const value = spec.childForFieldName('value');
+            if (value && executedWritesName(value, name))
+                return true;
+            if (boundValue(spec, name) !== undefined)
+                return false;
+        }
+    }
+    return false;
+}
+/**
+ * Whether `stmt` holds a function literal that writes the outer `name`. Such
+ * a literal can run after any later direct assignment (`reset := func(){ g = … };
+ * g = …; reset()`), so captured writes are found independently of statement
+ * order instead of being lost behind the last-assignment return. Writes that
+ * resolve to a declaration inside the literal (a parameter, a nested `:=`) are
+ * local and do not count.
+ */
+function closureWritesName(stmt, name) {
+    const literals = stmt.type === 'func_literal'
+        ? [stmt, ...stmt.descendantsOfType('func_literal')]
+        : stmt.descendantsOfType('func_literal');
+    return literals.some((fn) => writesOuterName(fn, name));
+}
+/**
+ * The effect a bare `{ … }` block placed before the use has on the outer
+ * `name`. A bare block always runs, so its last top-level `name = v` is the
+ * value that reaches the use (`{ g = r.Group("/new") }` → `/new`); a write
+ * nested in a branch, loop, or closure inside it is CONFLICT. A `:=` or `var`
+ * of `name` in the block starts a new variable, so only the statements before
+ * it touch the outer one — but the declaring statement's initializer still
+ * does, because it evaluates before the new variable is in scope. undefined
+ * when the block leaves `name` alone.
+ */
+function bareBlockWrite(block, name) {
+    const stmts = codeChildren(block);
+    const declIndex = stmts.findIndex((s) => (s.type === 'short_var_declaration' || s.type === 'var_declaration') &&
+        boundValue(s, name) !== undefined);
+    const outerRegion = declIndex < 0 ? stmts : stmts.slice(0, declIndex);
+    if (declIndex >= 0 && initializerWritesName(stmts[declIndex], name))
+        return CONFLICT;
+    if (outerRegion.some((stmt) => closureWritesName(stmt, name)))
+        return CONFLICT;
+    for (const stmt of outerRegion.reverse()) {
+        if (stmt.type === 'assignment_statement') {
+            const value = boundValue(stmt, name);
+            if (value !== undefined)
+                return value;
+        }
+        if (stmt.type === 'block') {
+            const inner = bareBlockWrite(stmt, name);
+            if (inner !== undefined)
+                return inner;
+            continue;
+        }
+        if (writesNameInside(stmt, name))
+            return CONFLICT;
+    }
+    return undefined;
+}
+/** The identifier named `name` on an assignment side (or null). */
+function identifierNamed(node, name) {
     if (!node)
-        return false;
+        return null;
     if (node.type === 'identifier')
-        return node.text === name;
-    return node.namedChildren.some((n) => n.type === 'identifier' && n.text === name);
+        return node.text === name ? node : null;
+    return node.namedChildren.find((n) => n.type === 'identifier' && n.text === name) ?? null;
+}
+/** Whether an identifier or expression_list (e.g. a range left side) declares `name`. */
+function declaresName(node, name) {
+    return identifierNamed(node, name) !== null;
 }
 /**
  * The value last bound to identifier `ident` before its use: the nearest
@@ -234,12 +424,14 @@ function findBinding(ident) {
  * CONFLICT means a preceding statement writes the name in a nested scope, so
  * the value at the use is control-flow dependent. A parameter or method
  * receiver of the enclosing function returns its declaration (ParamBinding):
- * no value, but a static type.
+ * no value, but a static type. `from` starts the walk at that node's parent
+ * instead of the identifier's, so an `=` range/receive target can be resolved
+ * outside its own clause.
  */
-function lookupBinding(ident) {
+function lookupBinding(ident, from) {
     const name = ident.text;
-    let child = ident;
-    for (let node = ident.parent; node; child = node, node = node.parent) {
+    let child = from ?? ident;
+    for (let node = child.parent; node; child = node, node = node.parent) {
         if (node.type === 'function_declaration' ||
             node.type === 'method_declaration' ||
             node.type === 'func_literal') {
@@ -287,8 +479,15 @@ function lookupBinding(ident) {
                 const value = boundValue(stmt, name);
                 if (value !== undefined)
                     return value;
-                // A write nested in an earlier statement (block, branch, loop) may or
-                // may not run before the use: the reaching value is unprovable.
+                // A bare block always runs: its unconditional writes are bindings.
+                if (stmt.type === 'block') {
+                    const written = bareBlockWrite(stmt, name);
+                    if (written !== undefined)
+                        return written;
+                    continue;
+                }
+                // A write nested in an earlier branch, loop, or closure may or may
+                // not run before the use: the reaching value is unprovable.
                 if (writesNameInside(stmt, name))
                     return CONFLICT;
             }

package/dist/core/ingestion/route-extractors/go-gin-echo.js

@@ -24,7 +24,7 @@
  */
 import { goImportPackageName } from '../languages/go/import-package-name.js';
 import { GoRouteBindings } from '../languages/go/route-bindings.js';
-import { stringLiteral } from './go-shared.js';
+import { isEchoImportPath, isGinImportPath, stringLiteral } from './go-shared.js';
 import { normalizeExtractedRoutePath } from './route-path.js';
 export const GIN_ROUTE_SOURCE = 'gin-route';
 export const ECHO_ROUTE_SOURCE = 'echo-route';
@@ -58,9 +58,9 @@ function readImports(root) {
         const local = explicit ?? goImportPackageName(importPath);
         if (!local)
             continue;
-        if (importPath === 'github.com/gin-gonic/gin')
+        if (isGinImportPath(importPath))
             gin = local;
-        if (/^github\.com\/labstack\/echo(\/v\d+)?$/.test(importPath))
+        if (isEchoImportPath(importPath))
             echo = local;
     }
     // Both, or neither: no way to tell which argument is the handler.

package/dist/core/ingestion/route-extractors/go-shared.d.ts

@@ -1,4 +1,12 @@
 import type { SyntaxNode } from 'tree-sitter';
+/**
+ * Framework import paths, matched EXACTLY on both layers (ingestion's
+ * `go-gin-echo.ts` and the group-mode `http-patterns/go.ts`): a substring
+ * test would classify `example.com/labstack/echo-wrapper` as echo on one
+ * side only, flipping the handler-argument order and splitting contracts.
+ */
+export declare function isGinImportPath(importPath: string): boolean;
+export declare function isEchoImportPath(importPath: string): boolean;
 /**
  * Go string-literal decoding shared by the Go route extractors on both
  * layers: the ingestion extractor (`go-gin-echo.ts`, Strategy A) and the

package/dist/core/ingestion/route-extractors/go-shared.js

@@ -1,3 +1,15 @@
+/**
+ * Framework import paths, matched EXACTLY on both layers (ingestion's
+ * `go-gin-echo.ts` and the group-mode `http-patterns/go.ts`): a substring
+ * test would classify `example.com/labstack/echo-wrapper` as echo on one
+ * side only, flipping the handler-argument order and splitting contracts.
+ */
+export function isGinImportPath(importPath) {
+    return importPath === 'github.com/gin-gonic/gin';
+}
+export function isEchoImportPath(importPath) {
+    return /^github\.com\/labstack\/echo(\/v\d+)?$/.test(importPath);
+}
 /**
  * Go string-literal decoding shared by the Go route extractors on both
  * layers: the ingestion extractor (`go-gin-echo.ts`, Strategy A) and the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.77",
+  "version": "1.6.13-rc.79",
   "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",