@lorrylurui/code-intelligence-mcp 1.0.8 → 1.0.9

package/dist/indexer/extractMeta.js

@@ -1,7 +1,7 @@
 /**
  * 从 AST 抽取写入 `symbols.meta` 的结构化字段（props/params、hooks、返回值、类型成员等）。
  */
-import { Node, } from 'ts-morph';
+import { Node, SyntaxKind, } from 'ts-morph';
 /**
  * 将节点收窄为可调用的函数形态，便于统一抽取参数与函数体。
  * @returns 若不是函数声明/表达式/箭头函数则为 `undefined`。
@@ -77,7 +77,7 @@ export function extractReturnTypeText(fn) {
     return rt ? rt.getText() : null;
 }
 /**
- * 汇总单个可调用代码块的元数据：`params`、可选 `hooks`、可选 `returnType`。
+ * 汇总单个可调用代码块的元数据：`params`、可选 `hooks`、可选 `returnType`、可选 `sideEffects`。
  * @returns 扁平对象，由上层按 `component`/`util` 再映射为 `props` 或保留 `params`。
  */
 export function extractFunctionMeta(fn) {
@@ -85,11 +85,13 @@ export function extractFunctionMeta(fn) {
     const paramTypeFields = extractParamTypeFieldNames(fn);
     const hooks = extractHooksFromBody(fn);
     const returnType = extractReturnTypeText(fn);
+    const sideEffects = extractSideEffects(fn);
     return {
         params,
         ...(paramTypeFields.length ? { paramTypeFields } : {}),
         ...(hooks.length ? { hooks } : {}),
         ...(returnType ? { returnType } : {}),
+        ...(sideEffects.length ? { sideEffects } : {}),
     };
 }
 /**
@@ -116,3 +118,94 @@ export function extractInterfaceOrTypeMeta(node) {
     }
     return { kind: 'unknown' };
 }
+/**
+ * 静态分析函数体的副作用。
+ * @returns 副作用类型数组，去重排序后写入 `meta.sideEffects`。
+ */
+export function extractSideEffects(node) {
+    const effects = new Set();
+    // 1. 检测网络请求
+    node.forEachDescendant((n) => {
+        if (Node.isCallExpression(n)) {
+            const expr = n.getExpression();
+            const text = expr.getText().toLowerCase();
+            // fetch、axios、xhr、ajax、superagent 等
+            if (text === 'fetch' ||
+                text === 'axios' ||
+                text === 'xhr' ||
+                text === 'ajax' ||
+                text.startsWith('axios.') ||
+                text.includes('request')) {
+                effects.add('network');
+            }
+            // XMLHttpRequest
+            if (text.includes('xmlhttprequest')) {
+                effects.add('network');
+            }
+        }
+    });
+    // 2. 检测计时器
+    node.forEachDescendant((n) => {
+        if (Node.isCallExpression(n)) {
+            const text = n.getExpression().getText();
+            if (text === 'setTimeout' ||
+                text === 'setInterval' ||
+                text === 'requestAnimationFrame' ||
+                text === 'setImmediate') {
+                effects.add('timer');
+            }
+        }
+    });
+    // 3. 检测 DOM / 全局对象操作
+    node.forEachDescendant((n) => {
+        if (Node.isExpressionStatement(n)) {
+            const text = n.getText();
+            // document. / window. 开头的赋值或调用
+            if (/\bdocument\.\w+/.test(text) ||
+                /\bwindow\.\w+/.test(text) ||
+                /\bnavigator\.\w+/.test(text) ||
+                /\blocation\.\w+/.test(text)) {
+                // 区分读取和写入
+                if (/=/.test(text) && !text.includes('===') && !text.includes('==')) {
+                    effects.add('dom');
+                }
+            }
+        }
+    });
+    // 4. 检测存储操作
+    node.forEachDescendant((n) => {
+        if (Node.isCallExpression(n)) {
+            const text = n.getExpression().getText();
+            if (text.includes('localStorage') ||
+                text.includes('sessionStorage') ||
+                text.includes('cookie')) {
+                effects.add('storage');
+            }
+        }
+    });
+    // 5. 检测入参修改（检测 mutation pattern）
+    // 如 props.items.push(...), obj.x = ...
+    const params = node.getKind() === SyntaxKind.FunctionDeclaration
+        ? node.getParameters()
+        : node.getKind() === SyntaxKind.ArrowFunction
+            ? node.getParameters()
+            : node.getKind() === SyntaxKind.FunctionExpression
+                ? node.getParameters()
+                : [];
+    if (params.length > 0) {
+        const paramNames = new Set(params.map((p) => p.getName()));
+        node.forEachDescendant((n) => {
+            if (Node.isExpressionStatement(n)) {
+                const text = n.getText();
+                // 检测 param.x = ... 或 param.push/pop/splice 等
+                for (const param of paramNames) {
+                    if (text.includes(`${param}.`) || text.startsWith(`${param} =`)) {
+                        effects.add('mutation');
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    return [...effects].sort();
+}

package/dist/indexer/indexProject.js

@@ -1,5 +1,6 @@
 /**
  * 扫描源码目录，用 ts-morph 解析 TS/TSX，Babel 解析 JS/JSX，生成待写入 MySQL 的代码块行。
+ * 同时分析调用关系，填充 meta.callers / meta.callees。
  */
 import fg from 'fast-glob';
 import { join, resolve } from 'node:path';
@@ -159,6 +160,7 @@ const DEFAULT_IGNORE = [
 ];
 /**
  * 按 glob 收集文件，用 ts-morph 加载并遍历每个文件的导出，生成全部代码块行。
+ * 同时分析调用关系，填充 meta.callers / meta.callees。
  * @returns 数组可交给 `upsertSymbols`；无匹配文件时返回空数组（不写库）。
  */
 export async function indexProject(opts) {
@@ -181,6 +183,7 @@ export async function indexProject(opts) {
     const tsFiles = files.filter(isTsFile);
     const jsFiles = files.filter(isJsFile);
     const out = [];
+    const symbolMap = new Map(); // name -> { name, path, exports }
     // 处理 TS/TSX 文件（只有 tsconfig.json 存在时才处理）
     const tsConfigPath = join(projectRoot, 'tsconfig.json');
     const hasTsConfig = existsSync(tsConfigPath);
@@ -192,12 +195,19 @@ export async function indexProject(opts) {
         });
         project.addSourceFilesAtPaths(tsFiles);
         for (const sf of project.getSourceFiles()) {
+            const relPath = getRelativePathForDisplay(projectRoot, sf.getFilePath());
             const exported = sf.getExportedDeclarations();
             for (const [exportName, decls] of exported) {
                 for (const decl of decls) {
                     const row = processDeclaration(exportName, decl, sf, projectRoot);
                     if (row) {
                         out.push(row);
+                        // 建立符号映射
+                        const key = `${row.name}|${row.path}`;
+                        if (!symbolMap.has(key)) {
+                            symbolMap.set(key, { name: row.name, path: row.path, exports: new Set() });
+                        }
+                        symbolMap.get(key).exports.add(exportName);
                     }
                 }
             }
@@ -209,10 +219,107 @@ export async function indexProject(opts) {
             const content = readFileSync(file, 'utf-8');
             const rows = parseJsFile(file, content, projectRoot);
             out.push(...rows);
+            // 建立符号映射
+            for (const row of rows) {
+                const key = `${row.name}|${row.path}`;
+                if (!symbolMap.has(key)) {
+                    symbolMap.set(key, { name: row.name, path: row.path, exports: new Set() });
+                }
+                symbolMap.get(key).exports.add(row.name);
+            }
         }
         catch (e) {
             console.error(`[indexProject] Failed to parse ${file}:`, e);
         }
     }
+    // 分析调用关系，填充 meta.callers / meta.callees
+    if (tsFiles.length > 0 && hasTsConfig) {
+        const project = new Project({
+            tsConfigFilePath: tsConfigPath,
+            skipAddingFilesFromTsConfig: true,
+            skipFileDependencyResolution: true,
+        });
+        project.addSourceFilesAtPaths(tsFiles);
+        analyzeRelations(project, symbolMap, projectRoot, out);
+    }
     return out;
 }
+/**
+ * 分析调用关系，填充每个符号的 meta.callers 和 meta.callees
+ */
+function analyzeRelations(project, symbolMap, projectRoot, rows) {
+    // 构造快速查找：exportName -> [ {name, path} ]
+    const exportToSymbol = new Map();
+    for (const [key, value] of symbolMap) {
+        for (const exp of value.exports) {
+            const list = exportToSymbol.get(exp) || [];
+            list.push({ name: value.name, path: value.path });
+            exportToSymbol.set(exp, list);
+        }
+    }
+    // 收集所有 callers 和 callees
+    const callersMap = new Map(); // key = "name|path" -> set of callers
+    const calleesMap = new Map(); // key = "name|path" -> set of callees
+    for (const sf of project.getSourceFiles()) {
+        const filePath = sf.getFilePath();
+        const relPath = getRelativePathForDisplay(projectRoot, filePath);
+        // 获取当前文件导出的符号
+        const exported = sf.getExportedDeclarations();
+        const fileExportNames = new Set();
+        for (const [name, decls] of exported) {
+            fileExportNames.add(name);
+        }
+        // 遍历 AST 查找调用
+        sf.forEachDescendant((node) => {
+            // 1. 函数调用
+            if (Node.isCallExpression(node)) {
+                const expr = node.getExpression();
+                const name = Node.isIdentifier(expr) ? expr.getText() : null;
+                if (name && exportToSymbol.has(name)) {
+                    const targets = exportToSymbol.get(name);
+                    // 当前文件是谁在调用
+                    for (const [expName, decls] of exported) {
+                        for (const decl of decls) {
+                            const callerKey = `${expName}|${relPath}`;
+                            for (const target of targets) {
+                                // callees: 我调用了谁
+                                const calleeSet = calleesMap.get(callerKey) || new Set();
+                                calleeSet.add({ name: target.name, path: target.path });
+                                calleesMap.set(callerKey, calleeSet);
+                                // callers: 谁调用了我
+                                const callerSet = callersMap.get(`${target.name}|${target.path}`) || new Set();
+                                callerSet.add({ name: expName, path: relPath });
+                                callersMap.set(`${target.name}|${target.path}`, callerSet);
+                            }
+                        }
+                    }
+                }
+            }
+            // 2. Import 导入
+            if (Node.isImportDeclaration(node)) {
+                const moduleSpec = node.getModuleSpecifier().getText();
+                // 简单处理：只处理从 ./ 或 ../ 开始的相对导入
+                if (moduleSpec.startsWith("'.") || moduleSpec.startsWith('".')) {
+                    const importPath = moduleSpec.slice(1, -1); // 去掉引号
+                    // 尝试匹配已索引的符号
+                    // 这里简化处理，暂不展开
+                }
+            }
+        });
+    }
+    // 写入 rows 的 meta
+    for (const row of rows) {
+        const key = `${row.name}|${row.path}`;
+        const callers = callersMap.get(key);
+        const callees = calleesMap.get(key);
+        if (callers && callers.size > 0) {
+            row.meta = row.meta || {};
+            row.meta.callers = [...callers].slice(0, 20); // 限制数量
+        }
+        if (callees && callees.size > 0) {
+            row.meta = row.meta || {};
+            row.meta.callees = [...callees].slice(0, 20);
+        }
+    }
+    console.error(`[analyzeRelations] processed ${rows.length} symbols`);
+}

package/dist/prompts/reusableCodeAdvisorPrompt.js

@@ -22,9 +22,11 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 
 按此结构输出（字段名可保留英文或改为中文小标题，二选一全文统一）：
 
-- **首选：** \`<代码块名>\`
+- **首选：** <代码块名>
+- **使用范围：** 展示 meta.callers（被哪些模块调用），用于评估稳定性和适用范围；若无调用记录则显示"新增"
+- **副作用：** 展示 meta.sideEffects（network/timer/dom/storage/mutation），优先推荐无副作用的方案，标注有副作用的方案风险
 - **理由：** 1～3 条要点
-- **其他候选：** 简要列出及取舍
+- **其他候选：** 简要列出及取舍（同步标注副作用）
 - **用法提示：** 结合用户场景的最小集成说明
 
 ## 约束
@@ -33,6 +35,12 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 - 若无合适代码块，明确说明，并给出最接近的选项及差距。
 - 推理简洁，面向落地实现。
 
+## 使用反馈
+
+当最终采纳了某个推荐代码块后，必须调用 inc_usage 工具记录采纳行为：
+“请调用 inc_usage({ symbolId: <选中的代码块 id> })”
+其中 symbolId 从 search_symbols 或 search_by_structure 返回结果的 id 字段获取。这条记录会用于后续排序优化。
+
 ## 更多示例
 
 与仓库内 \`.cursor/skills/reusable-code-advisor/examples.md\` 中的示例一致（在 Cursor 或本地打开该文件查看）。

package/dist/repositories/symbolRepository.js

@@ -167,6 +167,22 @@ export class SymbolRepository {
         }
         return mapRow(rows[0]);
     }
+    /**
+     * 将指定代码块的 usage_count +1，用于用户采纳推荐后记录。
+     */
+    async incUsage(symbolId) {
+        if (!this.pool) {
+            // 内存模式：找到并 +1
+            const idx = inMemorySymbols.findIndex((s) => s.id === symbolId);
+            if (idx >= 0) {
+                inMemorySymbols[idx].usageCount++;
+                return true;
+            }
+            return false;
+        }
+        const [result] = await this.pool.query(`UPDATE ${env.mysqlSymbolsTable} SET usage_count = usage_count + 1 WHERE id = ?`, [symbolId]);
+        return result.affectedRows > 0;
+    }
     async searchByStructure(fields, opts) {
         const normalized = fields.map((f) => f.trim()).filter(Boolean);
         if (normalized.length === 0)

package/dist/server/createServer.js

@@ -5,6 +5,7 @@ import { createSearchSymbolsTool } from "../tools/searchSymbols.js";
 import { createGetSymbolDetailTool } from "../tools/getSymbolDetail.js";
 import { createReindexTool } from "../tools/reindex.js";
 import { createSearchByStructureTool } from "../tools/searchByStructure.js";
+import { createIncUsageTool } from "../tools/incUsage.js";
 export function createServer() {
     const server = new McpServer({
         name: "code-intelligence-mcp",
@@ -19,6 +20,8 @@ export function createServer() {
     server.tool(structureTool.name, structureTool.description, structureTool.inputSchema, structureTool.handler);
     const reindexTool = createReindexTool();
     server.tool(reindexTool.name, reindexTool.description, reindexTool.inputSchema, reindexTool.handler);
+    const incUsageTool = createIncUsageTool(repository);
+    server.tool(incUsageTool.name, incUsageTool.description, incUsageTool.inputSchema, incUsageTool.handler);
     registerReusableCodeAdvisorPrompt(server);
     return server;
 }

package/dist/tools/incUsage.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export const incUsageInput = z.object({
+    /** 要增加使用计数的代码块 ID（从搜索结果中获取） */
+    symbolId: z.number().int().positive(),
+});
+export function createIncUsageTool(repository) {
+    return {
+        name: 'inc_usage',
+        description: '当开发者采纳了某个推荐代码块时，调用此工具记录。usage_count 会 +1，用于后续排序优化。',
+        inputSchema: incUsageInput.shape,
+        handler: async (input) => {
+            const success = await repository.incUsage(input.symbolId);
+            if (!success) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ error: '未找到该代码块', symbolId: input.symbolId }, null, 2),
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ ok: true, symbolId: input.symbolId, message: 'usage_count 已 +1' }, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+}

package/dist/tools/searchByStructure.js

@@ -22,6 +22,7 @@ export function createSearchByStructureTool(repository) {
             const query = input.fields.join(' ');
             const resultRows = input.ranked
                 ? rankSymbols(query, rows).map((item) => ({
+                    id: item.symbol.id,
                     name: item.symbol.name,
                     type: item.symbol.type,
                     category: item.symbol.category,
@@ -34,6 +35,7 @@ export function createSearchByStructureTool(repository) {
                     meta: item.symbol.meta,
                 }))
                 : rows.map((r) => ({
+                    id: r.id,
                     name: r.name,
                     type: r.type,
                     category: r.category,

package/dist/tools/searchSymbols.js

@@ -22,6 +22,7 @@ export function createSearchSymbolsTool(repository) {
                 const simById = new Map(hits.map((h) => [h.symbol.id, h.similarity]));
                 const resultRows = input.ranked
                     ? rankSemanticHits(hits).map((item) => ({
+                        id: item.symbol.id,
                         name: item.symbol.name,
                         type: item.symbol.type,
                         path: item.symbol.path,
@@ -33,6 +34,7 @@ export function createSearchSymbolsTool(repository) {
                         semanticSimilarity: Number((simById.get(item.symbol.id) ?? 0).toFixed(4)),
                     }))
                     : hits.map((h) => ({
+                        id: h.symbol.id,
                         name: h.symbol.name,
                         type: h.symbol.type,
                         path: h.symbol.path,
@@ -52,6 +54,7 @@ export function createSearchSymbolsTool(repository) {
             const rows = await repository.search(input.query, input.type);
             const resultRows = input.ranked
                 ? rankSymbols(input.query, rows).map((item) => ({
+                    id: item.symbol.id,
                     name: item.symbol.name,
                     type: item.symbol.type,
                     path: item.symbol.path,
@@ -62,6 +65,7 @@ export function createSearchSymbolsTool(repository) {
                     reasonDetail: item.reason,
                 }))
                 : rows.map((r) => ({
+                    id: r.id,
                     name: r.name,
                     type: r.type,
                     path: r.path,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lorrylurui/code-intelligence-mcp",
-    "version": "1.0.8",
+    "version": "1.0.9",
     "private": false,
     "description": "MCP server 提供仓库内可复用代码块（ts/tsx/js/jsx/css/less）的索引和查询能力，支持基于代码上下文的智能推荐。",
     "type": "module",