ucn 3.7.1 → 3.7.2

package/core/project.js

@@ -8,10 +8,10 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 const { expandGlob, findProjectRoot, detectProjectPattern, isTestFile, parseGitignore, DEFAULT_IGNORES } = require('./discovery');
 const { extractImports, extractExports, resolveImport } = require('./imports');
-const { parseFile, cleanHtmlScriptTags } = require('./parser');
+const { parse, parseFile, cleanHtmlScriptTags } = require('./parser');
 const { detectLanguage, getParser, getLanguageModule, PARSE_OPTIONS, safeParse } = require('../languages');
 const { getTokenTypeAtPosition } = require('../languages/utils');
 
@@ -402,7 +402,15 @@ class ProjectIndex {
                         return parent;
                     });
 
-                    this.extendsGraph.set(symbol.name, resolvedParents);
+                    // Store with file scope to avoid collisions when same class name
+                    // appears in multiple files (F-002 fix)
+                    if (!this.extendsGraph.has(symbol.name)) {
+                        this.extendsGraph.set(symbol.name, []);
+                    }
+                    this.extendsGraph.get(symbol.name).push({
+                        file: filePath,
+                        parents: resolvedParents
+                    });
 
                     for (const parent of resolvedParents) {
                         if (!this.extendedByGraph.has(parent)) {
@@ -419,6 +427,66 @@ class ProjectIndex {
         }
     }
 
+    /**
+     * Get inheritance parents for a class, scoped by file to handle
+     * duplicate class names across files.
+     * @param {string} className - Class name to look up
+     * @param {string} contextFile - File path for scoping (prefer same-file match)
+     * @returns {string[]|null} Parent class names, or null if none
+     */
+    _getInheritanceParents(className, contextFile) {
+        const entries = this.extendsGraph.get(className);
+        if (!entries || entries.length === 0) return null;
+
+        // New format: array of {file, parents}
+        if (typeof entries[0] === 'object' && entries[0].file !== undefined) {
+            // Prefer same-file match
+            const match = entries.find(e => e.file === contextFile);
+            if (match) return match.parents;
+
+            // Try imported file
+            if (contextFile) {
+                const imports = this.importGraph.get(contextFile);
+                if (imports) {
+                    const imported = entries.find(e => imports.includes(e.file));
+                    if (imported) return imported.parents;
+                }
+            }
+
+            // Fallback to first entry
+            return entries[0].parents;
+        }
+
+        // Old format (cache compat): plain array of parent names
+        return entries;
+    }
+
+    /**
+     * Resolve which file a class is defined in, preferring contextFile.
+     * Used during inheritance BFS to find grandparent chains.
+     * @param {string} className - Class name to resolve
+     * @param {string} contextFile - Preferred file (e.g., child's file)
+     * @returns {string|null} Resolved file path
+     */
+    _resolveClassFile(className, contextFile) {
+        const symbols = this.symbols.get(className);
+        if (!symbols) return contextFile;
+        const classSymbols = symbols.filter(s =>
+            ['class', 'interface', 'struct', 'trait'].includes(s.type));
+        if (classSymbols.length === 0) return contextFile;
+        // Prefer same file as context
+        if (classSymbols.some(s => s.file === contextFile)) return contextFile;
+        // Prefer imported
+        if (contextFile) {
+            const imports = this.importGraph.get(contextFile);
+            if (imports) {
+                const imported = classSymbols.find(s => imports.includes(s.file));
+                if (imported) return imported.file;
+            }
+        }
+        return classSymbols[0].file;
+    }
+
 
     // ========================================================================
     // QUERY METHODS
@@ -1246,21 +1314,23 @@ class ProjectIndex {
                             let matchesDef = call.receiver === 'super'
                                 ? false
                                 : definitions.some(d => d.className === callerSymbol.className);
-                            // Walk inheritance chain if not found in same class
+                            // Walk inheritance chain using BFS if not found in same class
                             if (!matchesDef) {
-                                let parents = this.extendsGraph.get(callerSymbol.className);
                                 const visited = new Set([callerSymbol.className]);
-                                while (parents && !matchesDef) {
-                                    for (const parent of parents) {
-                                        if (visited.has(parent)) continue;
-                                        visited.add(parent);
-                                        matchesDef = definitions.some(d => d.className === parent);
-                                        if (matchesDef) break;
-                                    }
+                                const callerFile = callerSymbol.file || filePath;
+                                const startParents = this._getInheritanceParents(callerSymbol.className, callerFile) || [];
+                                const queue = startParents.map(p => ({ name: p, contextFile: callerFile }));
+                                while (queue.length > 0 && !matchesDef) {
+                                    const { name: current, contextFile } = queue.shift();
+                                    if (visited.has(current)) continue;
+                                    visited.add(current);
+                                    matchesDef = definitions.some(d => d.className === current);
                                     if (!matchesDef) {
-                                        const nextParent = parents.find(p => !visited.has(p));
-                                        if (!nextParent) break;
-                                        parents = this.extendsGraph.get(nextParent);
+                                        const resolvedFile = this._resolveClassFile(current, contextFile);
+                                        const grandparents = this._getInheritanceParents(current, resolvedFile) || [];
+                                        for (const gp of grandparents) {
+                                            if (!visited.has(gp)) queue.push({ name: gp, contextFile: resolvedFile });
+                                        }
                                     }
                                 }
                             }
@@ -1665,22 +1735,23 @@ class ProjectIndex {
                         ? null
                         : symbols.find(s => s.className === def.className);
 
-                    // Walk inheritance chain if not found in same class
+                    // Walk inheritance chain using BFS if not found in same class
                     if (!match) {
-                        let parents = this.extendsGraph.get(def.className);
                         const visited = new Set([def.className]);
-                        while (parents && !match) {
-                            for (const parent of parents) {
-                                if (visited.has(parent)) continue;
-                                visited.add(parent);
-                                match = symbols.find(s => s.className === parent);
-                                if (match) break;
-                            }
+                        const defFile = def.file;
+                        const startParents = this._getInheritanceParents(def.className, defFile) || [];
+                        const queue = startParents.map(p => ({ name: p, contextFile: defFile }));
+                        while (queue.length > 0 && !match) {
+                            const { name: current, contextFile } = queue.shift();
+                            if (visited.has(current)) continue;
+                            visited.add(current);
+                            match = symbols.find(s => s.className === current);
                             if (!match) {
-                                // Follow first parent's chain (simplified MRO)
-                                const nextParent = parents.find(p => !visited.has(p));
-                                if (!nextParent) break;
-                                parents = this.extendsGraph.get(nextParent);
+                                const resolvedFile = this._resolveClassFile(current, contextFile);
+                                const grandparents = this._getInheritanceParents(current, resolvedFile) || [];
+                                for (const gp of grandparents) {
+                                    if (!visited.has(gp)) queue.push({ name: gp, contextFile: resolvedFile });
+                                }
                             }
                         }
                     }
@@ -4830,8 +4901,8 @@ class ProjectIndex {
             throw new Error('Not a git repository. diff-impact requires git.');
         }
 
-        // Build git diff command
-        const diffArgs = ['git', 'diff', '--unified=0'];
+        // Build git diff command (use execFileSync to avoid shell expansion)
+        const diffArgs = ['diff', '--unified=0'];
         if (staged) {
             diffArgs.push('--staged');
         } else {
@@ -4843,7 +4914,7 @@ class ProjectIndex {
 
         let diffText;
         try {
-            diffText = execSync(diffArgs.join(' '), { cwd: this.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
+            diffText = execFileSync('git', diffArgs, { cwd: this.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
         } catch (e) {
             // git diff exits non-zero when there are diff errors, but also for invalid refs
             if (e.stdout) {
@@ -4878,7 +4949,31 @@ class ProjectIndex {
             if (!lang) continue;
 
             const fileEntry = this.files.get(change.filePath);
-            if (!fileEntry) continue;
+
+            // Handle deleted files: entire file was removed, all functions are deleted
+            if (!fileEntry) {
+                if (change.isDeleted && change.deletedLines.length > 0) {
+                    const ref = staged ? 'HEAD' : base;
+                    try {
+                        const oldContent = execFileSync(
+                            'git', ['show', `${ref}:${change.relativePath}`],
+                            { cwd: this.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
+                        );
+                        const oldParsed = parse(oldContent, lang);
+                        for (const oldFn of extractCallableSymbols(oldParsed)) {
+                            deletedFunctions.push({
+                                name: oldFn.name,
+                                filePath: change.filePath,
+                                relativePath: change.relativePath,
+                                startLine: oldFn.startLine
+                            });
+                        }
+                    } catch (e) {
+                        // git show failed — skip
+                    }
+                }
+                continue;
+            }
 
             // Track which functions are affected by added/modified lines
             const affectedSymbols = new Map(); // symbolName -> { symbol, addedLines, deletedLines }
@@ -4960,6 +5055,57 @@ class ProjectIndex {
                 }
             }
 
+            // Detect deleted functions: compare old file symbols with current by identity.
+            // Uses name+className counts to handle overloads (e.g. Java method overloading).
+            if (change.deletedLines.length > 0) {
+                const ref = staged ? 'HEAD' : base;
+                try {
+                    const oldContent = execFileSync(
+                        'git', ['show', `${ref}:${change.relativePath}`],
+                        { cwd: this.root, encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 }
+                    );
+                    const fileLang = detectLanguage(change.filePath);
+                    if (fileLang) {
+                        const oldParsed = parse(oldContent, fileLang);
+                        const nonCallableTypes = new Set(['class', 'struct', 'interface', 'type', 'state', 'impl', 'enum', 'trait']);
+                        // Count current symbols by identity (name + className)
+                        const currentCounts = new Map();
+                        for (const s of fileEntry.symbols) {
+                            if (nonCallableTypes.has(s.type)) continue;
+                            const key = `${s.name}\0${s.className || ''}`;
+                            currentCounts.set(key, (currentCounts.get(key) || 0) + 1);
+                        }
+                        // Count old symbols by identity and detect deletions
+                        const oldCounts = new Map();
+                        const oldSymbols = extractCallableSymbols(oldParsed);
+                        for (const oldFn of oldSymbols) {
+                            const key = `${oldFn.name}\0${oldFn.className || ''}`;
+                            oldCounts.set(key, (oldCounts.get(key) || 0) + 1);
+                        }
+                        // For each identity, if old count > current count, the difference are deletions
+                        for (const [key, oldCount] of oldCounts) {
+                            const curCount = currentCounts.get(key) || 0;
+                            if (oldCount > curCount) {
+                                // Find the specific old symbols with this identity that were deleted
+                                const matching = oldSymbols.filter(s => `${s.name}\0${s.className || ''}` === key);
+                                // Report the extra ones (by startLine descending — later ones more likely deleted)
+                                const toReport = matching.slice(curCount);
+                                for (const oldFn of toReport) {
+                                    deletedFunctions.push({
+                                        name: oldFn.name,
+                                        filePath: change.filePath,
+                                        relativePath: change.relativePath,
+                                        startLine: oldFn.startLine
+                                    });
+                                }
+                            }
+                        }
+                    }
+                } catch (e) {
+                    // File didn't exist in base, or git error — skip
+                }
+            }
+
             // For each affected function, find callers
             for (const [, data] of affectedSymbols) {
                 const { symbol, addedLines: aLines, deletedLines: dLines } = data;
@@ -5012,6 +5158,40 @@ class ProjectIndex {
     }
 }
 
+/**
+ * Extract all callable symbols (functions + class methods) from a parse result,
+ * matching how indexFile builds the symbol list. Methods get className added.
+ * @param {object} parsed - Result from parse()
+ * @returns {Array<{name, className, startLine}>}
+ */
+function extractCallableSymbols(parsed) {
+    const symbols = [];
+    for (const fn of parsed.functions) {
+        symbols.push({ name: fn.name, className: fn.className || '', startLine: fn.startLine });
+    }
+    for (const cls of parsed.classes) {
+        if (cls.members) {
+            for (const m of cls.members) {
+                symbols.push({ name: m.name, className: cls.name, startLine: m.startLine });
+            }
+        }
+    }
+    return symbols;
+}
+
+/**
+ * Unquote a git diff path: unescape C-style backslash sequences and strip tab metadata.
+ * Git quotes paths containing special chars as "a/path\"with\"quotes".
+ * @param {string} raw - Raw path string (may contain backslash escapes)
+ * @returns {string} Unquoted path
+ */
+function unquoteDiffPath(raw) {
+    const ESCAPES = { '\\\\': '\\', '\\"': '"', '\\n': '\n', '\\t': '\t' };
+    return raw
+        .split('\t')[0]
+        .replace(/\\[\\"nt]/g, m => ESCAPES[m]);
+}
+
 /**
  * Parse unified diff output into structured change data
  * @param {string} diffText - Output from `git diff --unified=0`
@@ -5021,16 +5201,39 @@ class ProjectIndex {
 function parseDiff(diffText, root) {
     const changes = [];
     let currentFile = null;
+    let pendingOldPath = null; // Track --- a/ path for deleted files
 
     for (const line of diffText.split('\n')) {
-        // Match file header: +++ b/path/to/file.js
-        if (line.startsWith('+++ b/')) {
-            const relativePath = line.slice(6);
+        // Track old file path from --- header for deleted-file detection
+        // Handles both unquoted (--- a/path) and quoted (--- "a/path") formats
+        const oldMatch = line.match(/^--- (?:"a\/((?:[^"\\]|\\.)*)"|a\/(.+?))\s*$/);
+        if (oldMatch) {
+            const raw = oldMatch[1] !== undefined ? oldMatch[1] : oldMatch[2];
+            pendingOldPath = unquoteDiffPath(raw);
+            continue;
+        }
+
+        // Match file header: +++ b/path or +++ "b/path" or +++ /dev/null
+        if (line.startsWith('+++ ')) {
+            let relativePath;
+            const isDevNull = line.startsWith('+++ /dev/null');
+            if (isDevNull) {
+                // File was deleted — use the --- a/ path
+                if (!pendingOldPath) continue;
+                relativePath = pendingOldPath;
+            } else {
+                const newMatch = line.match(/^\+\+\+ (?:"b\/((?:[^"\\]|\\.)*)"|b\/(.+?))\s*$/);
+                if (!newMatch) continue;
+                const raw = newMatch[1] !== undefined ? newMatch[1] : newMatch[2];
+                relativePath = unquoteDiffPath(raw);
+            }
+            pendingOldPath = null;
             currentFile = {
                 filePath: path.join(root, relativePath),
                 relativePath,
                 addedLines: [],
-                deletedLines: []
+                deletedLines: [],
+                ...(isDevNull && { isDeleted: true })
             };
             changes.push(currentFile);
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.7.1",
+  "version": "3.7.2",
   "description": "Universal Code Navigator — function relationships, call trees, and impact analysis across large codebases without reading entire files.",
   "main": "index.js",
   "bin": {

package/test/accuracy.test.js

@@ -1376,7 +1376,7 @@ class Child(Base):
         } finally { rm(d); }
     });
 
-    it('LIMITATION: deep inheritance chain (3+ levels)', () => {
+    it('PASS: deep inheritance chain (3+ levels)', () => {
         const d = tmp({
             'package.json': '{"name":"t"}',
             'lib.js': `

package/test/parser.test.js

@@ -12690,5 +12690,340 @@ function doStuff() { return 42; }
     });
 });
 
+// FIX 91: Deep inheritance chain (3+ levels) — BFS traversal
+it('FIX 91 — deep inheritance chain resolves callees through 3+ levels', () => {
+    const tmpDir = path.join(os.tmpdir(), `ucn-deep-inherit-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'lib.js'), `
+class A {
+    helper() { return 1; }
+}
+class B extends A {
+    other() { return 2; }
+}
+class C extends B {
+    process() { return this.helper(); }
+}
+module.exports = { A, B, C };
+`);
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+
+        // Callees: C.process() should resolve this.helper() to A.helper via C → B → A
+        const processDef = index.symbols.get('process')?.[0];
+        const callees = index.findCallees(processDef);
+        assert.ok(callees.some(c => c.name === 'helper' && c.className === 'A'),
+            'Deep chain callees: C → B → A, this.helper() resolves to A.helper');
+
+        // Callers: A.helper should be found as called from C.process()
+        const callers = index.findCallers('helper');
+        assert.ok(callers.some(c => c.callerName === 'process'),
+            'Deep chain callers: A.helper() called from C.process() via inheritance');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 92: Inheritance graph key collision with duplicate class names across files
+it('FIX 92 — duplicate class names across files resolve independently', () => {
+    const tmpDir = path.join(os.tmpdir(), `ucn-dup-class-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'a1.js'), `
+class A { helper() { return 1; } }
+class C extends A { process() { return this.helper(); } }
+module.exports = { A, C };
+`);
+        fs.writeFileSync(path.join(tmpDir, 'a2.js'), `
+class B { helper() { return 2; } }
+class C extends B { run() { return this.helper(); } }
+module.exports = { B, C };
+`);
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+
+        // C in a1.js extends A → helper should resolve to A.helper (a1.js)
+        const processDef = index.symbols.get('process').find(s => s.file.endsWith('a1.js'));
+        const processCallees = index.findCallees(processDef);
+        const helperFromProcess = processCallees.find(c => c.name === 'helper');
+        assert.ok(helperFromProcess, 'process() resolves this.helper()');
+        assert.strictEqual(helperFromProcess.className, 'A', 'process() helper is from class A');
+        assert.ok(helperFromProcess.file.endsWith('a1.js'), 'process() helper is in a1.js');
+
+        // C in a2.js extends B → helper should resolve to B.helper (a2.js)
+        const runDef = index.symbols.get('run').find(s => s.file.endsWith('a2.js'));
+        const runCallees = index.findCallees(runDef);
+        const helperFromRun = runCallees.find(c => c.name === 'helper');
+        assert.ok(helperFromRun, 'run() resolves this.helper()');
+        assert.strictEqual(helperFromRun.className, 'B', 'run() helper is from class B');
+        assert.ok(helperFromRun.file.endsWith('a2.js'), 'run() helper is in a2.js');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 93: diffImpact detects deleted functions
+it('FIX 93 — diffImpact detects deleted functions', () => {
+    const { execSync } = require('child_process');
+    const tmpDir = path.join(os.tmpdir(), `ucn-diff-del-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        execSync('git init', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'app.js'), `function foo() { return 1; }
+function bar() { return foo(); }
+`);
+        execSync('git add -A && git commit -m "init"', { cwd: tmpDir, stdio: 'pipe' });
+
+        // Delete foo, keep bar
+        fs.writeFileSync(path.join(tmpDir, 'app.js'), `function bar() { return 2; }
+`);
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+        const result = index.diffImpact({ base: 'HEAD' });
+
+        assert.ok(result.deletedFunctions.length >= 1, 'Should detect deleted function');
+        assert.ok(result.deletedFunctions.some(f => f.name === 'foo'), 'foo should be in deletedFunctions');
+        assert.strictEqual(result.summary.deletedFunctions, result.deletedFunctions.length,
+            'Summary count should match deletedFunctions length');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 94: diffImpact detects deleted functions when entire file is removed
+it('FIX 94 — diffImpact detects all functions in a deleted file', () => {
+    const { execSync } = require('child_process');
+    const tmpDir = path.join(os.tmpdir(), `ucn-diff-filedel-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        execSync('git init', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'a.js'), 'function foo() { return 1; }\nfunction bar() { return 2; }\n');
+        fs.writeFileSync(path.join(tmpDir, 'b.js'), 'function baz() { return 3; }\n');
+        execSync('git add -A && git commit -m "init"', { cwd: tmpDir, stdio: 'pipe' });
+
+        // Delete entire file a.js
+        fs.unlinkSync(path.join(tmpDir, 'a.js'));
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+        const result = index.diffImpact({ base: 'HEAD' });
+
+        assert.ok(result.deletedFunctions.some(f => f.name === 'foo'), 'foo should be detected as deleted');
+        assert.ok(result.deletedFunctions.some(f => f.name === 'bar'), 'bar should be detected as deleted');
+        assert.ok(!result.deletedFunctions.some(f => f.name === 'baz'), 'baz should NOT be deleted');
+        assert.strictEqual(result.summary.deletedFunctions, 2);
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 95: diffImpact detects same-name method deletion by identity
+it('FIX 95 — diffImpact detects A.foo deleted while B.foo remains', () => {
+    const { execSync } = require('child_process');
+    const tmpDir = path.join(os.tmpdir(), `ucn-diff-samename-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        execSync('git init', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'app.js'), `
+class A { foo() { return 1; } }
+class B { foo() { return 2; } }
+module.exports = { A, B };
+`);
+        execSync('git add -A && git commit -m "init"', { cwd: tmpDir, stdio: 'pipe' });
+
+        // Delete A.foo but keep B.foo
+        fs.writeFileSync(path.join(tmpDir, 'app.js'), `
+class A { }
+class B { foo() { return 2; } }
+module.exports = { A, B };
+`);
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+        const result = index.diffImpact({ base: 'HEAD' });
+
+        assert.strictEqual(result.deletedFunctions.length, 1, 'Exactly one foo should be deleted');
+        assert.strictEqual(result.deletedFunctions[0].name, 'foo');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 96: parseDiff handles filenames with spaces and tab metadata
+it('FIX 96 — diffImpact works with filenames containing spaces', () => {
+    const { execSync } = require('child_process');
+    const tmpDir = path.join(os.tmpdir(), `ucn-diff-spaces-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        execSync('git init', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'a b.js'), 'function spaceFn() { return 1; }\nfunction gone() { return 2; }\n');
+        execSync('git add -A && git commit -m "init"', { cwd: tmpDir, stdio: 'pipe' });
+
+        // Modify spaceFn, delete gone
+        fs.writeFileSync(path.join(tmpDir, 'a b.js'), 'function spaceFn() { return 99; }\n');
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+        const result = index.diffImpact({ base: 'HEAD' });
+
+        assert.ok(result.functions.some(f => f.name === 'spaceFn'), 'spaceFn should be detected as modified');
+        assert.ok(result.deletedFunctions.some(f => f.name === 'gone'), 'gone should be detected as deleted');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 97: git show uses execFileSync (no shell expansion of $ in filenames)
+it('FIX 97 — diffImpact works with $ in filenames', () => {
+    const { execSync } = require('child_process');
+    const tmpDir = path.join(os.tmpdir(), `ucn-diff-dollar-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        execSync('git init', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'package.json'), '{"name":"test"}');
+        fs.writeFileSync(path.join(tmpDir, 'a$HOME.js'), 'function dollarFn() { return 1; }\nfunction gone() { return 2; }\n');
+        execSync('git add -A && git commit -m "init"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'a$HOME.js'), 'function dollarFn() { return 99; }\n');
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+        const result = index.diffImpact({ base: 'HEAD' });
+
+        assert.ok(result.functions.some(f => f.name === 'dollarFn'), 'dollarFn should be detected as modified');
+        assert.ok(result.deletedFunctions.some(f => f.name === 'gone'), 'gone should be detected as deleted');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 98: deleted-function identity handles overloads (same name+class, different signatures)
+it('FIX 98 — diffImpact detects deleted overload while sibling remains', () => {
+    const { execSync } = require('child_process');
+    const tmpDir = path.join(os.tmpdir(), `ucn-diff-overload-${Date.now()}`);
+    fs.mkdirSync(tmpDir, { recursive: true });
+
+    try {
+        execSync('git init', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.email "test@test.com"', { cwd: tmpDir, stdio: 'pipe' });
+        execSync('git config user.name "Test"', { cwd: tmpDir, stdio: 'pipe' });
+
+        fs.writeFileSync(path.join(tmpDir, 'pom.xml'), '<project></project>\n');
+        fs.writeFileSync(path.join(tmpDir, 'A.java'), `
+public class A {
+    public void foo(int x) { System.out.println(x); }
+    public void foo(String s) { System.out.println(s); }
+    public void bar() { foo(1); }
+}
+`);
+        execSync('git add -A && git commit -m "init"', { cwd: tmpDir, stdio: 'pipe' });
+
+        // Delete one overload
+        fs.writeFileSync(path.join(tmpDir, 'A.java'), `
+public class A {
+    public void foo(String s) { System.out.println(s); }
+    public void bar() { foo("hi"); }
+}
+`);
+
+        const { ProjectIndex } = require('../core/project');
+        const index = new ProjectIndex(tmpDir);
+        index.build(null, { quiet: true });
+        const result = index.diffImpact({ base: 'HEAD' });
+
+        assert.strictEqual(result.deletedFunctions.length, 1, 'Exactly one overload should be deleted');
+        assert.strictEqual(result.deletedFunctions[0].name, 'foo');
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});
+
+// FIX 99: parseDiff handles quoted diff headers (special chars in filenames)
+it('FIX 99 — parseDiff handles quoted paths with special characters', () => {
+    const { parseDiff } = require('../core/project');
+
+    // Quoted path with escaped quotes
+    const diffText = `diff --git "a/a\\"b.js" "b/a\\"b.js"
+--- "a/a\\"b.js"
++++ "b/a\\"b.js"
+@@ -1 +1 @@
+`;
+    const changes = parseDiff(diffText, '/tmp/test');
+    assert.strictEqual(changes.length, 1);
+    assert.strictEqual(changes[0].relativePath, 'a"b.js');
+
+    // Quoted deleted file
+    const diffText2 = `diff --git "a/a\\"b.js" "b/a\\"b.js"
+--- "a/a\\"b.js"
++++ /dev/null
+@@ -1,2 +0,0 @@
+`;
+    const changes2 = parseDiff(diffText2, '/tmp/test');
+    assert.strictEqual(changes2.length, 1);
+    assert.strictEqual(changes2[0].isDeleted, true);
+    assert.strictEqual(changes2[0].relativePath, 'a"b.js');
+
+    // Unquoted path still works
+    const diffText3 = `diff --git a/normal.js b/normal.js
+--- a/normal.js
++++ b/normal.js
+@@ -1 +1 @@
+`;
+    const changes3 = parseDiff(diffText3, '/tmp/test');
+    assert.strictEqual(changes3.length, 1);
+    assert.strictEqual(changes3[0].relativePath, 'normal.js');
+
+    // Literal backslash+n in filename must not become a newline (single-pass unescape)
+    // Git represents a\\n.js as a\\\\n.js in quoted headers
+    const diffText4 = `diff --git "a/a\\\\n.js" "b/a\\\\n.js"
+--- "a/a\\\\n.js"
++++ "b/a\\\\n.js"
+@@ -1 +1 @@
+`;
+    const changes4 = parseDiff(diffText4, '/tmp/test');
+    assert.strictEqual(changes4.length, 1);
+    assert.strictEqual(changes4[0].relativePath, 'a\\n.js',
+        'Literal backslash-n in filename must be preserved, not converted to newline');
+});
+
 console.log('UCN v3 Test Suite');
 console.log('Run with: node --test test/parser.test.js');