@lorrylurui/code-intelligence-mcp 1.1.15 → 2.0.1

package/README.md

@@ -1,4 +1,4 @@
-# Code Intelligence MCP (Minimal)
+# Code Intelligence MCP
 
 - MCP Server（stdio）
 - Tool: `search_symbols`
@@ -8,7 +8,6 @@
 - Tool: `recommend_component`
 - Tool: `incUsage`
 - Prompt: `reusable-code-advisor`
-- MySQL Repository（可选启用）
 - Cursor Skill：`reusable-code-advisor`（`.cursor/skills/reusable-code-advisor/`，
 
 ## 1) 配置mcp servers
@@ -32,5 +31,77 @@
 
 ## 3) 项目根目录环境变量
 
+<!-- 最小配置 1.表名 2.需要检索的文件路径和类型 -->
+
 MYSQL\*SYMBOLS_TABLE=frontend_collections_symbols
-INDEX_GLOB=interview-code-collection/\*\*/\_.{js,jsx,ts,tsx}
+INDEX_GLOB=xxx/\*\*/\_.{js,jsx,ts,tsx}
+
+# 待优化项
+
+修复优先级：
+✅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-cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * CI增量索引CLI：处理changed files和deleted files
+ *
+ * 用法：
+ * node src/cli/ci-index-cli.js --changed src/file1.ts,src/file2.ts --deleted src/old.ts --renamed src/old.ts:src/new.ts
+ */
+import { resolve } from 'node:path';
+import { loadProjectDotenv } from '../config/env.js';
+import { runIncrementalIndex } from './ci-index.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const projectRoot = resolve(process.env.INDEX_ROOT ?? process.cwd());
+    loadProjectDotenv(projectRoot);
+    let changedFiles = [];
+    let deletedFiles = [];
+    let renamedFiles = [];
+    /** 解析 --key value 和 --key=value 两种格式 */
+    function getArgValue(key, idx) {
+        const arg = args[idx];
+        const prefix = `--${key}=`;
+        if (arg.startsWith(prefix))
+            return [arg.slice(prefix.length), idx];
+        if (arg === `--${key}` && idx + 1 < args.length)
+            return [args[idx + 1], idx + 1];
+        return [null, idx];
+    }
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--changed' || arg.startsWith('--changed=')) {
+            const [val, next] = getArgValue('changed', i);
+            if (val) {
+                changedFiles = val
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                i = next;
+            }
+        }
+        else if (arg === '--deleted' || arg.startsWith('--deleted=')) {
+            const [val, next] = getArgValue('deleted', i);
+            if (val) {
+                deletedFiles = val
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                i = next;
+            }
+        }
+        else if (arg === '--renamed' || arg.startsWith('--renamed=')) {
+            const [val, next] = getArgValue('renamed', i);
+            if (val) {
+                renamedFiles = val
+                    .split(',')
+                    .map((s) => {
+                    const [from, to] = s.split(':');
+                    return { from: from.trim(), to: to.trim() };
+                })
+                    .filter((r) => r.from && r.to);
+                i = next;
+            }
+        }
+    }
+    if (changedFiles.length === 0 &&
+        deletedFiles.length === 0 &&
+        renamedFiles.length === 0) {
+        console.error('Usage: node ci-index-cli.js --changed file1,file2 --deleted file3 --renamed old:new');
+        process.exit(1);
+    }
+    console.error(`[ci-index-cli] projectRoot=${projectRoot}`);
+    console.error(`[ci-index-cli] changed: ${changedFiles.join(', ')}`);
+    console.error(`[ci-index-cli] deleted: ${deletedFiles.join(', ')}`);
+    console.error(`[ci-index-cli] renamed: ${renamedFiles.map((r) => `${r.from}->${r.to}`).join(', ')}`);
+    await runIncrementalIndex({
+        projectRoot,
+        changedFiles,
+        deletedFiles,
+        renamedFiles,
+    });
+    console.error('[ci-index-cli] completed successfully');
+}
+main().catch((err) => {
+    console.error('[ci-index-cli] failed:', err);
+    process.exit(1);
+});

package/dist/cli/ci-index.js

