@lorrylurui/code-intelligence-mcp 1.2.0 → 2.0.1

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

@@ -15,31 +15,50 @@ async function main() {
     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' && i + 1 < args.length) {
-            changedFiles = args[i + 1]
-                .split(',')
-                .map((s) => s.trim())
-                .filter(Boolean);
-            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' && i + 1 < args.length) {
-            deletedFiles = args[i + 1]
-                .split(',')
-                .map((s) => s.trim())
-                .filter(Boolean);
-            i++;
+        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' && i + 1 < args.length) {
-            renamedFiles = args[i + 1]
-                .split(',')
-                .map((s) => {
-                const [from, to] = s.split(':');
-                return { from: from.trim(), to: to.trim() };
-            })
-                .filter((r) => r.from && r.to);
-            i++;
+        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 &&

package/dist/cli/ci-index.js

@@ -1,28 +1,21 @@
 // CI增量索引：处理changed files和deleted files
-import { env, loadProjectDotenv } from '../config/env.js';
-import { getMySqlPool } from '../db/mysql.js';
+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;
-    loadProjectDotenv(projectRoot);
-    const pool = getMySqlPool();
-    if (!pool) {
-        throw new Error('Failed to get MySQL pool');
-    }
-    const tableName = env.mysqlSymbolsTable;
+    const pool = getPool();
+    const tableName = env.symbolsTable;
     // 1. 删除文件：标记 offline
     for (const file of deletedFiles) {
-        await pool.query(`UPDATE ${tableName} SET status = ? WHERE path = ?`, [
-            SYMBOL_STATUS.OFFLINE,
-            file,
-        ]);
+        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 = ? WHERE path = ?`, [
+        await pool.query(`UPDATE ${tableName} SET path = $1 WHERE path = $2`, [
             to,
             from,
         ]);
@@ -35,21 +28,25 @@ export async function runIncrementalIndex(opts) {
             globPatterns: changedFiles,
         });
         for (const row of rows) {
-            // 写入结构化数据，标记pending
+            // 写入结构化数据
+            // 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 (?, ?, ?, ?, ?, ?, CAST(? AS JSON), ?, ?, ?, 0, NOW(), NOW())
-                 ON DUPLICATE KEY UPDATE
-                   type             = VALUES(type),
-                   category         = VALUES(category),
-                   description      = VALUES(description),
-                   content          = VALUES(content),
-                   meta             = VALUES(meta),
-                   file_hash        = VALUES(file_hash),
-                   semantic_hash    = VALUES(semantic_hash),
-                   status           = ?,
+                 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,
@@ -61,16 +58,15 @@ export async function runIncrementalIndex(opts) {
                 row.file_hash,
                 row.semantic_hash,
                 DEFAULT_STATUS_ON_UPSERT,
-                DEFAULT_STATUS_ON_UPSERT,
             ]);
-            console.error(`[ci-index] indexed (pending): ${row.path}:${row.name}`);
+            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);
+            await enqueueEmbeddingBatch(hashes, env.symbolsTable);
             console.error(`[ci-index] enqueued ${hashes.length} unique semantic hashes for embedding`);
         }
     }

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

@@ -11,7 +11,7 @@
  *
  * 环境变量：
  *   REDIS_URL           Redis 连接 URL（默认 redis://127.0.0.1:6379）
- *   MYSQL_HOST / ...    MySQL 连接配置
+ *   PG_URL              PostgreSQL 连接字符串
  *   EMBEDDING_SERVICE_URL  Python embedding 服务地址
  *   WORKER_CONCURRENCY  单进程并发 job 数（默认 5）
  *   WORKER_RPM_LIMIT    全局 RPM 上限（默认 100，跨所有 worker 进程）
@@ -23,13 +23,13 @@ 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 = startEmbeddingWorker({ concurrency, rpmLimit });
+const { worker, stop } = await startEmbeddingWorker({ concurrency, rpmLimit });
 console.error(`[embedding-worker] started  concurrency=${concurrency}  rpm_limit=${rpmLimit}`);
-// 优雅关闭：等当前 job 执行完再退出
+// 当前 job 执行完再退出
 for (const sig of ['SIGINT', 'SIGTERM']) {
     process.on(sig, async () => {
         console.error('[embedding-worker] shutting down…');
-        await worker.close();
+        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/config/env.js

@@ -3,98 +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_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 = {
-    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 使用 */
-    redisUrl: process.env.REDIS_URL ?? 'redis://127.0.0.1:6379',
+    get redisUrl() {
+        return process.env.REDIS_URL ?? 'redis://127.0.0.1:6379';
+    },
 };
 export function validateEnv() {
-    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/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;
+}

package/dist/db/schema.js

@@ -1,36 +1,51 @@
 /**
- * 动态生成数据库表结构 SQL，表名可通过环境变量配置
+ * 动态生成数据库表结构 SQL（PostgreSQL + pgvector），表名可通过环境变量配置
  */
 import { env } from '../config/env.js';
 import { DEFAULT_STATUS_ON_UPSERT } from '../config/symbolStatus.js';
+/** 确保 vector 扩展已启用 */
+export function getEnsureExtensionSQL() {
+    return `CREATE EXTENSION IF NOT EXISTS vector`;
+}
 /** 获取 symbols 表的建表 SQL */
 export function getSymbolsTableSQL() {
-    const tableName = env.mysqlSymbolsTable;
+    const tableName = env.symbolsTable;
     return `CREATE TABLE IF NOT EXISTS ${tableName} (
-  id INT PRIMARY KEY AUTO_INCREMENT,
-  name VARCHAR(255) NOT NULL,
-  type ENUM('component', 'function', 'type', 'class', 'interface', 'hook') NOT NULL,
-  category VARCHAR(255) NULL,
-  path TEXT NOT NULL,
-  description TEXT NULL,
-  content MEDIUMTEXT NULL,
-  meta JSON NULL,
-  usage_count INT NOT NULL DEFAULT 0,
-  embedding JSON NULL COMMENT 'Phase 5: L2-normalized vector from Python embedding service (e.g. 384-dim MiniLM)',
-  insert_user VARCHAR(255) NOT NULL DEFAULT 'LorryIsLuRui',
-  updated_user VARCHAR(255) NOT NULL DEFAULT 'LorryIsLuRui',
-  created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-  file_hash VARCHAR(64) NULL COMMENT '文件内容 SHA256',
-  semantic_hash VARCHAR(64) NULL COMMENT 'normalized AST 语义模板 SHA256',
-  status TINYINT NOT NULL DEFAULT ${DEFAULT_STATUS_ON_UPSERT} COMMENT '状态: 0-offline(删除), 1-pending(待处理), 2-online(可用), 3-error(错误)',
-  UNIQUE KEY uk_symbols_path_name (path(512), name(255)),
-  INDEX idx_file_hash (file_hash),
-  INDEX idx_semantic_hash (semantic_hash),
-  INDEX idx_status (status)
+  id            SERIAL PRIMARY KEY,
+  name          VARCHAR(255) NOT NULL,
+  type          VARCHAR(50) NOT NULL,
+  category      VARCHAR(255),
+  path          TEXT NOT NULL,
+  description   TEXT,
+  content       TEXT,
+  meta          JSONB,
+  usage_count   INT NOT NULL DEFAULT 0,
+  embedding     vector(384),
+  insert_user   VARCHAR(255) NOT NULL DEFAULT 'system',
+  updated_user  VARCHAR(255) NOT NULL DEFAULT 'system',
+  created_at    TIMESTAMP NOT NULL DEFAULT NOW(),
+  updated_at    TIMESTAMP NOT NULL DEFAULT NOW(),
+  file_hash     VARCHAR(64),
+  semantic_hash VARCHAR(64),
+  status        SMALLINT NOT NULL DEFAULT ${DEFAULT_STATUS_ON_UPSERT},
+  CONSTRAINT uk_${tableName}_path_name UNIQUE (path, name),
+  CONSTRAINT chk_${tableName}_type CHECK (type IN ('component','function','type','class','interface','hook'))
 )`;
 }
-/** 获取所有建表 SQL（可一次性执行） */
+/** 获取基础索引 SQL（不含 HNSW，HNSW 建议数据量 > 1000 后手动执行） */
+export function getSymbolsIndexSQLs() {
+    const t = env.symbolsTable;
+    return [
+        `CREATE INDEX IF NOT EXISTS idx_file_hash ON ${t}(file_hash)`,
+        `CREATE INDEX IF NOT EXISTS idx_semantic_hash ON ${t}(semantic_hash)`,
+        `CREATE INDEX IF NOT EXISTS idx_status ON ${t}(status)`,
+    ];
+}
+/** 获取所有建表 SQL（extension + table + indexes，可逐条执行） */
 export function getAllTableSQLs() {
-    return [getSymbolsTableSQL()];
+    return [
+        getEnsureExtensionSQL(),
+        getSymbolsTableSQL(),
+        ...getSymbolsIndexSQLs(),
+    ];
 }

package/dist/indexer/categoryClassifier.js

@@ -101,7 +101,7 @@ export async function resolveCategory(rows, vecs) {
     const pros = rows.map(async (r, i) => {
         const { name } = r;
         const ruleCategory = inferCategoryFromPath(r.path) || inferCategoryFromName(name);
-        console.error(`===from ruleCategory`, name, ruleCategory);
+        // console.error(`===from ruleCategory`, name, ruleCategory);
         if (ruleCategory) {
             return {
                 ...r,
@@ -110,7 +110,7 @@ export async function resolveCategory(rows, vecs) {
         }
         // TODO: 这里有问题，embedding是语义模板向量，categoryEmbeddingsCache是单个词的向量，相似度必然是<0.3
         const emd = categoryFromEmbedding(vecs[i]);
-        console.error(`===from categoryFromEmbedding`, name, emd);
+        // console.error(`===from categoryFromEmbedding`, name, emd);
         if (emd) {
             return {
                 ...r,
@@ -118,7 +118,7 @@ export async function resolveCategory(rows, vecs) {
             };
         }
         const cateLlm = await categoryFromLLM(r.content);
-        console.error(`===from categoryFromLLM`, name, cateLlm);
+        // console.error(`===from categoryFromLLM`, name, cateLlm);
         return {
             ...r,
             category: cateLlm,

package/dist/indexer/indexProject.js

@@ -182,7 +182,7 @@ function processDeclaration(exportName, decl, sf, projectRoot) {
     }
     return null;
 }
-const DEFAULT_IGNORE = [
+export const DEFAULT_IGNORE = [
     '**/node_modules/**',
     '**/dist/**',
     '**/.git/**',

package/dist/indexer/persistSymbols.js

@@ -1,10 +1,12 @@
 import { env } from '../config/env.js';
-import { getSymbolsTableSQL } from '../db/schema.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）。
- * @returns Promise 在提交成功时 resolve；任一行失败则整批回滚并抛出异常。
+ *   - 有值 → status 置为 online(2)
+ *   - null  → 新行写 pending(1)，已有行保持原 status
  */
 export async function upsertSymbols(pool, rows, embeddings) {
     if (rows.length === 0)
@@ -12,30 +14,48 @@ export async function upsertSymbols(pool, rows, embeddings) {
     if (embeddings && embeddings.length !== rows.length) {
         throw new Error('upsertSymbols: embeddings length must match rows');
     }
-    const actor = process.env.GITHUB_USERNAME?.trim() || 'LorryIsLuRui';
-    await pool.query(getSymbolsTableSQL()); // 确保表存在
-    const sql = `
-    INSERT INTO ${env.mysqlSymbolsTable} (name, type, category, path, description, content, meta, insert_user, updated_user, embedding, semantic_hash, file_hash)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON DUPLICATE KEY UPDATE
-      type = VALUES(type),
-      category = VALUES(category),
-      description = VALUES(description),
-      content = VALUES(content),
-      meta = VALUES(meta),
-      updated_user = VALUES(updated_user),
-      embedding = CASE WHEN VALUES(embedding) IS NOT NULL THEN VALUES(embedding) ELSE embedding END,
-      semantic_hash = VALUES(semantic_hash),
-      file_hash = VALUES(file_hash)
-  `;
-    const conn = await pool.getConnection();
+    const actor = process.env.GITHUB_USERNAME?.trim() || 'system';
+    const client = await pool.connect();
     try {
-        await conn.beginTransaction();
+        // 确保 extension + 表 + 基础索引存在
+        for (const sql of getAllTableSQLs()) {
+            await client.query(sql);
+        }
+        await client.query('BEGIN');
+        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)
+    VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8, $9, $10::vector, $11, $12, $13)
+    ON CONFLICT (path, name) DO UPDATE SET
+      type          = EXCLUDED.type,
+      category      = EXCLUDED.category,
+      description   = EXCLUDED.description,
+      content       = EXCLUDED.content,
+      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
+                      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
+                      END,
+      updated_at    = NOW()
+  `;
         for (let i = 0; i < rows.length; i++) {
             const r = rows[i];
             const emb = embeddings?.[i];
-            const embJson = emb !== undefined && emb !== null ? JSON.stringify(emb) : null;
-            await conn.query(sql, [
+            // 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,
@@ -45,18 +65,19 @@ export async function upsertSymbols(pool, rows, embeddings) {
                 JSON.stringify(r.meta),
                 actor,
                 actor,
-                embJson,
+                vecStr, // $10 → cast as vector, null 时写 NULL
                 r.semantic_hash,
                 r.file_hash,
+                statusVal,
             ]);
         }
-        await conn.commit();
+        await client.query('COMMIT');
     }
     catch (e) {
-        await conn.rollback();
+        await client.query('ROLLBACK');
         throw e;
     }
     finally {
-        conn.release();
+        client.release();
     }
 }