@cqsjjb/meter-sphere-mcp-server 1.0.0-beta.1

package/README.md

@@ -0,0 +1,189 @@
+# @cqsjjb/meter-sphere-mcp-server
+
+MCP (Model Context Protocol) 服务器，用于 MeterSphere 测试用例平台。让 Cursor 等 AI 编辑器可以直接调用测试用例平台，获取测试用例列表、生成 AI 测试提示语，并跟踪测试进度。
+
+## 功能特性
+
+- 🤖 **MCP 工具集成**：提供 MCP 服务器，让 Cursor 可以直接调用测试用例平台
+- 📋 **测试用例清单**：自动获取所有优先级的测试用例，按优先级排序（P0 > P1 > P2 > P3）
+- 🔍 **AI 测试提示语**：自动生成 AI 测试提示语，方便开发者进行测试自检
+- 📊 **进度跟踪**：支持测试进度跟踪，可以暂停和恢复测试
+- 🎯 **智能分析**：集成 AI 模型进行测试用例分析（支持 Deepseek、OpenAI 等）
+
+## 安装
+
+```bash
+npm install @cqsjjb/meter-sphere-mcp-server
+```
+
+## 配置
+
+在 Cursor 的 MCP 配置文件中添加以下配置（通常在 `~/.cursor/mcp.json` 或 Cursor 设置中）：
+
+**Windows 路径示例：**
+```json
+{
+  "mcpServers": {
+    "meter-sphere": {
+      "command": "node",
+      "args": ["./node_modules/@cqsjjb/meter-sphere-mcp-server/mcp-server.mjs"],
+      "env": {
+        "PLATFORM_URL": "http://your-platform-url?organization=xxx&project=xxx&testPlanId=xxx",
+        "X_AUTH_TOKEN": "your-x-auth-token-here",
+        "CSRF_TOKEN": "your-csrf-token-here",
+        "API_BASE_URL": "http://192.168.3.26:8081",
+        "MODEL_BASE_URL": "https://api.deepseek.com",
+        "MODEL_API_KEY": "your-model-api-key-here",
+        "MODEL_ID": "deepseek-chat"
+      }
+    }
+  }
+}
+```
+
+**macOS/Linux 路径示例：**
+```json
+{
+  "mcpServers": {
+    "meter-sphere": {
+      "command": "node",
+      "args": ["./node_modules/@cqsjjb/meter-sphere-mcp-server/mcp-server.mjs"],
+      "env": {
+        "PLATFORM_URL": "http://your-platform-url?organization=xxx&project=xxx&testPlanId=xxx",
+        "X_AUTH_TOKEN": "your-x-auth-token-here",
+        "CSRF_TOKEN": "your-csrf-token-here",
+        "API_BASE_URL": "http://192.168.3.26:8081",
+        "MODEL_BASE_URL": "https://api.deepseek.com",
+        "MODEL_API_KEY": "your-model-api-key-here",
+        "MODEL_ID": "deepseek-chat"
+      }
+    }
+  }
+}
+```
+
+**使用全局安装：**
+```json
+{
+  "mcpServers": {
+    "meter-sphere": {
+      "command": "npx",
+      "args": ["-y", "@cqsjjb/meter-sphere-mcp-server"],
+      "env": {
+        "PLATFORM_URL": "http://your-platform-url?organization=xxx&project=xxx&testPlanId=xxx",
+        "X_AUTH_TOKEN": "your-x-auth-token-here",
+        "CSRF_TOKEN": "your-csrf-token-here"
+      }
+    }
+  }
+}
+```
+
+## 环境变量说明
+
+- `PLATFORM_URL` (必需): 测试用例平台的完整URL（包含查询参数）
+- `X_AUTH_TOKEN` (必需): x-auth-token认证令牌
+- `CSRF_TOKEN` (必需): Csrf-token认证令牌
+- `API_BASE_URL` (可选): API服务器的基础URL，默认值为 `http://192.168.3.26:8081`
+- `MODEL_BASE_URL` (可选): AI模型API的基础URL，默认值为 `https://api.deepseek.com`
+- `MODEL_API_KEY` (可选): AI模型API密钥，如果未配置则跳过AI分析
+- `MODEL_ID` (可选): AI模型ID，默认值为 `deepseek-chat`
+- `PROGRESS_FILE_DIR` (可选): 进度文件存储目录，默认值为当前工作目录（`process.cwd()`）
+
+## 可用工具
+
+### 1. `get_test_list` - 获取测试用例列表
+
+获取所有优先级的测试用例列表，按优先级排序（P0 > P1 > P2 > P3），生成 TODO 清单。支持过滤已完成用例和显示完成状态。
+
+**参数：**
+- `excludeCompleted` (boolean, 可选): 是否排除已完成的测试用例，默认为 false
+
+**使用示例：**
+
+```bash
+# 获取所有测试用例（包括已完成）
+帮我获取所有测试用例的TODO清单
+
+# 只获取未完成的测试用例
+帮我获取未完成的测试用例列表
+```
+
+### 2. `get_test_detail` - 获取测试用例详情
+
+根据测试用例 ID 获取详细信息，包括测试步骤和 AI 测试提示语。会自动调用 AI 模型进行测试用例分析。
+
+**参数：**
+- `testCaseId` (string, 必需): 测试用例 ID
+- `testPlanCollectionName` (string, 必需): 测试点名称（从 get_test_list 返回）
+
+**使用示例：**
+
+```bash
+获取测试用例ID为12345的详细信息，测试点是登录功能
+```
+
+### 3. `mark_test_completed` - 标记测试用例完成
+
+标记指定测试用例为已完成状态，用于进度跟踪。
+
+**参数：**
+- `testCaseId` (string, 必需): 测试用例 ID
+- `priority` (string, 必需): 测试用例优先级（P0/P1/P2/P3）
+
+**使用示例：**
+
+```bash
+标记测试用例ID为12345已完成，优先级是P0
+```
+
+### 4. `get_test_progress` - 获取测试进度
+
+获取当前测试进度，包括已完成和未完成的测试用例统计信息。
+
+**参数：**
+- 无需参数
+
+**使用示例：**
+
+```bash
+查看当前测试进度
+```
+
+## 工作流程
+
+1. **获取测试清单**：使用 `get_test_list` 获取所有测试用例的 TODO 清单
+2. **逐个测试自检**：根据 TODO 清单，使用 `get_test_detail` 逐个获取测试用例详情
+3. **标记完成**：完成测试后，使用 `mark_test_completed` 标记测试用例为已完成
+4. **查看进度**：使用 `get_test_progress` 查看当前测试进度
+5. **继续执行**：使用 `get_test_list(excludeCompleted: true)` 获取未完成的测试用例，继续测试
+6. **AI 辅助测试**：将 AI 测试提示语直接用于 Cursor，进行代码位置定位和测试检查
+
+## 进度跟踪
+
+MCP 工具会自动将测试进度保存到 `test-progress.json` 文件中。进度文件存储位置优先级：
+1. **环境变量 `PROGRESS_FILE_DIR`** 指定的目录
+2. **当前工作目录**（`process.cwd()`，通常是项目根目录）- **默认值**
+3. **用户配置目录**（`~/.config/meter-sphere-mcp/`）- 回退方案
+
+进度文件包含：
+- 测试计划ID
+- 已完成用例列表（包含用例ID、优先级、完成时间）
+- 总用例数和已完成数量
+
+**注意**：
+- 如果切换了不同的测试计划（testPlanId），进度会自动重置
+- 进度文件默认保存在用户项目根目录中，不同项目有独立的进度文件
+- 建议将 `test-progress.json` 添加到 `.gitignore`，避免提交到代码仓库
+
+## 注意事项
+
+1. **URL 格式**：PLATFORM_URL 需要包含完整的查询参数，支持标准 query 参数和 hash 中的参数（SPA 路由格式）
+2. **参数映射**：URL 中的 `id` 会自动映射为 `testPlanId`，`pId` 会自动映射为 `project`，`orgId` 会自动映射为 `organization`
+3. **环境变量配置**：必须在 Cursor 的 MCP 配置中通过 `env` 字段设置 `PLATFORM_URL`、`X_AUTH_TOKEN`、`CSRF_TOKEN`
+4. **API服务器地址**：可通过 `API_BASE_URL` 环境变量配置API服务器地址，默认值为 `http://192.168.3.26:8081`
+5. **AI模型配置**：支持任意兼容 OpenAI API 格式的 AI 模型（Deepseek、OpenAI、Claude 等）
+
+## License
+
+ISC

