@lorrylurui/code-intelligence-mcp 2.0.7 → 2.0.9

package/dist/services/recommendationService.js

@@ -28,7 +28,8 @@
  * ──────────────────────────────────────────────────────────────────────────────
  */
 import { rankSemanticHits, rankSymbols } from './ranking.js';
-import { DEMO_PATH_PRIORITY_PENALTY, LITERAL_MATCH_PRIORITY_BOOST, MIN_LITERAL_MATCH_SCORE, MIN_RECOMMENDATION_SCORE, MIN_SEMANTIC_TEXT_MATCH_SCORE, REQUIRED_FIELD_FALLBACK_MIN_SCORE, } from '../config/tuning.js';
+import { DEMO_PATH_PRIORITY_PENALTY, INDEX_FILE_PRIORITY_BOOST, LITERAL_MATCH_PRIORITY_BOOST, MIN_LITERAL_MATCH_SCORE, MIN_RECOMMENDATION_SCORE, MIN_SEMANTIC_TEXT_MATCH_SCORE, REQUIRED_FIELD_FALLBACK_MIN_SCORE, SAME_DIR_INDEX_EXISTS_PENALTY, } from '../config/tuning.js';
+import { NOISE_PATTERNS, buildSynonymVariant } from '../config/queryRewrite.js';
 /** 跳过原因标识 */
 const SKIPPED_REASON = {
     NO_COMBINED: 'no_combined',
@@ -50,8 +51,8 @@ const RECOMMENDATION_MESSAGE = {
 };
 /** 详情补查的 top-k 条数 */
 const ENRICH_TOP_K = 3;
-/** 最多取查询变体数量 */
-const MAX_QUERY_VARIANTS = 2;
+/** 最多取查询变体数量（原始 + 清洗 + 同义词扩展） */
+const MAX_QUERY_VARIANTS = 3;
 /** 结构/语义搜索 limit 倍数 */
 const STRUCTURE_LIMIT_MULTIPLIER = 4;
 /** 结构/语义搜索 limit 最小值 */
@@ -61,31 +62,33 @@ const DEFAULT_KEYWORD_SIMILARITY = 0.55;
 function uniqueStrings(values = []) {
     return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
-const QUERY_REWRITE_PATTERNS = [
-    /^帮我找(找)?(一个|一下)?/g,
-    /^有没有(现成的)?/g,
-    /^请推荐(一个|一下)?/g,
-    /可复用/g,
-    /现成的/g,
-    /封装好的/g,
-    /(组件|函数|hook|工具|util)(实现)?/gi,
-];
 /**
- * 对原始查询进行清洗和变体生成，去掉无意义的词，提炼更核心的查询内容
+ * 对原始查询进行清洗和变体生成：
+ * 1. 噪音词清洗（去掉口语化前缀、无意义词）
+ * 2. 同义词扩展（中英互转、别名替换）
+ * 生成最多 MAX_QUERY_VARIANTS 个去重变体，按从精确到宽泛排序。
  */
 function buildQueryVariants(rawQuery) {
     const base = rawQuery.trim();
     if (!base)
         return [];
-    let rewritten = base;
-    for (const pattern of QUERY_REWRITE_PATTERNS) {
-        rewritten = rewritten.replace(pattern, ' ');
-    }
-    rewritten = rewritten.replace(/\s+/g, ' ').trim();
-    if (!rewritten || rewritten === base) {
-        return [base];
+    // Step 1: 噪音词清洗
+    let cleaned = base;
+    for (const pattern of NOISE_PATTERNS) {
+        cleaned = cleaned.replace(pattern, ' ');
     }
-    return uniqueStrings([base, rewritten]);
+    cleaned = cleaned.replace(/\s+/g, ' ').trim();
+    if (!cleaned)
+        cleaned = base;
+    // Step 2: 同义词扩展（基于清洗后的 query，减少噪音干扰匹配）
+    const synonymVariant = buildSynonymVariant(cleaned);
+    // 候选：原始 → 清洗后（若不同）→ 同义词扩展（若不同）
+    const candidates = [
+        base,
+        cleaned,
+        ...(synonymVariant ? [synonymVariant] : []),
+    ];
+    return uniqueStrings(candidates);
 }
 function normalizeToken(value) {
     return value.trim().toLowerCase();
@@ -205,6 +208,14 @@ function isDemoLikePath(path, strict = false) {
         : DEMO_LIKE_PATH_SEGMENTS_SOFT;
     return segments.some((segment) => normalizedPath.includes(segment));
 }
+/**
+ * 判断文件是否为组件目录入口文件（index.js / index.ts / index.tsx / index.jsx）。
+ * 入口文件是组件的公共 API，应优先于内部子文件被推荐。
+ */
+function isIndexFile(filePath) {
+    const basename = filePath.split('/').pop()?.toLowerCase() ?? '';
+    return /^index\.(js|ts|tsx|jsx)$/.test(basename);
+}
 /**
  * 判断是否为可复用候选，过滤掉明显的测试/示例代码。虽然有可能误伤一些真实组件，但优先保证推荐结果的实用性和专业度。
  * @param symbol 要判断的代码符号
@@ -295,6 +306,10 @@ function computeRecommendationPriority(item, query) {
         score += LITERAL_MATCH_PRIORITY_BOOST;
         notes.push('名称或文件名命中查询');
     }
+    if (isIndexFile(path)) {
+        score += INDEX_FILE_PRIORITY_BOOST;
+        notes.push('组件目录入口文件优先');
+    }
     if (isDemoLikePath(path)) {
         score -= DEMO_PATH_PRIORITY_PENALTY;
         notes.push('示例工程路径降权');
@@ -306,6 +321,49 @@ function computeRecommendationPriority(item, query) {
             : item.reason.summary,
     };
 }
+/**
+ * 同目录 index 文件降权：当结果集中某目录已有 index 文件时，对该目录内其他子文件扭扣分，
+ * 解决 index.js 因内容稀疏（仅有 re-export）导致 embedding 分低而被内部子文件抑制的问题。
+ */
+function applyDirectoryIndexPenalty(entries) {
+    // 找出结果集中哪些目录已有 index 文件
+    const dirsWithIndex = new Set();
+    for (const entry of entries) {
+        const p = entry.item.symbol.path;
+        if (isIndexFile(p)) {
+            const dir = p.includes('/')
+                ? p.substring(0, p.lastIndexOf('/'))
+                : '';
+            dirsWithIndex.add(dir);
+        }
+    }
+    if (dirsWithIndex.size === 0)
+        return entries;
+    // 对同目录中的非入口文件手动扣分
+    return entries.map((entry) => {
+        const p = entry.item.symbol.path;
+        if (isIndexFile(p))
+            return entry;
+        const dir = p.includes('/') ? p.substring(0, p.lastIndexOf('/')) : '';
+        if (!dirsWithIndex.has(dir))
+            return entry;
+        const newScore = Number(Math.max(0, entry.adjustedScore - SAME_DIR_INDEX_EXISTS_PENALTY).toFixed(3));
+        return {
+            ...entry,
+            adjustedScore: newScore,
+            adjustedReason: `${entry.adjustedReason} + 同目录入口文件已命中，内部子文件降权`,
+        };
+    });
+}
+function accToEvalTrace(acc) {
+    return {
+        semanticIds: [...acc.semanticIds],
+        reusableIds: [...acc.reusableIds],
+        combinedIds: [...acc.combinedIds],
+        qualifiedIds: [...acc.qualifiedIds],
+        returnedIds: [...acc.returnedIds],
+    };
+}
 export class RecommendationService {
     repository;
     constructor(repository) {
@@ -400,6 +458,15 @@ export class RecommendationService {
         let selectedQuery = null;
         let fallbackReason = null;
         const attempts = [];
+        const evalAcc = input.evalMode
+            ? {
+                semanticIds: new Set(),
+                reusableIds: new Set(),
+                combinedIds: new Set(),
+                qualifiedIds: new Set(),
+                returnedIds: new Set(),
+            }
+            : undefined;
         this.logSearchTypes(searchTypes);
         for (const queryVariant of queryVariants) {
             const { attempt, combined, searchResults, gathered } = await this.tryQueryVariant({
@@ -411,6 +478,7 @@ export class RecommendationService {
                 structureFields,
                 requiredProps,
                 requiredHooks,
+                evalAcc,
             });
             queriedBy = gathered.queriedBy;
             if (!fallbackReason && gathered.fallbackReason) {
@@ -433,6 +501,7 @@ export class RecommendationService {
                 requiredHooks,
                 attempt,
                 limit,
+                evalAcc,
             });
             lastRankedCandidates = candidates;
             if (candidates.length > 0) {
@@ -454,6 +523,7 @@ export class RecommendationService {
                     attempts,
                     selectedQuery,
                     fallbackReason,
+                    evalTrace: evalAcc ? accToEvalTrace(evalAcc) : undefined,
                 });
             }
             this.logAttemptCheckpoint('attempt.no_candidate_after_rank', attempt);
@@ -474,6 +544,7 @@ export class RecommendationService {
             attempts,
             selectedQuery,
             fallbackReason,
+            evalTrace: evalAcc ? accToEvalTrace(evalAcc) : undefined,
         });
     }
     logStart(input) {
@@ -505,9 +576,12 @@ export class RecommendationService {
         console.error('[code-intelligence-mcp] recommendComponent.preprocess queryVariants=%s requiredProps=%s requiredHooks=%s structureFields=%s searchTypes=%s preferSemantic=%s limit=%s', JSON.stringify(queryVariants), JSON.stringify(requiredProps), JSON.stringify(requiredHooks), JSON.stringify(structureFields), JSON.stringify(searchTypes), String(preferSemantic), String(limit));
         return res;
     }
-    async tryQueryVariant({ queryVariant, input, searchTypes, preferSemantic, limit, structureFields, requiredProps, requiredHooks, }) {
+    async tryQueryVariant({ queryVariant, input, searchTypes, preferSemantic, limit, structureFields, requiredProps, requiredHooks, evalAcc, }) {
         const gathered = await this.gatherSearchResults(queryVariant, searchTypes, preferSemantic, limit);
         const searchResults = gathered.searchResults;
+        if (evalAcc) {
+            searchResults.forEach((r) => evalAcc.semanticIds.add(r.symbol.id));
+        }
         const attempt = {
             query: queryVariant,
             queriedBy: gathered.queriedBy,
@@ -542,36 +616,59 @@ export class RecommendationService {
         if (reusableCandidates.length > 0) {
             combined = reusableCandidates;
         }
+        if (evalAcc) {
+            reusableCandidates.forEach((s) => evalAcc.reusableIds.add(s.id));
+            combined.forEach((s) => evalAcc.combinedIds.add(s.id));
+        }
         attempt.combinedCount = combined.length;
         return { attempt, combined, searchResults, gathered };
     }
-    async rankAndEnrichCandidates({ combined, searchResults, queryVariant, queriedBy, requiredProps, requiredHooks, attempt, limit, }) {
+    async rankAndEnrichCandidates({ combined, searchResults, queryVariant, queriedBy, requiredProps, requiredHooks, attempt, limit, evalAcc, }) {
         const ranked = queriedBy === QUERIED_BY.SEMANTIC
             ? rankSemanticHits(combined.map((symbol) => ({
                 symbol,
                 similarity: searchResults.find((item) => item.symbol.id === symbol.id)?.similarity ?? 0.55,
             })), queryVariant)
             : rankSymbols(queryVariant, combined);
-        const enriched = await this.enrichTopCandidatesWithDetail(ranked);
-        const enrichedRanked = enriched.ranked;
-        attempt.detailEnrichedCount = enriched.enrichedCount;
-        const qualifiedRanked = enrichedRanked.filter((item) => isStrongEnoughRecommendation(item, queryVariant, queriedBy, requiredProps, requiredHooks));
-        attempt.qualifiedCount = qualifiedRanked.length;
-        if (qualifiedRanked.length === 0) {
-            attempt.skippedReason = SKIPPED_REASON.NO_QUALIFIED;
-        }
-        const prioritizedRanked = qualifiedRanked
-            .map((item) => {
+        // 优先级预排序：仅依赖 name/path，无需 meta，前置到详情补查之前。
+        // 目的：确保补查的 Top-K 是优先级调整后最可能命中的候选，
+        // 避免高语义分但字面命中弱的候选占据补查名额，遗漏字面强命中的候选。
+        const priorityScored = ranked.map((item) => {
             const adjusted = computeRecommendationPriority(item, queryVariant);
             return {
                 item,
                 adjustedScore: adjusted.score,
                 adjustedReason: adjusted.reason,
             };
-        })
-            .sort((a, b) => b.adjustedScore - a.adjustedScore);
-        const candidates = prioritizedRanked.map((entry) => toCandidate(entry.item.symbol, entry.adjustedScore, entry.adjustedReason, requiredProps, requiredHooks));
-        console.error('[code-intelligence-mcp] recommendComponent.rank query=%s queriedBy=%s enriched=%s qualified=%s candidates=%s', queryVariant, queriedBy, String(enrichedRanked.length), String(qualifiedRanked.length), String(candidates.length));
+        });
+        priorityScored.sort((a, b) => b.adjustedScore - a.adjustedScore);
+        // 同目录 index 文件降权：对同目录非入口子文件扭扣，确保 index.js > menu.js / panel.js
+        const reranked = applyDirectoryIndexPenalty(priorityScored);
+        reranked.sort((a, b) => b.adjustedScore - a.adjustedScore);
+        // 对优先级预排序后的 Top-K 做详情补查（getByName 补全完整 meta）
+        const enriched = await this.enrichTopCandidatesWithDetail(reranked.map((e) => e.item));
+        attempt.detailEnrichedCount = enriched.enrichedCount;
+        // 将补查结果回填到 reranked，保持优先级排序
+        const enrichedPriorityScored = enriched.ranked.map((item, idx) => ({
+            item,
+            adjustedScore: reranked[idx]?.adjustedScore ?? item.score,
+            adjustedReason: reranked[idx]?.adjustedReason ?? item.reason.summary,
+        }));
+        // 质量门控：score 阈值 + requiredProps/Hooks 命中校验（依赖完整 meta，必须在补查之后）
+        const qualifiedRanked = enrichedPriorityScored.filter((entry) => isStrongEnoughRecommendation(entry.item, queryVariant, queriedBy, requiredProps, requiredHooks));
+        attempt.qualifiedCount = qualifiedRanked.length;
+        if (qualifiedRanked.length === 0) {
+            attempt.skippedReason = SKIPPED_REASON.NO_QUALIFIED;
+        }
+        if (evalAcc) {
+            qualifiedRanked.forEach((e) => evalAcc.qualifiedIds.add(e.item.symbol.id));
+        }
+        // 已按优先级排序，直接构建候选结果
+        const candidates = qualifiedRanked.map((entry) => toCandidate(entry.item.symbol, entry.adjustedScore, entry.adjustedReason, requiredProps, requiredHooks));
+        if (evalAcc) {
+            candidates.forEach((c) => evalAcc.returnedIds.add(c.id));
+        }
+        console.error('[code-intelligence-mcp] recommendComponent.rank query=%s queriedBy=%s enriched=%s qualified=%s candidates=%s', queryVariant, queriedBy, String(enrichedPriorityScored.length), String(qualifiedRanked.length), String(candidates.length));
         return candidates;
     }
     logAttemptCheckpoint(stage, attempt) {
@@ -580,7 +677,7 @@ export class RecommendationService {
     logAttemptsTrace(stage, payload) {
         console.error('[code-intelligence-mcp] %s selectedQuery=%s queriedBy=%s attempts=%s fallbackReason=%s', stage, payload.selectedQuery ?? 'none', payload.queriedBy, JSON.stringify(payload.attempts), payload.fallbackReason ?? 'none');
     }
-    buildResult({ recommended, alternatives, queriedBy, requiredProps, requiredHooks, attempts, selectedQuery, fallbackReason, }) {
+    buildResult({ recommended, alternatives, queriedBy, requiredProps, requiredHooks, attempts, selectedQuery, fallbackReason, evalTrace, }) {
         return {
             recommended,
             alternatives,
@@ -598,6 +695,7 @@ export class RecommendationService {
                 retryUsed: attempts.length > 1,
                 fallbackReason,
             },
+            evalTrace,
         };
     }
 }

package/dist/services/reconcileIndexedSymbols.js

@@ -0,0 +1,40 @@
+import { env } from '../config/env.js';
+import { SYMBOL_STATUS } from '../config/symbolStatus.js';
+function buildPathToSymbolNames(rows) {
+    const pathToNames = new Map();
+    for (const row of rows) {
+        const names = pathToNames.get(row.path) ?? new Set();
+        names.add(row.name);
+        pathToNames.set(row.path, names);
+    }
+    return new Map([...pathToNames.entries()].map(([path, names]) => [path, [...names]]));
+}
+async function markFileSymbolsOffline(db, path) {
+    await db.query(`UPDATE ${env.symbolsTable}
+         SET status = $1::smallint, file_hash = NULL, updated_at = NOW()
+         WHERE path = $2 AND status != $1::smallint`, [SYMBOL_STATUS.OFFLINE, path]);
+}
+/**
+ * 将指定文件集合中已消失的 symbol 标记为 offline。
+ * - `rows` 为空（整文件被删）→ 该文件所有 symbol 下线；
+ * - `rows` 非空 → 仅将不再出现于 `rows` 的 symbol 下线；
+ * - 重新出现的 symbol 状态恢复由 upsertSymbols 负责（hash 没变且有 embedding → online，否则 pending），此处不重复处理。
+ * forceRebuild 场景由上游先统一清空 embedding/status，此函数不负责强制重算策略。
+ */
+export async function markRemovedSymbolsOffline(db, filePaths, rows) {
+    if (filePaths.length === 0)
+        return;
+    const currentNamesByPath = buildPathToSymbolNames(rows);
+    for (const path of filePaths) {
+        const currentNames = currentNamesByPath.get(path) ?? [];
+        if (currentNames.length > 0) {
+            // 当前文件中已消失的 symbol 标记为 offline；
+            await db.query(`UPDATE ${env.symbolsTable}
+                 SET status = $1::smallint, file_hash = NULL, updated_at = NOW()
+                 WHERE path = $2 AND NOT (name = ANY($3)) AND status != $1::smallint`, [SYMBOL_STATUS.OFFLINE, path, currentNames]);
+            continue;
+        }
+        // 没有symbol，表示所有内容都删除下线
+        await markFileSymbolsOffline(db, path);
+    }
+}

package/dist/services/reindex.js

@@ -9,6 +9,7 @@ import { upsertSymbols } from '../indexer/persistSymbols.js';
 import { computeFileHash } from '../indexer/tsAstNormalizer.js';
 import { getRelativePathForDisplay } from '../indexer/heuristics.js';
 import { enqueueEmbeddingBatch, closeEmbeddingQueue, } from '../services/embeddingQueue.js';
+import { markRemovedSymbolsOffline } from './reconcileIndexedSymbols.js';
 import { SYMBOL_STATUS } from '../config/symbolStatus.js';
 function isCallerDebugEnabled() {
     return /^(1|true|yes|on)$/i.test(process.env.DEBUG_CALLERS ?? '');
@@ -108,15 +109,33 @@ export async function runReindex(options = {}) {
     const pendingHashes = [
         ...new Set(rows.map((r) => r.semantic_hash).filter(Boolean)),
     ];
+    const relPathsForIndexedFiles = filesToIndex.map((file) => getRelativePathForDisplay(projectRoot, file));
     if (!dryRun) {
-        // forceRebuild：先清空 DB 中已有的 embedding，使 worker cache check 必然 miss
-        if (forceRebuild && pendingHashes.length > 0) {
-            await pool.query(`UPDATE ${env.symbolsTable}
-                 SET embedding = NULL, status = $1
-                 WHERE semantic_hash = ANY($2)`, [SYMBOL_STATUS.PENDING, pendingHashes]);
-            console.error(`[reindex] forceRebuild: cleared embeddings for ${pendingHashes.length} semantic_hash(es)`);
+        const client = await pool.connect();
+        try {
+            await client.query('BEGIN');
+            // forceRebuild：先清空 DB 中已有的 embedding，使 worker cache check 必然 miss；
+            // file_hash 一并重置，确保本次重建与后续普通 reindex 都不会复用旧缓存判定。
+            if (forceRebuild && pendingHashes.length > 0) {
+                await client.query(`UPDATE ${env.symbolsTable}
+                     SET embedding = NULL, status = $1::smallint, file_hash = NULL
+                     WHERE semantic_hash = ANY($2)`, [SYMBOL_STATUS.PENDING, pendingHashes]);
+                console.error(`[reindex] forceRebuild: cleared embeddings + file_hash for ${pendingHashes.length} semantic_hash(es)`);
+            }
+            // 能复用 status=online
+            // 结构变了，不能复用 status=pending embedding=null
+            await upsertSymbols(client, rows, nullPayload);
+            // 处理 file内 symbol下线 或 整个file所有symbols下线
+            await markRemovedSymbolsOffline(client, relPathsForIndexedFiles, rows);
+            await client.query('COMMIT');
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+        finally {
+            client.release();
         }
-        await upsertSymbols(pool, rows, nullPayload);
         if (pendingHashes.length > 0) {
             await enqueueEmbeddingBatch(pendingHashes, env.symbolsTable);
             console.error(`[reindex] enqueued ${pendingHashes.length} semantic_hash(es) → worker will handle embedding asynchronously`);

package/dist/types/evalTrace.js

@@ -0,0 +1,25 @@
+/**
+ * evalTrace.ts — 推荐主链各阶段符号 ID 追踪，仅在 evalMode=true 时填充。
+ *
+ * 用于 eval CLI 做 per-symbol 失败分类（误杀分析），
+ * 判断 expected symbol 在哪个阶段丢失：
+ *   semanticIds → reusableIds → combinedIds → qualifiedIds → returnedIds
+ */
+/**
+ * 根据 EvalTrace 对单个 expected symbol 进行失败分类。
+ * @param symbolId DB 中的 symbol.id（需提前通过名称解析）
+ * @param trace 该次推荐调用的 EvalTrace
+ */
+export function classifySymbolFailure(symbolId, trace) {
+    if (trace.returnedIds.includes(symbolId))
+        return 'found';
+    if (!trace.semanticIds.includes(symbolId))
+        return 'no_semantic_recall';
+    if (!trace.reusableIds.includes(symbolId))
+        return 'reusability_filtered';
+    if (!trace.combinedIds.includes(symbolId))
+        return 'structure_filtered';
+    if (!trace.qualifiedIds.includes(symbolId))
+        return 'ranked_below_topk';
+    return 'quality_gate_rejected';
+}

package/dist/workers/embeddingWorker.js

@@ -14,6 +14,11 @@
  * 大仓分片：
  * - 直接启动多个 worker 进程（同一 Redis）即可水平扩展，BullMQ 原生分布式协调
  */
+// env.redisUrl (同一个 Redis)  url+name('embedding') 决定了 BullMQ 的队列，生产者和消费者通过它们读写同一个队列实现通信
+//        │
+//        ├─ Queue('embedding')      → LPUSH bull:embedding:wait  ...  ← Producer 写
+//        ├─ Worker('embedding')     → BRPOPLPUSH bull:embedding:wait  ← Worker 消费
+//        └─ QueueEvents('embedding')→ SUBSCRIBE bull:embedding:events ← 监听事件
 import { Worker, QueueEvents } from 'bullmq';
 import { Redis } from 'ioredis';
 import { env } from '../config/env.js';
@@ -31,7 +36,7 @@ async function processEmbedJob(job, pool) {
     const ts = () => new Date().toISOString();
     // Step 1: 缓存命中检查 —— 相同 semantic_hash 已有 online 向量
     const { rows: cached } = await pool.query(`SELECT embedding FROM ${table}
-         WHERE semantic_hash = $1 AND status = $2 AND embedding IS NOT NULL
+         WHERE semantic_hash = $1 AND status = $2::smallint AND embedding IS NOT NULL
          LIMIT 1`, [semanticHash, SYMBOL_STATUS.ONLINE]);
     let vector;
     if (cached.length > 0) {
@@ -43,8 +48,8 @@ async function processEmbedJob(job, pool) {
                 : cached[0].embedding;
         // cache hit 时只需把 pending 行的向量补齐（有可能是新增的同语义符号）
         const cacheResult = await pool.query(`UPDATE ${table}
-             SET embedding = $1::vector, status = $2
-             WHERE semantic_hash = $3 AND status = $4`, [
+             SET embedding = $1::vector, status = $2::smallint
+             WHERE semantic_hash = $3 AND status = $4::smallint`, [
             `[${vector.join(',')}]`,
             SYMBOL_STATUS.ONLINE,
             semanticHash,
@@ -56,7 +61,7 @@ async function processEmbedJob(job, pool) {
     // Cache miss: 取一条 pending 行做 embedding
     const { rows: pending } = await pool.query(`SELECT name, type, category, path, description, content, meta
          FROM ${table}
-         WHERE semantic_hash = $1 AND status = $2
+         WHERE semantic_hash = $1 AND status = $2::smallint
          LIMIT 1`, [semanticHash, SYMBOL_STATUS.PENDING]);
     if (pending.length === 0) {
         // 所有行已被并发 worker 处理，幂等退出
@@ -75,8 +80,8 @@ async function processEmbedJob(job, pool) {
     const resolvedCategory = resolvedRow.category ?? null;
     // Step 2: 批量写入 —— 覆盖所有相同 semantic_hash 的 pending 行
     const result = await pool.query(`UPDATE ${table}
-         SET embedding = $1::vector, status = $2, category = COALESCE($3, category)
-         WHERE semantic_hash = $4 AND status = $5`, [
+         SET embedding = $1::vector, status = $2::smallint, category = COALESCE($3, category)
+         WHERE semantic_hash = $4 AND status = $5::smallint`, [
         `[${vector.join(',')}]`,
         SYMBOL_STATUS.ONLINE,
         resolvedCategory,
@@ -91,11 +96,14 @@ async function processEmbedJob(job, pool) {
  */
 export async function startEmbeddingWorker(opts = {}) {
     const { concurrency = 5, rpmLimit = 100 } = opts;
+    // worker1 负责从 Redis 拉 job。
+    // BullMQ Worker 用它执行 BRPOPLPUSH 这类阻塞命令来抢占 job、加锁、标记完成/失败。阻塞命令会占住整个连接，无法复用。
     const connection = new Redis(env.redisUrl, {
         maxRetriesPerRequest: null,
         enableReadyCheck: false,
     });
-    // 独立连接监听队列事件（BullMQ 要求不共用 Worker 连接）
+    // worker2 负责订阅 Redis 的 Pub/Sub 事件频道。
+    // 给 QueueEvents 用。BullMQ 在 Redis 里发 Pub/Sub 事件（drained、completed、failed…），监听方需要独立的连接订阅这些事件频道。如果共用 connection，阻塞命令会让 Pub/Sub 订阅无法正常工作，所以 BullMQ 官方要求两个连接必须分开。
     const eventsConnection = new Redis(env.redisUrl, {
         maxRetriesPerRequest: null,
         enableReadyCheck: false,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lorrylurui/code-intelligence-mcp",
-    "version": "2.0.7",
+    "version": "2.0.9",
     "private": false,
     "description": "MCP server 提供仓库内可复用代码块（ts/tsx/js/jsx/css/less）的索引和查询能力，支持基于代码上下文的智能推荐。",
     "type": "module",
@@ -9,8 +9,8 @@
         "dist"
     ],
     "bin": {
-        "code-intelligence-mcp": "./dist/index.js",
-        "code-intelligence-index": "./dist/cli/index-codebase-cli.js"
+        "code-intelligence-mcp": "dist/index.js",
+        "code-intelligence-index": "dist/cli/index-codebase-cli.js"
     },
     "scripts": {
         "dev": "tsx watch --clear-screen=false --exclude node_modules --exclude dist src/index.ts",
@@ -21,6 +21,8 @@
         "start": "node dist/index.js",
         "index": "tsx src/cli/index-codebase-cli.ts",
         "ci-index": "tsx src/cli/ci-index-cli.ts",
+        "eval": "tsx src/cli/eval-recommendation-cli.ts",
+        "analyze": "tsx src/cli/eval-analyze-cli.ts",
         "worker:embedding": "tsx src/cli/embedding-worker-cli.ts",
         "embedding:dev": "cd embedding-service && python3 -m uvicorn app:app --host 127.0.0.1 --port 8765",
         "docker:up": "docker compose up -d",

package/dist/.env

@@ -1,24 +0,0 @@
-MYSQL_ENABLED=true
-MYSQL_HOST=127.0.0.1
-MYSQL_PORT=3306
-MYSQL_USER=root
-# 与 docker-compose.yml 中 MYSQL_ROOT_PASSWORD 一致（默认 devpassword，仅本地开发）
-MYSQL_PASSWORD=devpassword
-MYSQL_DATABASE=code_intelligence
-MYSQL_SYMBOLS_TABLE=symbols
-EMBEDDING_SERVICE_URL=http://127.0.0.1:8765
-
-# MCP Server 传输模式：stdio | http
-MCP_TRANSPORT=stdio
-# HTTP 模式监听地址，0.0.0.0 支持局域网访问，公网用公网IP
-MCP_HOST=0.0.0.0
-# HTTP 模式端口
-MCP_PORT=3000
-# Docker Compose 可选：与 .env 同步（compose 会读环境变量覆盖默认值）
-# MYSQL_ROOT_PASSWORD=devpassword
-
-# Phase 2 索引（npm run index）
-# INDEX_ROOT=
-# INDEX_GLOB=src/**/*.{ts,tsx}
-# INDEX_IGNORE=**/generated/**,**/*.spec.ts
-GIT_CI_MOCK_SERVER=false