agent-ide 0.7.5 → 0.8.0

package/dist/plugins/typescript/parser.js

@@ -9,6 +9,12 @@ import { DEFAULT_COMPILER_OPTIONS, TypeScriptParseError, createTypeScriptASTNode
 import { createSymbolExtractor } from '../typescript/symbol-extractor.js';
 import { createDependencyAnalyzer } from '../typescript/dependency-analyzer.js';
 import { MemoryMonitor } from '../../shared/utils/memory-monitor.js';
+import { TYPESCRIPT_EXCLUDE_PATTERNS, matchesAnyPattern } from '../shared/index.js';
+import { createLanguageServiceManager } from './language-service.js';
+import { createScopeAnalyzer } from './scope-analyzer.js';
+import { createDeclarationAnalyzer } from './declaration-analyzer.js';
+import { createPatternAnalyzer } from './pattern-analyzer.js';
+import { createReferenceFinder } from './reference-finder.js';
 /**
  * TypeScript Parser 實作
  */
@@ -20,13 +26,20 @@ export class TypeScriptParser {
     symbolExtractor;
     dependencyAnalyzer;
     compilerOptions;
-    languageService = null;
-    languageServiceHost = null;
-    files = new Map();
+    languageServiceManager;
+    scopeAnalyzer;
+    declarationAnalyzer;
+    patternAnalyzer;
+    referenceFinder;
     constructor(compilerOptions) {
+        this.compilerOptions = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions };
         this.symbolExtractor = createSymbolExtractor();
         this.dependencyAnalyzer = createDependencyAnalyzer();
-        this.compilerOptions = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions };
+        this.languageServiceManager = createLanguageServiceManager(this.compilerOptions);
+        this.scopeAnalyzer = createScopeAnalyzer();
+        this.declarationAnalyzer = createDeclarationAnalyzer(this.compilerOptions);
+        this.patternAnalyzer = createPatternAnalyzer(this.compilerOptions);
+        this.referenceFinder = createReferenceFinder(this.compilerOptions);
         // 註冊到記憶體監控器
         MemoryMonitor.getInstance().register(this);
     }
