@ppdocs/mcp 2.6.29 → 2.6.31

package/dist/tools/index.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import * as storage from '../storage/httpClient.js';
 import { decodeUnicodeEscapes, decodeObjectStrings, getRules, RULE_TYPE_LABELS } from '../utils.js';
 import * as vector from '../vector/index.js';
-import * as vectorManager from '../vector/manager.js';
+// vectorManager 已弃用，向量索引由 Tauri 后端自动维护
 import { wrap, fetchRelations, mergeSearchResults, formatNodeMarkdown, formatRelationsMarkdown, buildDirectoryTree, formatTreeText, countTreeNodes } from './helpers.js';
 export function registerTools(server, projectId, _user) {
     // 1. 创建节点
@@ -35,27 +35,13 @@ export function registerTools(server, projectId, _user) {
             dependencies: decoded.dependencies || [],
             relatedFiles: decoded.relatedFiles || []
         });
-        // 自动更新向量索引
-        try {
-            await vector.upsertNode(projectId, node.id, node.title, node.description, node.categories);
-        }
-        catch (e) {
-            console.warn('[kg_create_node] Vector index update failed:', e);
-        }
+        // 向量索引由 Tauri 后端自动维护，MCP 不再手动更新
         return wrap(JSON.stringify(node, null, 2));
     });
     // 2. 删除节点
     server.tool('kg_delete_node', '删除节点(锁定节点和根节点不可删除)', { nodeId: z.string().describe('节点ID') }, async (args) => {
         const success = await storage.deleteNode(projectId, args.nodeId);
-        // 同步删除向量索引
-        if (success) {
-            try {
-                await vector.removeNode(projectId, args.nodeId);
-            }
-            catch (e) {
-                console.warn('[kg_delete_node] Vector index removal failed:', e);
-            }
-        }
+        // 向量索引由 Tauri 后端自动维护，MCP 不再手动删除
         return wrap(success ? '删除成功' : '删除失败(节点不存在/已锁定/是根节点)');
     });
     // 3. 更新节点
@@ -110,15 +96,7 @@ export function registerTools(server, projectId, _user) {
         if (lastSyncAt !== undefined)
             updates.lastSyncAt = lastSyncAt;
         const node = await storage.updateNode(projectId, nodeId, updates);
-        // 自动更新向量索引 (标题或描述变更时)
-        if (node && (rest.title || rest.description || tags)) {
-            try {
-                await vector.upsertNode(projectId, node.id, node.title, node.description, node.categories);
-            }
-            catch (e) {
-                console.warn('[kg_update_node] Vector index update failed:', e);
-            }
-        }
+        // 向量索引由 Tauri 后端自动维护，MCP 不再手动更新
         return wrap(node ? JSON.stringify(node, null, 2) : '更新失败(节点不存在或已锁定)');
     });
     // 3.5 更新根节点 (项目介绍)
