cloudcc-cli 2.2.2 → 2.2.4

package/src/mcp/tools/Scheduled Class List Retriever/handler.js

@@ -0,0 +1,52 @@
+/**
+ * Scheduled Class List Retriever 工具处理器
+ * 查询定时类列表
+ */
+
+const getScheduleModule = require('../../../timer/get');
+
+/**
+ * 获取定时类列表
+ */
+async function listSchedules({ projectPath = process.cwd() }) {
+    try {
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            const result = await getScheduleModule('', projectPath, true);
+
+            if (!result || result.length === 0) {
+                return {
+                    content: [{
+                        type: 'text',
+                        text: '未找到任何定时器类\n\n提示：使用 create_schedule 创建新定时器类'
+                    }]
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2)
+                    }
+                ]
+            };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return {
+            content: [
+                { type: 'text', text: `获取定时类列表失败: ${error.message}` }
+            ]
+        };
+    }
+}
+
+
+
+module.exports = {
+    listSchedules
+};
+

package/src/mcp/tools/Scheduled Class Publisher/handler.js

@@ -0,0 +1,30 @@
+/**
+ * Scheduled Class Publisher 工具处理器
+ * 发布定时类到服务器
+ */
+
+const publishScheduleModule = require('../../../timer/publish');
+
+/**
+ * 发布定时类到服务器
+ */
+async function publishSchedule({ scheduleName, projectPath = process.cwd() }) {
+    try {
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            await publishScheduleModule(scheduleName);
+            return { content: [{ type: 'text', text: `✓ 发布成功！定时类 ${scheduleName} 已发布到服务器` }] };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 发布失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    publishSchedule
+};
+

package/src/mcp/tools/Scheduled Class Puller/handler.js

@@ -0,0 +1,92 @@
+/**
+ * Scheduled Class Puller 工具处理器
+ * 从服务器拉取定时类
+ */
+
+const fs = require('fs');
+const path = require('path');
+const getScheduleModule = require('../../../timer/get');
+const pullScheduleModule = require('../../../timer/pull');
+const pullListModule = require('../../../timer/pullList');
+
+/**
+ * 从服务器拉取定时类
+ */
+async function pullSchedule({ scheduleName, projectPath = process.cwd() }) {
+    try {
+        const schedulePath = path.join(projectPath, `schedule/${scheduleName}`);
+        const configPath = path.join(schedulePath, 'config.json');
+
+        // 检查本地是否存在该定时类
+        if (!fs.existsSync(configPath)) {
+            // 本地不存在，查询服务器
+            try {
+                const queryString = encodeURI(JSON.stringify({
+                    shownum: "2000",
+                    showpage: "1",
+                    fid: "",
+                    sname: scheduleName,
+                    rptcond: '',
+                    rptorder: ''
+                }));
+                const scheduleList = await getScheduleModule(queryString, projectPath);
+
+                if (!scheduleList || scheduleList.length === 0) {
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: `✗ 拉取失败: 服务器上不存在定时类 ${scheduleName}`
+                        }]
+                    };
+                }
+
+                // 找到匹配的定时类
+                const targetSchedule = scheduleList.find(item => item.name === scheduleName || item.apiname === scheduleName);
+                if (!targetSchedule) {
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: `✗ 拉取失败: 服务器上未找到定时类 ${scheduleName}`
+                        }]
+                    };
+                }
+
+                // 使用 ID 从服务器拉取并在本地创建
+                const originalCwd = process.cwd();
+                process.chdir(projectPath);
+
+                try {
+                    await pullListModule(targetSchedule.id, projectPath);
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: `✓ 拉取成功！已从服务器拉取定时类 ${scheduleName} 并在本地创建\n\n本地路径: schedule/${scheduleName}/`
+                        }]
+                    };
+                } finally {
+                    process.chdir(originalCwd);
+                }
+            } catch (error) {
+                return { content: [{ type: 'text', text: `✗ 拉取失败: ${error.message}` }] };
+            }
+        }
+
+        // 本地存在，直接更新
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            await pullScheduleModule(scheduleName);
+            return { content: [{ type: 'text', text: `✓ 拉取成功！本地文件已更新: schedule/${scheduleName}/${scheduleName}.java` }] };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 拉取失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    pullSchedule
+};
+

package/src/mcp/tools/Trigger Creator/handler.js

