@ppdocs/mcp 3.2.34 → 3.2.36

package/dist/tools/helpers.js

@@ -1,94 +0,0 @@
-/**
- * MCP 工具辅助函数
- */
-// ==================== 通用包装 ====================
-/**
- * 包装返回结果为 MCP 格式
- */
-export function wrap(text) {
-    return { content: [{ type: 'text', text }] };
-}
-// ==================== 文档格式化 ====================
-/**
- * 格式化文档为 Markdown 输出
- */
-export function formatDocMarkdown(doc, path) {
-    const lines = [];
-    const name = path.split('/').pop() || path;
-    // 标题和简介
-    lines.push(`## ${name}\n`);
-    if (doc.summary) {
-        lines.push(`> ${doc.summary}\n`);
-    }
-    // 内容
-    if (doc.content) {
-        lines.push('**内容**');
-        lines.push(doc.content);
-        lines.push('');
-    }
-    // 更新历史
-    if (doc.versions && doc.versions.length > 0) {
-        lines.push('**更新历史**');
-        lines.push('| 版本 | 日期 | 变更 |');
-        lines.push('|:---|:---|:---|');
-        doc.versions.forEach((v) => lines.push(`| ${v.version} | ${v.date} | ${v.changes} |`));
-        lines.push('');
-    }
-    // 修复历史
-    if (doc.bugfixes && doc.bugfixes.length > 0) {
-        lines.push('**修复历史**');
-        lines.push('| 日期 | 问题 | 方案 |');
-        lines.push('|:---|:---|:---|');
-        doc.bugfixes.forEach((b) => lines.push(`| ${b.date} | ${b.issue} | ${b.solution} |`));
-        lines.push('');
-    }
-    return lines;
-}
-/**
- * 格式化树为文本
- */
-export function formatTreeText(tree) {
-    function format(nodes, prefix = '') {
-        const lines = [];
-        nodes.forEach((node, index) => {
-            const isLast = index === nodes.length - 1;
-            const connector = isLast ? '└── ' : '├── ';
-            const childPrefix = isLast ? '    ' : '│   ';
-            const icon = node.isDir ? '📁' : '📄';
-            const summary = node.summary ? ` # ${node.summary}` : '';
-            lines.push(`${prefix}${connector}${icon} ${node.name}${summary}`);
-            if (node.children && node.children.length > 0) {
-                lines.push(...format(node.children, prefix + childPrefix));
-            }
-        });
-        return lines;
-    }
-    return format(tree).join('\n');
-}
-/**
- * 统计树中的文档数
- */
-export function countTreeDocs(tree) {
-    let count = 0;
-    function traverse(nodes) {
-        for (const node of nodes) {
-            if (!node.isDir)
-                count++;
-            if (node.children)
-                traverse(node.children);
-        }
-    }
-    traverse(tree);
-    return count;
-}
-// ==================== 文件大小格式化 ====================
-/**
- * 格式化文件大小
- */
-export function formatFileSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
-}

package/dist/vector/index.d.ts

@@ -1,56 +0,0 @@
-/**
- * 向量检索服务 - 基于 transformers.js 的语义搜索
- * @version 0.2
- */
-interface VectorConfig {
-    model: string;
-    quantized: boolean;
-}
-/**
- * 获取向量配置 (从 ~/.ppdocs/config/vector.json 读取)
- */
-export declare function getVectorConfig(): VectorConfig;
-interface VectorSearchResult {
-    id: string;
-    title: string;
-    similarity: number;
-}
-/**
- * 获取索引文件路径
- */
-export declare function getIndexPath(projectId: string): string;
-/**
- * 添加或更新节点向量
- */
-export declare function upsertNode(projectId: string, nodeId: string, title: string, description: string, categories?: string[]): Promise<void>;
-/**
- * 删除节点向量
- */
-export declare function removeNode(projectId: string, nodeId: string): Promise<void>;
-/**
- * 向量语义搜索
- */
-export declare function semanticSearch(projectId: string, query: string, limit?: number): Promise<VectorSearchResult[]>;
-/**
- * 批量构建索引 (用于初始化或重建)
- */
-export declare function buildIndex(projectId: string, nodes: Array<{
-    id: string;
-    title: string;
-    description: string;
-    categories?: string[];
-}>): Promise<number>;
-/**
- * 检查索引状态
- */
-export declare function getIndexStats(projectId: string): Promise<{
-    count: number;
-    model: string;
-    dimension: number;
-    loaded: boolean;
-}>;
-/**
- * 预加载模型 (可选, 用于启动时预热)
- */
-export declare function preloadModel(): Promise<void>;
-export {};

