@lorrylurui/code-intelligence-mcp 2.0.4 → 2.0.5

package/README.md

@@ -10,6 +10,14 @@
 - Prompt: `reusable-code-advisor`
 - Cursor Skill：`reusable-code-advisor`（`.cursor/skills/reusable-code-advisor/`，
 
+## 开发
+
+```
+    1. npm run dev:mcp 启动mcp  server
+    2. npm run embedding:dev 启动本地python环境
+    3. npm run worker:embedding 启动worker队列
+```
+
 ## 1) 配置mcp servers
 
 ```
@@ -37,73 +45,3 @@
 
 MYSQL\*SYMBOLS_TABLE=frontend_collections_symbols
 INDEX_GLOB=xxx/\*\*/\_.{js,jsx,ts,tsx}
-
-# 待优化项
-
-修复优先级：
-✅8
-✅5
-✅134 done，但是第二层embedding需要优化，llm fallback太慢+漂移，也需要调整模型
-✅6
-✅27
-
-1.  meta里面有多个信息，哪些做结构化过滤，哪些做向量检索？
-    结论：ast normalizers后拼一个语义模板，用这个模板内容生成向量
-    ❓做法见qa-doc/semantic-phrase.md
-2.  对于 class类型，content字段保留关键方法或摘要，而不是完全为空
-    最新修改：content赋值为语义模板
-3.  category过于模糊，
-    这三层怎么做：category 优先使用规则和 embedding 分类，
-    LLM 只作为 fallback，避免不稳定和成本问题
-    ❓做法见qa-doc/category.md
-4.  type category meta.kind 字段是否多余了？type只有5个值，
-    type表达代码结构、category表达语义结构，kind？
-    type： function / component / hook / class / type / interface
-    category：最新的三层结构（还没实现，只有文档）
-    kind: 现在跟type重叠较多，建议弱化meta.kind → 只保留特殊情况：
-    ❓改造方法qa-doc/type-category-kind.md
-5.  在ci做增量索引时，把changed files,如果是1000+文件，性能爆炸，考虑用file hash 判断？embedding也没有优化缓存？
-    ❓见qa-doc/ci-hash-solution 方案：🥈 file hash + ast normalizer hash，新增semantic_hash
-    - CI 增量（git changed files 触发）
-      只需要 semantic_hash
-      file_hash 可省，因为文件必然变了
-    - 每日全量扫描
-      file_hash 用来跳过 AST 解析（CPU 优化）
-      semantic_hash 用来跳过 embedding（费用优化）
-      content_hash 删掉，职责完全被 semantic_hash 覆盖
-6.  大仓问题：
-    ❓big-repo.md
-    - ci embedding解耦，新增embedding_status, ci时，全量写入status='pending'-> ci finish
-    - ci如果检测到文件删除，则对被删除的代码块标记delete（这里需要新增字段）
-    - node+redis 消费写embedding job
-    - 对语义模板semantic_hash做向量缓存，semantic_hash相同即功能未变
-    - 大仓分片并行
-7.  content暂时用不到，但也不用删除，目前暴利截取4000字符需要优化：
-    content（降级为辅助字段）：✔ 不参与 embedding✔ 不参与排序✔ 不参与过滤✔ 用于：1. LLM改造建议 2.debug 3.future rerank
-    最简单：只存 signature
-    最优：content = {
-    signature: "function fetchData(url, options)",
-    snippet: "核心逻辑代码（<=300行）",
-    keyCalls: ["fetch", "cache"]
-    }
-8.  TopK???，首先去掉usage过滤，再做两次topk,1.根据余弦相似度选topk 2.对1的结果用现有的usage,updated_at等加权排序
-    ❓topK.md
-    现在：SQL过滤(type) → ORDER BY usage_count DESC LIMIT 3000→ embedding 相似度排序→ 取 top20
-    这个逻辑不对，导致query: "debounce function"，debounce 使用少 ❌ fetch 很热门 ✅，结果Top3000里全是 fetch / request， debounce 被过滤掉 ❌
-
-👉 优点：
-• 不阻塞 CI
-• 可扩展
-
-6. 大仓问题呢？
-
-# 简历里还没做的优化
-
-1. embedding基石 - 语义模板模板，使用ast数据拼装语义模板
-2. class的content为null
-3. category分层 1.规则 2.预设所有种类，使用embedding召回 3.llm兜底
-4. type meta.kind逻辑优化，现在太重叠了
-5. ci-hash-solution
-6. 大仓问题
-7. content优化
-8. ✅topk优化

package/dist/index.js

@@ -6,6 +6,7 @@ async function main() {
     // 加载第三方项目的 .env（通过 INDEX_ROOT 指定，或默认当前工作目录）
     const projectRoot = process.env.INDEX_ROOT || process.cwd();
     loadProjectDotenv(projectRoot);
+    console.error('[code-intelligence-mcp] env.loaded env.projectRoot=%s', projectRoot);
     const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/indexer/babelParser.js

@@ -357,6 +357,7 @@ function createRowFromFunction(name, decl, filePath, projectRoot, isJsx) {
 function createRowFromClass(name, _decl, filePath, projectRoot) {
     const relPath = getRelativePathForDisplay(projectRoot, filePath);
     const category = inferCategoryFromPath(filePath);
+    const jsdoc = parseJsDocInfo(_decl);
     // 大写开头的类视为组件
     const type = /^[A-Z]/.test(name) ? 'component' : 'function';
     return {
@@ -364,7 +365,7 @@ function createRowFromClass(name, _decl, filePath, projectRoot) {
         type,
         category,
         path: relPath,
-        description: null,
+        description: jsdoc.description,
         // content meta.kind 暂时废弃不用，
         content: null,
         meta: {},

package/dist/indexer/indexProject.js

@@ -3,7 +3,9 @@
  * 同时分析调用关系，填充 meta.callers / meta.callees。
  */
 import fg from 'fast-glob';
-import { join, resolve } from 'node:path';
+import * as babelParser from '@babel/parser';
+import * as bt from '@babel/types';
+import { dirname, join, resolve } from 'node:path';
 import { Node, Project } from 'ts-morph';
 import { readFileSync, existsSync } from 'node:fs';
 import { extractInterfaceOrTypeMeta, extractMetaFromCallable, } from './extractMeta.js';
@@ -12,6 +14,40 @@ import { parseJsFile } from './babelParser.js';
 import { isParamPlaceholder } from './paramPlaceholder.js';
 import { computeFileHash, computeSemanticHash } from './tsAstNormalizer.js';
 const CALLERS_LIMIT = 20;
+const BABEL_PLUGINS = [
+    'jsx',
+    'typescript',
+    'classPrivateMethods',
+    'classPrivateProperties',
+    'decorators-legacy',
+    'doExpressions',
+    'exportDefaultFrom',
+    'functionBind',
+    'logicalAssignment',
+    'nullishCoalescingOperator',
+    'objectRestSpread',
+    'optionalChaining',
+    'optionalCatchBinding',
+];
+function isCallerDebugEnabled() {
+    return /^(1|true|yes|on)$/i.test(process.env.DEBUG_CALLERS ?? '');
+}
+function getCallerDebugMatch() {
+    return (process.env.DEBUG_CALLERS_MATCH ?? '').trim().toLowerCase();
+}
+function shouldLogCallerDebug(parts) {
+    if (!isCallerDebugEnabled())
+        return false;
+    const match = getCallerDebugMatch();
+    if (!match)
+        return true;
+    return parts.some((part) => part?.toLowerCase().includes(match));
+}
+function logCallerDebug(stage, payload, parts) {
+    if (!shouldLogCallerDebug(parts))
+        return;
+    console.error(`[callers.debug] ${stage} ${JSON.stringify(payload)}`);
+}
 /** 判断文件类型 */
 function isJsFile(filePath) {
     return filePath.endsWith('.js') || filePath.endsWith('.jsx');
@@ -30,9 +66,9 @@ function mergeCallableMeta(symbolType, raw) {
     const paramTypeFields = raw.paramTypeFields;
     const { params: _p, paramTypeFields: _f, ...rest } = raw;
     if (symbolType === 'component' && params?.length) {
-        const props = [
-            ...new Set([...(paramTypeFields ?? []), ...params]),
-        ].filter((name) => name.toLowerCase() !== 'props' && !isParamPlaceholder(name)).sort();
+        const props = [...new Set([...(paramTypeFields ?? []), ...params])]
+            .filter((name) => name.toLowerCase() !== 'props' && !isParamPlaceholder(name))
+            .sort();
         return { ...rest, ...(props.length ? { props } : {}) };
     }
     return { ...rest, ...(params?.length ? { params } : {}) };
@@ -198,6 +234,142 @@ export const DEFAULT_IGNORE = [
     '**/dist-srv/**',
     '**/.turbo/**',
 ];
+function resolveImportedSourceFile(currentFilePath, moduleSpecifier) {
+    if (!moduleSpecifier.startsWith('.'))
+        return null;
+    const base = resolve(dirname(currentFilePath), moduleSpecifier);
+    const candidates = [
+        base,
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        join(base, 'index.ts'),
+        join(base, 'index.tsx'),
+        join(base, 'index.js'),
+        join(base, 'index.jsx'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function applyRelationMaps(rows, callersMap, calleesMap) {
+    for (const row of rows) {
+        const key = `${row.name}|${row.path}`;
+        const callers = callersMap.get(key);
+        const callees = calleesMap.get(key);
+        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?.size) {
+            row.meta.callees = [...callees].slice(0, CALLERS_LIMIT).map((s) => {
+                const [name, ...pathParts] = s.split('|');
+                return { name, path: pathParts.join('|') };
+            });
+        }
+    }
+}
+function analyzeJsRelations(jsFiles, symbolMap, projectRoot, rows) {
+    const callersMap = new Map();
+    const calleesMap = new Map();
+    for (const filePath of jsFiles) {
+        const relPath = getRelativePathForDisplay(projectRoot, filePath);
+        const callerRows = rows.filter((row) => row.path === relPath);
+        if (callerRows.length === 0)
+            continue;
+        logCallerDebug('js-file-start', {
+            filePath,
+            relPath,
+            callerRows: callerRows.map((row) => row.name),
+        }, [filePath, relPath, ...callerRows.map((row) => row.name)]);
+        let ast;
+        try {
+            ast = babelParser.parse(readFileSync(filePath, 'utf-8'), {
+                sourceType: 'module',
+                plugins: [...BABEL_PLUGINS],
+                strictMode: false,
+            });
+        }
+        catch (error) {
+            console.error(`[analyzeJsRelations] Failed to parse ${filePath}:`, error);
+            continue;
+        }
+        for (const stmt of ast.program.body) {
+            if (!bt.isImportDeclaration(stmt))
+                continue;
+            const moduleSpecifier = stmt.source.value;
+            if (typeof moduleSpecifier !== 'string')
+                continue;
+            const importedFile = resolveImportedSourceFile(filePath, moduleSpecifier);
+            logCallerDebug('js-import-resolve', {
+                from: relPath,
+                moduleSpecifier,
+                importedFile,
+            }, [relPath, moduleSpecifier, importedFile]);
+            if (!importedFile)
+                continue;
+            const importedRelPath = getRelativePathForDisplay(projectRoot, importedFile);
+            const importedNames = stmt.specifiers
+                .map((spec) => {
+                if (bt.isImportSpecifier(spec)) {
+                    return bt.isIdentifier(spec.imported)
+                        ? spec.imported.name
+                        : spec.imported.value;
+                }
+                if (bt.isImportDefaultSpecifier(spec)) {
+                    return spec.local.name;
+                }
+                return null;
+            })
+                .filter((name) => Boolean(name));
+            logCallerDebug('js-import-specifiers', {
+                from: relPath,
+                moduleSpecifier,
+                importedRelPath,
+                importedNames,
+            }, [relPath, moduleSpecifier, importedRelPath, ...importedNames]);
+            for (const callerRow of callerRows) {
+                const callerKey = `${callerRow.name}|${callerRow.path}`;
+                for (const importedName of importedNames) {
+                    const targetKey = `${importedName}|${importedRelPath}`;
+                    const target = symbolMap.get(targetKey);
+                    logCallerDebug('js-import-target', {
+                        callerKey,
+                        targetKey,
+                        hit: Boolean(target),
+                        availableKeysInFile: [...symbolMap.keys()].filter((key) => key.endsWith(`|${importedRelPath}`)),
+                    }, [callerKey, targetKey, importedRelPath, importedName]);
+                    if (!target)
+                        continue;
+                    const calleeSet = calleesMap.get(callerKey) || new Set();
+                    calleeSet.add(`${target.name}|${target.path}`);
+                    calleesMap.set(callerKey, calleeSet);
+                    const callerSet = callersMap.get(`${target.name}|${target.path}`) ||
+                        new Set();
+                    callerSet.add(callerKey);
+                    callersMap.set(`${target.name}|${target.path}`, callerSet);
+                    logCallerDebug('js-link-added', {
+                        callerKey,
+                        calleeKey: `${target.name}|${target.path}`,
+                    }, [callerKey, target.name, target.path]);
+                }
+            }
+        }
+    }
+    applyRelationMaps(rows, callersMap, calleesMap);
+    for (const row of rows) {
+        logCallerDebug('js-row-final', {
+            row: `${row.name}|${row.path}`,
+            callers: row.meta.callers ?? [],
+            callees: row.meta.callees ?? [],
+        }, [row.name, row.path]);
+    }
+}
 /**
  * 按 glob 收集文件，用 ts-morph 加载并遍历每个文件的导出，生成全部代码块行。
  * 同时分析调用关系，填充 meta.callers / meta.callees。
@@ -269,6 +441,10 @@ export async function indexProject(opts) {
                             });
                         }
                         symbolMap.get(key).exports.add(exportName);
+                        logCallerDebug('symbol-map-add-ts', {
+                            key,
+                            exportName,
+                        }, [row.name, row.path, exportName]);
                     }
                 }
             }
@@ -291,6 +467,10 @@ export async function indexProject(opts) {
                     });
                 }
                 symbolMap.get(key).exports.add(row.name);
+                logCallerDebug('symbol-map-add-js', {
+                    key,
+                    exportName: row.name,
+                }, [row.name, row.path]);
             }
         }
         catch (e) {
@@ -307,6 +487,9 @@ export async function indexProject(opts) {
         project.addSourceFilesAtPaths(tsFiles);
         analyzeRelations(project, symbolMap, projectRoot, out);
     }
+    if (jsFiles.length > 0) {
+        analyzeJsRelations(jsFiles, symbolMap, projectRoot, out);
+    }
     return out;
 }
 /**
@@ -392,25 +575,13 @@ function analyzeRelations(project, symbolMap, projectRoot, rows) {
             }
         });
     }
-    // 写入 rows 的 meta
+    applyRelationMaps(rows, callersMap, calleesMap);
     for (const row of rows) {
-        const key = `${row.name}|${row.path}`;
-        const callers = callersMap.get(key);
-        const callees = calleesMap.get(key);
-        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?.size) {
-            row.meta.callees = [...callees].slice(0, CALLERS_LIMIT).map((s) => {
-                const [name, ...pathParts] = s.split('|');
-                // path:为了防止路径里万一含有 | 字符时截断错误。
-                return { name, path: pathParts.join('|') };
-            });
-        }
+        logCallerDebug('ts-row-final', {
+            row: `${row.name}|${row.path}`,
+            callers: row.meta.callers ?? [],
+            callees: row.meta.callees ?? [],
+        }, [row.name, row.path]);
     }
     console.error(`[analyzeRelations] processed ${rows.length} symbols`);
 }

package/dist/indexer/jsAstNormalizer.js

@@ -171,17 +171,32 @@ function traverseNode(node, cb) {
     }
 }
 export function inferBehaviorFromJS(node) {
-    const behavior = [];
+    const behavior = new Set();
+    const add = (label) => {
+        behavior.add(label);
+    };
     // 遍历 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');
+                add('performs network request');
             }
             if (name.includes('settimeout')) {
-                behavior.push('uses timer');
+                add('uses timer');
+            }
+            if (name.includes('getscroll')) {
+                add('tracks scroll position');
+            }
+            if (name.includes('getoffset')) {
+                add('computes element offset');
+            }
+            if (name.includes('throttle')) {
+                add('throttles position updates');
+            }
+            if (name.includes('addeventlistener')) {
+                add('listens to viewport events');
             }
         }
         if (t.isCallExpression(n) &&
@@ -190,17 +205,32 @@ export function inferBehaviorFromJS(node) {
             const prop = n.callee.property.name;
             if (prop === 'getBoundingClientRect' ||
                 prop === 'getComputedStyle') {
-                behavior.push('reads dom layout');
+                add('reads dom layout');
             }
+            if (prop === 'addEventListener') {
+                add('listens to viewport events');
+            }
+        }
+        if (t.isIdentifier(n)) {
+            const name = n.name.toLowerCase();
+            if (name === 'offsettop' || name === 'offsetbottom') {
+                add('supports offset positioning');
+            }
+            if (name === 'scrolltop') {
+                add('tracks scroll position');
+            }
+        }
+        if (t.isStringLiteral(n) && n.value.toLowerCase() === 'fixed') {
+            add('uses fixed positioning');
         }
         // localStorage
         if (t.isMemberExpression(n) &&
             t.isIdentifier(n.object) &&
             n.object.name === 'localStorage') {
-            behavior.push('uses local storage');
+            add('uses local storage');
         }
     });
-    return Array.from(new Set(behavior));
+    return [...behavior].sort();
 }
 export function extractNormalizedSignatureJS(node) {
     if (t.isFunctionDeclaration(node) || t.isFunctionExpression(node)) {

package/dist/prompts/reusableCodeAdvisorPrompt.js

@@ -3,22 +3,30 @@ const REUSABLE_CODE_ADVISOR_DESCRIPTION = '在实现需求时检索并推荐最
 /** 与 SKILL.md 中 `# 可复用代码推荐` 起至约束、示例说明为止的正文一致（无 YAML frontmatter）。 */
 const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 
