@lorrylurui/code-intelligence-mcp 1.1.14 → 1.2.0

package/dist/indexer/tsAstNormalizer.js

@@ -0,0 +1,363 @@
+/**
+ * tsAstNormalizer.ts
+ * 对 ts-morph Node 做语义级标准化，生成 semantic_hash。
+ *
+ * 去掉：参数名、泛型参数名、函数体实现、空白格式、字面量值
+ * 保留：参数类型结构、返回类型、sideEffects、hooks
+ */
+import { createHash } from 'node:crypto';
+import { Node, SyntaxKind } from 'ts-morph';
+// ─────────────────────────────────────────────
+// 内置类型白名单：不替换为 $T
+// ─────────────────────────────────────────────
+const BUILTIN_TYPES = new Set([
+    'string',
+    'number',
+    'boolean',
+    'void',
+    'null',
+    'undefined',
+    'never',
+    'unknown',
+    'any',
+    'object',
+    'symbol',
+    'bigint',
+    'Promise',
+    'Array',
+    'Record',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'Partial',
+    'Required',
+    'Readonly',
+    'Pick',
+    'Omit',
+    'Exclude',
+    'Extract',
+    'NonNullable',
+    'ReturnType',
+    'InstanceType',
+    'React',
+    'ReactNode',
+    'ReactElement',
+    'FC',
+    'MouseEvent',
+    'KeyboardEvent',
+    'ChangeEvent',
+    'HTMLElement',
+    'HTMLDivElement',
+    'HTMLInputElement',
+    'CSSProperties',
+    'RefObject',
+    'MutableRefObject',
+]);
+function normalizeTypeName(name) {
+    if (BUILTIN_TYPES.has(name))
+        return name;
+    if (/^T[A-Z]/.test(name) || (name.length === 1 && /[A-Z]/.test(name)))
+        return '$T';
+    return name;
+}
+function normalizeTypeString(typeStr) {
+    return typeStr
+        .replace(/\b([A-Z][A-Za-z0-9]*)\b/g, (match) => normalizeTypeName(match))
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// 从类型节点提取属性列表（递归处理嵌套对象）
+function extractPropertiesFromType(typeNode) {
+    const props = [];
+    // 处理 { a: string, b: number } 这种字面量对象类型
+    if (Node.isTypeLiteral(typeNode)) {
+        for (const member of typeNode.getMembers()) {
+            if (Node.isPropertySignature(member)) {
+                const name = member.getName();
+                const typeNode = member.getTypeNode();
+                const typeStr = typeNode
+                    ? normalizeTypeString(typeNode.getText())
+                    : '$unknown';
+                const optional = member.hasQuestionToken() ? '?' : '';
+                props.push(`${name}${optional}:${typeStr}`);
+            }
+        }
+    }
+    // 处理交叉类型 A & B
+    if (Node.isIntersectionTypeNode(typeNode)) {
+        for (const member of typeNode.getChildren()) {
+            if (Node.isTypeLiteral(member)) {
+                props.push(...extractPropertiesFromType(member));
+            }
+        }
+    }
+    return props;
+}
+// ─────────────────────────────────────────────
+// normalizeNode：递归遍历 AST，输出标准化字符串
+// ─────────────────────────────────────────────
+export function normalizeNode(node) {
+    const paramNames = new Map();
+    let paramIdx = 0;
+    function allocParam(name) {
+        if (!paramNames.has(name))
+            paramNames.set(name, `$p${paramIdx++}`);
+        return paramNames.get(name);
+    }
+    function visit(n) {
+        const kind = n.getKind();
+        // 函数体 → {}（不关心实现）
+        if (kind === SyntaxKind.Block)
+            return '{}';
+        // 参数：只保留类型，去参数名
+        if (Node.isParameterDeclaration(n)) {
+            const nameNode = n.getNameNode();
+            const typeNode = n.getTypeNode();
+            const typeStr = typeNode
+                ? normalizeTypeString(typeNode.getText())
+                : '$unknown';
+            const prefix = n.isRestParameter() ? '...' : '';
+            const suffix = n.hasInitializer() ? '=$default' : '';
+            // 解构参数：{ userId, options }: Config → {}:Config
+            if (Node.isObjectBindingPattern(nameNode) ||
+                Node.isArrayBindingPattern(nameNode)) {
+                return `${prefix}{}:${typeStr}${suffix}`;
+            }
+            allocParam(n.getName());
+            return `${prefix}$p:${typeStr}${suffix}`;
+        }
+        // 泛型参数：T / TData → $T
+        if (Node.isTypeParameterDeclaration(n)) {
+            const constraint = n.getConstraint();
+            return `$T${constraint ? ` extends ${normalizeTypeString(constraint.getText())}` : ''}`;
+        }
+        // 类型引用：标准化名称
+        if (Node.isTypeReference(n))
+            return normalizeTypeString(n.getText());
+        // JSX：只记录存在
+        if (Node.isJsxElement(n) || Node.isJsxSelfClosingElement(n))
+            return '<JSX/>';
+        // 字面量 → 占位符
+        if (kind === SyntaxKind.StringLiteral)
+            return '"$s"';
+        if (kind === SyntaxKind.NumericLiteral ||
+            kind === SyntaxKind.BigIntLiteral)
+            return '$n';
+        if (kind === SyntaxKind.TrueKeyword || kind === SyntaxKind.FalseKeyword)
+            return '$b';
+        const children = n.getChildren();
+        if (children.length === 0)
+            return n.getText();
+        return children.map(visit).join('');
+    }
+    return visit(node).replace(/\s+/g, ' ').trim();
+}
+function normalizeParameter(param, index) {
+    const typeNode = param.getTypeNode();
+    const typeStr = typeNode
+        ? normalizeTypeWithStructure(typeNode)
+        : '$unknown';
+    const prefix = param.isRestParameter() ? '...' : '';
+    const suffix = param.hasInitializer() ? '=$default' : '';
+    const nameNode = param.getNameNode();
+    // 解构参数：{ id, opts }: Config → { id: $d, opts: $d }:{id:xx, opts:xx}
+    if (Node.isObjectBindingPattern(nameNode) ||
+        Node.isArrayBindingPattern(nameNode)) {
+        const elements = nameNode.getElements();
+        const destrProps = [];
+        for (const el of elements) {
+            if (Node.isOmittedExpression(el))
+                continue;
+            const elAny = el;
+            const name = elAny.getName?.() ?? 'unknown';
+            // 检查是否有问号（可选属性）
+            const hasQ = el
+                .getChildren()
+                .some((c) => c.getKind() === SyntaxKind.QuestionToken);
+            // 检查是否有默认值，有则使用默认值的类型
+            const initializer = el.getInitializer();
+            let valueType;
+            if (initializer) {
+                // 用初始值表达式的类型
+                valueType = normalizeTypeWithStructure(initializer);
+            }
+            else {
+                valueType = '$d';
+            }
+            destrProps.push(`${name}${hasQ ? '?' : ''}:${valueType}`);
+        }
+        // 排序 key, 防止仅仅因为顺序不一样导致hash不稳定
+        destrProps.sort();
+        return `${prefix}{${destrProps.join(',')}}:${typeStr}${suffix}`;
+    }
+    return `${prefix}$p${index}:${typeStr}${suffix}`;
+}
+function normalizeTypeWithStructure(typeNode) {
+    // 如果是类型字面量 { name: string, age: number }
+    if (Node.isTypeLiteral(typeNode)) {
+        const props = typeNode
+            .getMembers()
+            .filter(Node.isPropertySignature)
+            .map((prop) => {
+            const propTypeNode = prop.getTypeNode();
+            const propType = propTypeNode
+                ? normalizeTypeWithStructure(propTypeNode)
+                : '$unknown';
+            return `${prop.getName()}${prop.hasQuestionToken() ? '?' : ''}:${propType}`;
+        });
+        return `{${props.join(',')}}`;
+    }
+    // 如果是类型引用（e.g. Param, Array<string>, Promise<User>）
+    if (Node.isTypeReference(typeNode)) {
+        const typeName = typeNode.getTypeName().getText();
+        // 优先处理泛型参数（不管是否在白名单中）
+        const typeArgs = typeNode.getTypeArguments();
+        if (typeArgs.length > 0) {
+            const normalizedArgs = typeArgs.map((arg) => normalizeTypeWithStructure(arg));
+            return `${typeName}<${normalizedArgs.join(',')}>`;
+        }
+        // 没有泛型参数时，检查是否是基础类型
+        if (BUILTIN_TYPES.has(typeName)) {
+            return typeName;
+        }
+        // 无泛型的类型引用，尝试解析实际类型
+        try {
+            const type = typeNode.getType();
+            const symbol = type.getSymbol();
+            if (symbol) {
+                const declarations = symbol.getDeclarations();
+                if (declarations.length > 0) {
+                    const decl = declarations[0];
+                    // 如果是接口声明，递归处理
+                    if (Node.isInterfaceDeclaration(decl)) {
+                        const props = decl.getProperties().map((prop) => {
+                            const propTypeNode = prop.getTypeNode();
+                            const propType = propTypeNode
+                                ? normalizeTypeWithStructure(propTypeNode)
+                                : '$unknown';
+                            return `${prop.getName()}${prop.hasQuestionToken() ? '?' : ''}:${propType}`;
+                        });
+                        return `{${props.join(',')}}`;
+                    }
+                    // 如果是类型别名
+                    if (Node.isTypeAliasDeclaration(decl)) {
+                        const aliasedType = decl.getTypeNode();
+                        if (aliasedType) {
+                            return normalizeTypeWithStructure(aliasedType);
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // 解析失败，回退到类型名
+        }
+        return typeName;
+    }
+    // 其他情况（联合类型、交叉类型、基础类型等）
+    return normalizeTypeString(typeNode.getText());
+}
+export function extractNormalizedSignature(node) {
+    // 函数声明 / 箭头函数 / 函数表达式
+    if (Node.isFunctionDeclaration(node) ||
+        Node.isArrowFunction(node) ||
+        Node.isFunctionExpression(node)) {
+        const typeParams = Node.isFunctionDeclaration(node)
+            ? node.getTypeParameters().map((tp) => normalizeNode(tp))
+            : [];
+        const params = node
+            .getParameters()
+            .sort()
+            .map((p, i) => normalizeParameter(p, i));
+        const retNode = node.getReturnTypeNode?.();
+        const returnType = retNode
+            ? normalizeTypeString(retNode.getText())
+            : '$inferred';
+        const tpStr = typeParams.length ? `<${typeParams.join(',')}>` : '';
+        return `fn${tpStr}(${params.join(',')})=>${returnType}`;
+    }
+    // 变量声明（const foo = () => {}）
+    if (Node.isVariableDeclaration(node)) {
+        const init = node.getInitializer();
+        if (init &&
+            (Node.isArrowFunction(init) || Node.isFunctionExpression(init))) {
+            return extractNormalizedSignature(init);
+        }
+        return normalizeNode(node);
+    }
+    // interface：提取所有属性，模板化名称
+    if (Node.isInterfaceDeclaration(node)) {
+        const props = node.getProperties().map((prop) => {
+            const typeNode = prop.getTypeNode();
+            const typeStr = typeNode
+                ? normalizeTypeString(typeNode.getText())
+                : '$unknown';
+            const optional = prop.hasQuestionToken() ? '?' : '';
+            return `${prop.getName()}${optional}:${typeStr}`;
+        });
+        const extendsClause = node.getExtends();
+        const extendsStr = extendsClause.length
+            ? ` extends ${extendsClause.map((e) => normalizeTypeString(e.getText())).join(',')}`
+            : '';
+        return `interface{${props.sort().join(';')}}${extendsStr}`;
+    }
+    // type alias（对象类型）：提取结构化信息
+    if (Node.isTypeAliasDeclaration(node)) {
+        const typeNode = node.getTypeNode();
+        if (typeNode) {
+            // 处理 type Foo = { ... }
+            const props = extractPropertiesFromType(typeNode);
+            if (props.length > 0) {
+                return `type{${props.sort().join(';')}}`;
+            }
+        }
+        return normalizeNode(node);
+    }
+    // class：只取方法签名列表
+    if (Node.isClassDeclaration(node)) {
+        const methods = node
+            .getMethods()
+            .sort()
+            .map((m) => {
+            const params = m
+                .getParameters()
+                .sort()
+                .map((p) => normalizeNode(p));
+            const retNode = m.getReturnTypeNode();
+            const ret = retNode
+                ? normalizeTypeString(retNode.getText())
+                : '$inferred';
+            return `${m.getName()}(${params.sort().join(',')})=>${ret}`;
+        });
+        return `class{${methods.join(';')}}`;
+    }
+    return normalizeNode(node);
+}
+// ─────────────────────────────────────────────
+// computeSemanticHash
+// 纳入：标准化签名 + name + type + description + sideEffects + hooks
+// 排除：参数名、实现、格式、callers/callees
+// ─────────────────────────────────────────────
+export function computeSemanticHash(row) {
+    const node = row.node || null;
+    const meta = row.meta || {};
+    const stable = {
+        name: row.name,
+        type: row.type,
+        description: row.description ?? null,
+        signature: node ? extractNormalizedSignature(node) : '',
+        sideEffects: [
+            ...(meta.sideEffects ?? []),
+        ].sort(),
+        hooks: [...(meta.hooks ?? [])].sort(),
+    };
+    const stableStr = JSON.stringify(stable);
+    return [createHash('sha256').update(stableStr).digest('hex'), stableStr];
+}
+// ─────────────────────────────────────────────
+// computeFileHash：对文件原始内容
+// ─────────────────────────────────────────────
+export function computeFileHash(fileContent) {
+    return createHash('sha256').update(fileContent).digest('hex');
+}

package/dist/prompts/reusableCodeAdvisorPrompt.js

@@ -16,7 +16,9 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
    - **API 是否简单**、入参是否合适
    - **依赖与副作用**风险
    - **复用安全性**（稳定性、耦合度、是否便于扩展）
-6. 给出**唯一首选**推荐，并说明理由
+6. 给出**唯一首选**推荐，并说明理由，同时使用 **AskUserQuestion **工具,提供两个选项: 
+   - 采纳推荐
+   - 取消
 
 ## 回复结构
 
@@ -28,6 +30,7 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 - **理由：** 1～3 条要点
 - **其他候选：** 简要列出及取舍（同步标注副作用）
 - **用法提示：** 结合用户场景的最小集成说明
+- **是否采纳：** 展示两个选项: 选项1.采纳推荐 选项2.取消。等待用户确认
 
 ## 约束
 
@@ -37,8 +40,8 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 
 ## 使用反馈
 
-当最终采纳了某个推荐代码块后，必须调用 inc_usage 工具记录采纳行为：
-“请调用 inc_usage({ symbolId: <选中的代码块 id> })”
+当选择‘采纳推荐’必须调用 inc_usage 工具记录采纳行为，调用格式如下：
+“inc_usage({ symbolId: <选中的代码块 id> })”
 其中 symbolId 从 search_symbols 或 search_by_structure 返回结果的 id 字段获取。这条记录会用于后续排序优化。
 
 ## 更多示例

package/dist/repositories/symbolRepository.js

@@ -2,6 +2,9 @@ import { env } from '../config/env.js';
 import { getMySqlPool } from '../db/mysql.js';
 import { createEmbeddingClient } from '../services/embeddingClient.js';
 import { cosineSimilarity } from '../services/vectorMath.js';
+import { SEARCHABLE_STATUS } from '../config/symbolStatus.js';
+const THREADHOLD_SIMILARITY_BEFORE_RANKED = 0.5;
+const TOP_K_FOR_RANKING = 100; // 进入复杂排序的候选数上限（语义相似度初筛后保留的结果数，过大会增加排序成本）
 const inMemorySymbols = [
     {
         id: 1,
@@ -18,7 +21,7 @@ const inMemorySymbols = [
     {
         id: 2,
         name: 'formatDate',
-        type: 'util',
+        type: 'function',
         category: 'date',
         path: 'src/utils/date.ts',
         description: 'Format date to YYYY-MM-DD',
@@ -99,6 +102,7 @@ export class SymbolRepository {
       SELECT id, name, type, category, path, description, content, CAST(meta AS CHAR) AS meta, usage_count, created_at
       FROM ${env.mysqlSymbolsTable}
       WHERE (name LIKE ? OR description LIKE ?)
+        AND status = ${SEARCHABLE_STATUS}
     `;
         params.push(`%${query}%`);
         if (type) {
@@ -110,8 +114,14 @@ export class SymbolRepository {
         return rows.map((r) => mapRow(r));
     }
     /**
-     * Phase 5：对自然语言查询做向量检索，返回代码块与余弦相似度（已去掉 embedding 列便于 JSON 输出）。
-     */
+   * Phase 5：对自然语言查询做向量检索，启用分桶采样策略，返回代码
+  块与余弦相似度。
+   * 分桶策略：
+   * - 第一层：按 category 占比计算每个分类应采样条数（保底10条）
+   * - 第二层：每个 path 子桶内乱序后采样 Math.max(5,
+  floor(catLimit / pathCount)) 条
+  * 最终选择topK，进入排序
+   */
     async searchSemanticHits(query, opts) {
         if (!env.embeddingServiceUrl) {
             throw new Error('语义检索需配置 EMBEDDING_SERVICE_URL 并启动嵌入服务');
@@ -120,38 +130,102 @@ export class SymbolRepository {
             return [];
         }
         const candidateLimit = opts?.candidateLimit ?? 3000;
-        const limit = opts?.limit ?? 20;
+        const limit = opts?.limit ?? TOP_K_FOR_RANKING;
         const type = opts?.type;
         const client = createEmbeddingClient(env.embeddingServiceUrl);
         const [queryVec] = await client.embed([query.trim()]);
         if (!queryVec?.length) {
             throw new Error('查询向量为空');
         }
+        // 查询足够的数据以支持分桶采样（3倍候选数以覆盖各桶）
+        const fetchLimit = candidateLimit * 3;
         let sql = `
       SELECT id, name, type, category, path, description, content, CAST(meta AS CHAR) AS meta, usage_count, created_at, embedding
       FROM ${env.mysqlSymbolsTable}
       WHERE embedding IS NOT NULL
+        AND status = ${SEARCHABLE_STATUS}
     `;
         const params = [];
         if (type) {
             sql += ' AND type = ?';
             params.push(type);
         }
-        sql += ' ORDER BY usage_count DESC LIMIT ?';
-        params.push(candidateLimit);
+        sql += ' DESC LIMIT ?';
+        params.push(fetchLimit);
         const [rows] = await this.pool.query(sql, params);
         const withVec = rows
             .map((r) => mapRow(r, { includeEmbedding: true }))
             .filter((s) => s.embedding && s.embedding.length === queryVec.length);
-        return withVec
+        // 分桶采样：按 category + path 两层分桶
+        const sampled = this.bucketSampling(withVec, candidateLimit);
+        return sampled
             .map((s) => {
             const sim = cosineSimilarity(queryVec, s.embedding);
             const { embedding: _, ...rest } = s;
             return { symbol: rest, similarity: sim };
         })
+            .filter((x) => x.similarity >= THREADHOLD_SIMILARITY_BEFORE_RANKED) // 初筛阈值，过滤掉明显不相关的结果
             .sort((a, b) => b.similarity - a.similarity)
             .slice(0, limit);
     }
+    /**
+   * 分桶采样核心逻辑
+   * - 第一层：按 category 占比计算每个分类应采样条数（保底10条）
+   * - 第二层：每个 path 子桶内乱序后采样 Math.max(5,
+  floor(catLimit / pathCount)) 条
+   */
+    bucketSampling(symbols, limit) {
+        if (symbols.length === 0)
+            return [];
+        // 按 category 分组
+        const categoryGroups = new Map();
+        for (const s of symbols) {
+            const cat = s.category ?? '__null__';
+            if (!categoryGroups.has(cat)) {
+                categoryGroups.set(cat, []);
+            }
+            categoryGroups.get(cat).push(s);
+        }
+        const total = symbols.length;
+        const sampled = [];
+        // 第一层：按 category 占比计算采样数，保底10条
+        for (const [, catSymbols] of categoryGroups) {
+            const catCount = catSymbols.length;
+            const catRatio = catCount / total;
+            const catLimit = Math.max(10, Math.floor(limit * catRatio));
+            // 按 path 分组（提取目录部分）
+            const pathGroups = new Map();
+            for (const s of catSymbols) {
+                const dir = s.path.includes('/')
+                    ? s.path.slice(0, s.path.lastIndexOf('/'))
+                    : '__root__';
+                if (!pathGroups.has(dir)) {
+                    pathGroups.set(dir, []);
+                }
+                pathGroups.get(dir).push(s);
+            }
+            const pathCount = pathGroups.size;
+            const perPathSample = Math.max(5, Math.floor(catLimit / pathCount));
+            // 第二层：每个 path 子桶内乱序后采样
+            for (const pathSymbols of pathGroups.values()) {
+                // 原地乱序（Fisher- Y ates）
+                for (let i = pathSymbols.length - 1; i > 0; i--) {
+                    const j = Math.floor(Math.random() * (i + 1));
+                    [pathSymbols[i], pathSymbols[j]] = [
+                        pathSymbols[j],
+                        pathSymbols[i],
+                    ];
+                }
+                const pathSampleCount = Math.min(perPathSample, pathSymbols.length);
+                sampled.push(...pathSymbols.slice(0, pathSampleCount));
+                if (sampled.length >= limit)
+                    break;
+            }
+            if (sampled.length >= limit)
+                break;
+        }
+        return sampled.slice(0, limit);
+    }
     async getByName(name) {
         if (!this.pool) {
             return (inMemorySymbols.find((s) => s.name.toLowerCase() === name.toLowerCase()) ?? null);

package/dist/services/embeddingQueue.js

@@ -0,0 +1,56 @@
+/**
+ * BullMQ embedding 队列 producer。
+ *
+ * 设计要点：
+ * - jobId = semanticHash → 相同语义模板自动去重，N 个符号相同 hash 只入队一次
+ * - CI 流程只负责 enqueue，worker 异步消费，CI 不阻塞
+ * - 调用方在进程退出前需调用 closeEmbeddingQueue() 释放连接
+ */
+import { Queue } from 'bullmq';
+import Redis from 'ioredis';
+import { env } from '../config/env.js';
+let _queue = null;
+let _connection = null;
+function getQueue() {
+    if (!_queue) {
+        _connection = new Redis(env.redisUrl, {
+            maxRetriesPerRequest: null, // BullMQ required
+            enableReadyCheck: false,
+        });
+        _queue = new Queue('embedding', { connection: _connection });
+    }
+    return _queue;
+}
+/**
+ * 将一个 semanticHash 对应的 embedding 任务入队。
+ * 若队列中已存在相同 jobId（semanticHash）的待处理任务，BullMQ 自动忽略重复请求。
+ */
+export async function enqueueEmbedding(semanticHash) {
+    await getQueue().add('embed', { semanticHash }, {
+        jobId: semanticHash, // 去重键：相同 hash 幂等
+        attempts: 5,
+        backoff: { type: 'exponential', delay: 5_000 },
+    });
+}
+/** 批量入队，适合全量扫描场景 */
+export async function enqueueEmbeddingBatch(semanticHashes) {
+    const queue = getQueue();
+    const jobs = semanticHashes.map((hash) => ({
+        name: 'embed',
+        data: { semanticHash: hash },
+        opts: {
+            jobId: hash,
+            attempts: 5,
+            backoff: { type: 'exponential', delay: 5_000 },
+        },
+    }));
+    // BullMQ addBulk 会跳过已存在 jobId 的任务
+    await queue.addBulkJobs(jobs);
+}
+/** 进程退出前关闭连接（CI 脚本必须调用，否则进程挂起） */
+export async function closeEmbeddingQueue() {
+    await _queue?.close();
+    await _connection?.quit();
+    _queue = null;
+    _connection = null;
+}

package/dist/services/reindex.js

@@ -4,6 +4,7 @@ import { getMySqlPool } from '../db/mysql.js';
 import { indexedRowToEmbedText } from '../indexer/embedText.js';
 import { indexProject } from '../indexer/indexProject.js';
 import { upsertSymbols } from '../indexer/persistSymbols.js';
+import { initCategoryEmbeddings, resolveCategory, } from '../indexer/categoryClassifier.js';
 import { createEmbeddingClient, embedAll, } from '../services/embeddingClient.js';
 export async function runReindex(options = {}) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
@@ -12,23 +13,20 @@ export async function runReindex(options = {}) {
     loadProjectDotenv(projectRoot);
     // 2️ 打印生效的环境变量（便于调试）
     console.error(`[reindex] projectRoot=${projectRoot}, dryRun=${dryRun}, ` +
-        `MYSQL_ENABLED=${process.env.MYSQL_ENABLED}, ` +
         `MYSQL_HOST=${process.env.MYSQL_HOST}`);
     // 3️⃣ 只有需要写入数据库时才检查 MySQL 并建立连接
-    // 注意：直接检查 process.env，因为 env.mysqlEnabled 是模块加载时计算的，不会反映 loadProjectDotenv 的更新
-    const mysqlEnabled = process.env.MYSQL_ENABLED === 'true';
     const embeddingServiceUrl = process.env.EMBEDDING_SERVICE_URL;
+    if (!dryRun && embeddingServiceUrl) {
+        // 初始化 category embeddings
+        await initCategoryEmbeddings();
+    }
     let pool = null;
     if (!dryRun) {
-        if (!mysqlEnabled) {
-            throw new Error(`最新！${JSON.stringify(process.env)}执行 reindex 写入数据库需要 MYSQL_ENABLED=true。' +
-                    '第三方项目可在 .env 中配置此变量（未配置则使用 MCP Server 本地配置）。`);
-        }
         pool = getMySqlPool();
         await pool.query('SELECT 1'); // 测试连接
         console.error('[reindex] MySQL connection successful');
     }
-    const rows = await indexProject({
+    let rows = await indexProject({
         projectRoot,
         globPatterns: options.globPatterns,
         ignore: options.ignore,
@@ -39,8 +37,12 @@ export async function runReindex(options = {}) {
     if (!options.dryRun && rows.length > 0 && embeddingServiceUrl) {
         try {
             const client = createEmbeddingClient(embeddingServiceUrl);
-            const texts = rows.map(indexedRowToEmbedText);
+            // 先实现ts语义模板,js保留原逻辑
+            const texts = rows.map((row) => row.semantic_hash ?? indexedRowToEmbedText(row));
             const vecs = await embedAll(client, texts);
+            console.error('==vecs', vecs?.length);
+            // 生成category
+            rows = await resolveCategory(rows, vecs);
             embeddingPayload = vecs;
             embeddingsComputed = true;
         }
@@ -52,6 +54,7 @@ export async function runReindex(options = {}) {
     if (!options.dryRun) {
         await upsertSymbols(pool, rows, embeddingPayload);
     }
+    console.error('===out', JSON.stringify(rows));
     return {
         projectRoot,
         extractedCount: rows.length,

package/dist/tools/searchByStructure.js

@@ -3,7 +3,9 @@ import { z } from 'zod';
 import { rankSymbols } from '../services/ranking.js';
 export const searchByStructureInput = z.object({
     fields: z.array(z.string().min(1)).min(1),
-    type: z.enum(['component', 'util', 'selector', 'type']).optional(),
+    type: z
+        .enum(['component', 'function', 'hook', 'type', 'interface', 'class'])
+        .optional(),
     category: z.string().optional(),
     limit: z.number().int().min(1).max(100).optional().default(20),
     ranked: z.boolean().optional().default(true),