@maxenlin/mcp-zentao-11-3 1.0.0-patch.1 → 1.0.2

package/README.md

@@ -1,6 +1,6 @@
 # @maxenlin/mcp-zentao-11-3
 
-禅道 11.3 Legacy 版 MCP 服务器，专为 Cursor IDE 设计，只支持旧版 Session API。
+禅道 11.3 Legacy 版 MCP 服务器，支持所有兼容 MCP 协议的 IDE 和工具（如 Cursor IDE、Claude Desktop、Continue 等），只支持旧版 Session API。
 
 ## ✨ 特性
 
@@ -15,33 +15,13 @@
 
 ## 📦 安装
 
-### 方法 1：使用 npx（推荐）
-
-在 Cursor IDE 配置文件中添加：
-
-```json
-{
-  "mcpServers": {
-    "zentao-11-3": {
-      "command": "npx",
-      "args": ["-y", "@maxenlin/mcp-zentao-11-3"],
-      "env": {
-        "ZENTAO_URL": "http://your-zentao-url/zentao",
-        "ZENTAO_USERNAME": "your-username",
-        "ZENTAO_PASSWORD": "your-password"
-      }
-    }
-  }
-}
-```
-
-### 方法 2：本地安装
+### 方法 1：本地安装
 
 ```bash
 npm install -g @maxenlin/mcp-zentao-11-3
 ```
 
-然后在 Cursor IDE 配置文件中添加：
+然后在支持 MCP 的 IDE/工具配置文件中添加（以 Cursor IDE 为例）：
 
 ```json
 {
@@ -59,18 +39,21 @@ npm install -g @maxenlin/mcp-zentao-11-3
 }
 ```
 
-## ⚙️ 配置
+**配置说明：**
+- `ZENTAO_URL`: 禅道服务器地址（必须包含 `/zentao` 路径）
+- `ZENTAO_USERNAME`: 禅道用户名
+- `ZENTAO_PASSWORD`: 禅道密码
 
-### 方法 1：在 Cursor 配置中直接设置（推荐）
+### 方法 2：使用 npx
 
