agent-ide 0.1.10 → 0.3.3

package/dist/interfaces/cli/cli.js

@@ -3,19 +3,13 @@
  * 提供命令列介面來操作 Agent IDE 功能
  */
 import { Command } from 'commander';
-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/index.js';
-import { SearchService } from '../../core/search/service.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 { ComplexityAnalyzer } from '../../core/analysis/complexity-analyzer.js';
-import { DeadCodeDetector } from '../../core/analysis/dead-code-detector.js';
-import { OutputFormatter, OutputFormat } from './output-formatter.js';
-import * as fs from 'fs/promises';
+import { SwiftParser } from '../../plugins/swift/parser.js';
+import { PythonParser } from '../../plugins/python/parser.js';
+import { FileSystem } from '../../infrastructure/storage/index.js';
+import { setupShiftCommand, setupMoveCommand, setupMoveMemberCommand, setupRenameCommand, setupChangeSignatureCommand, setupExtractCommand, setupInlineCommand, setupSearchCommand, setupAnalyzeCommand, setupDepsCommand, setupSnapshotCommand } from '../cli/commands/index.js';
 import { readFileSync } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
@@ -33,17 +27,24 @@ catch {
 }
 export class AgentIdeCLI {
     program;
-    indexEngine;
-    dependencyAnalyzer;
-    renameEngine;
-    importResolver;
-    moveService;
-    searchService;
-    constructor() {
+    fileSystem;
+    /**
+     * 建立 CLI 實例
+     * @param fileSystem - 檔案系統實例（可選，預設使用真實檔案系統）
+     */
+    constructor(fileSystem) {
         this.program = new Command();
+        // eslint-disable-next-line custom/no-default-instance-in-constructor -- CLI 入口點需要預設 FileSystem
+        this.fileSystem = fileSystem ?? new FileSystem();
         this.setupCommands();
         this.initializeParsers();
     }
+    /**
+     * 建立測試用 CLI 實例
+     */
+    static createForTesting(fileSystem) {
+        return new AgentIdeCLI(fileSystem);
+    }
     /**
      * 執行 CLI 程式
      */
@@ -91,6 +92,32 @@ export class AgentIdeCLI {
                 console.debug('JavaScript parser loading failed:', jsError);
                 console.debug('JavaScript Parser initialization warning:', jsError);
             }
+            // 嘗試註冊內建的 Swift Parser
+            try {
+                // 解析 Swift CLI Bridge 路徑
+                const swiftBridgePath = path.resolve(__dirname, '../../plugins/swift/swift-bridge/swift-parser');
+                const swiftParser = new SwiftParser(swiftBridgePath);
+                if (!registry.getParserByName('swift')) {
+                    registry.register(swiftParser);
+                }
+            }
+            catch (swiftError) {
+                // 如果 Swift Parser 載入失敗，記錄錯誤
+                console.debug('Swift parser loading failed:', swiftError);
+                console.debug('Swift Parser initialization warning:', swiftError);
+            }
+            // 嘗試註冊內建的 Python Parser
+            try {
+                const pythonParser = new PythonParser();
+                if (!registry.getParserByName('python')) {
+                    registry.register(pythonParser);
+                }
+            }
+            catch (pythonError) {
+                // 如果 Python Parser 載入失敗，記錄錯誤
+                console.debug('Python parser loading failed:', pythonError);
+                console.debug('Python Parser initialization warning:', pythonError);
+            }
         }
         catch (error) {
             // 靜默處理初始化錯誤，避免影響 CLI 啟動
@@ -102,1180 +129,32 @@ export class AgentIdeCLI {
             .name('agent-ide')
             .description('程式碼智能工具集 for AI Agents')
             .version(packageVersion);
-        this.setupIndexCommand();
-        this.setupRenameCommand();
-        this.setupRefactorCommand();
-        this.setupMoveCommand();
-        this.setupSearchCommand();
-        this.setupAnalyzeCommand();
-        this.setupDepsCommand();
-        this.setupPluginsCommand();
-    }
-    setupIndexCommand() {
-        this.program
-            .command('index')
-            .description('建立或更新程式碼索引')
-            .option('-p, --path <path>', '專案路徑', process.cwd())
-            .option('-u, --update', '增量更新索引')
-            .option('-e, --extensions <exts>', '包含的檔案副檔名', '.ts,.js,.tsx,.jsx')
-            .option('-x, --exclude <patterns>', '排除模式', 'node_modules/**,*.test.*')
-            .option('--format <format>', '輸出格式 (markdown|plain|json|minimal)', 'plain')
-            .action(async (options) => {
-            await this.handleIndexCommand(options);
-        });
-    }
-    setupRenameCommand() {
-        this.program
-            .command('rename')
-            .description('重新命名程式碼元素')
-            .option('-t, --type <type>', '符號類型 (variable|function|class|interface)', 'variable')
-            .option('-s, --symbol <name>', '要重新命名的符號')
-            .option('-f, --from <name>', '原始名稱（--symbol 的別名）')
-            .option('-n, --new-name <name>', '新名稱')
-            .option('-o, --to <name>', '新名稱（--new-name 的別名）')
-            .option('-p, --path <path>', '檔案或目錄路徑', '.')
-            .option('--preview', '預覽變更而不執行')
-            .option('--format <format>', '輸出格式 (markdown|plain|json|minimal)', 'plain')
-            .action(async (options) => {
-            await this.handleRenameCommand(options);
-        });
-    }
-    setupRefactorCommand() {
-        this.program
-            .command('refactor <action>')
-            .description('重構程式碼 (extract-function | inline-function)')
-            .option('-f, --file <file>', '檔案路徑')
-            .option('-s, --start-line <line>', '起始行號')
-            .option('-e, --end-line <line>', '結束行號')
-            .option('-n, --function-name <name>', '函式名稱')
-            .option('-t, --target-file <file>', '目標檔案路徑（跨檔案提取）')
-            .option('-p, --path <path>', '專案路徑', '.')
-            .option('--preview', '預覽變更而不執行')
-            .option('--format <format>', '輸出格式 (markdown|plain|json|minimal)', 'plain')
-            .action(async (action, options) => {
-            await this.handleRefactorCommand(action, options);
-        });
-    }
-    setupMoveCommand() {
-        this.program
-            .command('move')
-            .description('移動檔案或目錄')
-            .argument('<source>', '來源路徑')
-            .argument('<target>', '目標路徑')
-            .option('--update-imports', '自動更新 import 路徑', true)
-            .option('--preview', '預覽變更而不執行')
-            .option('--format <format>', '輸出格式 (markdown|plain|json|minimal)', 'plain')
-            .action(async (source, target, options) => {
-            await this.handleMoveCommand(source, target, options);
-        });
-    }
-    setupSearchCommand() {
-        this.program
-            .command('search')
-            .description('搜尋程式碼')
-            .argument('<query>', '搜尋查詢')
-            .option('-t, --type <type>', '搜尋類型 (text|regex|fuzzy)', 'text')
-            .option('-p, --path <path>', '搜尋路徑', '.')
-            .option('-e, --extensions <exts>', '檔案副檔名', '.ts,.js,.tsx,.jsx')
-            .option('-l, --limit <num>', '結果數量限制', '50')
-            .option('-c, --context <lines>', '上下文行數', '2')
-            .option('--case-sensitive', '大小寫敏感')
-            .option('--whole-word', '全字匹配')
-            .option('--multiline', '多行匹配')
-            .option('--include <patterns>', '包含模式')
-            .option('--exclude <patterns>', '排除模式', 'node_modules/**,*.test.*')
-            .option('--format <format>', '輸出格式 (list|json|minimal)', 'list')
-            .action(async (query, options) => {
-            await this.handleSearchCommand(query, options);
-        });
-    }
-    setupAnalyzeCommand() {
-        this.program
-            .command('analyze [type]')
-            .description('分析程式碼品質')
-            .option('-p, --path <path>', '分析路徑', '.')
-            .option('--pattern <pattern>', '分析模式')
-            .option('--format <format>', '輸出格式 (json|table|summary)', 'summary')
-            .option('--all', '顯示所有掃描結果（預設只顯示有問題的項目）', false)
-            .action(async (type, options) => {
-            await this.handleAnalyzeCommand(type, options);
-        });
-    }
-    setupDepsCommand() {
-        this.program
-            .command('deps')
-            .description('分析依賴關係')
-            .option('-p, --path <path>', '分析路徑', '.')
-            .option('-t, --type <type>', '分析類型 (graph|cycles|impact)')
-            .option('-f, --file <file>', '特定檔案分析')
-            .option('--format <format>', '輸出格式 (json|dot|summary)', 'summary')
-            .option('--all', '顯示完整依賴圖（預設只顯示循環依賴和孤立檔案）', false)
-            .action(async (options) => {
-            await this.handleDepsCommand(options);
-        });
-    }
-    setupPluginsCommand() {
-        const pluginsCmd = this.program
-            .command('plugins')
-            .description('管理 Parser 插件');
-        pluginsCmd
-            .command('list')
-            .option('--enabled', '只顯示啟用的插件')
-            .option('--disabled', '只顯示停用的插件')
-            .description('列出所有插件')
-            .action(async (options) => {
-            await this.handlePluginsListCommand(options);
-        });
-        pluginsCmd
-            .command('info <plugin>')
-            .description('顯示插件資訊')
-            .action(async (pluginName) => {
-            await this.handlePluginInfoCommand(pluginName);
-        });
-    }
-    // Command handlers
-    async handleIndexCommand(options) {
-        const formatter = this.createFormatter(options.format);
-        const startTime = Date.now();
-        if (options.format !== 'json' && options.format !== 'minimal') {
-            console.log(formatter.formatTitle('程式碼索引', 1));
-            console.log('\n🔍 開始建立程式碼索引...\n');
-        }
-        try {
-            const config = createIndexConfig(options.path, {
-                includeExtensions: options.extensions.split(','),
-                excludePatterns: options.exclude.split(',')
-            });
-            this.indexEngine = new IndexEngine(config);
-            if (options.update) {
-                if (options.format !== 'json' && options.format !== 'minimal') {
-                    console.log('📝 執行增量索引更新...');
-                }
-            }
-            else {
-                await this.indexEngine.indexProject(options.path);
-            }
-            const stats = await this.indexEngine.getStats();
-            const duration = Date.now() - startTime;
-            const statsData = {
-                檔案數: stats.totalFiles,
-                符號數: stats.totalSymbols,
-                '執行時間(ms)': duration
-            };
-            if (options.format === 'json') {
-                console.log(formatter.formatSuccess('索引完成', statsData));
-            }
-            else if (options.format === 'minimal') {
-                console.log(`index:success files=${stats.totalFiles} symbols=${stats.totalSymbols} time=${duration}ms`);
-            }
-            else {
-                console.log('\n' + formatter.formatSuccess('索引完成'));
-                console.log('\n' + formatter.formatTitle('統計資訊', 2));
-                console.log(formatter.formatStats(statsData));
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (options.format === 'json') {
-                console.error(formatter.formatError(errorMessage));
-            }
-            else if (options.format === 'minimal') {
-                console.error(`index:error ${errorMessage}`);
-            }
-            else {
-                console.error('\n' + formatter.formatError(`索引失敗: ${errorMessage}`));
-            }
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-    }
-    async handleRenameCommand(options) {
-        // 支援多種參數名稱
-        const from = options.symbol || options.from;
-        const to = options.newName || options.to;
-        if (!from || !to) {
-            console.error('❌ 必須指定符號名稱和新名稱');
-            console.error('   使用方式: agent-ide rename --symbol <name> --new-name <name>');
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-            return;
-        }
-        console.log(`🔄 重新命名 ${from} → ${to}`);
-        try {
-            const workspacePath = options.path || process.cwd();
-            // 初始化索引引擎（每次都重新索引以確保資料是最新的）
-            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();
-            }
-            // 1. 查找符號
-            console.log(`🔍 查找符號 "${from}"...`);
-            const searchResults = await this.indexEngine.findSymbol(from);
-            if (searchResults.length === 0) {
-                console.log(`❌ 找不到符號 "${from}"`);
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-                return;
-            }
-            if (searchResults.length > 1) {
-                console.log('⚠️  找到多個符號，使用第一個:');
-                searchResults.forEach((result, index) => {
-                    console.log(`   ${index + 1}. ${result.symbol.name} 在 ${result.symbol.location.filePath}:${result.symbol.location.range.start.line}`);
-                });
-            }
-            const targetSymbol = searchResults[0].symbol;
-            // 2. 預覽變更
-            if (options.preview) {
-                console.log('🔍 預覽變更...');
-                try {
-                    // 取得所有專案檔案以進行跨檔案引用查找
-                    const allProjectFiles = await this.getAllProjectFiles(options.path || workspacePath);
-                    const preview = await this.renameEngine.previewRename({
-                        symbol: targetSymbol,
-                        newName: to,
-                        filePaths: allProjectFiles
-                    });
-                    console.log('📝 預計變更:');
-                    console.log(`   檔案數: ${preview.affectedFiles.length}`);
-                    console.log(`   操作數: ${preview.operations.length}`);
-                    if (preview.conflicts.length > 0) {
-                        console.log('⚠️  發現衝突:');
-                        preview.conflicts.forEach(conflict => {
-                            console.log(`   - ${conflict.message}`);
-                        });
-                    }
-                    preview.operations.forEach(op => {
-                        console.log(`   ${op.filePath}: "${op.oldText}" → "${op.newText}"`);
-                    });
-                    console.log('✅ 預覽完成');
-                    return;
-                }
-                catch (previewError) {
-                    console.error('❌ 預覽失敗:', previewError instanceof Error ? previewError.message : previewError);
-                    if (process.env.NODE_ENV !== 'test') {
-                        process.exit(1);
-                    }
-                }
-            }
-            // 3. 執行重新命名（處理跨檔案引用）
-            console.log('✏️  執行重新命名...');
-            // 取得所有專案檔案（使用與 preview 相同的邏輯）
-            const allProjectFiles = await this.getAllProjectFiles(options.path || workspacePath);
-            // 使用 renameEngine 執行重新命名（與 preview 使用相同的引擎）
-            const renameResult = await this.renameEngine.rename({
-                symbol: targetSymbol,
-                newName: to,
-                filePaths: allProjectFiles
-            });
-            if (renameResult.success) {
-                console.log('✅ 重新命名成功!');
-                console.log(`📊 統計: ${renameResult.affectedFiles.length} 檔案, ${renameResult.operations.length} 變更`);
-                renameResult.operations.forEach(operation => {
-                    console.log(`   ✓ ${operation.filePath}: "${operation.oldText}" → "${operation.newText}"`);
-                });
-            }
-            else {
-                console.error('❌ 重新命名失敗:');
-                renameResult.errors?.forEach(error => {
-                    console.error(`   - ${error}`);
-                });
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-        }
-        catch (error) {
-            console.error('❌ 重新命名失敗:', error instanceof Error ? error.message : error);
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-    }
-    async handleRefactorCommand(action, options) {
-        if (!options.file) {
-            console.error('❌ 必須指定 --file 參數');
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-            return;
-        }
-        console.log(`🔧 重構: ${action}`);
-        try {
-            const filePath = path.resolve(options.file);
-            if (action === 'extract-function') {
-                if (!options.startLine || !options.endLine || !options.functionName) {
-                    console.error('❌ extract-function 需要 --start-line, --end-line 和 --function-name 參數');
-                    if (process.env.NODE_ENV !== 'test') {
-                        process.exit(1);
-                    }
-                    return;
-                }
-                // 讀取檔案內容
-                const fs = await import('fs/promises');
-                const code = await fs.readFile(filePath, 'utf-8');
-                // 建立範圍
-                const range = {
-                    start: { line: parseInt(options.startLine), column: 0 },
-                    end: { line: parseInt(options.endLine), column: 0 }
-                };
-                // 初始化 FunctionExtractor
-                const { FunctionExtractor } = await import('../../core/refactor/extract-function.js');
-                const extractor = new FunctionExtractor();
-                // 執行提取
-                const extractConfig = {
-                    functionName: options.functionName,
-                    generateComments: true,
-                    preserveFormatting: true,
-                    validateExtraction: true,
-                    ...(options.targetFile ? {
-                        targetFile: path.resolve(options.targetFile),
-                        sourceFile: filePath
-                    } : {})
-                };
-                const result = await extractor.extract(code, range, extractConfig);
-                if (result.success) {
-                    // 套用編輯（按正確順序）
-                    let modifiedCode = code;
-                    // 先處理所有 insert 類型（在檔案開頭插入函式定義）
-                    const insertEdits = result.edits.filter(e => e.type === 'insert');
-                    const replaceEdits = result.edits.filter(e => e.type === 'replace');
-                    // 先應用 replace（替換選取範圍為函式呼叫）
-                    for (const edit of replaceEdits) {
-                        modifiedCode = this.applyEditCorrectly(modifiedCode, edit);
-                    }
-                    // 再應用 insert（插入函式定義）
-                    for (const edit of insertEdits) {
-                        modifiedCode = this.applyEditCorrectly(modifiedCode, edit);
-                    }
-                    // 提取函式簽名（從修改後的程式碼中）
-                    const functionSignatureMatch = modifiedCode.match(new RegExp(`(async\\s+)?function\\s+${result.functionName}\\s*\\([^)]*\\)`));
-                    const functionSignature = functionSignatureMatch ? functionSignatureMatch[0] : `function ${result.functionName}`;
-                    console.log('✅ 重構完成');
-                    console.log(`📝 提取的函式: ${functionSignature}`);
-                    console.log(functionSignature);
-                    if (!options.preview) {
-                        // 寫入原始檔案
-                        await fs.writeFile(filePath, modifiedCode, 'utf-8');
-                        console.log(`✓ 已更新 ${filePath}`);
-                        // 如果是跨檔案提取，寫入目標檔案
-                        if (result.targetFileContent && options.targetFile) {
-                            const targetPath = path.resolve(options.targetFile);
-                            // 確保目標目錄存在
-                            const targetDir = path.dirname(targetPath);
-                            await fs.mkdir(targetDir, { recursive: true });
-                            // 寫入目標檔案
-                            await fs.writeFile(targetPath, result.targetFileContent, 'utf-8');
-                            console.log(`✓ 已建立/更新目標檔案 ${targetPath}`);
-                            if (result.importStatement) {
-                                console.log(`✓ 已加入 import: ${result.importStatement}`);
-                            }
-                        }
-                    }
-                    else {
-                        console.log('\n🔍 預覽模式 - 未寫入檔案');
-                        console.log(`📊 參數: ${result.parameters.map(p => p.name).join(', ')}`);
-                        if (result.targetFileContent && options.targetFile) {
-                            console.log(`📁 目標檔案: ${options.targetFile}`);
-                            console.log(`📥 Import: ${result.importStatement || '(無)'}`);
-                        }
-                    }
-                }
-                else {
-                    console.error('❌ 重構失敗:', result.errors.join(', '));
-                    process.exitCode = 1;
-                    if (process.env.NODE_ENV !== 'test') {
-                        process.exit(1);
-                    }
-                }
-            }
-            else if (action === 'inline-function') {
-                console.error('❌ inline-function 尚未實作');
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-            else {
-                console.error(`❌ 未知的重構操作: ${action}`);
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-        }
-        catch (error) {
-            console.error('❌ 重構失敗:', error instanceof Error ? error.message : error);
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-    }
-    async handleMoveCommand(source, target, options) {
-        console.log(`📦 移動 ${source} → ${target}`);
-        try {
-            // 檢查源檔案是否存在
-            const sourceExists = await this.fileExists(source);
-            if (!sourceExists) {
-                console.log(`❌ 移動失敗: 源檔案不存在 "${source}"`);
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-            // 初始化移動服務
-            if (!this.moveService) {
-                // 讀取 tsconfig.json 路徑別名
-                const pathAliases = await this.loadPathAliases(process.cwd());
-                this.moveService = new MoveService({
-                    pathAliases,
-                    supportedExtensions: ['.ts', '.tsx', '.js', '.jsx', '.vue'],
-                    includeNodeModules: false
-                });
-            }
-            const moveOperation = {
-                source: path.resolve(source),
-                target: path.resolve(target),
-                updateImports: options.updateImports
-            };
-            const moveOptions = {
-                preview: options.preview,
-                projectRoot: process.cwd()
-            };
-            // 執行移動操作
-            const result = await this.moveService.moveFile(moveOperation, moveOptions);
-            if (result.success) {
-                if (options.preview) {
-                    console.log('🔍 預覽移動操作:');
-                }
-                else {
-                    console.log('✅ 移動成功!');
-                }
-                console.log(`📊 統計: ${result.pathUpdates.length} 個 import 需要更新`);
-                if (result.pathUpdates.length > 0) {
-                    console.log('📝 影響的檔案:');
-                    const fileGroups = new Map();
-                    result.pathUpdates.forEach(update => {
-                        if (!fileGroups.has(update.filePath)) {
-                            fileGroups.set(update.filePath, []);
-                        }
-                        fileGroups.get(update.filePath).push(update);
-                    });
-                    for (const [filePath, updates] of fileGroups) {
-                        console.log(`   📄 ${path.relative(process.cwd(), filePath)}:`);
-                        updates.forEach(update => {
-                            console.log(`      第 ${update.line} 行: "${path.basename(source)}" → "${path.basename(target)}"`);
-                        });
-                    }
-                }
-            }
-            else {
-                console.error('❌ 移動失敗:', result.error);
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-        }
-        catch (error) {
-            console.error('❌ 移動失敗:', error instanceof Error ? error.message : error);
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-    }
-    async handleSearchCommand(query, options) {
-        const isMinimalOrJson = options.format === 'minimal' || options.format === 'json';
-        if (!isMinimalOrJson) {
-            console.log(`🔍 搜尋: "${query}"`);
-        }
-        try {
-            // 初始化搜尋服務
-            if (!this.searchService) {
-                this.searchService = new SearchService();
-            }
-            // 建構搜尋選項
-            const searchOptions = this.buildSearchOptions(options);
-            // 根據搜尋類型建立查詢
-            const searchQuery = {
-                type: 'text',
-                query,
-                options: searchOptions
-            };
-            // 執行搜尋
-            const startTime = Date.now();
-            const result = await this.searchService.searchText(searchQuery);
-            const searchTime = Date.now() - startTime;
-            // 顯示結果
-            if (result.matches.length === 0) {
-                if (!isMinimalOrJson) {
-                    console.log('📝 沒有找到匹配結果');
-                }
-                else if (options.format === 'json') {
-                    // JSON 格式輸出空結果
-                    console.log(JSON.stringify({ results: [] }, null, 2));
-                }
-                return;
-            }
-            if (!isMinimalOrJson) {
-                console.log(`✅ 找到 ${result.matches.length} 個結果 (${searchTime}ms)`);
-                if (result.truncated) {
-                    console.log(`⚠️  結果已截斷，顯示前 ${options.limit} 個結果`);
-                }
-            }
-            // 格式化輸出
-            this.formatSearchResults(result, options);
-        }
-        catch (error) {
-            if (isMinimalOrJson) {
-                // 對於 minimal 和 json 格式，輸出空結果或錯誤
-                if (options.format === 'json') {
-                    console.log(JSON.stringify({ matches: [], error: error instanceof Error ? error.message : String(error) }));
-                }
-                else {
-                    console.error(`Error: ${error instanceof Error ? error.message : error}`);
-                }
-            }
-            else {
-                console.error('❌ 搜尋失敗:', error instanceof Error ? error.message : error);
-            }
-            // 測試環境不 exit
-            if (process.env.NODE_ENV !== 'test') {
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-        }
+        const context = this.createCommandContext();
+        // Transform 群組
+        const transformCmd = this.program
+            .command('transform')
+            .description('程式碼變換工具');
+        // 直接掛載到 transform（無中間層）
+        setupRenameCommand(transformCmd, context);
+        setupChangeSignatureCommand(transformCmd, context);
+        setupMoveCommand(transformCmd, context);
+        setupMoveMemberCommand(transformCmd, context);
+        setupShiftCommand(transformCmd, context);
+        setupExtractCommand(transformCmd, context);
+        setupInlineCommand(transformCmd, context);
+        // Query 命令（扁平式）
+        setupSearchCommand(this.program, context);
+        setupAnalyzeCommand(this.program, context);
+        setupDepsCommand(this.program, context);
+        setupSnapshotCommand(this.program, context);
     }
     /**
-     * 建構搜尋選項
+     * 建立命令共用 Context
      */
-    buildSearchOptions(options) {
-        const includeFiles = options.include ? options.include.split(',') : undefined;
-        const excludeFiles = options.exclude ? options.exclude.split(',') : undefined;
+    createCommandContext() {
         return {
-            scope: {
-                type: 'directory',
-                path: path.resolve(options.path),
-                recursive: true
-            },
-            maxResults: parseInt(options.limit),
-            caseSensitive: options.caseSensitive || false,
-            wholeWord: options.wholeWord || false,
-            regex: options.type === 'regex',
-            fuzzy: options.type === 'fuzzy',
-            multiline: options.multiline || false,
-            showContext: options.context > 0,
-            contextLines: parseInt(options.context),
-            includeFiles,
-            excludeFiles,
-            timeout: 30000
+            fileSystem: this.fileSystem
         };
     }
-    /**
-     * 格式化搜尋結果輸出
-     */
-    formatSearchResults(result, options) {
-        switch (options.format) {
-            case 'json':
-                // 測試期望的格式是 { results: [...] } 而不是 { matches: [...] }
-                // 將絕對路徑轉換為相對路徑
-                const resultsWithRelativePaths = result.matches.map((match) => ({
-                    ...match,
-                    file: this.formatFilePath(match.file)
-                }));
-                console.log(JSON.stringify({ results: resultsWithRelativePaths }, null, 2));
-                break;
-            case 'minimal':
-                // AI Agent 友善的最小輸出
-                result.matches.forEach((match) => {
-                    console.log(`${match.file}:${match.line}:${match.column}:${match.content.trim()}`);
-                });
-                break;
-            case 'list':
-            default:
-                result.matches.forEach((match, index) => {
-                    console.log(`\n${index + 1}. ${this.formatFilePath(match.file)}:${match.line}:${match.column}`);
-                    console.log(`   ${this.highlightMatch(match.content, options.query)}`);
-                    // 顯示上下文
-                    if (options.context > 0 && match.context) {
-                        if (match.context.before.length > 0) {
-                            match.context.before.forEach((line, i) => {
-                                const lineNum = match.line - match.context.before.length + i;
-                                console.log(`   ${lineNum.toString().padStart(3, ' ')}: ${line}`);
-                            });
-                        }
-                        console.log(`>> ${match.line.toString().padStart(3, ' ')}: ${this.highlightMatch(match.content, options.query)}`);
-                        if (match.context.after.length > 0) {
-                            match.context.after.forEach((line, i) => {
-                                const lineNum = match.line + i + 1;
-                                console.log(`   ${lineNum.toString().padStart(3, ' ')}: ${line}`);
-                            });
-                        }
-                    }
-                });
-                break;
-        }
-    }
-    /**
-     * 格式化檔案路徑（顯示相對路徑）
-     */
-    formatFilePath(filePath) {
-        const cwd = process.cwd();
-        const relativePath = path.relative(cwd, filePath);
-        return relativePath.startsWith('..') ? filePath : relativePath;
-    }
-    /**
-     * 高亮匹配內容
-     */
-    highlightMatch(text, query) {
-        if (!text || !query) {
-            return text;
-        }
-        // 簡單的高亮實作
-        try {
-            const regex = new RegExp(query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi');
-            return text.replace(regex, `[${query}]`);
-        }
-        catch {
-            return text;
-        }
-    }
-    async handleAnalyzeCommand(type, options) {
-        const analyzeType = type || 'complexity';
-        if (options.format !== 'json') {
-            console.log('📊 分析程式碼品質...');
-        }
-        try {
-            const analyzePath = options.path || process.cwd();
-            // 根據分析類型執行對應分析
-            if (analyzeType === 'complexity') {
-                const analyzer = new ComplexityAnalyzer();
-                // 獲取需要分析的檔案列表
-                const files = await this.getAllProjectFiles(analyzePath);
-                const results = await analyzer.analyzeFiles(files);
-                // 過濾高複雜度檔案（evaluation === 'high' 或 complexity > 10）
-                const highComplexityFiles = results.filter(r => r.complexity.evaluation === 'high' || r.complexity.cyclomaticComplexity > 10);
-                // 計算統計資訊
-                const complexities = results.map(r => r.complexity.cyclomaticComplexity);
-                const averageComplexity = complexities.length > 0
-                    ? complexities.reduce((sum, c) => sum + c, 0) / complexities.length
-                    : 0;
-                const maxComplexity = complexities.length > 0
-                    ? Math.max(...complexities)
-                    : 0;
-                if (options.format === 'json') {
-                    const outputData = {
-                        summary: {
-                            totalScanned: results.length,
-                            issuesFound: highComplexityFiles.length,
-                            averageComplexity,
-                            maxComplexity
-                        }
-                    };
-                    if (options.all) {
-                        outputData.all = results.map(r => ({
-                            path: r.file,
-                            complexity: r.complexity.cyclomaticComplexity,
-                            cognitiveComplexity: r.complexity.cognitiveComplexity,
-                            evaluation: r.complexity.evaluation
-                        }));
-                    }
-                    else {
-                        outputData.issues = highComplexityFiles.map(r => ({
-                            path: r.file,
-                            complexity: r.complexity.cyclomaticComplexity,
-                            cognitiveComplexity: r.complexity.cognitiveComplexity,
-                            evaluation: r.complexity.evaluation
-                        }));
-                    }
-                    console.log(JSON.stringify(outputData, null, 2));
-                }
-                else {
-                    console.log('✅ 複雜度分析完成!');
-                    console.log(`📊 統計: ${results.length} 個檔案，${highComplexityFiles.length} 個高複雜度檔案`);
-                    console.log(`   平均複雜度: ${averageComplexity.toFixed(2)}`);
-                    console.log(`   最高複雜度: ${maxComplexity}`);
-                    if (!options.all && highComplexityFiles.length > 0) {
-                        console.log(`\n⚠️  高複雜度檔案:`);
-                        highComplexityFiles.forEach(r => {
-                            console.log(`   - ${r.file}: ${r.complexity.cyclomaticComplexity}`);
-                        });
-                    }
-                }
-            }
-            else if (analyzeType === 'dead-code') {
-                const detector = new DeadCodeDetector();
-                // 獲取需要分析的檔案列表
-                const files = await this.getAllProjectFiles(analyzePath);
-                const results = await detector.detectInFiles(files);
-                // 過濾有 dead code 的檔案
-                const filesWithDeadCode = results.filter(r => r.deadCode.length > 0);
-                // 統計結果
-                const allDeadCode = results.flatMap(r => r.deadCode);
-                const deadFunctions = allDeadCode.filter(d => d.type === 'function');
-                const deadVariables = allDeadCode.filter(d => d.type === 'variable');
-                if (options.format === 'json') {
-                    const outputData = {
-                        summary: {
-                            totalScanned: results.length,
-                            filesWithIssues: filesWithDeadCode.length,
-                            totalDeadFunctions: deadFunctions.length,
-                            totalDeadVariables: deadVariables.length,
-                            totalDeadCode: allDeadCode.length
-                        }
-                    };
-                    if (options.all) {
-                        outputData.all = results.map(r => ({
-                            path: r.file,
-                            deadCode: r.deadCode
-                        }));
-                    }
-                    else {
-                        outputData.issues = filesWithDeadCode.map(r => ({
-                            path: r.file,
-                            deadCode: r.deadCode
-                        }));
-                    }
-                    outputData.deadFunctions = deadFunctions;
-                    outputData.deadVariables = deadVariables;
-                    console.log(JSON.stringify(outputData, null, 2));
-                }
-                else {
-                    console.log('✅ 死代碼檢測完成!');
-                    console.log(`📊 統計: ${results.length} 個檔案，${filesWithDeadCode.length} 個有死代碼`);
-                    console.log('📊 發現:');
-                    console.log(`   未使用函式: ${deadFunctions.length} 個`);
-                    console.log(`   未使用變數: ${deadVariables.length} 個`);
-                    if (!options.all && filesWithDeadCode.length > 0) {
-                        console.log(`\n⚠️  有死代碼的檔案:`);
-                        filesWithDeadCode.forEach(r => {
-                            console.log(`   - ${r.file}: ${r.deadCode.length} 項`);
-                        });
-                    }
-                }
-            }
-            else if (analyzeType === 'best-practices') {
-                // 檢查最佳實踐
-                const files = await this.getAllProjectFiles(analyzePath);
-                const issues = [];
-                const recommendations = [];
-                // 檢查 ES Module 使用情況
-                const hasEsmImports = files.some(async (file) => {
-                    const content = await fs.readFile(file, 'utf-8');
-                    return content.includes('import ') && content.includes('from ');
-                });
-                if (hasEsmImports) {
-                    recommendations.push({
-                        type: 'es-modules',
-                        status: 'good',
-                        message: '專案使用 ES Module'
-                    });
-                }
-                if (options.format === 'json') {
-                    console.log(JSON.stringify({
-                        issues,
-                        recommendations
-                    }, null, 2));
-                }
-                else {
-                    console.log('✅ 最佳實踐檢查完成!');
-                    console.log(`📊 建議數: ${recommendations.length}`);
-                }
-            }
-            else if (analyzeType === 'patterns') {
-                // 檢測程式碼模式
-                const files = await this.getAllProjectFiles(analyzePath);
-                const patterns = [];
-                let asyncFunctionCount = 0;
-                for (const file of files) {
-                    const content = await fs.readFile(file, 'utf-8');
-                    // 檢測 async 函式
-                    if (content.includes('async ')) {
-                        asyncFunctionCount++;
-                        if (!patterns.includes('async-functions')) {
-                            patterns.push('async-functions');
-                        }
-                    }
-                    // 檢測 Promise 使用
-                    if (content.includes('Promise') || content.includes('.then(')) {
-                        if (!patterns.includes('promise-usage')) {
-                            patterns.push('promise-usage');
-                        }
-                    }
-                    // TypeScript 特定模式
-                    if (file.endsWith('.ts') || file.endsWith('.tsx')) {
-                        // 檢測 interface 使用
-                        if (content.includes('interface ') && !patterns.includes('interface-usage')) {
-                            patterns.push('interface-usage');
-                        }
-                        // 檢測泛型類型
-                        if (content.match(/<[A-Z]\w*(\s*extends\s+\w+)?>/g) && !patterns.includes('generic-types')) {
-                            patterns.push('generic-types');
-                        }
-                        // 檢測 enum 使用
-                        if (content.includes('enum ') && !patterns.includes('enum-usage')) {
-                            patterns.push('enum-usage');
-                        }
-                    }
-                }
-                if (options.format === 'json') {
-                    console.log(JSON.stringify({
-                        patterns,
-                        statistics: {
-                            asyncFunctions: asyncFunctionCount
-                        }
-                    }, null, 2));
-                }
-                else {
-                    console.log('✅ 模式檢測完成!');
-                    console.log(`📊 發現模式: ${patterns.join(', ')}`);
-                }
-            }
-            else {
-                throw new Error(`不支援的分析類型: ${analyzeType}`);
-            }
-        }
-        catch (error) {
-            if (options.format === 'json') {
-                console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
-            }
-            else {
-                console.error('❌ 分析失敗:', error instanceof Error ? error.message : error);
-            }
-            if (process.env.NODE_ENV !== 'test') {
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-        }
-    }
-    async handleDepsCommand(options) {
-        if (options.format !== 'json') {
-            console.log('🕸️ 分析依賴關係...');
-        }
-        try {
-            const analyzePath = options.path || process.cwd();
-            // 初始化依賴分析器
-            if (!this.dependencyAnalyzer) {
-                this.dependencyAnalyzer = new DependencyAnalyzer();
-            }
-            // 分析專案依賴
-            const projectDeps = await this.dependencyAnalyzer.analyzeProject(analyzePath);
-            // 獲取統計資訊
-            const stats = this.dependencyAnalyzer.getStats();
-            // 使用 CycleDetector 檢測循環依賴
-            const cycleDetector = new (await import('../../core/dependency/cycle-detector.js')).CycleDetector();
-            const graph = await this.buildGraphFromProjectDeps(projectDeps);
-            const cycles = cycleDetector.detectCycles(graph);
-            // 輸出結果
-            if (options.format === 'json') {
-                // 根據 --file 選項決定輸出格式
-                if (options.file) {
-                    // 單檔案依賴查詢模式
-                    const targetFile = path.resolve(options.file);
-                    const dependencies = {};
-                    dependencies[options.file] = graph.getDependencies(targetFile);
-                    console.log(JSON.stringify({
-                        dependencies
-                    }, null, 2));
-                }
-                else {
-                    // 專案依賴圖模式
-                    const outputData = {
-                        summary: {
-                            totalFiles: stats.totalFiles,
-                            totalDependencies: stats.totalDependencies,
-                            averageDependenciesPerFile: stats.averageDependenciesPerFile,
-                            maxDependenciesInFile: stats.maxDependenciesInFile,
-                            issuesFound: cycles.length + stats.orphanedFiles
-                        },
-                        issues: {
-                            cycles: cycles.map(c => ({
-                                cycle: c.cycle,
-                                length: c.length,
-                                severity: c.severity
-                            })),
-                            circularDependencies: cycles.length,
-                            orphanedFiles: stats.orphanedFiles
-                        }
-                    };
-                    // 只有在 --all 時才輸出完整依賴圖
-                    if (options.all) {
-                        const nodes = graph.getAllNodes().map((nodeId) => ({
-                            id: nodeId,
-                            dependencies: graph.getDependencies(nodeId)
-                        }));
-                        const edges = [];
-                        for (const nodeId of graph.getAllNodes()) {
-                            for (const depId of graph.getDependencies(nodeId)) {
-                                edges.push({ source: nodeId, target: depId });
-                            }
-                        }
-                        outputData.all = {
-                            nodes,
-                            edges
-                        };
-                    }
-                    console.log(JSON.stringify(outputData, null, 2));
-                }
-            }
-            else {
-                console.log('✅ 依賴分析完成!');
-                console.log('📊 統計:');
-                console.log(`   總檔案數: ${stats.totalFiles}`);
-                console.log(`   總依賴數: ${stats.totalDependencies}`);
-                console.log(`   平均依賴數: ${stats.averageDependenciesPerFile.toFixed(2)}`);
-                console.log(`   最大依賴數: ${stats.maxDependenciesInFile}`);
-                if (cycles.length > 0) {
-                    console.log(`⚠️  發現 ${cycles.length} 個循環依賴:`);
-                    cycles.forEach((cycle, index) => {
-                        console.log(`   ${index + 1}. ${cycle.cycle.join(' → ')} (長度: ${cycle.length}, 嚴重性: ${cycle.severity})`);
-                    });
-                }
-                else {
-                    console.log('✓ 無循環依賴');
-                }
-                if (stats.orphanedFiles > 0) {
-                    console.log(`⚠️  發現 ${stats.orphanedFiles} 個孤立檔案`);
-                }
-            }
-        }
-        catch (error) {
-            if (options.format === 'json') {
-                console.log(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
-            }
-            else {
-                console.error('❌ 依賴分析失敗:', error instanceof Error ? error.message : error);
-            }
-            if (process.env.NODE_ENV !== 'test') {
-                if (process.env.NODE_ENV !== 'test') {
-                    process.exit(1);
-                }
-            }
-        }
-    }
-    /**
-     * 從專案依賴資訊建立依賴圖
-     */
-    async buildGraphFromProjectDeps(projectDeps) {
-        const { DependencyGraph } = await import('../../core/dependency/dependency-graph.js');
-        const graph = new DependencyGraph();
-        // 新增所有檔案節點及其依賴關係
-        for (const fileDep of projectDeps.fileDependencies) {
-            graph.addNode(fileDep.filePath);
-            for (const dep of fileDep.dependencies) {
-                graph.addDependency(fileDep.filePath, dep.path);
-            }
-        }
-        return graph;
-    }
-    async handlePluginsListCommand(options) {
-        console.log('🔌 插件列表:');
-        const registry = ParserRegistry.getInstance();
-        // 確保 registry 存在且有 listParsers 方法
-        if (!registry || typeof registry.listParsers !== 'function') {
-            console.log('📝 插件系統尚未初始化');
-            return;
-        }
-        const parsers = registry.listParsers();
-        if (!parsers || parsers.length === 0) {
-            console.log('📝 未找到已註冊的插件');
-            return;
-        }
-        console.table(parsers.map(p => ({
-            名稱: p.name,
-            版本: p.version,
-            支援副檔名: p.supportedExtensions.join(', '),
-            支援語言: p.supportedLanguages.join(', '),
-            註冊時間: p.registeredAt.toLocaleString()
-        })));
-    }
-    async handlePluginInfoCommand(pluginName) {
-        const registry = ParserRegistry.getInstance();
-        // 確保 registry 存在且有 getParserByName 方法
-        if (!registry || typeof registry.getParserByName !== 'function') {
-            console.error('❌ 插件系統尚未初始化');
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-        const plugin = registry.getParserByName(pluginName);
-        if (!plugin) {
-            console.error(`❌ 找不到插件: ${pluginName}`);
-            if (process.env.NODE_ENV !== 'test') {
-                process.exit(1);
-            }
-        }
-        console.log(`🔌 插件資訊: ${pluginName}`);
-        // TODO: 顯示詳細插件資訊
-    }
-    /**
-     * 檢查檔案是否存在
-     */
-    async fileExists(filePath) {
-        try {
-            await fs.access(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 正確套用程式碼編輯
-     */
-    applyEditCorrectly(code, edit) {
-        const lines = code.split('\n');
-        switch (edit.type) {
-            case 'replace': {
-                // 計算起始和結束位置的偏移量
-                const startOffset = this.positionToOffset(lines, edit.range.start);
-                const endOffset = this.positionToOffset(lines, edit.range.end);
-                return code.substring(0, startOffset) + edit.newText + code.substring(endOffset);
-            }
-            case 'insert': {
-                const offset = this.positionToOffset(lines, edit.range.start);
-                return code.substring(0, offset) + edit.newText + code.substring(offset);
-            }
-            case 'delete': {
-                const startOffset = this.positionToOffset(lines, edit.range.start);
-                const endOffset = this.positionToOffset(lines, edit.range.end);
-                return code.substring(0, startOffset) + code.substring(endOffset);
-            }
-            default:
-                return code;
-        }
-    }
-    /**
-     * 將行列位置轉換為字元偏移量
-     */
-    positionToOffset(lines, position) {
-        let offset = 0;
-        for (let i = 0; i < position.line - 1 && i < lines.length; i++) {
-            offset += lines[i].length + 1; // +1 for newline
-        }
-        offset += position.column;
-        return Math.min(offset, lines.join('\n').length);
-    }
-    /**
-     * @deprecated 使用 applyEditCorrectly 代替
-     */
-    applyCodeEdit(code, edit) {
-        const lines = code.split('\n');
-        const startLine = edit.range.start.line - 1; // 轉為 0-based
-        const endLine = edit.range.end.line - 1;
-        // 取得編輯範圍前後的內容
-        const before = lines.slice(0, startLine);
-        const after = lines.slice(endLine + 1);
-        // 組合新的內容
-        return [...before, edit.newText, ...after].join('\n');
-    }
-    /**
-     * 獲取專案中的所有檔案
-     */
-    async getAllProjectFiles(projectPath) {
-        const files = [];
-        const allowedExtensions = ['.ts', '.tsx', '.js', '.jsx'];
-        const excludePatterns = ['node_modules', 'dist', '.git', 'coverage'];
-        // 檢查路徑是檔案還是目錄
-        try {
-            const stats = await fs.stat(projectPath);
-            if (stats.isFile()) {
-                // 如果是單一檔案，直接返回
-                if (allowedExtensions.some(ext => projectPath.endsWith(ext))) {
-                    return [projectPath];
-                }
-                return [];
-            }
-        }
-        catch (error) {
-            // 路徑不存在
-            return [];
-        }
-        async function walkDir(dir) {
-            try {
-                const entries = await fs.readdir(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        // 跳過排除的目錄
-                        if (excludePatterns.some(pattern => entry.name.includes(pattern))) {
-                            continue;
-                        }
-                        await walkDir(fullPath);
-                    }
-                    else if (entry.isFile()) {
-                        // 只包含支援的副檔名
-                        if (allowedExtensions.some(ext => entry.name.endsWith(ext))) {
-                            files.push(fullPath);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                // 忽略無法存取的目錄
-            }
-        }
-        await walkDir(projectPath);
-        return files;
-    }
-    /**
-     * 讀取 tsconfig.json 的路徑別名設定
-     */
-    async loadPathAliases(projectRoot) {
-        const pathAliases = {};
-        try {
-            const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
-            const tsconfigContent = await fs.readFile(tsconfigPath, 'utf-8');
-            const tsconfig = JSON.parse(tsconfigContent);
-            if (tsconfig.compilerOptions?.paths) {
-                const baseUrl = tsconfig.compilerOptions.baseUrl || '.';
-                const basePath = path.resolve(projectRoot, baseUrl);
-                for (const [alias, paths] of Object.entries(tsconfig.compilerOptions.paths)) {
-                    if (Array.isArray(paths) && paths.length > 0) {
-                        // 移除 /* 後綴
-                        const cleanAlias = alias.replace(/\/\*$/, '');
-                        const cleanPath = paths[0].replace(/\/\*$/, '');
-                        // 轉換為絕對路徑
-                        pathAliases[cleanAlias] = path.resolve(basePath, cleanPath);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // tsconfig.json 不存在或解析失敗，使用空的路徑別名
-            if (process.env.NODE_ENV !== 'test') {
-                console.warn('⚠️  無法讀取 tsconfig.json 路徑別名設定');
-            }
-        }
-        return pathAliases;
-    }
-    /**
-     * 建立輸出格式化器
-     */
-    createFormatter(format) {
-        let outputFormat;
-        switch (format?.toLowerCase()) {
-            case 'markdown':
-                outputFormat = OutputFormat.Markdown;
-                break;
-            case 'json':
-                outputFormat = OutputFormat.Json;
-                break;
-            case 'minimal':
-                outputFormat = OutputFormat.Minimal;
-                break;
-            case 'plain':
-            default:
-                outputFormat = OutputFormat.Plain;
-                break;
-        }
-        return new OutputFormatter(outputFormat);
-    }
 }
 //# sourceMappingURL=cli.js.map