@@ -207,8 +185,7 @@ export function registerTools(server, projectId, _user) {
         let semanticResults = [];
         if (mode === 'hybrid' || mode === 'semantic') {
             try {
-                // 自动检测索引状态，缺失/不匹配则自动构建
-                await vectorManager.ensureIndex(projectId);
+                // 向量索引由 Tauri 后端自动维护，MCP 直接读取
                 const rawSemantic = await vector.semanticSearch(projectId, query, limit * 2);
                 // 补全节点信息 (关键词结果中已有的复用，没有的获取)
                 const keywordMap = new Map(keywordResults.map(r => [r.id, r]));
@@ -241,18 +218,6 @@ export function registerTools(server, projectId, _user) {
         const json = JSON.stringify(output, null, 2);
         return wrap(`${json}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情\n🔍 搜索模式: ${mode}`);
     });
-    // 5.5 列出所有标签
-    server.tool('kg_list_tags', '获取所有节点使用过的标签列表(去重)', {}, async () => {
-        const nodes = await storage.listNodes(projectId);
-        const tagSet = new Set();
-        for (const node of nodes) {
-            if (node.categories && Array.isArray(node.categories)) {
-                node.categories.forEach(cat => tagSet.add(cat));
-            }
-        }
-        const tags = Array.from(tagSet).sort();
-        return wrap(JSON.stringify({ total: tags.length, tags }, null, 2));
-    });
     // 6. 路径查找
     server.tool('kg_find_path', '查找两节点间的依赖路径', {
         startId: z.string().describe('起点节点ID'),
@@ -438,22 +403,13 @@ export function registerTools(server, projectId, _user) {
         return wrap(JSON.stringify(result, null, 2));
     });
     // ===================== 向量索引管理 =====================
-    // 16. 构建向量索引
-    server.tool('kg_build_index', '构建/重建向量语义索引(首次使用或索引损坏时调用)', {}, async () => {
-        const count = await vectorManager.rebuildIndex(projectId);
-        return wrap(`✅ 向量索引构建完成，共 ${count} 个节点`);
-    });
-    // 17. 查看索引状态
+    // 注意: 向量索引由 Tauri 后端自动维护，MCP 只提供只读查询
+    // 16. 查看索引状态 (只读)
     server.tool('kg_index_stats', '查看向量索引状态', {}, async () => {
         const stats = await vector.getIndexStats(projectId);
-        const rebuildCheck = await vectorManager.needsRebuild(projectId);
         return wrap(JSON.stringify({
             ...stats,
-            needsRebuild: rebuildCheck.needed,
-            rebuildReason: rebuildCheck.reason,
-            tip: rebuildCheck.needed
-                ? `索引需要重建，原因: ${rebuildCheck.reason}`
-                : '索引正常 (搜索时会自动检测并重建)'
+            tip: '向量索引由软件端自动维护，节点增删改时自动更新'
         }, null, 2));
     });
 }

package/dist/vector/manager.d.ts

@@ -1,11 +1,16 @@
 /**
- * 向量索引管理器
- * 负责自动检测、重建索引逻辑
- * @version 0.1
+ * 向量索引管理器 (已弃用)
+ *
+ * ⚠️ 自 v2.7.0 起，向量索引由 Tauri 后端自动维护
+ * 此模块保留仅用于向后兼容，不再被主动调用
+ *
+ * @deprecated 请使用 Tauri 后端的 vector 模块
+ * @version 0.2
  */
 interface RebuildReason {
     needed: boolean;
-    reason: 'missing' | 'model_mismatch' | 'empty' | 'none';
+    reason: 'missing' | 'model_mismatch' | 'empty' | 'count_mismatch' | 'none';
+    missingCount?: number;
 }
 interface RebuildResult {
     projectId: string;
@@ -21,7 +26,11 @@ export declare function needsRebuild(projectId: string): Promise<RebuildReason>;
  */
 export declare function rebuildIndex(projectId: string): Promise<number>;
 /**
- * 确保索引存在 (自动检测 + 按需构建)
+ * 增量同步缺失节点 (仅补漏，不全量重建)
+ */
+export declare function syncMissingNodes(projectId: string): Promise<number>;
+/**
+ * 确保索引存在 (自动检测 + 按需构建/增量补漏)
  */
 export declare function ensureIndex(projectId: string): Promise<void>;
 /**

package/dist/vector/manager.js

@@ -1,12 +1,46 @@
 /**
- * 向量索引管理器
- * 负责自动检测、重建索引逻辑
- * @version 0.1
+ * 向量索引管理器 (已弃用)
+ *
+ * ⚠️ 自 v2.7.0 起，向量索引由 Tauri 后端自动维护
+ * 此模块保留仅用于向后兼容，不再被主动调用
+ *
+ * @deprecated 请使用 Tauri 后端的 vector 模块
+ * @version 0.2
  */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as vectorCore from './index.js';
 // ==================== 检测函数 ====================
+/**
+ * 获取节点目录下的节点ID列表
+ */
+function getNodeIdsFromDisk(projectId) {
+    const baseDir = process.env.PPDOCS_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE || '', '.ppdocs');
+    const nodesDir = path.join(baseDir, 'projects', projectId, 'nodes');
+    const nodeIds = new Set();
+    if (!fs.existsSync(nodesDir))
+        return nodeIds;
+    try {
+        const files = fs.readdirSync(nodesDir).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(nodesDir, file), 'utf-8');
+                const node = JSON.parse(content);
+                // 跳过根节点
+                if (node.isOrigin || node.id === 'root')
+                    continue;
+                nodeIds.add(node.id);
+            }
+            catch {
+                // 跳过无法解析的文件
+            }
+        }
+    }
+    catch {
+        // 忽略读取错误
+    }
+    return nodeIds;
+}
 /**
  * 检测索引是否需要重建
  */
