gitnexus 1.6.10-rc.76 → 1.6.10-rc.78

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

@@ -1,6 +1,22 @@
 const REF_PREFIX_RE = /^&\s*(mut\s+)?/;
 const PTR_PREFIX_RE = /^\*\s*(const|mut)?\s*/;
+const DYN_PREFIX_RE = /^dyn\s+/;
 const ENUM_VARIANT_NAMES = new Set(['Some', 'None', 'Ok', 'Err']);
+// `dyn Trait`, `&dyn Trait`, `Box<dyn Trait>` all name a trait object whose
+// receiver-dispatch target is the trait itself (#2604) — strip the `dyn`
+// keyword and any auto-trait/lifetime bound list (`dyn Trait + Send`) down to
+// the principal trait name. Reference/pointer sigils are stripped by the
+// caller first; wrapper unwrapping (Box<T> etc.) runs before this so the
+// unwrapped inner text still gets the same treatment.
+function stripDynBound(t) {
+    if (!DYN_PREFIX_RE.test(t))
+        return t;
+    t = t.replace(DYN_PREFIX_RE, '');
+    const plus = t.indexOf('+');
+    if (plus !== -1)
+        t = t.slice(0, plus);
+    return t.trim();
+}
 // ─── interpretImport ──────────────────────────────────────────────────────
 export function interpretRustImport(captures) {
     const kind = captures['@import.kind']?.text;
@@ -104,6 +120,7 @@ export function normalizeRustTypeName(text) {
         if (inner !== null)
             t = inner;
     }
+    t = stripDynBound(t);
     const bracket = t.indexOf('<');
     if (bracket !== -1)
         t = t.slice(0, bracket);
@@ -168,6 +185,7 @@ function normalizeRustReturnType(text) {
             }
         }
     }
+    t = stripDynBound(t);
     const bracket = t.indexOf('<');
     if (bracket !== -1)
         t = t.slice(0, bracket);

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

@@ -9,6 +9,7 @@ const RUST_SCOPE_QUERY = `
 (enum_item) @scope.class
 (union_item) @scope.class
 (function_item) @scope.function
+(function_signature_item) @scope.function
 (closure_expression) @scope.function
 (block) @scope.block
 (if_expression) @scope.block
@@ -54,6 +55,14 @@ const RUST_SCOPE_QUERY = `
 (function_item
   name: (identifier) @declaration.name) @declaration.function
 
