@lorrylurui/code-intelligence-mcp 1.1.15 → 2.0.1

package/dist/services/reindex.js

@@ -1,61 +1,108 @@
-import { resolve } from 'node:path';
-import { loadProjectDotenv } from '../config/env.js';
-import { getMySqlPool } from '../db/mysql.js';
-import { indexedRowToEmbedText } from '../indexer/embedText.js';
-import { indexProject } from '../indexer/indexProject.js';
+import { resolve, join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import fg from 'fast-glob';
+import { env } from '../config/env.js';
+import { getPool } from '../db/postgres.js';
+import { getAllTableSQLs } from '../db/schema.js';
+import { indexProject, DEFAULT_IGNORE } from '../indexer/indexProject.js';
 import { upsertSymbols } from '../indexer/persistSymbols.js';
-import { createEmbeddingClient, embedAll, } from '../services/embeddingClient.js';
+import { computeFileHash } from '../indexer/tsAstNormalizer.js';
+import { getRelativePathForDisplay } from '../indexer/heuristics.js';
+import { enqueueEmbeddingBatch, closeEmbeddingQueue, } from '../services/embeddingQueue.js';
+import { SYMBOL_STATUS } from '../config/symbolStatus.js';
 export async function runReindex(options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
-    const { dryRun = false } = options;
-    // 1️ 加载第三方 .env：只覆盖未定义的变量 → 保留 MCP Server 自身配置
-    loadProjectDotenv(projectRoot);
-    // 2️ 打印生效的环境变量（便于调试）
-    console.error(`[reindex] projectRoot=${projectRoot}, dryRun=${dryRun}, ` +
-        `MYSQL_ENABLED=${process.env.MYSQL_ENABLED}, ` +
-        `MYSQL_HOST=${process.env.MYSQL_HOST}`);
-    // 3️⃣ 只有需要写入数据库时才检查 MySQL 并建立连接
-    // 注意：直接检查 process.env，因为 env.mysqlEnabled 是模块加载时计算的，不会反映 loadProjectDotenv 的更新
-    const mysqlEnabled = process.env.MYSQL_ENABLED === 'true';
-    const embeddingServiceUrl = process.env.EMBEDDING_SERVICE_URL;
+    const { dryRun = false, forceRebuild = false } = options;
+    console.error(`[reindex] projectRoot=${projectRoot}, dryRun=${dryRun}, forceRebuild=${forceRebuild}, PG_URL=${process.env.PG_URL ? '(set)' : '(not set)'}, SYMBOLS_TABLE=${env.symbolsTable}`);
     let pool = null;
     if (!dryRun) {
-        if (!mysqlEnabled) {
-            throw new Error(`最新！${JSON.stringify(process.env)}执行 reindex 写入数据库需要 MYSQL_ENABLED=true。' +
-                    '第三方项目可在 .env 中配置此变量（未配置则使用 MCP Server 本地配置）。`);
+        pool = getPool();
+        await pool.query('SELECT 1');
+        console.error('[reindex] PostgreSQL connection successful');
+        // 确保 extension + table + indexes 存在（幂等，多租户表名安全）
+        for (const sql of getAllTableSQLs()) {
+            await pool.query(sql);
         }
-        pool = getMySqlPool();
-        await pool.query('SELECT 1'); // 测试连接
-        console.error('[reindex] MySQL connection successful');
+        console.error(`[reindex] schema ready: ${env.symbolsTable}`);
     }
+    // ─── 1. glob 解析出全量文件列表（绝对路径）──────────────────────────
+    const ignore = [...DEFAULT_IGNORE, ...(options.ignore ?? [])];
+    const patterns = (options.globPatterns ?? ['src/**/*.{ts,tsx}']).map((p) => p.startsWith('/') ? p : join(projectRoot, p).replace(/\\/g, '/'));
+    const allFiles = await fg(patterns, {
+        absolute: true,
+        ignore,
+        onlyFiles: true,
+        dot: false,
+    });
+    console.error(`[reindex] glob found ${allFiles.length} file(s)`);
+    // ─── 2. file_hash 过滤：跳过 AST 未变的文件（CPU 优化）────────────────
+    // forceRebuild 时跳过此过滤，file_hash 不可复用（模板/模型变更时相同文件产出不同 content）
+    let filesToIndex = allFiles;
+    let skippedFiles = 0;
+    if (!forceRebuild && pool && allFiles.length > 0) {
+        // 计算所有文件当前 hash
+        const currentFileHashes = new Map(); // relPath → hash
+        for (const absPath of allFiles) {
+            const content = readFileSync(absPath, 'utf-8');
+            const relPath = getRelativePathForDisplay(projectRoot, absPath);
+            currentFileHashes.set(relPath, computeFileHash(content));
+        }
+        // 一次性批量查 DB 已有的 file_hash
+        const relPaths = [...currentFileHashes.keys()];
+        const { rows: dbRows } = await pool.query(`SELECT DISTINCT path, file_hash FROM ${env.symbolsTable}
+             WHERE path = ANY($1) AND file_hash IS NOT NULL`, [relPaths]);
+        const dbFileHash = new Map(dbRows.map((r) => [r.path, r.file_hash]));
+        filesToIndex = allFiles.filter((absPath) => {
+            const relPath = getRelativePathForDisplay(projectRoot, absPath);
+            return currentFileHashes.get(relPath) !== dbFileHash.get(relPath);
+        });
+        skippedFiles = allFiles.length - filesToIndex.length;
+        console.error(`[reindex] file_hash: ${skippedFiles} unchanged (skipped), ${filesToIndex.length} changed (to parse)`);
+    }
+    else if (forceRebuild) {
+        console.error(`[reindex] forceRebuild=true, skipping file_hash filter — parsing all ${allFiles.length} file(s)`);
+    }
+    if (filesToIndex.length === 0) {
+        console.error('[reindex] all files unchanged, nothing to do');
+        return {
+            projectRoot,
+            extractedCount: 0,
+            skippedFiles,
+            enqueuedCount: 0,
+            upserted: false,
+        };
+    }
+    // ─── 3. 只对变更文件做 AST 解析 ──────────────────────────────────
     const rows = await indexProject({
         projectRoot,
-        globPatterns: options.globPatterns,
-        ignore: options.ignore,
+        globPatterns: filesToIndex,
     });
-    console.error(`[reindex] extracted ${rows.length} symbol(s) from ${projectRoot}`);
-    let embeddingsComputed = false;
-    let embeddingPayload;
-    if (!options.dryRun && rows.length > 0 && embeddingServiceUrl) {
-        try {
-            const client = createEmbeddingClient(embeddingServiceUrl);
-            const texts = rows.map(indexedRowToEmbedText);
-            const vecs = await embedAll(client, texts);
-            embeddingPayload = vecs;
-            embeddingsComputed = true;
+    console.error(`[reindex] extracted ${rows.length} symbol(s) from ${filesToIndex.length} changed file(s)`);
+    // ─── 4. 写库（全部 pending）→ 入队，worker 异步处理 embedding + category ──
+    const nullPayload = rows.map(() => null);
+    const pendingHashes = [
+        ...new Set(rows.map((r) => r.semantic_hash).filter(Boolean)),
+    ];
+    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)`);
         }
-        catch (err) {
-            console.error('[reindex] embedding skipped (service error):', err);
-            embeddingPayload = rows.map(() => null);
+        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`);
         }
-    }
-    if (!options.dryRun) {
-        await upsertSymbols(pool, rows, embeddingPayload);
+        await closeEmbeddingQueue();
     }
     return {
         projectRoot,
         extractedCount: rows.length,
-        upserted: !options.dryRun,
-        embeddingsComputed,
+        skippedFiles,
+        enqueuedCount: pendingHashes.length,
+        upserted: !dryRun,
     };
 }