@@ -0,0 +1,53 @@
+/**
+ * Trigger Creator 工具处理器
+ * 创建触发器
+ */
+
+const path = require('path');
+const createTriggerModule = require('../../../triggers/create');
+
+/**
+ * 创建触发器
+ * @param {Object} params - 参数对象
+ * @param {string} params.triggerName - 触发器名称
+ * @param {string} params.objectName - 对象名称（schemetableName）
+ * @param {string} params.targetObjectId - 目标对象ID
+ * @param {string} params.triggerTime - 触发时间（例如：beforeInsert, beforeUpdate, beforeUpsert, beforeDelete, afterInsert, afterUpdate, afterUpsert, afterDelete, afterInsertCommit, afterUpdateCommit, afterUpsertCommit, afterDeleteCommit, approval, beforeBatch, afterBatch, commitBatch）
+ * @param {string} params.projectPath - 项目路径（可选，默认为当前工作目录）
+ */
+async function createTrigger({ triggerName, objectName, targetObjectId, triggerTime, projectPath = process.cwd() }) {
+    try {
+        // 构造传递给底层模块的参数
+        const body = {
+            name: triggerName,
+            schemetableName: objectName,
+            targetObjectId: targetObjectId,
+            triggerTime: triggerTime
+        };
+        
+        const argvs = ['', '', encodeURI(JSON.stringify(body))];
+        
+        // 临时改变工作目录以兼容原有模块
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            await createTriggerModule(argvs);
+            const triggerPath = path.resolve(projectPath, `triggers/${objectName.toLowerCase()}/${triggerName}`);
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✓ 创建成功！\n\n触发器路径: ${triggerPath}\n生成的文件:\n  - ${triggerName}.java (主类文件，继承 CCTrigger)\n  - config.json (配置文件)\n\n触发器说明：\n  - 触发器继承 CCTrigger，用于在对象操作时执行特定逻辑\n  - 对象：${objectName}\n  - 触发时间：${triggerTime}\n  - 代码写在构造函数中，系统会在指定时机自动执行`
+                }]
+            };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 创建失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    createTrigger
+};

package/src/mcp/tools/Trigger Detail Retriever/handler.js

@@ -0,0 +1,33 @@
+/**
+ * Trigger Detail Retriever 工具处理器
+ * 获取触发器的详细信息
+ */
+
+const detailModule = require('../../../triggers/detail');
+
+/**
+ * 获取触发器详细信息
+ * @param {Object} params - 参数对象
+ * @param {string} params.triggerPath - 触发器路径 "objectName/triggerName"（可选，优先使用）
+ * @param {string} params.triggerId - 触发器ID（可选，当没有triggerPath时使用）
+ * @param {string} params.projectPath - 项目路径（可选，默认为当前工作目录）
+ */
+async function getTriggerDetail({ triggerPath, triggerId, projectPath = process.cwd() }) {
+    try {
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            const detail = await detailModule(triggerPath, triggerId);
+            return { content: [{ type: 'text', text: JSON.stringify(detail, null, 2) }] };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 获取失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    getTriggerDetail
+};

package/src/mcp/tools/Trigger Editor Guide/handler.js

@@ -0,0 +1,58 @@
+/**
+ * Trigger Editor Guide 工具处理器
+ * 提供触发器编辑指南，使用与自定义类和定时类相同的知识库
+ */
+
+const classEditorGuideHandler = require('../Class Editor Guide/handler.js');
+
+/**
+ * 获取触发器编辑指南
+ * 触发器继承CCTrigger，使用与自定义类和定时类相同的API和编辑规范
+ * @param {Object} params - 参数对象
+ * @param {string} params.topic - 编辑指南主题
+ */
+async function editTrigger({ topic = 'overview' }) {
+    try {
+        // 触发器使用与自定义类和定时类相同的编辑指南
+        // 只是继承的基类不同（CCTrigger vs CCClass vs CCSchedule）
+        const result = await classEditorGuideHandler.editClass({ topic });
+        
+        // 在结果前添加触发器特定说明
+        if (result.content && result.content[0]) {
+            const triggerNote = `
+📌 触发器特别说明：
+------------------
+触发器继承 CCTrigger 类，用于在对象操作时自动执行特定逻辑。
+
+触发器与自定义类/定时类的主要区别：
+1. 继承基类：extends CCTrigger
+2. 触发时机：通过 triggerTime 配置（beforeInsert, beforeUpdate, beforeUpsert, beforeDelete, afterInsert, afterUpdate, afterUpsert, afterDelete, afterInsertCommit, afterUpdateCommit, afterUpsertCommit, afterDeleteCommit, approval, beforeBatch, afterBatch, commitBatch）
+3. 关联对象：触发器与特定对象绑定（targetObjectId）
+4. 执行时机：在对象操作时自动触发，无需手动调用
+5. 常见用途：数据验证、字段自动填充、关联数据更新、业务规则检查等
+
+触发器中可访问的特殊变量：
+- newList：新记录列表（insert/update操作）
+- oldList：旧记录列表（update/delete操作）
+- trigger.isInsert：是否为插入操作
+- trigger.isUpdate：是否为更新操作
+- trigger.isDelete：是否为删除操作
+- trigger.isBefore：是否为before触发器
+- trigger.isAfter：是否为after触发器
+
+以下是触发器开发的通用API文档（与自定义类、定时类共享）：
+==========================================
+
+`;
+            result.content[0].text = triggerNote + result.content[0].text;
+        }
+        
+        return result;
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 获取触发器编辑指南失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    editTrigger
+};

package/src/mcp/tools/Trigger List Retriever/handler.js

@@ -0,0 +1,49 @@
+/**
+ * Trigger List Retriever 工具处理器
+ * 查询触发器列表
+ */
+
+const getTriggerModule = require('../../../triggers/get');
+
+/**
+ * 获取触发器列表
+ * @param {Object} params - 参数对象
+ * @param {string} params.triggerName - 可选，触发器名称（用于筛选）
+ * @param {string} params.targetObjectId - 可选，目标对象ID（用于筛选）
+ * @param {string} params.projectPath - 项目路径（可选，默认为当前工作目录）
+ */
+async function listTriggers({ triggerName = '', targetObjectId = '', projectPath = process.cwd() }) {
+    try {
+        // 构造查询条件
+        const queryBody = {
+            shownum: "2000",
+            showpage: "1",
+            fid: targetObjectId || "",
+            sname: triggerName || "",
+            rptcond: '',
+            rptorder: ''
+        };
+        
+        const argvs = ['', '', encodeURI(JSON.stringify(queryBody)), projectPath];
+        
+        const result = await getTriggerModule(argvs, true);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2)
+                }
+            ]
+        };
+    } catch (error) {
+        return {
+            content: [
+                { type: 'text', text: `获取触发器列表失败: ${error.message}` }
+            ]
+        };
+    }
+}
+
+module.exports = {
+    listTriggers
+};

package/src/mcp/tools/Trigger Publisher/handler.js

@@ -0,0 +1,34 @@
+/**
+ * Trigger Publisher 工具处理器
+ * 发布触发器到服务器
+ */
+
+const publishTriggerModule = require('../../../triggers/publish');
+
+/**
+ * 发布触发器到服务器
+ * @param {Object} params - 参数对象
+ * @param {string} params.triggerPath - 触发器路径 "objectName/triggerName"
+ * @param {string} params.projectPath - 项目路径（可选，默认为当前工作目录）
+ */
+async function publishTrigger({ triggerPath, projectPath = process.cwd() }) {
+    try {
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            const argvs = ['', '', triggerPath];
+            await publishTriggerModule(argvs);
+            const triggerName = triggerPath.split("/")[1];
+            return { content: [{ type: 'text', text: `✓ 发布成功！触发器 ${triggerName} 已发布到服务器` }] };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 发布失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    publishTrigger
+};

package/src/mcp/tools/Trigger Puller/handler.js

@@ -0,0 +1,40 @@
+/**
+ * Trigger Puller 工具处理器
+ * 从服务器拉取触发器
+ */
+
+const pullListModule = require('../../../triggers/pullList');
+
+/**
+ * 从服务器拉取触发器
+ * @param {Object} params - 参数对象
+ * @param {string} params.id - 触发器ID
+ * @param {string} params.projectPath - 项目路径（可选，默认为当前工作目录）
+ */
+async function pullTrigger({ id, projectPath = process.cwd() }) {
+    try {
+        // 使用 ID 从服务器拉取并创建/更新本地文件
+        const originalCwd = process.cwd();
+        process.chdir(projectPath);
+
+        try {
+            const argvs = ['', '', id, projectPath];
+            await pullListModule(argvs, true);
+
+            return {
+                content: [{
+                    type: 'text',
+                    text: `✓ 拉取成功！已从服务器拉取触发器（ID: ${id}）并在本地创建/更新`
+                }]
+            };
+        } finally {
+            process.chdir(originalCwd);
+        }
+    } catch (error) {
+        return { content: [{ type: 'text', text: `✗ 拉取失败: ${error.message}` }] };
+    }
+}
+
+module.exports = {
+    pullTrigger
+};

package/src/mcp/tools/ccdk/fetcher.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+/**
+ * CCDK API 文档爬取工具
+ * 用于从 CloudCC 官方文档爬取 CCDK API 信息并生成结构化知识库
+ * 
+ * TODO: 实现 CCDK 文档的自动爬取功能
+ * 目前 CCDK 文档是手动维护的，未来可以添加自动爬取功能
+ */
+
+console.error('CCDK 文档爬取工具');
+console.error('注意：当前 CCDK 文档为手动维护，暂无自动爬取功能');
+console.error('如需更新文档，请手动编辑 prompt.js 文件');
+
+// 预留：未来可以添加从官方文档网站爬取 CCDK API 的功能
+// 参考 dev-env 的实现方式
+
+process.exit(0);

package/src/mcp/tools/ccdk/handler.js

@@ -0,0 +1,98 @@
+/**
+ * CCDK 工具处理器
+ * 提供 CCDK API 文档查询、搜索等功能的具体实现
+ */
+
+const { ccdkApiTree } = require('./prompt.js');
+
+/**
+ * 获取 CCDK 文档（完整或指定模块）
+ */
+async function getCcdkDocs({ module } = {}) {
+    const tree = ccdkApiTree;
+
+    if (module) {
+        const moduleInfo = tree[module];
+        if (moduleInfo) {
+            let content = `# ${module} - ${moduleInfo.name}\n\n${moduleInfo.description}\n\n---\n\n`;
+            Object.entries(moduleInfo.apis).forEach(([apiName, apiInfo]) => {
+                content += `## ${apiName}\n\n**描述**: ${apiInfo.description}\n\n**版本**: ${apiInfo.version}\n\n${apiInfo.content}\n\n---\n\n`;
+            });
+            return { content: [{ type: 'text', text: content }] };
+        } else {
+            const modules = Object.keys(tree);
+            return { content: [{ type: 'text', text: `未找到 "${module}" 模块的文档。\n\n可用模块：\n${modules.map(m => `- ${m}`).join('\n')}` }] };
+        }
+    } else {
+        let content = '# CloudCC CCDK API 模块概览\n\n';
+        Object.entries(tree).forEach(([moduleName, moduleInfo]) => {
+            const apiCount = Object.keys(moduleInfo.apis).length;
+            content += `## ${moduleName} - ${moduleInfo.name}\n\n${moduleInfo.description}\n\n**API 数量**: ${apiCount}\n\n---\n\n`;
+        });
+        content += '\n💡 使用 `get_ccdk_docs` 工具并指定 `module` 参数获取模块详细文档';
+        return { content: [{ type: 'text', text: content }] };
+    }
+}
+
+/**
+ * 搜索 CCDK 文档
+ */
+async function searchCcdkDocs({ keyword, maxResults = 20 }) {
+    const tree = ccdkApiTree;
+    const keywordLower = keyword.toLowerCase();
+    const results = [];
+
+    Object.entries(tree).forEach(([moduleName, moduleInfo]) => {
+        Object.entries(moduleInfo.apis).forEach(([apiName, apiInfo]) => {
+            let score = 0;
+            if (apiName.toLowerCase() === keywordLower) score += 100;
+            else if (apiName.toLowerCase().includes(keywordLower)) score += 50;
+            if (apiInfo.keyword.toLowerCase().includes(keywordLower)) score += 30;
+            if (apiInfo.description.toLowerCase().includes(keywordLower)) score += 20;
+            if (apiInfo.content.toLowerCase().includes(keywordLower)) score += 10;
+            if (moduleInfo.name.toLowerCase().includes(keywordLower)) score += 15;
+            if (moduleInfo.description.toLowerCase().includes(keywordLower)) score += 10;
+            if (score > 0) results.push({ score, moduleName, moduleInfo, apiName, apiInfo });
+        });
+    });
+
+    results.sort((a, b) => b.score - a.score);
+    const topResults = results.slice(0, maxResults);
+
+    if (topResults.length > 0) {
+        let content = `# 搜索结果：${keyword}\n\n找到 ${topResults.length} 个相关 API (共 ${results.length} 个匹配)\n\n---\n\n`;
+        topResults.forEach(({ moduleName, moduleInfo, apiName, apiInfo }) => {
+            content += `## ${moduleName}.${apiName}\n\n**模块**: ${moduleInfo.name}\n\n**描述**: ${apiInfo.description}\n\n**版本**: ${apiInfo.version}\n\n${apiInfo.content}\n\n---\n\n`;
+        });
+        return { content: [{ type: 'text', text: content }] };
+    } else {
+        return { content: [{ type: 'text', text: `未找到包含 "${keyword}" 的内容。` }] };
+    }
+}
+
+/**
+ * 列出 CCDK 模块
+ */
+async function listCcdkModules({ showApis = false }) {
+    const tree = ccdkApiTree;
+    let content = '# CCDK API 模块列表\n\n';
+    Object.entries(tree).forEach(([moduleName, moduleInfo]) => {
+        const apiCount = Object.keys(moduleInfo.apis).length;
+        content += `## ${moduleName} - ${moduleInfo.name}\n\n${moduleInfo.description}\n\n**API 数量**: ${apiCount}\n\n`;
+        if (showApis) {
+            content += '**包含 API**:\n';
+            Object.entries(moduleInfo.apis).forEach(([apiName, apiInfo]) => {
+                content += `- \`${apiName}\`: ${apiInfo.description}\n`;
+            });
+            content += '\n';
+        }
+        content += '---\n\n';
+    });
+    return { content: [{ type: 'text', text: content }] };
+}
+
+module.exports = {
+    getCcdkDocs,
+    searchCcdkDocs,
+    listCcdkModules
+};