-## 工作流
-
-当用户需要可复用代码或实现类需求时，按顺序执行：
-
-1. 如果用户是在找可复用组件，优先调用 recommend_component，由它完成候选搜索、结构过滤和排序。
-2. 只有当用户明确要求手动检索、或需要更细粒度控制时，才组合调用 search_symbols / search_by_structure / get_symbol_detail。
-3. 若仅凭摘要无法判断，对最相关的若干候选调用 get_symbol_detail 获取详情。
-4. 从以下维度对比候选：
-   - 与用户需求的**功能匹配度**
-   - **API 是否简单**、入参是否合适
-   - **依赖与副作用**风险
-   - **复用安全性**（稳定性、耦合度、是否便于扩展）
-5. 给出**唯一首选**推荐，并说明理由，同时使用 **AskUserQuestion** 工具，提供两个选项：
-   - 采纳推荐
-   - 取消
-6. 用户选择"采纳推荐"后，立即调用 inc_usage 工具记录该行为（symbolId 从搜索结果的 id 字段获取），不要遗漏此步骤。
+## 工作流（三级降级链，严格按序，每级有结果即终止）
+
+### 第一级：recommend_component（唯一首选）
+1. 用户询问可复用组件/函数/util/工具 → 必须先调用 \`recommend_component\`
+2. 返回 recommended != null → 将工具返回文本**原样输出**，**完全停止**，不得继续调用任何工具
+3. 返回 recommended = null → 进入第二级
+
+### 第二级：search_symbols（仅在第一级无结果时）
+4. 调用 \`search_symbols\`（semantic=true，传入原始 query）
+5. 返回非空结果 → 取第一条，按固定回复结构输出，**完全停止**
+6. 返回空结果 → 进入第三级
+
+### 第三级：输出无结果模板
+7. 直接输出无结果固定模板，**完全停止**
+8. 禁止进行 grep、read file、file search 等文件系统操作
+
+## 硬性约束
+
+- **不得跳过第一级直接调用 search_symbols**：对任何"帮我找 X""有没有 X"类问题，第一步永远是 \`recommend_component\`
+- **工具返回后不得自由发挥**：输出必须以工具返回结果为唯一事实来源，按模板格式输出，禁止改写为散文或追加额外检索过程
+- **禁止文件系统兜底**：MCP 三级链全部无结果后，只输出无结果模板，不读文件、不 grep
+- **禁止工作区外路径**：禁止引用或读取工作区外文件（如 \`/Users/.../not_git_private/...\`）
+- **禁止过程叙述**：不得输出"我先检索""Ran search_symbols""Read file"等过程描述
+- 用户选择"采纳推荐"后，立即调用 \`inc_usage\`（symbolId 从结果 id 字段获取）
 
 ## 不适用场景
 
@@ -30,32 +38,53 @@ const REUSABLE_CODE_ADVISOR_MARKDOWN = `# 可复用代码推荐
 ## 搜索结果判断
 
 根据 semanticSimilarity 决定推荐置信度：
