@zzp123/mcp-zentao 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 bigtian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,294 @@
+# MCP-Zentao
+
+禅道项目管理系统的高级API集成包，提供任务管理、Bug跟踪等功能的完整封装，专为Cursor IDE设计的MCP扩展。
+
+## 安装
+
+```bash
+npm install @bigtian/mcp-zentao -g
+```
+
+## 使用方法
+
+### 首次使用（配置禅道信息）
+
+首次使用时，需要提供禅道的配置信息：
+
+```bash
+zentao '{"config":{"url":"https://your-zentao-url","username":"your-username","password":"your-password","apiVersion":"v1"},"name":"张三","age":25,"skills":["编程","设计"]}'
+```
+
+配置信息会被保存在用户目录下的 `.zentao/config.json` 文件中，后续使用时无需再次提供。
+
+### 后续使用
+
+配置完成后，只需要提供任务相关的信息即可：
+
+```bash
+zentao '{"name":"张三","age":25,"skills":["编程","设计"]}'
+```
+
+### 更新配置
+
+如果需要更新禅道配置信息，只需要再次提供 config 参数即可：
+
+```bash
+zentao '{"config":{"url":"https://new-zentao-url","username":"new-username","password":"new-password","apiVersion":"v1"},"name":"张三","age":25,"skills":["编程","设计"]}'
+```
+
+## 配置文件位置
+
+配置文件保存在用户目录下的 `.zentao/config.json` 文件中：
+
+- Windows: `C:\Users\你的用户名\.zentao\config.json`
+- macOS/Linux: `~/.zentao/config.json`
+
+## 功能特性
+
+- 支持配置信息的持久化存储
+- 自动管理禅道API的认证信息
+- 提供任务创建、更新、完成等功能
+- 支持Bug跟踪和处理
+- 完整的类型定义支持
+
+## 注意事项
+
+- 配置文件中包含敏感信息，请确保文件权限设置正确
+- 建议定期更新密码，以确保安全性
+- 如遇到问题，可以删除配置文件重新配置
+
+## 许可证
+
+MIT
+
+## 特点
+
+- 完整的禅道API封装
+- 简单易用的接口设计
+- 类型安全（TypeScript支持）
+- 完善的错误处理
+- 自动化的认证管理
+
+## 与其他项目的区别
+
+不同于通用的数据库操作工具（如 mcp-mysql-server），本项目专注于提供：
+
+1. 禅道系统特定的业务功能
+2. 高级别的API抽象
+3. 完整的禅道工作流支持
+4. 开箱即用的禅道集成方案
+
+## 本地开发
+
+1. 克隆仓库
+```bash
+git clone https://github.com/bigtian/mcp-zentao.git
+cd mcp-zentao
+```
+
+2. 安装依赖
+```bash
+npm install
+```
+
+3. 运行测试
+```bash
+npm test
+```
+
+4. 构建项目
+```bash
+npm run build
+```
+
+## Docker 使用
+
+### 使用 docker-compose（推荐）
+
+1. 复制环境变量模板并修改配置
+```bash
+cp .env.example .env
+# 编辑 .env 文件，填入你的禅道系统配置
+```
+
+2. 启动服务
+```bash
+docker-compose up -d
+```
+
+3. 查看日志
+```bash
+docker-compose logs -f
+```
+
+### 手动使用 Docker
+
+1. 构建镜像
+```bash
+docker build -t mcp-zentao .
+```
+
+2. 运行容器
+```bash
+docker run -d \
+  --name mcp-zentao \
+  -p 3000:3000 \
+  -e ZENTAO_URL=your-zentao-url \
+  -e ZENTAO_USERNAME=your-username \
+  -e ZENTAO_PASSWORD=your-password \
+  -e ZENTAO_API_VERSION=v1 \
+  -v $(pwd)/logs:/app/logs \
+  mcp-zentao
+```
+
+### 在 Cursor IDE 中配置
+
+在 Cursor IDE 的配置文件中添加以下配置：
+
+```json
+{
+  "mcpServers": {
+    "zentao": {
+      "url": "http://localhost:3000"
+    }
+  }
+}
+```
+
+## 基本使用
+
+```typescript
+import { ZentaoAPI } from '@bigtian/mcp-zentao';
+
+// 创建API实例
+const api = new ZentaoAPI({
+    url: 'https://your-zentao-url',  // 你的禅道系统URL
+    username: 'your-username',        // 用户名
+    password: 'your-password',        // 密码
+    apiVersion: 'v1'                 // API版本，默认为v1
+});
+
+// 获取我的任务列表
+async function getMyTasks() {
+    try {
+        const tasks = await api.getMyTasks();
+        console.log('我的任务:', tasks);
+    } catch (error) {
+        console.error('获取任务失败:', error);
+    }
+}
+
+// 获取我的Bug列表
+async function getMyBugs() {
+    try {
+        const bugs = await api.getMyBugs();
+        console.log('我的Bug:', bugs);
+    } catch (error) {
+        console.error('获取Bug失败:', error);
+    }
+}
+
+// 完成任务
+async function finishTask(taskId: number) {
+    try {
+        await api.finishTask(taskId);
+        console.log('任务已完成');
+    } catch (error) {
+        console.error('完成任务失败:', error);
+    }
+}
+
+// 解决Bug
+async function resolveBug(bugId: number) {
+    try {
+        await api.resolveBug(bugId, {
+            resolution: 'fixed',
+            resolvedBuild: 'trunk',
+            comment: '问题已修复'
+        });
+        console.log('Bug已解决');
+    } catch (error) {
+        console.error('解决Bug失败:', error);
+    }
+}
+```
+
+## API文档
+
+### ZentaoAPI 类
+
+#### 构造函数
+
+```typescript
+constructor(config: {
+    url: string;          // 禅道系统URL
+    username: string;     // 用户名
+    password: string;     // 密码
+    apiVersion?: string;  // API版本，默认为v1
+})
+```
+
+#### 方法
+
+1. `getMyTasks(): Promise<Task[]>`
+   - 获取当前用户的任务列表
+   - 返回: Promise<Task[]>
+
+2. `getMyBugs(): Promise<Bug[]>`
+   - 获取当前用户的Bug列表
+   - 返回: Promise<Bug[]>
+
+3. `finishTask(taskId: number): Promise<void>`
+   - 完成指定ID的任务
+   - 参数: taskId - 任务ID
+   - 返回: Promise<void>
+
+4. `resolveBug(bugId: number, resolution: BugResolution): Promise<void>`
+   - 解决指定ID的Bug
+   - 参数: 
+     - bugId - Bug ID
+     - resolution - Bug解决方案
+   - 返回: Promise<void>
+
+### 类型定义
+
+```typescript
+interface Task {
+    id: number;
+    name: string;
+    status: string;
+    pri: number;
+    // ... 其他任务属性
+}
+
+interface Bug {
+    id: number;
+    title: string;
+    status: string;
+    severity: number;
+    // ... 其他Bug属性
+}
+
+interface BugResolution {
+    resolution: string;      // 解决方案类型
+    resolvedBuild?: string; // 解决版本
+    duplicateBug?: number;  // 重复Bug ID
+    comment?: string;       // 备注
+}
+```
+
+## 注意事项
+
+1. 确保提供正确的禅道系统URL和API版本
+2. 用户名和密码需要有相应的API访问权限
+3. 所有API调用都是异步的，需要使用async/await或Promise处理
+4. 错误处理建议使用try/catch进行捕获
+
+## 开发环境
+
+- Node.js >= 14.0.0
+- TypeScript >= 4.0.0
+
+## 贡献
+
+欢迎提交Issue和Pull Request！

