@lorrylurui/code-intelligence-mcp 1.1.15 → 2.0.1

package/dist/db/schema.js

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

package/dist/indexer/astNormalizer.js

@@ -0,0 +1,201 @@
+/**
+ * astNormalizer.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();
+}
+// ─────────────────────────────────────────────
+// 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();
+}
+// ─────────────────────────────────────────────
+// extractNormalizedSignature：从声明节点提取标准化签名
+// ─────────────────────────────────────────────
+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().map((p) => normalizeNode(p));
+        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 / type alias
+    if (Node.isInterfaceDeclaration(node) ||
+        Node.isTypeAliasDeclaration(node)) {
+        return normalizeNode(node);
+    }
+    // class：只取方法签名列表
+    if (Node.isClassDeclaration(node)) {
+        const methods = node.getMethods().map((m) => {
+            const params = m.getParameters().map((p) => normalizeNode(p));
+            const retNode = m.getReturnTypeNode();
+            const ret = retNode
+                ? normalizeTypeString(retNode.getText())
+                : '$inferred';
+            return `${m.getName()}(${params.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(),
+    };
+    return createHash('sha256').update(JSON.stringify(stable)).digest('hex');
+}
+// ─────────────────────────────────────────────
+// computeFileHash：对文件原始内容
+// ─────────────────────────────────────────────
+export function computeFileHash(fileContent) {
+    return createHash('sha256').update(fileContent).digest('hex');
+}

package/dist/indexer/babelParser.js

@@ -3,7 +3,9 @@
  */
 import * as babelParser from '@babel/parser';
 import * as bt from '@babel/types';
-import { getRelativePathForDisplay, inferCategoryFromPath, } from './heuristics.js';
+import { getRelativePathForDisplay, inferCategoryFromPath, inferCategoryFromName, } from './heuristics.js';
+import { computeFileHash } from './tsAstNormalizer.js';
+import { computeSemanticHashJs } from './jsAstNormalizer.js';
 /** 从 JS 文件内容解析导出的代码块 */
 export function parseJsFile(filePath, content, projectRoot) {
     const out = [];
@@ -46,7 +48,23 @@ export function parseJsFile(filePath, content, projectRoot) {
             out.push(...rows);
         }
     }
-    return out;
+    // 第三轮：更新content、file_hash、semantic_hash 字段
+    const outWithTwoHash = out.map((o) => {
+        const [semantic_hash, stableStr] = computeSemanticHashJs(o);
+        const { name, type, description, meta, category, path } = o;
+        return {
+            name,
+            type,
+            category,
+            path,
+            description,
+            meta,
+            content: stableStr,
+            file_hash: computeFileHash(content),
+            semantic_hash,
+        };
+    });
+    return outWithTwoHash;
 }
 /** 处理导出的声明 */
 function processStatement(stmt, filePath, isJsx, projectRoot) {
@@ -216,21 +234,19 @@ function arrowToFunction(name, arrow) {
 }
 function createRowFromFunction(name, decl, filePath, projectRoot, isJsx) {
     const relPath = getRelativePathForDisplay(projectRoot, filePath);
-    const category = inferCategoryFromPath(filePath);
+    const category = inferCategoryFromPath(filePath) || inferCategoryFromName(name);
     // 检测是否有 JSX
     const hasJsx = isJsx || containsJsx(decl);
     // 判断类型：
     // 1. 有 JSX = component
-    // 2. 名字包含 selector = selector
+    // 2. 名字包含 use = hook
     // 3. 大写开头（JSX 组件约定）= component
-    // 4. 其他 = util
-    const type = hasJsx
-        ? 'component'
-        : name.toLowerCase().includes('selector')
-            ? 'selector'
-            : isJsx && /^[A-Z]/.test(name)
-                ? 'component'
-                : 'util';
+    // 4. 其他 = function
+    const type = name.toLowerCase().includes('use')
+        ? 'hook'
+        : isJsx || /^[A-Z]/.test(name)
+            ? 'component'
+            : 'function';
     const params = decl.params
         .filter((p) => bt.isIdentifier(p))
         .map((p) => p.name);
@@ -250,21 +266,28 @@ function createRowFromFunction(name, decl, filePath, projectRoot, isJsx) {
             ...(hooks.length ? { hooks } : {}),
             ...(sideEffects.length ? { sideEffects } : {}),
         },
+        file_hash: '',
+        semantic_hash: '',
+        node: decl,
     };
 }
 function createRowFromClass(name, _decl, filePath, projectRoot) {
     const relPath = getRelativePathForDisplay(projectRoot, filePath);
     const category = inferCategoryFromPath(filePath);
     // 大写开头的类视为组件
-    const type = /^[A-Z]/.test(name) ? 'component' : 'util';
+    const type = /^[A-Z]/.test(name) ? 'component' : 'function';
     return {
         name,
         type,
         category,
         path: relPath,
         description: null,
+        // content meta.kind 暂时废弃不用，
         content: null,
-        meta: { kind: 'class' },
+        meta: {},
+        file_hash: '',
+        semantic_hash: '',
+        node: _decl,
     };
 }
 /** 简单检测是否包含 JSX */
