@bangdao-ai/zentao-mcp 1.0.0 → 1.1.1

package/README.md

@@ -2,9 +2,88 @@
 
 这是一个基于 Python 的 MCP（Model Context Protocol）工具，用于连接禅道Bug管理系统。支持通过 npm/npx 直接使用。
 
+## 使用场景与AI沟通话术
+
+### 场景一：创建Bug
+
+**话术示例**：
+- "帮我创建一个Bug，标题是'登录页面验证码不显示'，重现步骤是：1. 打开登录页面 2. 点击验证码区域 3. 验证码未显示"
+- "创建一个Bug，标题'支付接口超时'，步骤：调用支付接口后等待30秒无响应，截图路径是 /path/to/screenshot.png"
+- "在禅道创建一个Bug，标题'数据导出功能异常'，重现步骤：进入数据管理页面，点击导出按钮，提示错误"
+
+### 场景二：获取需求详情
+
+**话术示例**：
+- "帮我获取需求ID为12345的需求详情"
+- "查询一下需求12345的详细信息，包括标题、描述、验收标准等"
+- "获取需求12345的完整信息"
+
+### 场景三：创建任务
+
+**话术示例**：
+- "帮我创建一个任务，任务名称是'优化登录接口性能'，分配给张三"
+- "创建一个开发任务，名称'修复支付bug'，优先级高，分配给李四"
+- "在禅道创建一个任务，标题'重构用户模块'，分配给王五，预计3天完成"
+
+### 场景四：指派任务
+
+**话术示例**：
+- "把任务ID为67890的任务指派给张三"
+- "将任务67890重新指派给李四，备注'需要紧急处理'"
+- "指派任务67890给王五，备注说明'这个任务需要前端配合'"
+
+### 场景五：查询BUG列表
+
+**话术示例**：
+- "帮我查询产品365下所有已确认的BUG"
+- "查询产品365中分配给张三的未解决BUG"
+- "获取产品365在2024-01-01到2024-01-31期间创建的BUG列表"
+- "查询产品365中状态为'激活'的BUG，创建人是李四"
+- "帮我拉取产品365下所有已确认但未解决的BUG"
+
+### 场景六：批量解决BUG
+
+**话术示例**：
+- "批量解决产品365下的BUG，BUG ID是[76016, 75241]，解决方案是fixed，解决人是68249，解决版本是2700"
+- "将产品365的BUG [76016, 75241] 标记为'设计如此'，解决人是张三"
+- "批量解决BUG，产品ID 365，BUG列表[76016, 75241]，解决方案duplicate（重复上报），解决人李四"
+
+### 场景七：创建测试用例
+
+**话术示例**：
+- "帮我创建一个接口测试用例，名称'用户登录接口测试'，接口地址是 /api/login，请求方法是POST"
+- "创建一个功能测试用例，名称'用户注册流程测试'，步骤包括：1. 打开注册页面 2. 填写信息 3. 提交注册"
+- "在禅道创建一个测试用例，类型是接口测试，名称'订单查询接口'"
+
+### 场景八：批量创建测试用例
+
+**话术示例**：
+- "从CSV文件 /path/to/cases.csv 批量创建测试用例"
+- "帮我将CSV文件中的测试用例批量提交到禅道，文件路径是 /path/to/test_cases.csv"
+- "从CSV文件批量创建接口测试用例，文件路径 /path/to/api_cases.csv"
+
+### 场景九：上传截图到BUG
+
+**话术示例**：
+- "把截图 /path/to/screenshot.png 上传到BUG 12345"
+- "上传图片到BUG 12345，图片路径是 /path/to/image.jpg，文件名改为'错误截图'"
+- "帮我把截图上传到BUG 12345的附件中"
+
+### 场景十：查看配置
+
+**话术示例**：
+- "查看一下当前的禅道配置信息"
+- "显示当前的配置"
+- "获取配置信息"
+
 ## 功能特性
 
 - ✅ 创建Bug（支持截图上传）
+- ✅ 获取需求详情
+- ✅ 创建任务
+- ✅ 指派任务
+- ✅ 查询BUG列表（支持多条件筛选）
+- ✅ 批量解决BUG
 - ✅ 创建测试用例
 - ✅ 批量从CSV文件创建测试用例
 - ✅ 上传图片到Bug附件
@@ -13,12 +92,37 @@
 
 ## 安装
 
-通过 npm/npx 使用（推荐）：
+### 前置要求
+
+- **Node.js**: >= 14.0.0
+- **Python**: >= 3.8
+
+### 安装方式
+
+#### 方式一：通过 npx 使用（推荐，无需安装）
+
+直接在 Cursor 配置中使用，无需手动安装：
 
 ```bash
 npx -y @bangdao-ai/zentao-mcp@latest
 ```
 
