@lorrylurui/code-intelligence-mcp 1.0.1

package/dist/db/mysql.js

@@ -0,0 +1,20 @@
+import mysql from "mysql2/promise";
+import { env } from "../config/env.js";
+let pool = null;
+export function getMySqlPool() {
+    if (!env.mysqlEnabled) {
+        return null;
+    }
+    if (!pool) {
+        pool = mysql.createPool({
+            host: env.mysqlHost,
+            port: env.mysqlPort,
+            user: env.mysqlUser,
+            password: env.mysqlPassword,
+            database: env.mysqlDatabase,
+            waitForConnections: true,
+            connectionLimit: 10
+        });
+    }
+    return pool;
+}

package/dist/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { validateEnv } from './config/env.js';
+import { createServer } from './server/createServer.js';
+async function main() {
+    validateEnv();
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error('MCP 服务启动失败：', error);
+    process.exit(1);
+});

package/dist/indexer/embedText.js

@@ -0,0 +1,28 @@
+function briefMeta(meta) {
+    const keys = ["props", "params", "properties", "hooks"];
+    const parts = [];
+    for (const k of keys) {
+        const v = meta[k];
+        if (Array.isArray(v)) {
+            const strs = v.filter((x) => typeof x === "string");
+            if (strs.length)
+                parts.push(`${k}: ${strs.slice(0, 24).join(", ")}`);
+        }
+    }
+    return parts.join("; ");
+}
+/**
+ * 拼成一段供向量模型编码的文本（名称、路径、注释、meta 摘要、源码片段）。
+ */
+export function indexedRowToEmbedText(row) {
+    const metaBit = briefMeta(row.meta);
+    return [
+        `${row.type} ${row.name}`,
+        row.path,
+        row.description ?? "",
+        metaBit,
+        (row.content ?? "").slice(0, 1200)
+    ]
+        .filter((s) => s.length > 0)
+        .join("\n");
+}

package/dist/indexer/extractMeta.js

