@ppdocs/mcp 3.1.9 → 3.2.0

package/dist/tools/kg_status.js

@@ -0,0 +1,42 @@
+/**
+ * 📊 kg_status — 项目速览仪表盘 (新增)
+ */
+import { getClient } from '../storage/httpClient.js';
+import { wrap, safeTool } from './shared.js';
+export function registerStatusTool(server, projectId) {
+    const client = () => getClient();
+    server.tool('kg_status', '📊 项目速览仪表盘 — 一键了解项目健康。返回: 文档总数、目录数、活跃任务数、最近变更。每次对话开始建议首先调用', {}, async () => safeTool(async () => {
+        const [docs, activeTasks] = await Promise.all([
+            client().listDocs(),
+            client().listTasks('active'),
+        ]);
+        const dirCount = docs.filter(d => d.isDir).length;
+        const docCount = docs.filter(d => !d.isDir).length;
+        const statusMap = new Map();
+        for (const d of docs) {
+            if (d.isDir)
+                continue;
+            const s = d.status || '已完成';
+            statusMap.set(s, (statusMap.get(s) || 0) + 1);
+        }
+        const lines = [
+            `📊 项目速览 [${projectId}]`,
+            ``,
+            `📄 文档: ${docCount} 个 | 📁 目录: ${dirCount} 个`,
+            `📝 活跃任务: ${activeTasks.length} 个`,
+        ];
+        if (statusMap.size > 0) {
+            const statusLine = Array.from(statusMap.entries())
+                .map(([s, c]) => `${s}(${c})`)
+                .join(' | ');
+            lines.push(`📋 状态分布: ${statusLine}`);
+        }
+        if (activeTasks.length > 0) {
+            lines.push(``, `🔧 进行中的任务:`);
+            for (const t of activeTasks.slice(0, 5)) {
+                lines.push(`  - ${t.title} (${t.id})`);
+            }
+        }
+        return wrap(lines.join('\n'));
+    }));
+}

package/dist/tools/projects.d.ts

@@ -1,6 +1,7 @@
 /**
- * 项目管理工具 (3个)
- * kg_list_projects, kg_create_project, kg_update_root
+ * 📋 kg_projects (3→1)
+ * 合并: kg_list_projects, kg_update_root → kg_doc 处理
+ * 删除: kg_create_project (桌面端操作)
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerProjectTools(server: McpServer, projectId: string): void;

package/dist/tools/projects.js

@@ -1,15 +1,13 @@
 /**
- * 项目管理工具 (3个)
- * kg_list_projects, kg_create_project, kg_update_root
+ * 📋 kg_projects (3→1)
+ * 合并: kg_list_projects, kg_update_root → kg_doc 处理
+ * 删除: kg_create_project (桌面端操作)
  */