+#### 方式二：全局安装
+
+```bash
+npm install -g @bangdao-ai/zentao-mcp@latest
+```
+
+#### 方式三：本地安装（开发模式）
+
+```bash
+git clone https://github.com/bangdao-ai/zentao-mcp.git
+cd zentao-mcp
+pip3 install -r requirements.txt
+```
+
+**详细安装指南请参考**：[docs/INSTALL.md](docs/INSTALL.md)
+
 ## 配置
 
 ### 在 Cursor 中配置
@@ -37,6 +141,7 @@ npx -y @bangdao-ai/zentao-mcp@latest
       "env": {
         "ZENTAO_PRODUCT_ID": "365",
         "ZENTAO_OPENED_BY": "69610",
+        "KEY": "643f0f490d1ea0d47520dd270989c99a",
         "ZENTAO_KEYWORDS": "AI",
         "ZENTAO_TITLE_PREFIX": ""
       }
@@ -47,13 +152,14 @@ npx -y @bangdao-ai/zentao-mcp@latest
 
 **配置说明**：
 - `ZENTAO_PRODUCT_ID`（必需）：产品ID
-- `ZENTAO_OPENED_BY`（必需）：创建人和指派人ID（同一个人）
+- `ZENTAO_OPENED_BY`（必需）：创建人和指派人ID（同一个人），作为API认证的code参数
+- `KEY`（必需）：API认证密钥，作为API认证的key参数
 - `ZENTAO_KEYWORDS`（可选）：关键词，默认为空
 - `ZENTAO_TITLE_PREFIX`（可选）：标题前缀，默认为空
 
 ### 兜底配置（可选）
 
-如果未在环境变量中配置，可以使用配置文件 `bug_config.json`（参考 `bug_config.example.json`）。配置文件路径可通过环境变量 `ZENTAO_CONFIG_PATH` 指定。
+如果未在环境变量中配置，可以使用配置文件 `bug_config.json`。配置文件路径可通过环境变量 `ZENTAO_CONFIG_PATH` 指定。
 
 ## MCP 工具
 
@@ -131,21 +237,95 @@ npx -y @bangdao-ai/zentao-mcp@latest
 
 获取当前配置信息。
 
+### 7. get_story_detail
+
+获取需求详情。
+
+**参数**：
+- `story_id` (必需): 需求ID
+
+**返回**：包含需求标题、描述、验收标准、创建人、指派人等详细信息
+
+### 8. create_task
+
+创建任务。
+
+**参数**：
+- `task_data` (必需): 任务数据对象，包含任务相关字段（form-data格式）
+
+**注意**：任务数据的具体字段请参考禅道API文档，常见字段包括：
+- `name`: 任务名称
+- `assignedTo`: 指派人
+- `pri`: 优先级
+- `estimate`: 预计工时
+- `desc`: 任务描述
+- 等其他字段
+
+### 9. assign_task
+
+指派任务。
+
+**参数**：
+- `task_id` (必需): 任务ID
+- `assigned_to` (必需): 新的指派人（姓名或工号）
+- `comment` (可选): 指派备注
+
+### 10. get_bug_list
+
+拉取已确认/未解决的BUG列表。
+
+**参数**：
+- `product_id` (必需): 产品ID
+- `assigned_to` (可选): 指派人（姓名或工号）
+- `opened_by` (可选): 创建人（姓名或工号）
+- `resolved_by` (可选): 解决人（姓名或工号）
+- `confirmed` (可选): 是否确认（2=已确认，1=未确认，0或不传=所有）
+- `status` (可选): 状态（激活/已解决/已关闭）
+- `start_date` (可选): 创建开始日期（格式：YYYY-MM-DD）
+- `end_date` (可选): 创建截止日期（格式：YYYY-MM-DD）
+
+### 11. resolve_bug
+
+批量解决BUG。
+
+**参数**：
+- `product_id` (必需): 产品ID
+- `bug_ids` (必需): BUG ID列表（数组）
+- `resolution` (必需): 解决方案，可选值：
+  - `fixed`: 修复解决
+  - `bydesign`: 设计如此
+  - `reqchange`: 修改需求
+  - `duplicate`: 重复上报
+  - `external`: 外部原因
+  - `notrepro`: 无法重现
+  - `postponed`: 延期处理
+  - `willnotfix`: 不予解决
+  - `tostory`: 转为需求
+  - `history`: 历史遗留
+  - `configchange`: 调整配置
+- `resolved_by` (必需): 解决人（姓名或工号）
+- `resolved_build` (可选): 解决版本ID（当解决方案为`fixed`时必传）
+
 ## 项目结构
 
 ```
 禅道mcp/
-├── index.js                    # npm 入口文件
-├── package.json                # npm 包配置
-├── src/
+├── src/                        # 源码目录
 │   ├── mcp_server.py          # MCP服务器主文件
 │   └── zentao_nexus.py         # 禅道工具类
+├── scripts/                    # 脚本目录
+│   └── publish/                # 发布脚本
+├── docs/                       # 文档目录
+│   ├── PUBLISH.md              # 发布指南
+│   └── README-PUBLISH.md       # 发布脚本使用指南
+├── index.js                    # npm 入口文件
+├── package.json                # npm 包配置
 ├── requirements.txt            # Python 依赖
-├── README.md                   # 项目说明
-├── PUBLISH.md                  # 发布指南
-└── bug_config.example.json     # 兜底配置示例
+└── README.md                   # 项目说明
 ```
 