package/dist/vector/index.js

@@ -1,228 +0,0 @@
-/**
- * 向量检索服务 - 基于 transformers.js 的语义搜索
- * @version 0.2
- */
-import { pipeline } from '@xenova/transformers';
-import * as fs from 'fs';
-import * as path from 'path';
-// 默认模型配置
-const DEFAULT_MODEL = 'Xenova/multilingual-e5-small';
-const VECTOR_DIM = 384;
-// 当前加载的模型名
-let currentModel = null;
-/**
- * 获取向量配置 (从 ~/.ppdocs/config/vector.json 读取)
- */
-export function getVectorConfig() {
-    const baseDir = process.env.PPDOCS_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE || '', '.ppdocs');
-    const configPath = path.join(baseDir, 'config', 'vector.json');
-    try {
-        if (fs.existsSync(configPath)) {
-            const content = fs.readFileSync(configPath, 'utf-8');
-            return JSON.parse(content);
-        }
-    }
-    catch (e) {
-        console.warn('[Vector] Failed to load config:', e);
-    }
-    return { model: DEFAULT_MODEL, quantized: true };
-}
-// 单例模式
-let extractor = null;
-let isLoading = false;
-let loadPromise = null;
-// 内存索引 (projectId -> entries)
-const vectorIndex = new Map();
-/**
- * 加载嵌入模型 (懒加载, 首次调用时下载)
- */
-async function getExtractor() {
-    const config = getVectorConfig();
-    // 如果模型变更，重新加载
-    if (extractor && currentModel === config.model) {
-        return extractor;
-    }
-    if (isLoading && loadPromise && currentModel === config.model) {
-        return loadPromise;
-    }
-    isLoading = true;
-    currentModel = config.model;
-    console.log(`[Vector] Loading embedding model: ${config.model}...`);
-    loadPromise = pipeline('feature-extraction', config.model, {
-        quantized: config.quantized,
-    });
-    extractor = await loadPromise;
-    isLoading = false;
-    console.log('[Vector] Model loaded successfully');
-    return extractor;
-}
-/**
- * 文本转向量
- */
-async function embed(text) {
-    const ext = await getExtractor();
-    const output = await ext(text, { pooling: 'mean', normalize: true });
-    return Array.from(output.data);
-}
-/**
- * 计算余弦相似度
- */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length)
-        return 0;
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
-        dotProduct += a[i] * b[i];
-        normA += a[i] * a[i];
-        normB += b[i] * b[i];
-    }
-    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-    return magnitude === 0 ? 0 : dotProduct / magnitude;
-}
-/**
- * 获取索引文件路径
- */
-export function getIndexPath(projectId) {
-    const baseDir = process.env.PPDOCS_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE || '', '.ppdocs');
-    return path.join(baseDir, 'projects', projectId, 'vector-index.json');
-}
-/**
- * 加载持久化索引
- */
-async function loadIndex(projectId) {
-    // 先检查内存
-    if (vectorIndex.has(projectId)) {
-        return vectorIndex.get(projectId);
-    }
-    // 尝试从文件加载
-    const indexPath = getIndexPath(projectId);
-    try {
-        if (fs.existsSync(indexPath)) {
-            const data = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-            vectorIndex.set(projectId, data.entries || []);
-            console.log(`[Vector] Loaded ${data.entries?.length || 0} entries from disk`);
-            return data.entries || [];
-        }
-    }
-    catch (e) {
-        console.warn('[Vector] Failed to load index:', e);
-    }
-    vectorIndex.set(projectId, []);
-    return [];
-}
-/**
- * 保存索引到磁盘
- */
-async function saveIndex(projectId) {
-    const entries = vectorIndex.get(projectId) || [];
-    const indexPath = getIndexPath(projectId);
-    try {
-        const dir = path.dirname(indexPath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        const config = getVectorConfig();
-        fs.writeFileSync(indexPath, JSON.stringify({
-            version: 1,
-            model: config.model,
-            dimension: VECTOR_DIM,
-            updatedAt: new Date().toISOString(),
-            entries
-        }, null, 2));
-        console.log(`[Vector] Saved ${entries.length} entries to disk`);
-    }
-    catch (e) {
-        console.warn('[Vector] Failed to save index:', e);
-    }
-}
-/**
- * 添加或更新节点向量
- */
-export async function upsertNode(projectId, nodeId, title, description, categories = []) {
-    const entries = await loadIndex(projectId);
-    // 合并可搜索文本
-    const searchableText = `${title} ${description} ${categories.join(' ')}`;
-    const embedding = await embed(searchableText);
-    // 查找现有条目
-    const existingIndex = entries.findIndex(e => e.id === nodeId);
-    const entry = { id: nodeId, title, embedding };
-    if (existingIndex >= 0) {
-        entries[existingIndex] = entry;
-    }
-    else {
-        entries.push(entry);
-    }
-    vectorIndex.set(projectId, entries);
-    await saveIndex(projectId);
-}
-/**
- * 删除节点向量
- */
-export async function removeNode(projectId, nodeId) {
-    const entries = await loadIndex(projectId);
-    const filtered = entries.filter(e => e.id !== nodeId);
-    vectorIndex.set(projectId, filtered);
-    await saveIndex(projectId);
-}
-/**
- * 向量语义搜索
- */
-export async function semanticSearch(projectId, query, limit = 10) {
-    const entries = await loadIndex(projectId);
-    if (entries.length === 0) {
-        console.log('[Vector] Index is empty, skipping semantic search');
-        return [];
-    }
-    // 查询向量化
-    const queryEmbedding = await embed(query);
-    // 计算相似度
-    const results = entries.map(entry => ({
-        id: entry.id,
-        title: entry.title,
-        similarity: cosineSimilarity(queryEmbedding, entry.embedding)
-    }));
-    // 排序并返回 top-k
-    results.sort((a, b) => b.similarity - a.similarity);
-    return results.slice(0, limit);
-}
-/**
- * 批量构建索引 (用于初始化或重建)
- */
-export async function buildIndex(projectId, nodes) {
-    console.log(`[Vector] Building index for ${nodes.length} nodes...`);
-    const entries = [];
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        const searchableText = `${node.title} ${node.description} ${(node.categories || []).join(' ')}`;
-        const embedding = await embed(searchableText);
-        entries.push({ id: node.id, title: node.title, embedding });
-        if ((i + 1) % 10 === 0) {
-            console.log(`[Vector] Processed ${i + 1}/${nodes.length}`);
-        }
-    }
-    vectorIndex.set(projectId, entries);
-    await saveIndex(projectId);
-    console.log(`[Vector] Index built with ${entries.length} entries`);
-    return entries.length;
-}
-/**
- * 检查索引状态
- */
-export async function getIndexStats(projectId) {
-    const entries = await loadIndex(projectId);
-    const config = getVectorConfig();
-    return {
-        count: entries.length,
-        model: config.model,
-        dimension: VECTOR_DIM,
-        loaded: extractor !== null
-    };
-}
-/**
- * 预加载模型 (可选, 用于启动时预热)
- */
-export async function preloadModel() {
-    await getExtractor();
-}

