@lorrylurui/code-intelligence-mcp 2.0.4 → 2.0.5

package/dist/repositories/symbolRepository.js

@@ -2,7 +2,7 @@ import { env } from '../config/env.js';
 import { getPool } from '../db/postgres.js';
 import { createEmbeddingClient } from '../services/embeddingClient.js';
 import { SEARCHABLE_STATUS } from '../config/symbolStatus.js';
-const SIMILARITY_THRESHOLD = 0.5;
+const SIMILARITY_THRESHOLD = 0;
 const TOP_K = 20;
 const inMemorySymbols = [
     {
@@ -82,21 +82,58 @@ function getMetaArray(meta, key) {
         return [];
     return value.filter((v) => typeof v === 'string');
 }
+function extractSearchTokens(query) {
+    const tokens = new Set();
+    const normalized = query.trim().toLowerCase();
+    for (const match of normalized.matchAll(/[a-z0-9_]+/g)) {
+        if (match[0].length >= 2)
+            tokens.add(match[0]);
+    }
+    for (const match of query.matchAll(/[\u4e00-\u9fff]{2,}/g)) {
+        const text = match[0];
+        for (let index = 0; index < text.length - 1; index += 1) {
+            tokens.add(text.slice(index, index + 2));
+        }
+    }
+    return [...tokens];
+}
+function buildSearchText(symbol) {
+    return [
+        symbol.name,
+        symbol.path,
+        symbol.description ?? '',
+        JSON.stringify(symbol.meta ?? {}),
+    ]
+        .join(' ')
+        .toLowerCase();
+}
+function countTokenMatches(text, tokens) {
+    return tokens.reduce((count, token) => text.includes(token.toLowerCase()) ? count + 1 : count, 0);
+}
 export class SymbolRepository {
     pool;
     constructor() {
         this.pool = getPool();
     }
     async search(query, type) {
+        console.error('[code-intelligence-mcp] repository.search.start query=%s type=%s table=%s searchableStatus=%s hasPool=%s', query, type ?? '', env.symbolsTable, String(SEARCHABLE_STATUS), String(Boolean(this.pool)));
         if (!this.pool) {
             const q = query.toLowerCase();
-            return inMemorySymbols.filter((s) => {
+            const tokens = extractSearchTokens(query);
+            const matched = inMemorySymbols.filter((s) => {
                 const typeOk = type ? s.type === type : true;
+                const text = buildSearchText(s);
                 return (typeOk &&
-                    (s.name.toLowerCase().includes(q) ||
-                        (s.description ?? '').toLowerCase().includes(q)));
+                    (text.includes(q) || countTokenMatches(text, tokens) >= 2));
             });
+            console.error('[code-intelligence-mcp] repository.search.memory count=%s top=%s', String(matched.length), JSON.stringify(matched.slice(0, 3).map((s) => ({
+                id: s.id,
+                name: s.name,
+                path: s.path,
+            }))));
+            return matched;
         }
+        const tokens = extractSearchTokens(query);
         const params = [
             `%${query}%`,
             SEARCHABLE_STATUS,
@@ -104,15 +141,46 @@ export class SymbolRepository {
         let sql = `
       SELECT id, name, type, category, path, description, content, meta::text AS meta, usage_count, created_at
       FROM ${env.symbolsTable}
-      WHERE (name ILIKE $1 OR description ILIKE $1)
+            WHERE (
+              name ILIKE $1 OR
+              description ILIKE $1 OR
+              path ILIKE $1 OR
+              meta::text ILIKE $1
+            )
         AND status = $2
     `;
+        if (tokens.length) {
+            const tokenClauses = tokens.map((token) => {
+                // 每个query token都要在name/description/path/meta中至少匹配一次才算匹配，来提升搜索的准确度，避免单个token过于泛匹配导致的排名干扰
+                params.push(`%${token}%`);
+                const index = params.length;
+                return `name ILIKE $${index} OR description ILIKE $${index} OR path ILIKE $${index} OR meta::text ILIKE $${index}`;
+            });
+            sql = `
+      SELECT id, name, type, category, path, description, content, meta::text AS meta, usage_count, created_at
+      FROM ${env.symbolsTable}
+            WHERE (
+              name ILIKE $1 OR
+              description ILIKE $1 OR
+              path ILIKE $1 OR
+              meta::text ILIKE $1 OR
+              (${tokenClauses.join(' OR ')})
+            )
+        AND status = $2
+    `;
+        }
         if (type) {
             params.push(type);
             sql += ` AND type = $${params.length}`;
         }
         sql += ' ORDER BY usage_count DESC LIMIT 20';
         const { rows } = await this.pool.query(sql, params);
+        console.error('[code-intelligence-mcp] repository.search.db table=%s rows=%s top=%s note=name/description only', env.symbolsTable, String(rows.length), JSON.stringify(rows.slice(0, 3).map((r) => ({
+            id: r.id,
+            name: r.name,
+            path: r.path,
+            type: r.type,
+        }))));
         return rows.map((r) => mapRow(r));
     }
     /**
@@ -120,10 +188,13 @@ export class SymbolRepository {
      * 不再需要在 Node 拉取全量向量做内存计算。
      */
     async searchSemanticHits(query, opts) {
+        console.error('[code-intelligence-mcp] repository.searchSemanticHits.start query=%s type=%s table=%s limit=%s threshold=%s searchableStatus=%s hasPool=%s', query, opts?.type ?? '', env.symbolsTable, String(opts?.limit ?? TOP_K), String(SIMILARITY_THRESHOLD), String(SEARCHABLE_STATUS), String(Boolean(this.pool)));
         if (!env.embeddingServiceUrl) {
+            console.error('[code-intelligence-mcp] repository.searchSemanticHits.error missingEmbeddingServiceUrl');
             throw new Error('语义检索需配置 EMBEDDING_SERVICE_URL 并启动嵌入服务');
         }
         if (!this.pool) {
+            console.error('[code-intelligence-mcp] repository.searchSemanticHits.noPool returnEmpty');
             return [];
         }
         const limit = opts?.limit ?? TOP_K;
@@ -151,15 +222,26 @@ export class SymbolRepository {
         params.push(limit * 2); // 多取一倍以便 SIMILARITY_THRESHOLD 过滤后仍有足量结果
         sql += ` ORDER BY embedding <=> $1::vector LIMIT $${params.length}`;
         const { rows } = await this.pool.query(sql, params);
-        return rows
-            .map((r) => ({
+        const mapped = rows.map((r) => ({
             symbol: mapRow(r),
             similarity: Number(r.similarity),
+        }));
+        const passed = mapped.filter((x) => x.similarity >= SIMILARITY_THRESHOLD);
+        console.error('[code-intelligence-mcp] repository.searchSemanticHits.db table=%s rawRows=%s passedThreshold=%s topRaw=%s', env.symbolsTable, String(rows.length), String(passed.length), JSON.stringify(mapped.slice(0, 5).map((x) => ({
+            id: x.symbol.id,
+            name: x.symbol.name,
+            path: x.symbol.path,
+            similarity: Number(x.similarity.toFixed(4)),
+        }))));
+        return passed
+            .map((r) => ({
+            symbol: r.symbol,
+            similarity: r.similarity,
         }))
-            .filter((x) => x.similarity >= SIMILARITY_THRESHOLD)
             .slice(0, limit);
     }
     async getByName(name) {
+        console.error('[code-intelligence-mcp] repository.getByName.start name=%s table=%s hasPool=%s', name, env.symbolsTable, String(Boolean(this.pool)));
         if (!this.pool) {
             return (inMemorySymbols.find((s) => s.name.toLowerCase() === name.toLowerCase()) ?? null);
         }
@@ -169,6 +251,7 @@ export class SymbolRepository {
       WHERE name = $1
       LIMIT 1
       `, [name]);
+        console.error('[code-intelligence-mcp] repository.getByName.db table=%s rows=%s', env.symbolsTable, String(rows.length));
         if (rows.length === 0) {
             return null;
         }
@@ -191,6 +274,7 @@ export class SymbolRepository {
         return result.rowCount !== null && result.rowCount > 0;
     }
     async searchByStructure(fields, opts) {
+        console.error('[code-intelligence-mcp] repository.searchByStructure.start fields=%s type=%s category=%s table=%s limit=%s hasPool=%s', JSON.stringify(fields), opts?.type ?? '', opts?.category ?? '', env.symbolsTable, String(opts?.limit ?? 20), String(Boolean(this.pool)));
         const normalized = fields.map((f) => f.trim()).filter(Boolean);
         if (normalized.length === 0)
             return [];
@@ -215,7 +299,13 @@ export class SymbolRepository {
             return normalized.every((field) => propPool.includes(field.toLowerCase()));
         };
         if (!this.pool) {
-            return inMemorySymbols.filter(matchesAll).slice(0, limit);
+            const matched = inMemorySymbols.filter(matchesAll).slice(0, limit);
+            console.error('[code-intelligence-mcp] repository.searchByStructure.memory matched=%s top=%s', String(matched.length), JSON.stringify(matched.slice(0, 3).map((s) => ({
+                id: s.id,
+                name: s.name,
+                path: s.path,
+            }))));
+            return matched;
         }
         const params = [];
         let sql = `
@@ -234,9 +324,13 @@ export class SymbolRepository {
         params.push(Math.max(limit * 5, 50));
         sql += ` ORDER BY usage_count DESC LIMIT $${params.length}`;
         const { rows } = await this.pool.query(sql, params);
-        return rows
-            .map((r) => mapRow(r))
-            .filter(matchesAll)
-            .slice(0, limit);
+        const mapped = rows.map((r) => mapRow(r));
+        const filtered = mapped.filter(matchesAll).slice(0, limit);
+        console.error('[code-intelligence-mcp] repository.searchByStructure.db table=%s scanned=%s matched=%s top=%s', env.symbolsTable, String(rows.length), String(filtered.length), JSON.stringify(filtered.slice(0, 3).map((s) => ({
+            id: s.id,
+            name: s.name,
+            path: s.path,
+        }))));
+        return filtered;
     }
 }

package/dist/server/createServer.js

@@ -9,24 +9,36 @@ import { createIncUsageTool } from '../tools/incUsage.js';
 import { RecommendationService } from '../services/recommendationService.js';
 import { createRecommendComponentTool } from '../tools/recommendComponent.js';
 export function createServer() {
+    console.error('[code-intelligence-mcp] createServer.init');
     const server = new McpServer({
         name: 'code-intelligence-mcp',
         version: '0.1.0',
     });
+    console.error('[code-intelligence-mcp] mcpServer.created name=code-intelligence-mcp version=0.1.0');
     const repository = new SymbolRepository();
+    console.error('[code-intelligence-mcp] repository.created');
     const recommendationService = new RecommendationService(repository);
+    console.error('[code-intelligence-mcp] recommendationService.created');
     const searchTool = createSearchSymbolsTool(repository);
     server.tool(searchTool.name, searchTool.description, searchTool.inputSchema, searchTool.handler);
+    console.error('[code-intelligence-mcp] tool.registered %s', searchTool.name);
     const detailTool = createGetSymbolDetailTool(repository);
     server.tool(detailTool.name, detailTool.description, detailTool.inputSchema, detailTool.handler);
+    console.error('[code-intelligence-mcp] tool.registered %s', detailTool.name);
     const structureTool = createSearchByStructureTool(repository);
     server.tool(structureTool.name, structureTool.description, structureTool.inputSchema, structureTool.handler);
+    console.error('[code-intelligence-mcp] tool.registered %s', structureTool.name);
     const reindexTool = createReindexTool();
     server.tool(reindexTool.name, reindexTool.description, reindexTool.inputSchema, reindexTool.handler);
+    console.error('[code-intelligence-mcp] tool.registered %s', reindexTool.name);
     const incUsageTool = createIncUsageTool(repository);
     server.tool(incUsageTool.name, incUsageTool.description, incUsageTool.inputSchema, incUsageTool.handler);
+    console.error('[code-intelligence-mcp] tool.registered %s', incUsageTool.name);
     const recommendComponentTool = createRecommendComponentTool(recommendationService);
     server.tool(recommendComponentTool.name, recommendComponentTool.description, recommendComponentTool.inputSchema, recommendComponentTool.handler);
+    console.error('[code-intelligence-mcp] tool.registered %s', recommendComponentTool.name);
     registerReusableCodeAdvisorPrompt(server);
+    console.error('[code-intelligence-mcp] prompt.registered reusable-code-advisor');
+    console.error('[code-intelligence-mcp] createServer.ready toolCount=6 promptCount=1');
     return server;
 }

package/dist/services/ranking.js

@@ -5,19 +5,56 @@ function clamp01(value) {
         return 1;
     return value;
 }
+function extractTextTokens(text) {
+    // eg: query='useDebounceInput组件', tokens=['useDebounceInput', '组件']
+    const tokens = new Set();
+    const lower = text.trim().toLowerCase();
+    for (const match of lower.matchAll(/[a-z0-9_]+/g)) {
+        if (match[0].length >= 2)
+            tokens.add(match[0]);
+    }
+    for (const match of text.matchAll(/[\u4e00-\u9fff]{2,}/g)) {
+        const chunk = match[0];
+        for (let index = 0; index < chunk.length - 1; index += 1) {
+            tokens.add(chunk.slice(index, index + 2));
+        }
+    }
+    return [...tokens];
+}
+// 先对query进行切分，然后计算切分后的token在symbol的name/description/path中出现的数量和比例，来判断是否存在关键词重合，进而提升排名。
+function tokenOverlapScore(query, symbol) {
+    const queryTokens = extractTextTokens(query);
+    if (queryTokens.length === 0)
+        return 0;
+    const text = [symbol.name, symbol.description ?? '', symbol.path]
+        .join(' ')
+        .toLowerCase();
+    const matched = queryTokens.filter((token) => text.includes(token)).length;
+    const overlapRatio = matched / queryTokens.length;
+    if (matched >= 4 && overlapRatio >= 0.45)
+        return 0.78;
+    if (matched >= 3 && overlapRatio >= 0.3)
+        return 0.68;
+    if (matched >= 2 && overlapRatio >= 0.18)
+        return 0.56;
+    return 0;
+}
 function textMatchScore(query, symbol) {
     const q = query.trim().toLowerCase();
     if (!q)
-        return { score: 0, matchedBy: "weak" };
+        return { score: 0, matchedBy: 'weak' };
     const name = symbol.name.toLowerCase();
-    const description = (symbol.description ?? "").toLowerCase();
+    const description = (symbol.description ?? '').toLowerCase();
     if (name === q)
-        return { score: 1, matchedBy: "exact_name" };
+        return { score: 1, matchedBy: 'exact_name' };
     if (name.includes(q))
-        return { score: 0.85, matchedBy: "name_contains" };
+        return { score: 0.85, matchedBy: 'name_contains' };
     if (description.includes(q))
-        return { score: 0.65, matchedBy: "description_contains" };
-    return { score: 0.2, matchedBy: "weak" };
+        return { score: 0.65, matchedBy: 'description_contains' };
+    const overlapScore = tokenOverlapScore(query, symbol);
+    if (overlapScore > 0)
+        return { score: overlapScore, matchedBy: 'token_overlap' };
+    return { score: 0.2, matchedBy: 'weak' };
 }
 function usageScore(usageCount) {
     // log scale to avoid very large usage monopolizing ranking.
@@ -50,62 +87,76 @@ function daysSinceCreated(createdAt) {
 }
 function commonPathScore(path) {
     const lower = path.toLowerCase();
-    return lower.includes("/common/") || lower.includes("/shared/") ? 1 : 0.35;
+    return lower.includes('/common/') || lower.includes('/shared/') ? 1 : 0.35;
 }
 const RANK_WEIGHTS = {
     textMatch: 0.5,
     usage: 0.3,
     recency: 0.1,
-    commonPath: 0.1
+    commonPath: 0.1,
 };
 /**
- * Phase 5：以向量余弦相似度作为主文本维度，再叠加 usage / recency / common（与 `rankSymbols` 同权重）。
+ * Phase 5：以向量余弦相似度作为主文本维度，再叠加 usage / recency / common 和 calleeNames 匹配度。
+ * calleeNames 作为结构信息独立信号，不污染纯语义向量。
  */
-export function rankSemanticHits(hits) {
+export function rankSemanticHits(hits, query) {
     return hits
         .map(({ symbol, similarity }) => {
         const textScore = clamp01(similarity);
         const usage = usageScore(symbol.usageCount);
         const recency = recencyScore(symbol.createdAt);
         const common = commonPathScore(symbol.path);
+        // ✨ 新增：calleeNames 作为独立信号
+        let calleeMatchScore = 0;
+        if (query && Array.isArray(symbol.meta?.calleeNames)) {
+            const calleeNames = symbol.meta.calleeNames;
+            const queryLower = query.toLowerCase();
+            const matchedCallees = calleeNames.filter((callee) => queryLower.includes(callee.toLowerCase())).length;
+            if (matchedCallees > 0) {
+                calleeMatchScore = Math.min(matchedCallees * 0.05, 0.2);
+            }
+        }
         const score = textScore * RANK_WEIGHTS.textMatch +
             usage * RANK_WEIGHTS.usage +
             recency * RANK_WEIGHTS.recency +
-            common * RANK_WEIGHTS.commonPath;
+            common * RANK_WEIGHTS.commonPath +
+            calleeMatchScore;
         const reasonParts = [];
         if (textScore >= 0.55)
-            reasonParts.push("语义相似度高");
+            reasonParts.push('语义相似度高');
         else if (textScore >= 0.4)
-            reasonParts.push("语义相关");
+            reasonParts.push('语义相关');
         if (usage >= 0.6)
-            reasonParts.push("使用频率高");
+            reasonParts.push('使用频率高');
         if (common >= 1)
-            reasonParts.push("位于 shared/common 路径");
+            reasonParts.push('位于 shared/common 路径');
+        if (calleeMatchScore > 0)
+            reasonParts.push('函数调用关系匹配');
         if (reasonParts.length === 0)
-            reasonParts.push("综合相关性较好");
+            reasonParts.push('综合相关性较好');
         return {
             symbol,
             score: Number(score.toFixed(3)),
             reason: {
                 textMatch: {
                     score: Number(textScore.toFixed(3)),
-                    matchedBy: "semantic"
+                    matchedBy: 'semantic',
                 },
                 usage: {
                     score: Number(usage.toFixed(3)),
-                    usageCount: symbol.usageCount
+                    usageCount: symbol.usageCount,
                 },
                 recency: {
                     score: Number(recency.toFixed(3)),
-                    daysSinceCreated: daysSinceCreated(symbol.createdAt)
+                    daysSinceCreated: daysSinceCreated(symbol.createdAt),
                 },
                 commonPath: {
                     score: Number(common.toFixed(3)),
-                    isCommonPath: common >= 1
+                    isCommonPath: common >= 1,
                 },
                 weights: RANK_WEIGHTS,
-                summary: reasonParts.join(" + ")
-            }
+                summary: reasonParts.join(' + '),
+            },
         };
     })
         .sort((a, b) => b.score - a.score);
@@ -123,38 +174,40 @@ export function rankSymbols(query, symbols) {
             common * RANK_WEIGHTS.commonPath;
         const reasonParts = [];
         if (text.score >= 0.85)
-            reasonParts.push("文本匹配度高");
+            reasonParts.push('文本匹配度高');
         else if (text.score >= 0.65)
-            reasonParts.push("描述命中");
+            reasonParts.push('描述命中');
+        else if (text.matchedBy === 'token_overlap')
+            reasonParts.push('关键词片段高度重合');
         if (usage >= 0.6)
-            reasonParts.push("使用频率高");
+            reasonParts.push('使用频率高');
         if (common >= 1)
-            reasonParts.push("位于 shared/common 路径");
+            reasonParts.push('位于 shared/common 路径');
         if (reasonParts.length === 0)
-            reasonParts.push("综合相关性较好");
+            reasonParts.push('综合相关性较好');
         return {
             symbol,
             score: Number(score.toFixed(3)),
             reason: {
                 textMatch: {
                     score: Number(text.score.toFixed(3)),
-                    matchedBy: text.matchedBy
+                    matchedBy: text.matchedBy,
                 },
                 usage: {
                     score: Number(usage.toFixed(3)),
-                    usageCount: symbol.usageCount
+                    usageCount: symbol.usageCount,
                 },
                 recency: {
                     score: Number(recency.toFixed(3)),
-                    daysSinceCreated: daysSinceCreated(symbol.createdAt)
+                    daysSinceCreated: daysSinceCreated(symbol.createdAt),
                 },
                 commonPath: {
                     score: Number(common.toFixed(3)),
-                    isCommonPath: common >= 1
+                    isCommonPath: common >= 1,
                 },
                 weights: RANK_WEIGHTS,
-                summary: reasonParts.join(" + ")
-            }
+                summary: reasonParts.join(' + '),
+            },
         };
     })
         .sort((a, b) => b.score - a.score);