+;; Declarations — trait method signature (required method, no body,
+;; e.g. fn foo(self) -> T; inside a trait body). Without this, an abstract
+;; trait method is invisible to scope resolution — never owned by its
+;; trait's Class scope, so a dyn Trait receiver can never dispatch to
+;; it (#2604).
+(function_signature_item
+  name: (identifier) @declaration.name) @declaration.function
+
 ;; Declarations — struct fields
 (field_declaration
   name: (field_identifier) @declaration.name

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

@@ -3549,28 +3549,13 @@ export class LocalBackend {
         if (oldName === new_name) {
             return { error: 'New name is the same as the current name.' };
         }
-        // Step 2: Collect edits from graph (high confidence)
-        const changes = new Map();
-        const addEdit = (filePath, line, oldText, newText, confidence) => {
-            if (!changes.has(filePath)) {
-                changes.set(filePath, { file_path: filePath, edits: [] });
-            }
-            changes.get(filePath).edits.push({ line, old_text: oldText, new_text: newText, confidence });
-        };
-        // The definition itself
-        if (sym.filePath && sym.startLine) {
-            try {
-                const content = await fs.readFile(assertSafePath(sym.filePath), 'utf-8');
-                const lines = content.split('\n');
-                const lineIdx = sym.startLine - 1;
-                if (lineIdx >= 0 && lineIdx < lines.length && lines[lineIdx].includes(oldName)) {
-                    const defRegex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
-                    addEdit(sym.filePath, sym.startLine, lines[lineIdx].trim(), lines[lineIdx].replace(defRegex, new_name).trim(), 'graph');
-                }
-            }
-            catch (e) {
-                logQueryError('rename:read-definition', e);
-            }
+        const escapedOldName = oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Classify each file to rewrite by how it was discovered. Definition and
+        // graph-ref files carry graph confidence; files found only by text search
+        // carry text_search confidence. A graph-classified file is never downgraded.
+        const fileConfidence = new Map();
+        if (sym.filePath) {
+            fileConfidence.set(sym.filePath, 'graph');
         }
         // All incoming refs from graph (callers, importers, etc.)
         const allIncoming = [
@@ -3579,31 +3564,12 @@ export class LocalBackend {
             ...(lookupResult.incoming.extends || []),
             ...(lookupResult.incoming.implements || []),
         ];
-        let graphEdits = changes.size > 0 ? 1 : 0; // count definition edit
         for (const ref of allIncoming) {
-            if (!ref.filePath)
-                continue;
-            try {
-                const content = await fs.readFile(assertSafePath(ref.filePath), 'utf-8');
-                const lines = content.split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    if (lines[i].includes(oldName)) {
-                        addEdit(ref.filePath, i + 1, lines[i].trim(), lines[i]
-                            .replace(new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g'), new_name)
-                            .trim(), 'graph');
-                        graphEdits++;
-                        break; // one edit per file from graph refs
-                    }
-                }
-            }
-            catch (e) {
-                logQueryError('rename:read-ref', e);
+            if (ref.filePath) {
+                fileConfidence.set(ref.filePath, 'graph');
             }
         }
-        // Step 3: Text search for refs the graph might have missed
-        let astSearchEdits = 0;
-        const graphFiles = new Set([sym.filePath, ...allIncoming.map((r) => r.filePath)].filter(Boolean));
-        // Simple text search across the repo for the old name (in files not already covered by graph)
+        // Text search for files the graph might have missed entirely.
         try {
             const { execFileSync } = await import('child_process');
             const rgArgs = [
@@ -3629,61 +3595,97 @@ export class LocalBackend {
                 .filter((f) => f.length > 0);
             for (const file of files) {
                 const normalizedFile = file.replace(/\\/g, '/').replace(/^\.\//, '');
-                if (graphFiles.has(normalizedFile))
-                    continue; // already covered by graph
-                try {
-                    const content = await fs.readFile(assertSafePath(normalizedFile), 'utf-8');
-                    const lines = content.split('\n');
-                    const regex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
-                    for (let i = 0; i < lines.length; i++) {
-                        regex.lastIndex = 0;
-                        if (regex.test(lines[i])) {
-                            regex.lastIndex = 0;
-                            addEdit(normalizedFile, i + 1, lines[i].trim(), lines[i].replace(regex, new_name).trim(), 'text_search');
-                            astSearchEdits++;
-                        }
-                    }
-                }
-                catch (e) {
-                    logQueryError('rename:text-search-read', e);
+                // Never downgrade a graph-classified file to text_search.
+                if (!fileConfidence.has(normalizedFile)) {
+                    fileConfidence.set(normalizedFile, 'text_search');
                 }
             }
         }
         catch (e) {
             logQueryError('rename:ripgrep', e);
         }
-        // Step 4: Apply or preview
-        const allChanges = Array.from(changes.values());
-        const totalEdits = allChanges.reduce((sum, c) => sum + c.edits.length, 0);
+        // Enumerate every `\boldName\b` line in each file to rewrite, so the previewed
+        // file set is exactly the set the apply loop below rewrites. A file with no
+        // matching line is dropped (apply would write nothing to it). `wordTest`
+        // (non-global) probes each line; `wordReplace` (global) rewrites it and is
+        // reused by the apply loop — compiled once each rather than once per line,
+        // and one escaping formula serves both passes.
+        const wordTest = new RegExp(`\\b${escapedOldName}\\b`);
+        const wordReplace = new RegExp(`\\b${escapedOldName}\\b`, 'g');
+        const changes = new Map();
+        for (const [filePath, confidence] of fileConfidence) {
+            try {
+                const content = await fs.readFile(assertSafePath(filePath), 'utf-8');
+                const lines = content.split('\n');
+                const edits = [];
+                for (let i = 0; i < lines.length; i++) {
+                    if (!wordTest.test(lines[i])) {
+                        continue;
+                    }
+                    edits.push({
+                        line: i + 1,
+                        old_text: lines[i].trim(),
+                        new_text: lines[i].replace(wordReplace, new_name).trim(),
+                        confidence,
+                    });
+                }
+                if (edits.length > 0) {
+                    changes.set(filePath, { file_path: filePath, edits });
+                }
+            }
+            catch (e) {
+                logQueryError('rename:enumerate', e);
+            }
+        }
+        // Step 4: Apply or preview.
         const failedFiles = [];
         if (!dry_run) {
-            // Apply edits to files
-            for (const change of allChanges) {
+            for (const change of changes.values()) {
                 try {
                     const fullPath = assertSafePath(change.file_path);
-                    let content = await fs.readFile(fullPath, 'utf-8');
-                    const regex = new RegExp(`\\b${oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
-                    content = content.replace(regex, new_name);
-                    await fs.writeFile(fullPath, content, 'utf-8');
+                    const content = await fs.readFile(fullPath, 'utf-8');
+                    await fs.writeFile(fullPath, content.replace(wordReplace, new_name), 'utf-8');
                 }
                 catch (e) {
-                    // A swallowed write failure must not be reported as a full success
-                    // (#2283): record the file so the result can degrade to 'partial'
-                    // with the unwritten files listed, rather than masquerading as done.
+                    // A swallowed write failure must not be reported as success (#2283):
+                    // record the file so the result degrades to 'partial'.
                     logQueryError('rename:apply-edit', e);
                     failedFiles.push(change.file_path);
                 }
             }
+            // A file whose write threw did not land, so drop its edits from the
+            // reported result — total_edits/changes must describe what actually
+            // reached disk, not what was attempted (#2605: the report matches reality
+            // even on partial failure). failed_files still names every dropped file.
+            for (const f of failedFiles) {
+                changes.delete(f);
+            }
+        }
+        // Counts derive from the reported set (dry-run: every enumerated file;
+        // apply: only files that landed), so the graph/text_search split always
+        // sums to total_edits and never overstates a partial apply.
+        const reported = Array.from(changes.values());
+        let graphEdits = 0;
+        let astSearchEdits = 0;
+        for (const change of reported) {
+            for (const edit of change.edits) {
+                if (edit.confidence === 'graph') {
+                    graphEdits++;
+                }
+                else {
+                    astSearchEdits++;
+                }
+            }
         }
         return {
             status: failedFiles.length > 0 ? 'partial' : 'success',
             old_name: oldName,
             new_name,
-            files_affected: allChanges.length,
-            total_edits: totalEdits,
+            files_affected: reported.length,
+            total_edits: graphEdits + astSearchEdits,
             graph_edits: graphEdits,
             text_search_edits: astSearchEdits,
-            changes: allChanges,
+            changes: reported,
             applied: !dry_run,
             ...(failedFiles.length > 0 && { failed_files: failedFiles }),
         };

package/dist/storage/repo-manager.d.ts

@@ -411,8 +411,15 @@ export interface RepoMeta {
  * `Record` node and its `HAS_METHOD` edges for every unchanged record file
  * (same v7 contract: new nodes/edges the incremental path would otherwise
  * never backfill); force a full re-analyze instead.
- */
-export declare const INCREMENTAL_SCHEMA_VERSION = 10;
+ * v11: Rust abstract trait methods (`fn foo(&self) -> T;`, no body) now get a
+ * scope + declaration capture (#2604): RUST_SCOPE_QUERY had no
+ * `function_signature_item` pattern, so a `&dyn Trait` receiver could never
+ * dispatch a CALLS edge to the trait's own method. Same v7/v10 contract: the
+ * incremental write set only covers changed files, so a top-up against a
+ * pre-v11 index would keep silently missing these CALLS edges for every
+ * unchanged Rust trait file; force a full re-analyze instead.
+ */
+export declare const INCREMENTAL_SCHEMA_VERSION = 11;
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;

package/dist/storage/repo-manager.js

@@ -132,8 +132,15 @@ export const cloneDirBelongsToEntry = (cloneDir, entryPath) => registryPathEqual
  * `Record` node and its `HAS_METHOD` edges for every unchanged record file
  * (same v7 contract: new nodes/edges the incremental path would otherwise
  * never backfill); force a full re-analyze instead.
+ * v11: Rust abstract trait methods (`fn foo(&self) -> T;`, no body) now get a
+ * scope + declaration capture (#2604): RUST_SCOPE_QUERY had no
+ * `function_signature_item` pattern, so a `&dyn Trait` receiver could never
+ * dispatch a CALLS edge to the trait's own method. Same v7/v10 contract: the
+ * incremental write set only covers changed files, so a top-up against a
+ * pre-v11 index would keep silently missing these CALLS edges for every
+ * unchanged Rust trait file; force a full re-analyze instead.
  */
-export const INCREMENTAL_SCHEMA_VERSION = 10;
+export const INCREMENTAL_SCHEMA_VERSION = 11;
 const GITNEXUS_DIR = '.gitnexus';
 const GITNEXUS_EXCLUDE_ENTRY = `${GITNEXUS_DIR}/`;
 export const INDEX_METADATA_FILE = 'gitnexus.json';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.76",
+  "version": "1.6.10-rc.78",
   "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",