@lorrylurui/code-intelligence-mcp 2.0.6 → 2.0.8

package/README.md

@@ -45,106 +45,3 @@
 
 MYSQL\*SYMBOLS_TABLE=frontend_collections_symbols
 INDEX_GLOB=xxx/\*\*/\_.{js,jsx,ts,tsx}
-
-# 召回效果优化
-
-你这个场景里，“召回优化”建议按 3 层做，效果最好：
-
-**1. 先把候选尽量捞全（Recall 层）**
-
-1. 提高语义检索候选池：把语义 `topK` 从现在的小值提高到 `50~200`，不要在第一层就截断太早。
-2. 语义 + 关键词并行召回：同时跑向量检索、名称/路径/描述关键词检索、结构字段检索（props/hooks/sideEffects），最后并集去重。
-3. 做查询扩展：`affix` 自动扩成 `fixed/sticky/offsetTop/offsetBottom/固钉/吸顶/吸底/固定定位`，提升召回覆盖率。
-4. 加别名词典：为组件建立别名（如 `Affix -> 固钉, 固定定位, sticky`），召回时强制并入。
-5. 路径先验加白名单：`Components/`、components这类目录可加权，`demo/examples/pages`不直接过滤，但降权。
-
-**2. 再做精排（Ranking 层）**
-
-1. 两阶段排序：第一阶段只看“能不能进池子”，第二阶段再做质量门槛。
-2. 显式命中强加权：用户 query 出现明确词（如 `affix`）时，名称/文件名命中要有明显 boost。
-3. 避免 usage 绑架：`usage_count` 只做弱特征，别让高 usage 的 demo/page 抢过真实组件。
-4. 引入轻量 reranker：对 Top-50 用交叉编码器或规则+LLM 打分，可明显提升 Top-1 准确率。
-
-**3. 建立评测闭环（Offline Eval）**
-
-1. 做一套 50~200 条真实查询集（中英混合、别名、口语化）。
-2. 每次改召回都跑：`Recall@10`、`Recall@50`、`MRR@10`、`nDCG@10`。
-3. 对失败样本做“误杀分析”：是没召回、被质量门槛挡掉、还是排序被 demo 抢位。
-
-你这个仓库当前最该优先做的 3 个点是：
-
-1. 把第一阶段候选池再放大（至少 50+）。
-2. 固化 query 扩展词典（Affix 这类高频组件先做）。
-3. 把质量门槛后移，先召回后精排，减少“找到了但被早期过滤掉”。
-
-如果你要，我可以下一步直接给你一版“可落地参数表”（每个阈值给默认值与调参范围），方便你马上 A/B。
-
-# 待优化项
-
-修复优先级：
-✅8
-✅5
-✅134 done，但是第二层embedding需要优化，llm fallback太慢+漂移，也需要调整模型
-✅6
-✅27
-
-1.  meta里面有多个信息，哪些做结构化过滤，哪些做向量检索？
-    结论：ast normalizers后拼一个语义模板，用这个模板内容生成向量
-    ❓做法见qa-doc/semantic-phrase.md
-2.  对于 class类型，content字段保留关键方法或摘要，而不是完全为空
-    最新修改：content赋值为语义模板
-3.  category过于模糊，
-    这三层怎么做：category 优先使用规则和 embedding 分类，
-    LLM 只作为 fallback，避免不稳定和成本问题
-    ❓做法见qa-doc/category.md
-4.  type category meta.kind 字段是否多余了？type只有5个值，
-    type表达代码结构、category表达语义结构，kind？
-    type： function / component / hook / class / type / interface
-    category：最新的三层结构（还没实现，只有文档）
-    kind: 现在跟type重叠较多，建议弱化meta.kind → 只保留特殊情况：
-    ❓改造方法qa-doc/type-category-kind.md
-5.  在ci做增量索引时，把changed files,如果是1000+文件，性能爆炸，考虑用file hash 判断？embedding也没有优化缓存？
-    ❓见qa-doc/ci-hash-solution 方案：🥈 file hash + ast normalizer hash，新增semantic_hash
-    - CI 增量（git changed files 触发）
-      只需要 semantic_hash
-      file_hash 可省，因为文件必然变了
-    - 每日全量扫描
-      file_hash 用来跳过 AST 解析（CPU 优化）
-      semantic_hash 用来跳过 embedding（费用优化）
-      content_hash 删掉，职责完全被 semantic_hash 覆盖
-6.  大仓问题：
-    ❓big-repo.md
-    - ci embedding解耦，新增embedding_status, ci时，全量写入status='pending'-> ci finish
-    - ci如果检测到文件删除，则对被删除的代码块标记delete（这里需要新增字段）
-    - node+redis 消费写embedding job
-    - 对语义模板semantic_hash做向量缓存，semantic_hash相同即功能未变
-    - 大仓分片并行
-7.  content暂时用不到，但也不用删除，目前暴利截取4000字符需要优化：
-    content（降级为辅助字段）：✔ 不参与 embedding✔ 不参与排序✔ 不参与过滤✔ 用于：1. LLM改造建议 2.debug 3.future rerank
-    最简单：只存 signature
-    最优：content = {
-    signature: "function fetchData(url, options)",
-    snippet: "核心逻辑代码（<=300行）",
-    keyCalls: ["fetch", "cache"]
-    }
-8.  TopK???，首先去掉usage过滤，再做两次topk,1.根据余弦相似度选topk 2.对1的结果用现有的usage,updated_at等加权排序
-    ❓topK.md
-    现在：SQL过滤(type) → ORDER BY usage_count DESC LIMIT 3000→ embedding 相似度排序→ 取 top20
-    这个逻辑不对，导致query: "debounce function"，debounce 使用少 ❌ fetch 很热门 ✅，结果Top3000里全是 fetch / request， debounce 被过滤掉 ❌
-
-👉 优点：
-• 不阻塞 CI
-• 可扩展
-
-6. 大仓问题呢？
-
-# 简历里还没做的优化
-
-1. embedding基石 - 语义模板模板，使用ast数据拼装语义模板
-2. class的content为null
-3. category分层 1.规则 2.预设所有种类，使用embedding召回 3.llm兜底
-4. type meta.kind逻辑优化，现在太重叠了
-5. ci-hash-solution
-6. 大仓问题
-7. content优化
-8. ✅topk优化