-- **> 0.85**：高置信度，可直接推荐
-- **0.6 – 0.85**：中等置信度，需结合 description 和 get_symbol_detail 综合判断
-- **< 0.6**：低置信度，说明可能无合适实现，明确告知用户
+- **> 0.85**：高置信度，直接推荐
+- **0.6 – 0.85**：中等置信度，需结合 description 综合判断
+- **< 0.6**：低置信度，明确告知用户可能无合适实现
 - **空结果**：明确说"未找到已有实现"，不要凭空推荐
 
-## 回复结构
+## 回复结构（固定模板，不得改写）
+
+> ⚠️ 以下模板中的所有字段值（symbolId、使用范围、副作用、理由等）**均由 \`recommend_component\` 工具返回文本中已填好**，禁止自行推断或从代码文件中读取。LLM 只需将工具返回的文本**原样复制输出**，不得改写、补全或省略任何字段。
 
-按此结构输出（字段名可保留英文或改为中文小标题，二选一全文统一）：
+有结果时：
 
-- **首选：** <代码块名>
-- **使用范围：** 展示 meta.callers（被哪些模块调用），用于评估稳定性和适用范围；若无调用记录则显示"新增"
-- **副作用：** 展示 meta.sideEffects（network/timer/dom/storage/mutation），优先推荐无副作用的方案，标注有副作用的方案风险
-- **理由：** 1～3 条要点
-- **其他候选：** 简要列出及取舍（同步标注副作用）
-- **用法提示：** 结合用户场景的最小集成说明
-- **是否采纳：** 展示两个选项：选项1. 采纳推荐  选项2. 取消。等待用户确认
+首选：<符号名> — <文件路径>
+使用范围：<callers 或 "新增">
+副作用：<sideEffects 或 "无">
+理由：
+1. <要点1>
+2. <要点2>
+其他候选：<候选A（副作用）>; <候选B（副作用）>
+用法提示：
+<最小集成示例>
+是否采纳：
+1. 采纳推荐
+2. 取消
 
-## 约束
+> 输出上述模板后**等待用户在聊天框输入回复**，识别规则：
+> - 用户输入 **"1"、"采纳"、"采纳推荐"、"ok"、"好的"** 或类似确认词 → 从上方输出文本中读取 \`symbolId：<id>\` 那一行的值，立即调用 \`inc_usage\` 工具传入该 id，调用成功后回复"✓ 已记录使用，可直接集成"
+> - 用户输入 **"2"、"取消"、"不用了"** 或类似否定词 → 回复"好的，已取消"，停止
+> - 用户输入其他内容（如追问细节）→ 正常回答，回答结束后再次展示"是否采纳"选项
 
-- 优先推荐已有可复用代码块，避免轻易建议新写一套。
-- 若无合适代码块，明确说明，并给出最接近的选项及差距。
-- 推理简洁，面向落地实现。
+无结果时：
 
-## 更多示例
+首选：未找到已有实现
+使用范围：无
+副作用：无
+理由：
+1. 当前索引中没有满足条件的符号
+2. 已尝试可用检索方式，仍无可用候选
+其他候选：无
+用法提示：
+// 可先创建一个最小可复用实现
+是否采纳：
+1. 让我新建一个最小可复用实现
+2. 取消
 
-与仓库内 \`.cursor/skills/reusable-code-advisor/examples.md\` 中的示例一致（在 Cursor 或本地打开该文件查看）。
+> 输出上述模板后**等待用户在聊天框输入回复**，识别规则：
+> - 用户输入 **"1"、"新建"、"帮我创建"** 或类似确认词 → 进入新建流程，引导用户确认最小接口设计
+> - 用户输入 **"2"、"取消"、"不用了"** → 回复"好的，已取消"，停止
 `;
 export function registerReusableCodeAdvisorPrompt(server) {
     server.prompt('reusable-code-advisor', REUSABLE_CODE_ADVISOR_DESCRIPTION, {