agent-ide 0.1.9 → 0.2.0

package/dist/interfaces/mcp/mcp.js

@@ -1,843 +0,0 @@
-/**
- * MCP (Model Context Protocol) 介面實作
- * 提供給 Claude Code 等 AI 工具使用的 MCP 工具
- */
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import { IndexEngine } from '../../core/indexing/index-engine.js';
-import { DependencyAnalyzer } from '../../core/dependency/dependency-analyzer.js';
-import { RenameEngine } from '../../core/rename/rename-engine.js';
-import { MoveService } from '../../core/move/move-service.js';
-import { ComplexityAnalyzer } from '../../core/analysis/complexity-analyzer.js';
-import { QualityMetricsAnalyzer } from '../../core/analysis/quality-metrics.js';
-import { createIndexConfig } from '../../core/indexing/types.js';
-import { ParserRegistry } from '../../infrastructure/parser/registry.js';
-import { TypeScriptParser } from '../../plugins/typescript/parser.js';
-import { JavaScriptParser } from '../../plugins/javascript/parser.js';
-import { glob } from 'glob';
-export class AgentIdeMCP {
-    indexEngine;
-    dependencyAnalyzer;
-    renameEngine;
-    importResolver;
-    parsersInitialized = false;
-    constructor() {
-        this.initializeParsers();
-    }
-    /**
-     * 初始化 Parser
-     */
-    initializeParsers() {
-        if (this.parsersInitialized) {
-            return;
-        }
-        const registry = ParserRegistry.getInstance();
-        // 註冊 TypeScript Parser
-        const tsParser = new TypeScriptParser();
-        registry.register(tsParser);
-        // 註冊 JavaScript Parser
-        const jsParser = new JavaScriptParser();
-        registry.register(jsParser);
-        this.parsersInitialized = true;
-    }
-    /**
-     * 獲取所有可用的 MCP 工具定義
-     */
-    getTools() {
-        return [
-            {
-                name: 'code_index',
-                description: '建立和查詢程式碼索引，提供符號搜尋和檔案索引功能',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        action: {
-                            type: 'string',
-                            enum: ['create', 'update', 'search', 'stats'],
-                            description: '操作類型: create=建立索引, update=更新索引, search=搜尋符號, stats=獲取統計'
-                        },
-                        path: {
-                            type: 'string',
-                            description: '專案路徑（用於 create/update）'
-                        },
-                        query: {
-                            type: 'string',
-                            description: '搜尋查詢（用於 search）'
-                        },
-                        extensions: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: '包含的檔案副檔名',
-                            default: ['.ts', '.js', '.tsx', '.jsx']
-                        },
-                        excludePatterns: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: '排除模式',
-                            default: ['node_modules/**', '*.test.*']
-                        }
-                    },
-                    required: ['action']
-                }
-            },
-            {
-                name: 'code_rename',
-                description: '執行安全的程式碼重新命名，自動更新所有引用',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        type: {
-                            type: 'string',
-                            enum: ['variable', 'function', 'class', 'interface', 'file'],
-                            description: '要重新命名的符號類型'
-                        },
-                        from: {
-                            type: 'string',
-                            description: '原始名稱'
-                        },
-                        to: {
-                            type: 'string',
-                            description: '新名稱'
-                        },
-                        path: {
-                            type: 'string',
-                            description: '檔案或目錄路徑',
-                            default: '.'
-                        },
-                        preview: {
-                            type: 'boolean',
-                            description: '是否只預覽變更而不執行',
-                            default: false
-                        }
-                    },
-                    required: ['type', 'from', 'to']
-                }
-            },
-            {
-                name: 'code_move',
-                description: '移動檔案或目錄，自動更新 import 路徑',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        source: {
-                            type: 'string',
-                            description: '來源路徑'
-                        },
-                        target: {
-                            type: 'string',
-                            description: '目標路徑'
-                        },
-                        updateImports: {
-                            type: 'boolean',
-                            description: '是否自動更新 import 路徑',
-                            default: true
-                        },
-                        preview: {
-                            type: 'boolean',
-                            description: '是否只預覽變更而不執行',
-                            default: false
-                        }
-                    },
-                    required: ['source', 'target']
-                }
-            },
-            {
-                name: 'code_search',
-                description: '搜尋程式碼中的符號、文字或模式',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        query: {
-                            type: 'string',
-                            description: '搜尋查詢'
-                        },
-                        type: {
-                            type: 'string',
-                            enum: ['symbol', 'text', 'regex'],
-                            description: '搜尋類型',
-                            default: 'symbol'
-                        },
-                        fileFilter: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: '檔案類型過濾'
-                        },
-                        limit: {
-                            type: 'number',
-                            description: '結果數量限制',
-                            default: 50
-                        }
-                    },
-                    required: ['query']
-                }
-            },
-            {
-                name: 'code_analyze',
-                description: '分析程式碼品質、複雜度和相關指標',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        path: {
-                            type: 'string',
-                            description: '分析路徑',
-                            default: '.'
-                        },
-                        type: {
-                            type: 'string',
-                            enum: ['complexity', 'dependencies', 'quality', 'all'],
-                            description: '分析類型',
-                            default: 'all'
-                        },
-                        format: {
-                            type: 'string',
-                            enum: ['json', 'summary'],
-                            description: '輸出格式',
-                            default: 'summary'
-                        }
-                    }
-                }
-            },
-            {
-                name: 'code_deps',
-                description: '分析程式碼依賴關係，檢測循環依賴和影響範圍',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        path: {
-                            type: 'string',
-                            description: '分析路徑',
-                            default: '.'
-                        },
-                        type: {
-                            type: 'string',
-                            enum: ['graph', 'cycles', 'impact', 'all'],
-                            description: '分析類型',
-                            default: 'all'
-                        },
-                        file: {
-                            type: 'string',
-                            description: '特定檔案分析（用於影響分析）'
-                        },
-                        format: {
-                            type: 'string',
-                            enum: ['json', 'dot', 'summary'],
-                            description: '輸出格式',
-                            default: 'summary'
-                        }
-                    }
-                }
-            },
-            {
-                name: 'parser_plugins',
-                description: '管理 Parser 插件，查看和操作插件狀態',
-                parameters: {
-                    type: 'object',
-                    properties: {
-                        action: {
-                            type: 'string',
-                            enum: ['list', 'info', 'enable', 'disable'],
-                            description: '操作類型'
-                        },
-                        plugin: {
-                            type: 'string',
-                            description: '插件名稱（用於 info/enable/disable）'
-                        },
-                        filter: {
-                            type: 'string',
-                            enum: ['all', 'enabled', 'disabled'],
-                            description: '過濾條件（用於 list）',
-                            default: 'all'
-                        }
-                    },
-                    required: ['action']
-                }
-            }
-        ];
-    }
-    /**
-     * 執行 MCP 工具
-     */
-    async executeTool(toolName, parameters) {
-        try {
-            switch (toolName) {
-                case 'code_index':
-                    return await this.handleCodeIndex(parameters);
-                case 'code_rename':
-                    return await this.handleCodeRename(parameters);
-                case 'code_move':
-                    return await this.handleCodeMove(parameters);
-                case 'code_search':
-                    return await this.handleCodeSearch(parameters);
-                case 'code_analyze':
-                    return await this.handleCodeAnalyze(parameters);
-                case 'code_deps':
-                    return await this.handleCodeDeps(parameters);
-                case 'parser_plugins':
-                    return await this.handleParserPlugins(parameters);
-                default:
-                    return {
-                        success: false,
-                        error: `未知的工具: ${toolName}`
-                    };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error)
-            };
-        }
-    }
-    // 工具處理方法
-    async handleCodeIndex(params) {
-        // 支援舊參數名稱以兼容測試
-        const action = params.action || 'create';
-        const projectPath = params.path;
-        const query = params.query;
-        const extensions = params.extensions || params.include;
-        const excludePatterns = params.excludePatterns || params.exclude;
-        switch (action) {
-            case 'create':
-            case 'update':
-                if (!projectPath) {
-                    return { success: false, error: '需要指定專案路徑' };
-                }
-                try {
-                    const config = createIndexConfig(projectPath, {
-                        includeExtensions: extensions || ['.ts', '.js', '.tsx', '.jsx'],
-                        excludePatterns: excludePatterns || ['node_modules/**', '*.test.*']
-                    });
-                    this.indexEngine = new IndexEngine(config);
-                    await this.indexEngine.indexProject(projectPath);
-                    const stats = await this.indexEngine.getStats();
-                    return {
-                        success: true,
-                        data: {
-                            action: action === 'create' ? '建立' : '更新',
-                            filesIndexed: stats.totalFiles,
-                            symbolsFound: stats.totalSymbols,
-                            stats: {
-                                totalFiles: stats.totalFiles,
-                                totalSymbols: stats.totalSymbols,
-                                indexedAt: new Date().toISOString()
-                            }
-                        }
-                    };
-                }
-                catch (error) {
-                    return {
-                        success: false,
-                        error: `建立索引失敗: ${error instanceof Error ? error.message : String(error)}`
-                    };
-                }
-            case 'search':
-                if (!query) {
-                    return { success: false, error: '需要指定搜尋查詢' };
-                }
-                if (!this.indexEngine) {
-                    return { success: false, error: '索引尚未建立，請先執行 create 操作' };
-                }
-                const results = await this.indexEngine.findSymbol(query);
-                return {
-                    success: true,
-                    data: {
-                        query,
-                        results: results.map(r => ({
-                            name: r.symbol.name,
-                            type: r.symbol.type,
-                            file: r.fileInfo.filePath,
-                            line: r.symbol.location.range.start.line,
-                            column: r.symbol.location.range.start.column,
-                            score: r.score
-                        }))
-                    }
-                };
-            case 'stats':
-                if (!this.indexEngine) {
-                    return { success: false, error: '索引尚未建立' };
-                }
-                const currentStats = await this.indexEngine.getStats();
-                return {
-                    success: true,
-                    data: currentStats
-                };
-            default:
-                return { success: false, error: `未知的索引操作: ${action}` };
-        }
-    }
-    async handleCodeRename(params) {
-        // 支援舊參數名稱以兼容測試
-        const type = params.type;
-        const from = params.from || params.symbol;
-        const to = params.to || params.newName;
-        const workspacePath = params.path || '.';
-        const preview = params.preview !== false; // 預設為 true
-        if (!from || !to) {
-            return { success: false, error: '需要指定原始名稱和新名稱' };
-        }
-        try {
-            // 初始化索引引擎
-            if (!this.indexEngine) {
-                const config = createIndexConfig(workspacePath, {
-                    includeExtensions: ['.ts', '.tsx', '.js', '.jsx'],
-                    excludePatterns: ['node_modules/**', '*.test.*']
-                });
-                this.indexEngine = new IndexEngine(config);
-                await this.indexEngine.indexProject(workspacePath);
-            }
-            // 初始化重新命名引擎
-            if (!this.renameEngine) {
-                this.renameEngine = new RenameEngine();
-            }
-            // 查找符號
-            const searchResults = await this.indexEngine.findSymbol(from);
-            if (searchResults.length === 0) {
-                return {
-                    success: true, // 為了測試相容性，返回 success: true
-                    data: {
-                        changes: [],
-                        filesAffected: 0
-                    }
-                };
-            }
-            // 準備變更列表
-            const changes = searchResults.map(r => ({
-                file: r.fileInfo.filePath,
-                line: r.symbol.location.range.start.line,
-                column: r.symbol.location.range.start.column,
-                content: `${from} → ${to}`,
-                oldName: from,
-                newName: to
-            }));
-            return {
-                success: true,
-                data: {
-                    changes,
-                    filesAffected: new Set(changes.map(c => c.file)).size,
-                    preview
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `重新命名失敗: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    async handleCodeMove(params) {
-        const { source, target, updateImports = true, preview = false } = params;
-        if (!source || !target) {
-            return { success: false, error: '需要指定來源路徑和目標路徑' };
-        }
-        try {
-            const workspacePath = process.cwd();
-            const sourcePath = path.isAbsolute(source) ? source : path.resolve(workspacePath, source);
-            const targetPath = path.isAbsolute(target) ? target : path.resolve(workspacePath, target);
-            const moveService = new MoveService();
-            const result = await moveService.moveFile({ source: sourcePath, target: targetPath, updateImports }, { preview, projectRoot: workspacePath });
-            if (!result.success) {
-                return {
-                    success: false,
-                    error: result.error || result.message
-                };
-            }
-            return {
-                success: true,
-                data: {
-                    from: this.formatRelativePath(sourcePath, workspacePath),
-                    to: this.formatRelativePath(targetPath, workspacePath),
-                    filesUpdated: result.pathUpdates.length,
-                    importUpdates: result.pathUpdates.map(update => ({
-                        file: this.formatRelativePath(update.filePath, workspacePath),
-                        line: update.line,
-                        oldImport: update.oldImport,
-                        newImport: update.newImport
-                    })),
-                    preview,
-                    message: result.message
-                }
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `移動檔案失敗: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    async handleCodeSearch(params) {
-        const query = params.query;
-        const searchType = params.type || 'text';
-        const workspacePath = params.path || '.';
-        const fileFilter = params.fileFilter;
-        const limit = params.limit || 50;
-        if (!query) {
-            return { success: false, error: '需要指定搜尋查詢' };
-        }
-        try {
-            // 初始化索引引擎（如果需要）
-            if (!this.indexEngine && searchType === 'symbol') {
-                const config = createIndexConfig(workspacePath, {
-                    includeExtensions: ['.ts', '.tsx', '.js', '.jsx'],
-                    excludePatterns: ['node_modules/**', '*.test.*']
-                });
-                this.indexEngine = new IndexEngine(config);
-                await this.indexEngine.indexProject(workspacePath);
-            }
-            if (searchType === 'symbol' && this.indexEngine) {
-                // 符號搜尋
-                const results = await this.indexEngine.findSymbol(query);
-                return {
-                    success: true,
-                    data: {
-                        query,
-                        type: searchType,
-                        results: results.slice(0, limit).map(r => ({
-                            file: this.formatRelativePath(r.fileInfo.filePath, workspacePath),
-                            line: r.symbol.location.range.start.line,
-                            column: r.symbol.location.range.start.column,
-                            content: r.symbol.name,
-                            type: r.symbol.type,
-                            score: r.score
-                        }))
-                    }
-                };
-            }
-            else {
-                // 文字搜尋
-                const files = await glob('**/*.{ts,tsx,js,jsx}', {
-                    cwd: workspacePath,
-                    ignore: ['node_modules/**', 'dist/**', '*.test.*', '*.d.ts'],
-                    absolute: true
-                });
-                const results = [];
-                for (const file of files.slice(0, 100)) {
-                    try {
-                        const content = await fs.readFile(file, 'utf-8');
-                        const lines = content.split('\n');
-                        lines.forEach((line, index) => {
-                            if (line.includes(query)) {
-                                results.push({
-                                    file: this.formatRelativePath(file, workspacePath),
-                                    line: index + 1,
-                                    column: line.indexOf(query) + 1,
-                                    content: line.trim()
-                                });
-                            }
-                        });
-                    }
-                    catch (error) {
-                        // 忽略讀取錯誤
-                    }
-                    if (results.length >= limit) {
-                        break;
-                    }
-                }
-                return {
-                    success: true,
-                    data: {
-                        query,
-                        type: searchType,
-                        results: results.slice(0, limit)
-                    }
-                };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `搜尋失敗: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    async handleCodeAnalyze(params) {
-        const analyzePath = params.path || '.';
-        const analyzeType = params.type || 'all';
-        const format = params.format || 'summary';
-        try {
-            const workspacePath = process.cwd();
-            const targetPath = path.isAbsolute(analyzePath)
-                ? analyzePath
-                : path.resolve(workspacePath, analyzePath);
-            const results = {
-                path: this.formatRelativePath(targetPath, workspacePath),
-                type: analyzeType,
-                format
-            };
-            // 檢查路徑是否存在
-            try {
-                await fs.access(targetPath);
-            }
-            catch {
-                return { success: false, error: `路徑不存在: ${analyzePath}` };
-            }
-            const stat = await fs.stat(targetPath);
-            if (stat.isFile()) {
-                // 分析單一檔案
-                const content = await fs.readFile(targetPath, 'utf-8');
-                if (analyzeType === 'complexity' || analyzeType === 'all') {
-                    const complexityAnalyzer = new ComplexityAnalyzer();
-                    const complexityResult = await complexityAnalyzer.analyzeCode(content);
-                    results.complexity = complexityResult;
-                }
-                if (analyzeType === 'quality' || analyzeType === 'all') {
-                    const qualityAnalyzer = new QualityMetricsAnalyzer();
-                    const qualityResult = await qualityAnalyzer.assess(content);
-                    results.quality = qualityResult;
-                }
-            }
-            else if (stat.isDirectory()) {
-                // 分析目錄中的檔案
-                const files = await glob('**/*.{ts,tsx,js,jsx}', {
-                    cwd: targetPath,
-                    ignore: ['node_modules/**', 'dist/**', '*.test.*', '*.d.ts'],
-                    absolute: true
-                });
-                const fileResults = [];
-                for (const file of files.slice(0, 10)) {
-                    try {
-                        const content = await fs.readFile(file, 'utf-8');
-                        const fileResult = {
-                            file: this.formatRelativePath(file, workspacePath)
-                        };
-                        if (analyzeType === 'complexity' || analyzeType === 'all') {
-                            const complexityAnalyzer = new ComplexityAnalyzer();
-                            fileResult.complexity = await complexityAnalyzer.analyzeCode(content);
-                        }
-                        if (analyzeType === 'quality' || analyzeType === 'all') {
-                            const qualityAnalyzer = new QualityMetricsAnalyzer();
-                            fileResult.quality = await qualityAnalyzer.assess(content);
-                        }
-                        fileResults.push(fileResult);
-                    }
-                    catch (error) {
-                        // 忽略讀取錯誤
-                    }
-                }
-                results.files = fileResults;
-                results.totalFiles = fileResults.length;
-            }
-            if (format === 'summary') {
-                return {
-                    success: true,
-                    data: {
-                        ...results,
-                        summary: this.formatAnalysisSummary(results)
-                    }
-                };
-            }
-            return {
-                success: true,
-                data: results
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `分析失敗: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    formatAnalysisSummary(results) {
-        const lines = [];
-        if (results.complexity) {
-            lines.push(`複雜度: ${results.complexity.evaluation} (循環: ${results.complexity.cyclomaticComplexity}, 認知: ${results.complexity.cognitiveComplexity})`);
-        }
-        if (results.quality) {
-            lines.push(`品質: ${results.quality.grade} (可維護性指數: ${results.quality.maintainabilityIndex})`);
-            if (results.quality.codeSmells?.length > 0) {
-                lines.push(`程式碼異味: ${results.quality.codeSmells.length} 個`);
-            }
-        }
-        if (results.files) {
-            const avgComplexity = results.files.reduce((sum, f) => sum + (f.complexity?.cyclomaticComplexity || 0), 0) / results.files.length;
-            lines.push(`平均循環複雜度: ${avgComplexity.toFixed(2)}`);
-        }
-        return lines.join('\n');
-    }
-    async handleCodeDeps(params) {
-        const analyzePath = params.path || '.';
-        const analyzeType = params.type || 'all';
-        const targetFile = params.file;
-        const format = params.format || 'summary';
-        try {
-            const workspacePath = process.cwd();
-            const projectPath = path.isAbsolute(analyzePath)
-                ? analyzePath
-                : path.resolve(workspacePath, analyzePath);
-            // 檢查路徑是否存在
-            try {
-                await fs.access(projectPath);
-            }
-            catch {
-                return { success: false, error: `路徑不存在: ${analyzePath}` };
-            }
-            const depAnalyzer = new DependencyAnalyzer({
-                includeNodeModules: false,
-                excludePatterns: ['node_modules', 'dist', '*.test.*', '*.d.ts'],
-                includePatterns: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx']
-            });
-            const results = {
-                path: this.formatRelativePath(projectPath, workspacePath),
-                type: analyzeType,
-                format
-            };
-            if (analyzeType === 'graph' || analyzeType === 'all') {
-                // 分析依賴圖
-                await depAnalyzer.analyzeProject(projectPath);
-                const stats = depAnalyzer.getStats();
-                results.graph = {
-                    totalFiles: stats.totalFiles,
-                    totalDependencies: stats.totalDependencies,
-                    averageDependenciesPerFile: stats.averageDependenciesPerFile,
-                    maxDependenciesInFile: stats.maxDependenciesInFile
-                };
-            }
-            if (analyzeType === 'cycles' || analyzeType === 'all') {
-                // 檢測循環依賴
-                await depAnalyzer.analyzeProject(projectPath);
-                const stats = depAnalyzer.getStats();
-                results.cycles = {
-                    circularDependencies: stats.circularDependencies,
-                    orphanedFiles: stats.orphanedFiles
-                };
-            }
-            if ((analyzeType === 'impact' || analyzeType === 'all') && targetFile) {
-                // 影響分析
-                const filePath = path.isAbsolute(targetFile)
-                    ? targetFile
-                    : path.resolve(projectPath, targetFile);
-                try {
-                    await fs.access(filePath);
-                    await depAnalyzer.analyzeProject(projectPath);
-                    const impactAnalysis = depAnalyzer.getImpactAnalysis(filePath);
-                    results.impact = {
-                        targetFile: this.formatRelativePath(filePath, workspacePath),
-                        directlyAffected: impactAnalysis.directlyAffected.length,
-                        transitivelyAffected: impactAnalysis.transitivelyAffected.length,
-                        affectedTests: impactAnalysis.affectedTests.length,
-                        impactScore: impactAnalysis.impactScore,
-                        directlyAffectedFiles: impactAnalysis.directlyAffected.map(f => this.formatRelativePath(f, workspacePath)).slice(0, 10)
-                    };
-                }
-                catch {
-                    results.impact = { error: `檔案不存在: ${targetFile}` };
-                }
-            }
-            if (format === 'summary') {
-                return {
-                    success: true,
-                    data: {
-                        ...results,
-                        summary: this.formatDependencySummary(results)
-                    }
-                };
-            }
-            return {
-                success: true,
-                data: results
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `依賴分析失敗: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-    formatDependencySummary(results) {
-        const lines = [];
-        if (results.graph) {
-            lines.push(`總檔案數: ${results.graph.totalFiles}`);
-            lines.push(`總依賴數: ${results.graph.totalDependencies}`);
-            lines.push(`平均每檔案依賴數: ${results.graph.averageDependenciesPerFile}`);
-        }
-        if (results.cycles) {
-            lines.push(`循環依賴: ${results.cycles.circularDependencies} 個`);
-            lines.push(`孤立檔案: ${results.cycles.orphanedFiles} 個`);
-        }
-        if (results.impact && !results.impact.error) {
-            lines.push(`直接影響: ${results.impact.directlyAffected} 個檔案`);
-            lines.push(`間接影響: ${results.impact.transitivelyAffected} 個檔案`);
-            lines.push(`影響分數: ${results.impact.impactScore.toFixed(2)}`);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * 格式化相對路徑
-     */
-    formatRelativePath(filePath, basePath) {
-        try {
-            const relativePath = path.relative(basePath, filePath);
-            return relativePath.startsWith('..') ? filePath : relativePath;
-        }
-        catch {
-            return filePath;
-        }
-    }
-    async handleParserPlugins(params) {
-        const { action, plugin, filter } = params;
-        try {
-            const registry = ParserRegistry.getInstance();
-            switch (action) {
-                case 'list':
-                    const parsers = registry.listParsers();
-                    return {
-                        success: true,
-                        data: {
-                            plugins: parsers.map(p => ({
-                                name: p.name,
-                                version: p.version,
-                                supportedExtensions: p.supportedExtensions,
-                                supportedLanguages: p.supportedLanguages,
-                                registeredAt: p.registeredAt.toISOString()
-                            })),
-                            total: parsers.length
-                        }
-                    };
-                case 'info':
-                    if (!plugin) {
-                        return { success: false, error: '需要指定插件名稱' };
-                    }
-                    const pluginInstance = registry.getParserByName(plugin);
-                    if (!pluginInstance) {
-                        return { success: false, error: `找不到插件: ${plugin}` };
-                    }
-                    const pluginInfo = registry.listParsers().find(p => p.name === plugin);
-                    if (!pluginInfo) {
-                        return { success: false, error: `找不到插件資訊: ${plugin}` };
-                    }
-                    // 避免循環引用，只返回必要的資訊
-                    return {
-                        success: true,
-                        data: {
-                            name: pluginInfo.name,
-                            version: pluginInfo.version,
-                            supportedExtensions: pluginInfo.supportedExtensions,
-                            supportedLanguages: pluginInfo.supportedLanguages,
-                            registeredAt: pluginInfo.registeredAt.toISOString()
-                        }
-                    };
-                case 'enable':
-                case 'disable':
-                    return {
-                        success: true,
-                        data: {
-                            message: `插件 ${action} 功能開發中`,
-                            plugin
-                        }
-                    };
-                default:
-                    return { success: false, error: `未知的插件操作: ${action}` };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `插件操作失敗: ${error instanceof Error ? error.message : String(error)}`
-            };
-        }
-    }
-}
-//# sourceMappingURL=mcp.js.map