package/dist/api/zentaoApi.d.ts

@@ -0,0 +1,38 @@
+import { Bug, BugStatus, CreateTaskRequest, Task, TaskStatus, ZentaoConfig } from '../types/zentao';
+export interface Product {
+    id: number;
+    name: string;
+    code: string;
+    status: string;
+    desc: string;
+}
+export interface TaskUpdate {
+    consumed?: number;
+    left?: number;
+    status?: TaskStatus;
+    finishedDate?: string;
+    comment?: string;
+}
+export interface BugResolution {
+    resolution: 'fixed' | 'notrepro' | 'duplicate' | 'bydesign' | 'willnotfix' | 'tostory' | 'external';
+    resolvedBuild?: string;
+    duplicateBug?: number;
+    comment?: string;
+}
+export declare class ZentaoAPI {
+    private config;
+    private client;
+    private token;
+    constructor(config: ZentaoConfig);
+    private getToken;
+    private request;
+    getMyTasks(status?: TaskStatus): Promise<Task[]>;
+    getTaskDetail(taskId: number): Promise<Task>;
+    getProducts(): Promise<Product[]>;
+    getMyBugs(status?: BugStatus, productId?: number): Promise<Bug[]>;
+    getBugDetail(bugId: number): Promise<Bug>;
+    updateTask(taskId: number, update: TaskUpdate): Promise<Task>;
+    finishTask(taskId: number, update?: TaskUpdate): Promise<Task>;
+    resolveBug(bugId: number, resolution: BugResolution): Promise<Bug>;
+    createTask(task: CreateTaskRequest): Promise<Task>;
+}