@@ -0,0 +1,118 @@
+/**
+ * 从 AST 抽取写入 `symbols.meta` 的结构化字段（props/params、hooks、返回值、类型成员等）。
+ */
+import { Node, } from 'ts-morph';
+/**
+ * 将节点收窄为可调用的函数形态，便于统一抽取参数与函数体。
+ * @returns 若不是函数声明/表达式/箭头函数则为 `undefined`。
+ */
+function asFn(node) {
+    if (Node.isFunctionDeclaration(node))
+        return node;
+    if (Node.isFunctionExpression(node))
+        return node;
+    if (Node.isArrowFunction(node))
+        return node;
+    return undefined;
+}
+/**
+ * 取第一个形参的「对外可见名」：对象解构取各属性名，单参数取标识符文本。
+ * @returns 用于后续在 `component` 中映射为 `props`，在 `util` 中保留为 `params`。
+ */
+function extractParamNames(fn) {
+    const params = fn.getParameters();
+    if (params.length === 0)
+        return [];
+    const first = params[0];
+    const nameNode = first.getNameNode();
+    if (Node.isObjectBindingPattern(nameNode)) {
+        return nameNode.getElements().map((el) => el.getName());
+    }
+    if (Node.isIdentifier(nameNode)) {
+        return [nameNode.getText()];
+    }
+    return [];
+}
+/**
+ * 从第一个参数的类型信息提取字段名（例如 `props: DialogProps` -> `title/content/onClose`）。
+ * @returns 若无可解析类型或无法安全推断，则返回空数组。
+ */
+function extractParamTypeFieldNames(fn) {
+    const params = fn.getParameters();
+    if (params.length === 0)
+        return [];
+    const first = params[0];
+    const type = first.getType();
+    const properties = type.getProperties();
+    if (!properties.length)
+        return [];
+    const names = properties.map((p) => p.getName());
+    // 防止出现泛型对象原型噪音字段。
+    return names.filter((n) => n !== '__type');
+}
+/**
+ * 在函数体内收集形如 `useXxx(...)` 的调用名（React Hooks 约定）。
+ * @returns 去重、排序后的钩子名列表，写入 `meta.hooks`；无则为空数组。
+ */
+export function extractHooksFromBody(node) {
+    const seen = new Set();
+    node.forEachDescendant((n) => {
+        if (Node.isCallExpression(n)) {
+            const ex = n.getExpression();
+            if (Node.isIdentifier(ex)) {
+                const id = ex.getText();
+                if (id.startsWith('use'))
+                    seen.add(id);
+            }
+        }
+    });
+    return [...seen].sort();
+}
+/**
+ * 读取显式标注的返回类型节点文本（无则 `null`）。
+ * @returns 写入 `meta.returnType`，供检索与对比工具函数签名。
+ */
+export function extractReturnTypeText(fn) {
+    const rt = fn.getReturnTypeNode();
+    return rt ? rt.getText() : null;
+}
+/**
+ * 汇总单个可调用代码块的元数据：`params`、可选 `hooks`、可选 `returnType`。
+ * @returns 扁平对象，由上层按 `component`/`util` 再映射为 `props` 或保留 `params`。
+ */
+export function extractFunctionMeta(fn) {
+    const params = extractParamNames(fn);
+    const paramTypeFields = extractParamTypeFieldNames(fn);
+    const hooks = extractHooksFromBody(fn);
+    const returnType = extractReturnTypeText(fn);
+    return {
+        params,
+        ...(paramTypeFields.length ? { paramTypeFields } : {}),
+        ...(hooks.length ? { hooks } : {}),
+        ...(returnType ? { returnType } : {}),
+    };
+}
+/**
+ * 若节点本身是函数声明/表达式/箭头函数，则抽取 `extractFunctionMeta` 结果。
+ * @returns 非可调用节点时为 `null`。
+ */
+export function extractMetaFromCallable(node) {
+    const fn = asFn(node);
+    if (!fn)
+        return null;
+    return extractFunctionMeta(fn);
+}
+/**
+ * 为 `interface` / `type` 代码块构造 `meta`：`interface` 带属性名列表，别名仅标记 `typeAlias`。
+ * @returns 写入 `symbols.meta`，供结构化搜索（如按属性名）扩展使用。
+ */
+export function extractInterfaceOrTypeMeta(node) {
+    if (Node.isInterfaceDeclaration(node)) {
+        const props = node.getProperties().map((p) => p.getName());
+        return { kind: 'interface', properties: props };
+    }
+    if (Node.isTypeAliasDeclaration(node)) {
+        return { kind: 'typeAlias' };
+    }
+    return { kind: 'unknown' };
+}

package/dist/indexer/heuristics.js

