gitnexus 1.6.10-rc.77 → 1.6.10-rc.78

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/package.json

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