@@ -0,0 +1,76 @@
+// CI增量索引：处理changed files和deleted files
+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 { enqueueEmbeddingBatch, closeEmbeddingQueue, } from '../services/embeddingQueue.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({
+            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}`);
+        }
+        // 批量入队：jobId = semanticHash，相同 hash 自动去重，1000 个符号可能只产生 N 个唯一 job
+        const hashes = [
+            ...new Set(rows.map((r) => r.semantic_hash).filter(Boolean)),
+        ];
+        if (hashes.length > 0) {
+            await enqueueEmbeddingBatch(hashes, env.symbolsTable);
+            console.error(`[ci-index] enqueued ${hashes.length} unique semantic hashes for embedding`);
+        }
+    }
+    await closeEmbeddingQueue();
+    await pool.end();
+    console.error(`[ci-index] processed ${deletedFiles.length} deletions, ${renamedFiles.length} renames, ${changedFiles.length} changes`);
+}

package/dist/cli/detect-duplicates.js

@@ -109,8 +109,7 @@ async function main() {
         }
     }
     loadProjectDotenv(projectRoot);
-    console.error(`[duplicate-check] projectRoot=${projectRoot}, ` +
-        `MYSQL_ENABLED=${process.env.MYSQL_ENABLED}`);
+    console.error(`[duplicate-check] projectRoot=${projectRoot}, `);
     // 3️ 解析命令行参数
     const args = parseArgs(process.argv.slice(2));
     const changedFilesPath = args.get('changed-files') ?? 'changed_files.txt';
@@ -131,10 +130,6 @@ async function main() {
     }
     else {
         validateEnv();
-        const pool = getMySqlPool();
-        if (!pool || !env.mysqlEnabled) {
-            throw new Error('duplicate-check 需要 MYSQL_ENABLED=true 并可连接 MySQL。');
-        }
         if (!env.embeddingServiceUrl) {
             throw new Error('duplicate-check 需要 EMBEDDING_SERVICE_URL（embedding service）。');
         }

package/dist/cli/embedding-worker-cli.js

@@ -0,0 +1,35 @@
+/**
+ * embedding worker 进程入口。
+ *
+ * 本地启动：
+ *   npm run worker:embedding
+ *
+ * 大仓分片（多进程并行）：
+ *   WORKER_CONCURRENCY=10 npm run worker:embedding &
+ *   WORKER_CONCURRENCY=10 npm run worker:embedding &
+ *   # 启动 N 个进程，BullMQ 自动分配任务，无需手动分片
+ *
+ * 环境变量：
+ *   REDIS_URL           Redis 连接 URL（默认 redis://127.0.0.1:6379）
+ *   PG_URL              PostgreSQL 连接字符串
+ *   EMBEDDING_SERVICE_URL  Python embedding 服务地址
+ *   WORKER_CONCURRENCY  单进程并发 job 数（默认 5）
+ *   WORKER_RPM_LIMIT    全局 RPM 上限（默认 100，跨所有 worker 进程）
+ *   PROJECT_ROOT        项目根目录，用于加载 .env（默认 cwd）
+ */
+import { loadProjectDotenv } from '../config/env.js';
+import { startEmbeddingWorker } from '../workers/embeddingWorker.js';
+const projectRoot = process.env.PROJECT_ROOT ?? process.cwd();
+loadProjectDotenv(projectRoot);
+const concurrency = Number(process.env.WORKER_CONCURRENCY ?? '5');
+const rpmLimit = Number(process.env.WORKER_RPM_LIMIT ?? '100');
+const { worker, stop } = await startEmbeddingWorker({ concurrency, rpmLimit });
+console.error(`[embedding-worker] started  concurrency=${concurrency}  rpm_limit=${rpmLimit}`);
+// 当前 job 执行完再退出
+for (const sig of ['SIGINT', 'SIGTERM']) {
+    process.on(sig, async () => {
+        console.error('[embedding-worker] shutting down…');
+        await stop();
+        process.exit(0);
+    });
+}

package/dist/cli/index-codebase-cli.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Phase 2 CLI：扫描代码库并写入 PostgreSQL `symbols`。
+ *
+ * 环境变量加载顺序：
+ * 1. 命令行参数（最高优先级）
+ * 2. INDEX_ROOT 指向的第三方项目 .env（中等优先级，优先使用第三方显式设置的值）
+ * 3. 本地的 .env（最低优先级，提供默认值）
+ */
+import { resolve } from 'node:path';
+import { CLI_KEYS, loadProjectDotenv } from '../config/env.js';
+import { runReindex } from '../services/reindex.js';
+/**
+ * 入口：加载第三方 .env → 校验环境 → 调用 runReindex。
+ * 进度与统计输出到 **stderr**，避免占用 stdout。
+ * 进程退出码：成功 `0`，连接失败或异常 `1`。
+ */
+async function main() {
+    // Step 1: 始终从 cwd 加载第三方 .env（这是 P2，会覆盖本地 MCP .env）
+    // 注意：不能用 process.env.INDEX_ROOT，那个值可能已被本地 MCP .env（P3）污染
+    const thirdPartyKeys = loadProjectDotenv(process.cwd());
+    // Step 2: INDEX_ROOT 只有来自 P1（CLI）或 P2（第三方 .env）时才可信
+    // 若只在本地 MCP .env（P3）里设了 INDEX_ROOT，在第三方项目中运行时应忽略它
+    const indexRoot = CLI_KEYS.has('INDEX_ROOT') || thirdPartyKeys.has('INDEX_ROOT')
+        ? process.env.INDEX_ROOT
+        : undefined;
+    const projectRoot = resolve(indexRoot ?? process.cwd());
+    console.error(`PG_URL=${process.env.PG_URL ? '(set)' : '(not set)'}` +
+        `[index] projectRoot=${projectRoot} (INDEX_ROOT: ${CLI_KEYS.has('INDEX_ROOT') ? 'CLI' : thirdPartyKeys.has('INDEX_ROOT') ? 'third-party .env' : 'cwd fallback'})`);
+    const globPatterns = process.env.INDEX_GLOB
+        ? process.env.INDEX_GLOB.split(/\s+/)
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : undefined;
+    const ignore = process.env.INDEX_IGNORE
+        ? process.env.INDEX_IGNORE.split(',').map((s) => s.trim())
+        : undefined;
+    const forceRebuild = process.argv.includes('--force-rebuild');
+    const result = await runReindex({
+        projectRoot,
+        globPatterns,
+        ignore,
+        dryRun: false,
+        forceRebuild,
+    });
+    console.error(`[index] extracted ${result.extractedCount} symbol(s), enqueued ${result.enqueuedCount} for embedding`);
+    console.error('[index] upserted into PostgreSQL, success:', result.upserted);
+}
+main().catch((err) => {
+    console.error('[index] failed:', err);
+    const anyErr = err;
+    if (anyErr.code === 'ECONNREFUSED') {
+        const pgUrl = process.env.PG_URL ?? 'postgresql://...@127.0.0.1:5432/...';
+        console.error(`[index] 原因: 无法连接 PostgreSQL（连接被拒绝）。当前 PG_URL=${pgUrl}。请确认 docker compose up -d 已启动 pgvector 容器。`);
+    }
+    else if (anyErr.code === 'ER_ACCESS_DENIED_ERROR' ||
+        anyErr.code === '28P01') {
+        console.error('[index] 原因: 用户名或密码错误，请检查 PG_URL 中的 user/password。');
+    }
+    else if (anyErr.code === 'ENOTFOUND' || anyErr.code === 'ETIMEDOUT') {
+        console.error('[index] 原因: 网络不可达或超时，请检查 PG_URL 中的 host 是否可解析。');
+    }
+    process.exit(1);
+});

package/dist/cli/index-codebase.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Phase 2 CLI：扫描代码库并写入 MySQL `symbols`（需 `MYSQL_ENABLED=true`）。
+ * Phase 2 CLI：扫描代码库并写入 MySQL `symbols`。
  *
  * 环境变量加载顺序：
  * 1. 命令行参数（最高优先级）
@@ -16,10 +16,11 @@ import { runReindex } from '../services/reindex.js';
  * 进程退出码：成功 `0`，无 MySQL 或异常 `1`。
  */
 async function main() {
+    // const projectRoot = resolve(process.env.INDEX_ROOT ?? process.cwd());
+    loadProjectDotenv(resolve(process.env.INDEX_ROOT ?? process.cwd()));
     const projectRoot = resolve(process.env.INDEX_ROOT ?? process.cwd());
-    loadProjectDotenv(projectRoot);
-    console.error(`[index] MYSQL_ENABLED=${process.env.MYSQL_ENABLED}, ` +
-        `MYSQL_HOST=${process.env.MYSQL_HOST}` +
+    console.error(projectRoot, process.env.INDEX_ROOT);
+    console.error(`MYSQL_HOST=${process.env.MYSQL_HOST}` +
         `[index] projectRoot=${projectRoot}`);
     const globPatterns = process.env.INDEX_GLOB
         ? process.env.INDEX_GLOB.split(/\s+/)

package/dist/config/env.js

@@ -3,101 +3,73 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { existsSync, readFileSync } from 'node:fs';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// 解析命令行参数 --key=value 格式，注入到 process.env
+// ─── Priority 1 (highest): Third-party CLI args --KEY=VALUE ───────────────────
+// 记录哪些 key 来自命令行，任何后续加载都不得覆盖
+export const CLI_KEYS = new Set();
 for (const arg of process.argv) {
     const match = arg.match(/^--([A-Z_][A-Z0-9_]*)=(.+)$/);
     if (match) {
         process.env[match[1]] = match[2];
+        CLI_KEYS.add(match[1]);
     }
 }
-// MCP Server 本地 .env 路径（固定指向项目根目录）
-const MCP_SERVER_ROOT = path.resolve(__dirname, '..', '..', './dist'); // MCP Server 根目录
-const MCP_SERVER_ENV_PATH = path.resolve(MCP_SERVER_ROOT, '.env');
-dotenv.config({
-    path: MCP_SERVER_ENV_PATH,
-    override: false, // 不覆盖已存在的变量
-});
+// ─── Priority 3 (lowest): Local MCP repo .env ─────────────────────────────────
+// override: false → 只填补尚未设置的 key，不覆盖 CLI 参数
+// dev 模式: __dirname = src/config → ../../ = 项目根目录
+// prod 模式: __dirname = dist/config → ../../ = 项目根目录
+const MCP_SERVER_ENV_PATH = path.resolve(__dirname, '..', '..', '.env');
+if (existsSync(MCP_SERVER_ENV_PATH)) {
+    dotenv.config({ path: MCP_SERVER_ENV_PATH, override: false });
+}
 /**
- * 从指定项目根目录加载 .env 到 process.env
- * 行为：优先使用第三方显式设置的值，否则保留 MCP Server 本地配置
+ * 加载第三方项目的 .env 文件（Priority 2）。
+ *
+ * 优先级规则：
+ *   第三方 CLI 参数（P1） > 第三方 .env（P2） > 本地 MCP .env（P3）
+ *
+ * - CLI 参数在 CLI_KEYS 中已记录，永不覆盖
+ * - 第三方 .env 中的 key 覆盖本地 MCP .env（即 P2 > P3）
+ *
+ * 应在进程启动后、任何 env.xxx 读取前尽早调用一次。
  */
 export function loadProjectDotenv(projectRoot) {
     const envPath = path.resolve(projectRoot, '.env');
-    if (!existsSync(envPath)) {
-        return;
-    }
-    const content = readFileSync(envPath, 'utf-8');
-    // 第一步：收集第三方 .env 中所有显式定义的 key
-    const thirdPartyKeys = new Set();
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIdx = trimmed.indexOf('=');
-        if (eqIdx === -1)
-            continue;
-        const key = trimmed.slice(0, eqIdx).trim();
-        if (!key)
-            continue;
-        thirdPartyKeys.add(key);
-    }
-    // 第二步：如果某个 key 是第三方显式定义的，则覆盖（不管值是什么）
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        const eqIdx = trimmed.indexOf('=');
-        if (eqIdx === -1)
-            continue;
-        const key = trimmed.slice(0, eqIdx).trim();
-        let value = trimmed.slice(eqIdx + 1).trim();
-        value = value.replace(/^["']|["']$/g, '');
-        if (!key)
-            continue;
-        // 只有当第三方显式定义了这个 key 时才覆盖
-        if (thirdPartyKeys.has(key)) {
-            process.env[key] = value;
-        }
-    }
-}
-// 外部传入的 env 已在上一步保留，这里确保环境变量已正确设置
-for (const arg of process.argv) {
-    const match = arg.match(/^--([A-Z_][A-Z0-9_]*)=(.+)$/);
-    if (match) {
-        process.env[match[1]] = match[2];
+    if (!existsSync(envPath))
+        return new Set();
+    // dotenv.parse 只解析文件，不写 process.env
+    const parsed = dotenv.parse(readFileSync(envPath));
+    const loadedKeys = new Set();
+    for (const [key, value] of Object.entries(parsed)) {
+        if (CLI_KEYS.has(key))
+            continue; // P1 CLI args 永不被覆盖
+        process.env[key] = value; // P2 第三方 .env 覆盖 P3 本地 .env
+        loadedKeys.add(key);
     }
+    return loadedKeys;
 }
-const requiredWhenEnabled = [
-    'MYSQL_HOST',
-    'MYSQL_USER',
-    'MYSQL_DATABASE',
-];
-console.error(`[Config] MYSQL_ENABLED: ${process.env.MYSQL_ENABLED},
-    MYSQL_HOST: ${process.env.MYSQL_HOST},
-    MYSQL_USER: ${process.env.MYSQL_USER},
-    MYSQL_DATABASE: ${process.env.MYSQL_DATABASE},
-    EMBEDDING_SERVICE_URL: ${process.env.EMBEDDING_SERVICE_URL},
-    MYSQL_SYMBOLS_TABLE: ${process.env.MYSQL_SYMBOLS_TABLE}
-    `);
+// ─── env 对象：getter 懒读取，确保 loadProjectDotenv() 后立即生效 ────────────
+// 每次访问 env.xxx 都从 process.env 实时读取，避免快照冻结问题
 export const env = {
-    mysqlEnabled: process.env.MYSQL_ENABLED === 'true',
-    mysqlHost: process.env.MYSQL_HOST ?? '127.0.0.1',
-    mysqlPort: Number(process.env.MYSQL_PORT ?? '3306'),
-    mysqlUser: process.env.MYSQL_USER ?? 'root',
-    mysqlPassword: process.env.MYSQL_PASSWORD ?? '',
-    mysqlDatabase: process.env.MYSQL_DATABASE ?? 'code_intelligence',
-    /** symbols 表名，可通过 MYSQL_SYMBOLS_TABLE 环境变量配置 */
-    mysqlSymbolsTable: process.env.MYSQL_SYMBOLS_TABLE ?? 'symbols',
-    /** Phase 5：指向 Python FastAPI 嵌入服务根 URL，如 http://127.0.0.1:8765 */
-    embeddingServiceUrl: (process.env.EMBEDDING_SERVICE_URL ?? '').trim(),
+    /** PostgreSQL 连接字符串，如 postgresql://user:pass@host:5432/db */
+    get pgUrl() {
+        return (process.env.PG_URL ??
+            'postgresql://postgres:devpassword@127.0.0.1:5432/code_intelligence');
+    },
+    /** symbols 表名，可通过 SYMBOLS_TABLE 环境变量配置 */
+    get symbolsTable() {
+        return process.env.SYMBOLS_TABLE ?? 'symbols';
+    },
+    /** Python FastAPI 嵌入服务根 URL，如 http://127.0.0.1:8765 */
+    get embeddingServiceUrl() {
+        return (process.env.EMBEDDING_SERVICE_URL ?? '').trim();
+    },
+    /** Redis 连接 URL，供 BullMQ embedding worker 使用 */
+    get redisUrl() {
+        return process.env.REDIS_URL ?? 'redis://127.0.0.1:6379';
+    },
 };
 export function validateEnv() {
-    if (!env.mysqlEnabled) {
-        return;
-    }
-    for (const key of requiredWhenEnabled) {
-        if (!process.env[key]) {
-            throw new Error(`Missing environment variable: ${key}`);
-        }
+    if (!process.env.PG_URL) {
+        console.warn('[Config] PG_URL not set, using default: postgresql://postgres:devpassword@127.0.0.1:5432/code_intelligence');
     }
 }

package/dist/config/symbolStatus.js

@@ -0,0 +1,8 @@
+export const SYMBOL_STATUS = {
+    OFFLINE: 0,
+    PENDING: 1,
+    ONLINE: 2,
+    ERROR: 3,
+};
+export const DEFAULT_STATUS_ON_UPSERT = SYMBOL_STATUS.PENDING;
+export const SEARCHABLE_STATUS = SYMBOL_STATUS.ONLINE;

package/dist/db/mysql.js

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

package/dist/db/postgres.js

@@ -0,0 +1,13 @@
+import pg from 'pg';
+import { env } from '../config/env.js';
+const { Pool } = pg;
+let pool = null;
+export function getPool() {
+    if (!pool) {
+        pool = new Pool({
+            connectionString: env.pgUrl,
+            max: 10,
+        });
+    }
+    return pool;
+}