@ppdocs/mcp 2.7.1 → 2.8.0

package/dist/storage/httpClient.d.ts

@@ -4,129 +4,55 @@
  *
  * API URL 格式: http://localhost:20001/api/:projectId/:password/...
  */
-import type { NodeData, SearchResult, PathResult, BugfixRecord, Task, TaskSummary, TaskLogType, TaskExperience } from './types.js';
-export interface ListNodesFilter {
-    status?: 'incomplete' | 'complete' | 'fixing' | 'refactoring' | 'deprecated';
-    minEdges?: number;
-    maxEdges?: number;
+import type { DocData, DocNode, DocSearchResult, Task, TaskSummary, TaskLogType, TaskExperience } from './types.js';
+interface TreeNode {
+    path: string;
+    name: string;
+    summary?: string;
+    isDir: boolean;
+    children?: TreeNode[];
 }
 export declare class PpdocsApiClient {
     private baseUrl;
     constructor(apiUrl: string);
     private request;
-    listNodes(filter?: ListNodesFilter): Promise<NodeData[]>;
-    getNode(nodeId: string): Promise<NodeData | null>;
-    createNode(node: Partial<NodeData>): Promise<NodeData>;
-    updateNode(nodeId: string, updates: Partial<NodeData>): Promise<NodeData | null>;
-    updateRoot(updates: {
-        title?: string;
-        description?: string;
-        userStyles?: string[];
-        testRules?: string[];
-        reviewRules?: string[];
-        codeStyle?: string[];
-    }): Promise<NodeData | null>;
-    deleteNode(nodeId: string): Promise<boolean>;
-    lockNode(nodeId: string, locked: boolean): Promise<NodeData | null>;
-    searchNodes(keywords: string[], limit?: number): Promise<SearchResult[]>;
-    findPath(startId: string, endId: string): Promise<PathResult | null>;
-    getRelations(nodeId: string): Promise<Array<{
-        nodeId: string;
-        title: string;
-        description: string;
-        edgeType: string;
-        direction: 'outgoing' | 'incoming';
-    }>>;
-    addBugfix(nodeId: string, bugfix: {
-        issue: string;
-        solution: string;
-        impact?: string;
-    }): Promise<BugfixRecord | null>;
+    listDocs(): Promise<DocNode[]>;
+    getDoc(docPath: string): Promise<DocData | null>;
+    createDoc(docPath: string, doc: Partial<DocData>): Promise<DocData>;
+    updateDoc(docPath: string, updates: Partial<DocData>): Promise<DocData | null>;
+    deleteDoc(docPath: string): Promise<boolean>;
+    searchDocs(keywords: string[], limit?: number): Promise<DocSearchResult[]>;
+    /** 获取目录树结构 */
+    getTree(): Promise<TreeNode[]>;
+    getRulesApi(ruleType: string): Promise<string[]>;
+    saveRulesApi(ruleType: string, rules: string[]): Promise<boolean>;
     listTasks(status?: 'active' | 'archived'): Promise<TaskSummary[]>;
     getTask(taskId: string): Promise<Task | null>;
     createTask(task: {
         title: string;
         description: string;
         goals: string[];
-        related_nodes?: string[];
     }, creator: string): Promise<Task>;
     addTaskLog(taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
     completeTask(taskId: string, experience: TaskExperience): Promise<Task | null>;
-    getRulesApi(ruleType: string): Promise<string[]>;
-    saveRulesApi(ruleType: string, rules: string[]): Promise<boolean>;
-    vectorSearch(query: string, limit: number, mode: string): Promise<Array<{
-        id: string;
-        title: string;
-        score: number;
-        match_type: string;
-        keyword_score: number;
-        semantic_score: number;
-    }>>;
-    vectorStats(): Promise<{
-        model_downloaded: boolean;
-        model_loaded: boolean;
-        model_path: string;
-        index_count: number;
-    }>;
 }
 export declare function initClient(apiUrl: string): void;
-export declare function listNodes(_projectId: string, filter?: ListNodesFilter): Promise<NodeData[]>;
-export declare function getNode(_projectId: string, nodeId: string): Promise<NodeData | null>;
-export declare function createNode(_projectId: string, node: Partial<NodeData>): Promise<NodeData>;
-export declare function updateNode(_projectId: string, nodeId: string, updates: Partial<NodeData>): Promise<NodeData | null>;
-export declare function updateRoot(_projectId: string, updates: {
-    title?: string;
-    description?: string;
-    userStyles?: string[];
-    testRules?: string[];
-    reviewRules?: string[];
-    codeStyle?: string[];
-}): Promise<NodeData | null>;
-export declare function deleteNode(_projectId: string, nodeId: string): Promise<boolean>;
-export declare function lockNode(_projectId: string, nodeId: string, locked: boolean): Promise<NodeData | null>;
-export declare function searchNodes(_projectId: string, keywords: string[], limit?: number): Promise<SearchResult[]>;
-export declare function findPath(_projectId: string, startId: string, endId: string): Promise<PathResult | null>;
-export declare function getRelations(_projectId: string, nodeId: string): Promise<Array<{
-    nodeId: string;
-    title: string;
-    description: string;
-    edgeType: string;
-    direction: 'outgoing' | 'incoming';
-}>>;
-export declare function addBugfix(_projectId: string, nodeId: string, bugfix: {
-    issue: string;
-    solution: string;
-    impact?: string;
-}): Promise<BugfixRecord | null>;
+export declare function listDocs(_projectId: string): Promise<DocNode[]>;
+export declare function getDoc(_projectId: string, docPath: string): Promise<DocData | null>;
+export declare function createDoc(_projectId: string, docPath: string, doc: Partial<DocData>): Promise<DocData>;
+export declare function updateDoc(_projectId: string, docPath: string, updates: Partial<DocData>): Promise<DocData | null>;
+export declare function deleteDoc(_projectId: string, docPath: string): Promise<boolean>;
+export declare function searchDocs(_projectId: string, keywords: string[], limit?: number): Promise<DocSearchResult[]>;
+export declare function getTree(_projectId: string): Promise<TreeNode[]>;
+export declare function getRules(_projectId: string, ruleType: string): Promise<string[]>;
+export declare function saveRules(_projectId: string, ruleType: string, rules: string[]): Promise<boolean>;
 export declare function listTasks(_projectId: string, status?: 'active' | 'archived'): Promise<TaskSummary[]>;
 export declare function getTask(_projectId: string, taskId: string): Promise<Task | null>;
 export declare function createTask(_projectId: string, task: {
     title: string;
     description: string;
     goals: string[];
-    related_nodes?: string[];
 }, creator: string): Promise<Task>;
 export declare function addTaskLog(_projectId: string, taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
 export declare function completeTask(_projectId: string, taskId: string, experience: TaskExperience): Promise<Task | null>;
-export declare function getRules(_projectId: string, ruleType: string): Promise<string[]>;
-export declare function saveRules(_projectId: string, ruleType: string, rules: string[]): Promise<boolean>;
-/** 向量搜索结果 */
-export interface VectorSearchResult {
-    id: string;
-    title: string;
-    score: number;
-    match_type: string;
-    keyword_score: number;
-    semantic_score: number;
-}
-/** 向量索引状态 */
-export interface VectorStats {
-    model_downloaded: boolean;
-    model_loaded: boolean;
-    model_path: string;
-    index_count: number;
-}
-/** 混合搜索 (关键词 + 语义) */
-export declare function vectorSearch(_projectId: string, query: string, limit: number, mode: 'hybrid' | 'keyword' | 'semantic'): Promise<VectorSearchResult[]>;
-/** 获取向量索引状态 */
-export declare function vectorStats(_projectId: string): Promise<VectorStats>;
+export type { TreeNode };

package/dist/storage/httpClient.js

@@ -4,58 +4,38 @@
  *
  * API URL 格式: http://localhost:20001/api/:projectId/:password/...
  */
-// ============ 智能定位算法 ============
-const SMART_NODE_GAP = 180;
-const SMART_SEARCH_RADIUS = 10;
-/**
- * 计算新节点的智能位置 (关联中心 + 螺旋搜索空位)
- */
-function computeSmartPosition(deps, nodes) {
-    // 1. 找关联节点
-    const related = [];
-    if (deps && deps.length > 0) {
-        const depNames = deps.map(d => d.name.toLowerCase());
-        nodes.forEach(n => {
-            if (n.signature && depNames.some(name => n.signature.toLowerCase().startsWith(name))) {
-                related.push(n);
-            }
-        });
-    }
-    // 2. 计算中心点
-    let cx, cy;
-    if (related.length > 0) {
-        cx = related.reduce((s, n) => s + n.x, 0) / related.length;
-        cy = related.reduce((s, n) => s + n.y, 0) / related.length + SMART_NODE_GAP;
-    }
-    else {
-        const root = nodes.find(n => n.isOrigin);
-        cx = root?.x ?? 0;
-        cy = (root?.y ?? 0) + SMART_NODE_GAP;
-    }
-    // 3. 碰撞检测
-    const collides = (x, y) => nodes.some(n => Math.abs(n.x - x) < SMART_NODE_GAP && Math.abs(n.y - y) < SMART_NODE_GAP * 0.6);
-    if (!collides(cx, cy))
-        return { x: Math.round(cx), y: Math.round(cy) };
-    // 4. 螺旋搜索
-    const dirs = [[1, 0], [0, 1], [-1, 0], [0, -1]];
-    let x = cx, y = cy, step = 1, dir = 0, steps = 0, turns = 0;
-    for (let i = 0; i < SMART_SEARCH_RADIUS * SMART_SEARCH_RADIUS * 4; i++) {
-        x += dirs[dir][0] * SMART_NODE_GAP;
-        y += dirs[dir][1] * SMART_NODE_GAP * 0.6;
-        steps++;
-        if (!collides(x, y))
-            return { x: Math.round(x), y: Math.round(y) };
-        if (steps >= step) {
-            steps = 0;
-            dir = (dir + 1) % 4;
-            if (++turns >= 2) {
-                turns = 0;
-                step++;
-            }
+/** 从扁平文档列表构建目录树 */
+function buildTree(docs) {
+    const root = [];
+    const pathMap = new Map();
+    // 按路径深度排序，确保父目录先处理
+    const sorted = [...docs].sort((a, b) => {
+        const depthA = (a.path.match(/\//g) || []).length;
+        const depthB = (b.path.match(/\//g) || []).length;
+        return depthA - depthB;
+    });
+    for (const doc of sorted) {
+        const node = {
+            path: doc.path,
+            name: doc.name,
+            summary: doc.summary,
+            isDir: doc.isDir,
+            children: doc.isDir ? [] : undefined
+        };
+        // 找父路径
+        const lastSlash = doc.path.lastIndexOf('/');
+        const parentPath = lastSlash > 0 ? doc.path.substring(0, lastSlash) : '';
+        if (parentPath && pathMap.has(parentPath)) {
+            pathMap.get(parentPath).children.push(node);
+        }
+        else {
+            root.push(node);
+        }
+        if (doc.isDir) {
+            pathMap.set(doc.path, node);
         }
     }
-    const maxX = Math.max(...nodes.map(n => n.x), 0);
-    return { x: Math.round(maxX + SMART_NODE_GAP), y: Math.round(cy) };
+    return root;
 }
 // API 客户端类
 export class PpdocsApiClient {
@@ -98,91 +78,51 @@ export class PpdocsApiClient {
             clearTimeout(timeout);
         }
     }
-    // ============ 节点操作 ============
-    async listNodes(filter) {
-        const nodes = await this.request('/nodes');
-        if (!filter)
-            return nodes;
-        // 计算每个节点的连接数 (入边+出边)
-        const edgeCounts = new Map();
-        nodes.forEach(n => edgeCounts.set(n.id, 0));
-        nodes.forEach(n => {
-            (n.dependencies || []).forEach(dep => {
-                // 出边: 当前节点依赖别人
-                edgeCounts.set(n.id, (edgeCounts.get(n.id) || 0) + 1);
-                // 入边: 被依赖的节点 (按 signature 匹配)
-                const target = nodes.find(t => t.signature?.toLowerCase() === dep.name.toLowerCase());
-                if (target)
-                    edgeCounts.set(target.id, (edgeCounts.get(target.id) || 0) + 1);
-            });
-        });
-        // 过滤
-        return nodes.filter(n => {
-            if (filter.status && n.status !== filter.status)
-                return false;
-            const edges = edgeCounts.get(n.id) || 0;
-            if (filter.minEdges !== undefined && edges < filter.minEdges)
-                return false;
-            if (filter.maxEdges !== undefined && edges > filter.maxEdges)
-                return false;
-            return true;
-        });
+    // ============ 文档操作 ============
+    async listDocs() {
+        return this.request('/docs');
     }
-    async getNode(nodeId) {
+    async getDoc(docPath) {
         try {
-            return await this.request(`/nodes/${nodeId}`);
+            // 移除开头的斜杠，API 路径会自动处理
+            const cleanPath = docPath.replace(/^\//, '');
+            return await this.request(`/docs/${cleanPath}`);
         }
         catch {
             return null;
         }
     }
-    async createNode(node) {
-        // 智能定位: 计算新节点位置
-        let x = node.x ?? 0;
-        let y = node.y ?? 0;
-        // 如果未指定位置，自动计算
-        if (node.x === undefined && node.y === undefined) {
-            const existingNodes = await this.listNodes();
-            const pos = computeSmartPosition(node.dependencies, existingNodes);
-            x = pos.x;
-            y = pos.y;
-        }
+    async createDoc(docPath, doc) {
+        const cleanPath = docPath.replace(/^\//, '');
         const payload = {
-            id: '', // 服务端自动生成
-            title: node.title || '',
-            type: node.type || 'logic',
-            status: node.status || 'incomplete',
-            x,
-            y,
-            locked: false,
-            signature: node.signature || node.title || '',
-            categories: node.categories || [],
-            description: node.description || '',
-            dependencies: node.dependencies || [],
-            relatedFiles: node.relatedFiles || [],
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            lastAccessedAt: new Date().toISOString(),
-            versions: [],
-            bugfixes: []
+            summary: doc.summary || '',
+            content: doc.content || '',
+            versions: doc.versions || [{
+                    version: 0.1,
+                    date: new Date().toISOString(),
+                    changes: '初始创建'
+                }],
+            bugfixes: doc.bugfixes || []
         };
-        return this.request('/nodes', {
+        return this.request(`/docs/${cleanPath}`, {
             method: 'POST',
             body: JSON.stringify(payload)
         });
     }
-    async updateNode(nodeId, updates) {
-        // 先获取现有节点，合并更新
-        const existing = await this.getNode(nodeId);
-        if (!existing)
-            return null;
-        const payload = {
-            ...existing,
-            ...updates,
-            updatedAt: new Date().toISOString()
-        };
+    async updateDoc(docPath, updates) {
         try {
-            return await this.request(`/nodes/${nodeId}`, {
+            const cleanPath = docPath.replace(/^\//, '');
+            // 先获取现有文档
+            const existing = await this.getDoc(docPath);
+            if (!existing)
+                return null;
+            const payload = {
+                summary: updates.summary ?? existing.summary,
+                content: updates.content ?? existing.content,
+                versions: updates.versions ?? existing.versions,
+                bugfixes: updates.bugfixes ?? existing.bugfixes
+            };
+            return await this.request(`/docs/${cleanPath}`, {
                 method: 'PUT',
                 body: JSON.stringify(payload)
             });
@@ -191,104 +131,48 @@ export class PpdocsApiClient {
             return null;
         }
     }
-    async updateRoot(updates) {
-        // 专用根节点更新，支持所有规则字段
-        const root = await this.getNode('root');
-        if (!root)
-            return null;
-        if (root.locked)
-            return null; // 锁定时拒绝
-        // 构建更新载荷 (只传入有值的字段)
-        const payload = { updatedAt: new Date().toISOString() };
-        if (updates.title !== undefined)
-            payload.title = updates.title;
-        if (updates.description !== undefined)
-            payload.description = updates.description;
-        if (updates.userStyles !== undefined)
-            payload.userStyles = updates.userStyles;
-        if (updates.testRules !== undefined)
-            payload.testRules = updates.testRules;
-        if (updates.reviewRules !== undefined)
-            payload.reviewRules = updates.reviewRules;
-        if (updates.codeStyle !== undefined)
-            payload.codeStyle = updates.codeStyle;
+    async deleteDoc(docPath) {
         try {
-            return await this.request('/nodes/root', {
-                method: 'PUT',
-                body: JSON.stringify({ ...root, ...payload })
-            });
-        }
-        catch {
-            return null;
-        }
-    }
-    async deleteNode(nodeId) {
-        try {
-            await this.request(`/nodes/${nodeId}`, { method: 'DELETE' });
+            const cleanPath = docPath.replace(/^\//, '');
+            await this.request(`/docs/${cleanPath}`, { method: 'DELETE' });
             return true;
         }
         catch {
             return false;
         }
     }
-    async lockNode(nodeId, locked) {
+    async searchDocs(keywords, limit = 20) {
+        return this.request('/docs/search', {
+            method: 'POST',
+            body: JSON.stringify({ keywords, limit })
+        });
+    }
+    /** 获取目录树结构 */
+    async getTree() {
+        const docs = await this.listDocs();
+        return buildTree(docs);
+    }
+    // ============ 规则 API ============
+    async getRulesApi(ruleType) {
         try {
-            return await this.request(`/nodes/${nodeId}/lock`, {
-                method: 'PUT',
-                body: JSON.stringify({ locked })
-            });
+            return await this.request(`/rules/${ruleType}`);
         }
         catch {
-            return null;
+            return [];
         }
     }
-    // ============ 搜索与路径 ============
-    async searchNodes(keywords, limit = 20) {
-        return this.request('/search', {
-            method: 'POST',
-            body: JSON.stringify({ keywords, limit })
-        });
-    }
-    async findPath(startId, endId) {
+    async saveRulesApi(ruleType, rules) {
         try {
-            return await this.request('/path', {
-                method: 'POST',
-                body: JSON.stringify({ start_id: startId, end_id: endId })
+            await this.request(`/rules/${ruleType}`, {
+                method: 'PUT',
+                body: JSON.stringify(rules)
             });
+            return true;
         }
         catch {
-            return null;
+            return false;
         }
     }
-    async getRelations(nodeId) {
-        const result = await this.request(`/relations/${nodeId}`);
-        // 转换字段名 (API 返回 type，前端期望 edgeType)
-        return result.map(r => ({
-            nodeId: r.nodeId,
-            title: r.title,
-            description: r.description,
-            edgeType: r.type,
-            direction: r.direction
-        }));
-    }
-    // ============ Bugfix ============
-    async addBugfix(nodeId, bugfix) {
-        // 添加 bugfix 需要先获取节点，追加 bugfix，然后更新
-        const node = await this.getNode(nodeId);
-        if (!node || node.locked)
-            return null;
-        const newBugfix = {
-            id: `bug-${Date.now()}`,
-            date: new Date().toISOString(),
-            issue: bugfix.issue,
-            solution: bugfix.solution,
-            impact: bugfix.impact
-        };
-        const updated = await this.updateNode(nodeId, {
-            bugfixes: [newBugfix, ...(node.bugfixes || [])].slice(0, 20)
-        });
-        return updated ? newBugfix : null;
-    }
     // ============ 任务管理 ============
     async listTasks(status) {
         const query = status ? `?status=${status}` : '';
@@ -309,7 +193,7 @@ export class PpdocsApiClient {
             detail: {
                 description: task.description,
                 goals: task.goals,
-                related_nodes: task.related_nodes || []
+                related_nodes: []
             }
         };
         return this.request('/tasks', {
@@ -339,39 +223,8 @@ export class PpdocsApiClient {
             return null;
         }
     }
-    // ============ 规则 API (独立文件存储) ============
-    async getRulesApi(ruleType) {
-        try {
-            return await this.request(`/rules/${ruleType}`);
-        }
-        catch {
-            return [];
-        }
-    }
-    async saveRulesApi(ruleType, rules) {
-        try {
-            await this.request(`/rules/${ruleType}`, {
-                method: 'PUT',
-                body: JSON.stringify(rules)
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    // ============ 向量搜索 API ============
-    async vectorSearch(query, limit, mode) {
-        return this.request('/vector/search', {
-            method: 'POST',
-            body: JSON.stringify({ query, limit, mode })
-        });
-    }
-    async vectorStats() {
-        return this.request('/vector/stats');
-    }
 }
-// ============ 模块级 API (兼容现有 tools/index.ts) ============
+// ============ 模块级 API ============
 let client = null;
 export function initClient(apiUrl) {
     client = new PpdocsApiClient(apiUrl);
@@ -382,39 +235,34 @@ function getClient() {
     }
     return client;
 }
-// 导出与 fileStorage 相同的函数签名
-export async function listNodes(_projectId, filter) {
-    return getClient().listNodes(filter);
+// ============ 文档管理 ============
+export async function listDocs(_projectId) {
+    return getClient().listDocs();
 }
-export async function getNode(_projectId, nodeId) {
-    return getClient().getNode(nodeId);
+export async function getDoc(_projectId, docPath) {
+    return getClient().getDoc(docPath);
 }
-export async function createNode(_projectId, node) {
-    return getClient().createNode(node);
+export async function createDoc(_projectId, docPath, doc) {
+    return getClient().createDoc(docPath, doc);
 }
-export async function updateNode(_projectId, nodeId, updates) {
-    return getClient().updateNode(nodeId, updates);
+export async function updateDoc(_projectId, docPath, updates) {
+    return getClient().updateDoc(docPath, updates);
 }
-export async function updateRoot(_projectId, updates) {
-    return getClient().updateRoot(updates);
+export async function deleteDoc(_projectId, docPath) {
+    return getClient().deleteDoc(docPath);
 }
-export async function deleteNode(_projectId, nodeId) {
-    return getClient().deleteNode(nodeId);
+export async function searchDocs(_projectId, keywords, limit) {
+    return getClient().searchDocs(keywords, limit);
 }
-export async function lockNode(_projectId, nodeId, locked) {
-    return getClient().lockNode(nodeId, locked);
+export async function getTree(_projectId) {
+    return getClient().getTree();
 }
-export async function searchNodes(_projectId, keywords, limit) {
-    return getClient().searchNodes(keywords, limit);
-}
-export async function findPath(_projectId, startId, endId) {
-    return getClient().findPath(startId, endId);
-}
-export async function getRelations(_projectId, nodeId) {
-    return getClient().getRelations(nodeId);
+// ============ 规则管理 ============
+export async function getRules(_projectId, ruleType) {
+    return getClient().getRulesApi(ruleType);
 }
-export async function addBugfix(_projectId, nodeId, bugfix) {
-    return getClient().addBugfix(nodeId, bugfix);
+export async function saveRules(_projectId, ruleType, rules) {
+    return getClient().saveRulesApi(ruleType, rules);
 }
 // ============ 任务管理 ============
 export async function listTasks(_projectId, status) {
@@ -432,18 +280,3 @@ export async function addTaskLog(_projectId, taskId, logType, content) {
 export async function completeTask(_projectId, taskId, experience) {
     return getClient().completeTask(taskId, experience);
 }
-// ============ 规则管理 (独立文件存储) ============
-export async function getRules(_projectId, ruleType) {
-    return getClient().getRulesApi(ruleType);
-}
-export async function saveRules(_projectId, ruleType, rules) {
-    return getClient().saveRulesApi(ruleType, rules);
-}
-/** 混合搜索 (关键词 + 语义) */
-export async function vectorSearch(_projectId, query, limit, mode) {
-    return getClient().vectorSearch(query, limit, mode);
-}
-/** 获取向量索引状态 */
-export async function vectorStats(_projectId) {
-    return getClient().vectorStats();
-}