ucn 3.7.1 → 3.7.3

package/README.md

@@ -1,12 +1,12 @@
 # UCN - Universal Code Navigator
 
-UCN is designed to work with large files and codebases, helping AI agents ingest exactly the data they need. Its surgical output discourages agents from cutting corners, and without UCN, agents working with large codebases tend to skip parts of the code structure, assuming they have "enough data."
+UCN gives AI agents call-graph-level understanding of code. Instead of reading entire files, agents ask structural questions like: "who calls this function", "what breaks if I change it", "what's unused", and get precise, AST-verified answers. UCN parses JS/TS, Python, Go, Rust, Java, and HTML inline scripts with tree-sitter, then exposes 28 navigation commands as a CLI tool, MCP server, or agent skill.
 
-Supported languages: JS/TS, Python, Go, Rust, Java. Also parses HTML files (inline scripts and event handlers).
+Designed for large codebases where agents waste context on reading large files. UCN's surgical output means agents spend tokens on reasoning, not on ingesting thousands of lines to find three callers, discourages agents from cutting corners, as without UCN, agents working with large codebases tend to skip parts of the code structure, assuming they have "enough data".
 
 ---
 
-## Three Ways to Use UCN
+## Three Ways to it: ucn mcp, ucn skill, ucn cli 
 
 ```
   ┌──────────────────────────────────────────────────────────────────────┐
@@ -25,9 +25,9 @@ Supported languages: JS/TS, Python, Go, Rust, Java. Also parses HTML files (inli
 
 ---
 
-## The Problem
+## How agents understand code today
 
-Typically, AI agents working with code do something like this:
+AI agents working with code typically do this:
 
 ```
   grep "functionName"      →  47 matches, 23 files
@@ -53,28 +53,7 @@ Typically, AI agents working with code do something like this:
 
 ---
 
-## The Solution
-
-UCN parses the code with tree-sitter and offers semantic navigation tools.
-
-Instead of reading entire files, ask precise questions:
-
-```
-  ┌──────────────────────────────────────┐
-  │                                      │
-  │   "Who calls this function?"         │──→  list of actual callers
-  │                                      │
-  │   "What breaks if I change this?"    │──→  every call site, with arguments
-  │                                      │
-  │   "Show me this function and         │──→  source + dependencies inline
-  │    everything it depends on"         │
-  │                                      │
-  └──────────────────────────────────────┘
-```
-
----
-
-## How It Works
+## How UCN works: tree-sitter, locally
 
 ```
   ┌──────────────────────────────────────────────┐
@@ -93,17 +72,17 @@ Instead of reading entire files, ask precise questions:
                           │
                     tree-sitter AST
                           │
-      ┌───────────────────┴─────────────────┐
-      │          Supported Languages        │
-      │ JS/TS, Python, Go, Rust, Java, HTML │
-      └─────────────────────────────────────┘
+        ┌─────────────────┴───────────────────┐
+        │          Supported Languages        │
+        │ JS/TS, Python, Go, Rust, Java, HTML │
+        └─────────────────────────────────────┘
 ```
 
 No cloud. No API keys. Parses locally, stays local.
 
 ---
 
-## Before & After
+## Before and after UCN
 
 ```
   WITHOUT UCN                              WITH UCN
@@ -141,7 +120,7 @@ No cloud. No API keys. Parses locally, stays local.
   Context spent on file contents           Context spent on reasoning
 ```
 
-After editing code:
+After editing code, before committing:
 
 ```
   WITHOUT UCN                              WITH UCN
@@ -170,7 +149,7 @@ After editing code:
 
 ---
 
-## grep vs AST
+## Text search vs AST
 
 ```
   Code: processOrder(items, user)
@@ -206,11 +185,11 @@ After editing code:
   └─────────────────────────────────────────────────────────────────┘
 ```
 
-The tradeoff: grep works on any language and any text. UCN only works on supported languages but gives structural understanding within those.
+The tradeoff: text search works on any language and any text. UCN only works on 5 languages + HTML, but gives structural understanding within those.
 
 ---
 
-## See It in Action
+## UCN commands in action
 
 Extract a function from a large file without reading it:
 
@@ -461,7 +440,7 @@ ucn --interactive                   # Multiple queries, index stays in memory
 
 ---
 
-## Workflows
+## UCN workflows
 
 Investigating a bug:
 ```bash
@@ -492,7 +471,7 @@ ucn toc                                   # Project overview
 
 ---
 
-## Limitations (and how we handle them)
+## Limitations
 
 ```
   ┌──────────────────────────┬──────────────────────────────────────────┐
@@ -500,8 +479,9 @@ ucn toc                                   # Project overview
   ├──────────────────────────┼──────────────────────────────────────────┤
   │                          │                                          │
   │  5 languages + HTML      │  JS/TS, Python, Go, Rust, Java.          │
-  │  (no C, Ruby, PHP, etc.) │  Agents fall back to grep for the rest.  │
-  │                          │  UCN complements, doesn't replace.       │
+  │  (no C, Ruby, PHP, etc.) │  Agents fall back to text search for     │
+  │                          │  the rest. UCN complements, doesn't      │
+  │                          │  replace.                                │
   │                          │                                          │
   ├──────────────────────────┼──────────────────────────────────────────┤
   │                          │                                          │
@@ -535,7 +515,7 @@ ucn toc                                   # Project overview
 
 ---
 
-## All 28 Tools
+## All 28 UCN tools
 
 ```
   UNDERSTAND                          MODIFY SAFELY

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,7 +1,7 @@
 {
   "name": "ucn",
-  "version": "3.7.1",
-  "description": "Universal Code Navigator — function relationships, call trees, and impact analysis across large codebases without reading entire files.",
+  "version": "3.7.3",
+  "description": "Universal Code Navigator — AST-based call graph analysis for AI agents. Find callers, trace impact, detect dead code across JS/TS, Python, Go, Rust, Java, and HTML. CLI, MCP server, and agent skill.",
   "main": "index.js",
   "bin": {
     "ucn": "cli/index.js",
@@ -11,19 +11,31 @@
     "test": "node --test test/parser.test.js test/accuracy.test.js test/systematic-test.js test/mcp-edge-cases.js"
   },
   "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
     "code-navigation",
+    "code-analysis",
+    "static-analysis",
+    "call-graph",
+    "callers",
+    "impact-analysis",
+    "dead-code",
+    "deadcode",
     "ast",
-    "parser",
     "tree-sitter",
+    "parser",
+    "skill",
+    "agent-skill",
+    "cli",
+    "ai-agent",
     "javascript",
     "typescript",
     "python",
     "go",
     "rust",
     "java",
-    "html",
-    "ai",
-    "agent"
+    "html"
   ],
   "author": "Constantin-Mihail Leoca (https://github.com/mleoca)",
   "repository": {

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');