+详细的项目结构说明请参考 [docs/PROJECT-STRUCTURE.md](docs/PROJECT-STRUCTURE.md)
+
 ## 发布
 
 参考 [PUBLISH.md](PUBLISH.md) 了解如何发布到 npm。

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@bangdao-ai/zentao-mcp",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "禅道Bug管理系统MCP工具",
   "main": "index.js",
   "bin": {
-    "zentao-mcp": "./index.js"
+    "zentao-mcp": "index.js"
   },
   "scripts": {
     "start": "node index.js"
@@ -21,7 +21,6 @@
     "index.js",
     "src/",
     "requirements.txt",
-    "bug_config.example.json",
     "README.md",
     "package.json"
   ],
@@ -30,6 +29,6 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/bangdao-ai/zentao-mcp.git"
+    "url": "git+https://github.com/bangdao-ai/zentao-mcp.git"
   }
 }

package/requirements.txt

@@ -3,4 +3,5 @@ requests>=2.31.0
 python-dotenv>=1.0.0
 fastapi>=0.104.0
 uvicorn[standard]>=0.24.0
+pytest>=7.0.0
 

package/src/mcp_server.py

@@ -127,6 +127,98 @@ class ZenTaoMCPServer:
                     name="get_config",
                     description="获取当前配置信息",
                     inputSchema={"type": "object", "properties": {}}
+                ),
+                Tool(
+                    name="get_story_detail",
+                    description="获取需求详情",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "story_id": {"type": "string", "description": "需求ID"}
+                        },
+                        "required": ["story_id"]
+                    }
+                ),
+                Tool(
+                    name="create_task",
+                    description="创建任务",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "task_data": {
+                                "type": "object",
+                                "description": "任务数据（form-data格式的键值对）",
+                                "additionalProperties": True
+                            }
+                        },
+                        "required": ["task_data"]
+                    }
+                ),
+                Tool(
+                    name="assign_task",
+                    description="指派任务",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "task_id": {"type": "string", "description": "任务ID"},
+                            "assigned_to": {"type": "string", "description": "新的指派人（姓名或工号）"},
+                            "comment": {"type": "string", "description": "指派备注（可选）"}
+                        },
+                        "required": ["task_id", "assigned_to"]
+                    }
+                ),
+                Tool(
+                    name="get_bug_list",
+                    description="拉取已确认/未解决的BUG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "product_id": {"type": "string", "description": "产品ID"},
+                            "assigned_to": {"type": "string", "description": "指派人（可选，姓名或工号）"},
+                            "opened_by": {"type": "string", "description": "创建人（可选，姓名或工号）"},
+                            "resolved_by": {"type": "string", "description": "解决人（可选，姓名或工号）"},
+                            "confirmed": {"type": "string", "description": "是否确认（可选，2已确认 1未确认 0或不传是所有）"},
+                            "status": {"type": "string", "description": "状态（可选，激活/已解决/已关闭）"},
+                            "start_date": {"type": "string", "description": "创建开始日期（可选）"},
+                            "end_date": {"type": "string", "description": "创建截止日期（可选）"}
+                        },
+                        "required": ["product_id"]
+                    }
+                ),
+                Tool(
+                    name="resolve_bug",
+                    description="批量解决BUG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "product_id": {"type": "string", "description": "产品ID"},
+                            "bug_ids": {
+                                "type": "array",
+                                "items": {"type": "string"},
+                                "description": "BUG ID列表"
+                            },
+                            "resolution": {
+                                "type": "string",
+                                "description": "解决方案",
+                                "enum": ["fixed", "bydesign", "reqchange", "duplicate", "external", "notrepro", "postponed", "willnotfix", "tostory", "history", "configchange"]
+                            },
+                            "resolved_by": {"type": "string", "description": "解决人（姓名或工号）"},
+                            "resolved_build": {"type": "string", "description": "解决版本ID（可选，如果未提供则默认使用trunk）"}
+                        },
+                        "required": ["product_id", "bug_ids", "resolution", "resolved_by"]
+                    }
+                ),
+                Tool(
+                    name="close_bug",
+                    description="关闭BUG",
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "bug_id": {"type": "string", "description": "BUG ID"},
+                            "comment": {"type": "string", "description": "关闭备注（可选，默认AI关闭）"}
+                        },
+                        "required": ["bug_id"]
+                    }
                 )
             ]
         
@@ -150,7 +242,8 @@ class ZenTaoMCPServer:
                             "product_id": product_id,
                             "opened_by": opened_by,
                             "keywords": os.getenv("ZENTAO_KEYWORDS", ""),
