circle-ir-ai 1.1.0

package/dist/dead-code/detector.js

@@ -0,0 +1,1003 @@
+/**
+ * Dead Code Detector
+ *
+ * Detects unreachable code in a codebase by:
+ * 1. Identifying entry points (main methods, exports, HTTP handlers, etc.)
+ * 2. Building a call graph from those entry points
+ * 3. Finding functions/classes that are never reached
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { initAnalyzer, isAnalyzerInitialized, analyze, } from 'circle-ir';
+// ============================================================================
+// Entry Point Detection Patterns
+// ============================================================================
+/** Method names that indicate entry points */
+const ENTRY_POINT_METHODS = new Set([
+    // Java main
+    'main',
+    // Servlet lifecycle
+    'init', 'destroy', 'service',
+    'doGet', 'doPost', 'doPut', 'doDelete', 'doHead', 'doOptions', 'doTrace',
+    // Spring lifecycle
+    'afterPropertiesSet', 'postConstruct', 'preDestroy',
+    // JUnit test methods (if includeTests is true)
+    'setUp', 'tearDown', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll',
+]);
+/** Annotations that indicate entry points */
+const ENTRY_POINT_ANNOTATIONS = new Set([
+    // Spring Web
+    'GetMapping', 'PostMapping', 'PutMapping', 'DeleteMapping', 'PatchMapping',
+    'RequestMapping', 'RestController', 'Controller',
+    // Spring lifecycle
+    'PostConstruct', 'PreDestroy', 'Bean', 'EventListener', 'Scheduled',
+    // JAX-RS
+    'GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS', 'PATCH', 'Path',
+    // JUnit (if includeTests is true)
+    'Test', 'BeforeEach', 'AfterEach', 'BeforeAll', 'AfterAll', 'Before', 'After',
+    // Servlet
+    'WebServlet', 'WebFilter', 'WebListener',
+    // EJB
+    'Stateless', 'Stateful', 'Singleton', 'MessageDriven',
+]);
+/** Class-level annotations that make all public methods entry points */
+const CLASS_ENTRY_POINT_ANNOTATIONS = new Set([
+    'RestController', 'Controller', 'Service', 'Component', 'Repository',
+    'Stateless', 'Stateful', 'Singleton',
+    'WebServlet', 'WebFilter',
+]);
+/** HTTP verbs used with framework receivers (JS/TS) */
+const HTTP_VERB_METHODS = new Set([
+    'get', 'post', 'put', 'delete', 'patch', 'head', 'options', 'use', 'all', 'route',
+]);
+/** Event emitter methods that take callback entry points (JS/TS) */
+const EVENT_LISTENER_METHODS = new Set([
+    'on', 'once', 'addEventListener', 'addListener',
+]);
+// ============================================================================
+// Dead Code Detector Implementation
+// ============================================================================
+export class DeadCodeDetector {
+    verbose = false;
+    onProgress;
+    methodMap = new Map();
+    callGraph = new Map();
+    reverseCallGraph = new Map();
+    entryPoints = new Set();
+    reachable = new Set();
+    /**
+     * Detect dead code in a codebase.
+     */
+    async detect(options) {
+        const startTime = Date.now();
+        this.verbose = options.verbose ?? false;
+        this.onProgress = options.onProgress;
+        // Reset state
+        this.methodMap.clear();
+        this.callGraph.clear();
+        this.reverseCallGraph.clear();
+        this.entryPoints.clear();
+        this.reachable.clear();
+        // Ensure analyzer is initialized
+        if (!isAnalyzerInitialized()) {
+            await initAnalyzer();
+        }
+        // Phase 1: Discover files
+        this.reportProgress({ phase: 'discover', filesProcessed: 0, totalFiles: 0 });
+        const files = this.discoverFiles(options);
+        // Phase 2: Analyze files
+        this.reportProgress({ phase: 'analyze', filesProcessed: 0, totalFiles: files.length });
+        const fileResults = await this.analyzeFiles(files, options);
+        // Phase 3: Build call graph
+        this.reportProgress({ phase: 'build-graph', filesProcessed: files.length, totalFiles: files.length });
+        this.buildCallGraph(fileResults, options);
+        // Phase 4: Detect dead code
+        this.reportProgress({ phase: 'detect', filesProcessed: files.length, totalFiles: files.length });
+        const deadCode = this.detectDeadCode(fileResults, options);
+        // Generate result
+        const result = this.generateResult(fileResults, deadCode, options, startTime);
+        return result;
+    }
+    /**
+     * Discover files to analyze.
+     */
+    discoverFiles(options) {
+        const { target, includeTests = false, includePatterns, excludePatterns } = options;
+        const files = [];
+        const defaultExcludes = [
+            '**/node_modules/**',
+            '**/vendor/**',
+            '**/target/**',
+            '**/build/**',
+            '**/dist/**',
+            '**/.git/**',
+            '**/.*',
+        ];
+        if (!includeTests) {
+            defaultExcludes.push('**/test/**', '**/tests/**', '**/__tests__/**', '**/*.test.*', '**/*.spec.*', '**/*Test.java', '**/*Tests.java', '**/src/test/**');
+        }
+        const excludes = [...defaultExcludes, ...(excludePatterns || [])];
+        const languageExtensions = {
+            java: ['.java'],
+            c: ['.c', '.h'],
+            cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hxx'],
+            javascript: ['.js', '.jsx', '.mjs', '.cjs'],
+            typescript: ['.ts', '.tsx', '.mts', '.cts'],
+            python: ['.py'],
+            rust: ['.rs'],
+        };
+        const extensions = options.languages
+            ? options.languages.flatMap(l => languageExtensions[l] || [])
+            : Object.values(languageExtensions).flat();
+        // Handle single file
+        if (fs.statSync(target).isFile()) {
+            return [path.resolve(target)];
+        }
+        // Walk directory
+        const walk = (dir, depth = 0) => {
+            if (depth > 30)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(target, fullPath);
+                    if (this.matchesPattern(relativePath, excludes)) {
+                        continue;
+                    }
+                    if (entry.isDirectory()) {
+                        walk(fullPath, depth + 1);
+                    }
+                    else if (entry.isFile()) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!extensions.includes(ext))
+                            continue;
+                        if (includePatterns && includePatterns.length > 0) {
+                            if (!this.matchesPattern(relativePath, includePatterns)) {
+                                continue;
+                            }
+                        }
+                        files.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Skip unreadable directories
+            }
+        };
+        walk(path.resolve(target));
+        if (this.verbose) {
+            console.log(`Discovered ${files.length} files to analyze`);
+        }
+        return files;
+    }
+    /**
+     * Check if path matches glob patterns.
+     */
+    matchesPattern(filePath, patterns) {
+        const normalized = filePath.replace(/\\/g, '/');
+        for (const pattern of patterns) {
+            // Convert glob pattern to regex:
+            // 1. Escape regex special chars except glob chars (*, ?, [, ])
+            // 2. Convert glob patterns to regex equivalents
+            const regex = pattern
+                .replace(/\*\*/g, '{{DOUBLESTAR}}')
+                .replace(/\*/g, '{{STAR}}')
+                .replace(/\?/g, '{{QUESTION}}')
+                .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars
+                .replace(/{{DOUBLESTAR}}/g, '.*')
+                .replace(/{{STAR}}/g, '[^/]*')
+                .replace(/{{QUESTION}}/g, '.');
+            if (new RegExp(`^${regex}$`).test(normalized)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Analyze files and extract methods.
+     */
+    async analyzeFiles(files, options) {
+        const results = [];
+        let processed = 0;
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(file, 'utf-8');
+                const language = this.detectLanguage(file);
+                const ir = await analyze(content, path.basename(file), language);
+                results.push({
+                    file: path.relative(options.target, file),
+                    ir,
+                    loc: ir.meta.loc,
+                });
+                processed++;
+                this.reportProgress({
+                    phase: 'analyze',
+                    filesProcessed: processed,
+                    totalFiles: files.length,
+                    message: path.basename(file),
+                });
+            }
+            catch (error) {
+                if (this.verbose) {
+                    console.error(`Error analyzing ${file}: ${error}`);
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Build call graph from analyzed files.
+     */
+    buildCallGraph(files, options) {
+        const { additionalEntryPoints = [], publicMethodsAsEntryPoints = false, includeTests = false } = options;
+        const additionalEntryPointSet = new Set(additionalEntryPoints);
+        // First pass: register all methods
+        for (const { file, ir } of files) {
+            const language = ir.meta.language;
+            for (const type of ir.types) {
+                if (type.kind !== 'class' && type.kind !== 'interface')
+                    continue;
+                const classAnnotations = type.annotations || [];
+                const isEntryPointClass = classAnnotations.some(a => CLASS_ENTRY_POINT_ANNOTATIONS.has(a));
+                for (const method of type.methods) {
+                    const methodId = this.getMethodId(file, type.name, method.name);
+                    this.methodMap.set(methodId, {
+                        id: methodId,
+                        file,
+                        className: type.name,
+                        methodName: method.name,
+                        startLine: method.start_line,
+                        endLine: method.end_line,
+                        lineCount: method.end_line - method.start_line + 1,
+                        modifiers: method.modifiers,
+                        annotations: method.annotations || [],
+                        language,
+                    });
+                    this.callGraph.set(methodId, new Set());
+                    this.reverseCallGraph.set(methodId, new Set());
+                    // Check if this is an entry point
+                    if (this.isEntryPoint(type, method, isEntryPointClass, additionalEntryPointSet, publicMethodsAsEntryPoints, includeTests, language)) {
+                        this.entryPoints.add(methodId);
+                    }
+                }
+                // Track constructors (skip <module> in JS/TS/Python — it's not a real class)
+                if (type.kind === 'class' && !(this.isModuleBasedLanguage(language) && type.name === '<module>')) {
+                    const constructorId = this.getMethodId(file, type.name, '<init>');
+                    this.methodMap.set(constructorId, {
+                        id: constructorId,
+                        file,
+                        className: type.name,
+                        methodName: '<init>',
+                        startLine: type.start_line,
+                        endLine: type.end_line,
+                        lineCount: type.end_line - type.start_line + 1,
+                        modifiers: [],
+                        annotations: [],
+                        language,
+                    });
+                    this.callGraph.set(constructorId, new Set());
+                    this.reverseCallGraph.set(constructorId, new Set());
+                    // Constructors are entry points if class is instantiable from outside
+                    if (isEntryPointClass || publicMethodsAsEntryPoints) {
+                        this.entryPoints.add(constructorId);
+                    }
+                }
+            }
+        }
+        // Second pass: build call edges
+        for (const { file, ir } of files) {
+            for (const call of ir.calls) {
+                // Find the containing method
+                const containingMethod = this.findContainingMethod(file, ir, call.location.line);
+                if (!containingMethod)
+                    continue;
+                // Resolve the target method
+                const targetMethods = this.resolveCallTarget(call, ir.types, files);
+                for (const targetId of targetMethods) {
+                    // Add edge from caller to callee
+                    this.callGraph.get(containingMethod)?.add(targetId);
+                    // Add reverse edge
+                    this.reverseCallGraph.get(targetId)?.add(containingMethod);
+                }
+            }
+        }
+        // Third pass: JS/TS/Python module-level entry points
+        for (const { file, ir } of files) {
+            const language = ir.meta.language;
+            if (!this.isModuleBasedLanguage(language))
+                continue;
+            // Register <module-init> as synthetic entry point for top-level code
+            const moduleType = ir.types.find(t => t.name === '<module>');
+            if (!moduleType)
+                continue;
+            const moduleInitId = this.getMethodId(file, '<module>', '<module-init>');
+            this.methodMap.set(moduleInitId, {
+                id: moduleInitId,
+                file,
+                className: '<module>',
+                methodName: '<module-init>',
+                startLine: 1,
+                endLine: moduleType.end_line,
+                lineCount: 0, // synthetic, don't count LOC
+                modifiers: [],
+                annotations: [],
+                language,
+            });
+            this.callGraph.set(moduleInitId, new Set());
+            this.reverseCallGraph.set(moduleInitId, new Set());
+            this.entryPoints.add(moduleInitId);
+            // Assign orphan calls (top-level + anonymous callbacks) to <module-init>
+            for (const call of ir.calls) {
+                const containingMethod = this.findContainingMethod(file, ir, call.location.line);
+                if (containingMethod === null) {
+                    const targetMethods = this.resolveCallTarget(call, ir.types, files);
+                    for (const targetId of targetMethods) {
+                        this.callGraph.get(moduleInitId)?.add(targetId);
+                        this.reverseCallGraph.get(targetId)?.add(moduleInitId);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Check if a method is an entry point.
+     */
+    isEntryPoint(type, method, isEntryPointClass, additionalEntryPoints, publicMethodsAsEntryPoints, includeTests, language) {
+        // JS/TS: entry points are determined by <module-init> reachability,
+        // NOT by method-level patterns. The third pass in buildCallGraph handles this.
+        // Here we only mark explicit framework patterns.
+        if (this.isJSTS(language)) {
+            // HTTP handler synthetic methods (get_handler, post_handler, etc.)
+            if (method.name.endsWith('_handler')) {
+                const verb = method.name.replace('_handler', '');
+                if (HTTP_VERB_METHODS.has(verb) || EVENT_LISTENER_METHODS.has(verb)) {
+                    return true;
+                }
+            }
+            // Additional user-specified entry points
+            if (additionalEntryPoints.has(method.name)) {
+                return true;
+            }
+            // Don't auto-mark all <module> functions — let call graph decide
+            return false;
+        }
+        // Python: similar to JS/TS, module-level code is the entry point.
+        // Here we mark Flask/Django route handlers and other framework patterns.
+        if (this.isPython(language)) {
+            const annotations = method.annotations || [];
+            // Flask/Django route decorators
+            if (annotations.some(a => a.startsWith('route') || a.startsWith('app.route') ||
+                a === 'get' || a === 'post' || a === 'put' || a === 'delete' || a === 'patch')) {
+                return true;
+            }
+            // Django class-based views
+            if (annotations.includes('api_view') || annotations.includes('action')) {
+                return true;
+            }
+            // pytest/unittest markers
+            if (includeTests && annotations.some(a => a.startsWith('pytest') || a === 'test')) {
+                return true;
+            }
+            // Additional user-specified entry points
+            if (additionalEntryPoints.has(method.name)) {
+                return true;
+            }
+            // Don't auto-mark all <module> functions — let call graph decide
+            return false;
+        }
+        // Rust: entry points include main, async runtime entry points, test functions, and pub fns
+        if (this.isRust(language)) {
+            const annotations = method.annotations || [];
+            // main function is always an entry point
+            if (method.name === 'main') {
+                return true;
+            }
+            // Async runtime entry points
+            if (annotations.some(a => a.includes('tokio::main') || a.includes('tokio::test') ||
+                a.includes('actix_web::main') || a.includes('actix_rt::main') ||
+                a.includes('async_std::main') || a.includes('rocket::launch') ||
+                a === 'main' || a === 'launch')) {
+                return true;
+            }
+            // Test functions
+            if (includeTests && (annotations.includes('test') ||
+                annotations.includes('tokio::test') ||
+                annotations.includes('async_std::test') ||
+                method.name.startsWith('test_'))) {
+                return true;
+            }
+            // Actix-web route handlers
+            if (annotations.some(a => a.includes('get') || a.includes('post') || a.includes('put') ||
+                a.includes('delete') || a.includes('patch') || a.includes('route'))) {
+                return true;
+            }
+            // Additional user-specified entry points
+            if (additionalEntryPoints.has(method.name)) {
+                return true;
+            }
+            // Public functions in lib.rs are potential entry points (library API)
+            if (method.modifiers.includes('pub') && publicMethodsAsEntryPoints) {
+                return true;
+            }
+            return false;
+        }
+        // Java logic
+        const methodAnnotations = method.annotations || [];
+        // Check explicit entry point methods
+        if (ENTRY_POINT_METHODS.has(method.name)) {
+            // For main, verify signature
+            if (method.name === 'main') {
+                const isPublic = method.modifiers.includes('public');
+                const isStatic = method.modifiers.includes('static');
+                if (isPublic && isStatic) {
+                    return true;
+                }
+            }
+            else if (!includeTests && ['setUp', 'tearDown', 'beforeEach', 'afterEach'].includes(method.name)) {
+                return false; // Skip test lifecycle methods if not including tests
+            }
+            else {
+                return true;
+            }
+        }
+        // Check annotations
+        for (const annotation of methodAnnotations) {
+            if (ENTRY_POINT_ANNOTATIONS.has(annotation)) {
+                if (!includeTests && ['Test', 'BeforeEach', 'AfterEach', 'BeforeAll', 'AfterAll', 'Before', 'After'].includes(annotation)) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        // Check if class is an entry point class (all public methods are entry points)
+        if (isEntryPointClass && method.modifiers.includes('public')) {
+            return true;
+        }
+        // Check additional entry points
+        if (additionalEntryPoints.has(method.name)) {
+            return true;
+        }
+        // Check if public methods should be entry points
+        if (publicMethodsAsEntryPoints && method.modifiers.includes('public')) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Find the method containing a given line.
+     */
+    findContainingMethod(file, ir, line) {
+        for (const type of ir.types) {
+            if (type.kind !== 'class' && type.kind !== 'interface')
+                continue;
+            for (const method of type.methods) {
+                if (line >= method.start_line && line <= method.end_line) {
+                    return this.getMethodId(file, type.name, method.name);
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolve a call to potential target methods.
+     */
+    resolveCallTarget(call, types, allFiles) {
+        const targets = [];
+        const methodName = call.method_name;
+        const receiver = call.receiver;
+        // Simple resolution: find all methods with the same name
+        // In a real implementation, this would use type inference
+        for (const { file, ir } of allFiles) {
+            for (const type of ir.types) {
+                if (type.kind !== 'class' && type.kind !== 'interface')
+                    continue;
+                for (const method of type.methods) {
+                    if (method.name === methodName) {
+                        // If we have a receiver, try to match the class
+                        if (receiver) {
+                            // Check if receiver matches class name (simplified)
+                            const receiverLower = receiver.toLowerCase();
+                            const classLower = type.name.toLowerCase();
+                            if (receiverLower.includes(classLower) || classLower.includes(receiverLower)) {
+                                targets.push(this.getMethodId(file, type.name, method.name));
+                            }
+                        }
+                        else {
+                            targets.push(this.getMethodId(file, type.name, method.name));
+                        }
+                    }
+                }
+            }
+        }
+        return targets;
+    }
+    /**
+     * Detect dead code using reachability analysis.
+     */
+    detectDeadCode(files, options) {
+        const { maxDepth = 50 } = options;
+        const deadCode = [];
+        // Perform BFS from entry points
+        const queue = [];
+        for (const entryPoint of this.entryPoints) {
+            queue.push({ id: entryPoint, depth: 0 });
+            this.reachable.add(entryPoint);
+        }
+        while (queue.length > 0) {
+            const { id, depth } = queue.shift();
+            if (depth >= maxDepth)
+                continue;
+            const callees = this.callGraph.get(id);
+            if (callees) {
+                for (const callee of callees) {
+                    if (!this.reachable.has(callee)) {
+                        this.reachable.add(callee);
+                        queue.push({ id: callee, depth: depth + 1 });
+                    }
+                }
+            }
+        }
+        // Find unreachable methods
+        for (const [methodId, node] of this.methodMap) {
+            if (!this.reachable.has(methodId)) {
+                // Determine confidence
+                let confidence = 'high';
+                let reason = 'Not reachable from any entry point';
+                if (this.isJSTS(node.language)) {
+                    // Skip synthetic <module-init> — not real dead code
+                    if (node.methodName === '<module-init>')
+                        continue;
+                    // Underscore-prefixed = conventionally private
+                    if (node.methodName.startsWith('_')) {
+                        confidence = 'high';
+                        reason = 'Private helper function not called from any entry point';
+                    }
+                    // Callback handler names — may be invoked by framework
+                    else if (node.methodName.endsWith('_handler')) {
+                        confidence = 'low';
+                        reason = 'Callback handler (may be invoked by framework)';
+                    }
+                    // JS protocol methods
+                    else if (['toString', 'valueOf', 'toJSON', 'constructor'].includes(node.methodName)) {
+                        confidence = 'low';
+                        reason = 'Standard protocol method (may be called implicitly)';
+                    }
+                }
+                else if (this.isPython(node.language)) {
+                    // Skip synthetic <module-init> — not real dead code
+                    if (node.methodName === '<module-init>')
+                        continue;
+                    // Single underscore prefix = conventionally private
+                    if (node.methodName.startsWith('_') && !node.methodName.startsWith('__')) {
+                        confidence = 'high';
+                        reason = 'Private helper function not called from any entry point';
+                    }
+                    // Dunder methods = special/magic methods, may be called implicitly
+                    else if (node.methodName.startsWith('__') && node.methodName.endsWith('__')) {
+                        confidence = 'low';
+                        reason = 'Magic method (may be called implicitly by Python runtime)';
+                    }
+                    // Test methods (if not including tests)
+                    else if (node.methodName.startsWith('test_')) {
+                        confidence = 'low';
+                        reason = 'Test method (may be called by test runner)';
+                    }
+                    // Common callback/handler patterns
+                    else if (node.methodName.endsWith('_handler') || node.methodName.endsWith('_callback')) {
+                        confidence = 'low';
+                        reason = 'Callback/handler (may be invoked by framework)';
+                    }
+                }
+                else if (this.isRust(node.language)) {
+                    // Rust-specific confidence logic
+                    // Test functions
+                    if (node.methodName.startsWith('test_') || node.annotations.some(a => a.includes('test'))) {
+                        confidence = 'low';
+                        reason = 'Test function (may be called by test runner)';
+                    }
+                    // Trait implementations often called implicitly
+                    else if (['new', 'default', 'from', 'into', 'clone', 'drop', 'deref'].includes(node.methodName)) {
+                        confidence = 'low';
+                        reason = 'Trait method (may be called implicitly)';
+                    }
+                    // Private functions (not pub)
+                    else if (!node.modifiers.includes('pub')) {
+                        confidence = 'high';
+                        reason = 'Private function not called from any entry point';
+                    }
+                    // Public functions in library crates may be external API
+                    else if (node.modifiers.includes('pub')) {
+                        confidence = 'medium';
+                        reason = 'Public function (may be library API)';
+                    }
+                }
+                else {
+                    // Java confidence logic
+                    // Lower confidence for private methods (may be used via reflection)
+                    if (node.modifiers.includes('private')) {
+                        confidence = 'medium';
+                        reason = 'Private method not called directly (could be reflection)';
+                    }
+                    // Lower confidence for methods with certain names
+                    if (['equals', 'hashCode', 'toString', 'compareTo', 'clone'].includes(node.methodName)) {
+                        confidence = 'low';
+                        reason = 'Standard method override (may be called implicitly)';
+                    }
+                }
+                deadCode.push({
+                    type: 'method',
+                    file: node.file,
+                    name: node.methodName,
+                    className: node.className,
+                    startLine: node.startLine,
+                    endLine: node.endLine,
+                    lineCount: node.lineCount,
+                    reason,
+                    confidence,
+                });
+            }
+        }
+        // Sort by file and line
+        deadCode.sort((a, b) => {
+            if (a.file !== b.file)
+                return a.file.localeCompare(b.file);
+            return a.startLine - b.startLine;
+        });
+        return deadCode;
+    }
+    /**
+     * Generate final result.
+     */
+    generateResult(files, deadCode, options, startTime) {
+        // Calculate summary
+        let totalLOC = 0;
+        let totalMethods = 0;
+        let totalClasses = 0;
+        let deadLOC = 0;
+        for (const { ir, loc } of files) {
+            totalLOC += loc;
+            for (const type of ir.types) {
+                if (type.kind === 'class')
+                    totalClasses++;
+                totalMethods += type.methods.length;
+            }
+        }
+        const byFile = new Map();
+        for (const item of deadCode) {
+            deadLOC += item.lineCount;
+            if (!byFile.has(item.file)) {
+                byFile.set(item.file, { deadMethods: 0, deadClasses: 0, deadLOC: 0 });
+            }
+            const fileStats = byFile.get(item.file);
+            if (item.type === 'method')
+                fileStats.deadMethods++;
+            if (item.type === 'class')
+                fileStats.deadClasses++;
+            fileStats.deadLOC += item.lineCount;
+        }
+        // Generate entry point list
+        const entryPointsList = [];
+        for (const entryPointId of this.entryPoints) {
+            const node = this.methodMap.get(entryPointId);
+            if (node) {
+                entryPointsList.push({
+                    type: this.getEntryPointType(node),
+                    file: node.file,
+                    className: node.className,
+                    methodName: node.methodName,
+                    line: node.startLine,
+                    reason: this.getEntryPointReason(node),
+                });
+            }
+        }
+        return {
+            meta: {
+                target: options.target,
+                timestamp: new Date().toISOString(),
+                durationMs: Date.now() - startTime,
+                filesAnalyzed: files.length,
+                totalMethods,
+                totalClasses,
+            },
+            entryPoints: entryPointsList,
+            deadCode,
+            summary: {
+                totalFiles: files.length,
+                totalLOC,
+                totalMethods,
+                totalClasses,
+                deadMethods: deadCode.filter(d => d.type === 'method').length,
+                deadClasses: deadCode.filter(d => d.type === 'class').length,
+                deadLOC,
+                deadPercentage: totalLOC > 0 ? Math.round((deadLOC / totalLOC) * 1000) / 10 : 0,
+                byFile: Array.from(byFile.entries()).map(([file, stats]) => ({ file, ...stats })),
+            },
+        };
+    }
+    /**
+     * Get entry point type.
+     */
+    getEntryPointType(node) {
+        if (this.isJSTS(node.language)) {
+            if (node.methodName === '<module-init>')
+                return 'export';
+            if (node.methodName.endsWith('_handler'))
+                return 'handler';
+            return 'export';
+        }
+        if (this.isPython(node.language)) {
+            if (node.methodName === '<module-init>')
+                return 'export';
+            // Route decorators
+            if (node.annotations.some(a => a.startsWith('route') || a.startsWith('app.route') ||
+                a === 'get' || a === 'post' || a === 'put' || a === 'delete')) {
+                return 'handler';
+            }
+            return 'export';
+        }
+        if (this.isRust(node.language)) {
+            if (node.methodName === 'main')
+                return 'main';
+            // Async runtime entry points
+            if (node.annotations.some(a => a.includes('tokio::main') || a.includes('actix_web::main') ||
+                a.includes('rocket::launch'))) {
+                return 'main';
+            }
+            // Route handlers
+            if (node.annotations.some(a => a.includes('get') || a.includes('post') || a.includes('put') ||
+                a.includes('delete') || a.includes('route'))) {
+                return 'handler';
+            }
+            // Test functions
+            if (node.annotations.some(a => a.includes('test'))) {
+                return 'annotation';
+            }
+            // Public functions in lib
+            if (node.modifiers.includes('pub')) {
+                return 'export';
+            }
+            return 'public';
+        }
+        if (node.methodName === 'main')
+            return 'main';
+        if (node.methodName === '<init>')
+            return 'constructor';
+        const handlerAnnotations = ['GetMapping', 'PostMapping', 'PutMapping', 'DeleteMapping', 'RequestMapping', 'GET', 'POST', 'PUT', 'DELETE'];
+        if (node.annotations.some(a => handlerAnnotations.includes(a)))
+            return 'handler';
+        if (node.annotations.some(a => ENTRY_POINT_ANNOTATIONS.has(a)))
+            return 'annotation';
+        return 'public';
+    }
+    /**
+     * Get entry point reason.
+     */
+    getEntryPointReason(node) {
+        if (this.isJSTS(node.language)) {
+            if (node.methodName === '<module-init>')
+                return 'Module top-level code';
+            if (node.methodName.endsWith('_handler')) {
+                const verb = node.methodName.replace('_handler', '').toUpperCase();
+                return `HTTP route handler (${verb})`;
+            }
+            return 'Exported function';
+        }
+        if (this.isPython(node.language)) {
+            if (node.methodName === '<module-init>')
+                return 'Module top-level code';
+            // Route decorators
+            if (node.annotations.some(a => a.startsWith('route') || a.startsWith('app.route'))) {
+                return 'Flask/Django route handler';
+            }
+            if (node.annotations.some(a => a === 'get' || a === 'post' || a === 'put' || a === 'delete')) {
+                return 'HTTP route handler';
+            }
+            return 'Exported function';
+        }
+        if (this.isRust(node.language)) {
+            if (node.methodName === 'main')
+                return 'Main function';
+            // Async runtime entry points
+            if (node.annotations.some(a => a.includes('tokio::main'))) {
+                return 'Tokio async main';
+            }
+            if (node.annotations.some(a => a.includes('actix_web::main') || a.includes('actix_rt::main'))) {
+                return 'Actix-web main';
+            }
+            if (node.annotations.some(a => a.includes('rocket::launch'))) {
+                return 'Rocket launch';
+            }
+            // Route handlers
+            if (node.annotations.some(a => a.includes('get')))
+                return 'HTTP GET handler';
+            if (node.annotations.some(a => a.includes('post')))
+                return 'HTTP POST handler';
+            if (node.annotations.some(a => a.includes('put')))
+                return 'HTTP PUT handler';
+            if (node.annotations.some(a => a.includes('delete')))
+                return 'HTTP DELETE handler';
+            if (node.annotations.some(a => a.includes('route')))
+                return 'HTTP route handler';
+            // Test functions
+            if (node.annotations.some(a => a.includes('test'))) {
+                return 'Test function';
+            }
+            // Public functions
+            if (node.modifiers.includes('pub')) {
+                return 'Public API function';
+            }
+            return 'Entry point';
+        }
+        if (node.methodName === 'main')
+            return 'Main method';
+        if (node.methodName === '<init>')
+            return 'Constructor';
+        const handlerAnnotations = ['GetMapping', 'PostMapping', 'PutMapping', 'DeleteMapping', 'RequestMapping'];
+        const handler = node.annotations.find(a => handlerAnnotations.includes(a));
+        if (handler)
+            return `HTTP handler (@${handler})`;
+        const annotation = node.annotations.find(a => ENTRY_POINT_ANNOTATIONS.has(a));
+        if (annotation)
+            return `Annotated with @${annotation}`;
+        return 'Public method';
+    }
+    /**
+     * Generate method ID.
+     */
+    getMethodId(file, className, methodName) {
+        return `${file}::${className}::${methodName}`;
+    }
+    /**
+     * Detect language from file extension.
+     */
+    detectLanguage(file) {
+        const ext = path.extname(file).toLowerCase();
+        switch (ext) {
+            case '.java': return 'java';
+            case '.c':
+            case '.h': return 'c';
+            case '.cpp':
+            case '.cc':
+            case '.cxx':
+            case '.hpp': return 'cpp';
+            case '.js':
+            case '.jsx':
+            case '.mjs':
+            case '.cjs': return 'javascript';
+            case '.ts':
+            case '.tsx':
+            case '.mts':
+            case '.cts': return 'typescript';
+            case '.py': return 'python';
+            case '.rs': return 'rust';
+            default: return 'java';
+        }
+    }
+    /**
+     * Check if language is JavaScript or TypeScript.
+     */
+    isJSTS(lang) {
+        return lang === 'javascript' || lang === 'typescript';
+    }
+    /**
+     * Check if language is Python.
+     */
+    isPython(lang) {
+        return lang === 'python';
+    }
+    /**
+     * Check if language is Rust.
+     */
+    isRust(lang) {
+        return lang === 'rust';
+    }
+    /**
+     * Check if language uses module-level entry points (JS/TS/Python).
+     */
+    isModuleBasedLanguage(lang) {
+        return this.isJSTS(lang) || this.isPython(lang);
+    }
+    /**
+     * Report progress.
+     */
+    reportProgress(progress) {
+        if (this.onProgress) {
+            this.onProgress(progress);
+        }
+        if (this.verbose) {
+            console.log(`[${progress.phase}] ${progress.filesProcessed}/${progress.totalFiles} ${progress.message || ''}`);
+        }
+    }
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Detect dead code in a directory or file.
+ */
+export async function detectDeadCode(options) {
+    const detector = new DeadCodeDetector();
+    return detector.detect(options);
+}
+/**
+ * Quick dead code detection with default options.
+ */
+export async function quickDeadCodeCheck(target) {
+    return detectDeadCode({
+        target,
+        verbose: false,
+        publicMethodsAsEntryPoints: false,
+    });
+}
+/**
+ * Generate a text report from dead code results.
+ */
+export function formatDeadCodeReport(result) {
+    const lines = [
+        '='.repeat(70),
+        'DEAD CODE ANALYSIS REPORT',
+        '='.repeat(70),
+        '',
+        `Target: ${result.meta.target}`,
+        `Timestamp: ${result.meta.timestamp}`,
+        `Duration: ${(result.meta.durationMs / 1000).toFixed(2)}s`,
+        '',
+        '-'.repeat(70),
+        'SUMMARY',
+        '-'.repeat(70),
+        '',
+        `Files Analyzed: ${result.summary.totalFiles}`,
+        `Total LOC: ${result.summary.totalLOC.toLocaleString()}`,
+        `Total Methods: ${result.summary.totalMethods}`,
+        `Total Classes: ${result.summary.totalClasses}`,
+        '',
+        `Dead Methods: ${result.summary.deadMethods}`,
+        `Dead Classes: ${result.summary.deadClasses}`,
+        `Dead LOC: ${result.summary.deadLOC.toLocaleString()} (${result.summary.deadPercentage}%)`,
+        '',
+    ];
+    if (result.entryPoints.length > 0) {
+        lines.push('-'.repeat(70));
+        lines.push(`ENTRY POINTS (${result.entryPoints.length})`);
+        lines.push('-'.repeat(70));
+        lines.push('');
+        for (const ep of result.entryPoints.slice(0, 20)) {
+            const location = ep.className ? `${ep.className}.${ep.methodName}` : ep.methodName;
+            lines.push(`  ${ep.type.toUpperCase().padEnd(12)} ${ep.file}:${ep.line} - ${location}`);
+        }
+        if (result.entryPoints.length > 20) {
+            lines.push(`  ... and ${result.entryPoints.length - 20} more`);
+        }
+        lines.push('');
+    }
+    if (result.deadCode.length > 0) {
+        lines.push('-'.repeat(70));
+        lines.push(`DEAD CODE (${result.deadCode.length} items)`);
+        lines.push('-'.repeat(70));
+        lines.push('');
+        // Group by file
+        const byFile = new Map();
+        for (const item of result.deadCode) {
+            if (!byFile.has(item.file)) {
+                byFile.set(item.file, []);
+            }
+            byFile.get(item.file).push(item);
+        }
+        for (const [file, items] of byFile) {
+            lines.push(`${file} (${items.length} items, ${items.reduce((sum, i) => sum + i.lineCount, 0)} lines):`);
+            for (const item of items.slice(0, 10)) {
+                const name = item.className ? `${item.className}.${item.name}` : item.name;
+                const conf = item.confidence === 'high' ? '' : ` [${item.confidence}]`;
+                lines.push(`  L${item.startLine}-${item.endLine}: ${item.type} ${name}${conf}`);
+            }
+            if (items.length > 10) {
+                lines.push(`  ... and ${items.length - 10} more`);
+            }
+            lines.push('');
+        }
+    }
+    lines.push('='.repeat(70));
+    return lines.join('\n');
+}
+//# sourceMappingURL=detector.js.map