-import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
-import { decodeObjectStrings } from '../utils.js';
 import { wrap, safeTool } from './shared.js';
 export function registerProjectTools(server, projectId) {
     const client = () => getClient();
-    // 列出所有可访问的项目
-    server.tool('kg_list_projects', '列出所有可访问的项目(返回name和id)。跨项目操作的第一步：先调用此工具获取项目ID，再作为其他工具的targetProject参数', {}, async () => safeTool(async () => {
+    server.tool('kg_projects', '📋 列出所有可访问的项目(返回名称和ID)。跨项目操作的第一步: 获取项目ID后用于其他工具的 targetProject 参数', {}, async () => safeTool(async () => {
         const projects = await client().crossListProjects();
         if (projects.length === 0)
             return wrap('暂无可访问的项目');
@@ -19,34 +17,4 @@ export function registerProjectTools(server, projectId) {
         });
         return wrap(`可访问的项目 (${projects.length} 个):\n\n${lines.join('\n')}`);
     }));
-    // 创建项目
-    server.tool('kg_create_project', '创建新项目。返回项目ID和密码(密码用于MCP连接)', {
-        id: z.string().describe('项目ID(英文/数字/中文，如"my-app")'),
-        name: z.string().describe('项目名称'),
-        description: z.string().optional().describe('项目简介'),
-        projectPath: z.string().optional().describe('项目源码路径(本地绝对路径)'),
-    }, async (args) => safeTool(async () => {
-        const result = await client().createProject(args.id, args.name, args.description, args.projectPath || process.cwd());
-        return wrap(`✅ 项目创建成功\n\n- 项目ID: ${result.project.id}\n- 项目名: ${result.project.name}\n- 密码: ${result.password}\n\nMCP 连接地址: http://<服务器IP>:20001/api/${result.project.id}/${result.password}`);
-    }));
-    // 更新根文档 (项目介绍)
-    server.tool('kg_update_root', '更新项目介绍(根文档)', {
-        title: z.string().optional().describe('项目标题'),
-        description: z.string().optional().describe('项目介绍(Markdown)')
-    }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args);
-        if (decoded.title === undefined && decoded.description === undefined) {
-            return wrap('❌ 请至少提供 title 或 description');
-        }
-        const existing = await client().getDoc('/');
-        if (!existing)
-            return wrap('更新失败(根文档不存在)');
-        const updates = {};
-        if (decoded.title !== undefined)
-            updates.summary = decoded.title;
-        if (decoded.description !== undefined)
-            updates.content = decoded.description;
-        const doc = await client().updateDoc('/', updates);
-        return wrap(doc ? '✅ 项目介绍已更新' : '更新失败');
-    }));
 }

package/dist/tools/rules.d.ts