@@ -380,7 +403,9 @@ function getNodeText(n) {
         if (propNode && typeof propNode === 'object') {
             const propType = propNode.type;
             if (propType === 'Identifier') {
-                prop = propNode.name || '';
+                prop =
+                    propNode.name ||
+                        '';
             }
             else if (propType === 'Literal') {
                 prop = String(propNode.value ?? '');

package/dist/indexer/categoryClassifier.js

@@ -0,0 +1,129 @@
+/**
+ * category 分类器：三层融合（规则 + embedding + LLM）
+ */
+import { createHash } from 'node:crypto';
+import { env } from '../config/env.js';
+import { createEmbeddingClient } from '../services/embeddingClient.js';
+import { cosineSimilarity } from '../services/vectorMath.js';
+import { inferCategoryFromPath, inferCategoryFromName } from './heuristics.js';
+// 1. 定义 category label space
+const CATEGORIES = [
+    'network',
+    'form',
+    'validation',
+    'format',
+    'state',
+    'ui',
+    'storage',
+    'math',
+    'hook',
+    'utils',
+    'component',
+    'service',
+];
+// 2. 预计算 category embeddings（缓存）
+let categoryEmbeddingsCache = null;
+export async function initCategoryEmbeddings() {
+    if (!env.embeddingServiceUrl)
+        return;
+    const client = createEmbeddingClient(env.embeddingServiceUrl);
+    const embeddings = await Promise.all(CATEGORIES.map(async (c) => {
+        const [vec] = await client.embed([c]);
+        return { name: c, embedding: vec };
+    }));
+    categoryEmbeddingsCache = embeddings;
+}
+// 3. embedding 层
+const EMBEDDING_THRESHOLD = 0.5;
+// TODO: 这里有问题，embedding是语义模板向量，categoryEmbeddingsCache是单个词的向量，相似度必然是<0.3
+function categoryFromEmbedding(embedding) {
+    if (!categoryEmbeddingsCache)
+        return null;
+    let best = 'utils';
+    let maxScore = -Infinity;
+    for (const c of categoryEmbeddingsCache) {
+        const score = cosineSimilarity(embedding, c.embedding);
+        if (score > maxScore) {
+            maxScore = score;
+            best = c.name;
+        }
+    }
+    return maxScore < EMBEDDING_THRESHOLD ? null : best;
+}
+// 4. LLM 层（带缓存）
+const LLM_CACHE_TTL = 24 * 60 * 60 * 1000;
+const OLLAMA_URL = 'http://127.0.0.1:11434/v1/chat/completions';
+// 可根据本地实际情况调整模型名称，例如：'llama3.2:3b'、'llama3.1:8b'
+const OLLAMA_MODEL = 'llama3.2:3b';
+const llmCategoryCache = new Map();
+async function categoryFromLLM(stableStr) {
+    if (!stableStr)
+        return null;
+    const cacheKey = createHash('sha256')
+        .update(stableStr)
+        .digest('hex')
+        .slice(0, 16);
+    const cached = llmCategoryCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < LLM_CACHE_TTL)
+        return cached.category;
+    const prompt = `给一段代码语义说明，在下面列出来的所有类别中找到最相符的类别，请直接返回命中的原始字符串，没有命中不用返回。
+    代码语义:${stableStr}
+    类别合集: ${CATEGORIES.join(', ')}`;
+    try {
+        const body = {
+            model: OLLAMA_MODEL,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: 0.4,
+            stream: false,
+        };
+        const res = await fetch(OLLAMA_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const data = (await res.json());
+        const content = data.choices?.[0]?.message?.content
+            ?.trim()
+            ?.toLowerCase();
+        const category = CATEGORIES.find((c) => content.includes(c));
+        if (category) {
+            llmCategoryCache.set(cacheKey, { category, timestamp: Date.now() });
+            return category;
+        }
+    }
+    catch (e) {
+        console.error('[categoryFromLLM]', e);
+    }
+    return null;
+}
+// 5. 三层融合
+export async function resolveCategory(rows, vecs) {
+    const pros = rows.map(async (r, i) => {
+        const { name } = r;
+        const ruleCategory = inferCategoryFromPath(r.path) || inferCategoryFromName(name);
+        // console.error(`===from ruleCategory`, name, ruleCategory);
+        if (ruleCategory) {
+            return {
+                ...r,
+                category: ruleCategory,
+            };
+        }
+        // TODO: 这里有问题，embedding是语义模板向量，categoryEmbeddingsCache是单个词的向量，相似度必然是<0.3
+        const emd = categoryFromEmbedding(vecs[i]);
+        // console.error(`===from categoryFromEmbedding`, name, emd);
+        if (emd) {
+            return {
+                ...r,
+                category: emd,
+            };
+        }
+        const cateLlm = await categoryFromLLM(r.content);
+        // console.error(`===from categoryFromLLM`, name, cateLlm);
+        return {
+            ...r,
+            category: cateLlm,
+        };
+    });
+    const newRows = await Promise.all(pros);
+    return newRows;
+}

package/dist/indexer/embedText.js

@@ -1,15 +1,17 @@
+// 仅js类型使用，后续会删掉
+const MAX_CONTENT_LENGTH = 1200;
 function briefMeta(meta) {
-    const keys = ["props", "params", "properties", "hooks"];
+    const keys = ['props', 'params', 'properties', 'hooks'];
     const parts = [];
     for (const k of keys) {
         const v = meta[k];
         if (Array.isArray(v)) {
-            const strs = v.filter((x) => typeof x === "string");
+            const strs = v.filter((x) => typeof x === 'string');
             if (strs.length)
-                parts.push(`${k}: ${strs.slice(0, 24).join(", ")}`);
+                parts.push(`${k}: ${strs.slice(0, 24).join(', ')}`);
         }
     }
-    return parts.join("; ");
+    return parts.join('; ');
 }
 /**
  * 拼成一段供向量模型编码的文本（名称、路径、注释、meta 摘要、源码片段）。
@@ -19,10 +21,10 @@ export function indexedRowToEmbedText(row) {
     return [
         `${row.type} ${row.name}`,
         row.path,
-        row.description ?? "",
+        row.description ?? '',
         metaBit,
-        (row.content ?? "").slice(0, 1200)
+        (row.content ?? '').slice(0, MAX_CONTENT_LENGTH),
     ]
         .filter((s) => s.length > 0)
-        .join("\n");
+        .join('\n');
 }

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 ... */';
 }