@@ -28,6 +62,13 @@ export async function needsRebuild(projectId) {
         if (!data.entries || data.entries.length === 0) {
             return { needed: true, reason: 'empty' };
         }
+        // 5. 检测节点数量不匹配 (新增)
+        const diskNodeIds = getNodeIdsFromDisk(projectId);
+        const indexedIds = new Set(data.entries.map(e => e.id));
+        const missingIds = [...diskNodeIds].filter(id => !indexedIds.has(id));
+        if (missingIds.length > 0) {
+            return { needed: true, reason: 'count_mismatch', missingCount: missingIds.length };
+        }
         return { needed: false, reason: 'none' };
     }
     catch {
@@ -87,11 +128,54 @@ export async function rebuildIndex(projectId) {
     return vectorCore.buildIndex(projectId, nodes);
 }
 /**
- * 确保索引存在 (自动检测 + 按需构建)
+ * 增量同步缺失节点 (仅补漏，不全量重建)
+ */
+export async function syncMissingNodes(projectId) {
+    const indexPath = vectorCore.getIndexPath(projectId);
+    // 读取当前索引
+    let indexedIds = new Set();
+    try {
+        if (fs.existsSync(indexPath)) {
+            const data = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+            indexedIds = new Set(data.entries.map(e => e.id));
+        }
+    }
+    catch {
+        // 索引损坏，需要全量重建
+        return rebuildIndex(projectId);
+    }
+    // 找出缺失的节点
+    const allNodes = await fetchNodesForIndex(projectId);
+    const missingNodes = allNodes.filter(n => !indexedIds.has(n.id));
+    if (missingNodes.length === 0) {
+        console.log(`[VectorManager] No missing nodes to sync`);
+        return 0;
+    }
+    console.log(`[VectorManager] Syncing ${missingNodes.length} missing nodes...`);
+    // 增量添加缺失节点
+    for (let i = 0; i < missingNodes.length; i++) {
+        const node = missingNodes[i];
+        await vectorCore.upsertNode(projectId, node.id, node.title, node.description, node.categories || []);
+        if ((i + 1) % 10 === 0) {
+            console.log(`[VectorManager] Synced ${i + 1}/${missingNodes.length}`);
+        }
+    }
+    console.log(`[VectorManager] Sync complete: ${missingNodes.length} nodes added`);
+    return missingNodes.length;
+}
+/**
+ * 确保索引存在 (自动检测 + 按需构建/增量补漏)
  */
 export async function ensureIndex(projectId) {
     const check = await needsRebuild(projectId);
-    if (check.needed) {
+    if (!check.needed)
+        return;
+    // count_mismatch 使用增量补漏，其他情况全量重建
+    if (check.reason === 'count_mismatch') {
+        console.log(`[VectorManager] Auto-syncing ${check.missingCount} missing nodes`);
+        await syncMissingNodes(projectId);
+    }
+    else {
         console.log(`[VectorManager] Auto-rebuilding index, reason: ${check.reason}`);
         await rebuildIndex(projectId);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ppdocs/mcp",
-  "version": "2.6.29",
+  "version": "2.6.31",
   "description": "ppdocs MCP Server - Knowledge Graph for Claude",
   "type": "module",
   "main": "dist/index.js",