-                            "title_prefix": os.getenv("ZENTAO_TITLE_PREFIX", "")
+                            "title_prefix": os.getenv("ZENTAO_TITLE_PREFIX", ""),
+                            "role_type": os.getenv("ZENTAO_ROLE_TYPE", "")
                         }
                         temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False)
                         json.dump(temp_config, temp_file, ensure_ascii=False)
@@ -312,6 +405,56 @@ class ZenTaoMCPServer:
                     config = self.nexus.get_config()
                     return [TextContent(type="text", text=json.dumps(config, ensure_ascii=False, indent=2))]
                 
+                elif name == "get_story_detail":
+                    story_id = arguments["story_id"]
+                    result = self.nexus.get_story_detail(story_id)
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
+                elif name == "create_task":
+                    task_data = arguments["task_data"]
+                    result = self.nexus.create_task_by_api(task_data)
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
+                elif name == "assign_task":
+                    task_id = arguments["task_id"]
+                    assigned_to = arguments["assigned_to"]
+                    comment = arguments.get("comment")
+                    result = self.nexus.assign_task(task_id, assigned_to, comment)
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
+                elif name == "get_bug_list":
+                    product_id = arguments["product_id"]
+                    assigned_to = arguments.get("assigned_to")
+                    opened_by = arguments.get("opened_by")
+                    resolved_by = arguments.get("resolved_by")
+                    confirmed = arguments.get("confirmed")
+                    status = arguments.get("status")
+                    start_date = arguments.get("start_date")
+                    end_date = arguments.get("end_date")
+                    
+                    result = self.nexus.get_bug_list(
+                        product_id, assigned_to, opened_by, resolved_by,
+                        confirmed, status, start_date, end_date
+                    )
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
+                elif name == "resolve_bug":
+                    product_id = arguments["product_id"]
+                    bug_ids = arguments["bug_ids"]
+                    resolution = arguments["resolution"]
+                    resolved_by = arguments["resolved_by"]
+                    resolved_build = arguments.get("resolved_build")
+                    
+                    result = self.nexus.resolve_bug(product_id, bug_ids, resolution, resolved_by, resolved_build)
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
+                elif name == "close_bug":
+                    bug_id = arguments["bug_id"]
+                    comment = arguments.get("comment", "AI关闭")
+                    
+                    result = self.nexus.close_bug(bug_id, comment)
+                    return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+                
                 else:
                     raise ValueError(f"未知的工具: {name}")
             

package/src/zentao_nexus.py

@@ -103,115 +103,350 @@ class ZenTaoAPIClient:
     
     # 写死的配置
     BASE_URL = "https://zentao.bangdao-tech.com"
-    ACCOUNT = "KUBETEST"
-    SECRET_KEY = "aa287b7b5a4ef5d051f82fb1825ca1ac"
-    CASE_SECRET_KEY = "db1d522a190f1135c6e7c324bd337fda"
-    CASE_ACCOUNT = "AUTOTEST"
+    TEST_BASE_URL = "https://test-zendao.bangdao-tech.com"
     
-    def __init__(self, silent=True):
+    def __init__(self, silent=True, use_test_env=False):
         """
         初始化禅道API客户端
         
         Args:
             silent (bool): 是否静默模式，不输出调试信息
+            use_test_env (bool): 是否使用测试环境
         """
-        self.base_url = self.BASE_URL
-        self.account = self.ACCOUNT
-        self.secret_key = self.SECRET_KEY
-        self.case_secret_key = self.CASE_SECRET_KEY
+        self.base_url = self.TEST_BASE_URL if use_test_env else self.BASE_URL
         self.silent = silent
+        self.use_test_env = use_test_env
+        
+        # 从环境变量读取 code 和 key
+        self.code = os.getenv("ZENTAO_OPENED_BY") or os.getenv("OPENED_BY")
+        self.key = os.getenv("ZENTAO_KEY") or os.getenv("KEY")
+        
+        if not self.code:
+            raise ValueError("未设置环境变量 ZENTAO_OPENED_BY 或 OPENED_BY（用于 code）")
+        if not self.key:
+            raise ValueError("未设置环境变量 ZENTAO_KEY 或 KEY（用于 key）")
     
-    def generate_bdtoken(self, timestamp):
-        """生成BDTOKEN（用于BUG创建）"""
-        token_string = f"accountfmtamp{timestamp}{self.secret_key}"
-        md5_hash = hashlib.md5()
-        md5_hash.update(token_string.encode('utf-8'))
-        return md5_hash.hexdigest()
-    
-    def generate_case_bdtoken(self, timestamp):
-        """生成用例创建用的BDTOKEN"""
-        token_string = f"accountfmtamp{timestamp}{self.case_secret_key}"
+    def generate_api_token(self, timestamp):
+        """生成统一API的token（md5(code + key + time)，32位小写）"""
+        token_string = f"{self.code}{self.key}{timestamp}"
         md5_hash = hashlib.md5()
         md5_hash.update(token_string.encode('utf-8'))
-        return md5_hash.hexdigest()
+        return md5_hash.hexdigest().lower()
     
