@lorrylurui/code-intelligence-mcp 1.1.14 → 1.2.0

package/dist/indexer/heuristics.js

@@ -1,13 +1,13 @@
 /**
  * JSX 检测、路径/selector 启发式、JSDoc 摘要、相对路径。
  */
-import { SyntaxKind } from "ts-morph";
+import { SyntaxKind } from 'ts-morph';
 /**
  * 判断源文件路径是否为 TSX（React JSX 语法所在扩展名）。
  * @returns `true` 表示按「可能出现 JSX」处理，用于与 `.ts` 区分组件启发式。
  */
 export function isTsxFile(filePath) {
-    return filePath.toLowerCase().endsWith(".tsx");
+    return filePath.toLowerCase().endsWith('.tsx');
 }
 /**
  * 在 AST 子树中是否出现 JSX 节点（元素、自闭合标签或 Fragment）。
@@ -27,30 +27,49 @@ export function hasJsxInNode(node) {
     return found;
 }
 /**
- * 从文件路径推断业务语义目录名（如 `.../components/form/Button.tsx` → `form`）。
- * @returns 命中 `components|features|...` 下一级目录名；无法推断时为 `null`，写入 DB 的 `category` 字段。
+ * 从文件路径推断业务语义目录名（如 `.../components/Button.tsx` → `components`）。
+ * @returns 命中 `components|features|...`
  */
 export function inferCategoryFromPath(filePath) {
-    const norm = filePath.replace(/\\/g, "/");
-    const parts = norm.split("/");
-    const markers = ["components", "features", "modules", "pages", "widgets", "hooks"];
-    for (let i = 0; i < parts.length; i++) {
-        const m = markers.indexOf(parts[i]);
-        if (m >= 0 && parts[i + 1]) {
-            return parts[i + 1];
+    const markers = [
+        'components',
+        'features',
+        'modules',
+        'pages',
+        'widgets',
+        'hooks',
+        'utils',
+        'services',
+        'selectors',
+        'types',
+        'apis',
+    ];
+    for (const m of markers) {
+        if (filePath.toLowerCase().includes(`/${m}/`)) {
+            return m;
         }
     }
     return null;
 }
 /**
- * 启发式判断导出是否更像状态选择器（selector）。
- * @returns `true` 时索引类型记为 `selector`，否则同文件下函数多为 `util`。
+ * 从命名推断业务语义类别（如 `useAuth` → `hook`，`formatDate` → `format`，`validateData` → `validation`）。
+ * @param name
+ * @returns 命中`hook | ...`
  */
-export function isSelectorLike(filePath, exportName) {
-    const lowerPath = filePath.toLowerCase();
-    if (lowerPath.includes("selector"))
-        return true;
-    if (/selector$/i.test(exportName))
+export function inferCategoryFromName(originName) {
+    const name = originName.toLowerCase();
+    if (name.startsWith('use'))
+        return 'hook';
+    if (name.includes('fetch'))
+        return 'network';
+    if (name.includes('format'))
+        return 'format';
+    if (name.includes('validate'))
+        return 'validation';
+    return null;
+}
+export function isHookLike(exportName) {
+    if (/use$/i.test(exportName))
         return true;
     return false;
 }
@@ -61,7 +80,7 @@ export function isSelectorLike(filePath, exportName) {
 export function getLeadingDocDescription(node) {
     const tryNode = (n) => {
         const jd = n.getJsDocs;
-        if (typeof jd !== "function")
+        if (typeof jd !== 'function')
             return null;
         const docs = jd.call(n);
         if (!docs?.length)
@@ -69,15 +88,15 @@ export function getLeadingDocDescription(node) {
         const t = docs[0].getDescription().trim();
         return t || null;
     };
-    return tryNode(node) ?? (node.getParent() ? tryNode(node.getParent()) : null);
+    return (tryNode(node) ?? (node.getParent() ? tryNode(node.getParent()) : null));
 }
 /**
  * 将绝对路径转为相对 `projectRoot` 的路径，作为库中 `symbols.path`（便于跨机器、展示）。
  * @returns 相对路径；若无法裁掉前缀则回退为原始绝对路径。
  */
 export function getRelativePathForDisplay(projectRoot, absolutePath) {
-    const r = projectRoot.replace(/\\/g, "/");
-    const a = absolutePath.replace(/\\/g, "/");
+    const r = projectRoot.replace(/\\/g, '/');
+    const a = absolutePath.replace(/\\/g, '/');
     if (a.startsWith(r)) {
         return a.slice(r.length + 1);
     }
@@ -92,5 +111,5 @@ export function snippetForNode(node, maxLen = 4000) {
     const raw = node.getText();
     if (raw.length <= maxLen)
         return raw;
-    return raw.slice(0, maxLen) + "\n/* ... truncated ... */";
+    return raw.slice(0, maxLen) + '\n/* ... truncated ... */';
 }

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,33 +132,52 @@ 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;
@@ -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

@@ -15,8 +15,8 @@ export async function upsertSymbols(pool, rows, embeddings) {
     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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    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),
@@ -24,7 +24,9 @@ export async function upsertSymbols(pool, rows, embeddings) {
       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
+      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();
     try {
@@ -44,6 +46,8 @@ export async function upsertSymbols(pool, rows, embeddings) {
                 actor,
                 actor,
                 embJson,
+                r.semantic_hash,
+                r.file_hash,
             ]);
         }
         await conn.commit();