@@ -103,26 +116,26 @@ export class TypeScriptParser {
         const typedAst = ast;
         const typedSymbol = symbol;
         // 確保 Language Service 已初始化
-        this.ensureLanguageServiceInitialized(typedAst.tsSourceFile);
-        if (!this.languageService) {
+        this.languageServiceManager.ensureInitialized(typedAst.tsSourceFile);
+        if (!this.languageServiceManager.languageService) {
             // 如果無法使用 Language Service，回退到原始方法
             return this.findReferencesBasic(ast, symbol);
         }
         const fileName = typedAst.tsSourceFile.fileName;
         // 取得符號位置
-        const symbolPosition = this.getSymbolPosition(typedSymbol, typedAst.tsSourceFile);
+        const symbolPosition = this.languageServiceManager.getSymbolPosition(typedSymbol, typedAst.tsSourceFile, (node) => this.scopeAnalyzer.getIdentifierFromSymbolNode(node) ?? undefined);
         if (symbolPosition === undefined) {
             return [];
         }
         // 使用 Language Service 查找引用
-        const referencesResult = this.languageService.findReferences(fileName, symbolPosition);
+        const referencesResult = this.languageServiceManager.languageService.findReferences(fileName, symbolPosition);
         if (!referencesResult) {
             return [];
         }
         const references = [];
         for (const refSymbol of referencesResult) {
             for (const ref of refSymbol.references) {
-                const sourceFile = this.getSourceFileFromFileName(ref.fileName);
+                const sourceFile = this.languageServiceManager.getSourceFileFromFileName(ref.fileName);
                 if (!sourceFile) {
                     continue;
                 }
@@ -155,17 +168,17 @@ export class TypeScriptParser {
         const references = [];
         const symbolName = typedSymbol.name;
         // 獲取符號的標識符節點
-        const symbolIdentifier = this.getIdentifierFromSymbolNode(typedSymbol.tsNode);
+        const symbolIdentifier = this.scopeAnalyzer.getIdentifierFromSymbolNode(typedSymbol.tsNode);
         if (!symbolIdentifier) {
             return references;
         }
         // 使用 TypeScript 原生的節點遍歷，收集所有標識符
         const collectIdentifiers = (node) => {
-            // 🚨 過濾：跳過字串字面值
+            // 過濾：跳過字串字面值
             if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
                 return; // 不處理子節點
             }
-            // 🚨 過濾：跳過模板字串
+            // 過濾：跳過模板字串
             if (ts.isTemplateExpression(node)) {
                 // 只處理模板表達式中的插值部分，跳過字串部分
                 node.templateSpans.forEach(span => {
@@ -175,12 +188,12 @@ export class TypeScriptParser {
             }
             if (ts.isIdentifier(node) && node.text === symbolName) {
                 // 檢查這個標識符是否真的引用了我們的符號
-                if (this.isReferenceToSymbol(node, typedSymbol)) {
+                if (this.scopeAnalyzer.isReferenceToSymbol(node, typedSymbol)) {
                     const location = {
                         filePath: typedAst.tsSourceFile.fileName,
                         range: tsNodeToRange(node, typedAst.tsSourceFile)
                     };
-                    const referenceType = this.getReferenceType(node, typedSymbol);
+                    const referenceType = this.scopeAnalyzer.getReferenceType(node, typedSymbol, this.isDeclarationNode.bind(this));
                     references.push({
                         symbol,
                         location,
@@ -220,7 +233,7 @@ export class TypeScriptParser {
             targetIdentifier = node;
         }
         else if (this.isRenameableNode(node)) {
-            targetIdentifier = this.getIdentifierFromSymbolNode(node);
+            targetIdentifier = this.scopeAnalyzer.getIdentifierFromSymbolNode(node);
         }
         if (!targetIdentifier) {
             throw new Error('該位置的符號不支援重新命名');
@@ -248,7 +261,7 @@ export class TypeScriptParser {
     /**
      * 提取函式重構
      */
-    async extractFunction(ast, selection) {
+    async extractFunction(_ast, _selection) {
         // 這是一個複雜的重構操作，目前提供基本實作
         throw new Error('提取函式重構尚未實作');
     }
@@ -345,16 +358,17 @@ export class TypeScriptParser {
     async dispose() {
         // 從記憶體監控器取消註冊
         MemoryMonitor.getInstance().unregister(this);
-        // 清理 Language Service 和相關資源
-        if (this.languageService) {
-            this.languageService.dispose();
-            this.languageService = null;
-        }
-        // 清理 Language Service Host
-        this.languageServiceHost = null;
-        // 清理檔案快取
-        this.files.clear();
-        // 清理編譯器選項參考（完全清空而非設為空物件）
+        // 清理 Language Service Manager
+        if (this.languageServiceManager && 'dispose' in this.languageServiceManager) {
+            this.languageServiceManager.dispose();
+        }
+        this.languageServiceManager = null;
+        // 清理新模組
+        this.scopeAnalyzer = null;
+        this.declarationAnalyzer = null;
+        this.patternAnalyzer = null;
+        this.referenceFinder = null;
+        // 清理編譯器選項參考
         this.compilerOptions = null;
         // 清理符號提取器和依賴分析器（如果有 dispose 方法）
         if (this.symbolExtractor && 'dispose' in this.symbolExtractor && typeof this.symbolExtractor.dispose === 'function') {
@@ -379,59 +393,14 @@ export class TypeScriptParser {
      * 包含基礎排除模式 + TypeScript 測試檔案和型別定義
      */
     getDefaultExcludePatterns() {
-        return [
-            // 通用排除模式
-            'node_modules/**',
-            '.git/**',
-            'dist/**',
-            'build/**',
-            'coverage/**',
-            '.next/**',
-            '.nuxt/**',
-            'out/**',
-            '.cache/**',
-            '.turbo/**',
-            // TypeScript 特定排除模式
-            '**/*.test.ts',
-            '**/*.spec.ts',
-            '**/*.test.tsx',
-            '**/*.spec.tsx',
-            '**/__tests__/**',
-            '**/__mocks__/**',
-            '**/*.d.ts' // 型別定義檔案通常不需要分析
-        ];
+        return [...TYPESCRIPT_EXCLUDE_PATTERNS];
     }
     /**
      * 判斷是否應該忽略特定檔案
      * TypeScript parser 會忽略測試檔案和型別定義檔案
      */
     shouldIgnoreFile(filePath) {
-        const patterns = this.getDefaultExcludePatterns();
-        const normalizedPath = filePath.replace(/^\.?\//, '');
-        // 使用 minimatch 進行模式匹配
-        return patterns.some(pattern => {
-            try {
-                // 直接使用字串包含檢查來提高效能
-                if (pattern.includes('**')) {
-                    // 對於包含 ** 的模式，進行簡單的子字串匹配
-                    const simplePattern = pattern.replace(/\*\*/g, '').replace(/\//g, '');
-                    if (normalizedPath.includes(simplePattern)) {
-                        return true;
-                    }
-                }
-                // 檢查檔案路徑是否匹配模式
-                if (pattern.startsWith('**/')) {
-                    const suffix = pattern.substring(3);
-                    if (normalizedPath.endsWith(suffix) || normalizedPath.includes('/' + suffix)) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-            catch (error) {
-                return false;
-            }
-        });
+        return matchesAnyPattern(filePath, TYPESCRIPT_EXCLUDE_PATTERNS);
     }
     /**
      * 判斷符號是否為抽象宣告
@@ -483,11 +452,6 @@ export class TypeScriptParser {
         const ext = filePath.substring(filePath.lastIndexOf('.'));
         return ext === '.tsx' ? 'tsx' : 'typescript';
     }
-    getSyntacticDiagnostics(sourceFile) {
-        // 對於獨立的 SourceFile，我們跳過語法診斷檢查
-        // 在實際專案中，這通常由 Program 提供
-        return [];
-    }
     findNodeAtPosition(sourceFile, position) {
         function findNode(node) {
             if (position >= node.getStart(sourceFile) && position < node.getEnd()) {
@@ -505,192 +469,6 @@ export class TypeScriptParser {
         }
         return findNode(sourceFile);
     }
-    isReferenceToSymbol(node, symbol) {
-        if (!ts.isIdentifier(node)) {
-            return false;
-        }
-        const name = node.text;
-        if (name !== symbol.name) {
-            return false;
-        }
-        // 找到符號的標識符節點
-        const symbolIdentifier = this.getIdentifierFromSymbolNode(symbol.tsNode);
-        if (!symbolIdentifier) {
-            return false;
-        }
-        // 檢查是否為相同符號的引用
-        // 1. 如果是符號的定義位置本身
-        if (node === symbolIdentifier) {
-            return true;
-        }
-        // 2. 對於型別宣告（類別、介面、型別別名等），檢查是否在型別位置使用
-        if (ts.isClassDeclaration(symbol.tsNode) ||
-            ts.isInterfaceDeclaration(symbol.tsNode) ||
-            ts.isTypeAliasDeclaration(symbol.tsNode) ||
-            ts.isEnumDeclaration(symbol.tsNode)) {
-            // 對於型別，只要名稱相同就是引用（在同一個檔案中）
-            if (node.getSourceFile() === symbolIdentifier.getSourceFile()) {
-                return true;
-            }
-        }
-        // 3. 檢查是否在同一個檔案中
-        if (node.getSourceFile() !== symbolIdentifier.getSourceFile()) {
-            return false;
-        }
-        // 4. 對於變數、函式和方法，使用作用域檢查
-        const symbolScope = this.getScopeContainer(symbolIdentifier);
-        const nodeScope = this.getScopeContainer(node);
-        // 檢查是否在相同作用域或符號的子作用域內
-        if (nodeScope === symbolScope || this.isInScopeChain(node, symbolScope)) {
-            // 檢查是否被遮蔽（同名變數在更內層作用域）
-            if (!this.isShadowed(node, symbolIdentifier)) {
-                return true;
-            }
-        }
-        // 5. 對於頂層函式和變數，放寬檢查條件
-        // 如果符號在頂層作用域（SourceFile），則同一檔案中所有同名標識符都可能是引用
-        if (ts.isSourceFile(symbolScope) && !this.isShadowed(node, symbolIdentifier)) {
-            return true;
-        }
-        return false;
-    }
-    getIdentifierFromSymbolNode(node) {
-        // 如果本身就是 Identifier，直接返回
-        if (ts.isIdentifier(node)) {
-            return node;
-        }
-        // 對於變數宣告，標識符在 name 屬性中
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於函式宣告，標識符在 name 屬性中
-        if (ts.isFunctionDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於類別宣告
-        if (ts.isClassDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於方法宣告
-        if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於屬性宣告
-        if (ts.isPropertyDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於參數
-        if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於介面宣告
-        if (ts.isInterfaceDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於型別別名宣告
-        if (ts.isTypeAliasDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於列舉宣告
-        if (ts.isEnumDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於命名空間宣告
-        if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於 Get/Set 存取器
-        if ((ts.isGetAccessor(node) || ts.isSetAccessor(node)) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於型別參數（泛型）
-        if (ts.isTypeParameterDeclaration(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於介面/型別的屬性簽名
-        if (ts.isPropertySignature(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        // 對於方法簽名
-        if (ts.isMethodSignature(node) && ts.isIdentifier(node.name)) {
-            return node.name;
-        }
-        return null;
-    }
-    getNodeScope(node) {
-        let current = node.parent;
-        while (current) {
-            if (ts.isFunctionDeclaration(current) ||
-                ts.isMethodDeclaration(current) ||
-                ts.isArrowFunction(current) ||
-                ts.isFunctionExpression(current)) {
-                return `function_${current.pos}_${current.end}`;
-            }
-            if (ts.isBlock(current) && current.parent &&
-                (ts.isIfStatement(current.parent) ||
-                    ts.isForStatement(current.parent) ||
-                    ts.isWhileStatement(current.parent))) {
-                return `block_${current.pos}_${current.end}`;
-            }
-            current = current.parent;
-        }
-        return 'global';
-    }
-    isInSameScope(node, symbolNode) {
-        // 找到符號定義所在的作用域
-        let symbolScope = symbolNode.parent;
-        while (symbolScope && !this.isScopeNode(symbolScope)) {
-            symbolScope = symbolScope.parent;
-        }
-        // 檢查節點是否在該作用域內
-        let currentScope = node.parent;
-        while (currentScope) {
-            if (currentScope === symbolScope) {
-                return true;
-            }
-            currentScope = currentScope.parent;
-        }
-        return false;
-    }
-    isScopeNode(node) {
-        return ts.isFunctionDeclaration(node) ||
-            ts.isMethodDeclaration(node) ||
-            ts.isArrowFunction(node) ||
-            ts.isFunctionExpression(node) ||
-            ts.isBlock(node) ||
-            ts.isSourceFile(node);
-    }
-    getReferenceType(node, symbol) {
-        // 找到符號的標識符節點
-        const symbolIdentifier = this.getIdentifierFromSymbolNode(symbol.tsNode);
-        // 如果是符號的原始定義位置
-        if (node === symbolIdentifier) {
-            return ReferenceType.Definition;
-        }
-        // 檢查是否為宣告（例如函式參數、變數宣告等）
-        if (this.isDeclarationNode(node.parent)) {
-            return ReferenceType.Declaration;
-        }
-        // 檢查是否在 import 語句內
-        if (this.isInImportStatement(node)) {
-            return ReferenceType.Import;
-        }
-        // 否則為使用
-        return ReferenceType.Usage;
-    }
-    /**
-     * 檢查節點是否位於 import 語句內
-     */
-    isInImportStatement(node) {
-        let current = node.parent;
-        while (current) {
-            if (ts.isImportDeclaration(current) || ts.isImportEqualsDeclaration(current)) {
-                return true;
-            }
-            current = current.parent;
-        }
-        return false;
-    }
     isRenameableNode(node) {
         return (ts.isIdentifier(node) ||
             ts.isClassDeclaration(node) ||
@@ -792,7 +570,7 @@ export class TypeScriptParser {
         for (const symbol of symbols) {
             const typedSymbol = symbol;
             // 獲取符號的標識符節點
-            const identifier = this.getIdentifierFromSymbolNode(typedSymbol.tsNode);
+            const identifier = this.scopeAnalyzer.getIdentifierFromSymbolNode(typedSymbol.tsNode);
             if (!identifier) {
                 continue;
             }
@@ -823,189 +601,56 @@ export class TypeScriptParser {
         return true;
     }
     /**
-     * 初始化 Language Service
-     */
-    ensureLanguageServiceInitialized(sourceFile) {
-        if (this.languageService) {
-            // 更新檔案內容
-            this.updateFile(sourceFile.fileName, sourceFile.text);
-            return;
-        }
-        // 添加當前檔案到檔案列表
-        this.updateFile(sourceFile.fileName, sourceFile.text);
-        // 建立 Language Service Host
-        this.languageServiceHost = {
-            getScriptFileNames: () => {
-                const fileNames = Array.from(this.files.keys());
-                // 確保包含當前檔案
-                if (!fileNames.includes(sourceFile.fileName)) {
-                    fileNames.push(sourceFile.fileName);
-                }
-                return fileNames;
-            },
-            getScriptVersion: (fileName) => {
-                const file = this.files.get(fileName);
-                return file ? String(file.version) : '0';
-            },
-            getScriptSnapshot: (fileName) => {
-                const file = this.files.get(fileName);
-                if (file) {
-                    return ts.ScriptSnapshot.fromString(file.content);
-                }
-                // 嘗試讀取實際檔案
-                try {
-                    const content = ts.sys.readFile(fileName);
-                    if (content) {
-                        return ts.ScriptSnapshot.fromString(content);
-                    }
-                }
-                catch {
-                    // 忽略錯誤
-                }
-                return undefined;
-            },
-            getCurrentDirectory: () => process.cwd(),
-            getCompilationSettings: () => ({
-                ...this.compilerOptions,
-                // 確保啟用必要的選項
-                allowNonTsExtensions: true,
-                noResolve: false,
-                noLib: false,
-                lib: this.compilerOptions.lib || ['lib.es2020.d.ts']
-            }),
-            getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options),
-            fileExists: (fileName) => {
-                return this.files.has(fileName) || (ts.sys.fileExists ? ts.sys.fileExists(fileName) : false);
-            },
-            readFile: (fileName) => {
-                const file = this.files.get(fileName);
-                if (file) {
-                    return file.content;
-                }
-                return ts.sys.readFile ? ts.sys.readFile(fileName) : undefined;
-            },
-            readDirectory: ts.sys.readDirectory ? ts.sys.readDirectory : () => [],
-            getDirectories: ts.sys.getDirectories ? ts.sys.getDirectories : () => [],
-            directoryExists: ts.sys.directoryExists ? ts.sys.directoryExists : () => false,
-            realpath: ts.sys.realpath ? ts.sys.realpath : (path) => path,
-            getNewLine: () => '\n'
-        };
-        // 建立 Language Service
-        this.languageService = ts.createLanguageService(this.languageServiceHost, ts.createDocumentRegistry());
-    }
-    /**
-     * 更新檔案內容
+     * 判斷檔案是否為測試檔案
      */
-    updateFile(fileName, content) {
-        const existing = this.files.get(fileName);
-        if (existing && existing.content === content) {
-            return;
-        }
-        this.files.set(fileName, {
-            version: existing ? existing.version + 1 : 0,
-            content
-        });
+    isTestFile(filePath) {
+        return /\.(test|spec)\.(ts|tsx)$/.test(filePath) ||
+            filePath.includes('/__tests__/') ||
+            filePath.includes('/__mocks__/');
     }
     /**
-     * 取得符號在檔案中的位置
+     * 取得符號的完整宣告範圍（包含 JSDoc、裝飾器）
+     * 委託給 DeclarationAnalyzer
      */
-    getSymbolPosition(symbol, sourceFile) {
-        const identifier = this.getIdentifierFromSymbolNode(symbol.tsNode);
-        if (!identifier) {
-            return undefined;
-        }
-        return identifier.getStart(sourceFile);
+    getFullDeclarationRange(code, symbolName, symbolType, startLine) {
+        return this.declarationAnalyzer.getFullDeclarationRange(code, symbolName, symbolType, startLine);
     }
     /**
-     * 根據檔案名稱取得 SourceFile
+     * 解析程式碼中的所有 import 宣告
+     * 委託給 DeclarationAnalyzer
      */
-    getSourceFileFromFileName(fileName) {
-        if (!this.languageService) {
-            return undefined;
-        }
-        const program = this.languageService.getProgram();
-        return program?.getSourceFile(fileName);
+    getImportDeclarations(code) {
+        return this.declarationAnalyzer.getImportDeclarations(code);
     }
     /**
-     * 取得節點的作用域容器
+     * 格式化函數簽章
+     * 委託給 DeclarationAnalyzer
      */
-    getScopeContainer(node) {
-        let current = node.parent;
-        while (current) {
-            if (ts.isFunctionDeclaration(current) ||
-                ts.isFunctionExpression(current) ||
-                ts.isArrowFunction(current) ||
-                ts.isMethodDeclaration(current) ||
-                ts.isConstructorDeclaration(current) ||
-                ts.isBlock(current) ||
-                ts.isSourceFile(current)) {
-                return current;
-            }
-            current = current.parent;
-        }
-        return node.getSourceFile();
+    formatSignature(code, functionName, line) {
+        return this.declarationAnalyzer.formatSignature(code, functionName, line);
     }
     /**
-     * 檢查節點是否在指定作用域鏈內
+     * 提取符號的 JSDoc 文件註解
+     * 委託給 DeclarationAnalyzer
      */
-    isInScopeChain(node, scopeContainer) {
-        let current = node.parent;
-        while (current) {
-            if (current === scopeContainer) {
-                return true;
-            }
-            current = current.parent;
-        }
-        return false;
+    getDocumentation(code, symbolName, symbolType, line) {
+        return this.declarationAnalyzer.getDocumentation(code, symbolName, symbolType, line);
     }
+    // ===== 設計模式識別支援 =====
     /**
-     * 檢查符號是否被遮蔽
+     * 識別程式碼中的設計模式
+     * 委託給 PatternAnalyzer
      */
-    isShadowed(node, originalIdentifier) {
-        const name = originalIdentifier.text;
-        let current = node.parent;
-        // 從 node 向上遍歷到 originalIdentifier 的作用域
-        while (current && current !== originalIdentifier.parent) {
-            // 檢查當前作用域是否有同名的宣告
-            if (ts.isFunctionDeclaration(current) ||
-                ts.isFunctionExpression(current) ||
-                ts.isArrowFunction(current) ||
-                ts.isMethodDeclaration(current)) {
-                // 檢查參數
-                if (current.parameters) {
-                    for (const param of current.parameters) {
-                        if (ts.isIdentifier(param.name) && param.name.text === name) {
-                            return true; // 被參數遮蔽
-                        }
-                    }
-                }
-            }
-            // 檢查區塊作用域中的宣告
-            if (ts.isBlock(current)) {
-                for (const statement of current.statements) {
-                    if (ts.isVariableStatement(statement)) {
-                        for (const decl of statement.declarationList.declarations) {
-                            if (ts.isIdentifier(decl.name) && decl.name.text === name) {
-                                // 確認這個宣告在 node 之前
-                                if (decl.pos < node.pos) {
-                                    return true; // 被區域變數遮蔽
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            current = current.parent;
-        }
-        return false;
+    identifyPatterns(code) {
+        return this.patternAnalyzer.identifyPatterns(code);
     }
+    // ===== 作用域感知符號查找支援 =====
     /**
-     * 判斷檔案是否為測試檔案
+     * 作用域感知的符號引用查找
+     * 委託給 ReferenceFinder
      */
-    isTestFile(filePath) {
-        return /\.(test|spec)\.(ts|tsx)$/.test(filePath) ||
-            filePath.includes('/__tests__/') ||
-            filePath.includes('/__mocks__/');
+    findScopedReferences(code, symbolName, options) {
+        return this.referenceFinder.findScopedReferences(code, symbolName, options);
     }
 }
 //# sourceMappingURL=parser.js.map