-在 Cursor IDE 的 MCP 配置文件中，直接在 `env` 字段中填入配置：
+在支持 MCP 的 IDE/工具配置文件中添加（以 Cursor IDE 为例）：
 
 ```json
 {
   "mcpServers": {
     "zentao-11-3": {
-      "command": "mcp-zentao-11-3",
-      "args": [],
+      "command": "npx",
+      "args": ["-y", "@maxenlin/mcp-zentao-11-3"],
       "env": {
         "ZENTAO_URL": "http://your-zentao-url/zentao",
         "ZENTAO_USERNAME": "your-username",
@@ -86,36 +69,9 @@ npm install -g @maxenlin/mcp-zentao-11-3
 - `ZENTAO_USERNAME`: 禅道用户名
 - `ZENTAO_PASSWORD`: 禅道密码
 
-### 方法 2：使用配置文件（备选）
-
-如果不想在 Cursor 配置中直接填写密码，可以创建配置文件：
-
-**Windows:**
-```
-C:\Users\你的用户名\.zentao\config.json
-```
-
-**macOS/Linux:**
-```
-~/.zentao/config.json
-```
-
-配置文件内容：
-
-```json
-{
-  "url": "http://your-zentao-url/zentao",
-  "username": "your-username",
-  "password": "your-password",
-  "apiVersion": "legacy"
-}
-```
-
-**注意：** 环境变量配置优先于配置文件。如果同时设置了环境变量和配置文件，将使用环境变量中的配置。
-
 ## 🚀 使用
 
-配置完成后，重启 Cursor IDE 即可使用。
+配置完成后，重启您的 IDE/工具即可使用。
 
 ### 基础功能
 
@@ -176,70 +132,84 @@ C:\Users\你的用户名\.zentao\config.json
 ## 📋 可用工具
 
 ### 配置管理
+
 - `initZentao` - 初始化禅道连接
 - `getConfig` - 查看配置信息
 
 ### 任务管理
+
 - `getMyTasks` - 获取我的任务列表
 - `getTaskDetail` - 获取任务详情
 - `updateTask` - 更新任务
 - `finishTask` - 完成任务
 
 ### Bug 管理
+
 - `getMyBugs` - 获取我的Bug列表
 - `getBugDetail` - 获取Bug详情
 - `resolveBug` - 解决Bug
 
 ### 产品管理
+
 - `getProducts` - 获取产品列表
 
 ### 需求管理
+
 - `getProductStories` - 获取产品的需求列表
 - `getStoryDetail` - 获取需求详情
 - `searchStories` - 搜索需求
 - `searchStoriesByProductName` - 按产品名称搜索需求
 
 ### 测试用例管理
+
 - `getProductTestCases` - 获取产品的测试用例
 - `getTestCaseDetail` - 获取测试用例详情
 - `createTestCase` - 创建测试用例
 - `getStoryTestCases` - 获取需求的测试用例
 
 ### 测试单管理
+
 - `getTestTasks` - 获取测试单列表
 - `getTestTaskDetail` - 获取测试单详情
 - `getTestTaskResults` - 获取测试单的测试结果
 - `runTestCase` - 执行测试用例
 
 ### 关联关系查询
+
 - `getStoryRelatedBugs` - 获取需求关联的 Bug 列表
 - `getBugRelatedStory` - 获取 Bug 关联的需求
 
 ### 批量操作
+
 - `batchUpdateTasks` - 批量更新任务
 - `batchResolveBugs` - 批量解决 Bug
 
 ### 数据统计
+
 - `getMyTaskStatistics` - 获取我的任务统计信息
 - `getMyBugStatistics` - 获取我的 Bug 统计信息
 
 ### AI 编程辅助功能
+
 - `getDevelopmentContext` - 获取需求/Bug 的完整开发上下文（包含关联信息）
 - `generateStorySummary` - 生成需求摘要（支持 JSON/Markdown/文本格式）
 - `generateBugSummary` - 生成 Bug 摘要（支持 JSON/Markdown/文本格式）
 - `formatTaskAsMarkdown` - 将任务格式化为 Markdown
 
 ### 智能分析功能
+
 - `analyzeStoryComplexity` - 分析需求复杂度（评分、工时估算、优先级建议）
 - `analyzeBugPriority` - 分析 Bug 优先级（评分、优先级建议）
 - `analyzeTaskWorkload` - 分析任务工作量（工时估算、难度评估）
 
 ### 代码生成提示
+
 - `generateCodePromptFromStory` - 根据需求生成代码框架提示
 - `generateTestPromptFromBug` - 根据 Bug 生成测试用例提示
 - `generateCodeReviewChecklist` - 生成代码审查检查清单
 
 ### 根据需求/Bug创建任务
+
 - `createTaskFromStory` - 根据需求创建任务（提供手动操作指南）
 - `createTaskFromBug` - 根据Bug创建修复任务（提供手动操作指南）
 
@@ -251,4 +221,3 @@ MIT
 
 - [禅道开源版 GitHub](https://github.com/easysoft/zentaopms) - 禅道官方 GitHub 仓库
 - [禅道官网](https://www.zentao.net/)
-

package/dist/index.js

@@ -9,6 +9,66 @@ import { ZentaoError, ErrorCode, createError } from './errors.js';
 import { formatStoryAsMarkdown, formatBugAsMarkdown, formatTaskAsMarkdown, generateStorySummary, generateBugSummary } from './utils/formatter.js';
 import { analyzeStoryComplexity, analyzeBugPriority, analyzeTaskWorkload } from './utils/analyzer.js';
 import { suggestNextActionsForStory, suggestNextActionsForBug, suggestNextActionsForTask, formatSuggestionsAsMarkdown } from './utils/suggestions.js';
+/**
+ * 解析自然语言时间表达式
+ * 支持：今年、今年1月、最近3个月、今天、昨天、上个月等
+ */
+function parseNaturalDate(dateStr) {
+    if (!dateStr) {
+        return undefined;
+    }
+    // 如果已经是标准格式（YYYY-MM-DD），直接返回
+    if (/^\d{4}-\d{2}-\d{2}/.test(dateStr)) {
+        return dateStr;
+    }
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth(); // 0-11
+    const date = now.getDate();
+    const lowerStr = dateStr.toLowerCase().trim();
+    // 今年
+    if (lowerStr === '今年' || lowerStr === 'this year') {
+        return `${year}-01-01`;
+    }
+    // 今年X月
+    const monthMatch = lowerStr.match(/今年(\d+)月/);
+    if (monthMatch) {
+        const m = parseInt(monthMatch[1]);
+        if (m >= 1 && m <= 12) {
+            return `${year}-${String(m).padStart(2, '0')}-01`;
+        }
+    }
+    // 最近N个月
+    const monthsMatch = lowerStr.match(/最近(\d+)个月/);
+    if (monthsMatch) {
+        const months = parseInt(monthsMatch[1]);
+        const targetDate = new Date(year, month - months, date);
+        return targetDate.toISOString().split('T')[0];
+    }
+    // 最近N天
+    const daysMatch = lowerStr.match(/最近(\d+)天/);
+    if (daysMatch) {
+        const days = parseInt(daysMatch[1]);
+        const targetDate = new Date(year, month, date - days);
+        return targetDate.toISOString().split('T')[0];
+    }
+    // 今天
+    if (lowerStr === '今天' || lowerStr === 'today') {
+        return `${year}-${String(month + 1).padStart(2, '0')}-${String(date).padStart(2, '0')}`;
+    }
+    // 昨天
+    if (lowerStr === '昨天' || lowerStr === 'yesterday') {
+        const yesterday = new Date(year, month, date - 1);
+        return yesterday.toISOString().split('T')[0];
+    }
+    // 上个月
+    if (lowerStr === '上个月' || lowerStr === 'last month') {
+        const lastMonth = new Date(year, month - 1, 1);
+        return lastMonth.toISOString().split('T')[0];
+    }
+    // 如果无法解析，返回原字符串（让后续的日期解析函数处理）
+    return dateStr;
+}
 // Create an MCP server
 const server = new McpServer({
     name: "Zentao 11.3 Legacy API",
@@ -379,17 +439,26 @@ server.tool("getStoryDetail", {
 });
 // Add searchStories tool
 server.tool("searchStories", {
-    keyword: z.string(),
-    productId: z.number().optional(),
-    status: z.enum(['draft', 'active', 'closed', 'changed', 'all']).optional(),
-    limit: z.number().optional().default(20)
-}, async ({ keyword, productId, status, limit = 20 }) => {
+    keyword: z.string().describe("搜索关键字，支持中英文，会在需求标题和描述中搜索。例如：'大R促活'、'音视频'、'每日任务'等"),
+    productId: z.number().optional().describe("产品ID（可选），如果指定则只搜索该产品的需求"),
+    status: z.enum(['draft', 'active', 'closed', 'changed', 'all']).optional().describe("需求状态（可选）：draft(草稿)、active(激活)、closed(已关闭)、changed(已变更)、all(全部)"),
+    limit: z.number().optional().default(20).describe("返回结果数量限制（默认20条）"),
+    deepSearch: z.boolean().optional().default(false).describe("是否启用深度搜索（获取需求详情以获取完整描述，速度较慢但结果更准确）"),
+    startDate: z.string().optional().describe("开始时间（可选），格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss。用于过滤需求的创建时间，例如：'2024-01-01' 表示2024年1月1日之后的需求。支持自然语言理解：'今年'、'今年1月'、'最近3个月'等"),
+    endDate: z.string().optional().describe("结束时间（可选），格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss。用于过滤需求的创建时间，例如：'2024-12-31' 表示2024年12月31日之前的需求。支持自然语言理解：'今年'、'今年12月'、'今天'等")
+}, async ({ keyword, productId, status, limit = 20, deepSearch = false, startDate, endDate }) => {
     await ensureInitialized();
     try {
+        // 解析自然语言时间表达式（如果 AI 传递的是自然语言）
+        const parsedStartDate = startDate ? parseNaturalDate(startDate) : undefined;
+        const parsedEndDate = endDate ? parseNaturalDate(endDate) : undefined;
         const stories = await zentaoApi.searchStories(keyword, {
             productId,
             status: status,
-            limit
+            limit,
+            deepSearch,
+            startDate: parsedStartDate || startDate,
+            endDate: parsedEndDate || endDate
         });
         return {
             content: [{ type: "text", text: JSON.stringify(stories, null, 2) }]

package/dist/zentaoLegacyApi.d.ts

@@ -90,12 +90,55 @@ export declare class ZentaoLegacyAPI {
     /**
      * 搜索需求（通过关键字）
      * 由于禅道11.3的搜索API权限限制，我们通过获取所有产品的需求然后本地过滤
+     *
+     * 搜索范围：
+     * - 如果指定 productId：搜索该产品的所有需求（全量）
+     * - 如果未指定 productId：搜索所有产品的所有需求（全量）
+     *
+     * 优化：
+     * 1. 支持分词搜索（将关键字拆分为多个词进行匹配）
+     * 2. 增强匹配逻辑（标题、描述、模块名、产品名）
+     * 3. 智能排序（匹配度评分：标题完全匹配 > 标题包含 > 描述匹配 > 其他字段匹配）
+     * 4. 如果列表接口的spec不完整，对标题匹配的需求进行深度搜索（获取详情）
+     * 5. 支持时间范围过滤（按创建时间 openedDate）
      */
     searchStories(keyword: string, options?: {
         productId?: number;
         status?: StoryStatus;
         limit?: number;
+        deepSearch?: boolean;
+        startDate?: string;
+        endDate?: string;
     }): Promise<Story[]>;
+    /**
+     * 分词：将关键字拆分为多个词
+     * 支持中英文混合，中文按字符拆分，英文按单词拆分
+     */
+    private splitKeywords;
+    /**
+     * 按时间范围过滤需求
+     * @param stories 需求列表
+     * @param startDate 开始时间（可选，格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss）
+     * @param endDate 结束时间（可选，格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss）
+     * @returns 过滤后的需求列表
+     */
+    private filterByDateRange;
+    /**
+     * 解析日期字符串
+     * 支持格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss
+     */
+    private parseDate;
+    /**
+     * 计算匹配度评分
+     * 评分规则：
+     * - 标题完全匹配：100分
+     * - 标题包含关键字：80分
+     * - 标题包含部分关键字（分词匹配）：60分
+     * - 描述包含关键字：40分
+     * - 描述包含部分关键字：20分
+     * - 模块名/产品名匹配：10分
+     */
+    private calculateMatchScore;
     /**
      * 按产品名称搜索需求
      */

package/dist/zentaoLegacyApi.js

@@ -450,9 +450,20 @@ export class ZentaoLegacyAPI {
     /**
      * 搜索需求（通过关键字）
      * 由于禅道11.3的搜索API权限限制，我们通过获取所有产品的需求然后本地过滤
+     *
+     * 搜索范围：
+     * - 如果指定 productId：搜索该产品的所有需求（全量）
+     * - 如果未指定 productId：搜索所有产品的所有需求（全量）
+     *
+     * 优化：
+     * 1. 支持分词搜索（将关键字拆分为多个词进行匹配）
+     * 2. 增强匹配逻辑（标题、描述、模块名、产品名）
+     * 3. 智能排序（匹配度评分：标题完全匹配 > 标题包含 > 描述匹配 > 其他字段匹配）
+     * 4. 如果列表接口的spec不完整，对标题匹配的需求进行深度搜索（获取详情）
+     * 5. 支持时间范围过滤（按创建时间 openedDate）
      */
     async searchStories(keyword, options) {
-        const { productId, status, limit = 50 } = options || {};
+        const { productId, status, limit = 50, deepSearch = false, startDate, endDate } = options || {};
         try {
             let allStories = [];
             if (productId) {
@@ -460,47 +471,190 @@ export class ZentaoLegacyAPI {
                 allStories = await this.getProductStories(productId, status);
             }
             else {
-                // 搜索所有产品的需求
+                // 搜索所有产品的需求（全量搜索）
                 const products = await this.getProducts();
-                // 限制搜索范围，避免请求过多
-                const searchProducts = products.slice(0, 20); // 只搜索前20个产品
-                for (const product of searchProducts) {
+                // 全量搜索：遍历所有产品
+                for (const product of products) {
                     try {
                         const stories = await this.getProductStories(product.id, status);
                         allStories.push(...stories);
                     }
                     catch (error) {
+                        // 某个产品获取失败，继续处理其他产品
+                        console.warn(`获取产品 ${product.id} (${product.name}) 的需求失败:`, error);
                         continue;
                     }
                 }
             }
-            // 本地过滤：按关键字搜索
+            // 时间范围过滤（如果指定了时间范围，先过滤再搜索，提高性能）
+            if (startDate || endDate) {
+                allStories = this.filterByDateRange(allStories, startDate, endDate);
+            }
+            // 分词：将关键字拆分为多个词（支持中英文）
+            const keywords = this.splitKeywords(keyword);
             const keyword_lower = keyword.toLowerCase();
-            const matchedStories = allStories.filter(story => {
-                // 在标题、描述中搜索关键字
-                const titleMatch = story.title.toLowerCase().includes(keyword_lower);
-                const specMatch = story.spec && story.spec.toLowerCase().includes(keyword_lower);
-                return titleMatch || specMatch;
-            });
-            // 按相关性排序（标题匹配优先）
-            matchedStories.sort((a, b) => {
-                const aTitle = a.title.toLowerCase().includes(keyword_lower);
-                const bTitle = b.title.toLowerCase().includes(keyword_lower);
-                if (aTitle && !bTitle)
-                    return -1;
-                if (!aTitle && bTitle)
-                    return 1;
-                // 都匹配标题或都不匹配标题，按ID倒序（新的在前）
-                return b.id - a.id;
+            // 计算匹配度评分
+            const scoredStories = allStories.map(story => {
+                const score = this.calculateMatchScore(story, keyword_lower, keywords);
+                return { story, score };
+            }).filter(item => item.score > 0); // 只保留有匹配的
+            // 如果启用深度搜索，对标题匹配但描述可能不完整的需求获取详情
+            if (deepSearch) {
+                const titleMatchedButLowScore = scoredStories
+                    .filter(item => {
+                    const titleMatch = item.story.title.toLowerCase().includes(keyword_lower);
+                    const specMatch = item.story.spec && item.story.spec.toLowerCase().includes(keyword_lower);
+                    return titleMatch && !specMatch && item.score < 50; // 标题匹配但描述不匹配，且评分较低
+                })
+                    .slice(0, 10); // 最多深度搜索10个
+                for (const item of titleMatchedButLowScore) {
+                    try {
+                        const detail = await this.getStoryDetail(item.story.id);
+                        // 使用完整描述重新计算评分
+                        const newScore = this.calculateMatchScore(detail, keyword_lower, keywords);
+                        if (newScore > item.score) {
+                            item.story = detail;
+                            item.score = newScore;
+                        }
+                    }
+                    catch (error) {
+                        // 忽略获取详情失败的情况
+                        continue;
+                    }
+                }
+            }
+            // 按评分降序排序
+            scoredStories.sort((a, b) => {
+                if (b.score !== a.score) {
+                    return b.score - a.score;
+                }
+                // 评分相同，按ID倒序（新的在前）
+                return b.story.id - a.story.id;
             });
             // 限制返回数量
-            return matchedStories.slice(0, limit);
+            return scoredStories.slice(0, limit).map(item => item.story);
         }
         catch (error) {
             console.error('搜索需求失败:', error);
             throw new Error(`搜索需求失败: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    /**
+     * 分词：将关键字拆分为多个词
+     * 支持中英文混合，中文按字符拆分，英文按单词拆分
+     */
+    splitKeywords(keyword) {
+        const keywords = [];
+        const lowerKeyword = keyword.toLowerCase();
+        // 英文单词（字母、数字、连字符）
+        const englishWords = lowerKeyword.match(/[a-z0-9]+(?:-[a-z0-9]+)*/g) || [];
+        keywords.push(...englishWords);
+        // 中文字符（每个字符作为一个词）
+        const chineseChars = lowerKeyword.match(/[\u4e00-\u9fa5]/g) || [];
+        keywords.push(...chineseChars);
+        // 如果分词后没有结果，返回原始关键字
+        if (keywords.length === 0) {
+            keywords.push(lowerKeyword);
+        }
+        return keywords;
+    }
+    /**
+     * 按时间范围过滤需求
+     * @param stories 需求列表
+     * @param startDate 开始时间（可选，格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss）
+     * @param endDate 结束时间（可选，格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss）
+     * @returns 过滤后的需求列表
+     */
+    filterByDateRange(stories, startDate, endDate) {
+        if (!startDate && !endDate) {
+            return stories;
+        }
+        const start = startDate ? this.parseDate(startDate) : null;
+        const end = endDate ? this.parseDate(endDate) : null;
+        return stories.filter(story => {
+            if (!story.openedDate) {
+                return false; // 没有创建时间的需求不包含在时间范围内
+            }
+            const storyDate = this.parseDate(story.openedDate);
+            if (!storyDate) {
+                return false;
+            }
+            // 检查是否在时间范围内
+            if (start && storyDate < start) {
+                return false;
+            }
+            if (end && storyDate > end) {
+                return false;
+            }
+            return true;
+        });
+    }
+    /**
+     * 解析日期字符串
+     * 支持格式：YYYY-MM-DD 或 YYYY-MM-DD HH:mm:ss
+     */
+    parseDate(dateStr) {
+        if (!dateStr) {
+            return null;
+        }
+        // 尝试解析常见格式
+        // 格式1: YYYY-MM-DD
+        // 格式2: YYYY-MM-DD HH:mm:ss
+        // 格式3: YYYY-MM-DDTHH:mm:ss (ISO格式)
+        const date = new Date(dateStr);
+        if (isNaN(date.getTime())) {
+            return null;
+        }
+        return date;
+    }
+    /**
+     * 计算匹配度评分
+     * 评分规则：
+     * - 标题完全匹配：100分
+     * - 标题包含关键字：80分
+     * - 标题包含部分关键字（分词匹配）：60分
+     * - 描述包含关键字：40分
+     * - 描述包含部分关键字：20分
+     * - 模块名/产品名匹配：10分
+     */
+    calculateMatchScore(story, keyword, keywords) {
+        let score = 0;
+        const title_lower = story.title.toLowerCase();
+        const spec_lower = (story.spec || '').toLowerCase();
+        const moduleName_lower = (story.moduleName || '').toLowerCase();
+        const productName_lower = (story.productName || '').toLowerCase();
+        // 标题完全匹配（最高优先级）
+        if (title_lower === keyword) {
+            score += 100;
+        }
+        // 标题包含完整关键字
+        else if (title_lower.includes(keyword)) {
+            score += 80;
+        }
+        // 标题包含部分关键字（分词匹配）
+        else {
+            const titleKeywordMatches = keywords.filter(k => title_lower.includes(k)).length;
+            if (titleKeywordMatches > 0) {
+                score += 60 * (titleKeywordMatches / keywords.length); // 按匹配比例计算
+            }
+        }
+        // 描述包含完整关键字
+        if (spec_lower.includes(keyword)) {
+            score += 40;
+        }
+        // 描述包含部分关键字
+        else if (spec_lower) {
+            const specKeywordMatches = keywords.filter(k => spec_lower.includes(k)).length;
+            if (specKeywordMatches > 0) {
+                score += 20 * (specKeywordMatches / keywords.length);
+            }
+        }
+        // 模块名/产品名匹配（加分项）
+        if (moduleName_lower.includes(keyword) || productName_lower.includes(keyword)) {
+            score += 10;
+        }
+        return score;
+    }
     /**
      * 按产品名称搜索需求
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxenlin/mcp-zentao-11-3",
-  "version": "1.0.0-patch.1",
+  "version": "1.0.2",
   "description": "Zentao 11.3 legacy 版 MCP 服务器，只支持旧版 Session API，纯净无 REST v1",
   "main": "dist/index.js",
   "type": "module",
@@ -25,13 +25,14 @@
     "11.3",
     "legacy",
     "session-api",
-    "cursor-ide"
+    "mcp-server",
+    "model-context-protocol"
   ],
   "author": "maxenlin",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/maxenlin/mcp-zentao-11-3.git"
+    "url": "https://github.com/MaxenLin/mcp-zentao-11-3.git"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.1",
@@ -49,4 +50,3 @@
     "access": "public"
   }
 }
-