package/dist/vector/manager.d.ts

@@ -1,48 +0,0 @@
-/**
- * 向量索引管理器 (已弃用)
- *
- * ⚠️ 自 v2.7.0 起，向量索引由 Tauri 后端自动维护
- * 此模块保留仅用于向后兼容，不再被主动调用
- *
- * @deprecated 请使用 Tauri 后端的 vector 模块
- * @version 0.2
- */
-interface RebuildReason {
-    needed: boolean;
-    reason: 'missing' | 'model_mismatch' | 'empty' | 'count_mismatch' | 'none';
-    missingCount?: number;
-}
-interface RebuildResult {
-    projectId: string;
-    count: number;
-    reason: string;
-}
-/**
- * 检测索引是否需要重建
- */
-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>;
-/**
- * 重建所有项目索引
- */
-export declare function rebuildAllIndexes(): Promise<RebuildResult[]>;
-/**
- * 获取所有项目的索引状态
- */
-export declare function getAllIndexStats(): Promise<Array<{
-    projectId: string;
-    status: RebuildReason;
-    nodeCount: number;
-}>>;
-export {};

package/dist/vector/manager.js

@@ -1,250 +0,0 @@
-/**
- * 向量索引管理器 (已弃用)
- *
- * ⚠️ 自 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;
-}
-/**
- * 检测索引是否需要重建
- */
-export async function needsRebuild(projectId) {
-    const indexPath = vectorCore.getIndexPath(projectId);
-    const config = vectorCore.getVectorConfig();
-    // 1. 索引文件不存在
-    if (!fs.existsSync(indexPath)) {
-        return { needed: true, reason: 'missing' };
-    }
-    // 2. 读取索引元数据
-    try {
-        const data = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
-        // 3. 模型不匹配
-        if (data.model !== config.model) {
-            return { needed: true, reason: 'model_mismatch' };
-        }
-        // 4. 索引为空
-        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 {
-        // 读取失败视为需要重建
-        return { needed: true, reason: 'missing' };
-    }
-}
-// ==================== 重建函数 ====================
-/**
- * 获取节点数据 (用于重建索引)
- */
-async function fetchNodesForIndex(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');
-    if (!fs.existsSync(nodesDir)) {
-        console.log(`[VectorManager] No nodes directory found for project ${projectId}`);
-        return [];
-    }
-    const nodes = [];
-    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;
-                nodes.push({
-                    id: node.id,
-                    title: node.title || '',
-                    description: node.description || '',
-                    categories: node.categories || node.tags || []
-                });
-            }
-            catch {
-                // 跳过无法解析的文件
-            }
-        }
-    }
-    catch (e) {
-        console.warn(`[VectorManager] Failed to read nodes:`, e);
-    }
-    return nodes;
-}
-/**
- * 强制重建项目索引
- */
-export async function rebuildIndex(projectId) {
-    console.log(`[VectorManager] Rebuilding index for project: ${projectId}`);
-    const nodes = await fetchNodesForIndex(projectId);
-    if (nodes.length === 0) {
-        console.log(`[VectorManager] No nodes to index`);
-        return 0;
-    }
-    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)
-        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);
-    }
-}
-// ==================== 批量操作 ====================
-/**
- * 获取所有项目 ID
- */
-function listAllProjects() {
-    const baseDir = process.env.PPDOCS_DATA_DIR || path.join(process.env.HOME || process.env.USERPROFILE || '', '.ppdocs');
-    const projectsDir = path.join(baseDir, 'projects');
-    if (!fs.existsSync(projectsDir)) {
-        return [];
-    }
-    try {
-        return fs.readdirSync(projectsDir)
-            .filter(name => {
-            const stat = fs.statSync(path.join(projectsDir, name));
-            return stat.isDirectory() && name.startsWith('project-');
-        });
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * 重建所有项目索引
- */
-export async function rebuildAllIndexes() {
-    const projects = listAllProjects();
-    console.log(`[VectorManager] Rebuilding indexes for ${projects.length} projects...`);
-    const results = [];
-    for (const projectId of projects) {
-        try {
-            const check = await needsRebuild(projectId);
-            const count = await rebuildIndex(projectId);
-            results.push({
-                projectId,
-                count,
-                reason: check.reason
-            });
-            console.log(`[VectorManager] Project ${projectId}: ${count} nodes indexed`);
-        }
-        catch (e) {
-            console.error(`[VectorManager] Failed to rebuild ${projectId}:`, e);
-            results.push({
-                projectId,
-                count: 0,
-                reason: 'error'
-            });
-        }
-    }
-    console.log(`[VectorManager] All indexes rebuilt`);
-    return results;
-}
-/**
- * 获取所有项目的索引状态
- */
-export async function getAllIndexStats() {
-    const projects = listAllProjects();
-    const stats = [];
-    for (const projectId of projects) {
-        const status = await needsRebuild(projectId);
-        const indexStats = await vectorCore.getIndexStats(projectId);
-        stats.push({
-            projectId,
-            status,
-            nodeCount: indexStats.count
-        });
-    }
-    return stats;
-}