@@ -1,7 +1,7 @@
 /**
- * 规则管理工具 (6个)
- * kg_get_rules, kg_save_rules, kg_get_rules_meta, kg_save_rules_meta,
- * kg_get_global_rules_meta, kg_save_global_rules_meta
+ * 📏 kg_rules (6→1)
+ * 合并: kg_get_rules, kg_save_rules, kg_get_rules_meta, kg_save_rules_meta
+ * 删除: kg_get_global_rules_meta, kg_save_global_rules_meta (管理员操作)
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerRuleTools(server: McpServer, projectId: string): void;

package/dist/tools/rules.js

@@ -1,7 +1,7 @@
 /**
- * 规则管理工具 (6个)
- * kg_get_rules, kg_save_rules, kg_get_rules_meta, kg_save_rules_meta,
- * kg_get_global_rules_meta, kg_save_global_rules_meta
+ * 📏 kg_rules (6→1)
+ * 合并: kg_get_rules, kg_save_rules, kg_get_rules_meta, kg_save_rules_meta
+ * 删除: kg_get_global_rules_meta, kg_save_global_rules_meta (管理员操作)
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
@@ -9,117 +9,95 @@ import { decodeObjectStrings, getRules, RULE_TYPE_LABELS } from '../utils.js';
 import { wrap, safeTool, crossPrefix } from './shared.js';
 export function registerRuleTools(server, projectId) {
     const client = () => getClient();
-    // 获取项目规则
-    server.tool('kg_get_rules', '获取项目规则(可指定类型或获取全部)。支持跨项目只读访问(需先用kg_list_projects获取项目ID)', {
-        ruleType: z.string().optional().describe('规则类型(如 userStyles, codeStyle, reviewRules, testRules, unitTests, 或自定义类型)。不传则返回全部'),
-        targetProject: z.string().optional().describe('目标项目ID或名称(不填=当前项目)。ID可从kg_list_projects获取')
-    }, async (args) => safeTool(async () => {
-        if (args.targetProject) {
-            const crossMeta = await client().crossGetRulesMeta(args.targetProject);
-            if (args.ruleType) {
-                const rules = await client().crossGetRules(args.targetProject, args.ruleType);
-                if (rules.length === 0) {
-                    const label = crossMeta[args.ruleType]?.label || args.ruleType;
-                    return wrap(`暂无${label}规则(项目: ${args.targetProject})`);
-                }
-                return wrap(`${crossPrefix(args.targetProject)}${rules.join('\n')}`);
-            }
-            const types = Object.keys(crossMeta).length > 0 ? Object.keys(crossMeta) : Object.keys(RULE_TYPE_LABELS);
-            const allRules = [];
-            for (const type of types) {
-                const rules = await client().crossGetRules(args.targetProject, type);
-                if (rules.length > 0) {
-                    const label = crossMeta[type]?.label || RULE_TYPE_LABELS[type] || type;
-                    allRules.push(`## ${label}\n${rules.join('\n')}`);
-                }
-            }
-            if (allRules.length === 0)
-                return wrap(`暂无项目规则(项目: ${args.targetProject})`);
-            return wrap(`${crossPrefix(args.targetProject)}${allRules.join('\n\n')}`);
-        }
-        const rules = await getRules(projectId, args.ruleType || undefined);
-        if (!rules || rules.trim() === '') {
-            const meta = await client().getRulesMeta();
-            const typeName = args.ruleType ? (meta[args.ruleType]?.label || args.ruleType) : '项目';
-            return wrap(`暂无${typeName}规则`);
-        }
-        return wrap(rules);
-    }));
-    // 保存项目规则 (自动合并,去重追加)
-    server.tool('kg_save_rules', '保存单个类型的项目规则(自动合并:已有规则保留,新规则去重追加)', {
-        ruleType: z.string().describe('规则类型(如 userStyles, codeStyle, reviewRules, testRules, unitTests, 或自定义类型)'),
-        rules: z.array(z.string()).describe('规则数组')
-    }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args);
-        // appendRules 逻辑内联（原 httpClient 包装函数）
-        const existing = await client().getRulesApi(decoded.ruleType);
-        const existingSet = new Set(existing.map(r => r.trim()));
-        const toAdd = decoded.rules.filter(r => !existingSet.has(r.trim()));
-        const merged = [...existing, ...toAdd];
-        const success = await client().saveRulesApi(decoded.ruleType, merged);
-        if (!success)
-            return wrap('❌ 保存失败');
-        const meta = await client().getRulesMeta();
-        const label = meta[decoded.ruleType]?.label || decoded.ruleType;
-        return wrap(`✅ ${label}已保存 (新增${toAdd.length}条, 共${merged.length}条)`);
-    }));
-    // 获取规则触发配置
-    server.tool('kg_get_rules_meta', '获取规则触发配置(所有类型的标签、关键词、触发数)。用于查看/编辑 hooks 触发条件', {}, async () => safeTool(async () => {
-        const meta = await client().getRulesMeta();
-        if (Object.keys(meta).length === 0)
-            return wrap('暂无规则配置');
-        const lines = Object.entries(meta).map(([type, m]) => {
-            const kw = m.keywords.length > 0 ? m.keywords.join(', ') : '(无)';
-            const trigger = m.always ? '始终触发' : `关键词≥${m.min_hits}: ${kw}`;
-            return `- **${m.label}** (${type}): ${trigger}`;
-        });
-        return wrap(`规则触发配置:\n\n${lines.join('\n')}`);
-    }));
-    // 保存规则触发配置 (自动合并)
-    server.tool('kg_save_rules_meta', '保存规则触发配置(自动合并:已有类型更新,新类型创建,其他类型不受影响)', {
+    server.tool('kg_rules', '📏 项目规则管理 — 读取或保存代码风格、审查规则等。action: get(读取规则)|save(保存规则)|get_meta(读取触发配置)|save_meta(保存触发配置)', {
+        action: z.enum(['get', 'save', 'get_meta', 'save_meta'])
+            .describe('操作类型'),
+        ruleType: z.string().optional()
+            .describe('规则类型(如 userStyles, codeStyle, reviewRules)。get/save 时使用，不传则获取全部'),
+        rules: z.array(z.string()).optional()
+            .describe('save 时的规则数组'),
         meta: z.record(z.string(), z.object({
             label: z.string().describe('规则显示名称'),
             keywords: z.array(z.string()).default([]).describe('触发关键词列表'),
             min_hits: z.number().default(1).describe('最低触发关键词数'),
-            always: z.boolean().default(false).describe('是否始终触发(如 userStyles)')
-        })).describe('规则类型 → 触发配置的映射')
+            always: z.boolean().default(false).describe('是否始终触发')
+        })).optional().describe('save_meta 时的触发配置映射'),
+        targetProject: z.string().optional()
+            .describe('跨项目读取 (get)'),
     }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args.meta);
-        // mergeRulesMeta 逻辑内联
-        const existing = await client().getRulesMeta();
-        const merged = { ...existing, ...decoded };
-        const success = await client().saveRulesMeta(merged);
-        if (!success)
-            return wrap('❌ 保存失败');
-        return wrap(`✅ 触发配置已保存 (更新${Object.keys(decoded).length}个类型, 共${Object.keys(merged).length}个类型)`);
-    }));
-    // 获取全局默认规则触发配置
-    server.tool('kg_get_global_rules_meta', '获取全局默认规则触发配置(新项目创建时继承此配置)', {}, async () => safeTool(async () => {
-        const meta = await client().getGlobalRulesMeta();
-        if (Object.keys(meta).length === 0)
-            return wrap('暂无全局默认规则配置');
-        const lines = Object.entries(meta).map(([type, m]) => {
-            const kw = m.keywords.length > 0 ? m.keywords.join(', ') : '(无)';
-            const trigger = m.always ? '始终触发' : `关键词≥${m.min_hits}: ${kw}`;
-            return `- **${m.label}** (${type}): ${trigger}`;
-        });
-        return wrap(`全局默认规则触发配置:\n\n${lines.join('\n')}`);
-    }));
-    // 保存全局默认规则触发配置 (自动合并)
-    server.tool('kg_save_global_rules_meta', '保存全局默认触发配置(自动合并:已有类型更新,新类型创建,其他类型不受影响)', {
-        meta: z.record(z.string(), z.object({
-            label: z.string().describe('规则显示名称'),
-            keywords: z.array(z.string()).default([]).describe('触发关键词列表'),
-            min_hits: z.number().default(1).describe('最低触发关键词数'),
-            always: z.boolean().default(false).describe('是否始终触发(如 userStyles)')
-        })).describe('规则类型 → 触发配置的映射')
-    }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args.meta);
-        const existing = await client().getGlobalRulesMeta();
-        const merged = { ...existing, ...decoded };
-        const success = await client().saveGlobalRulesMeta(merged);
-        if (!success)
-            return wrap('❌ 保存失败');
-        return wrap(`✅ 全局触发配置已保存 (更新${Object.keys(decoded).length}个类型, 共${Object.keys(merged).length}个类型)`);
+        const decoded = decodeObjectStrings(args);
+        switch (decoded.action) {
+            case 'get': {
+                if (decoded.targetProject) {
+                    const crossMeta = await client().crossGetRulesMeta(decoded.targetProject);
+                    if (decoded.ruleType) {
+                        const rules = await client().crossGetRules(decoded.targetProject, decoded.ruleType);
+                        if (rules.length === 0) {
+                            const label = crossMeta[decoded.ruleType]?.label || decoded.ruleType;
+                            return wrap(`暂无${label}规则(项目: ${decoded.targetProject})`);
+                        }
+                        return wrap(`${crossPrefix(decoded.targetProject)}${rules.join('\n')}`);
+                    }
+                    const types = Object.keys(crossMeta).length > 0 ? Object.keys(crossMeta) : Object.keys(RULE_TYPE_LABELS);
+                    const allRules = [];
+                    for (const type of types) {
+                        const rules = await client().crossGetRules(decoded.targetProject, type);
+                        if (rules.length > 0) {
+                            const label = crossMeta[type]?.label || RULE_TYPE_LABELS[type] || type;
+                            allRules.push(`## ${label}\n${rules.join('\n')}`);
+                        }
+                    }
+                    if (allRules.length === 0)
+                        return wrap(`暂无项目规则(项目: ${decoded.targetProject})`);
+                    return wrap(`${crossPrefix(decoded.targetProject)}${allRules.join('\n\n')}`);
+                }
+                const rules = await getRules(projectId, decoded.ruleType || undefined);
+                if (!rules || rules.trim() === '') {
+                    const meta = await client().getRulesMeta();
+                    const typeName = decoded.ruleType ? (meta[decoded.ruleType]?.label || decoded.ruleType) : '项目';
+                    return wrap(`暂无${typeName}规则`);
+                }
+                return wrap(rules);
+            }
+            case 'save': {
+                if (!decoded.ruleType)
+                    return wrap('❌ save 需要 ruleType');
+                if (!decoded.rules)
+                    return wrap('❌ save 需要 rules 数组');
+                const existing = await client().getRulesApi(decoded.ruleType);
+                const existingSet = new Set(existing.map(r => r.trim()));
+                const toAdd = decoded.rules.filter((r) => !existingSet.has(r.trim()));
+                const merged = [...existing, ...toAdd];
+                const success = await client().saveRulesApi(decoded.ruleType, merged);
+                if (!success)
+                    return wrap('❌ 保存失败');
+                const meta = await client().getRulesMeta();
+                const label = meta[decoded.ruleType]?.label || decoded.ruleType;
+                return wrap(`✅ ${label}已保存 (新增${toAdd.length}条, 共${merged.length}条)`);
+            }
+            case 'get_meta': {
+                const meta = await client().getRulesMeta();
+                if (Object.keys(meta).length === 0)
+                    return wrap('暂无规则配置');
+                const lines = Object.entries(meta).map(([type, m]) => {
+                    const kw = m.keywords.length > 0 ? m.keywords.join(', ') : '(无)';
+                    const trigger = m.always ? '始终触发' : `关键词≥${m.min_hits}: ${kw}`;
+                    return `- **${m.label}** (${type}): ${trigger}`;
+                });
+                return wrap(`规则触发配置:\n\n${lines.join('\n')}`);
+            }
+            case 'save_meta': {
+                if (!decoded.meta)
+                    return wrap('❌ save_meta 需要 meta');
+                const existing = await client().getRulesMeta();
+                const merged = { ...existing, ...decoded.meta };
+                const success = await client().saveRulesMeta(merged);
+                if (!success)
+                    return wrap('❌ 保存失败');
+                return wrap(`✅ 触发配置已保存 (更新${Object.keys(decoded.meta).length}个类型, 共${Object.keys(merged).length}个类型)`);
+            }
+            default:
+                return wrap(`❌ 未知 action: ${decoded.action}`);
+        }
     }));
 }

package/dist/tools/tasks.d.ts

@@ -1,6 +1,6 @@
 /**
- * 任务管理工具 (4个)
- * task_create, task_get, task_update, task_archive
+ * 📝 kg_task (4→1)
+ * 合并: task_create, task_get, task_update, task_archive
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerTaskTools(server: McpServer, projectId: string, user: string): void;

package/dist/tools/tasks.js

@@ -1,6 +1,6 @@
 /**
- * 任务管理工具 (4个)
- * task_create, task_get, task_update, task_archive
+ * 📝 kg_task (4→1)
+ * 合并: task_create, task_get, task_update, task_archive
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
@@ -8,79 +8,102 @@ import { decodeObjectStrings } from '../utils.js';
 import { wrap, safeTool } from './shared.js';
 export function registerTaskTools(server, projectId, user) {
     const client = () => getClient();
-    // 创建任务
-    server.tool('task_create', '创建开发任务', {
-        title: z.string().describe('任务标题'),
-        description: z.string().describe('任务描述(Markdown)'),
-        goals: z.array(z.string()).optional().describe('目标清单')
+    server.tool('kg_task', '📝 任务管理 — 创建、查询、更新进展、归档。action: create(创建)|get(查询)|update(添加日志)|archive(归档)', {
+        action: z.enum(['create', 'get', 'update', 'archive'])
+            .describe('操作类型'),
+        title: z.string().optional()
+            .describe('任务标题 (create/get)'),
+        description: z.string().optional()
+            .describe('任务描述Markdown (create)'),
+        goals: z.array(z.string()).optional()
+            .describe('目标清单 (create)'),
+        taskId: z.string().optional()
+            .describe('任务ID (update/archive)'),
+        log_type: z.enum(['progress', 'issue', 'solution', 'reference']).optional()
+            .describe('日志类型 (update)'),
+        content: z.string().optional()
+            .describe('日志内容Markdown (update)'),
+        summary: z.string().optional()
+            .describe('经验总结Markdown (archive)'),
+        difficulties: z.array(z.string()).optional()
+            .describe('遇到的困难 (archive)'),
+        solutions: z.array(z.string()).optional()
+            .describe('解决方案 (archive)'),
+        status: z.enum(['active', 'archived', 'all']).optional()
+            .describe('状态筛选 (get, 默认all)'),
     }, async (args) => safeTool(async () => {
         const decoded = decodeObjectStrings(args);
-        const task = await client().createTask({
-            title: decoded.title,
-            description: decoded.description,
-            goals: decoded.goals || []
-        }, user);
-        return wrap(JSON.stringify(task, null, 2));
-    }));
-    // 读取任务
-    server.tool('task_get', '读取任务详情(按名字搜索，支持当前任务和历史任务)', {
-        title: z.string().describe('任务名称(模糊匹配)'),
-        status: z.enum(['active', 'archived', 'all']).optional().describe('状态筛选: active=进行中, archived=已归档, all=全部(默认)')
-    }, async (args) => safeTool(async () => {
-        const status = args.status || 'all';
-        const searchTitle = args.title.toLowerCase();
-        let tasks;
-        if (status === 'all') {
-            const [active, archived] = await Promise.all([
-                client().listTasks('active'),
-                client().listTasks('archived')
-            ]);
-            tasks = [...active, ...archived];
-        }
-        else {
-            tasks = await client().listTasks(status);
+        switch (decoded.action) {
+            case 'create': {
+                if (!decoded.title)
+                    return wrap('❌ create 需要 title');
+                if (!decoded.description)
+                    return wrap('❌ create 需要 description');
+                const task = await client().createTask({
+                    title: decoded.title,
+                    description: decoded.description,
+                    goals: decoded.goals || []
+                }, user);
+                return wrap(JSON.stringify(task, null, 2));
+            }
+            case 'get': {
+                if (!decoded.title)
+                    return wrap('❌ get 需要 title');
+                const filterStatus = decoded.status || 'all';
+                const searchTitle = decoded.title.toLowerCase();
+                let tasks;
+                if (filterStatus === 'all') {
+                    const [active, archived] = await Promise.all([
+                        client().listTasks('active'),
+                        client().listTasks('archived')
+                    ]);
+                    tasks = [...active, ...archived];
+                }
+                else {
+                    tasks = await client().listTasks(filterStatus);
+                }
+                const matched = tasks.filter(t => t.title.toLowerCase().includes(searchTitle));
+                if (matched.length === 0)
+                    return wrap(`未找到匹配 "${decoded.title}" 的任务`);
+                if (matched.length === 1) {
+                    const task = await client().getTask(matched[0].id);
+                    return wrap(task ? JSON.stringify(task, null, 2) : '任务详情获取失败');
+                }
+                const list = matched.map(t => ({
+                    id: t.id, title: t.title, status: t.status,
+                    creator: t.creator, created_at: t.created_at
+                }));
+                return wrap(`找到 ${matched.length} 个匹配任务:\n${JSON.stringify(list, null, 2)}\n\n请提供更精确的任务名称`);
+            }
+            case 'update': {
+                if (!decoded.taskId)
+                    return wrap('❌ update 需要 taskId');
+                if (!decoded.log_type)
+                    return wrap('❌ update 需要 log_type');
+                if (!decoded.content)
+                    return wrap('❌ update 需要 content');
+                const task = await client().addTaskLog(decoded.taskId, decoded.log_type, decoded.content);
+                if (!task)
+                    return wrap('更新失败(任务不存在或已归档)');
+                return wrap(`✅ 日志已添加，任务共有 ${task.logs.length} 条日志`);
+            }
+            case 'archive': {
+                if (!decoded.taskId)
+                    return wrap('❌ archive 需要 taskId');
+                if (!decoded.summary)
+                    return wrap('❌ archive 需要 summary');
+                const task = await client().completeTask(decoded.taskId, {
+                    summary: decoded.summary,
+                    difficulties: decoded.difficulties || [],
+                    solutions: decoded.solutions || [],
+                    references: []
+                });
+                if (!task)
+                    return wrap('归档失败(任务不存在或已归档)');
+                return wrap(`✅ 任务已归档: ${task.title}`);
+            }
+            default:
+                return wrap(`❌ 未知 action: ${decoded.action}`);
         }
-        const matched = tasks.filter(t => t.title.toLowerCase().includes(searchTitle));
-        if (matched.length === 0)
-            return wrap(`未找到匹配 "${args.title}" 的任务`);
-        if (matched.length === 1) {
-            const task = await client().getTask(matched[0].id);
-            return wrap(task ? JSON.stringify(task, null, 2) : '任务详情获取失败');
-        }
-        const list = matched.map(t => ({
-            id: t.id, title: t.title, status: t.status,
-            creator: t.creator, created_at: t.created_at
-        }));
-        return wrap(`找到 ${matched.length} 个匹配任务:\n${JSON.stringify(list, null, 2)}\n\n请提供更精确的任务名称`);
-    }));
-    // 更新任务
-    server.tool('task_update', '更新任务(添加进展日志)', {
-        taskId: z.string().describe('任务ID'),
-        log_type: z.enum(['progress', 'issue', 'solution', 'reference']).describe('日志类型: progress=进展, issue=问题, solution=方案, reference=参考'),
-        content: z.string().describe('日志内容(Markdown)')
-    }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args);
-        const task = await client().addTaskLog(args.taskId, decoded.log_type, decoded.content);
-        if (!task)
-            return wrap('更新失败(任务不存在或已归档)');
-        return wrap(`✅ 日志已添加，任务共有 ${task.logs.length} 条日志`);
-    }));
-    // 归档任务
-    server.tool('task_archive', '归档任务(完成并填写经验总结)', {
-        taskId: z.string().describe('任务ID'),
-        summary: z.string().describe('经验总结(Markdown)'),
-        difficulties: z.array(z.string()).optional().describe('遇到的困难'),
-        solutions: z.array(z.string()).optional().describe('解决方案')
-    }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args);
-        const task = await client().completeTask(args.taskId, {
-            summary: decoded.summary,
-            difficulties: decoded.difficulties || [],
-            solutions: decoded.solutions || [],
-            references: []
-        });
-        if (!task)
-            return wrap('归档失败(任务不存在或已归档)');
-        return wrap(`✅ 任务已归档: ${task.title}`);
     }));
 }

package/dist/web/server.d.ts

@@ -0,0 +1,43 @@
+/**
+ * PPDocs Agent V2 — Web Config Server
+ * 多项目管理 + 智能匹配 + 知识图谱预览 + MCP 安装
+ */
+export interface ProjectBinding {
+    localDir: string;
+    localName: string;
+    remote: {
+        id: string;
+        name: string;
+        password: string;
+    };
+    sync: {
+        enabled: boolean;
+        intervalSec: number;
+    };
+    createdAt: string;
+}
+export interface AgentConfig {
+    host: string;
+    port: number;
+    webPort: number;
+    projects: ProjectBinding[];
+}
+export declare function loadAgentConfig(): AgentConfig | null;
+export declare function saveAgentConfig(config: AgentConfig): void;
+interface ProjectStatus {
+    connected: boolean;
+    syncStatus: string;
+    lastSync: Date | null;
+    docCount?: number;
+}
+interface AgentState {
+    hostConnected: boolean;
+    projectStatus: Map<string, ProjectStatus>;
+    onBind?: (project: ProjectBinding) => void;
+    onUnbind?: (remoteId: string) => void;
+}
+export declare function getAgentState(): AgentState;
+export declare function setAgentState(partial: Partial<AgentState>): void;
+export declare function setProjectStatus(remoteId: string, status: Partial<ProjectStatus>): void;
+export declare function startWebServer(webPort: number): void;
+export {};