@@ -0,0 +1,96 @@
+/**
+ * JSX 检测、路径/selector 启发式、JSDoc 摘要、相对路径。
+ */
+import { SyntaxKind } from "ts-morph";
+/**
+ * 判断源文件路径是否为 TSX（React JSX 语法所在扩展名）。
+ * @returns `true` 表示按「可能出现 JSX」处理，用于与 `.ts` 区分组件启发式。
+ */
+export function isTsxFile(filePath) {
+    return filePath.toLowerCase().endsWith(".tsx");
+}
+/**
+ * 在 AST 子树中是否出现 JSX 节点（元素、自闭合标签或 Fragment）。
+ * @returns `true` 表示该导出更像 React 组件（与 `isTsxFile` 等组合用于分类）。
+ */
+export function hasJsxInNode(node) {
+    let found = false;
+    node.forEachDescendant((n) => {
+        const k = n.getKind();
+        if (k === SyntaxKind.JsxElement ||
+            k === SyntaxKind.JsxSelfClosingElement ||
+            k === SyntaxKind.JsxFragment) {
+            found = true;
+            return false;
+        }
+    });
+    return found;
+}
+/**
+ * 从文件路径推断业务语义目录名（如 `.../components/form/Button.tsx` → `form`）。
+ * @returns 命中 `components|features|...` 下一级目录名；无法推断时为 `null`，写入 DB 的 `category` 字段。
+ */
+export function inferCategoryFromPath(filePath) {
+    const norm = filePath.replace(/\\/g, "/");
+    const parts = norm.split("/");
+    const markers = ["components", "features", "modules", "pages", "widgets", "hooks"];
+    for (let i = 0; i < parts.length; i++) {
+        const m = markers.indexOf(parts[i]);
+        if (m >= 0 && parts[i + 1]) {
+            return parts[i + 1];
+        }
+    }
+    return null;
+}
+/**
+ * 启发式判断导出是否更像状态选择器（selector）。
+ * @returns `true` 时索引类型记为 `selector`，否则同文件下函数多为 `util`。
+ */
+export function isSelectorLike(filePath, exportName) {
+    const lowerPath = filePath.toLowerCase();
+    if (lowerPath.includes("selector"))
+        return true;
+    if (/selector$/i.test(exportName))
+        return true;
+    return false;
+}
+/**
+ * 读取节点（或父节点）上第一段 JSDoc 的 **描述正文**（不含 `@tag`）。
+ * @returns 供写入 `symbols.description`；无注释时为 `null`。
+ */
+export function getLeadingDocDescription(node) {
+    const tryNode = (n) => {
+        const jd = n.getJsDocs;
+        if (typeof jd !== "function")
+            return null;
+        const docs = jd.call(n);
+        if (!docs?.length)
+            return null;
+        const t = docs[0].getDescription().trim();
+        return t || null;
+    };
+    return tryNode(node) ?? (node.getParent() ? tryNode(node.getParent()) : null);
+}
+/**
+ * 将绝对路径转为相对 `projectRoot` 的路径，作为库中 `symbols.path`（便于跨机器、展示）。
+ * @returns 相对路径；若无法裁掉前缀则回退为原始绝对路径。
+ */
+export function getRelativePathForDisplay(projectRoot, absolutePath) {
+    const r = projectRoot.replace(/\\/g, "/");
+    const a = absolutePath.replace(/\\/g, "/");
+    if (a.startsWith(r)) {
+        return a.slice(r.length + 1);
+    }
+    return absolutePath;
+}
+/**
+ * 截取节点对应源码文本，用于 `symbols.content`（全文检索或人工核对）。
+ * @param maxLen 超长时截断并追加注释标记，避免单行 MEDIUMTEXT 过大。
+ * @returns 源码字符串；无额外语义，仅作存档片段。
+ */
+export function snippetForNode(node, maxLen = 4000) {
+    const raw = node.getText();
+    if (raw.length <= maxLen)
+        return raw;
+    return raw.slice(0, maxLen) + "\n/* ... truncated ... */";
+}

package/dist/indexer/indexProject.js