package/dist/tools/getSymbolDetail.js

@@ -5,7 +5,9 @@ export const getSymbolDetailInput = z.object({
 export function createGetSymbolDetailTool(repository) {
     return {
         name: 'get_symbol_detail',
-        description: '按名称获取单个代码块的完整详情。',
+        description: '获取单个代码块的完整详情（含源码、参数类型、调用关系、副作用）。\n' +
+            '仅在以下情况调用：search_symbols 返回的摘要信息不足以判断是否适用（如签名模糊、副作用不明确）。\n' +
+            '通常对 top 1-3 候选调用，不要对所有结果批量调用。',
         inputSchema: getSymbolDetailInput.shape,
         handler: async (input) => {
             const symbol = await repository.getByName(input.name);

package/dist/tools/incUsage.js

@@ -6,7 +6,9 @@ export const incUsageInput = z.object({
 export function createIncUsageTool(repository) {
     return {
         name: 'inc_usage',
-        description: '当开发者采纳了某个推荐代码块时，调用此工具记录。usage_count 会 +1，用于后续排序优化。',
+        description: '在用户明确确认"采纳推荐"后调用，记录复用行为用于排序优化（usage_count +1）。\n' +
+            '注意：仅在用户主动确认采纳时调用，不要在推荐后自动调用。\n' +
+            'symbolId 从 search_symbols 或 search_by_structure 返回结果的 id 字段获取。',
         inputSchema: incUsageInput.shape,
         handler: async (input) => {
             const success = await repository.incUsage(input.symbolId);
@@ -15,7 +17,10 @@ export function createIncUsageTool(repository) {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({ error: '未找到该代码块', symbolId: input.symbolId }, null, 2),
+                            text: JSON.stringify({
+                                error: '未找到该代码块',
+                                symbolId: input.symbolId,
+                            }, null, 2),
                         },
                     ],
                 };
@@ -24,7 +29,11 @@ export function createIncUsageTool(repository) {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({ ok: true, symbolId: input.symbolId, message: 'usage_count 已 +1' }, null, 2),
+                        text: JSON.stringify({
+                            ok: true,
+                            symbolId: input.symbolId,
+                            message: 'usage_count 已 +1',
+                        }, null, 2),
                     },
                 ],
             };

package/dist/tools/reindex.js

@@ -9,7 +9,9 @@ export const reindexInput = z.object({
 export function createReindexTool() {
     return {
         name: 'reindex',
-        description: '重建源码代码块索引并写入 MySQL；设置 dryRun=true 时仅预览抽取数量，不落库、不调用嵌入服务。若配置 EMBEDDING_SERVICE_URL，非 dryRun 时会写入向量列。',
+        description: '⚠️ 高成本操作（耗时可能超过数分钟），仅在用户明确要求"重建索引"时调用，不要因搜索结果不佳而自动调用。\n' +
+            '重建源码代码块索引并写入 MySQL。设置 dryRun=true 时仅预览抽取数量，不落库。\n' +
+            '写入后 embedding 由后台 worker 异步处理，队列清空后打印完成信号。',
         inputSchema: reindexInput.shape,
         handler: async (input) => {
             const startedAt = Date.now();

package/dist/tools/searchByStructure.js

@@ -3,7 +3,9 @@ import { z } from 'zod';
 import { rankSymbols } from '../services/ranking.js';
 export const searchByStructureInput = z.object({
     fields: z.array(z.string().min(1)).min(1),
-    type: z.enum(['component', 'util', 'selector', 'type']).optional(),
+    type: z
+        .enum(['component', 'function', 'hook', 'type', 'interface', 'class'])
+        .optional(),
     category: z.string().optional(),
     limit: z.number().int().min(1).max(100).optional().default(20),
     ranked: z.boolean().optional().default(true),
@@ -11,7 +13,9 @@ export const searchByStructureInput = z.object({
 export function createSearchByStructureTool(repository) {
     return {
         name: 'search_by_structure',
-        description: '通过结构化字段（如 props/params/properties/hooks）搜索代码块，适用于 API 形态的查询。',
+        description: '按代码块的结构字段（props/params/hooks）检索，适合已知接口形态时使用。\n' +
+            '示例：需要一个接受 value、onChange、error 三个 prop 的输入组件 → fields: ["value", "onChange", "error"], type: "component"\n' +
+            '与 search_symbols 配合：先语义检索候选，再用本工具做 API 结构过滤以精确匹配。',
         inputSchema: searchByStructureInput.shape,
         handler: async (input) => {
             const rows = await repository.searchByStructure(input.fields, {

package/dist/tools/searchSymbols.js

@@ -2,16 +2,24 @@ import { z } from 'zod';
 import { rankSemanticHits, rankSymbols } from '../services/ranking.js';
 export const searchSymbolsInput = z.object({
     query: z.string().min(1),
-    type: z.enum(['component', 'util', 'selector', 'type']).optional(),
+    type: z
+        .enum(['component', 'function', 'hook', 'type', 'interface', 'class'])
+        .optional(),
     ranked: z.boolean().optional().default(true),
     /** Phase 5：自然语言 / 描述句检索（需 EMBEDDING_SERVICE_URL + 索引已写入 embedding） */
     semantic: z.boolean().optional().default(false),
     limit: z.number().int().min(1).max(100).optional().default(20),
 });
+const SCORE_THRESHOLD_FOR_FINAL = 0.45; // 综合排序分阈值（语义相似度占50%权重，原始0.5相似度 ≈ 综合0.35起）
+const TOP_K_FOR_FINAL_RESULTS = 20; // 结果上限,返回相似度高的，保证数据质量
 export function createSearchSymbolsTool(repository) {
     return {
         name: 'search_symbols',
-        description: '通过关键词和可选的类型搜索代码块。设置 semantic=true 可进行自然语言/意图式搜索（此功能需要 embedding 服务 + 已索引的向量）。',
+        description: '搜索项目中已有的可复用代码块（函数、组件、Hook、类型等）。在生成新代码之前必须先调用本工具，确认是否已有实现。\n' +
+            '- 有明确名称时（如 "useDebounce"）：semantic=false（默认），直接关键词检索\n' +
+            '- 描述功能意图时（如 "防抖"、"处理表单提交"）：semantic=true，进行语义检索（需 embedding 服务已就绪）\n' +
+            '- 不确定 type 时省略该参数，不要猜测\n' +
+            '- 返回结果含 semanticSimilarity 字段：>0.85 高置信度可直接推荐，0.6-0.85 需结合 description 判断，<0.6 说明可能无合适实现',
         inputSchema: searchSymbolsInput.shape,
         handler: async (input) => {
             if (input.semantic) {
@@ -21,7 +29,8 @@ export function createSearchSymbolsTool(repository) {
                 });
                 const simById = new Map(hits.map((h) => [h.symbol.id, h.similarity]));
                 const resultRows = input.ranked
-                    ? rankSemanticHits(hits).map((item) => ({
+                    ? rankSemanticHits(hits)
+                        .map((item) => ({
                         id: item.symbol.id,
                         name: item.symbol.name,
                         type: item.symbol.type,
@@ -33,6 +42,8 @@ export function createSearchSymbolsTool(repository) {
                         reasonDetail: item.reason,
                         semanticSimilarity: Number((simById.get(item.symbol.id) ?? 0).toFixed(4)),
                     }))
+                        .filter((x) => x.score >= SCORE_THRESHOLD_FOR_FINAL) // 基于综合排序分过滤，保留 usage/recency 高的结果
+                        .slice(0, TOP_K_FOR_FINAL_RESULTS)
                     : hits.map((h) => ({
                         id: h.symbol.id,
                         name: h.symbol.name,
@@ -53,7 +64,8 @@ export function createSearchSymbolsTool(repository) {
             }
             const rows = await repository.search(input.query, input.type);
             const resultRows = input.ranked
-                ? rankSymbols(input.query, rows).map((item) => ({
+                ? rankSymbols(input.query, rows)
+                    .map((item) => ({
                     id: item.symbol.id,
                     name: item.symbol.name,
                     type: item.symbol.type,
@@ -64,6 +76,8 @@ export function createSearchSymbolsTool(repository) {
                     reason: item.reason.summary,
                     reasonDetail: item.reason,
                 }))
+                    .filter((x) => x.score >= SCORE_THRESHOLD_FOR_FINAL) // 基于综合排序分过滤
+                    .slice(0, TOP_K_FOR_FINAL_RESULTS)
                 : rows.map((r) => ({
                     id: r.id,
                     name: r.name,

package/dist/workers/embeddingWorker.js

@@ -0,0 +1,145 @@
+/**
+ * BullMQ embedding worker（常驻消费进程）。
+ *
+ * 流程：
+ * 1. 收到 job { semanticHash }
+ * 2. 查 semantic_hash 缓存：若已有 status=online 的符号带 embedding → 直接复用（0 次 API 调用）
+ * 3. 缓存未命中 → 取一条 pending 行构建语义文本 → 调 embedding API
+ * 4. 批量 UPDATE：所有 semantic_hash 相同且 status=pending 的行一次性写入向量并置 online
+ *
+ * 并发/限流：
+ * - concurrency 控制同时处理的 job 数（默认 5）
+ * - BullMQ limiter 控制全局 RPM（默认 100/min，留 buffer 低于 OpenAI 3000 RPM）
+ *
+ * 大仓分片：
+ * - 直接启动多个 worker 进程（同一 Redis）即可水平扩展，BullMQ 原生分布式协调
+ */
+import { Worker, QueueEvents } from 'bullmq';
+import { Redis } from 'ioredis';
+import { env } from '../config/env.js';
+import { getPool } from '../db/postgres.js';
+import { createEmbeddingClient } from '../services/embeddingClient.js';
+import { indexedRowToEmbedText } from '../indexer/embedText.js';
+import { initCategoryEmbeddings, resolveCategory, } from '../indexer/categoryClassifier.js';
+import { SYMBOL_STATUS } from '../config/symbolStatus.js';
+async function processEmbedJob(job, pool) {
+    const { semanticHash } = job.data;
+    // 优先使用 job payload 里的表名（跨项目场景），降级到 env（单项目场景）
+    const table = job.data.symbolsTable ?? env.symbolsTable;
+    const shortHash = semanticHash.slice(0, 10);
+    const embedClient = createEmbeddingClient(env.embeddingServiceUrl);
+    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
+         LIMIT 1`, [semanticHash, SYMBOL_STATUS.ONLINE]);
+    let vector;
+    if (cached.length > 0) {
+        // Cache hit: 直接复用已有向量，0 次 API 调用
+        // pgvector 返回字符串 "[x1,x2,...]", JSON.parse 可直接解析
+        vector =
+            typeof cached[0].embedding === 'string'
+                ? JSON.parse(cached[0].embedding)
+                : 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`, [
+            `[${vector.join(',')}]`,
+            SYMBOL_STATUS.ONLINE,
+            semanticHash,
+            SYMBOL_STATUS.PENDING,
+        ]);
+        console.error(`[worker] ✅ cache hit   [${ts()}]  table=${table}  hash=${shortHash}…  updated ${cacheResult.rowCount ?? 0} row(s)  (0 API calls)`);
+        return { updatedRows: cacheResult.rowCount ?? 0 };
+    }
+    // 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
+         LIMIT 1`, [semanticHash, SYMBOL_STATUS.PENDING]);
+    if (pending.length === 0) {
+        // 所有行已被并发 worker 处理，幂等退出
+        console.error(`[worker] ⚠️  skip       [${ts()}]  table=${table}  hash=${shortHash}…  (no pending rows)`);
+        return { updatedRows: 0 };
+    }
+    const row = pending[0];
+    const meta = typeof row.meta === 'string' ? JSON.parse(row.meta) : (row.meta ?? {});
+    const rowObj = { ...row, meta };
+    console.error(`[worker] 🔄 embedding  [${ts()}]  table=${table}  hash=${shortHash}…  ${row.path}:${row.name}`);
+    // 与 reindex 保持一致：优先用 content（语义模板），降级用 indexedRowToEmbedText
+    const doc = row.content ?? indexedRowToEmbedText(rowObj);
+    const vectors = await embedClient.embed([doc]);
+    vector = vectors[0];
+    // 生成 category（规则 → embedding → LLM 三层融合）
+    const [resolvedRow] = await resolveCategory([rowObj], [vector]);
+    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`, [
+        `[${vector.join(',')}]`,
+        SYMBOL_STATUS.ONLINE,
+        resolvedCategory,
+        semanticHash,
+        SYMBOL_STATUS.PENDING,
+    ]);
+    console.error(`[worker] ✓  done        [${ts()}]  table=${table}  hash=${shortHash}…  category=${resolvedCategory ?? 'null'}  updated ${result.rowCount ?? 0} row(s)`);
+    return { updatedRows: result.rowCount ?? 0 };
+}
+/**
+ * 启动 embedding worker，返回包含 stop() 的句柄。
+ */
+export async function startEmbeddingWorker(opts = {}) {
+    const { concurrency = 5, rpmLimit = 100 } = opts;
+    const connection = new Redis(env.redisUrl, {
+        maxRetriesPerRequest: null,
+        enableReadyCheck: false,
+    });
+    // 独立连接监听队列事件（BullMQ 要求不共用 Worker 连接）
+    const eventsConnection = new Redis(env.redisUrl, {
+        maxRetriesPerRequest: null,
+        enableReadyCheck: false,
+    });
+    const queueEvents = new QueueEvents('embedding', {
+        connection: eventsConnection,
+    });
+    const pool = getPool();
+    // 预热 category embeddings（仅在服务启动时调用一次）
+    if (env.embeddingServiceUrl) {
+        await initCategoryEmbeddings();
+        console.error('[embedding-worker] category embeddings initialized');
+    }
+    const worker = new Worker('embedding', (job) => processEmbedJob(job, pool), {
+        connection,
+        concurrency,
+        // 全局限流：所有 worker 进程共享，防止触发 OpenAI rate limit
+        limiter: { max: rpmLimit, duration: 60_000 },
+        // 完成后立即从 Redis 清除，避免 jobId 残留导致下次同 hash 无法入队
+        removeOnComplete: { count: 0 },
+        removeOnFail: { count: 100 },
+    });
+    // 累计统计：每次 drained 后重置
+    const stats = { completed: 0, updatedRows: 0 };
+    worker.on('completed', (_job, result) => {
+        stats.completed++;
+        stats.updatedRows += result?.updatedRows ?? 0;
+    });
+    worker.on('failed', (job, err) => {
+        console.error(`[worker] ✗  failed     [${new Date().toISOString()}]  table=${job?.data?.symbolsTable ?? env.symbolsTable}  hash=${job?.data?.semanticHash?.slice(0, 10)}…  err=${err.message}`);
+    });
+    worker.on('error', (err) => {
+        console.error(`[worker] error: ${err.message}`);
+    });
+    // 队列清空时打汇总（全量 reindex 入队后监听，确认所有 embedding 已处理）
+    queueEvents.on('drained', () => {
+        console.error(`[worker] ✅ queue drained  [${new Date().toISOString()}]  completed=${stats.completed} jobs  rows_updated=${stats.updatedRows}`);
+        stats.completed = 0;
+        stats.updatedRows = 0;
+    });
+    const stop = async () => {
+        await worker.close();
+        await queueEvents.close();
+    };
+    return { worker, stop };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lorrylurui/code-intelligence-mcp",
-    "version": "1.1.15",
+    "version": "2.0.1",
     "private": false,
     "description": "MCP server 提供仓库内可复用代码块（ts/tsx/js/jsx/css/less）的索引和查询能力，支持基于代码上下文的智能推荐。",
     "type": "module",
@@ -10,34 +10,39 @@
     ],
     "bin": {
         "code-intelligence-mcp": "./dist/index.js",
-        "code-intelligence-index": "./dist/cli/index-codebase.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",
         "dev:mcp": "node ./scripts/mcp-dev-watch.mjs",
         "build": "tsc -p tsconfig.json",
         "start": "node dist/index.js",
-        "index": "tsx src/cli/index-codebase.ts",
-        "detect-duplicates": "tsx src/cli/detect-duplicates.ts",
+        "index": "tsx src/cli/index-codebase-cli.ts",
+        "ci-index": "tsx src/cli/ci-index-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",
         "docker:down": "docker compose down",
-        "docker:logs": "docker compose logs -f mysql"
+        "docker:logs": "docker compose logs -f postgres"
     },
     "dependencies": {
         "@babel/parser": "^7.29.2",
         "@babel/types": "^7.29.0",
         "@modelcontextprotocol/sdk": "^1.12.3",
         "@types/react": "^19.2.14",
+        "bullmq": "^5.74.1",
         "dotenv": "^16.4.5",
         "fast-glob": "^3.3.2",
+        "ioredis": "^5.10.1",
         "mysql2": "^3.11.3",
+        "pg": "^8.20.0",
         "react": "^19.2.4",
         "ts-morph": "^25.0.0",
         "zod": "^3.23.8"
     },
     "devDependencies": {
         "@types/node": "^22.10.1",
+        "@types/pg": "^8.20.0",
         "tsx": "^4.19.2",
         "typescript": "^5.6.3"
     },