@mycodemap/mycodemap 1.9.0 → 2.7.0

package/dist/cli/commands/query.js

@@ -1,718 +1,33 @@
 // [META] since:2026-03-03 | owner:orchestrator-team | stable:true
-// [WHY] 查询命令优化：改进缓存策略、添加索引结构、添加性能指标输出
-import chalk from 'chalk';
-import fs from 'fs';
-import path from 'path';
-import { resolveDataPath } from '../paths.js';
-// ===== 性能优化：改进的缓存机制 =====
-// 缓存配置
-const CACHE_CONFIG = {
-    TTL: 60000, // 60秒缓存（从5秒提升）
-    MAX_SIZE: 10, // 最大缓存 10 个项目的索引
-};
-const indexCache = new Map();
-/**
- * 标准化依赖名称，用于去重比较
- * 1. 去除扩展名（如 .ts, .js）
- * 2. 去除 ./ 前缀
- * 3. 转换为小写
- */
-function normalizeDependencyName(name) {
-    return name
-        .replace(/\.[jt]s$/, "") // 去除 .ts 或 .js 扩展名
-        .replace(/^\.\//, "") // 去除 ./ 前缀
-        .toLowerCase();
+// [WHY] Thin CLI wrapper for shared query execution so CLI and MCP can converge on one transport-free truth
+import { resolveOutputMode, renderOutput, createProgressEmitter, formatError } from '../output/index.js';
+import { executeQueryTool, formatQueryHuman, } from '../../execution/contract-tools/query.js';
+function toExecutionError(error) {
+    const executionError = new Error(error.message);
+    executionError.code = error.code;
+    executionError.remediation = error.remediation;
+    executionError.details = error.details;
+    return executionError;
 }
-/**
- * 预构建索引以加速查询
- */
-function buildIndex(codeMap, rootDir) {
-    const index = {
-        symbols: new Map(),
-        symbolsExact: new Map(),
-        modules: new Map(),
-        dependencies: new Map(),
-        prefixIndex: new Map(),
-        prefixIndexExact: new Map(),
-    };
-    for (const module of codeMap.modules) {
-        const relativePath = path.relative(rootDir, module.absolutePath);
-        const moduleIndex = {
-            absolutePath: module.absolutePath,
-            relativePath,
-            type: module.type,
-            exports: module.exports.map(e => e.name),
-        };
-        // 索引模块（使用相对路径作为主键）
-        index.modules.set(relativePath.toLowerCase(), moduleIndex);
-        // 索引导出
-        for (const exp of module.exports) {
-            const entry = {
-                name: exp.name,
-                kind: exp.kind,
-                filePath: relativePath,
-                isExported: true,
-            };
-            // 精确索引（不区分大小写）
-            const lowerName = exp.name.toLowerCase();
-            if (!index.symbols.has(lowerName)) {
-                index.symbols.set(lowerName, []);
-            }
-            index.symbols.get(lowerName).push(entry);
-            // 精确索引（区分大小写）
-            if (!index.symbolsExact.has(exp.name)) {
-                index.symbolsExact.set(exp.name, []);
-            }
-            index.symbolsExact.get(exp.name).push(entry);
-            // 前缀索引（不区分大小写）
-            for (let i = 1; i <= exp.name.length; i++) {
-                const prefix = exp.name.substring(0, i).toLowerCase();
-                if (!index.prefixIndex.has(prefix)) {
-                    index.prefixIndex.set(prefix, []);
-                }
-                index.prefixIndex.get(prefix).push(entry);
-            }
-            // 前缀索引（区分大小写）
-            for (let i = 1; i <= exp.name.length; i++) {
-                const prefix = exp.name.substring(0, i);
-                if (!index.prefixIndexExact.has(prefix)) {
-                    index.prefixIndexExact.set(prefix, []);
-                }
-                index.prefixIndexExact.get(prefix).push(entry);
-            }
-        }
-        // 索引符号
-        for (const sym of module.symbols) {
-            const entry = {
-                name: sym.name,
-                kind: sym.kind,
-                filePath: relativePath,
-                line: sym.location.line,
-                column: sym.location.column,
-                isExported: false,
-            };
-            const lowerName = sym.name.toLowerCase();
-            if (!index.symbols.has(lowerName)) {
-                index.symbols.set(lowerName, []);
-            }
-            index.symbols.get(lowerName).push(entry);
-            // 精确索引（区分大小写）
-            if (!index.symbolsExact.has(sym.name)) {
-                index.symbolsExact.set(sym.name, []);
-            }
-            index.symbolsExact.get(sym.name).push(entry);
-            // 前缀索引（不区分大小写）
-            for (let i = 1; i <= sym.name.length; i++) {
-                const prefix = sym.name.substring(0, i).toLowerCase();
-                if (!index.prefixIndex.has(prefix)) {
-                    index.prefixIndex.set(prefix, []);
-                }
-                index.prefixIndex.get(prefix).push(entry);
-            }
-            // 前缀索引（区分大小写）
-            for (let i = 1; i <= sym.name.length; i++) {
-                const prefix = sym.name.substring(0, i);
-                if (!index.prefixIndexExact.has(prefix)) {
-                    index.prefixIndexExact.set(prefix, []);
-                }
-                index.prefixIndexExact.get(prefix).push(entry);
-            }
-        }
-        // 索引依赖和导入，进行去重处理
-        // 使用 Set 跟踪当前模块已添加的依赖（基于标准化名称）
-        const seenDeps = new Set();
-        // 先索引 dependencies（优先保留）
-        for (const dep of module.dependencies) {
-            const normalizedDep = normalizeDependencyName(dep);
-            const depKey = `${relativePath}:${normalizedDep}`;
-            // 跳过已存在的依赖
-            if (seenDeps.has(depKey)) {
-                continue;
-            }
-            seenDeps.add(depKey);
-            const depEntry = {
-                name: dep,
-                sourcePath: relativePath,
-                type: "dependency",
-            };
-            const lowerDep = dep.toLowerCase();
-            if (!index.dependencies.has(lowerDep)) {
-                index.dependencies.set(lowerDep, []);
-            }
-            index.dependencies.get(lowerDep).push(depEntry);
-        }
-        // 再索引 imports（如果与 dependency 重复则跳过）
-        for (const imp of module.imports) {
-            const normalizedSource = normalizeDependencyName(imp.source);
-            const impKey = `${relativePath}:${normalizedSource}`;
-            // 跳过已存在的依赖（避免与 dependency 重复）
-            if (seenDeps.has(impKey)) {
-                continue;
-            }
-            seenDeps.add(impKey);
-            const impEntry = {
-                name: imp.source,
-                sourcePath: relativePath,
-                type: "import",
-            };
-            const lowerSource = imp.source.toLowerCase();
-            if (!index.dependencies.has(lowerSource)) {
-                index.dependencies.set(lowerSource, []);
-            }
-            index.dependencies.get(lowerSource).push(impEntry);
-        }
-    }
-    return index;
-}
-/**
- * 加载代码地图数据（带改进的缓存）
- */
-function loadCodeMap(rootDir, useCache = true) {
-    const codemapPath = resolveDataPath(rootDir);
-    const startTime = performance.now();
-    // 检查缓存
-    if (useCache) {
-        const cached = indexCache.get(rootDir);
-        if (cached && Date.now() - cached.timestamp < CACHE_CONFIG.TTL) {
-            return {
-                codeMap: cached.data,
-                index: cached.index,
-                cacheHit: true,
-                loadTime: 0,
-            };
-        }
-    }
-    if (!fs.existsSync(codemapPath)) {
-        console.log(chalk.red('错误: 代码地图不存在，请先运行 codemap generate'));
-        return { codeMap: null, index: null, cacheHit: false, loadTime: 0 };
-    }
+export async function queryCommand(options) {
+    const mode = resolveOutputMode({ json: options.json, human: options.human });
+    const progress = createProgressEmitter(mode, 'Querying...');
     try {
-        const data = fs.readFileSync(codemapPath, 'utf-8');
-        const parsed = JSON.parse(data);
-        const loadTime = performance.now() - startTime;
-        // 构建索引
-        const index = buildIndex(parsed, rootDir);
-        // 缓存（如果启用）
-        if (useCache) {
-            // 清理超出限制的旧缓存
-            if (indexCache.size >= CACHE_CONFIG.MAX_SIZE) {
-                // 删除最旧的缓存
-                let oldestKey = null;
-                let oldestTime = Infinity;
-                for (const [key, val] of indexCache.entries()) {
-                    if (val.timestamp < oldestTime) {
-                        oldestTime = val.timestamp;
-                        oldestKey = key;
-                    }
-                }
-                if (oldestKey) {
-                    indexCache.delete(oldestKey);
-                }
-            }
-            indexCache.set(rootDir, {
-                data: parsed,
-                timestamp: Date.now(),
-                path: codemapPath,
-                index,
+        progress.update(30, 'Loading index...');
+        const execution = await executeQueryTool(options, process.cwd());
+        if (execution.status !== 'ok' || !execution.result) {
+            throw toExecutionError(execution.error ?? {
+                code: 'EXECUTION_FAILED',
+                message: 'Query execution failed',
             });
         }
-        return {
-            codeMap: parsed,
-            index,
-            cacheHit: false,
-            loadTime,
-        };
+        progress.complete();
+        renderOutput(execution.result, formatQueryHuman, mode);
     }
     catch (error) {
-        console.log(chalk.red('错误: 读取代码地图失败:', error instanceof Error ? error.message : String(error)));
-        return { codeMap: null, index: null, cacheHit: false, loadTime: 0 };
-    }
-}
-/**
- * 清除缓存
- */
-function clearCache() {
-    indexCache.clear();
-}
-/**
- * 查找符号的引用位置
- */
-function findReferences(codeMap, symbolName, excludeFile, caseSensitive = false) {
-    const references = [];
-    const searchName = caseSensitive ? symbolName : symbolName.toLowerCase();
-    for (const mod of codeMap.modules) {
-        const relPath = path.relative(codeMap.project.rootDir, mod.absolutePath);
-        // 跳过定义位置文件
-        if (relPath === excludeFile)
-            continue;
-        // 检查 imports 中是否引用了该符号
-        for (const imp of mod.imports) {
-            // 检查导入源
-            const impSource = caseSensitive ? imp.source : imp.source.toLowerCase();
-            if (impSource.includes(searchName)) {
-                references.push({
-                    file: relPath,
-                    line: 1, // 简化处理，显示第一行
-                    type: 'import',
-                });
-                continue;
-            }
-            // 检查导入的 specifiers
-            for (const spec of imp.specifiers) {
-                const specName = caseSensitive ? spec.name : spec.name.toLowerCase();
-                if (specName === searchName) {
-                    references.push({
-                        file: relPath,
-                        line: 1,
-                        type: 'import',
-                    });
-                    break;
-                }
-            }
-        }
-        // 检查 exports 中是否导出该符号
-        for (const exp of mod.exports) {
-            const expName = caseSensitive ? exp.name : exp.name.toLowerCase();
-            if (expName === searchName) {
-                references.push({
-                    file: relPath,
-                    line: 1,
-                    type: 'export',
-                });
-            }
-        }
-    }
-    return references.slice(0, 20); // 限制引用数量
-}
-/**
- * 读取代码上下文
- */
-function readCodeContext(filePath, lineNumber, contextLines, rootDir) {
-    const fullPath = path.join(rootDir, filePath);
-    if (!fs.existsSync(fullPath)) {
-        return [];
-    }
-    try {
-        const content = fs.readFileSync(fullPath, 'utf-8');
-        const lines = content.split('\n');
-        const context = [];
-        const startLine = Math.max(1, lineNumber - contextLines);
-        const endLine = Math.min(lines.length, lineNumber + contextLines);
-        for (let i = startLine; i <= endLine; i++) {
-            context.push({
-                line: i,
-                content: lines[i - 1] || '',
-            });
-        }
-        return context;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * 查询符号（使用索引）
- */
-function querySymbol(index, codeMap, symbolName, limit, caseSensitive = false, includeReferences = false, contextLines = 0) {
-    const results = [];
-    // 选择正确的索引
-    const symbolsMap = caseSensitive ? index.symbolsExact : index.symbols;
-    const prefixMap = caseSensitive ? index.prefixIndexExact : index.prefixIndex;
-    // 搜索键：不区分大小写时转换为小写
-    const searchKey = caseSensitive ? symbolName : symbolName.toLowerCase();
-    // 用于去重的 Set
-    const seenResults = new Set();
-    // 首先尝试精确匹配（完全相等）
-    const exactMatches = symbolsMap.get(searchKey);
-    if (exactMatches) {
-        for (const entry of exactMatches) {
-            const key = `${entry.name}:${entry.filePath}`;
-            if (!seenResults.has(key)) {
-                seenResults.add(key);
-                results.push({
-                    name: entry.name,
-                    path: path.join(codeMap.project.rootDir, entry.filePath),
-                    kind: entry.kind,
-                    details: `${entry.isExported ? '导出于' : '定义于'} ${entry.filePath}${entry.line ? ':' + entry.line : ''}`,
-                    location: { file: entry.filePath, line: entry.line, column: entry.column },
-                    isExported: entry.isExported,
-                });
-            }
-        }
-    }
-    // 尝试前缀匹配（以搜索词开头）
-    const prefixResults = prefixMap.get(searchKey) || [];
-    for (const entry of prefixResults) {
-        const key = `${entry.name}:${entry.filePath}`;
-        if (!seenResults.has(key)) {
-            seenResults.add(key);
-            results.push({
-                name: entry.name,
-                path: path.join(codeMap.project.rootDir, entry.filePath),
-                kind: entry.kind,
-                details: `${entry.isExported ? '导出于' : '定义于'} ${entry.filePath}${entry.line ? ':' + entry.line : ''}`,
-                location: { file: entry.filePath, line: entry.line, column: entry.column },
-                isExported: entry.isExported,
-            });
-        }
-    }
-    // 尝试子串匹配（包含匹配）
-    // 例如：搜索 "Analyzer" 应匹配 "GitAnalyzer"
-    for (const [key, entries] of symbolsMap.entries()) {
-        if (key.includes(searchKey) && !key.startsWith(searchKey)) {
-            // 跳过已经通过精确匹配和前缀匹配找到的键
-            for (const entry of entries) {
-                const resultKey = `${entry.name}:${entry.filePath}`;
-                if (!seenResults.has(resultKey)) {
-                    seenResults.add(resultKey);
-                    results.push({
-                        name: entry.name,
-                        path: path.join(codeMap.project.rootDir, entry.filePath),
-                        kind: entry.kind,
-                        details: `${entry.isExported ? '导出于' : '定义于'} ${entry.filePath}${entry.line ? ':' + entry.line : ''}`,
-                        location: { file: entry.filePath, line: entry.line, column: entry.column },
-                        isExported: entry.isExported,
-                    });
-                }
-            }
-        }
-    }
-    // 添加引用信息
-    if (includeReferences) {
-        for (const result of results) {
-            result.references = findReferences(codeMap, symbolName, result.location?.file || '', caseSensitive);
-        }
-    }
-    // 添加代码上下文
-    if (contextLines > 0) {
-        for (const result of results) {
-            result.context = readCodeContext(result.location?.file || '', result.location?.line || 0, contextLines, codeMap.project.rootDir);
-        }
-    }
-    return results.slice(0, limit);
-}
-/**
- * 查询模块（使用索引）
- */
-function queryModule(index, codeMap, modulePath, limit) {
-    const results = [];
-    const searchPath = modulePath.toLowerCase();
-    // 使用索引查找
-    for (const [key, moduleIdx] of index.modules.entries()) {
-        if (key.includes(searchPath) || moduleIdx.absolutePath.toLowerCase().includes(searchPath)) {
-            const exports = moduleIdx.exports.join(', ') || '无导出';
-            results.push({
-                name: moduleIdx.relativePath,
-                path: moduleIdx.absolutePath,
-                kind: moduleIdx.type,
-                details: `导出: ${exports}`,
-                location: { file: moduleIdx.relativePath },
-                isExported: moduleIdx.exports.length > 0,
-            });
-        }
-    }
-    return results.slice(0, limit);
-}
-/**
- * 查询依赖（使用索引）
- * @param index 符号索引
- * @param codeMap 代码地图数据
- * @param depName 依赖名称
- * @param limit 结果数量限制
- * @param deduplicate 是否去重（默认true）
- */
-function queryDeps(index, codeMap, depName, limit, deduplicate = true) {
-    const results = [];
-    const searchDep = depName.toLowerCase();
-    // 使用索引查找
-    const depEntries = index.dependencies.get(searchDep);
-    if (depEntries) {
-        for (const entry of depEntries) {
-            results.push({
-                name: entry.name,
-                path: path.join(codeMap.project.rootDir, entry.sourcePath),
-                kind: entry.type,
-                details: `${entry.type === 'dependency' ? '被' : '导入自'} ${entry.sourcePath} 引用`,
-                location: { file: entry.sourcePath },
-                isExported: false,
-            });
-        }
-    }
-    // 去重：基于 name:sourcePath 组合去重，避免 dependency 和 import 重复
-    if (deduplicate) {
-        const unique = new Map();
-        for (const item of results) {
-            const key = `${item.name}:${item.path}`;
-            if (!unique.has(key)) {
-                unique.set(key, item);
-            }
-        }
-        return Array.from(unique.values()).slice(0, limit);
-    }
-    return results.slice(0, limit);
-}
-/**
- * 模糊搜索（使用索引）
- * @param index 符号索引
- * @param codeMap 代码地图数据
- * @param keyword 搜索关键词
- * @param limit 结果数量限制
- * @param useRegex 是否使用正则表达式搜索
- * @param caseSensitive 大小写敏感
- * @param contextLines 代码上下文行数
- */
-function search(index, codeMap, keyword, limit, useRegex = false, caseSensitive = false, contextLines = 0) {
-    const results = [];
-    // 正则表达式模式
-    let regex = null;
-    if (useRegex) {
-        try {
-            const flags = caseSensitive ? '' : 'i';
-            regex = new RegExp(keyword, flags);
-        }
-        catch {
-            // 正则表达式无效，回退到普通搜索
-            regex = null;
-        }
-    }
-    // 1. 搜索模块路径
-    for (const [key, moduleIdx] of index.modules.entries()) {
-        const searchTarget = caseSensitive ? key : key.toLowerCase();
-        const keywordLower = keyword.toLowerCase();
-        const matches = regex
-            ? regex.test(key) || regex.test(moduleIdx.relativePath)
-            : searchTarget.includes(keywordLower);
-        if (matches) {
-            results.push({
-                name: moduleIdx.relativePath,
-                path: moduleIdx.absolutePath,
-                kind: 'module',
-                details: useRegex ? `正则匹配` : `模块匹配`,
-                location: { file: moduleIdx.relativePath },
-                isExported: false,
-            });
-        }
-    }
-    // 2. 搜索符号和导出（使用前缀索引）
-    // 选择正确的索引
-    const symbolsMap = caseSensitive ? index.symbolsExact : index.symbols;
-    const prefixMap = caseSensitive ? index.prefixIndexExact : index.prefixIndex;
-    if (useRegex && regex) {
-        // 正则模式：遍历所有符号进行匹配
-        for (const [symbolKey, entries] of symbolsMap.entries()) {
-            const matchTarget = caseSensitive ? symbolKey : symbolKey.toLowerCase();
-            if (regex.test(matchTarget) || regex.test(symbolKey)) {
-                for (const entry of entries) {
-                    results.push({
-                        name: entry.name,
-                        path: path.join(codeMap.project.rootDir, entry.filePath),
-                        kind: entry.isExported ? `export (${entry.kind})` : entry.kind,
-                        details: `正则匹配于 ${entry.filePath}${entry.line ? ':' + entry.line : ''}`,
-                        location: { file: entry.filePath, line: entry.line, column: entry.column },
-                        isExported: entry.isExported,
-                    });
-                }
-            }
-        }
-    }
-    else {
-        // 普通模式：使用前缀索引
-        // 搜索键：不区分大小写时转换为小写
-        const searchKey = caseSensitive ? keyword : keyword.toLowerCase();
-        const prefixResults = prefixMap.get(searchKey) || [];
-        for (const entry of prefixResults) {
-            results.push({
-                name: entry.name,
-                path: path.join(codeMap.project.rootDir, entry.filePath),
-                kind: entry.isExported ? `export (${entry.kind})` : entry.kind,
-                details: `${entry.isExported ? '导出于' : '定义于'} ${entry.filePath}${entry.line ? ':' + entry.line : ''}`,
-                location: { file: entry.filePath, line: entry.line, column: entry.column },
-                isExported: entry.isExported,
-            });
-        }
-    }
-    // 去重（基于 name:path 组合）
-    const unique = new Map();
-    for (const item of results) {
-        const key = `${item.name}:${item.path}`;
-        if (!unique.has(key)) {
-            unique.set(key, item);
-        }
-    }
-    const finalResults = Array.from(unique.values()).slice(0, limit);
-    // 添加代码上下文
-    if (contextLines > 0) {
-        for (const result of finalResults) {
-            result.context = readCodeContext(result.location?.file || '', result.location?.line || 0, contextLines, codeMap.project.rootDir);
-        }
-    }
-    return finalResults;
-}
-/**
- * 格式化输出结果
- */
-function formatResults(result, isJson, verbose, structured = false) {
-    if (isJson) {
-        // 如果是 structured 模式，移除 details 字段
-        if (structured) {
-            const structuredResult = {
-                ...result,
-                results: result.results.map(item => {
-                    const { details, ...rest } = item;
-                    void details; // 标记为有意忽略的变量
-                    return rest;
-                })
-            };
-            console.log(JSON.stringify(structuredResult, null, 2));
-        }
-        else {
-            console.log(JSON.stringify(result, null, 2));
-        }
-        return;
-    }
-    console.log(chalk.cyan(`\n查询 "${result.query}" (${result.type})`));
-    console.log(chalk.gray(`   找到 ${result.count} 个结果\n`));
-    if (result.count === 0) {
-        console.log(chalk.yellow('   未找到匹配结果'));
-        return;
-    }
-    for (const item of result.results) {
-        console.log(chalk.green(`   ${item.name}`));
-        if (item.kind) {
-            console.log(chalk.gray(`      类型: ${item.kind}`));
-        }
-        if (item.path) {
-            console.log(chalk.gray(`      路径: ${item.path}`));
-        }
-        if (item.details) {
-            console.log(chalk.gray(`      ${item.details}`));
-        }
-        // 显示引用信息
-        if (item.references && item.references.length > 0) {
-            console.log(chalk.gray(`      引用:`));
-            for (const ref of item.references.slice(0, 5)) {
-                console.log(chalk.gray(`        - ${ref.type}: ${ref.file}`));
-            }
-            if (item.references.length > 5) {
-                console.log(chalk.gray(`        ... 还有 ${item.references.length - 5} 个引用`));
-            }
-        }
-        // 显示代码上下文
-        if (item.context && item.context.length > 0) {
-            console.log(chalk.gray(`      代码上下文:`));
-            for (const ctx of item.context) {
-                const prefix = ctx.line === item.location?.line ? '>' : ' ';
-                console.log(chalk.gray(`        ${prefix}${ctx.line}: ${ctx.content}`));
-            }
-        }
-        console.log('');
-    }
-    // verbose 模式输出性能指标
-    if (verbose && result.metrics) {
-        const m = result.metrics;
-        console.log(chalk.cyan('性能指标:'));
-        console.log(chalk.gray(`   索引加载: ${m.indexLoadTime.toFixed(2)}ms ${m.cacheHit ? '(缓存命中)' : ''}`));
-        console.log(chalk.gray(`   查询执行: ${m.queryTime.toFixed(2)}ms`));
-        console.log(chalk.gray(`   总耗时: ${m.totalTime.toFixed(2)}ms`));
-        console.log(chalk.gray(`   索引大小: ${m.indexSize} 个条目`));
-    }
-}
-/**
- * Query 命令实现
- */
-export async function queryCommand(options) {
-    const rootDir = process.cwd();
-    const limit = options.limit || 50;
-    const useCache = options.cache !== false; // 默认启用缓存
-    const verbose = options.verbose || false;
-    const useRegex = options.regex || false;
-    const depsFormat = options.depsFormat || 'default';
-    const caseSensitive = options.caseSensitive || false;
-    const contextLines = typeof options.context === 'string' ? parseInt(options.context, 10) : (options.context || 0);
-    const includeReferences = options.includeReferences || false;
-    // 清除缓存（如果指定 --no-cache）
-    if (!useCache) {
-        clearCache();
-    }
-    // 加载代码地图（带缓存）
-    const startTotal = performance.now();
-    const { codeMap, index, cacheHit, loadTime } = loadCodeMap(rootDir, useCache);
-    if (!codeMap || !index) {
-        process.exit(1);
-    }
-    const indexLoadTime = loadTime;
-    const indexSize = index.symbols.size + index.modules.size + index.dependencies.size;
-    let result;
-    const queryStartTime = performance.now();
-    // 执行查询
-    if (options.symbol) {
-        const items = querySymbol(index, codeMap, options.symbol, limit, caseSensitive, includeReferences, contextLines);
-        result = {
-            type: 'symbol',
-            query: options.symbol,
-            count: items.length,
-            results: items,
-        };
-    }
-    else if (options.module) {
-        const items = queryModule(index, codeMap, options.module, limit);
-        result = {
-            type: 'module',
-            query: options.module,
-            count: items.length,
-            results: items,
-        };
-    }
-    else if (options.deps) {
-        // 依赖查询：根据 depsFormat 决定是否去重
-        // default 模式下去重，detailed 模式显示完整信息（包含 dependency 和 import）
-        const deduplicate = depsFormat !== 'detailed';
-        const items = queryDeps(index, codeMap, options.deps, limit, deduplicate);
-        result = {
-            type: 'deps',
-            query: options.deps,
-            count: items.length,
-            results: items,
-        };
-    }
-    else if (options.search) {
-        const items = search(index, codeMap, options.search, limit, useRegex, caseSensitive, contextLines);
-        result = {
-            type: 'search',
-            query: options.search,
-            count: items.length,
-            results: items,
-        };
-    }
-    else {
-        console.log(chalk.red('错误: 请指定查询类型: --symbol, --module, --deps, 或 --search'));
-        console.log(chalk.gray('\n用法:'));
-        console.log(chalk.gray('   codemap query --symbol <name>    # 查询符号'));
-        console.log(chalk.gray('   codemap query --module <path>   # 查询模块'));
-        console.log(chalk.gray('   codemap query --deps <name>    # 查询依赖'));
-        console.log(chalk.gray('   codemap query --search <word>  # 模糊搜索'));
-        console.log(chalk.gray('\n选项:'));
-        console.log(chalk.gray('   -l, --limit <number>  限制结果数量'));
-        console.log(chalk.gray('   -j, --json           JSON 格式输出'));
-        console.log(chalk.gray('   -v, --verbose        显示性能指标'));
-        console.log(chalk.gray('   -r, --regex          使用正则表达式搜索'));
-        console.log(chalk.gray('   --deps-format        依赖查询格式 (default|detailed)'));
-        console.log(chalk.gray('   --no-cache           禁用缓存'));
-        process.exit(1);
-    }
-    const queryTime = performance.now() - queryStartTime;
-    const totalTime = performance.now() - startTotal;
-    // 添加性能指标
-    if (verbose) {
-        result.metrics = {
-            indexLoadTime,
-            queryTime,
-            totalTime,
-            cacheHit,
-            indexSize,
-        };
+        progress.fail();
+        process.stdout.write(formatError(error, mode, 'codemap query') + '\n');
+        process.exitCode = 1;
     }
-    // 输出结果
-    formatResults(result, options.json || false, verbose, options.structured || false);
 }
 //# sourceMappingURL=query.js.map