@@ -0,0 +1,178 @@
+/**
+ * 扫描源码目录，用 ts-morph 解析导出并生成待写入 MySQL 的代码块行。
+ */
+import fg from 'fast-glob';
+import { join, resolve } from 'node:path';
+import { Node, Project } from 'ts-morph';
+import { extractInterfaceOrTypeMeta, extractMetaFromCallable, } from './extractMeta.js';
+import { getLeadingDocDescription, getRelativePathForDisplay, hasJsxInNode, inferCategoryFromPath, isSelectorLike, isTsxFile, snippetForNode, } from './heuristics.js';
+/**
+ * 将 `extractFunctionMeta` 的 `params` 转为组件用的 `props` 名，或保留为 `params`。
+ * @returns 供 `IndexedSymbolRow.meta` 序列化入库。
+ */
+function mergeCallableMeta(symbolType, raw) {
+    if (!raw)
+        return {};
+    const params = raw.params;
+    const paramTypeFields = raw.paramTypeFields;
+    const { params: _p, paramTypeFields: _f, ...rest } = raw;
+    if (symbolType === 'component' && params?.length) {
+        const props = [
+            ...new Set([...(paramTypeFields ?? []), ...params]),
+        ].filter((name) => name.toLowerCase() !== 'props');
+        return { ...rest, props: props.length ? props : params };
+    }
+    return { ...rest, ...(params?.length ? { params } : {}) };
+}
+/**
+ * 将 MCP/ts 的 `default` 导出键还原为具体代码块名（函数名、变量名、类名）。
+ * @returns 用于 `IndexedSymbolRow.name` 与去重键 `(path, name)`。
+ */
+function resolveExportName(exportName, decl) {
+    if (exportName !== 'default')
+        return exportName;
+    if (Node.isFunctionDeclaration(decl) && decl.getName()) {
+        return decl.getName();
+    }
+    if (Node.isVariableDeclaration(decl)) {
+        return decl.getName();
+    }
+    if (Node.isClassDeclaration(decl) && decl.getName()) {
+        return decl.getName();
+    }
+    return 'default';
+}
+/**
+ * 将单个导出声明转为一条索引行；不支持的声明类型返回 `null`。
+ * @returns 成功时含分类结果与 meta，供 `persistSymbols` 写入数据库。
+ */
+function processDeclaration(exportName, decl, sf, projectRoot) {
+    const filePath = sf.getFilePath();
+    const relPath = getRelativePathForDisplay(projectRoot, filePath);
+    const category = inferCategoryFromPath(filePath);
+    const name = resolveExportName(exportName, decl);
+    const description = getLeadingDocDescription(decl) ?? null;
+    if (Node.isInterfaceDeclaration(decl) ||
+        Node.isTypeAliasDeclaration(decl)) {
+        const meta = extractInterfaceOrTypeMeta(decl);
+        return {
+            name,
+            type: 'type',
+            category,
+            path: relPath,
+            description,
+            content: snippetForNode(decl),
+            meta,
+        };
+    }
+    if (Node.isFunctionDeclaration(decl)) {
+        const jsx = isTsxFile(filePath) && hasJsxInNode(decl);
+        const type = jsx
+            ? 'component'
+            : isSelectorLike(filePath, name)
+                ? 'selector'
+                : 'util';
+        const raw = extractMetaFromCallable(decl);
+        const meta = mergeCallableMeta(type, raw);
+        return {
+            name,
+            type,
+            category,
+            path: relPath,
+            description,
+            content: snippetForNode(decl),
+            meta,
+        };
+    }
+    if (Node.isVariableDeclaration(decl)) {
+        const init = decl.getInitializer();
+        if (!init)
+            return null;
+        let callable;
+        if (Node.isArrowFunction(init) || Node.isFunctionExpression(init)) {
+            callable = init;
+        }
+        else if (Node.isCallExpression(init)) {
+            const arg0 = init.getArguments()[0];
+            if (arg0 &&
+                (Node.isArrowFunction(arg0) || Node.isFunctionExpression(arg0))) {
+                callable = arg0;
+            }
+        }
+        if (!callable)
+            return null;
+        const jsx = isTsxFile(filePath) && hasJsxInNode(callable);
+        const type = jsx
+            ? 'component'
+            : isSelectorLike(filePath, name)
+                ? 'selector'
+                : 'util';
+        const raw = extractMetaFromCallable(callable);
+        const meta = mergeCallableMeta(type, raw);
+        return {
+            name,
+            type,
+            category,
+            path: relPath,
+            description,
+            content: snippetForNode(callable),
+            meta,
+        };
+    }
+    if (Node.isClassDeclaration(decl)) {
+        // 轻量：仅将 class 记为 util（后续可扩展为带 JSX 的组件类）
+        return {
+            name,
+            type: 'util',
+            category,
+            path: relPath,
+            description,
+            content: snippetForNode(decl),
+            meta: { kind: 'class' },
+        };
+    }
+    return null;
+}
+const DEFAULT_IGNORE = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/.git/**',
+    '**/coverage/**',
+];
+/**
+ * 按 glob 收集文件，用 ts-morph 加载并遍历每个文件的导出，生成全部代码块行。
+ * @returns 数组可交给 `upsertSymbols`；无匹配文件时返回空数组（不写库）。
+ */
+export async function indexProject(opts) {
+    const projectRoot = resolve(opts.projectRoot);
+    const patterns = (opts.globPatterns ?? ['src/**/*.{ts,tsx}']).map((p) => p.startsWith('/') ? p : join(projectRoot, p).replace(/\\/g, '/'));
+    const ignore = [...DEFAULT_IGNORE, ...(opts.ignore ?? [])];
+    const files = await fg(patterns, {
+        absolute: true,
+        ignore,
+        onlyFiles: true,
+        dot: false,
+    });
+    if (files.length === 0) {
+        return [];
+    }
+    const project = new Project({
+        tsConfigFilePath: join(projectRoot, 'tsconfig.json'),
+        skipAddingFilesFromTsConfig: true,
+        skipFileDependencyResolution: true,
+    });
+    project.addSourceFilesAtPaths(files);
+    const out = [];
+    for (const sf of project.getSourceFiles()) {
+        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);
+                }
+            }
+        }
+    }
+    return out;
+}