-    def create_bug_by_api(self, bug_data, use_form_data=True):
-        """通过API创建bug"""
+    def _call_new_api(self, function_name, params=None, form_data=None, files=None, m_param='allneedlist'):
+        """
+        调用新的API接口（使用code、time、token认证）
+        
+        Args:
+            function_name: API函数名（f参数）
+            params: URL参数（字典）
+            form_data: POST form-data数据（字典或列表，列表格式用于数组参数）
+            files: 文件上传（字典，用于文件上传接口）
+            m_param: m参数值（默认allneedlist，某些接口可能需要其他值如bug）
+        
+        Returns:
+            dict: API响应结果
+        """
         current_timestamp = int(time.time())
-        bdtoken = self.generate_bdtoken(current_timestamp)
-        
-        url = f"{self.base_url}/zentaopms/www/index.php"
-        params = {
-            'm': 'allneedlist',
-            'f': 'createbugbyapi',
-            'account': self.account,
-            'tamp': current_timestamp
+        token = self.generate_api_token(current_timestamp)
+        
+        api_url = f"{self.base_url}/zentaopms/www/api.php"
+        url_params = {
+            'code': self.code,
+            'time': current_timestamp,
+            'token': token,
+            'm': m_param,
+            'f': function_name
         }
         
+        # 合并URL参数
+        if params:
+            url_params.update(params)
+        
         headers = {
-            'BDTOKEN': bdtoken,
             'User-Agent': 'Python-ZenTao-Client/1.0'
         }
         
+        # 打印请求信息
+        print("\n" + "=" * 80)
+        print("【禅道API请求信息】")
+        print("=" * 80)
+        print(f"API URL: {api_url}")
+        print(f"\n【Headers】")
+        for key, value in headers.items():
+            print(f"  {key}: {value}")
+        
+        print(f"\n【Token生成信息】")
+        print(f"  code: {self.code}")
+        print(f"  key: {self.key[:10]}...{self.key[-10:] if len(self.key) > 20 else self.key}")  # 只显示部分key，保护隐私
+        print(f"  time: {current_timestamp}")
+        print(f"  token生成公式: md5(code + key + time)")
+        print(f"  token生成字符串: {self.code}{self.key}{current_timestamp}")
+        print(f"  token: {token}")
+        
+        print(f"\n【URL参数】")
+        for key, value in url_params.items():
+            print(f"  {key}: {value}")
+        
+        # 处理form_data用于显示
+        display_form_data = form_data
+        if isinstance(form_data, dict):
+            # 检查是否有数组类型的值
+            processed_data = []
+            for key, value in form_data.items():
+                if isinstance(value, (list, tuple)):
+                    for item in value:
+                        processed_data.append((key, str(item)))
+                else:
+                    processed_data.append((key, str(value)))
+            display_form_data = processed_data
+        
+        if display_form_data:
+            print(f"\n【Body (form-data)】")
+            if isinstance(display_form_data, list):
+                for item in display_form_data:
+                    if isinstance(item, tuple):
+                        key, value = item
+                        # 如果是文件，只显示文件名
+                        if hasattr(value, 'read'):
+                            print(f"  {key}: <文件对象>")
+                        else:
+                            print(f"  {key}: {value}")
+                    else:
+                        print(f"  {item}")
+            elif isinstance(display_form_data, dict):
+                for key, value in display_form_data.items():
+                    print(f"  {key}: {value}")
+        
+        if files:
+            print(f"\n【Files】")
+            for key, file_info in files.items():
+                if isinstance(file_info, tuple):
+                    filename = file_info[0] if len(file_info) > 0 else "unknown"
+                    print(f"  {key}: {filename}")
+                else:
+                    print(f"  {key}: {file_info}")
+        
+        print("=" * 80)
+        
         try:
-            if use_form_data:
-                response = requests.post(url, params=params, headers=headers, data=bug_data, timeout=30)
+            if files:
+                # 文件上传
+                response = requests.post(api_url, params=url_params, headers=headers, data=form_data, files=files, timeout=30)
+            elif form_data:
+                # 如果form_data是列表，直接使用（用于数组参数）
+                # 如果是字典，需要检查是否有数组类型的值
+                if isinstance(form_data, dict):
+                    # 检查是否有数组类型的值，转换为元组列表格式
+                    processed_data = []
+                    for key, value in form_data.items():
+                        if isinstance(value, (list, tuple)):
+                            # 数组参数，使用元组列表格式
+                            for item in value:
+                                processed_data.append((key, str(item)))
+                        else:
+                            processed_data.append((key, str(value)))
+                    form_data = processed_data
+                
+                response = requests.post(api_url, params=url_params, headers=headers, data=form_data, timeout=30)
             else:
-                headers['Content-Type'] = 'application/json'
-                response = requests.post(url, params=params, headers=headers, json=bug_data, timeout=30)
+                response = requests.post(api_url, params=url_params, headers=headers, timeout=30)
+            
+            # 打印响应信息
+            print("\n【禅道API响应信息】")
+            print("=" * 80)
+            print(f"状态码: {response.status_code}")
+            print(f"响应Headers:")
+            for key, value in response.headers.items():
+                print(f"  {key}: {value}")
             
             try:
-                return response.json()
+                response_json = response.json()
+                print(f"\n响应Body (JSON):")
+                print(json.dumps(response_json, ensure_ascii=False, indent=2))
+                print("=" * 80 + "\n")
+                return response_json
             except json.JSONDecodeError:
+                print(f"\n响应Body (非JSON):")
+                print(response.text[:1000])  # 只显示前1000个字符
+                print("=" * 80 + "\n")
                 return {
-                    "status": -1,
-                    "message": "响应不是有效的JSON格式",
+                    "status": 0,
+                    "message": "fail",
+                    "info": "响应不是有效的JSON格式",
+                    "data": {},
                     "raw_response": response.text
                 }
         except requests.exceptions.RequestException as e:
+            print(f"\n【请求异常】")
+            print(f"错误信息: {str(e)}")
+            print("=" * 80 + "\n")
             return {
-                "status": -1,
-                "message": f"请求失败: {str(e)}"
+                "status": 0,
+                "message": "fail",
+                "info": f"请求失败: {str(e)}",
+                "data": {}
             }
     
-    def create_case_by_api(self, case_data, use_form_data=True):
-        """通过API创建测试用例"""
-        current_timestamp = int(time.time())
-        bdtoken = self.generate_case_bdtoken(current_timestamp)
-        
-        url = f"{self.base_url}/zentaopms/www/index.php"
-        params = {
-            'm': 'allneedlist',
-            'f': 'createcasebyapi',
-            'account': self.CASE_ACCOUNT,
-            'tamp': current_timestamp
-        }
+    def get_story_detail(self, story_id):
+        """
+        获取需求详情
         
-        headers = {
-            'BDTOKEN': bdtoken,
-            'User-Agent': 'Python-ZenTao-Client/1.0'
+        Args:
+            story_id: 需求ID
+        
+        Returns:
+            dict: 需求详情
+        """
+        params = {'storyID': story_id}
+        return self._call_new_api('getStoryDetail', params=params)
+    
+    def create_task_by_api(self, task_data):
+        """
+        创建任务
+        
+        Args:
+            task_data: 任务数据（字典，form-data格式）
+        
+        Returns:
+            dict: 创建结果，包含taskID
+        """
+        return self._call_new_api('createtaskbyapi', form_data=task_data)
+    
+    def assign_task(self, task_id, assigned_to, comment=None):
+        """
+        指派任务
+        
+        Args:
+            task_id: 任务ID（必传）
+            assigned_to: 新的指派人（姓名或工号）
+            comment: 指派备注（可选）
+        
+        Returns:
+            dict: 指派结果
+        """
+        params = {'taskID': task_id}
+        form_data = {'assignedTo': assigned_to}
+        if comment:
+            form_data['comment'] = comment
+        return self._call_new_api('assignTask', params=params, form_data=form_data)
+    
+    def get_bug_list(self, product_id, assigned_to=None, opened_by=None, resolved_by=None,
+                     confirmed=None, status=None, start_date=None, end_date=None):
+        """
+        拉取已确认/未解决的BUG
+        
+        Args:
+            product_id: 产品ID（必传）
+            assigned_to: 指派人（可选，姓名或工号）
+            opened_by: 创建人（可选，姓名或工号）
+            resolved_by: 解决人（可选，姓名或工号）
+            confirmed: 是否确认（可选，2已确认 1未确认 0或不传是所有）
+            status: 状态（可选，激活/已解决/已关闭）
+            start_date: 创建开始日期（可选）
+            end_date: 创建截止日期（可选）
+        
+        Returns:
+            dict: BUG列表
+        """
+        params = {'productID': product_id}
+        form_data = {}
+        
+        if assigned_to:
+            form_data['assignedTo'] = assigned_to
+        if opened_by:
+            form_data['openedBy'] = opened_by
+        if resolved_by:
+            form_data['resolvedBy'] = resolved_by
+        if confirmed is not None:
+            form_data['confirmed'] = str(confirmed)
+        if status:
+            form_data['status'] = status
+        if start_date:
+            form_data['startDate'] = start_date
+        if end_date:
+            form_data['endDate'] = end_date
+        
+        return self._call_new_api('getBugList', params=params, form_data=form_data if form_data else None)
+    
+    def resolve_bug(self, product_id, bug_ids, resolution="fixed", resolved_by=None, resolved_build=None):
+        """
+        批量解决BUG
+        
+        Args:
+            product_id: 产品ID（必传）
+            bug_ids: BUG ID列表（必传），可以是单个ID或ID列表
+            resolution: 解决方案（可选，默认fixed），可选值：
+                fixed: 修复解决
+                bydesign: 设计如此
+                reqchange: 修改需求
+                duplicate: 重复上报
+                external: 外部原因
+                notrepro: 无法重现
+                postponed: 延期处理
+                willnotfix: 不予解决
+                tostory: 转为需求
+                history: 历史遗留
+                configchange: 调整配置
+            resolved_by: 解决人（必传，姓名或工号）
+            resolved_build: 解决版本ID（可选，如果未提供则默认使用"trunk"）
+        
+        Returns:
+            dict: 解决结果
+        """
+        # 如果没有提供 resolved_build，使用默认值 "trunk"
+        if not resolved_build:
+            resolved_build = "trunk"
+        
+        params = {'productID': product_id}
+        form_data = {
+            'resolution': resolution,
+            'resolvedBy': resolved_by
         }
         
-        try:
-            if use_form_data:
-                response = requests.post(url, params=params, headers=headers, data=case_data, timeout=30)
-            else:
-                headers['Content-Type'] = 'application/json'
-                response = requests.post(url, params=params, headers=headers, json=case_data, timeout=30)
-            
-            try:
-                return response.json()
-            except json.JSONDecodeError:
-                return {
-                    "status": -1,
-                    "message": "响应不是有效的JSON格式",
-                    "raw_response": response.text
-                }
-        except requests.exceptions.RequestException as e:
+        # bugID[] 数组格式 - 转换为列表格式，_call_new_api会自动处理
+        if isinstance(bug_ids, (list, tuple)):
+            form_data['bugID[]'] = [str(bug_id) for bug_id in bug_ids]
+        else:
+            form_data['bugID[]'] = [str(bug_ids)]
+        
+        if resolved_build:
+            form_data['resolvedBuild'] = str(resolved_build)
+        
+        return self._call_new_api('resolveBug', params=params, form_data=form_data)
+    
+    def close_bug(self, bug_id, comment="AI关闭"):
+        """
+        关闭BUG
+        
+        Args:
+            bug_id: BUG ID（必传）
+            comment: 关闭备注（可选，默认"AI关闭"）
+        
+        Returns:
+            dict: 关闭结果
+        """
+        params = {'bugID': bug_id}
+        form_data = {'comment': comment}
+        result = self._call_new_api('close', params=params, form_data=form_data, m_param='bug')
+        
+        # 如果返回的是"Array"字符串，表示操作成功（禅道某些接口的特殊返回格式）
+        if isinstance(result, dict) and result.get("raw_response") == "Array":
             return {
-                "status": -1,
-                "message": f"请求失败: {str(e)}"
+                "status": 1,
+                "message": "success",
+                "info": "success"
             }
+        
+        return result
+    
+    def create_bug_by_api(self, bug_data, use_form_data=True):
+        """通过API创建bug"""
+        return self._call_new_api('createbugbyapi', form_data=bug_data)
+    
+    def create_case_by_api(self, case_data, use_form_data=True):
+        """通过API创建测试用例"""
+        return self._call_new_api('createcasebyapi', form_data=case_data)
     
     def upload_image_to_bug(self, bug_id, image_path, custom_filename=None):
         """上传图片到BUG附件"""
@@ -221,25 +456,6 @@ class ZenTaoAPIClient:
                 "message": f"图片文件不存在: {image_path}"
             }
         