package/dist/cli/ci-index.js

@@ -2,75 +2,64 @@
 import { env } from '../config/env.js';
 import { getPool } from '../db/postgres.js';
 import { indexProject } from '../indexer/indexProject.js';
-import { DEFAULT_STATUS_ON_UPSERT, SYMBOL_STATUS, } from '../config/symbolStatus.js';
+import { upsertSymbols } from '../indexer/persistSymbols.js';
 import { enqueueEmbeddingBatch, closeEmbeddingQueue, } from '../services/embeddingQueue.js';
+import { markRemovedSymbolsOffline } from '../services/reconcileIndexedSymbols.js';
 export async function runIncrementalIndex(opts) {
     const { projectRoot, changedFiles, deletedFiles, renamedFiles = [] } = opts;
     const pool = getPool();
     const tableName = env.symbolsTable;
-    // 1. 删除文件：标记 offline
-    for (const file of deletedFiles) {
-        await pool.query(`UPDATE ${tableName} SET status = $1 WHERE path = $2`, [SYMBOL_STATUS.OFFLINE, file]);
-        console.error(`[ci-index] marked offline: ${file}`);
-    }
-    // 2. 重命名文件：更新path
-    for (const { from, to } of renamedFiles) {
-        await pool.query(`UPDATE ${tableName} SET path = $1 WHERE path = $2`, [
-            to,
-            from,
-        ]);
-        console.error(`[ci-index] renamed: ${from} -> ${to}`);
-    }
-    // 3. 变更/新增文件：重新索引并标记 pending
-    if (changedFiles.length > 0) {
-        const rows = await indexProject({
+    const rows = changedFiles.length > 0
+        ? await indexProject({
             projectRoot,
             globPatterns: changedFiles,
-        });
-        for (const row of rows) {
-            // 写入结构化数据
-            // status 逻辑：新行写 pending；已有行仅在 semantic_hash 发生变化时才重置为 pending，
-            // hash 未变说明语义未变，保留原 status（online → 缓存命中，不重复 embedding）
-            await pool.query(`INSERT INTO ${tableName}
-                   (name, type, category, path, description, content, meta,
-                    file_hash, semantic_hash, status,
-                    usage_count, created_at, updated_at)
-                 VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8, $9, $10, 0, NOW(), NOW())
-                 ON CONFLICT (path, name) DO UPDATE SET
-                   type             = EXCLUDED.type,
-                   category         = EXCLUDED.category,
-                   description      = EXCLUDED.description,
-                   content          = EXCLUDED.content,
-                   meta             = EXCLUDED.meta,
-                   file_hash        = EXCLUDED.file_hash,
-                   semantic_hash    = EXCLUDED.semantic_hash,
-                   status           = CASE WHEN ${tableName}.semantic_hash = EXCLUDED.semantic_hash
-                                          THEN ${tableName}.status
-                                          ELSE EXCLUDED.status END,
-                   updated_at       = NOW()`, [
-                row.name,
-                row.type,
-                row.category ?? null,
-                row.path,
-                row.description ?? null,
-                row.content ?? null,
-                JSON.stringify(row.meta),
-                row.file_hash,
-                row.semantic_hash,
-                DEFAULT_STATUS_ON_UPSERT,
-            ]);
-            console.error(`[ci-index] upserted: ${row.path}:${row.name}`);
+        })
+        : [];
+    const nullPayload = rows.map(() => null);
+    const hashes = [
+        ...new Set(rows.map((r) => r.semantic_hash).filter(Boolean)),
+    ];
+    const client = await pool.connect();
+    try {
+        await client.query('BEGIN');
+        // 1. 删除文件：复用 reconcile 的整文件 offline 语义
+        if (deletedFiles.length > 0) {
+            await markRemovedSymbolsOffline(client, deletedFiles, []);
+            for (const file of deletedFiles) {
+                console.error(`[ci-index] marked offline: ${file}`);
+            }
+        }
+        // 2. 重命名文件：更新path
+        for (const { from, to } of renamedFiles) {
+            await client.query(`UPDATE ${tableName} SET path = $1 WHERE path = $2`, [to, from]);
+            console.error(`[ci-index] renamed: ${from} -> ${to}`);
+        }
+        // 3. 变更/新增文件：重新索引并标记 pending
+        if (rows.length > 0) {
+            await upsertSymbols(client, rows, nullPayload);
+            for (const row of rows) {
+                console.error(`[ci-index] upserted: ${row.path}:${row.name}`);
+            }
+            await markRemovedSymbolsOffline(client, changedFiles, rows);
         }
-        // 批量入队：jobId = semanticHash，相同 hash 自动去重，1000 个符号可能只产生 N 个唯一 job
-        const hashes = [
-            ...new Set(rows.map((r) => r.semantic_hash).filter(Boolean)),
-        ];
+        await client.query('COMMIT');
+    }
+    catch (error) {
+        await client.query('ROLLBACK');
+        throw error;
+    }
+    finally {
+        client.release();
+    }
+    try {
         if (hashes.length > 0) {
             await enqueueEmbeddingBatch(hashes, env.symbolsTable);
             console.error(`[ci-index] enqueued ${hashes.length} unique semantic hashes for embedding`);
         }
+        await closeEmbeddingQueue();
+    }
+    finally {
+        await pool.end();
     }
-    await closeEmbeddingQueue();
-    await pool.end();
     console.error(`[ci-index] processed ${deletedFiles.length} deletions, ${renamedFiles.length} renames, ${changedFiles.length} changes`);
 }

package/dist/indexer/persistSymbols.js

@@ -1,29 +1,22 @@
 import { env } from '../config/env.js';
-import { getAllTableSQLs } from '../db/schema.js';
 import { SYMBOL_STATUS } from '../config/symbolStatus.js';
 /**
  * 依赖表上 `(path, name)` 唯一键：新行插入，已存在则更新类型/描述/内容与 meta；**不**修改 `usage_count`。
+ * 事务与连接生命周期由调用方管理。
  * @param rows 来自 `indexProject`；空数组时立即返回，不开启事务。
  * @param embeddings 与 `rows` 等长；某项为 `null` 表示本行不更新已有 `embedding`（新行则写入 NULL）。
  *   - 有值 → status 置为 online(2)
  *   - null  → 新行写 pending(1)，已有行保持原 status
  */
-export async function upsertSymbols(pool, rows, embeddings) {
+export async function upsertSymbols(client, 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() || 'system';
-    const client = await pool.connect();
-    try {
-        // 确保 extension + 表 + 基础索引存在
-        for (const sql of getAllTableSQLs()) {
-            await client.query(sql);
-        }
-        await client.query('BEGIN');
-        const t = env.symbolsTable;
-        const sql = `
+    const t = env.symbolsTable;
+    const sql = `
     INSERT INTO ${t}
       (name, type, category, path, description, content, meta,
        insert_user, updated_user, embedding, semantic_hash, file_hash, status)
@@ -36,48 +29,40 @@ export async function upsertSymbols(pool, rows, embeddings) {
       meta          = EXCLUDED.meta,
       updated_user  = EXCLUDED.updated_user,
       embedding     = CASE
-                        WHEN EXCLUDED.embedding IS NOT NULL THEN EXCLUDED.embedding
-                        WHEN EXCLUDED.semantic_hash != ${t}.semantic_hash THEN NULL
-                        ELSE ${t}.embedding
+                        WHEN EXCLUDED.embedding IS NOT NULL THEN EXCLUDED.embedding  -- 本次带了新向量，直接使用
+                        WHEN EXCLUDED.semantic_hash != ${t}.semantic_hash THEN NULL  -- 结构变了，旧向量作废，等重算
+                        ELSE ${t}.embedding                                          -- 结构未变，复用旧向量
                       END,
       semantic_hash = EXCLUDED.semantic_hash,
       file_hash     = EXCLUDED.file_hash,
       status        = CASE
-                        WHEN EXCLUDED.embedding IS NOT NULL THEN ${SYMBOL_STATUS.ONLINE}
-                        WHEN EXCLUDED.semantic_hash != ${t}.semantic_hash THEN ${SYMBOL_STATUS.PENDING}
-                        ELSE ${t}.status
+                        WHEN EXCLUDED.embedding IS NOT NULL THEN ${SYMBOL_STATUS.ONLINE}   -- 本次带了新向量 → 直接 online
+                        WHEN EXCLUDED.semantic_hash != ${t}.semantic_hash THEN ${SYMBOL_STATUS.PENDING}  -- 结构变了，需重新 embedding → pending
+                        WHEN ${t}.embedding IS NOT NULL THEN ${SYMBOL_STATUS.ONLINE}        -- 结构未变且已有向量（含 offline 恢复）→ online
+                        ELSE ${SYMBOL_STATUS.PENDING}                                       -- 结构未变但无向量（首次 or 之前失败）→ pending
                       END,
       updated_at    = NOW()
   `;
-        for (let i = 0; i < rows.length; i++) {
-            const r = rows[i];
-            const emb = embeddings?.[i];
-            // pgvector 接受 "[x1,x2,...]" 格式字符串
-            const vecStr = emb != null ? `[${emb.join(',')}]` : null;
-            const statusVal = vecStr !== null ? SYMBOL_STATUS.ONLINE : SYMBOL_STATUS.PENDING;
-            await client.query(sql, [
-                r.name,
-                r.type,
-                r.category,
-                r.path,
-                r.description,
-                r.content,
-                JSON.stringify(r.meta),
-                actor,
-                actor,
-                vecStr, // $10 → cast as vector, null 时写 NULL
-                r.semantic_hash,
-                r.file_hash,
-                statusVal,
-            ]);
-        }
-        await client.query('COMMIT');
-    }
-    catch (e) {
-        await client.query('ROLLBACK');
-        throw e;
-    }
-    finally {
-        client.release();
+    for (let i = 0; i < rows.length; i++) {
+        const r = rows[i];
+        const emb = embeddings?.[i];
+        // pgvector 接受 "[x1,x2,...]" 格式字符串
+        const vecStr = emb != null ? `[${emb.join(',')}]` : null;
+        const statusVal = vecStr !== null ? SYMBOL_STATUS.ONLINE : SYMBOL_STATUS.PENDING;
+        await client.query(sql, [
+            r.name,
+            r.type,
+            r.category,
+            r.path,
+            r.description,
+            r.content,
+            JSON.stringify(r.meta),
+            actor,
+            actor,
+            vecStr, // $10 → cast as vector, null 时写 NULL
+            r.semantic_hash,
+            r.file_hash,
+            statusVal,
+        ]);
     }
 }

package/dist/prompts/reusableCodeAdvisorPrompt.js

@@ -65,7 +65,7 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 > 输出上述模板后**等待用户在聊天框输入回复**，识别规则：
 > - 用户输入 **"1"、"采纳"、"采纳推荐"、"ok"、"好的"** 或类似确认词 → 从上方输出文本中读取 \`symbolId：<id>\` 那一行的值，立即调用 \`inc_usage\` 工具传入该 id，调用成功后回复"✓ 已记录使用，可直接集成"
 > - 用户输入 **"2"、"取消"、"不用了"** 或类似否定词 → 回复"好的，已取消"，停止
-> - 用户输入其他内容（如追问细节）→ 正常回答，回答结束后再次展示"是否采纳"选项
+> - 用户输入其他内容（如追问细节、props、最小接入方式）→ 可以继续补充说明，但回答结尾**必须再次原样展示**"是否采纳"的两个选项，不得省略
 
 无结果时：
 
@@ -85,6 +85,7 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 > 输出上述模板后**等待用户在聊天框输入回复**，识别规则：
 > - 用户输入 **"1"、"新建"、"帮我创建"** 或类似确认词 → 进入新建流程，引导用户确认最小接口设计
 > - 用户输入 **"2"、"取消"、"不用了"** → 回复"好的，已取消"，停止
+> - 用户输入其他内容（如追问为何没找到、想先看候选）→ 可以继续解释，但回答结尾**必须再次原样展示**"是否采纳"的两个选项，不得省略
 `;
 export function registerReusableCodeAdvisorPrompt(server) {
     server.prompt('reusable-code-advisor', REUSABLE_CODE_ADVISOR_DESCRIPTION, {

package/dist/repositories/chunkRepository.js

@@ -151,7 +151,7 @@ export class ChunkRepository {
                    1 - (embedding <=> $1::vector) AS similarity
             FROM ${env.chunksTable}
             WHERE embedding IS NOT NULL
-              AND status = $2
+              AND status = $2::smallint
         `;
         if (opts?.path) {
             params.push(opts.path);

package/dist/repositories/symbolRepository.js

@@ -146,7 +146,7 @@ export class SymbolRepository {
               path ILIKE $1 OR
               meta::text ILIKE $1
             )
-        AND status = $2
+        AND status = $2::smallint
     `;
         if (tokens.length) {
             const tokenClauses = tokens.map((token) => {
@@ -165,7 +165,7 @@ export class SymbolRepository {
               meta::text ILIKE $1 OR
               (${tokenClauses.join(' OR ')})
             )
-        AND status = $2
+        AND status = $2::smallint
     `;
         }
         if (type) {
@@ -212,7 +212,7 @@ export class SymbolRepository {
              1 - (embedding <=> $1::vector) AS similarity
       FROM ${env.symbolsTable}
       WHERE embedding IS NOT NULL
-        AND status = $2
+                AND status = $2::smallint
     `;
         if (opts?.type) {
             params.push(opts.type);
@@ -248,8 +248,9 @@ export class SymbolRepository {
       SELECT id, name, type, category, path, description, content, meta::text AS meta, usage_count, created_at
       FROM ${env.symbolsTable}
       WHERE name = $1
+                AND status = $2::smallint
       LIMIT 1
-      `, [name]);
+      `, [name, SEARCHABLE_STATUS]);
         console.error('[code-intelligence-mcp] repository.getByName.db table=%s rows=%s', env.symbolsTable, String(rows.length));
         if (rows.length === 0) {
             return null;
@@ -310,8 +311,9 @@ 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 1 = 1
+                        WHERE status = $1::smallint
     `;
+        params.push(SEARCHABLE_STATUS);
         if (type) {
             params.push(type);
             sql += ` AND type = $${params.length}`;

package/dist/services/recommendationService.js

@@ -552,26 +552,36 @@ export class RecommendationService {
                 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);
+        // 对优先级预排序后的 Top-K 做详情补查（getByName 补全完整 meta）
+        const enriched = await this.enrichTopCandidatesWithDetail(priorityScored.map((e) => e.item));
+        attempt.detailEnrichedCount = enriched.enrichedCount;
+        // 将补查结果回填到 priorityScored，保持优先级排序
+        const enrichedPriorityScored = enriched.ranked.map((item, idx) => ({
+            item,
+            adjustedScore: priorityScored[idx]?.adjustedScore ?? item.score,
+            adjustedReason: priorityScored[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;
+        }
+        // 已按优先级排序，直接构建候选结果
+        const candidates = qualifiedRanked.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(enrichedPriorityScored.length), String(qualifiedRanked.length), String(candidates.length));
         return candidates;
     }
     logAttemptCheckpoint(stage, attempt) {

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/workers/embeddingWorker.js

@@ -31,7 +31,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 +43,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 +56,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 +75,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,

package/package.json

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

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