package/dist/indexer/persistSymbols.js

@@ -0,0 +1,55 @@
+/**
+ * 依赖表上 `(path, name)` 唯一键：新行插入，已存在则更新类型/描述/内容与 meta；**不**修改 `usage_count`。
+ * @param rows 来自 `indexProject`；空数组时立即返回，不开启事务。
+ * @param embeddings 与 `rows` 等长；某项为 `null` 表示本行不更新已有 `embedding`（新行则写入 NULL）。
+ * @returns Promise 在提交成功时 resolve；任一行失败则整批回滚并抛出异常。
+ */
+export async function upsertSymbols(pool, rows, embeddings) {
+    if (rows.length === 0)
+        return;
+    if (embeddings && embeddings.length !== rows.length) {
+        throw new Error("upsertSymbols: embeddings length must match rows");
+    }
+    const actor = process.env.GITHUB_USERNAME?.trim() || "LorryIsLuRui";
+    const sql = `
+    INSERT INTO symbols (name, type, category, path, description, content, meta, insert_user, updated_user, embedding)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON DUPLICATE KEY UPDATE
+      type = VALUES(type),
+      category = VALUES(category),
+      description = VALUES(description),
+      content = VALUES(content),
+      meta = VALUES(meta),
+      updated_user = VALUES(updated_user),
+      embedding = CASE WHEN VALUES(embedding) IS NOT NULL THEN VALUES(embedding) ELSE embedding END
+  `;
+    const conn = await pool.getConnection();
+    try {
+        await conn.beginTransaction();
+        for (let i = 0; i < rows.length; i++) {
+            const r = rows[i];
+            const emb = embeddings?.[i];
+            const embJson = emb !== undefined && emb !== null ? JSON.stringify(emb) : null;
+            await conn.query(sql, [
+                r.name,
+                r.type,
+                r.category,
+                r.path,
+                r.description,
+                r.content,
+                JSON.stringify(r.meta),
+                actor,
+                actor,
+                embJson
+            ]);
+        }
+        await conn.commit();
+    }
+    catch (e) {
+        await conn.rollback();
+        throw e;
+    }
+    finally {
+        conn.release();
+    }
+}

