@ppdocs/mcp 2.7.1 → 2.8.0

package/dist/storage/types.d.ts

@@ -1,99 +1,62 @@
-export type EdgeType = 'contains' | 'uses' | 'extends' | 'implements';
-export interface Edge {
-    source: string;
-    target: string;
-    type: EdgeType;
-    auto?: boolean;
-}
-export type NodeType = 'logic' | 'data' | 'intro';
-export type NodeStatus = 'incomplete' | 'complete' | 'fixing' | 'refactoring' | 'deprecated';
-export interface DataRef {
-    type: string;
-    description: string;
-    formatPath?: string;
-}
-export interface Dependency {
-    name: string;
-    description: string;
-    nodePath?: string;
-}
+/** 版本记录 */
 export interface VersionRecord {
     version: number;
     date: string;
     changes: string;
 }
+/** 错误修复记录 */
 export interface BugfixRecord {
-    id: string;
     date: string;
     issue: string;
     solution: string;
-    impact?: string;
 }
-export interface NodeData {
-    id: string;
-    title: string;
-    type: NodeType;
-    status: NodeStatus;
-    x: number;
-    y: number;
-    locked: boolean;
-    isOrigin?: boolean;
-    signature: string;
-    categories: string[];
+/** 文档数据 (4个核心字段) */
+export interface DocData {
+    summary: string;
+    content: string;
+    versions: VersionRecord[];
+    bugfixes: BugfixRecord[];
+}
+/** 文档节点 (含路径信息，用于列表展示) */
+export interface DocNode {
     path: string;
-    description: string;
-    summary?: string;
-    dataInput?: DataRef;
-    dataOutput?: DataRef;
-    dependencies: Dependency[];
-    relatedFiles?: string[];
-    userStyles?: string[];
-    testRules?: string[];
-    reviewRules?: string[];
-    codeStyle?: string[];
-    unitTests?: string[];
-    createdAt?: string;
-    updatedAt?: string;
-    lastAccessedAt?: string;
-    lastSyncAt?: string;
-    versions?: VersionRecord[];
-    bugfixes?: BugfixRecord[];
+    name: string;
+    summary: string;
+    isDir: boolean;
+}
+/** 文档搜索结果 */
+export interface DocSearchResult {
+    path: string;
+    name: string;
+    summary: string;
+    score: number;
 }
 export interface ProjectMeta {
     projectId: string;
     projectName: string;
     updatedAt: string;
-    edges: Edge[];
+    password?: string;
 }
 export interface Project {
     id: string;
     name: string;
+    description?: string;
     updatedAt: string;
 }
-export interface SearchResult {
-    node: NodeData;
-    score: number;
-    matches: string[];
-}
-export interface PathResult {
-    path: NodeData[];
-    edges: Edge[];
-}
 export type TaskLogType = 'progress' | 'issue' | 'solution' | 'reference';
 export interface TaskLog {
     time: string;
     log_type: TaskLogType;
     content: string;
 }
-export interface TaskReference {
-    title: string;
-    url?: string;
-}
 export interface TaskExperience {
     summary: string;
     difficulties: string[];
     solutions: string[];
-    references: TaskReference[];
+    references: Array<{
+        title: string;
+        url?: string;
+    }>;
 }
 export interface TaskDetail {
     description: string;

package/dist/storage/types.js

@@ -1,2 +1,2 @@
-// 知识图谱类型定义 - 与 UI 和 Tauri 后端保持同步
+// ppdocs - 文档类型定义 (简化版)
 export {};

package/dist/tools/helpers.d.ts

@@ -1,8 +1,7 @@
 /**
  * MCP 工具辅助函数
- * 提取自 index.ts，避免重复代码
  */
-import type { NodeData } from '../storage/types.js';
+import type { DocData } from '../storage/types.js';
 /**
  * 包装返回结果为 MCP 格式
  */
@@ -12,43 +11,23 @@ export declare function wrap(text: string): {
         text: string;
     }[];
 };
-interface RelationItem {
-    id: string;
-    title: string;
-    edge: string;
-}
-/**
- * 递归获取节点的上下游关系
- */
-export declare function fetchRelations(projectId: string, nodeId: string, maxDepth: number): Promise<{
-    outgoing: RelationItem[];
-    incoming: RelationItem[];
-}>;
 /**
- * 格式化节点为 Markdown 输出
+ * 格式化文档为 Markdown 输出
  */
-export declare function formatNodeMarkdown(node: NodeData): string[];
-/**
- * 格式化关系输出
- */
-export declare function formatRelationsMarkdown(outgoing: RelationItem[], incoming: RelationItem[]): string[];
+export declare function formatDocMarkdown(doc: DocData, path: string): string[];
 interface TreeNode {
+    path: string;
     name: string;
-    type: 'folder' | 'node';
-    nodeId?: string;
-    status?: string;
+    summary?: string;
+    isDir: boolean;
     children?: TreeNode[];
 }
-/**
- * 构建目录树结构
- */
-export declare function buildDirectoryTree(nodes: NodeData[]): TreeNode;
 /**
  * 格式化树为文本
  */
-export declare function formatTreeText(tree: TreeNode): string;
+export declare function formatTreeText(tree: TreeNode[]): string;
 /**
- * 统计树中的节点数
+ * 统计树中的文档数
  */
-export declare function countTreeNodes(tree: TreeNode): number;
+export declare function countTreeDocs(tree: TreeNode[]): number;
 export {};

package/dist/tools/helpers.js

@@ -1,8 +1,6 @@
 /**
  * MCP 工具辅助函数
- * 提取自 index.ts，避免重复代码
  */
-import * as storage from '../storage/httpClient.js';
 // ==================== 通用包装 ====================
 /**
  * 包装返回结果为 MCP 格式
@@ -10,196 +8,74 @@ import * as storage from '../storage/httpClient.js';
 export function wrap(text) {
     return { content: [{ type: 'text', text }] };
 }
+// ==================== 文档格式化 ====================
 /**
- * 递归获取节点的上下游关系
+ * 格式化文档为 Markdown 输出
  */
-export async function fetchRelations(projectId, nodeId, maxDepth) {
-    const visited = new Set();
-    const outgoing = [];
-    const incoming = [];
-    async function recurse(currentNodeId, currentDepth, direction) {
-        if (currentDepth > maxDepth || visited.has(`${currentNodeId}-${direction}`))
-            return;
-        visited.add(`${currentNodeId}-${direction}`);
-        const relations = await storage.getRelations(projectId, currentNodeId);
-        for (const r of relations) {
-            if (r.direction === 'outgoing' && (direction === 'outgoing' || direction === 'both')) {
-                if (!outgoing.some(o => o.id === r.nodeId)) {
-                    outgoing.push({ id: r.nodeId, title: r.title, edge: r.edgeType });
-                    await recurse(r.nodeId, currentDepth + 1, 'outgoing');
-                }
-            }
-            if (r.direction === 'incoming' && (direction === 'incoming' || direction === 'both')) {
-                if (!incoming.some(i => i.id === r.nodeId)) {
-                    incoming.push({ id: r.nodeId, title: r.title, edge: r.edgeType });
-                    await recurse(r.nodeId, currentDepth + 1, 'incoming');
-                }
-            }
-        }
-    }
-    await recurse(nodeId, 1, 'both');
-    return { outgoing, incoming };
-}
-// ==================== 节点格式化 ====================
-/**
- * 格式化节点为 Markdown 输出
- */
-export function formatNodeMarkdown(node) {
+export function formatDocMarkdown(doc, path) {
     const lines = [];
-    // 基础信息
-    lines.push(`## ${node.title}\n`);
-    if (node.summary) {
-        lines.push(`> ${node.summary}\n`);
+    const name = path.split('/').pop() || path;
+    // 标题和简介
+    lines.push(`## ${name}\n`);
+    if (doc.summary) {
+        lines.push(`> ${doc.summary}\n`);
     }
-    lines.push('**基础信息**');
-    lines.push(`| 字段 | 值 |`);
-    lines.push(`|:---|:---|`);
-    lines.push(`| ID | ${node.id} |`);
-    lines.push(`| 类型 | ${node.type} |`);
-    lines.push(`| 状态 | ${node.status} |`);
-    lines.push(`| 签名 | ${node.signature} |`);
-    if (node.categories && node.categories.length > 0) {
-        lines.push(`| 标签 | ${node.categories.join(', ')} |`);
-    }
-    lines.push('');
-    // 关联文件
-    if (node.relatedFiles && node.relatedFiles.length > 0) {
-        lines.push('**关联文件**');
-        node.relatedFiles.forEach((f) => lines.push(`- ${f}`));
-        lines.push('');
-    }
-    // 依赖关系
-    if (node.dependencies && node.dependencies.length > 0) {
-        lines.push('**依赖关系**');
-        node.dependencies.forEach((d) => lines.push(`- ${d.name}: ${d.description}`));
-        lines.push('');
-    }
-    // 描述内容
-    if (node.description) {
-        lines.push('**描述内容**');
-        lines.push(node.description);
+    // 内容
+    if (doc.content) {
+        lines.push('**内容**');
+        lines.push(doc.content);
         lines.push('');
     }
     // 更新历史
-    if (node.versions && node.versions.length > 0) {
+    if (doc.versions && doc.versions.length > 0) {
         lines.push('**更新历史**');
         lines.push('| 版本 | 日期 | 变更 |');
         lines.push('|:---|:---|:---|');
-        node.versions.forEach((v) => lines.push(`| ${v.version} | ${v.date} | ${v.changes} |`));
+        doc.versions.forEach((v) => lines.push(`| ${v.version} | ${v.date} | ${v.changes} |`));
         lines.push('');
     }
     // 修复历史
-    if (node.bugfixes && node.bugfixes.length > 0) {
+    if (doc.bugfixes && doc.bugfixes.length > 0) {
         lines.push('**修复历史**');
-        lines.push('| ID | 日期 | 问题 | 方案 |');
-        lines.push('|:---|:---|:---|:---|');
-        node.bugfixes.forEach((b) => lines.push(`| ${b.id} | ${b.date} | ${b.issue} | ${b.solution} |`));
-        lines.push('');
-    }
-    return lines;
-}
-/**
- * 格式化关系输出
- */
-export function formatRelationsMarkdown(outgoing, incoming) {
-    const lines = [];
-    if (outgoing.length > 0 || incoming.length > 0) {
-        lines.push('**上下游关系**');
-        if (outgoing.length > 0) {
-            lines.push(`- 依赖 (${outgoing.length}): ${outgoing.map(o => o.title).join(', ')}`);
-        }
-        if (incoming.length > 0) {
-            lines.push(`- 被依赖 (${incoming.length}): ${incoming.map(i => i.title).join(', ')}`);
-        }
+        lines.push('| 日期 | 问题 | 方案 |');
+        lines.push('|:---|:---|:---|');
+        doc.bugfixes.forEach((b) => lines.push(`| ${b.date} | ${b.issue} | ${b.solution} |`));
         lines.push('');
     }
     return lines;
 }
-/**
- * 构建目录树结构
- */
-export function buildDirectoryTree(nodes) {
-    const root = { name: '/', type: 'folder', children: [] };
-    // 过滤掉根节点
-    const docNodes = nodes.filter(n => !n.isOrigin && n.id !== 'root');
-    for (const node of docNodes) {
-        const pathSegments = (node.path || '').split('/').filter(Boolean);
-        let current = root;
-        // 遍历路径段，创建目录结构
-        for (const segment of pathSegments) {
-            if (!current.children)
-                current.children = [];
-            let child = current.children.find(c => c.name === segment && c.type === 'folder');
-            if (!child) {
-                child = { name: segment, type: 'folder', children: [] };
-                current.children.push(child);
-            }
-            current = child;
-        }
-        // 添加节点
-        if (!current.children)
-            current.children = [];
-        current.children.push({
-            name: node.title,
-            type: 'node',
-            nodeId: node.id,
-            status: node.status
-        });
-    }
-    // 递归排序 (目录在前，节点在后)
-    sortTree(root);
-    return root;
-}
-function sortTree(node) {
-    if (!node.children)
-        return;
-    node.children.sort((a, b) => {
-        if (a.type === 'folder' && b.type !== 'folder')
-            return -1;
-        if (a.type !== 'folder' && b.type === 'folder')
-            return 1;
-        return a.name.localeCompare(b.name, 'zh-CN');
-    });
-    for (const child of node.children) {
-        if (child.type === 'folder')
-            sortTree(child);
-    }
-}
 /**
  * 格式化树为文本
  */
 export function formatTreeText(tree) {
-    function format(node, prefix = '', isLast = true) {
+    function format(nodes, prefix = '') {
         const lines = [];
-        const connector = isLast ? '└── ' : '├── ';
-        const childPrefix = isLast ? '    ' : '│   ';
-        if (node.name !== '/') {
-            const icon = node.type === 'folder' ? '📁' : '📄';
-            const status = node.status ? ` [${node.status}]` : '';
-            lines.push(`${prefix}${connector}${icon} ${node.name}${status}`);
-        }
-        if (node.children) {
-            for (let i = 0; i < node.children.length; i++) {
-                const child = node.children[i];
-                const childIsLast = i === node.children.length - 1;
-                const newPrefix = node.name === '/' ? '' : prefix + childPrefix;
-                lines.push(...format(child, newPrefix, childIsLast));
+        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 countTreeNodes(tree) {
+export function countTreeDocs(tree) {
     let count = 0;
-    function traverse(node) {
-        if (node.type === 'node')
-            count++;
-        if (node.children) {
-            node.children.forEach(traverse);
+    function traverse(nodes) {
+        for (const node of nodes) {
+            if (!node.isDir)
+                count++;
+            if (node.children)
+                traverse(node.children);
         }
     }
     traverse(tree);