agent-ide 0.6.0 → 0.7.0

package/dist/core/dead-code/dead-code-remover.js

@@ -0,0 +1,803 @@
+/**
+ * Dead Code 刪除器
+ * 負責刪除未使用的程式碼並清理相關 import
+ */
+import { minimatch } from 'minimatch';
+import { createSymbolFinder, SymbolReferenceType } from '../shared/symbol-finder.js';
+import { DEFAULT_REMOVAL_OPTIONS } from './types.js';
+/**
+ * Dead Code 刪除器
+ */
+export class DeadCodeRemover {
+    fileSystem;
+    parserRegistry;
+    options;
+    fileCache = new Map();
+    symbolFinder;
+    constructor(fileSystem, parserRegistry, options) {
+        this.fileSystem = fileSystem;
+        this.parserRegistry = parserRegistry;
+        this.options = { ...DEFAULT_REMOVAL_OPTIONS, ...options };
+        this.symbolFinder = createSymbolFinder(parserRegistry, fileSystem);
+    }
+    /**
+     * 預覽刪除操作
+     */
+    async preview(deadCodeItems) {
+        try {
+            // 1. 過濾符合條件的項目
+            const { filteredItems, warnings } = this.filterItems(deadCodeItems);
+            if (filteredItems.length === 0) {
+                return this.createEmptyPreview(warnings);
+            }
+            // 2. 產生刪除操作
+            const { operations: removals, warnings: removalWarnings } = await this.generateRemovalOperations(filteredItems);
+            warnings.push(...removalWarnings);
+            // 3. 分析並產生 import 清理操作
+            let importCleanups = [];
+            if (this.options.cleanupImports) {
+                const importResult = await this.analyzeImportCleanups(removals);
+                importCleanups = importResult.cleanups;
+                warnings.push(...importResult.warnings);
+            }
+            // 4. 計算統計
+            const summary = this.calculateSummary(removals, importCleanups);
+            // 5. 收集影響的檔案
+            const affectedFiles = this.collectAffectedFiles(removals, importCleanups);
+            return {
+                success: true,
+                removals,
+                importCleanups,
+                affectedFiles,
+                summary,
+                warnings: warnings.length > 0 ? warnings : undefined
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                removals: [],
+                importCleanups: [],
+                affectedFiles: [],
+                summary: this.createEmptySummary(),
+                errors: [error instanceof Error ? error.message : String(error)]
+            };
+        }
+    }
+    /**
+     * 執行刪除（非 dry-run 時）
+     */
+    async execute(preview) {
+        if (!preview.success) {
+            return {
+                success: false,
+                updatedFiles: [],
+                summary: preview.summary,
+                errors: preview.errors
+            };
+        }
+        const errors = [];
+        const updatedFiles = [];
+        // 按檔案分組操作
+        const fileOperations = this.groupOperationsByFile(preview);
+        // 逐檔案套用變更
+        for (const [filePath, operations] of fileOperations) {
+            try {
+                const result = await this.applyFileOperations(filePath, operations);
+                updatedFiles.push(result);
+            }
+            catch (error) {
+                errors.push(`檔案 ${filePath} 處理失敗: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return {
+            success: errors.length === 0,
+            updatedFiles,
+            summary: preview.summary,
+            errors: errors.length > 0 ? errors : undefined
+        };
+    }
+    /**
+     * 過濾符合刪除條件的項目
+     */
+    filterItems(items) {
+        const filteredItems = [];
+        const warnings = [];
+        for (const item of items) {
+            // 信心度檢查
+            if (item.confidence < this.options.minConfidence) {
+                warnings.push(`跳過 ${item.name}：信心度 ${(item.confidence * 100).toFixed(0)}% 低於門檻 ${(this.options.minConfidence * 100).toFixed(0)}%`);
+                continue;
+            }
+            // 排除檔案模式（支援 glob 匹配）
+            if (this.options.excludeFiles.some(pattern => this.matchesExcludePattern(item.location.filePath, pattern))) {
+                warnings.push(`跳過 ${item.name}：檔案被排除`);
+                continue;
+            }
+            // 排除符號名稱
+            if (this.options.excludeSymbols.includes(item.name)) {
+                warnings.push(`跳過 ${item.name}：符號被排除`);
+                continue;
+            }
+            filteredItems.push(item);
+        }
+        return { filteredItems, warnings };
+    }
+    /**
+     * 產生刪除操作
+     */
+    async generateRemovalOperations(items) {
+        const operations = [];
+        const warnings = [];
+        for (const item of items) {
+            const content = await this.readFile(item.location.filePath);
+            if (!content) {
+                warnings.push(`跳過 ${item.name}：無法讀取檔案 ${item.location.filePath}`);
+                continue;
+            }
+            // 擴展範圍以包含完整宣告（含 JSDoc 註解）
+            const expandedRange = this.expandRangeToFullDeclaration(content, item.location.range, item.type);
+            const originalCode = this.extractCode(content, expandedRange);
+            operations.push({
+                filePath: item.location.filePath,
+                range: expandedRange,
+                originalCode,
+                symbolName: item.name,
+                symbolType: item.type,
+                confidence: item.confidence
+            });
+        }
+        return { operations, warnings };
+    }
+    /**
+     * 分析需要清理的 import
+     * 支援部分清理：當 import { A, B, C } 中只有部分符號未使用時，保留其他符號
+     */
+    async analyzeImportCleanups(removals) {
+        const cleanups = [];
+        const warnings = [];
+        const affectedFiles = new Set(removals.map(r => r.filePath));
+        const removedSymbols = new Set(removals.map(r => r.symbolName));
+        for (const filePath of affectedFiles) {
+            const content = await this.readFile(filePath);
+            if (!content) {
+                warnings.push(`跳過 import 清理：無法讀取檔案 ${filePath}`);
+                continue;
+            }
+            // 解析 import 語句（以語句為單位）
+            const importStatements = this.parseImportStatements(content);
+            const fileRemovals = removals.filter(r => r.filePath === filePath);
+            for (const stmt of importStatements) {
+                // 找出此 import 中需要清理的符號
+                const unusedSymbols = [];
+                const usedSymbols = [];
+                for (const symbol of stmt.symbols) {
+                    // 符號是否在被刪除的列表中，且刪除後不再使用
+                    if (removedSymbols.has(symbol.name)) {
+                        const stillUsed = await this.isImportStillUsed(filePath, symbol.name, fileRemovals);
+                        if (!stillUsed) {
+                            unusedSymbols.push(symbol.name);
+                        }
+                        else {
+                            usedSymbols.push(symbol.name);
+                        }
+                    }
+                    else {
+                        usedSymbols.push(symbol.name);
+                    }
+                }
+                // 沒有需要清理的符號，跳過
+                if (unusedSymbols.length === 0) {
+                    continue;
+                }
+                // 判斷清理類型
+                if (usedSymbols.length === 0) {
+                    // 所有符號都未使用，刪除整行
+                    cleanups.push({
+                        filePath,
+                        range: stmt.range,
+                        originalImport: stmt.statement,
+                        unusedSymbols,
+                        cleanupType: 'delete'
+                    });
+                }
+                else {
+                    // 部分符號仍在使用，產生新的 import 語句
+                    const newImport = this.generatePartialImport(stmt, usedSymbols);
+                    if (newImport) {
+                        cleanups.push({
+                            filePath,
+                            range: stmt.range,
+                            originalImport: stmt.statement,
+                            unusedSymbols,
+                            cleanupType: 'partial',
+                            newImport
+                        });
+                    }
+                }
+            }
+        }
+        return { cleanups, warnings };
+    }
+    /**
+     * 產生部分清理後的 import 語句
+     * 支援：純 named import、混合 default + named import
+     */
+    generatePartialImport(stmt, usedSymbols) {
+        // Namespace import 不支援部分清理（整體使用）
+        if (stmt.isNamespace) {
+            return null;
+        }
+        // 從原始語句中提取 from 路徑
+        const fromMatch = stmt.statement.match(/from\s+(['"])(.+?)\1/);
+        if (!fromMatch) {
+            return null;
+        }
+        const fromPath = fromMatch[2];
+        const quote = fromMatch[1];
+        // 分離 default 和 named symbols
+        const defaultSymbol = stmt.symbols.find(s => s.isDefault);
+        const namedSymbols = stmt.symbols.filter(s => !s.isDefault);
+        // 檢查 default import 是否仍需保留
+        const keepDefault = defaultSymbol && usedSymbols.includes(defaultSymbol.name);
+        // 過濾出需要保留的 named symbols，並保留別名資訊
+        // 同時檢查 name 和 alias，因為 usedSymbols 可能包含別名
+        const keptNamedSymbols = namedSymbols
+            .filter(s => usedSymbols.includes(s.name) || (s.alias && usedSymbols.includes(s.alias)))
+            .map(s => s.alias ? `${s.name} as ${s.alias}` : s.name);
+        // 判斷是否需要 type 關鍵字（僅對純 named import）
+        const isTypeImport = stmt.statement.match(/import\s+type\s*\{/);
+        const typePrefix = isTypeImport ? 'type ' : '';
+        // 建構新的 import 語句
+        if (keepDefault && keptNamedSymbols.length > 0) {
+            // 混合格式：import X, { Y, Z } from '...'
+            return `import ${defaultSymbol.name}, { ${keptNamedSymbols.join(', ')} } from ${quote}${fromPath}${quote};`;
+        }
+        else if (keepDefault) {
+            // 只有 default：import X from '...'
+            return `import ${defaultSymbol.name} from ${quote}${fromPath}${quote};`;
+        }
+        else if (keptNamedSymbols.length > 0) {
+            // 只有 named：import { Y, Z } from '...'
+            return `import ${typePrefix}{ ${keptNamedSymbols.join(', ')} } from ${quote}${fromPath}${quote};`;
+        }
+        // 沒有任何符號需要保留
+        return null;
+    }
+    /**
+     * 解析 import 語句（以語句為單位）
+     * 支援 named import, default import, namespace import, 多行 import
+     */
+    parseImportStatements(content) {
+        const statements = [];
+        const lines = content.split('\n');
+        // 用於處理多行 import
+        let multiLineImport = '';
+        let multiLineStartLine = -1;
+        let multiLineCount = 0;
+        const MAX_MULTILINE_IMPORT = 20; // 安全限制：最多 20 行
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNumber = i + 1;
+            // 處理多行 import
+            if (multiLineImport) {
+                multiLineImport += '\n' + line;
+                multiLineCount++;
+                // 檢測結束條件：有 from 和 引號，或超過安全限制
+                const cleanLine = line.replace(/\/\/.*/, '').replace(/\/\*[\s\S]*?\*\//g, '');
+                const isComplete = cleanLine.includes('from') && /['"]/.test(cleanLine);
+                const isOverLimit = multiLineCount > MAX_MULTILINE_IMPORT;
+                if (isComplete || isOverLimit) {
+                    // 多行 import 結束
+                    const stmt = this.parseImportStatementLine(multiLineImport, multiLineStartLine, lineNumber, lines);
+                    if (stmt) {
+                        statements.push(stmt);
+                    }
+                    multiLineImport = '';
+                    multiLineStartLine = -1;
+                    multiLineCount = 0;
+                }
+                continue;
+            }
+            // 檢查是否為多行 import 開始（有 { 但沒有 } 或沒有 from）
+            if (line.match(/^\s*import\s+(?:type\s*)?\{/) && !line.includes('}')) {
+                multiLineImport = line;
+                multiLineStartLine = lineNumber;
+                multiLineCount = 1;
+                continue;
+            }
+            // 單行處理
+            const stmt = this.parseImportStatementLine(line, lineNumber, lineNumber, lines);
+            if (stmt) {
+                statements.push(stmt);
+            }
+        }
+        return statements;
+    }
+    /**
+     * 解析單行或合併後的 import 語句
+     */
+    parseImportStatementLine(line, startLine, endLine, lines) {
+        const trimmedLine = line.replace(/\s+/g, ' ').trim();
+        // 不是 import 語句
+        if (!trimmedLine.startsWith('import ')) {
+            return null;
+        }
+        // Side-effect import: import '...' (沒有符號)
+        if (trimmedLine.match(/^import\s+['"][^'"]+['"]/)) {
+            return null;
+        }
+        const range = {
+            start: { line: startLine, column: 1, offset: undefined },
+            end: { line: endLine, column: (lines[endLine - 1] || '').length + 1, offset: undefined }
+        };
+        const symbols = [];
+        let hasDefault = false;
+        let isNamespace = false;
+        // 1. Namespace import: import * as X from '...'
+        const namespaceMatch = trimmedLine.match(/import\s+\*\s+as\s+(\w+)\s+from/);
+        if (namespaceMatch) {
+            symbols.push({ name: namespaceMatch[1], isNamespace: true });
+            isNamespace = true;
+            return { statement: trimmedLine, range, symbols, hasDefault, isNamespace };
+        }
+        // 2. Default import with named: import X, { Y, Z } from '...'
+        const defaultWithNamedMatch = trimmedLine.match(/import\s+(\w+)\s*,\s*\{([^}]+)\}\s*from/);
+        if (defaultWithNamedMatch) {
+            hasDefault = true;
+            symbols.push({ name: defaultWithNamedMatch[1], isDefault: true });
+            this.parseNamedSymbols(defaultWithNamedMatch[2], symbols);
+            return { statement: trimmedLine, range, symbols, hasDefault, isNamespace };
+        }
+        // 3. Default import only: import X from '...'
+        const defaultMatch = trimmedLine.match(/import\s+(\w+)\s+from\s+['"]/);
+        if (defaultMatch && !trimmedLine.includes('{')) {
+            hasDefault = true;
+            symbols.push({ name: defaultMatch[1], isDefault: true });
+            return { statement: trimmedLine, range, symbols, hasDefault, isNamespace };
+        }
+        // 4. Named import: import { X, Y } from '...' or import type { X } from '...'
+        const namedImportMatch = trimmedLine.match(/import\s+(?:type\s*)?\{([^}]+)\}\s*from/);
+        if (namedImportMatch) {
+            this.parseNamedSymbols(namedImportMatch[1], symbols);
+            if (symbols.length > 0) {
+                return { statement: trimmedLine, range, symbols, hasDefault, isNamespace };
+            }
+        }
+        return null;
+    }
+    /**
+     * 解析 named import 中的符號
+     */
+    parseNamedSymbols(symbolsStr, symbols) {
+        const parts = symbolsStr.split(',').map(s => s.trim());
+        for (const part of parts) {
+            // 跳過空字串和 type-only imports
+            if (!part || part.startsWith('type ')) {
+                continue;
+            }
+            // 處理 as 別名: X as Y
+            const asMatch = part.match(/^(\w+)\s+as\s+(\w+)$/);
+            if (asMatch) {
+                symbols.push({ name: asMatch[1], alias: asMatch[2] });
+            }
+            else {
+                const cleanSymbol = part.trim();
+                if (cleanSymbol) {
+                    symbols.push({ name: cleanSymbol });
+                }
+            }
+        }
+    }
+    /**
+     * 檢查 import 是否仍被使用
+     * 使用 SymbolFinder.findReferencesInFile 進行語義分析
+     */
+    async isImportStillUsed(filePath, symbolName, removalsInFile) {
+        // 使用 SymbolFinder 查找該檔案中的所有引用
+        const references = await this.symbolFinder.findReferencesInFile(filePath, symbolName);
+        // 過濾掉 import 類型的引用（import 語句本身）
+        const usageRefs = references.filter(ref => ref.type === SymbolReferenceType.Usage);
+        // 過濾掉被刪除程式碼區塊內的引用
+        const remainingRefs = usageRefs.filter(ref => {
+            const refLine = ref.location.range.start.line;
+            // 檢查引用是否在任一刪除範圍內
+            for (const removal of removalsInFile) {
+                if (refLine >= removal.range.start.line && refLine <= removal.range.end.line) {
+                    return false; // 在刪除範圍內，過濾掉
+                }
+            }
+            return true;
+        });
+        // 如果還有剩餘的使用引用，表示 import 仍需要
+        return remainingRefs.length > 0;
+    }
+    /**
+     * 移除註解和字串，用於準確檢測符號使用
+     */
+    removeCommentsAndStrings(content) {
+        let result = content;
+        // 移除多行註解 /* ... */
+        result = result.replace(/\/\*[\s\S]*?\*\//g, '');
+        // 移除單行註解 // ...
+        result = result.replace(/\/\/[^\n]*/g, '');
+        // 移除模板字串 `...`（簡化處理，不處理嵌套）
+        result = result.replace(/`(?:[^`\\]|\\.)*`/g, '""');
+        // 移除雙引號字串 "..."
+        result = result.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+        // 移除單引號字串 '...'
+        result = result.replace(/'(?:[^'\\]|\\.)*'/g, '\'\'');
+        return result;
+    }
+    /**
+     * 擴展範圍至完整宣告（包含前導註解和空行）
+     * 使用清理後的內容進行括號匹配，避免字串/註解中的括號干擾
+     */
+    expandRangeToFullDeclaration(content, range, symbolType) {
+        const lines = content.split('\n');
+        let startLine = range.start.line - 1; // 轉為 0-based
+        // 向上擴展：包含 JSDoc 註解和裝飾器
+        while (startLine > 0) {
+            const prevLine = lines[startLine - 1].trim();
+            if (prevLine.endsWith('*/') ||
+                prevLine.startsWith('*') ||
+                prevLine.startsWith('//') ||
+                prevLine.startsWith('@') ||
+                prevLine === '') {
+                startLine--;
+            }
+            else {
+                break;
+            }
+        }
+        // 向下擴展：確保包含完整的結尾
+        let endLine = range.end.line - 1;
+        // 對於 class/function，需要找到對應的結尾括號
+        if (symbolType === 'class' || symbolType === 'function') {
+            let braceCount = 0;
+            let foundOpenBrace = false;
+            for (let i = range.start.line - 1; i < lines.length; i++) {
+                // 清理該行的註解和字串，避免括號誤判
+                const cleanLine = this.removeCommentsAndStringsFromLine(lines[i]);
+                for (const char of cleanLine) {
+                    if (char === '{') {
+                        braceCount++;
+                        foundOpenBrace = true;
+                    }
+                    if (char === '}') {
+                        braceCount--;
+                    }
+                }
+                if (foundOpenBrace && braceCount === 0) {
+                    endLine = i;
+                    break;
+                }
+            }
+        }
+        // 對於 variable（可能是 arrow function），只有當包含 { 時才做括號匹配
+        if (symbolType === 'variable') {
+            const startLineContent = lines[range.start.line - 1] || '';
+            // 檢查是否包含 arrow function 的 block body
+            if (startLineContent.includes('=>') && startLineContent.includes('{')) {
+                let braceCount = 0;
+                let foundOpenBrace = false;
+                for (let i = range.start.line - 1; i < lines.length; i++) {
+                    const cleanLine = this.removeCommentsAndStringsFromLine(lines[i]);
+                    for (const char of cleanLine) {
+                        if (char === '{') {
+                            braceCount++;
+                            foundOpenBrace = true;
+                        }
+                        if (char === '}') {
+                            braceCount--;
+                        }
+                    }
+                    if (foundOpenBrace && braceCount === 0) {
+                        endLine = i;
+                        break;
+                    }
+                }
+            }
+        }
+        // 包含後續空行（最多一行）
+        if (endLine < lines.length - 1 && lines[endLine + 1].trim() === '') {
+            endLine++;
+        }
+        return {
+            start: { line: startLine + 1, column: 1, offset: undefined },
+            end: { line: endLine + 1, column: lines[endLine].length + 1, offset: undefined }
+        };
+    }
+    /**
+     * 移除單行中的註解和字串（用於括號匹配）
+     */
+    removeCommentsAndStringsFromLine(line) {
+        let result = line;
+        // 移除單行註解 // ...
+        const commentIndex = result.indexOf('//');
+        if (commentIndex !== -1) {
+            // 確保 // 不在字串中
+            const beforeComment = result.substring(0, commentIndex);
+            const quoteCount = (beforeComment.match(/['"]/g) || []).length;
+            if (quoteCount % 2 === 0) {
+                result = beforeComment;
+            }
+        }
+        // 移除字串（簡化處理）
+        result = result.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+        result = result.replace(/'(?:[^'\\]|\\.)*'/g, '\'\'');
+        result = result.replace(/`(?:[^`\\]|\\.)*`/g, '""');
+        return result;
+    }
+    /**
+     * 提取程式碼
+     */
+    extractCode(content, range) {
+        const lines = content.split('\n');
+        // 邊界檢查：確保索引在有效範圍內
+        const startLine = Math.max(0, Math.min(range.start.line - 1, lines.length - 1));
+        const endLine = Math.max(0, Math.min(range.end.line - 1, lines.length - 1));
+        if (startLine === endLine) {
+            const line = lines[startLine] || '';
+            return line.substring(range.start.column - 1, range.end.column - 1);
+        }
+        const result = [];
+        for (let i = startLine; i <= endLine; i++) {
+            const line = lines[i] || '';
+            if (i === startLine) {
+                result.push(line.substring(range.start.column - 1));
+            }
+            else if (i === endLine) {
+                result.push(line.substring(0, range.end.column - 1));
+            }
+            else {
+                result.push(line);
+            }
+        }
+        return result.join('\n');
+    }
+    /**
+     * 按檔案分組操作（去重相同 range）
+     */
+    groupOperationsByFile(preview) {
+        const fileOperations = new Map();
+        // 用於檢查 range 是否重複
+        const rangeKey = (r) => `${r.start.line}:${r.start.column}-${r.end.line}:${r.end.column}`;
+        const seenRanges = new Map();
+        const addOperation = (filePath, op) => {
+            const existing = fileOperations.get(filePath) || [];
+            const seen = seenRanges.get(filePath) || new Set();
+            const key = rangeKey(op.range);
+            // 去重：相同 range 只加入一次
+            if (!seen.has(key)) {
+                existing.push(op);
+                seen.add(key);
+                fileOperations.set(filePath, existing);
+                seenRanges.set(filePath, seen);
+            }
+        };
+        // 加入刪除操作
+        for (const removal of preview.removals) {
+            addOperation(removal.filePath, { range: removal.range, type: 'removal' });
+        }
+        // 加入 import 清理操作
+        for (const cleanup of preview.importCleanups) {
+            if (cleanup.cleanupType === 'partial' && cleanup.newImport) {
+                addOperation(cleanup.filePath, {
+                    range: cleanup.range,
+                    type: 'import-partial',
+                    newContent: cleanup.newImport
+                });
+            }
+            else {
+                addOperation(cleanup.filePath, { range: cleanup.range, type: 'import-delete' });
+            }
+        }
+        return fileOperations;
+    }
+    /**
+     * 套用檔案操作
+     */
+    async applyFileOperations(filePath, operations) {
+        const originalContent = await this.readFile(filePath);
+        if (!originalContent) {
+            throw new Error(`無法讀取檔案: ${filePath}`);
+        }
+        // 按位置從後往前排序（避免位置偏移）
+        // 第三層：type 排序確保穩定性（import 清理優先於符號刪除）
+        const typeOrder = {
+            'import-partial': 0,
+            'import-delete': 1,
+            'removal': 2
+        };
+        const sortedOps = [...operations].sort((a, b) => {
+            if (a.range.start.line !== b.range.start.line) {
+                return b.range.start.line - a.range.start.line;
+            }
+            if (a.range.start.column !== b.range.start.column) {
+                return b.range.start.column - a.range.start.column;
+            }
+            return typeOrder[a.type] - typeOrder[b.type];
+        });
+        let lines = originalContent.split('\n');
+        let removedSymbols = 0;
+        let cleanedImports = 0;
+        for (const op of sortedOps) {
+            // 邊界檢查：確保索引在有效範圍內
+            const startLine = Math.max(0, Math.min(op.range.start.line - 1, lines.length - 1));
+            const endLine = Math.max(startLine, Math.min(op.range.end.line - 1, lines.length - 1));
+            const deleteCount = endLine - startLine + 1;
+            if (op.type === 'import-partial' && op.newContent) {
+                // 部分清理：替換而非刪除
+                if (startLine < lines.length && deleteCount > 0) {
+                    // 保留原始縮排
+                    const originalIndent = lines[startLine].match(/^(\s*)/)?.[1] || '';
+                    lines.splice(startLine, deleteCount, originalIndent + op.newContent);
+                }
+                cleanedImports++;
+            }
+            else {
+                // 完整刪除
+                if (startLine < lines.length && deleteCount > 0) {
+                    lines.splice(startLine, deleteCount);
+                }
+                if (op.type === 'removal') {
+                    removedSymbols++;
+                }
+                else {
+                    cleanedImports++;
+                }
+            }
+        }
+        // 清理連續空行（最多保留一行）
+        lines = this.cleanupEmptyLines(lines);
+        const newContent = lines.join('\n');
+        // 寫入檔案
+        await this.writeFile(filePath, newContent);
+        return {
+            filePath,
+            removedSymbols,
+            cleanedImports
+        };
+    }
+    /**
+     * 清理連續空行
+     */
+    cleanupEmptyLines(lines) {
+        const result = [];
+        let prevEmpty = false;
+        for (const line of lines) {
+            const isEmpty = line.trim() === '';
+            if (isEmpty && prevEmpty) {
+                // 跳過連續的空行
+                continue;
+            }
+            result.push(line);
+            prevEmpty = isEmpty;
+        }
+        return result;
+    }
+    /**
+     * 計算統計摘要
+     */
+    calculateSummary(removals, importCleanups) {
+        const byType = {};
+        for (const removal of removals) {
+            byType[removal.symbolType] = (byType[removal.symbolType] || 0) + 1;
+        }
+        const filesAffected = new Set([
+            ...removals.map(r => r.filePath),
+            ...importCleanups.map(c => c.filePath)
+        ]).size;
+        // 計算刪除的行數
+        let linesRemoved = 0;
+        for (const removal of removals) {
+            linesRemoved += removal.range.end.line - removal.range.start.line + 1;
+        }
+        for (const cleanup of importCleanups) {
+            linesRemoved += cleanup.range.end.line - cleanup.range.start.line + 1;
+        }
+        return {
+            totalRemovals: removals.length,
+            byType,
+            filesAffected,
+            linesRemoved,
+            importsCleanedUp: importCleanups.length
+        };
+    }
+    /**
+     * 收集影響的檔案
+     */
+    collectAffectedFiles(removals, importCleanups) {
+        const files = new Set();
+        for (const removal of removals) {
+            files.add(removal.filePath);
+        }
+        for (const cleanup of importCleanups) {
+            files.add(cleanup.filePath);
+        }
+        return Array.from(files);
+    }
+    /**
+     * 建立空的預覽結果
+     */
+    createEmptyPreview(warnings) {
+        return {
+            success: true,
+            removals: [],
+            importCleanups: [],
+            affectedFiles: [],
+            summary: this.createEmptySummary(),
+            warnings: warnings.length > 0 ? warnings : undefined
+        };
+    }
+    /**
+     * 建立空的統計摘要
+     */
+    createEmptySummary() {
+        return {
+            totalRemovals: 0,
+            byType: {},
+            filesAffected: 0,
+            linesRemoved: 0,
+            importsCleanedUp: 0
+        };
+    }
+    /**
+     * 讀取檔案
+     */
+    async readFile(filePath) {
+        if (this.fileCache.has(filePath)) {
+            return this.fileCache.get(filePath);
+        }
+        try {
+            const content = await this.fileSystem.readFile(filePath, 'utf-8');
+            const contentStr = typeof content === 'string' ? content : content.toString('utf-8');
+            this.fileCache.set(filePath, contentStr);
+            return contentStr;
+        }
+        catch {
+            // 清除可能存在的失敗快取，避免重試時仍返回 null
+            this.fileCache.delete(filePath);
+            return null;
+        }
+    }
+    /**
+     * 寫入檔案
+     */
+    async writeFile(filePath, content) {
+        await this.fileSystem.writeFile(filePath, content);
+        this.fileCache.set(filePath, content);
+    }
+    /**
+     * 檢查檔案路徑是否匹配排除模式
+     * 支援 glob 模式（如 *.test.ts、**\/__tests__/**）和簡單字串匹配
+     */
+    matchesExcludePattern(filePath, pattern) {
+        // 如果 pattern 包含 glob 特殊字符，使用 minimatch
+        if (pattern.includes('*') || pattern.includes('?') || pattern.includes('[')) {
+            return minimatch(filePath, pattern, { dot: true, matchBase: true });
+        }
+        // 否則使用簡單字串包含匹配（向後相容）
+        return filePath.includes(pattern);
+    }
+    /**
+     * 逸出正則表達式特殊字符
+     */
+    escapeRegex(text) {
+        return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * 清除快取
+     */
+    clearCache() {
+        this.fileCache.clear();
+    }
+}
+/**
+ * 建立 DeadCodeRemover 實例
+ */
+export function createDeadCodeRemover(fileSystem, parserRegistry, options) {
+    return new DeadCodeRemover(fileSystem, parserRegistry, options);
+}
+//# sourceMappingURL=dead-code-remover.js.map