-        current_timestamp = int(datetime.now().timestamp())
-        url = f"{self.base_url}/zentaopms/www/index.php"
-        params = {
-            'm': 'allneedlist',
-            'f': 'uploadbyapi',
-            'account': self.CASE_ACCOUNT,
-            'tamp': current_timestamp
-        }
-        
-        token_string = f"accountfmtamp{current_timestamp}{self.case_secret_key}"
-        md5_hash = hashlib.md5()
-        md5_hash.update(token_string.encode('utf-8'))
-        bdtoken = md5_hash.hexdigest()
-        
-        headers = {
-            'BDTOKEN': bdtoken,
-            'User-Agent': 'Python-ZenTao-Client/1.0'
-        }
-        
         filename = custom_filename or os.path.basename(image_path)
         
         try:
@@ -247,22 +463,8 @@ class ZenTaoAPIClient:
                 files = {
                     'files[]': (filename, f, 'application/octet-stream')
                 }
-                data = {'id': bug_id}
-                response = requests.post(url, params=params, headers=headers, files=files, data=data, timeout=30)
-                
-                try:
-                    return response.json()
-                except json.JSONDecodeError:
-                    return {
-                        "status": -1,
-                        "message": "响应不是有效的JSON格式",
-                        "raw_response": response.text
-                    }
-        except requests.exceptions.RequestException as e:
-            return {
-                "status": -1,
-                "message": f"请求失败: {str(e)}"
-            }
+                form_data = {'id': bug_id}
+                return self._call_new_api('uploadbyapi', form_data=form_data, files=files)
         except Exception as e:
             return {
                 "status": -1,
@@ -467,6 +669,15 @@ class ZenTaoNexus:
     LOWER_BUG = "0"
     REGRESSION = "0"
     
+    # 职位类型到任务类型的映射
+    ROLE_TO_TASK_TYPE = {
+        "测试": "4",      # 测试
+        "前端": "8",      # 前端开发
+        "后端": "3",      # 后端开发
+        "其它": "20",     # 其他
+        "其他": "20"      # 其他（兼容两种写法）
+    }
+    
     def __init__(self, config_path: str = None):
         """
         初始化ZenTao Nexus工具
@@ -505,6 +716,10 @@ class ZenTaoNexus:
         env_title_prefix = os.getenv("ZENTAO_TITLE_PREFIX") or os.getenv("TITLE_PREFIX")
         self.title_prefix = env_title_prefix or self.config_loader.get("title_prefix", "")
         
+        # 职位类型（用于创建任务时自动设置任务类型）
+        env_role_type = os.getenv("ZENTAO_ROLE_TYPE") or os.getenv("ROLE_TYPE")
+        self.role_type = env_role_type or self.config_loader.get("role_type", "")
+        
         # 创建API客户端
         self.client = ZenTaoAPIClient(silent=True)
     
@@ -621,7 +836,8 @@ class ZenTaoNexus:
             "product_id": self.product_id,
             "opened_by": self.opened_by,
             "keywords": self.keywords,
-            "title_prefix": self.title_prefix
+            "title_prefix": self.title_prefix,
+            "role_type": self.role_type
         }
     
     def upload_image_to_bug(self, bug_id, image_path, custom_filename=None):
@@ -635,6 +851,68 @@ class ZenTaoNexus:
     def submit_csv_cases_to_zentao(self, csv_file_path, case_type=None):
         """将CSV文件中的所有测试用例提交到禅道"""
         return self.client.submit_csv_cases_to_zentao(csv_file_path, case_type, self.product_id, self.opened_by, self.keywords)
+    
+    def get_story_detail(self, story_id):
+        """获取需求详情"""
+        return self.client.get_story_detail(story_id)
+    
+    def create_task_by_api(self, task_data):
+        """
+        创建任务
+        
+        Args:
+            task_data: 任务数据（字典，form-data格式）
+                如果 task_data 中没有 'mold' 字段，且配置了职位类型(role_type)，
+                则根据职位类型自动设置任务类型
+                自动设置字段：
+                - estStarted: 当前日期（如果未指定）
+                - deadline: 当前日期+3天（如果未指定）
+                - pri: 2（如果未指定）
+                - openedBy: 配置的创建人（如果未指定）
+        
+        Returns:
+            dict: 创建结果，包含taskID
+        """
+        # 如果 task_data 中没有指定 mold，且配置了职位类型，则自动设置
+        if 'mold' not in task_data or (task_data.get('mold') == '' or task_data.get('mold') is None):
+            if self.role_type and self.role_type in self.ROLE_TO_TASK_TYPE:
+                task_data['mold'] = self.ROLE_TO_TASK_TYPE[self.role_type]
+        
+        # 自动设置预计开始时间（当前日期）
+        if 'estStarted' not in task_data or (task_data.get('estStarted') == '' or task_data.get('estStarted') is None):
+            task_data['estStarted'] = datetime.now().strftime("%Y-%m-%d")
+        
+        # 自动设置预计结束时间（当前日期+3天）
+        if 'deadline' not in task_data or (task_data.get('deadline') == '' or task_data.get('deadline') is None):
+            task_data['deadline'] = (datetime.now() + timedelta(days=3)).strftime("%Y-%m-%d")
+        
+        # 自动设置优先级为2
+        if 'pri' not in task_data or (task_data.get('pri') == '' or task_data.get('pri') is None):
+            task_data['pri'] = '2'
+        
+        # 自动设置创建人
+        if 'openedBy' not in task_data or (task_data.get('openedBy') == '' or task_data.get('openedBy') is None):
+            task_data['openedBy'] = self.opened_by
+        
+        return self.client.create_task_by_api(task_data)
+    
+    def assign_task(self, task_id, assigned_to, comment=None):
+        """指派任务"""
+        return self.client.assign_task(task_id, assigned_to, comment)
+    
+    def get_bug_list(self, product_id, assigned_to=None, opened_by=None, resolved_by=None,
+                     confirmed=None, status=None, start_date=None, end_date=None):
+        """拉取已确认/未解决的BUG"""
+        return self.client.get_bug_list(product_id, assigned_to, opened_by, resolved_by,
+                                       confirmed, status, start_date, end_date)
+    
+    def resolve_bug(self, product_id, bug_ids, resolution="fixed", resolved_by=None, resolved_build=None):
+        """批量解决BUG"""
+        return self.client.resolve_bug(product_id, bug_ids, resolution, resolved_by, resolved_build)
+    
+    def close_bug(self, bug_id, comment="AI关闭"):
+        """关闭BUG"""
+        return self.client.close_bug(bug_id, comment)
 
 
 # 便捷函数

package/bug_config.example.json

@@ -1,7 +0,0 @@
-{
-  "product_id": "365",
-  "opened_by": "69610",
-  "keywords": "AI",
-  "title_prefix": ""
-}
-