@getmikk/core 1.5.1 → 1.7.0

package/src/parser/typescript/ts-extractor.ts

@@ -7,11 +7,11 @@ import { hashContent } from '../../hash/file-hasher.js'
  * and extracts functions, classes, imports, exports and call relationships.
  */
 export class TypeScriptExtractor {
-    private sourceFile: ts.SourceFile
+    protected readonly sourceFile: ts.SourceFile
 
     constructor(
-        private filePath: string,
-        private content: string
+        protected readonly filePath: string,
+        protected readonly content: string
     ) {
         this.sourceFile = ts.createSourceFile(
             filePath,
@@ -118,7 +118,7 @@ export class TypeScriptExtractor {
         return generics
     }
 
-    private isVariableFunction(node: ts.VariableStatement): boolean {
+    protected isVariableFunction(node: ts.VariableStatement): boolean {
         for (const decl of node.declarationList.declarations) {
             if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
                 return true
@@ -309,14 +309,14 @@ export class TypeScriptExtractor {
         return routes
     }
 
-    // ─── Private Helpers ──────────────────────────────────────
+    // ─── Protected Helpers ─────────────────────────────────────
 
-    private parseFunctionDeclaration(node: ts.FunctionDeclaration): ParsedFunction {
+    protected parseFunctionDeclaration(node: ts.FunctionDeclaration): ParsedFunction {
         const name = node.name!.text
         const startLine = this.getLineNumber(node.getStart())
         const endLine = this.getLineNumber(node.getEnd())
         const params = this.extractParams(node.parameters)
-        const returnType = node.type ? node.type.getText(this.sourceFile) : 'void'
+        const returnType = normalizeTypeAnnotation(node.type ? node.type.getText(this.sourceFile) : 'void')
         const isAsync = !!node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
         const isGenerator = !!node.asteriskToken
         const typeParameters = this.extractTypeParameters(node.typeParameters)
@@ -344,7 +344,7 @@ export class TypeScriptExtractor {
         }
     }
 
-    private parseVariableFunction(
+    protected parseVariableFunction(
         stmt: ts.VariableStatement,
         decl: ts.VariableDeclaration,
         fn: ts.ArrowFunction | ts.FunctionExpression
@@ -353,7 +353,7 @@ export class TypeScriptExtractor {
         const startLine = this.getLineNumber(stmt.getStart())
         const endLine = this.getLineNumber(stmt.getEnd())
         const params = this.extractParams(fn.parameters)
-        const returnType = fn.type ? fn.type.getText(this.sourceFile) : 'void'
+        const returnType = normalizeTypeAnnotation(fn.type ? fn.type.getText(this.sourceFile) : 'void')
         const isAsync = !!fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
         const isGenerator = ts.isFunctionExpression(fn) && !!fn.asteriskToken
         const typeParameters = this.extractTypeParameters(fn.typeParameters)
@@ -381,7 +381,7 @@ export class TypeScriptExtractor {
         }
     }
 
-    private parseClass(node: ts.ClassDeclaration): ParsedClass {
+    protected parseClass(node: ts.ClassDeclaration): ParsedClass {
         const name = node.name!.text
         const startLine = this.getLineNumber(node.getStart())
         const endLine = this.getLineNumber(node.getEnd())
@@ -420,7 +420,7 @@ export class TypeScriptExtractor {
                 const mStartLine = this.getLineNumber(member.getStart())
                 const mEndLine = this.getLineNumber(member.getEnd())
                 const params = this.extractParams(member.parameters)
-                const returnType = member.type ? member.type.getText(this.sourceFile) : 'void'
+                const returnType = normalizeTypeAnnotation(member.type ? member.type.getText(this.sourceFile) : 'void')
                 const isAsync = !!member.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
                 const isGenerator = !!member.asteriskToken
                 const methodTypeParams = this.extractTypeParameters(member.typeParameters)
@@ -465,7 +465,7 @@ export class TypeScriptExtractor {
         }
     }
 
-    private parseImport(node: ts.ImportDeclaration): ParsedImport | null {
+    protected parseImport(node: ts.ImportDeclaration): ParsedImport | null {
         const source = (node.moduleSpecifier as ts.StringLiteral).text
         const names: string[] = []
         let isDefault = false
@@ -503,7 +503,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract function/method call expressions from a node (including new Foo()) */
-    private extractCalls(node: ts.Node): string[] {
+    protected extractCalls(node: ts.Node): string[] {
         const calls: string[] = []
         const walkCalls = (n: ts.Node) => {
             if (ts.isCallExpression(n)) {
@@ -530,35 +530,57 @@ export class TypeScriptExtractor {
         return [...new Set(calls)] // deduplicate
     }
 
-    /** Extract the purpose from JSDoc comments or preceding single-line comments */
-    private extractPurpose(node: ts.Node): string {
+    /** Extract the purpose from JSDoc comments or preceding single-line comments.
+     *  Falls back to deriving a human-readable sentence from the function name. */
+    protected extractPurpose(node: ts.Node): string {
         const fullText = this.sourceFile.getFullText()
         const commentRanges = ts.getLeadingCommentRanges(fullText, node.getFullStart())
-        if (!commentRanges || commentRanges.length === 0) return ''
-
-        const meaningfulLines: string[] = []
-        for (const range of commentRanges) {
-            const comment = fullText.slice(range.pos, range.end)
-            let clean = ''
-            if (comment.startsWith('/**') || comment.startsWith('/*')) {
-                clean = comment.replace(/[\/\*]/g, '').trim()
-            } else if (comment.startsWith('//')) {
-                clean = comment.replace(/\/\//g, '').trim()
-            }
+        if (commentRanges && commentRanges.length > 0) {
+            const meaningfulLines: string[] = []
+            for (const range of commentRanges) {
+                const comment = fullText.slice(range.pos, range.end)
+                let clean = ''
+                if (comment.startsWith('/**') || comment.startsWith('/*')) {
+                    clean = comment.replace(/[\/\*]/g, '').trim()
+                } else if (comment.startsWith('//')) {
+                    clean = comment.replace(/\/\//g, '').trim()
+                }
 
-            // Skip divider lines (lines with 3+ repeated special characters)
-            if (/^[─\-_=\*]{3,}$/.test(clean)) continue
+                // Skip divider lines (lines with 3+ repeated special characters)
+                if (/^[─\-_=\*]{3,}$/.test(clean)) continue
+
+                if (clean) meaningfulLines.push(clean)
+            }
 
-            if (clean) meaningfulLines.push(clean)
+            // Return the first meaningful line — in JSDoc, the first line is the summary.
+            const fromComment = meaningfulLines.length > 0 ? meaningfulLines[0].split('\n')[0].trim() : ''
+            if (fromComment) return fromComment
         }
 
-        // Return the first meaningful line — in JSDoc, the first line is the summary.
-        // e.g. "Decrypt data using AES-256-GCM" (not a later detail line)
-        return meaningfulLines.length > 0 ? meaningfulLines[0].split('\n')[0].trim() : ''
+        // Fallback: derive a human-readable sentence from the function/identifier name
+        const name = this.getNodeName(node)
+        return name ? derivePurposeFromName(name) : ''
+    }
+
+    /** Get the identifier name from common declaration node types */
+    protected getNodeName(node: ts.Node): string {
+        if (ts.isFunctionDeclaration(node) && node.name) return node.name.text
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            const parent = node.parent
+            if (parent && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+                return parent.name.text
+            }
+        }
+        if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) return node.name.text
+        if (ts.isConstructorDeclaration(node)) return 'constructor'
+        if ((ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node)) && node.name) {
+            return (node as any).name.text
+        }
+        return ''
     }
 
     /** Extract edge cases handled (if statements returning early) */
-    private extractEdgeCases(node: ts.Node): string[] {
+    protected extractEdgeCases(node: ts.Node): string[] {
         const edgeCases: string[] = []
         const walkEdgeCases = (n: ts.Node) => {
             if (ts.isIfStatement(n)) {
@@ -579,7 +601,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract try-catch blocks or explicit throw statements */
-    private extractErrorHandling(node: ts.Node): { line: number, type: 'try-catch' | 'throw', detail: string }[] {
+    protected extractErrorHandling(node: ts.Node): { line: number, type: 'try-catch' | 'throw', detail: string }[] {
         const errors: { line: number, type: 'try-catch' | 'throw', detail: string }[] = []
         const walkErrors = (n: ts.Node) => {
             if (ts.isTryStatement(n)) {
@@ -603,7 +625,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract detailed line block breakdowns */
-    private extractDetailedLines(node: ts.Node): { startLine: number, endLine: number, blockType: string }[] {
+    protected extractDetailedLines(node: ts.Node): { startLine: number, endLine: number, blockType: string }[] {
         const blocks: { startLine: number, endLine: number, blockType: string }[] = []
         const walkBlocks = (n: ts.Node) => {
             if (ts.isIfStatement(n) || ts.isSwitchStatement(n)) {
@@ -628,13 +650,13 @@ export class TypeScriptExtractor {
     }
 
     /** Extract type parameter names from a generic declaration */
-    private extractTypeParameters(typeParams: ts.NodeArray<ts.TypeParameterDeclaration> | undefined): string[] {
+    protected extractTypeParameters(typeParams: ts.NodeArray<ts.TypeParameterDeclaration> | undefined): string[] {
         if (!typeParams || typeParams.length === 0) return []
         return typeParams.map(tp => tp.name.text)
     }
 
     /** Extract decorator names from a class declaration */
-    private extractDecorators(node: ts.ClassDeclaration): string[] {
+    protected extractDecorators(node: ts.ClassDeclaration): string[] {
         const decorators: string[] = []
         const modifiers = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined
         if (modifiers) {
@@ -652,30 +674,59 @@ export class TypeScriptExtractor {
     }
 
     /** Extract parameters from a function's parameter list */
-    private extractParams(params: ts.NodeArray<ts.ParameterDeclaration>): ParsedParam[] {
+    protected extractParams(params: ts.NodeArray<ts.ParameterDeclaration>): ParsedParam[] {
         return params.map((p) => ({
             name: p.name.getText(this.sourceFile),
-            type: p.type ? p.type.getText(this.sourceFile) : 'any',
+            type: normalizeTypeAnnotation(p.type ? p.type.getText(this.sourceFile) : 'any'),
             optional: !!p.questionToken || !!p.initializer,
             defaultValue: p.initializer ? p.initializer.getText(this.sourceFile) : undefined,
         }))
     }
 
     /** Check if a node has the 'export' modifier */
-    private hasExportModifier(node: ts.Node): boolean {
+    protected hasExportModifier(node: ts.Node): boolean {
         const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined
         return !!modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)
     }
 
     /** Get 1-indexed line number from a character position */
-    private getLineNumber(pos: number): number {
+    protected getLineNumber(pos: number): number {
         return this.sourceFile.getLineAndCharacterOfPosition(pos).line + 1
     }
 
     /** Walk the top-level children of a node (non-recursive — callbacks decide depth) */
-    private walkNode(node: ts.Node, callback: (node: ts.Node) => void): void {
+    protected walkNode(node: ts.Node, callback: (node: ts.Node) => void): void {
         ts.forEachChild(node, (child) => {
             callback(child)
         })
     }
 }
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/**
+ * Derive a human-readable purpose sentence from a camelCase/PascalCase identifier.
+ * Examples:
+ *   validateJwtToken   → "Validate jwt token"
+ *   buildGraphFromLock → "Build graph from lock"
+ *   UserRepository     → "User repository"
+ *   parseFiles         → "Parse files"
+ */
+function normalizeTypeAnnotation(type: string): string {
+    return type.replace(/\s*\n\s*/g, ' ').replace(/\s{2,}/g, ' ').trim()
+}
+
+function derivePurposeFromName(name: string): string {
+    if (!name || name === 'constructor') return ''
+    // Split on camelCase/PascalCase boundaries and underscores
+    const words = name
+        .replace(/_+/g, ' ')
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .toLowerCase()
+        .split(/\s+/)
+        .filter(Boolean)
+    if (words.length === 0) return ''
+    words[0] = words[0].charAt(0).toUpperCase() + words[0].slice(1)
+    return words.join(' ')
+}

package/src/parser/typescript/ts-parser.ts

@@ -1,3 +1,5 @@
+import * as path from 'node:path'
+import * as fs from 'node:fs'
 import { BaseParser } from '../base-parser.js'
 import { TypeScriptExtractor } from './ts-extractor.js'
 import { TypeScriptResolver } from './ts-resolver.js'
@@ -54,7 +56,8 @@ export class TypeScriptParser extends BaseParser {
 
     /** Resolve all import paths in parsed files to absolute project paths */
     resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
-        const resolver = new TypeScriptResolver(projectRoot)
+        const tsConfigPaths = loadTsConfigPaths(projectRoot)
+        const resolver = new TypeScriptResolver(projectRoot, tsConfigPaths)
         const allFilePaths = files.map(f => f.path)
         return files.map(file => ({
             ...file,
@@ -66,3 +69,119 @@ export class TypeScriptParser extends BaseParser {
         return ['.ts', '.tsx']
     }
 }
+
+/**
+ * Read compilerOptions.paths from tsconfig.json in projectRoot.
+ * Recursively follows "extends" chains (e.g. extends ./tsconfig.base.json,
+ * extends @tsconfig/node-lts/tsconfig.json) and merges paths.
+ * 
+ * Handles:
+ *  - extends with relative paths (./tsconfig.base.json)
+ *  - extends with node_modules packages (@tsconfig/node-lts)
+ *  - baseUrl prefix so aliases like "@/*" → ["src/*"] resolve correctly
+ *  - JSON5-style comments (line and block comments)
+ */
+function loadTsConfigPaths(projectRoot: string): Record<string, string[]> {
+    const candidates = ['tsconfig.json', 'tsconfig.base.json']
+    for (const name of candidates) {
+        const tsConfigPath = path.join(projectRoot, name)
+        try {
+            const merged = loadTsConfigWithExtends(tsConfigPath, new Set())
+            const options = merged.compilerOptions ?? {}
+            const rawPaths: Record<string, string[]> = options.paths ?? {}
+            if (Object.keys(rawPaths).length === 0) continue
+
+            const baseUrl: string = options.baseUrl ?? '.'
+            const resolved: Record<string, string[]> = {}
+            for (const [alias, targets] of Object.entries(rawPaths)) {
+                resolved[alias] = (targets as string[]).map(t =>
+                    t.startsWith('.') ? path.posix.join(baseUrl, t) : t
+                )
+            }
+            return resolved
+        } catch { /* tsconfig not found or invalid — continue */ }
+    }
+    return {}
+}
+
+/**
+ * Recursively load a tsconfig, following the "extends" chain.
+ * Merges compilerOptions from parent → child (child wins on conflict).
+ * Prevents infinite loops via a visited set.
+ */
+function loadTsConfigWithExtends(configPath: string, visited: Set<string>): any {
+    const resolved = path.resolve(configPath)
+    if (visited.has(resolved)) return {}
+    visited.add(resolved)
+
+    let raw: string
+    try {
+        raw = fs.readFileSync(resolved, 'utf-8')
+    } catch {
+        return {}
+    }
+
+    // Strip JSON5 comments
+    const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')
+    let config: any
+    try {
+        config = JSON.parse(stripped)
+    } catch {
+        try { config = JSON.parse(raw) } catch { return {} }
+    }
+
+    if (!config.extends) return config
+
+    // Resolve the parent config path
+    const extendsValue = config.extends
+    let parentPath: string
+
+    if (extendsValue.startsWith('.')) {
+        // Relative path: ./tsconfig.base.json or ../tsconfig.json
+        parentPath = path.resolve(path.dirname(resolved), extendsValue)
+        // Add .json if missing
+        if (!parentPath.endsWith('.json')) parentPath += '.json'
+    } else {
+        // Node module: @tsconfig/node-lts or @tsconfig/node-lts/tsconfig.json
+        try {
+            // Try resolving as a node module from projectRoot
+            const projectRoot = path.dirname(resolved)
+            const modulePath = path.join(projectRoot, 'node_modules', extendsValue)
+            if (fs.existsSync(modulePath + '.json')) {
+                parentPath = modulePath + '.json'
+            } else if (fs.existsSync(path.join(modulePath, 'tsconfig.json'))) {
+                parentPath = path.join(modulePath, 'tsconfig.json')
+            } else if (fs.existsSync(modulePath)) {
+                parentPath = modulePath
+            } else {
+                // Can't resolve — skip extends
+                delete config.extends
+                return config
+            }
+        } catch {
+            delete config.extends
+            return config
+        }
+    }
+
+    // Load parent recursively
+    const parent = loadTsConfigWithExtends(parentPath, visited)
+
+    // Merge: parent compilerOptions → child compilerOptions (child wins)
+    const merged = { ...config }
+    delete merged.extends
+    merged.compilerOptions = {
+        ...(parent.compilerOptions ?? {}),
+        ...(config.compilerOptions ?? {}),
+    }
+
+    // Merge paths specifically (child paths override parent paths for same alias)
+    if (parent.compilerOptions?.paths || config.compilerOptions?.paths) {
+        merged.compilerOptions.paths = {
+            ...(parent.compilerOptions?.paths ?? {}),
+            ...(config.compilerOptions?.paths ?? {}),
+        }
+    }
+
+    return merged
+}

package/tests/adr-manager.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'bun:test'
+import { AdrManager } from '../src/contract/adr-manager'
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+
+describe('AdrManager', () => {
+    const TEMP_DIR = path.join(process.cwd(), '.test-temp')
+    const CONTRACT_PATH = path.join(TEMP_DIR, 'mikk.json')
+
+    beforeAll(async () => {
+        await fs.mkdir(TEMP_DIR, { recursive: true })
+    })
+
+    afterAll(async () => {
+        await fs.rm(TEMP_DIR, { recursive: true, force: true })
+    })
+
+    beforeEach(async () => {
+        // Create a fresh mikk.json for each test
+        const initialContract = {
+            version: '1.0.0',
+            project: { name: 'test', description: 'test', language: 'ts', entryPoints: [] },
+            declared: {
+                modules: [],
+                decisions: [
+                    { id: 'ADR-1', title: 'First ADR', reason: 'Because', date: '2024-01-01' }
+                ]
+            },
+            overwrite: { mode: 'never' as const }
+        }
+        await fs.writeFile(CONTRACT_PATH, JSON.stringify(initialContract))
+    })
+
+    it('lists decisions', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        const decisions = await manager.list()
+        expect(decisions).toHaveLength(1)
+        expect(decisions[0].id).toBe('ADR-1')
+    })
+
+    it('gets a decision by id', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        const decision = await manager.get('ADR-1')
+        expect(decision?.title).toBe('First ADR')
+
+        const missing = await manager.get('NOT-FOUND')
+        expect(missing).toBeNull()
+    })
+
+    it('adds a new decision', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        await manager.add({
+            id: 'ADR-2',
+            title: 'Second ADR',
+            reason: 'Why not',
+            date: '2024-01-02'
+        })
+
+        const decisions = await manager.list()
+        expect(decisions).toHaveLength(2)
+        expect(decisions[1].id).toBe('ADR-2')
+    })
+
+    it('fails to add if id already exists', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        await expect(manager.add({
+            id: 'ADR-1',
+            title: 'Duplicate',
+            reason: 'Will fail',
+            date: '2024-01-03'
+        })).rejects.toThrow(/already exists/)
+    })
+
+    it('updates an existing decision', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        await manager.update('ADR-1', { title: 'Updated Title' })
+
+        const decision = await manager.get('ADR-1')
+        expect(decision?.title).toBe('Updated Title')
+        expect(decision?.reason).toBe('Because') // Preserved
+        expect(decision?.id).toBe('ADR-1')
+    })
+
+    it('fails to update missing decision', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        await expect(manager.update('ADR-99', { title: 'Nope' })).rejects.toThrow(/not found/)
+    })
+
+    it('removes a decision', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        const success = await manager.remove('ADR-1')
+        expect(success).toBe(true)
+
+        const decisions = await manager.list()
+        expect(decisions).toHaveLength(0)
+    })
+})

package/tests/contract.test.ts

@@ -76,7 +76,7 @@ describe('LockCompiler', () => {
         const graph = new GraphBuilder().build(files)
         const lock = compiler.compile(graph, contract, files)
 
-        expect(lock.version).toBe('1.0.0')
+        expect(lock.version).toBe('1.7.0')
         expect(lock.syncState.status).toBe('clean')
         expect(Object.keys(lock.functions).length).toBeGreaterThan(0)
         expect(Object.keys(lock.modules).length).toBeGreaterThanOrEqual(1)

package/tests/dead-code.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect } from 'bun:test'
+import { DeadCodeDetector } from '../src/graph/dead-code-detector'
+import { buildTestGraph, mockFunction } from './helpers'
+import { GraphBuilder } from '../src/graph/graph-builder'
+import type { MikkLock } from '../src/contract/schema'
+
+/** Helper to generate a dummy lock file from graph nodes for the detector */
+function generateDummyLock(graphNodes: Map<string, any>): MikkLock {
+    const lock: MikkLock = {
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        generatorVersion: '1.0.0',
+        projectRoot: '/test',
+        syncState: {
+            status: 'clean',
+            lastSyncAt: new Date().toISOString(),
+            lockHash: 'x',
+            contractHash: 'x',
+        },
+        graph: {
+            nodes: 0,
+            edges: 0,
+            rootHash: 'x',
+        },
+        functions: {},
+        classes: {},
+        files: {},
+        modules: {},
+        routes: [],
+    }
+
+    for (const [id, node] of graphNodes.entries()) {
+        if (node.type === 'function') {
+            const name = node.label
+            const file = node.file
+            // We need to populate `calledBy` for transitive liveness checks
+
+            lock.functions[id] = {
+                id,
+                name,
+                file,
+                moduleId: node.moduleId ?? 'unknown',
+                startLine: 1, endLine: 10, hash: 'x',
+                calls: [],
+                calledBy: [],
+                isExported: node.metadata?.isExported ?? false,
+                isAsync: false,
+                params: [],
+            }
+        }
+    }
+    return lock
+}
+
+describe('DeadCodeDetector', () => {
+
+    it('detects uncalled functions', () => {
+        // A calls B. C is isolated.
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'nothing'],
+            ['C', 'nothing']
+        ])
+
+        const lock = generateDummyLock(graph.nodes)
+
+        // Add calledBy relationships since GraphBuilder test helper doesn't do reverse 
+        // lookups for the lock structure (it only does it for the graph)
+        Object.values(lock.functions).forEach(fn => {
+            const inEdges = graph.inEdges.get(fn.id) ?? []
+            fn.calledBy = inEdges.filter(e => e.type === 'calls').map(e => e.source)
+        })
+
+        const detector = new DeadCodeDetector(graph, lock)
+        const result = detector.detect()
+
+        expect(result.deadFunctions.map(f => f.name)).toContain('C')
+        expect(result.deadFunctions.map(f => f.name)).toContain('A') // A has no callers, so it is dead code
+        expect(result.deadFunctions.map(f => f.name)).not.toContain('B') // B has a caller
+    })
+
+    it('exempts exported functions', () => {
+        const graph = buildTestGraph([
+            ['D', 'nothing']
+        ])
+        graph.nodes.get('fn:src/D.ts:D')!.metadata!.isExported = true
+
+        const lock = generateDummyLock(graph.nodes)
+
+        const detector = new DeadCodeDetector(graph, lock)
+        const result = detector.detect()
+
+        expect(result.deadFunctions).toHaveLength(0) // D is exported
+    })
+
+    it('exempts entry point name patterns', () => {
+        const graph = buildTestGraph([
+            ['main', 'nothing'],
+            ['loginHandler', 'nothing'],
+            ['useAuth', 'nothing'] // React hook
+        ])
+
+        const lock = generateDummyLock(graph.nodes)
+
+        const detector = new DeadCodeDetector(graph, lock)
+        const result = detector.detect()
+
+        expect(result.deadFunctions).toHaveLength(0) // All match exempt patterns
+    })
+
+    it('exempts functions called by exported functions in the same file', () => {
+        const graph = buildTestGraph([
+            ['ExportedFn', 'InternalHelper'],
+            ['InternalHelper', 'nothing']
+        ])
+
+        // Both in same file by default from buildTestGraph
+        graph.nodes.get('fn:src/ExportedFn.ts:ExportedFn')!.metadata!.isExported = true
+
+        // In the lock, we must place them in the SAME file manually because buildTestGraph 
+        // puts them in separate files based on name
+        const lock = generateDummyLock(graph.nodes)
+        lock.functions['fn:src/ExportedFn.ts:ExportedFn'].file = 'src/shared.ts'
+        lock.functions['fn:src/InternalHelper.ts:InternalHelper'].file = 'src/shared.ts'
+
+        // Set up the calledBy relation
+        lock.functions['fn:src/InternalHelper.ts:InternalHelper'].calledBy = ['fn:src/ExportedFn.ts:ExportedFn']
+
+        const detector = new DeadCodeDetector(graph, lock)
+        const result = detector.detect()
+
+        expect(result.deadFunctions).toHaveLength(0) // InternalHelper is called by exported fn in same file
+    })
+})