package/dist/prompts/recommendComponentPrompt.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+const DESCRIPTION = "使用 recommend_component 流程推荐最合适的可复用组件候选。";
+export function registerRecommendComponentPrompt(server) {
+    server.prompt("recommend-component", DESCRIPTION, {
+        requirement: z.string().describe("用户需求描述，例如：带校验的表单组件"),
+        props: z
+            .array(z.string())
+            .optional()
+            .describe("结构过滤所需的可选 props，例如 onChange,value")
+    }, async (args) => {
+        const propsHint = args.props?.length
+            ? `\n并传入 props 参数：${JSON.stringify(args.props)}`
+            : "";
+        return {
+            description: DESCRIPTION,
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `你正在执行 Phase 4 的 skill 验证流程。\n` +
+                            `1）调用 recommend_component，query 参数为：${JSON.stringify(args.requirement)}。${propsHint}\n` +
+                            `2）返回 Top 结果，并给出 score、reason 以及使用建议。\n` +
+                            `3）如果没有结果，请明确说明缺口，并给出最接近的候选项。`
+                    }
+                }
+            ]
+        };
+    });
+}

package/dist/prompts/reusableCodeAdvisorPrompt.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+const REUSABLE_CODE_ADVISOR_DESCRIPTION = '在实现需求时检索并推荐最合适的可复用代码代码块（函数/类/模块等）。在用户要求复用现有代码、询问是否已有组件/函数/服务、或要在多个代码块中选最优时使用。';
+/** 与 SKILL.md 中 `# 可复用代码推荐` 起至约束、示例说明为止的正文一致（无 YAML frontmatter）。 */
+const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
+
+## 工作流
+
+当用户需要可复用代码或实现类需求时，按顺序执行：
+
+1. 先判断意图：若意图是“组件推荐”（如推荐表单组件、弹窗组件、列表组件等），优先调用 \`recommend_component\`；否则走通用多工具流程。
+2. 通用多工具流程中，先调用 \`search_symbols\` 检索可能满足需求的候选代码块；query 用短英文/关键词（如 formInput），需要限定类型时再加 type（如 component），不要用整句中文。
+3. 执行细则：先 \`search_symbols(limit=20)\` 拉候选，再对 Top 3 调用 \`get_symbol_detail\` 做深度判断。
+4. 若仅凭签名/摘要无法判断，对最相关的若干候选调用 \`get_symbol_detail\` 获取详情。
+5. 从以下维度对比候选：
+   - 与用户需求的**功能匹配度**
+   - **API 是否简单**、入参是否合适
+   - **依赖与副作用**风险
+   - **复用安全性**（稳定性、耦合度、是否便于扩展）
+6. 给出**唯一首选**推荐，并说明理由。
+
+## 回复结构
+
+按此结构输出（字段名可保留英文或改为中文小标题，二选一全文统一）：
+
+- **首选：** \`<代码块名>\`
+- **理由：** 1～3 条要点
+- **其他候选：** 简要列出及取舍
+- **用法提示：** 结合用户场景的最小集成说明
+
+## 约束
+
+- 优先推荐已有可复用代码块，避免轻易建议新写一套。
+- 若无合适代码块，明确说明，并给出最接近的选项及差距。
+- 推理简洁，面向落地实现。
+
+## 更多示例
+
+与仓库内 \`.cursor/skills/reusable-code-advisor/examples.md\` 中的示例一致（在 Cursor 或本地打开该文件查看）。
+`;
+export function registerReusableCodeAdvisorPrompt(server) {
+    server.prompt('reusable-code-advisor', REUSABLE_CODE_ADVISOR_DESCRIPTION, {
+        userRequest: z
+            .string()
+            .optional()
+            .describe('用户当前需求或关键词，用于聚焦检索与推荐（可选）'),
+    }, async (args) => {
+        const suffix = args.userRequest?.trim()
+            ? `\n\n## 当前上下文\n\n${args.userRequest.trim()}\n`
+            : '';
+        return {
+            description: REUSABLE_CODE_ADVISOR_DESCRIPTION,
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `${REUSABLE_CODE_ADVISOR_MARKDOWN}${suffix}`,
+                    },
+                },
+            ],
+        };
+    });
+}