package/dist/api/zentaoApi.js

@@ -0,0 +1,230 @@
+import axios from 'axios';
+import { createHash } from 'crypto';
+export class ZentaoAPI {
+    config;
+    client;
+    token = null;
+    constructor(config) {
+        this.config = config;
+        this.client = axios.create({
+            baseURL: `${this.config.url}/api.php/${this.config.apiVersion}`,
+            timeout: 10000,
+        });
+    }
+    async getToken() {
+        if (this.token)
+            return this.token;
+        const password = createHash('md5')
+            .update(this.config.password)
+            .digest('hex');
+        try {
+            console.log('正在请求token...');
+            console.log('请求URL:', `${this.config.url}/api.php/${this.config.apiVersion}/tokens`);
+            const response = await this.client.post('/tokens', {
+                account: this.config.username,
+                password,
+            });
+            console.log('服务器响应:', response.data);
+            if (response.status === 200 || response.status === 201) {
+                if (typeof response.data === 'object' && response.data.token) {
+                    this.token = response.data.token;
+                    return this.token;
+                }
+                throw new Error(`获取token失败: 响应格式不正确 ${JSON.stringify(response.data)}`);
+            }
+            throw new Error(`获取token失败: 状态码 ${response.status}`);
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                const errorMessage = error.response
+                    ? `状态码: ${error.response.status}, 响应: ${JSON.stringify(error.response.data)}`
+                    : error.message;
+                throw new Error(`登录失败: ${errorMessage}`);
+            }
+            throw error;
+        }
+    }
+    async request(method, url, params, data) {
+        const token = await this.getToken();
+        try {
+            console.log(`正在请求 ${method} ${url}`, { params, data });
+            const response = await this.client.request({
+                method,
+                url,
+                params,
+                data,
+                headers: { Token: token },
+            });
+            console.log(`响应状态码: ${response.status}`);
+            console.log('响应数据:', response.data);
+            return response.data;
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                console.error('请求失败:', {
+                    status: error.response?.status,
+                    data: error.response?.data,
+                    message: error.message
+                });
+                throw new Error(`请求失败: ${error.response?.data?.message || error.message}`);
+            }
+            throw error;
+        }
+    }
+    async getMyTasks(status) {
+        const params = {
+            assignedTo: this.config.username,
+            status: status || 'all',
+        };
+        const response = await this.request('GET', '/tasks', params);
+        return response.tasks;
+    }
+    async getTaskDetail(taskId) {
+        console.log(`正在获取任务 ${taskId} 的详情`);
+        const response = await this.request('GET', `/tasks/${taskId}`);
+        console.log('任务详情响应:', response);
+        if (!response) {
+            throw new Error(`获取任务详情失败: 响应为空`);
+        }
+        // 检查响应格式
+        if (response && typeof response === 'object') {
+            if ('task' in response) {
+                return response.task;
+            }
+            else {
+                // 如果响应本身就是任务对象
+                return response;
+            }
+        }
+        throw new Error(`获取任务详情失败: 响应格式不正确 ${JSON.stringify(response)}`);
+    }
+    async getProducts() {
+        try {
+            console.log('正在获取产品列表...');
+            const response = await this.request('GET', '/products');
+            console.log('产品列表响应:', response);
+            if (Array.isArray(response)) {
+                return response;
+            }
+            else if (response && typeof response === 'object') {
+                if (Array.isArray(response.products)) {
+                    return response.products;
+                }
+            }
+            throw new Error(`获取产品列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
+        }
+        catch (error) {
+            console.error('获取产品列表失败:', error);
+            throw error;
+        }
+    }
+    async getMyBugs(status, productId) {
+        if (!productId) {
+            // 如果没有提供产品ID，获取第一个可用的产品
+            const products = await this.getProducts();
+            if (products.length === 0) {
+                throw new Error('没有可用的产品');
+            }
+            productId = products[0].id;
+            console.log(`使用第一个可用的产品ID: ${productId}`);
+        }
+        const params = {
+            assignedTo: this.config.username,
+            status: status || 'all',
+            product: productId
+        };
+        try {
+            console.log('正在获取Bug列表，参数:', params);
+            const response = await this.request('GET', '/bugs', params);
+            console.log('Bug列表响应:', response);
+            if (Array.isArray(response)) {
+                return response;
+            }
+            else if (response && typeof response === 'object' && Array.isArray(response.bugs)) {
+                return response.bugs;
+            }
+            throw new Error(`获取Bug列表失败: 响应格式不正确 ${JSON.stringify(response)}`);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('Need product id')) {
+                throw new Error('获取Bug列表失败: 请提供产品ID');
+            }
+            console.error('获取Bug列表失败:', error);
+            throw error;
+        }
+    }
+    async getBugDetail(bugId) {
+        const response = await this.request('GET', `/bugs/${bugId}`);
+        return response.bug;
+    }
+    async updateTask(taskId, update) {
+        try {
+            console.log(`正在更新任务 ${taskId}...`);
+            const response = await this.request('PUT', `/tasks/${taskId}`, undefined, {
+                ...update,
+                assignedTo: this.config.username,
+            });
+            console.log('任务更新响应:', response);
+            return response;
+        }
+        catch (error) {
+            console.error('更新任务失败:', error);
+            throw error;
+        }
+    }
+    async finishTask(taskId, update = {}) {
+        try {
+            console.log(`正在完成任务 ${taskId}...`);
+            const finalUpdate = {
+                status: 'done',
+                finishedDate: new Date().toISOString(),
+                ...update,
+            };
+            return await this.updateTask(taskId, finalUpdate);
+        }
+        catch (error) {
+            console.error('完成任务失败:', error);
+            throw error;
+        }
+    }
+    async resolveBug(bugId, resolution) {
+        try {
+            console.log(`正在解决Bug ${bugId}...`);
+            const response = await this.request('PUT', `/bugs/${bugId}`, undefined, {
+                status: 'resolved',
+                assignedTo: this.config.username,
+                ...resolution,
+                resolvedDate: new Date().toISOString(),
+            });
+            console.log('Bug解决响应:', response);
+            return response;
+        }
+        catch (error) {
+            console.error('解决Bug失败:', error);
+            throw error;
+        }
+    }
+    async createTask(task) {
+        try {
+            console.log('正在创建新任务...');
+            if (!task.execution) {
+                throw new Error('创建任务需要指定执行ID');
+            }
+            // 将数据转换为表单格式
+            const formData = new URLSearchParams();
+            Object.entries(task).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    formData.append(key, value.toString());
+                }
+            });
+            // 在URL中添加执行ID
+            const response = await this.request('POST', `/executions/${task.execution}/tasks`, undefined, formData);
+            console.log('创建任务响应:', response);
+            return response;
+        }
+        catch (error) {
+            console.error('创建任务失败:', error);
+            throw error;
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,9 @@
+export interface ZentaoConfig {
+    url: string;
+    username: string;
+    password: string;
+    apiVersion: string;
+}
+export declare function saveConfig(config: ZentaoConfig): void;
+export declare function loadConfig(): ZentaoConfig | null;
+export declare function isConfigured(): boolean;

package/dist/config.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+// 定义配置文件路径
+const CONFIG_DIR = path.join(os.homedir(), '.zentao');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// 保存配置
+export function saveConfig(config) {
+    // 确保配置目录存在
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    // 写入配置文件
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+// 读取配置
+export function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+            return config;
+        }
+    }
+    catch (error) {
+        console.error('读取配置文件失败:', error);
+    }
+    return null;
+}
+// 检查是否已配置
+export function isConfigured() {
+    return fs.existsSync(CONFIG_FILE);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { ZentaoConfig } from './config.js';
+interface UserParams {
+    config?: ZentaoConfig;
+    name: string;
+    age: number;
+    skills: string[];
+}
+export default function main(params: UserParams): Promise<void>;
+export {};

package/dist/index.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { ZentaoAPI } from './api/zentaoApi.js';
+import { loadConfig, saveConfig } from './config.js';
+// 解析命令行参数
+const args = process.argv.slice(2);
+let configData = null;
+// 查找 --config 参数
+const configIndex = args.indexOf('--config');
+if (configIndex !== -1 && configIndex + 1 < args.length) {
+    try {
+        // 获取 --config 后面的 JSON 字符串并解析
+        const jsonStr = args[configIndex + 1];
+        configData = JSON.parse(jsonStr);
+        console.log('成功解析配置数据:', configData);
+        // 如果配置数据中包含 config 对象，则保存配置
+        if (configData.config) {
+            console.log('正在保存配置...');
+            saveConfig(configData.config);
+        }
+    }
+    catch (error) {
+        console.error('配置解析失败:', error);
+        process.exit(1);
+    }
+}
+// Create an MCP server
+const server = new McpServer({
+    name: "Zentao API",
+    version: "1.0.0"
+});
+// Initialize ZentaoAPI instance
+let zentaoApi = null;
+export default async function main(params) {
+    console.log('接收到的参数:', params);
+    // 如果传入了配置信息，就保存它
+    if (params.config) {
+        console.log('保存新的配置信息...');
+        saveConfig(params.config);
+    }
+}
+// Add Zentao configuration tool
+server.tool("initZentao", {}, async ({}) => {
+    let config;
+    // 尝试从配置文件加载配置
+    const savedConfig = loadConfig();
+    if (!savedConfig) {
+        throw new Error("No configuration found. Please provide complete Zentao configuration.");
+    }
+    config = savedConfig;
+    zentaoApi = new ZentaoAPI(config);
+    return {
+        content: [{ type: "text", text: JSON.stringify(config, null, 2) }]
+    };
+});
+// Add getMyTasks tool
+server.tool("getMyTasks", {
+    status: z.enum(['wait', 'doing', 'done', 'all']).optional()
+}, async ({ status }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const tasks = await zentaoApi.getMyTasks(status);
+    return {
+        content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }]
+    };
+});
+// Add getTaskDetail tool
+server.tool("getTaskDetail", {
+    taskId: z.number()
+}, async ({ taskId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const task = await zentaoApi.getTaskDetail(taskId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(task, null, 2) }]
+    };
+});
+// Add getProducts tool
+server.tool("getProducts", {}, async () => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const products = await zentaoApi.getProducts();
+    return {
+        content: [{ type: "text", text: JSON.stringify(products, null, 2) }]
+    };
+});
+// Add getMyBugs tool
+server.tool("getMyBugs", {
+    status: z.enum(['active', 'resolved', 'closed', 'all']).optional(),
+    productId: z.number().optional()
+}, async ({ status, productId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const bugs = await zentaoApi.getMyBugs(status, productId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(bugs, null, 2) }]
+    };
+});
+// Add getBugDetail tool
+server.tool("getBugDetail", {
+    bugId: z.number()
+}, async ({ bugId }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const bug = await zentaoApi.getBugDetail(bugId);
+    return {
+        content: [{ type: "text", text: JSON.stringify(bug, null, 2) }]
+    };
+});
+// Add updateTask tool
+server.tool("updateTask", {
+    taskId: z.number(),
+    update: z.object({
+        consumed: z.number().optional(),
+        left: z.number().optional(),
+        status: z.enum(['wait', 'doing', 'done']).optional(),
+        finishedDate: z.string().optional(),
+        comment: z.string().optional()
+    })
+}, async ({ taskId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const task = await zentaoApi.updateTask(taskId, update);
+    return {
+        content: [{ type: "text", text: JSON.stringify(task, null, 2) }]
+    };
+});
+// Add finishTask tool
+server.tool("finishTask", {
+    taskId: z.number(),
+    update: z.object({
+        consumed: z.number().optional(),
+        left: z.number().optional(),
+        comment: z.string().optional()
+    }).optional()
+}, async ({ taskId, update }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const task = await zentaoApi.finishTask(taskId, update);
+    return {
+        content: [{ type: "text", text: JSON.stringify(task, null, 2) }]
+    };
+});
+// Add resolveBug tool
+server.tool("resolveBug", {
+    bugId: z.number(),
+    resolution: z.object({
+        resolution: z.enum(['fixed', 'notrepro', 'duplicate', 'bydesign', 'willnotfix', 'tostory', 'external']),
+        resolvedBuild: z.string().optional(),
+        duplicateBug: z.number().optional(),
+        comment: z.string().optional()
+    })
+}, async ({ bugId, resolution }) => {
+    if (!zentaoApi)
+        throw new Error("Please initialize Zentao API first");
+    const bug = await zentaoApi.resolveBug(bugId, resolution);
+    return {
+        content: [{ type: "text", text: JSON.stringify(bug, null, 2) }]
+    };
+});
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+await server.connect(transport).catch(console.error);

package/dist/mcpCommands.d.ts

@@ -0,0 +1,6 @@
+import { BugStatus, TaskStatus, ZentaoConfig } from './types/zentao';
+export declare function mcp_zentao_connect(config: ZentaoConfig): Promise<string>;
+export declare function mcp_zentao_tasks(status?: TaskStatus): Promise<string>;
+export declare function mcp_zentao_task(taskId: number): Promise<string>;
+export declare function mcp_zentao_bugs(status?: BugStatus): Promise<string>;
+export declare function mcp_zentao_bug(bugId: number): Promise<string>;

package/dist/mcpCommands.js

@@ -0,0 +1,70 @@
+import { ZentaoAPI } from './api/zentaoApi';
+import { BugService } from './services/bugService';
+import { TaskService } from './services/taskService';
+import { formatBugDetail, formatBugsTable, formatTaskDetail, formatTasksTable } from './utils/displayUtils';
+let api = null;
+let taskService = null;
+let bugService = null;
+function initializeServices(config) {
+    api = new ZentaoAPI(config);
+    taskService = new TaskService(api);
+    bugService = new BugService(api);
+}
+export async function mcp_zentao_connect(config) {
+    try {
+        initializeServices(config);
+        await api?.getMyTasks(); // 测试连接
+        return '禅道连接成功';
+    }
+    catch (error) {
+        return `连接失败: ${error instanceof Error ? error.message : '未知错误'}`;
+    }
+}
+export async function mcp_zentao_tasks(status) {
+    try {
+        if (!taskService)
+            throw new Error('请先连接禅道');
+        const tasks = await taskService.getMyTasks(status);
+        if (tasks.length === 0)
+            return '没有找到任何任务';
+        return formatTasksTable(tasks);
+    }
+    catch (error) {
+        return `获取任务失败: ${error instanceof Error ? error.message : '未知错误'}`;
+    }
+}
+export async function mcp_zentao_task(taskId) {
+    try {
+        if (!taskService)
+            throw new Error('请先连接禅道');
+        const task = await taskService.getTaskDetail(taskId);
+        return formatTaskDetail(task);
+    }
+    catch (error) {
+        return `获取任务详情失败: ${error instanceof Error ? error.message : '未知错误'}`;
+    }
+}
+export async function mcp_zentao_bugs(status) {
+    try {
+        if (!bugService)
+            throw new Error('请先连接禅道');
+        const bugs = await bugService.getMyBugs(status);
+        if (bugs.length === 0)
+            return '没有找到任何Bug';
+        return formatBugsTable(bugs);
+    }
+    catch (error) {
+        return `获取Bug失败: ${error instanceof Error ? error.message : '未知错误'}`;
+    }
+}
+export async function mcp_zentao_bug(bugId) {
+    try {
+        if (!bugService)
+            throw new Error('请先连接禅道');
+        const bug = await bugService.getBugDetail(bugId);
+        return formatBugDetail(bug);
+    }
+    catch (error) {
+        return `获取Bug详情失败: ${error instanceof Error ? error.message : '未知错误'}`;
+    }
+}

package/dist/services/bugService.d.ts

@@ -0,0 +1,9 @@
+import { ZentaoAPI } from '../api/zentaoApi';
+import { Bug, BugStatus } from '../types/zentao';
+export declare class BugService {
+    private api;
+    constructor(api: ZentaoAPI);
+    getMyBugs(status?: BugStatus): Promise<Bug[]>;
+    getBugDetail(bugId: number): Promise<Bug>;
+    private enrichBugData;
+}

package/dist/services/bugService.js

@@ -0,0 +1,47 @@
+import { calculateDaysDifference } from '../utils/dateUtils';
+export class BugService {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async getMyBugs(status) {
+        const bugs = await this.api.getMyBugs(status);
+        return bugs.map(bug => this.enrichBugData(bug));
+    }
+    async getBugDetail(bugId) {
+        const bug = await this.api.getBugDetail(bugId);
+        return this.enrichBugData(bug);
+    }
+    enrichBugData(bug) {
+        const enrichedBug = { ...bug };
+        // 添加严重程度标识
+        const severity = bug.severity;
+        if (severity >= 3) {
+            enrichedBug.severity_level = '严重';
+        }
+        else if (severity >= 2) {
+            enrichedBug.severity_level = '一般';
+        }
+        else {
+            enrichedBug.severity_level = '轻微';
+        }
+        // 计算处理时间
+        if (bug.openedDate) {
+            const daysOpen = calculateDaysDifference(bug.openedDate);
+            enrichedBug.days_open = daysOpen;
+            if (daysOpen > 7) {
+                enrichedBug.aging_status = '已超过7天';
+                enrichedBug.aging_description = `已开启${daysOpen}天，请尽快处理`;
+            }
+            else if (daysOpen > 3) {
+                enrichedBug.aging_status = '已超过3天';
+                enrichedBug.aging_description = `已开启${daysOpen}天`;
+            }
+            else {
+                enrichedBug.aging_status = '新建';
+                enrichedBug.aging_description = '新建Bug';
+            }
+        }
+        return enrichedBug;
+    }
+}

package/dist/services/taskService.d.ts

@@ -0,0 +1,9 @@
+import { ZentaoAPI } from '../api/zentaoApi';
+import { Task, TaskStatus } from '../types/zentao';
+export declare class TaskService {
+    private api;
+    constructor(api: ZentaoAPI);
+    getMyTasks(status?: TaskStatus): Promise<Task[]>;
+    getTaskDetail(taskId: number): Promise<Task>;
+    private enrichTaskData;
+}

package/dist/services/taskService.js

@@ -0,0 +1,44 @@
+import { calculateRemainingDays } from '../utils/dateUtils';
+export class TaskService {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async getMyTasks(status) {
+        const tasks = await this.api.getMyTasks(status);
+        return tasks.map(task => this.enrichTaskData(task));
+    }
+    async getTaskDetail(taskId) {
+        const task = await this.api.getTaskDetail(taskId);
+        return this.enrichTaskData(task);
+    }
+    enrichTaskData(task) {
+        const enrichedTask = { ...task };
+        // 添加优先级标识
+        const priority = task.pri;
+        if (priority >= 4) {
+            enrichedTask.priority_level = '高';
+        }
+        else if (priority >= 2) {
+            enrichedTask.priority_level = '中';
+        }
+        else {
+            enrichedTask.priority_level = '低';
+        }
+        // 计算剩余时间
+        if (task.deadline) {
+            const remainingDays = calculateRemainingDays(task.deadline);
+            enrichedTask.remaining_days = remainingDays;
+            if (remainingDays < 0) {
+                enrichedTask.status_description = '已逾期';
+            }
+            else if (remainingDays === 0) {
+                enrichedTask.status_description = '今日到期';
+            }
+            else {
+                enrichedTask.status_description = `还剩${remainingDays}天`;
+            }
+        }
+        return enrichedTask;
+    }
+}

package/dist/types/zentao.d.ts

@@ -0,0 +1,58 @@
+export interface ZentaoConfig {
+    url: string;
+    username: string;
+    password: string;
+    apiVersion: string;
+}
+export interface CreateTaskRequest {
+    name: string;
+    desc?: string;
+    pri?: number;
+    estimate?: number;
+    project?: number;
+    execution?: number;
+    module?: number;
+    story?: number;
+    type?: string;
+    assignedTo?: string;
+    estStarted?: string;
+    deadline?: string;
+}
+export interface Task {
+    id: number;
+    name: string;
+    status: string;
+    pri: number;
+    deadline?: string;
+    desc?: string;
+    priority_level?: '高' | '中' | '低';
+    remaining_days?: number;
+    status_description?: string;
+}
+export interface Bug {
+    id: number;
+    title: string;
+    status: string;
+    severity: number;
+    steps?: string;
+    openedDate?: string;
+    severity_level?: '严重' | '一般' | '轻微';
+    days_open?: number;
+    aging_status?: string;
+    aging_description?: string;
+}
+export interface TaskUpdate {
+    consumed?: number;
+    left?: number;
+    status?: TaskStatus;
+    finishedDate?: string;
+    comment?: string;
+}
+export interface BugResolution {
+    resolution: 'fixed' | 'notrepro' | 'duplicate' | 'bydesign' | 'willnotfix' | 'tostory' | 'external';
+    resolvedBuild?: string;
+    duplicateBug?: number;
+    comment?: string;
+}
+export type TaskStatus = 'wait' | 'doing' | 'done' | 'all';
+export type BugStatus = 'active' | 'resolved' | 'closed' | 'all';

package/dist/types/zentao.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/dateUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function formatDate(date: Date): string;
+export declare function calculateRemainingDays(deadline: string): number;
+export declare function calculateDaysDifference(startDate: string): number;

package/dist/utils/dateUtils.js

@@ -0,0 +1,19 @@
+export function formatDate(date) {
+    return date.toISOString().split('T')[0];
+}
+export function calculateRemainingDays(deadline) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const deadlineDate = new Date(deadline);
+    deadlineDate.setHours(0, 0, 0, 0);
+    const diffTime = deadlineDate.getTime() - today.getTime();
+    return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+}
+export function calculateDaysDifference(startDate) {
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const start = new Date(startDate);
+    start.setHours(0, 0, 0, 0);
+    const diffTime = today.getTime() - start.getTime();
+    return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+}

package/dist/utils/displayUtils.d.ts

@@ -0,0 +1,5 @@
+import { Bug, Task } from '../types/zentao';
+export declare function formatTasksTable(tasks: Task[]): string;
+export declare function formatBugsTable(bugs: Bug[]): string;
+export declare function formatTaskDetail(task: Task): string;
+export declare function formatBugDetail(bug: Bug): string;

package/dist/utils/displayUtils.js

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import { table } from 'table';
+const tableConfig = {
+    border: {
+        topBody: `─`,
+        topJoin: `┬`,
+        topLeft: `┌`,
+        topRight: `┐`,
+        bottomBody: `─`,
+        bottomJoin: `┴`,
+        bottomLeft: `└`,
+        bottomRight: `┘`,
+        bodyLeft: `│`,
+        bodyRight: `│`,
+        bodyJoin: `│`,
+        joinBody: `─`,
+        joinLeft: `├`,
+        joinRight: `┤`,
+        joinJoin: `┼`
+    }
+};
+export function formatTasksTable(tasks) {
+    const header = ['ID', '标题', '优先级', '状态', '剩余时间'];
+    const rows = tasks.map(task => {
+        const priorityColor = {
+            '高': chalk.red,
+            '中': chalk.yellow,
+            '低': chalk.green
+        }[task.priority_level || '低'];
+        return [
+            task.id.toString(),
+            task.name,
+            priorityColor(task.priority_level || '低'),
+            task.status,
+            `${task.remaining_days || '-'}天`
+        ];
+    });
+    return table([header, ...rows], tableConfig);
+}
+export function formatBugsTable(bugs) {
+    const header = ['ID', '标题', '严重程度', '状态', '处理时间'];
+    const rows = bugs.map(bug => {
+        const severityColor = {
+            '严重': chalk.red,
+            '一般': chalk.yellow,
+            '轻微': chalk.green
+        }[bug.severity_level || '轻微'];
+        return [
+            bug.id.toString(),
+            bug.title,
+            severityColor(bug.severity_level || '轻微'),
+            bug.status,
+            bug.aging_status || '-'
+        ];
+    });
+    return table([header, ...rows], tableConfig);
+}
+export function formatTaskDetail(task) {
+    const lines = [
+        chalk.blue.bold(`任务详情 #${task.id}`),
+        `标题: ${task.name}`,
+        `状态: ${task.status}`,
+        `优先级: ${task.priority_level || '-'}`,
+        task.status_description ? `时间状态: ${task.status_description}` : '',
+        '',
+        '描述:',
+        task.desc || '无'
+    ];
+    return lines.filter(Boolean).join('\n');
+}
+export function formatBugDetail(bug) {
+    const lines = [
+        chalk.red.bold(`Bug详情 #${bug.id}`),
+        `标题: ${bug.title}`,
+        `状态: ${bug.status}`,
+        `严重程度: ${bug.severity_level || '-'}`,
+        bug.aging_description ? `处理时间: ${bug.aging_description}` : '',
+        '',
+        '描述:',
+        bug.steps || '无'
+    ];
+    return lines.filter(Boolean).join('\n');
+}

package/json-args.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+// 获取命令行参数中的 JSON 字符串
+const jsonArg = process.argv[2];
+
+if (!jsonArg) {
+    console.error('请提供 JSON 参数');
+    process.exit(1);
+}
+
+try {
+    // 解析 JSON 字符串
+    const params = JSON.parse(jsonArg);
+
+    // 导入并执行主程序
+    import('./dist/index.js')
+        .then(module => {
+            module.default(params);
+        })
+        .catch(error => {
+            console.error('执行失败:', error);
+            process.exit(1);
+        });
+} catch (error) {
+    console.error('JSON 解析失败:', error);
+    process.exit(1);
+} 

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "@zzp123/mcp-zentao",
+    "version": "1.0.0",
+    "description": "禅道项目管理系统的高级API集成包，提供任务管理、Bug跟踪等功能的完整封装，专为Cursor IDE设计的MCP扩展",
+    "main": "dist/index.js",
+    "type": "module",
+    "types": "dist/index.d.ts",
+    "bin": {
+        "zentao": "json-args.js"
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "json-args.js"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "watch": "tsc -w",
+        "lint": "eslint src/**/*.ts",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:manual": "ts-node test/manual-test.ts",
+        "prepublishOnly": "npm run test && npm run build",
+        "start": "node json-args.js"
+    },
+    "keywords": [
+        "mcp",
+        "zentao",
+        "禅道",
+        "任务管理",
+        "项目管理",
+        "bug跟踪",
+        "api集成",
+        "cursor-ide",
+        "typescript"
+    ],
+    "author": "yourname",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/yourusername/mcp-zentao.git"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.6.1",
+        "axios": "^1.6.7",
+        "chalk": "^4.1.2",
+        "fs": "^0.0.1-security",
+        "table": "^6.8.1",
+        "yargs": "^17.7.2"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.12",
+        "@types/node": "^20.11.19",
+        "@types/table": "^6.3.2",
+        "@typescript-eslint/eslint-plugin": "^7.0.1",
+        "@typescript-eslint/parser": "^7.0.1",
+        "eslint": "^8.56.0",
+        "jest": "^29.7.0",
+        "ts-jest": "^29.1.2",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.9.3"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}