package/mcp-config.example.json

@@ -0,0 +1,20 @@
+{
+  "mcpServers": {
+    "meter-sphere": {
+      "command": "node",
+      "args": [
+        "./node_modules/@cqsjjb/meter-sphere-mcp-server/mcp-server.mjs"
+      ],
+      "env": {
+        "PLATFORM_URL": "http://your-platform-url?organization=xxx&project=xxx&testPlanId=xxx",
+        "X_AUTH_TOKEN": "your-x-auth-token-here",
+        "CSRF_TOKEN": "your-csrf-token-here",
+        "API_BASE_URL": "http://192.168.3.26:8081",
+        "MODEL_BASE_URL": "https://api.deepseek.com",
+        "MODEL_API_KEY": "your-model-api-key-here",
+        "MODEL_ID": "deepseek-chat"
+      },
+      "description": "MeterSphere 测试用例平台 MCP 工具"
+    }
+  }
+}

package/mcp-server.mjs

@@ -0,0 +1,846 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import http from 'http';
+import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * 获取API基础URL，从环境变量读取，默认值为 http://192.168.3.26:8081
+ */
+function getApiBaseUrl() {
+  return process.env.API_BASE_URL || 'http://192.168.3.26:8081';
+}
+
+/**
+ * 获取AI模型配置，从环境变量读取
+ */
+function getModelConfig() {
+  return {
+    baseURL: process.env.MODEL_BASE_URL || 'https://api.deepseek.com',
+    apiKey: process.env.MODEL_API_KEY || '',
+    model: process.env.MODEL_ID || 'deepseek-chat'
+  };
+}
+
+/**
+ * 获取进度文件路径
+ * 优先级：环境变量 > 当前工作目录 > 用户主目录下的配置目录
+ */
+function getProgressFilePath() {
+  // 优先使用环境变量指定的目录
+  if (process.env.PROGRESS_FILE_DIR) {
+    return path.join(process.env.PROGRESS_FILE_DIR, 'test-progress.json');
+  }
+  
+  // 其次使用当前工作目录（用户运行命令的目录，通常是项目根目录）
+  // 这对于npm包来说是最合适的，因为进度文件应该跟随项目
+  const cwd = process.cwd();
+  if (cwd && cwd !== '/') {
+    return path.join(cwd, 'test-progress.json');
+  }
+  
+  // 最后回退到用户主目录下的配置目录
+  const homeDir = os.homedir();
+  const configDir = path.join(homeDir, '.config', 'meter-sphere-mcp');
+  
+  // 确保配置目录存在
+  try {
+    if (!fs.existsSync(configDir)) {
+      fs.mkdirSync(configDir, { recursive: true });
+    }
+  } catch (error) {
+    console.error('创建配置目录失败:', error);
+  }
+  
+  return path.join(configDir, 'test-progress.json');
+}
+
+/**
+ * 加载测试进度
+ */
+function loadProgress() {
+  const progressPath = getProgressFilePath();
+  try {
+    if (fs.existsSync(progressPath)) {
+      const content = fs.readFileSync(progressPath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.error('加载进度文件失败:', error);
+  }
+  return {
+    testPlanId: null,
+    lastUpdate: null,
+    completed: [],
+    total: 0,
+    completedCount: 0
+  };
+}
+
+/**
+ * 保存测试进度
+ */
+function saveProgress(progress) {
+  const progressPath = getProgressFilePath();
+  try {
+    progress.lastUpdate = new Date().toISOString();
+    fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf8');
+  } catch (error) {
+    console.error('保存进度文件失败:', error);
+    throw new Error(`保存进度失败: ${error.message}`);
+  }
+}
+
+/**
+ * 检查测试用例是否已完成
+ */
+function isCompleted(testCaseId, progress) {
+  return progress.completed.some(item => item.testCaseId === testCaseId);
+}
+
+/**
+ * 标记测试用例为已完成
+ */
+function markCompleted(testCaseId, priority, progress) {
+  if (!isCompleted(testCaseId, progress)) {
+    progress.completed.push({
+      testCaseId: testCaseId,
+      priority: priority,
+      completedAt: new Date().toISOString()
+    });
+    progress.completedCount = progress.completed.length;
+    saveProgress(progress);
+  }
+}
+
+/**
+ * 发送 HTTP POST 请求
+ */
+function httpPost(url, headers = {}, data = {}) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const postData = JSON.stringify(data);
+
+    const requestHeaders = {
+      'Content-Type': 'application/json;charset=UTF-8',
+      'Content-Length': Buffer.byteLength(postData),
+      ...headers
+    };
+
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+      path: urlObj.pathname + (urlObj.search || ''),
+      method: 'POST',
+      headers: requestHeaders
+    };
+
+    const req = http.request(options, res => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const buffer = Buffer.concat(chunks);
+        const responseData = buffer.toString('utf8');
+        resolve(responseData);
+      });
+    });
+
+    req.on('error', error => reject(error));
+    req.write(postData);
+    req.end();
+  });
+}
+
+/**
+ * 发送 HTTP GET 请求
+ */
+function httpGet(url, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || (urlObj.protocol === 'https:' ? 443 : 80),
+      path: urlObj.pathname + (urlObj.search || ''),
+      method: 'GET',
+      headers: headers
+    };
+
+    const req = http.request(options, res => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const buffer = Buffer.concat(chunks);
+        const responseData = buffer.toString('utf8');
+        resolve(responseData);
+      });
+    });
+
+    req.on('error', error => reject(error));
+    req.end();
+  });
+}
+
+/**
+ * 解析URL获取查询参数（与前端index.html中的逻辑保持一致）
+ */
+function parseQueryParams(url) {
+  try {
+    // 创建URL对象来解析URL
+    const urlObj = new URL(url);
+    
+    // 获取标准位置的query参数（在?之后，在#之前）
+    const params = {};
+    urlObj.searchParams.forEach((value, key) => {
+      params[key] = value;
+    });
+
+    // 检查hash中是否包含query参数（SPA路由格式）
+    const hash = urlObj.hash;
+    if (hash && hash.includes('?')) {
+      // 提取hash中的query部分
+      const hashQueryString = hash.substring(hash.indexOf('?') + 1);
+      // 解析hash中的query参数
+      const hashParams = new URLSearchParams(hashQueryString);
+      hashParams.forEach((value, key) => {
+        // 如果标准位置已有同名参数，hash中的参数会覆盖它
+        params[key] = value;
+      });
+    }
+
+    // 参数映射（与前端保持一致）
+    if (params.id) {
+      params.testPlanId = params.id;
+      delete params.id;
+    }
+    if (params.pId) {
+      params.project = params.pId;
+      delete params.pId;
+    }
+    if (params.orgId) {
+      params.organization = params.orgId;
+      delete params.orgId;
+    }
+
+    return params;
+  } catch (error) {
+    throw new Error(`URL解析失败: ${error.message}`);
+  }
+}
+
+/**
+ * 生成AI测试提示语
+ */
+function generateAIPrompt(detailData, testPlanCollectionName) {
+  try {
+    const name = detailData.name || '';
+    const steps = detailData.steps || [];
+    const stepsArray = typeof steps === 'string' ? JSON.parse(steps) : steps;
+
+    if (!Array.isArray(stepsArray) || stepsArray.length === 0) {
+      return `测试点：${testPlanCollectionName || ''}\n用例名称：${name}\n测试步骤：暂无测试步骤`;
+    }
+
+    const sortedSteps = stepsArray.sort((a, b) => (a.num || 0) - (b.num || 0));
+    let prompt = `测试点：${testPlanCollectionName || ''}\n用例名称：${name}\n测试步骤：\n`;
+
+    sortedSteps.forEach((step, index) => {
+      const stepNum = index + 1;
+      const desc = step.desc || '';
+      const result = step.result || '';
+      const stepText = `${desc}${result ? ' 期望结果： ' + result : ''}`;
+      prompt += `${stepNum}. ${stepText}\n`;
+    });
+
+    return prompt.trim();
+  } catch (error) {
+    console.error('生成AI提示语错误:', error);
+    return '生成提示语失败';
+  }
+}
+
+/**
+ * 获取优先级等级（用于排序）
+ */
+function getPriorityLevel(priority) {
+  const priorityMap = {
+    'P0': 0,
+    'P1': 1,
+    'P2': 2,
+    'P3': 3
+  };
+  return priorityMap[priority] !== undefined ? priorityMap[priority] : 999;
+}
+
+/**
+ * 调用 AI 模型 API 进行流式分析
+ */
+async function analyzeWithModel(promptText) {
+  const config = getModelConfig();
+  
+  if (!config.apiKey) {
+    throw new Error('缺少 MODEL_API_KEY 环境变量配置');
+  }
+
+  const analysisPrompt = `你是一个专业的测试用例分析专家。请仔细分析以下测试用例，将其中的测试步骤按照以下三个类别进行分类：
+
+**分类说明：**
+1. **配置优化** - 涉及系统配置、参数设置、选项调整、权限配置、环境配置等
+2. **前端交互功能** - 涉及用户界面操作、页面交互、表单填写、按钮点击、数据展示、样式验证等前端功能
+3. **后端数据** - 涉及接口调用、数据处理、数据库操作、数据同步、API请求、数据查询等后端功能
+
+**测试用例内容：**
+${promptText}
+
+**要求：**
+1. 仔细分析每个测试步骤，判断它主要属于哪个类别
+2. 对于每个测试步骤，明确标注其类别（配置优化/前端交互功能/后端数据）
+3. 如果某个步骤涉及多个方面，选择最主要的一个类别
+4. 最后给出整体分类结论：这个用例主要属于哪个类别
+5. 如果是前端自测，请明确指出哪些步骤是前端需要测试的，哪些不需要
+
+**输出格式：**
+请按照以下格式输出：
+
+1. 测试点：[测试点名称]
+2. 用例名称：[用例名称]
+3. 测试类别：[前端交互功能 / 配置优化 / 后端数据]
+4. 测试步骤
+- 需要测试的步骤：[列出前端相关的步骤]
+- 不需要测试的步骤：[列出非前端相关的步骤]`;
+
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(`${config.baseURL}/v1/chat/completions`);
+    const postData = JSON.stringify({
+      model: config.model,
+      messages: [
+        {
+          role: 'user',
+          content: analysisPrompt
+        }
+      ],
+      stream: true,
+      temperature: 0.3
+    });
+
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || 443,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.apiKey}`,
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      if (res.statusCode !== 200) {
+        let errorData = '';
+        res.on('data', chunk => errorData += chunk.toString());
+        res.on('end', () => {
+          reject(new Error(`AI模型API请求失败: ${res.statusCode} - ${errorData}`));
+        });
+        return;
+      }
+
+      let buffer = '';
+      let fullContent = '';
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.trim() === '') continue;
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6);
+            if (data === '[DONE]') {
+              resolve(fullContent);
+              return;
+            }
+            try {
+              const json = JSON.parse(data);
+              const content = json.choices?.[0]?.delta?.content || '';
+              if (content) {
+                fullContent += content;
+              }
+            } catch (e) {
+              // 忽略JSON解析错误
+            }
+          }
+        }
+      });
+
+      res.on('end', () => {
+        if (fullContent) {
+          resolve(fullContent);
+        } else {
+          reject(new Error('AI模型API响应为空'));
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(new Error(`AI模型API请求错误: ${error.message}`));
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+class MeterSphereMCPServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'meter-sphere-test-cases',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+  }
+
+  setupHandlers() {
+    // 列出可用工具
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: 'get_test_list',
+            description: '获取所有优先级的测试用例列表，按优先级排序（P0 > P1 > P2 > P3），生成TODO清单。支持过滤已完成用例和显示完成状态。配置信息从环境变量读取（PLATFORM_URL、X_AUTH_TOKEN、CSRF_TOKEN）。重要提示：当用户要求"继续测试"、"继续自检"、"跳过已完成的"或类似需求时，必须设置 excludeCompleted=true 来排除已完成的测试用例，只返回未完成的用例列表。',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                excludeCompleted: {
+                  type: 'boolean',
+                  description: '是否排除已完成的测试用例。默认为false（显示所有用例）。当用户要求继续测试、跳过已完成用例时，必须设置为true。设置为true后，返回的列表将只包含未完成的测试用例，方便继续测试工作。',
+                },
+              },
+              required: [],
+            },
+          },
+          {
+            name: 'get_test_detail',
+            description: '根据测试用例ID获取详细信息，包括测试步骤和AI测试提示语。会自动调用AI模型进行测试用例分析。配置信息从环境变量读取（PLATFORM_URL、X_AUTH_TOKEN、CSRF_TOKEN、MODEL_BASE_URL、MODEL_API_KEY、MODEL_ID）。',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                testCaseId: {
+                  type: 'string',
+                  description: '测试用例ID',
+                },
+                testPlanCollectionName: {
+                  type: 'string',
+                  description: '测试点名称（从get_test_list返回）',
+                },
+              },
+              required: ['testCaseId', 'testPlanCollectionName'],
+            },
+          },
+          {
+            name: 'mark_test_completed',
+            description: '标记指定测试用例为已完成状态，用于进度跟踪。',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                testCaseId: {
+                  type: 'string',
+                  description: '测试用例ID',
+                },
+                priority: {
+                  type: 'string',
+                  description: '测试用例优先级（P0/P1/P2/P3）',
+                },
+              },
+              required: ['testCaseId', 'priority'],
+            },
+          },
+          {
+            name: 'get_test_progress',
+            description: '获取当前测试进度，包括已完成和未完成的测试用例统计信息。',
+            inputSchema: {
+              type: 'object',
+              properties: {},
+              required: [],
+            },
+          },
+        ],
+      };
+    });
+
+    // 处理工具调用
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        if (name === 'get_test_list') {
+          return await this.handleGetTestList(args);
+        } else if (name === 'get_test_detail') {
+          return await this.handleGetTestDetail(args);
+        } else if (name === 'mark_test_completed') {
+          return await this.handleMarkTestCompleted(args);
+        } else if (name === 'get_test_progress') {
+          return await this.handleGetTestProgress(args);
+        } else {
+          throw new Error(`未知工具: ${name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `错误: ${error.message}\n${error.stack || ''}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    });
+  }
+
+  async handleGetTestList(args) {
+    const { excludeCompleted = false } = args || {};
+    
+    // 从环境变量读取配置
+    const platformUrl = process.env.PLATFORM_URL;
+    const xAuthToken = process.env.X_AUTH_TOKEN;
+    const csrfToken = process.env.CSRF_TOKEN;
+    
+    if (!platformUrl || !xAuthToken || !csrfToken) {
+      throw new Error('缺少必要配置。请在 Cursor 的 MCP 配置中通过环境变量设置 PLATFORM_URL、X_AUTH_TOKEN、CSRF_TOKEN');
+    }
+
+    // 解析URL获取参数
+    const parsedParams = parseQueryParams(platformUrl);
+    const { organization, project, testPlanId } = parsedParams;
+
+    if (!organization || !project || !testPlanId) {
+      throw new Error('URL中缺少必要参数（organization、project、testPlanId）');
+    }
+
+    // 加载进度
+    const progress = loadProgress();
+    if (progress.testPlanId && progress.testPlanId !== testPlanId) {
+      // 如果testPlanId变化，重置进度
+      progress.testPlanId = testPlanId;
+      progress.completed = [];
+      progress.completedCount = 0;
+      saveProgress(progress);
+    } else if (!progress.testPlanId) {
+      progress.testPlanId = testPlanId;
+      saveProgress(progress);
+    }
+
+    // 构建目标API URL
+    const apiBaseUrl = getApiBaseUrl();
+    const targetUrl = `${apiBaseUrl}/test-plan/functional/case/page`;
+    
+    const headers = {
+      'Csrf-token': csrfToken,
+      'organization': organization,
+      'project': project,
+      'x-auth-token': xAuthToken,
+    };
+
+    const requestData = {
+      current: 1,
+      pageSize: 500,
+      sort: {},
+      keyword: '',
+      viewId: '',
+      combineSearch: {
+        searchMode: 'AND',
+        conditions: [],
+      },
+      filter: {},
+      treeType: 'COLLECTION',
+      testPlanId: testPlanId,
+      collectionId: '',
+      projectId: '',
+    };
+
+    const response = await httpPost(targetUrl, headers, requestData);
+    const data = JSON.parse(response);
+
+    if (!data || !data.data || !data.data.list) {
+      throw new Error('获取测试用例列表失败：响应数据格式不正确');
+    }
+
+    const testCases = data.data.list;
+
+    // 处理所有测试用例，提取优先级并按优先级排序
+    let processedTestCases = testCases
+      .map(item => {
+        const priority = (item.customFields && item.customFields[0] && item.customFields[0].defaultValue) || '-';
+        return {
+          id: item.id,
+          name: item.name,
+          priority: priority.toUpperCase(),
+          testPlanCollectionName: item.testPlanCollectionName || '',
+          createUserName: item.createUserName || '',
+          moduleName: item.moduleName || '',
+        };
+      })
+      .sort((a, b) => {
+        return getPriorityLevel(a.priority) - getPriorityLevel(b.priority);
+      });
+
+    // 更新进度中的总数
+    progress.total = processedTestCases.length;
+    saveProgress(progress);
+
+    // 如果excludeCompleted为true，过滤已完成的用例
+    if (excludeCompleted) {
+      processedTestCases = processedTestCases.filter(testCase => {
+        return !isCompleted(testCase.id, progress);
+      });
+    }
+
+    // 统计各优先级的数量
+    const priorityCounts = {
+      P0: 0,
+      P1: 0,
+      P2: 0,
+      P3: 0,
+      other: 0
+    };
+
+    processedTestCases.forEach(testCase => {
+      const priority = testCase.priority;
+      if (priorityCounts.hasOwnProperty(priority)) {
+        priorityCounts[priority]++;
+      } else {
+        priorityCounts.other++;
+      }
+    });
+
+    const totalCount = processedTestCases.length;
+
+    // 生成统计信息
+    const stats = [
+      `共找到 (${totalCount}) 个测试用例;`,
+      `P0: ${priorityCounts.P0}个`,
+      `P1: ${priorityCounts.P1}个`,
+      `P2: ${priorityCounts.P2}个`,
+      `P3: ${priorityCounts.P3}个`
+    ].join('\n');
+
+    // 生成TODO清单格式：✅/⬜ 用例ID:1245456454654545(P0)
+    const todoList = processedTestCases.map(testCase => {
+      const status = isCompleted(testCase.id, progress) ? '✅' : '⬜';
+      return `${status} 用例ID:${testCase.id}(${testCase.priority})`;
+    }).join('\n');
+
+    const progressInfo = excludeCompleted 
+      ? `\n（已过滤已完成用例，剩余 ${processedTestCases.length} 个未完成用例）`
+      : `\n（已完成: ${progress.completedCount}/${progress.total}）\n提示：如需继续测试未完成的用例，请使用 excludeCompleted=true 参数调用此工具`;
+
+    const result = `${stats}${progressInfo}\n\nTODO:\n${todoList}`;
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result,
+        },
+      ],
+    };
+  }
+
+  async handleGetTestDetail(args) {
+    const { testCaseId, testPlanCollectionName } = args;
+    
+    // 检查用例是否已完成
+    const progress = loadProgress();
+    const isCaseCompleted = isCompleted(testCaseId, progress);
+    let completedInfo = '';
+    if (isCaseCompleted) {
+      const completedItem = progress.completed.find(item => item.testCaseId === testCaseId);
+      const completedTime = completedItem ? new Date(completedItem.completedAt).toLocaleString('zh-CN') : '';
+      completedInfo = `\n\n⚠️ **注意：此测试用例已完成** ✅\n完成时间：${completedTime}\n如需继续测试其他用例，请使用 get_test_list 工具并设置 excludeCompleted=true 获取未完成的用例列表。\n`;
+    }
+    
+    // 从环境变量读取配置
+    const platformUrl = process.env.PLATFORM_URL;
+    const xAuthToken = process.env.X_AUTH_TOKEN;
+    const csrfToken = process.env.CSRF_TOKEN;
+
+    if (!platformUrl || !xAuthToken || !csrfToken) {
+      throw new Error('缺少必要配置。请在 Cursor 的 MCP 配置中通过环境变量设置 PLATFORM_URL、X_AUTH_TOKEN、CSRF_TOKEN');
+    }
+
+    // 解析URL获取参数
+    const parsedParams = parseQueryParams(platformUrl);
+    const { organization, project } = parsedParams;
+
+    if (!organization || !project) {
+      throw new Error('URL中缺少必要参数（organization、project）');
+    }
+
+    // 构建目标API URL
+    const apiBaseUrl = getApiBaseUrl();
+    const targetUrl = `${apiBaseUrl}/test-plan/functional/case/detail/${testCaseId}`;
+    
+    const headers = {
+      'Csrf-token': csrfToken,
+      'organization': organization,
+      'project': project,
+      'x-auth-token': xAuthToken,
+    };
+
+    const response = await httpGet(targetUrl, headers);
+    const data = JSON.parse(response);
+
+    if (!data || !data.data) {
+      throw new Error('获取测试用例详情失败：响应数据格式不正确');
+    }
+
+    const detailData = data.data;
+    const aiPrompt = generateAIPrompt(detailData, testPlanCollectionName);
+
+    // 尝试调用AI模型进行分析
+    let modelAnalysis = '';
+    try {
+      modelAnalysis = await analyzeWithModel(aiPrompt);
+    } catch (error) {
+      console.error('AI模型分析失败:', error);
+      modelAnalysis = `\n\n⚠️ AI模型分析失败: ${error.message}\n（如果未配置MODEL_API_KEY，可以忽略此错误）`;
+    }
+
+    // 添加AI测试提示语前缀
+    const fullPrompt = '请根据下列提示语中的测试点、用例名称、测试类别、测试步骤、分析说明找到当前项目中对应的代码位置，进行测试检查\n\n' + aiPrompt;
+
+    let resultText = `## 测试用例详情\n\n` +
+                      `**用例ID**: ${testCaseId}${completedInfo}` +
+                      `## 测试内容\n\n\`\`\`\n${fullPrompt}\n\`\`\`\n`;
+
+    if (modelAnalysis && !modelAnalysis.includes('AI模型分析失败')) {
+      resultText += `\n## AI分析结果\n\n\`\`\`\n${modelAnalysis}\n\`\`\`\n`;
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: resultText
+        },
+      ],
+    };
+  }
+
+  async handleMarkTestCompleted(args) {
+    const { testCaseId, priority } = args;
+    
+    if (!testCaseId || !priority) {
+      throw new Error('缺少必要参数：testCaseId 和 priority');
+    }
+
+    const progress = loadProgress();
+    markCompleted(testCaseId, priority, progress);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `✅ 已标记测试用例 ${testCaseId}(${priority}) 为已完成\n\n当前进度: ${progress.completedCount}/${progress.total}`
+        },
+      ],
+    };
+  }
+
+  async handleGetTestProgress(args) {
+    const progress = loadProgress();
+
+    if (!progress.testPlanId || progress.total === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: '暂无测试进度记录。请先调用 get_test_list 获取测试用例列表。'
+          },
+        ],
+      };
+    }
+
+    const completedCount = progress.completedCount;
+    const total = progress.total;
+    const remaining = total - completedCount;
+    const percentage = total > 0 ? Math.round((completedCount / total) * 100) : 0;
+
+    // 按优先级统计已完成用例
+    const completedByPriority = {
+      P0: 0,
+      P1: 0,
+      P2: 0,
+      P3: 0,
+      other: 0
+    };
+
+    progress.completed.forEach(item => {
+      const priority = item.priority || 'other';
+      if (completedByPriority.hasOwnProperty(priority)) {
+        completedByPriority[priority]++;
+      } else {
+        completedByPriority.other++;
+      }
+    });
+
+    const progressText = [
+      `## 测试进度统计`,
+      ``,
+      `总用例数: ${total}`,
+      `已完成: ${completedCount}`,
+      `剩余: ${remaining}`,
+      `完成率: ${percentage}%`,
+      ``,
+      `### 已完成用例按优先级分布:`,
+      `P0: ${completedByPriority.P0}个`,
+      `P1: ${completedByPriority.P1}个`,
+      `P2: ${completedByPriority.P2}个`,
+      `P3: ${completedByPriority.P3}个`,
+      ``,
+      `### 已完成用例列表:`,
+      ...(progress.completed.length > 0 
+        ? progress.completed.map(item => 
+            `✅ 用例ID:${item.testCaseId}(${item.priority}) - ${new Date(item.completedAt).toLocaleString('zh-CN')}`
+          )
+        : ['暂无']
+      )
+    ].join('\n');
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: progressText
+        },
+      ],
+    };
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('MeterSphere MCP Server 已启动');
+  }
+}
+
+// 启动服务器
+const server = new MeterSphereMCPServer();
+server.run().catch(console.error);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@cqsjjb/meter-sphere-mcp-server",
+  "version": "1.0.0-beta.1",
+  "description": "MCP server for MeterSphere test cases platform - Get test cases, generate AI test prompts, and track testing progress",
+  "main": "mcp-server.mjs",
+  "type": "module",
+  "bin": {
+    "meter-sphere-mcp": "./mcp-server.mjs"
+  },
+  "scripts": {
+    "start": "node mcp-server.mjs"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "meter-sphere",
+    "test-cases",
+    "testing",
+    "ai",
+    "cursor"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://192.168.1.242:10985/jjb/ai-agent/mcp/meter-sphere-mcp-server.git"
+  },
+  "files": [
+    "mcp-server.mjs",
+    "README.md",
+    "mcp-config.example.json"
+  ]
+}