@lorrylurui/code-intelligence-mcp 1.1.15 → 2.0.1

package/dist/indexer/indexProject.js

@@ -7,8 +7,10 @@ import { join, resolve } from 'node:path';
 import { Node, Project } from 'ts-morph';
 import { readFileSync, existsSync } from 'node:fs';
 import { extractInterfaceOrTypeMeta, extractMetaFromCallable, } from './extractMeta.js';
-import { getLeadingDocDescription, getRelativePathForDisplay, hasJsxInNode, inferCategoryFromPath, isSelectorLike, isTsxFile, snippetForNode, } from './heuristics.js';
+import { getLeadingDocDescription, getRelativePathForDisplay, hasJsxInNode, isHookLike, isTsxFile, } from './heuristics.js';
 import { parseJsFile } from './babelParser.js';
+import { computeFileHash, computeSemanticHash } from './tsAstNormalizer.js';
+const CALLERS_LIMIT = 20;
 /** 判断文件类型 */
 function isJsFile(filePath) {
     return filePath.endsWith('.js') || filePath.endsWith('.jsx');
@@ -59,39 +61,57 @@ function resolveExportName(exportName, decl) {
 function processDeclaration(exportName, decl, sf, projectRoot) {
     const filePath = sf.getFilePath();
     const relPath = getRelativePathForDisplay(projectRoot, filePath);
-    const category = inferCategoryFromPath(filePath);
     const name = resolveExportName(exportName, decl);
     const description = getLeadingDocDescription(decl) ?? null;
     if (Node.isInterfaceDeclaration(decl) ||
         Node.isTypeAliasDeclaration(decl)) {
         const meta = extractInterfaceOrTypeMeta(decl);
+        const type = Node.isInterfaceDeclaration(decl) ? 'interface' : 'type';
+        const [semantic_hash, stableStr] = computeSemanticHash({
+            name,
+            type,
+            description,
+            meta,
+            node: decl,
+        });
         return {
             name,
-            type: 'type',
-            category,
+            type,
+            category: '',
             path: relPath,
             description,
-            content: snippetForNode(decl),
+            content: stableStr,
             meta,
+            file_hash: computeFileHash(sf.getFullText()),
+            semantic_hash,
         };
     }
     if (Node.isFunctionDeclaration(decl)) {
         const jsx = isTsxFile(filePath) && hasJsxInNode(decl);
-        const type = jsx
-            ? 'component'
-            : isSelectorLike(filePath, name)
-                ? 'selector'
-                : 'util';
+        const type = isHookLike(name)
+            ? 'hook'
+            : jsx
+                ? 'component'
+                : 'function';
         const raw = extractMetaFromCallable(decl);
         const meta = mergeCallableMeta(type, raw);
+        const [semantic_hash, stableStr] = computeSemanticHash({
+            name,
+            type,
+            description,
+            meta,
+            node: decl,
+        });
         return {
             name,
             type,
-            category,
+            category: '',
             path: relPath,
             description,
-            content: snippetForNode(decl),
+            content: stableStr,
             meta,
+            semantic_hash,
+            file_hash: computeFileHash(sf.getFullText()),
         };
     }
     if (Node.isVariableDeclaration(decl)) {
@@ -112,38 +132,57 @@ function processDeclaration(exportName, decl, sf, projectRoot) {
         if (!callable)
             return null;
         const jsx = isTsxFile(filePath) && hasJsxInNode(callable);
-        const type = jsx
-            ? 'component'
-            : isSelectorLike(filePath, name)
-                ? 'selector'
-                : 'util';
+        const type = isHookLike(name)
+            ? 'hook'
+            : jsx
+                ? 'component'
+                : 'function';
         const raw = extractMetaFromCallable(callable);
         const meta = mergeCallableMeta(type, raw);
+        const [semantic_hash, stableStr] = computeSemanticHash({
+            name,
+            type,
+            description,
+            meta,
+            node: callable,
+        });
         return {
             name,
             type,
-            category,
+            category: '',
             path: relPath,
             description,
-            content: snippetForNode(callable),
+            content: stableStr,
             meta,
+            semantic_hash,
+            file_hash: computeFileHash(sf.getFullText()),
         };
     }
     if (Node.isClassDeclaration(decl)) {
         // 轻量：仅将 class 记为 util（后续可扩展为带 JSX 的组件类）
+        const type = 'class';
+        const [semantic_hash, stableStr] = computeSemanticHash({
+            name,
+            type,
+            description,
+            meta: { kind: type },
+            node: decl,
+        });
         return {
             name,
-            type: 'util',
-            category,
+            type,
+            category: '',
             path: relPath,
             description,
-            content: snippetForNode(decl),
-            meta: { kind: 'class' },
+            content: stableStr,
+            meta: { kind: type },
+            semantic_hash,
+            file_hash: computeFileHash(sf.getFullText()),
         };
     }
     return null;
 }
-const DEFAULT_IGNORE = [
+export const DEFAULT_IGNORE = [
     '**/node_modules/**',
     '**/dist/**',
     '**/.git/**',
@@ -197,6 +236,23 @@ export async function indexProject(opts) {
         for (const sf of project.getSourceFiles()) {
             const relPath = getRelativePathForDisplay(projectRoot, sf.getFilePath());
             const exported = sf.getExportedDeclarations();
+            // 只检索export的代码，减少噪音
+            // 如果要检索未export的，需要考虑
+            /**
+             *  类型一：真正的内部实现，不应该复用
+                function _buildSqlFragment() {}     // 和模块强耦合，外部用不了
+                const __validateInternal = () => {} // 私有约定（下划线前缀）
+                → 索引了也没用，反而是噪音
+
+                类型二：工具函数，只是作者忘了 export / 懒得 export
+                function debounce(fn, ms) {}        // 通用，完全可以复用
+                function formatCurrency(n) {}       // 通用，其他地方也需要
+                → 索引有价值，还能反向提示"这个应该被 export"
+
+                类型三：文件内共享但跨文件无意义
+                function getLocalConfig() {}        // 依赖闭包变量，移出去就坏了
+                → 索引意义不大
+             */
             for (const [exportName, decls] of exported) {
                 for (const decl of decls) {
                     const row = processDeclaration(exportName, decl, sf, projectRoot);
@@ -205,7 +261,11 @@ export async function indexProject(opts) {
                         // 建立符号映射
                         const key = `${row.name}|${row.path}`;
                         if (!symbolMap.has(key)) {
-                            symbolMap.set(key, { name: row.name, path: row.path, exports: new Set() });
+                            symbolMap.set(key, {
+                                name: row.name,
+                                path: row.path,
+                                exports: new Set(),
+                            });
                         }
                         symbolMap.get(key).exports.add(exportName);
                     }
@@ -223,7 +283,11 @@ export async function indexProject(opts) {
             for (const row of rows) {
                 const key = `${row.name}|${row.path}`;
                 if (!symbolMap.has(key)) {
-                    symbolMap.set(key, { name: row.name, path: row.path, exports: new Set() });
+                    symbolMap.set(key, {
+                        name: row.name,
+                        path: row.path,
+                        exports: new Set(),
+                    });
                 }
                 symbolMap.get(key).exports.add(row.name);
             }
@@ -248,7 +312,6 @@ export async function indexProject(opts) {
  * 分析调用关系，填充每个符号的 meta.callers 和 meta.callees
  */
 function analyzeRelations(project, symbolMap, projectRoot, rows) {
-    // 构造快速查找：exportName -> [ {name, path} ]
     const exportToSymbol = new Map();
     for (const [key, value] of symbolMap) {
         for (const exp of value.exports) {
@@ -257,52 +320,73 @@ function analyzeRelations(project, symbolMap, projectRoot, rows) {
             exportToSymbol.set(exp, list);
         }
     }
-    // 收集所有 callers 和 callees
-    const callersMap = new Map(); // key = "name|path" -> set of callers
-    const calleesMap = new Map(); // key = "name|path" -> set of callees
+    const callersMap = new Map();
+    const calleesMap = new Map();
     for (const sf of project.getSourceFiles()) {
         const filePath = sf.getFilePath();
         const relPath = getRelativePathForDisplay(projectRoot, filePath);
-        // 获取当前文件导出的符号
         const exported = sf.getExportedDeclarations();
-        const fileExportNames = new Set();
-        for (const [name, decls] of exported) {
-            fileExportNames.add(name);
-        }
-        // 遍历 AST 查找调用
         sf.forEachDescendant((node) => {
-            // 1. 函数调用
+            // 函数调用
             if (Node.isCallExpression(node)) {
                 const expr = node.getExpression();
                 const name = Node.isIdentifier(expr) ? expr.getText() : null;
                 if (name && exportToSymbol.has(name)) {
                     const targets = exportToSymbol.get(name);
-                    // 当前文件是谁在调用
                     for (const [expName, decls] of exported) {
-                        for (const decl of decls) {
+                        for (const _decl of decls) {
                             const callerKey = `${expName}|${relPath}`;
                             for (const target of targets) {
                                 // callees: 我调用了谁
-                                const calleeSet = calleesMap.get(callerKey) || new Set();
-                                calleeSet.add({ name: target.name, path: target.path });
+                                const calleeSet = calleesMap.get(callerKey) ||
+                                    new Set();
+                                calleeSet.add(`${target.name}|${target.path}`); // ✅ 字符串天然去重
                                 calleesMap.set(callerKey, calleeSet);
-                                // callers: 谁调用了我
                                 const callerSet = callersMap.get(`${target.name}|${target.path}`) || new Set();
-                                callerSet.add({ name: expName, path: relPath });
+                                callerSet.add(`${expName}|${relPath}`);
                                 callersMap.set(`${target.name}|${target.path}`, callerSet);
                             }
                         }
                     }
                 }
             }
-            // 2. Import 导入
+            // Import 导入关系（含 import type）
             if (Node.isImportDeclaration(node)) {
-                const moduleSpec = node.getModuleSpecifier().getText();
-                // 简单处理：只处理从 ./ 或 ../ 开始的相对导入
-                if (moduleSpec.startsWith("'.") || moduleSpec.startsWith('".')) {
-                    const importPath = moduleSpec.slice(1, -1); // 去掉引号
-                    // 尝试匹配已索引的符号
-                    // 这里简化处理，暂不展开
+                // 1. 解析被导入文件的路径
+                const importedSf = node.getModuleSpecifierSourceFile();
+                if (!importedSf)
+                    return; // 无法解析（第三方包等）跳过
+                const importedRelPath = getRelativePathForDisplay(projectRoot, importedSf.getFilePath());
+                // 2. 收集本条 import 引入了哪些具名符号
+                const namedBindings = node.getNamedImports(); // { SymbolRepository }
+                const defaultImport = node.getDefaultImport(); // import Foo from ...
+                const importedNames = [
+                    ...namedBindings.map((n) => n.getName()),
+                    ...(defaultImport ? [defaultImport.getText()] : []),
+                ];
+                if (importedNames.length === 0)
+                    return;
+                // 3. 当前文件的所有导出符号作为 caller
+                for (const [expName] of exported) {
+                    const callerKey = `${expName}|${relPath}`;
+                    for (const importedName of importedNames) {
+                        // 4. 在 symbolMap 里找到被导入符号对应的 row
+                        //    key 格式：`name|path`，name 是 resolveExportName 后的真实名
+                        //    exportToSymbol 里存的是 exportName（可能是 'default'），
+                        //    所以同时按 importedName 和路径在 symbolMap 里直接查
+                        const targetKey = `${importedName}|${importedRelPath}`;
+                        const target = symbolMap.get(targetKey);
+                        if (!target)
+                            continue;
+                        // callee：当前文件的导出符号引用了 target
+                        const calleeSet = calleesMap.get(callerKey) || new Set();
+                        calleeSet.add(`${target.name}|${target.path}`);
+                        calleesMap.set(callerKey, calleeSet);
+                        const callerRefKey = `${target.name}|${target.path}`;
+                        const callerSet = callersMap.get(callerRefKey) || new Set();
+                        callerSet.add(`${expName}|${relPath}`);
+                        callersMap.set(callerRefKey, callerSet);
+                    }
                 }
             }
         });
@@ -312,13 +396,19 @@ function analyzeRelations(project, symbolMap, projectRoot, rows) {
         const key = `${row.name}|${row.path}`;
         const callers = callersMap.get(key);
         const callees = calleesMap.get(key);
-        if (callers && callers.size > 0) {
-            row.meta = row.meta || {};
-            row.meta.callers = [...callers].slice(0, 20); // 限制数量
+        if (callers?.size) {
+            row.meta.callers = [...callers].slice(0, CALLERS_LIMIT).map((s) => {
+                // ✅ 反序列化回对象
+                const [name, ...pathParts] = s.split('|');
+                return { name, path: pathParts.join('|') };
+            });
         }
-        if (callees && callees.size > 0) {
-            row.meta = row.meta || {};
-            row.meta.callees = [...callees].slice(0, 20);
+        if (callees?.size) {
+            row.meta.callees = [...callees].slice(0, CALLERS_LIMIT).map((s) => {
+                const [name, ...pathParts] = s.split('|');
+                // path:为了防止路径里万一含有 | 字符时截断错误。
+                return { name, path: pathParts.join('|') };
+            });
         }
     }
     console.error(`[analyzeRelations] processed ${rows.length} symbols`);

package/dist/indexer/jsAstNormalizer.js

@@ -0,0 +1,201 @@
+/**
+ * astNormalizerJs.ts
+ *
+ * JS/JSX 文件的语义签名提取，对应 ts-morph 版的 extractNormalizedSignature。
+ * Babel AST 没有类型信息，通过以下策略补偿：
+ *   1. 有 JSDoc → 从 @param / @returns 提取类型
+ *   2. 无 JSDoc → 参数类型标记为 $unknown，签名仍可区分结构形态
+ *
+ * 与 TS 版行为对齐：
+ *   - 参数名   → 丢弃，替换为 $p
+ *   - 函数体   → 替换为 {}
+ *   - 默认值存在性保留（=$default），默认值内容丢弃
+ *   - rest 参数保留 ... 前缀
+ *   - 解构参数保留结构形态（{} / []），无法展开内部字段
+ */
+import { createHash } from 'node:crypto';
+import * as t from '@babel/types';
+// ─────────────────────────────────────────────
+// JSDoc 类型提取
+// ─────────────────────────────────────────────
+function getJSDoc(node) {
+    const comments = node.leadingComments;
+    if (!comments || comments.length === 0)
+        return null;
+    const jsdoc = comments.find((c) => c.value.includes('@param') || c.value.includes('@returns'));
+    return jsdoc ? jsdoc.value : null;
+}
+function parseJSDoc(jsdoc) {
+    const params = {};
+    let returnType;
+    const paramRegex = /@param\s+\{([^}]+)\}\s+(\w+)/g;
+    const returnRegex = /@returns?\s+\{([^}]+)\}/;
+    let match;
+    while ((match = paramRegex.exec(jsdoc))) {
+        const [, type, name] = match;
+        params[name] = normalizeType(type);
+    }
+    const returnMatch = jsdoc.match(returnRegex);
+    if (returnMatch) {
+        returnType = normalizeType(returnMatch[1]);
+    }
+    return { params, returnType };
+}
+function normalizeType(type) {
+    type = type.trim().toLowerCase();
+    if (type.includes('string'))
+        return 'string';
+    if (type.includes('number'))
+        return 'number';
+    if (type.includes('boolean'))
+        return 'boolean';
+    if (type.includes('array'))
+        return 'array';
+    if (type.includes('object'))
+        return 'object';
+    if (type.includes('promise')) {
+        const inner = type.match(/promise<(.+)>/);
+        return inner ? `Promise<${normalizeType(inner[1])}>` : 'Promise';
+    }
+    return 'unknown';
+}
+function normalizeParam(param, fallbackName, jsdoc) {
+    if (param.type === 'Identifier') {
+        const name = param.name;
+        const type = jsdoc?.params[name] ?? 'unknown';
+        return `${name}:${type}`;
+    }
+    if (param.type === 'ObjectPattern') {
+        const props = param.properties.map((p) => {
+            if (p.key?.name) {
+                const name = p.key.name;
+                const type = jsdoc?.params[name] ?? 'unknown';
+                return `${name}:${type}`;
+            }
+            return 'unknown';
+        });
+        return `{${props.sort().join(';')}}`;
+    }
+    return `${fallbackName}:unknown`;
+}
+function inferTypeFromExpression(expr) {
+    if (t.isStringLiteral(expr))
+        return 'string';
+    if (t.isNumericLiteral(expr))
+        return 'number';
+    if (t.isBooleanLiteral(expr))
+        return 'boolean';
+    if (t.isArrayExpression(expr))
+        return 'array';
+    if (t.isObjectExpression(expr))
+        return 'object';
+    return 'unknown';
+}
+function inferReturnType(node) {
+    if (!node.body)
+        return 'unknown';
+    if (t.isBlockStatement(node.body)) {
+        const returnStmt = node.body.body.find(t.isReturnStatement);
+        if (returnStmt && returnStmt.argument) {
+            return inferTypeFromExpression(returnStmt.argument);
+        }
+    }
+    if (!t.isBlockStatement(node.body)) {
+        return inferTypeFromExpression(node.body);
+    }
+    return 'unknown';
+}
+function normalizeFunction(node) {
+    const jsdocText = getJSDoc(node);
+    const jsdoc = jsdocText ? parseJSDoc(jsdocText) : undefined;
+    const params = node.params.map((p, i) => normalizeParam(p, `$p${i}`, jsdoc));
+    const returnType = jsdoc?.returnType ?? inferReturnType(node);
+    return `fn(${params.join(',')})=>${returnType}`;
+}
+function normalizeArrowFunction(node) {
+    const jsdocText = getJSDoc(node);
+    const jsdoc = jsdocText ? parseJSDoc(jsdocText) : undefined;
+    const params = node.params.map((p, i) => normalizeParam(p, `$p${i}`, jsdoc));
+    // const params = node.params.map((p, i) => normalizeParam(p, `$p${i}`));
+    const returnType = jsdoc?.returnType ?? inferReturnType(node);
+    return `fn(${params.join(',')})=>${returnType}`;
+}
+function normalizeClass(node) {
+    const methods = node.body.body
+        .filter(t.isClassMethod)
+        .map((m) => {
+        const name = t.isIdentifier(m.key) ? m.key.name : 'unknown';
+        return `${name}():unknown`;
+    })
+        .sort();
+    return `class{${methods.join(';')}}`;
+}
+function traverseNode(node, cb) {
+    cb(node);
+    for (const key in node) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+            value.forEach((v) => {
+                if (v && typeof v.type === 'string') {
+                    traverseNode(v, cb);
+                }
+            });
+        }
+        else if (value && typeof value.type === 'string') {
+            traverseNode(value, cb);
+        }
+    }
+}
+export function inferBehaviorFromJS(node) {
+    const behavior = [];
+    // 遍历 AST
+    traverseNode(node, (n) => {
+        // fetch / axios
+        if (t.isCallExpression(n) && t.isIdentifier(n.callee)) {
+            const name = n.callee.name.toLowerCase();
+            if (name.includes('fetch') || name.includes('axios')) {
+                behavior.push('performs network request');
+            }
+            if (name.includes('settimeout')) {
+                behavior.push('uses timer');
+            }
+        }
+        // localStorage
+        if (t.isMemberExpression(n) &&
+            t.isIdentifier(n.object) &&
+            n.object.name === 'localStorage') {
+            behavior.push('uses local storage');
+        }
+    });
+    return Array.from(new Set(behavior));
+}
+export function extractNormalizedSignatureJS(node) {
+    if (t.isFunctionDeclaration(node) || t.isFunctionExpression(node)) {
+        return normalizeFunction(node);
+    }
+    if (t.isArrowFunctionExpression(node)) {
+        return normalizeArrowFunction(node);
+    }
+    if (t.isClassDeclaration(node)) {
+        return normalizeClass(node);
+    }
+    return '';
+}
+export function computeSemanticHashJs(row) {
+    const signature = extractNormalizedSignatureJS(row.node);
+    const behavior = inferBehaviorFromJS(row.node);
+    const meta = row.meta || {};
+    const stable = {
+        name: row.name,
+        type: row.type,
+        description: row.description ?? null,
+        signature,
+        behavior: behavior.sort(),
+        sideEffects: [
+            ...(meta.sideEffects ?? []),
+        ].sort(),
+        hooks: [...(meta.hooks ?? [])].sort(),
+    };
+    const stableStr = JSON.stringify(stable);
+    return [createHash('sha256').update(stableStr).digest('hex'), stableStr];
+}

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,28 +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)
-    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
-  `;
-    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,
@@ -43,16 +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();
     }
 }