@cqsjjb/meter-sphere-mcp-server 1.0.1 → 1.0.3

package/mcp-server.mjs

@@ -1,928 +1,999 @@
-#!/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,
-    apiKey: process.env.MODEL_API_KEY,
-    model: process.env.MODEL_ID
-  };
-}
-
-/**
- * 获取进度文件路径
- * 优先级：环境变量 > 当前工作目录 > 用户主目录下的配置目录
- */
-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);
-  }
-}
-
-/**
- * 重置测试进度文件
- */
-function resetProgress(keepTestPlanId = false) {
-  const currentProgress = loadProgress();
-  
-  const newProgress = {
-    testPlanId: keepTestPlanId ? currentProgress.testPlanId : null,
-    lastUpdate: null,
-    completed: [],
-    total: 0,
-    completedCount: 0
-  };
-  
-  try {
-    saveProgress(newProgress);
-    return newProgress;
-  } catch (error) {
-    console.error('重置进度文件失败:', error);
-    throw new Error(`重置进度失败: ${error.message}`);
-  }
-}
-
-/**
- * 发送 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. **对于涉及交互的步骤，必须明确标注"需要用户手动验证交互效果"**
-6. 明确指出哪些步骤可以通过静态代码分析完成，哪些需要用户手动测试验证
-
-**输出格式：**
-请按照以下格式输出：
-
-1. 测试点：[测试点名称]
-2. 用例名称：[用例名称]
-3. 测试类别：[前端交互功能 / 配置优化 / 后端数据]
-4. 测试步骤分析
-- 可通过静态代码分析验证的步骤：[列出可通过代码分析验证的步骤]
-- 需要用户手动验证交互的步骤：[列出需要实际交互验证的步骤，并明确提示用户手动完成测试]
-5. 静态代码分析建议：[针对可通过静态代码分析的部分，给出具体的代码检查建议]`;
-
-  return new Promise((resolve, reject) => {
-    const urlObj = new URL(`${config.baseURL}/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: [],
-            },
-          },
-          {
-            name: 'reset_test_progress',
-            description: '重置测试进度文件（test-progress.json），清空所有已完成的测试用例记录。可选择是否保留当前测试计划ID。',
-            inputSchema: {
-              type: 'object',
-              properties: {
-                keepTestPlanId: {
-                  type: 'boolean',
-                  description: '是否保留当前测试计划ID。默认为false（完全重置）。设置为true时，只清空已完成用例记录，但保留testPlanId。',
-                },
-              },
-              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 if (name === 'reset_test_progress') {
-          return await this.handleResetTestProgress(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\n⚠️ **提示**：此工具仅用于静态代码分析，不涉及实际交互测试。对于涉及交互的测试用例，需要用户手动完成测试验证。`
-      : `\n（已完成: ${progress.completedCount}/${progress.total}）\n\n⚠️ **提示**：此工具仅用于静态代码分析，不涉及实际交互测试。对于涉及交互的测试用例，需要用户手动完成测试验证。\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请根据下列提示语中的测试点、用例名称、测试类别、测试步骤、分析说明找到当前项目中对应的代码位置，进行静态代码检查：\n- 检查代码逻辑是否正确实现\n- 检查配置参数是否正确设置\n- 检查接口调用是否符合预期\n- 检查数据结构是否正确\n\n**对于涉及用户交互、界面操作、实际运行验证的测试步骤，请明确提示用户需要手动完成测试验证。**\n\n' + aiPrompt;
-
-    let resultText = `## 测试用例详情\n\n` +
-                      `**用例ID**: ${testCaseId}${completedInfo}` +
-                      `## ⚠️ 重要提示\n\n**此工具仅用于静态代码分析**，通过分析代码结构、逻辑、配置等来验证测试用例，不涉及实际交互操作。对于涉及用户交互、界面操作、实际运行验证的测试步骤，需要用户手动完成测试验证。\n\n` +
-                      `## 测试内容\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 handleResetTestProgress(args) {
-    const { keepTestPlanId = false } = args || {};
-    
-    const progressPath = getProgressFilePath();
-    const oldProgress = loadProgress();
-    
-    // 重置进度
-    const newProgress = resetProgress(keepTestPlanId);
-    
-    const resetInfo = [
-      `✅ 测试进度文件已重置`,
-      ``,
-      `重置前状态:`,
-      `- 测试计划ID: ${oldProgress.testPlanId || '无'}`,
-      `- 已完成用例数: ${oldProgress.completedCount}`,
-      `- 总用例数: ${oldProgress.total}`,
-      ``,
-      `重置后状态:`,
-      `- 测试计划ID: ${newProgress.testPlanId || '无'}${keepTestPlanId ? ' (已保留)' : ' (已清空)'}`,
-      `- 已完成用例数: ${newProgress.completedCount}`,
-      `- 总用例数: ${newProgress.total}`,
-      ``,
-      `进度文件路径: ${progressPath}`
-    ].join('\n');
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: resetInfo
-        },
-      ],
-    };
-  }
-
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    console.error('MeterSphere MCP Server 已启动');
-  }
-}
-
-// 启动服务器
-const server = new MeterSphereMCPServer();
+#!/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';
+
+/**
+ * 获取平台配置，从环境变量读取（扁平化格式）
+ */
+function getPlatformConfig() {
+  const xAuthToken = process.env.PLATFORM_X_AUTH_TOKEN;
+  const csrfToken = process.env.PLATFORM_CSRF_TOKEN;
+  const project = process.env.PLATFORM_PROJECT;
+  const organization = process.env.PLATFORM_ORGANIZATION;
+  const moduleIdsStr = process.env.PLATFORM_MODULE_IDS || '[]';
+  
+  if (!xAuthToken || !csrfToken || !project || !organization) {
+    throw new Error('缺少必要配置。请在 Cursor 的 MCP 配置中通过环境变量设置 PLATFORM_X_AUTH_TOKEN、PLATFORM_CSRF_TOKEN、PLATFORM_PROJECT、PLATFORM_ORGANIZATION');
+  }
+  
+  let moduleIds = [];
+  try {
+    moduleIds = JSON.parse(moduleIdsStr);
+    if (!Array.isArray(moduleIds)) {
+      moduleIds = [];
+    }
+  } catch (error) {
+    // 如果解析失败，使用空数组
+    moduleIds = [];
+  }
+  
+  return {
+    xAuthToken,
+    csrfToken,
+    project,
+    organization,
+    moduleIds
+  };
+}
+
+/**
+ * 获取默认的AI分析提示语模板
+ */
+function getDefaultAnalysisPromptTemplate() {
+  return `你是一个专业的测试用例分析专家。请仔细分析以下测试用例，将其中的测试步骤按照以下三个类别进行分类：
+
+**重要说明：**
+- 此工具仅用于**静态代码分析**，通过分析代码结构、逻辑、配置等来验证测试用例
+- **不涉及实际交互操作**，如页面点击、表单提交、实际运行等
+- 对于涉及用户交互、界面操作、实际运行验证的测试步骤，需要明确提示用户手动完成测试验证
+
+**分类说明：**
+1. **配置优化** - 涉及系统配置、参数设置、选项调整、权限配置、环境配置等（可通过静态代码分析验证）
+2. **前端交互功能** - 涉及用户界面操作、页面交互、表单填写、按钮点击、数据展示、样式验证等前端功能（需要用户手动验证交互效果）
+3. **后端数据** - 涉及接口调用、数据处理、数据库操作、数据同步、API请求、数据查询等后端功能（可通过静态代码分析验证接口调用逻辑）
+
+**测试用例内容：**
+{{PROMPT_TEXT}}
+
+**要求：**
+1. 仔细分析每个测试步骤，判断它主要属于哪个类别
+2. 对于每个测试步骤，明确标注其类别（配置优化/前端交互功能/后端数据）
+3. 如果某个步骤涉及多个方面，选择最主要的一个类别
+4. 最后给出整体分类结论：这个用例主要属于哪个类别
+5. **对于涉及交互的步骤，必须明确标注"需要用户手动验证交互效果"**
+6. 明确指出哪些步骤可以通过静态代码分析完成，哪些需要用户手动测试验证
+
+**输出格式：**
+请按照以下格式输出：
+
+1. 测试点：[测试点名称]
+2. 用例名称：[用例名称]
+3. 测试类别：[前端交互功能 / 配置优化 / 后端数据]
+4. 测试步骤分析
+- 可通过静态代码分析验证的步骤：[列出可通过代码分析验证的步骤]
+- 需要用户手动验证交互的步骤：[列出需要实际交互验证的步骤，并明确提示用户手动完成测试]
+5. 静态代码分析建议：[针对可通过静态代码分析的部分，给出具体的代码检查建议]`;
+}
+
+/**
+ * 获取AI模型配置，从环境变量读取（扁平化格式）
+ */
+function getModelConfig() {
+  const baseURL = process.env.MODEL_BASE_URL;
+  const apiKey = process.env.MODEL_API_KEY;
+  const model = process.env.MODEL_ID;
+  const analysisPromptTemplate = process.env.MODEL_ANALYSIS_PROMPT || getDefaultAnalysisPromptTemplate();
+  
+  return {
+    baseURL: baseURL || null,
+    apiKey: apiKey || null,
+    model: model || null,
+    analysisPromptTemplate: analysisPromptTemplate
+  };
+}
+
+/**
+ * 获取进度文件路径
+ * 优先级：环境变量 > 当前工作目录 > 用户主目录下的配置目录
+ */
+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');
+      const progress = JSON.parse(content);
+      // 向后兼容：如果旧进度文件没有 knownTestCaseIds 字段，初始化它
+      if (!progress.knownTestCaseIds) {
+        progress.knownTestCaseIds = [];
+        // 如果已有已完成用例，将它们添加到 knownTestCaseIds 中
+        if (progress.completed && Array.isArray(progress.completed)) {
+          progress.completed.forEach(item => {
+            if (item.testCaseId && !progress.knownTestCaseIds.includes(item.testCaseId)) {
+              progress.knownTestCaseIds.push(item.testCaseId);
+            }
+          });
+        }
+        // 更新 total 为 knownTestCaseIds 的长度
+        progress.total = progress.knownTestCaseIds.length;
+        // 保存更新后的进度，确保向后兼容的修改被持久化
+        try {
+          saveProgress(progress);
+        } catch (error) {
+          // 如果保存失败，不影响加载，只记录错误
+          console.error('保存向后兼容更新失败:', error);
+        }
+      }
+      return progress;
+    }
+  } catch (error) {
+    console.error('加载进度文件失败:', error);
+  }
+  return {
+    lastUpdate: null,
+    completed: [],
+    total: 0,
+    completedCount: 0,
+    knownTestCaseIds: [] // 记录所有已知的用例ID（用于准确计算总数）
+  };
+}
+
+/**
+ * 保存测试进度
+ */
+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;
+    
+    // 确保 knownTestCaseIds 存在
+    if (!progress.knownTestCaseIds) {
+      progress.knownTestCaseIds = [];
+    }
+    // 将已完成的用例ID添加到已知集合中（如果不存在）
+    if (!progress.knownTestCaseIds.includes(testCaseId)) {
+      progress.knownTestCaseIds.push(testCaseId);
+    }
+    // 更新总数
+    progress.total = progress.knownTestCaseIds.length;
+    
+    saveProgress(progress);
+  }
+}
+
+/**
+ * 重置测试进度文件
+ */
+function resetProgress() {
+  const newProgress = {
+    lastUpdate: null,
+    completed: [],
+    total: 0,
+    completedCount: 0,
+    knownTestCaseIds: []
+  };
+  
+  try {
+    saveProgress(newProgress);
+    return newProgress;
+  } catch (error) {
+    console.error('重置进度文件失败:', error);
+    throw new Error(`重置进度失败: ${error.message}`);
+  }
+}
+
+/**
+ * 发送 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();
+  });
+}
+
+/**
+ * 生成AI测试提示语
+ */
+function generateAIPrompt(detailData, testPlanCollectionName) {
+  try {
+    const name = detailData.name || '';
+    const caseEditType = detailData.caseEditType || 'STEP';
+    
+    let prompt = `测试点：${testPlanCollectionName || ''}\n用例名称：${name}\n测试步骤：\n`;
+    let hasSteps = false;
+
+    // 处理 STEP 类型：从 steps 字段解析
+    if (caseEditType === 'STEP') {
+      try {
+        const steps = detailData.steps || [];
+        let stepsArray = [];
+        
+        if (typeof steps === 'string') {
+          try {
+            stepsArray = JSON.parse(steps);
+          } catch (e) {
+            // 如果解析失败，尝试作为空数组处理
+            stepsArray = [];
+          }
+        } else {
+          stepsArray = steps;
+        }
+
+        if (Array.isArray(stepsArray) && stepsArray.length > 0) {
+          const sortedSteps = stepsArray.sort((a, b) => (a.num || 0) - (b.num || 0));
+          
+          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`;
+            hasSteps = true;
+          });
+        }
+      } catch (e) {
+        console.error('解析STEP类型步骤失败:', e);
+      }
+    }
+    // 处理 TEXT 类型：从 textDescription 和 expectedResult 字段解析
+    else if (caseEditType === 'TEXT') {
+      const textDescription = detailData.textDescription || '';
+      const expectedResult = detailData.expectedResult || '';
+
+      if (textDescription && textDescription.trim()) {
+        // 解析 textDescription，格式类似 "[1]步骤1\n[2]步骤2\n..."
+        const descLines = textDescription.split('\n').filter(line => line.trim());
+        const resultLines = expectedResult && expectedResult.trim() ? expectedResult.split('\n').filter(line => line.trim()) : [];
+
+        if (descLines.length > 0) {
+          descLines.forEach((line, index) => {
+            // 移除开头的 [数字] 标记，支持多种格式
+            const cleanLine = line.replace(/^\[\d+\]\s*/, '').trim();
+            const resultLine = resultLines[index] ? resultLines[index].replace(/^\[\d+\]\s*/, '').trim() : '';
+            const stepText = `${cleanLine}${resultLine ? ' 期望结果： ' + resultLine : ''}`;
+            prompt += `${index + 1}. ${stepText}\n`;
+            hasSteps = true;
+          });
+        }
+      }
+    }
+
+    if (!hasSteps) {
+      return `测试点：${testPlanCollectionName || ''}\n用例名称：${name}\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 进行流式分析
+ */
+/**
+ * 调用 AI 模型 API 进行流式分析
+ * @param {string} promptText - 测试用例提示语
+ * @returns {Promise<string|null>} 返回分析结果，如果未配置MODEL则返回null
+ */
+async function analyzeWithModel(promptText) {
+  const config = getModelConfig();
+  
+  // 如果MODEL配置不完整，返回null表示跳过AI分析
+  if (!config.baseURL || !config.apiKey || !config.model) {
+    return null;
+  }
+
+  // 使用配置的提示语模板，将 {{PROMPT_TEXT}} 替换为实际的测试用例内容
+  // 如果模板中没有 {{PROMPT_TEXT}} 占位符，则在末尾追加测试用例内容
+  let analysisPrompt = config.analysisPromptTemplate;
+  if (analysisPrompt.includes('{{PROMPT_TEXT}}')) {
+    analysisPrompt = analysisPrompt.replace('{{PROMPT_TEXT}}', promptText);
+  } else {
+    analysisPrompt = `${analysisPrompt}\n\n**测试用例内容：**\n${promptText}`;
+  }
+
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(`${config.baseURL}/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配置必需，MODEL配置可选）。重要提示：此工具仅用于静态代码分析，不涉及实际交互测试。当用户要求"继续测试"、"继续自检"、"跳过已完成的"或类似需求时，必须设置 excludeCompleted=true 来排除已完成的测试用例，只返回未完成的用例列表。',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                excludeCompleted: {
+                  type: 'boolean',
+                  description: '是否排除已完成的测试用例。默认为false（显示所有用例）。当用户要求继续测试、跳过已完成用例时，必须设置为true。设置为true后，返回的列表将只包含未完成的测试用例，方便继续测试工作。',
+                },
+              },
+              required: [],
+            },
+          },
+          {
+            name: 'get_test_detail',
+            description: '根据测试用例ID获取详细信息，包括测试步骤和AI测试提示语。如果配置了MODEL，会自动调用AI模型进行测试用例分析；如果未配置MODEL，则只返回测试用例详情。此工具仅用于静态代码分析，通过分析代码结构、逻辑、配置等来验证测试用例，不涉及实际交互操作。对于涉及用户交互、界面操作、实际运行验证的测试用例，需要提示用户手动完成测试验证。配置信息从环境变量读取（PLATFORM配置必需，MODEL配置可选）。',
+            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: [],
+            },
+          },
+          {
+            name: 'reset_test_progress',
+            description: '重置测试进度文件（test-progress.json），清空所有已完成的测试用例记录。',
+            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 if (name === 'reset_test_progress') {
+          return await this.handleResetTestProgress(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 platformConfig = getPlatformConfig();
+
+    // 加载进度
+    const progress = loadProgress();
+
+    // 构建目标API URL（使用默认的 API 基础 URL）
+    const apiBaseUrl = 'http://192.168.3.26:8081';
+    const targetUrl = `${apiBaseUrl}/functional/case/page`;
+    
+    const headers = {
+      'Csrf-token': platformConfig.csrfToken,
+      'organization': platformConfig.organization,
+      'project': platformConfig.project,
+      'x-auth-token': platformConfig.xAuthToken,
+    };
+
+    const requestData = {
+      current: 1,
+      pageSize: 500,
+      combineSearch: {
+        searchMode: 'AND',
+        conditions: [],
+      },
+      projectId: platformConfig.project,
+    };
+
+    
+    // 如果配置了 MODULE_IDS，添加到请求参数中
+    if (platformConfig.moduleIds && platformConfig.moduleIds.length > 0) {
+      requestData.moduleIds = platformConfig.moduleIds;
+    }
+
+    const response = await httpPost(targetUrl, headers, requestData);
+    console.log(response);
+    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);
+      });
+
+    // 更新已知用例ID集合（合并当前查询到的用例ID）
+    if (!progress.knownTestCaseIds) {
+      progress.knownTestCaseIds = [];
+    }
+    const currentTestCaseIds = processedTestCases.map(tc => tc.id);
+    // 合并去重：将当前查询到的用例ID添加到已知集合中
+    currentTestCaseIds.forEach(id => {
+      if (!progress.knownTestCaseIds.includes(id)) {
+        progress.knownTestCaseIds.push(id);
+      }
+    });
+    // 基于已知用例ID集合计算总数
+    progress.total = progress.knownTestCaseIds.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\n⚠️ **提示**：此工具仅用于静态代码分析，不涉及实际交互测试。对于涉及交互的测试用例，需要用户手动完成测试验证。`
+      : `\n（已完成: ${progress.completedCount}/${progress.total}）\n\n⚠️ **提示**：此工具仅用于静态代码分析，不涉及实际交互测试。对于涉及交互的测试用例，需要用户手动完成测试验证。\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 platformConfig = getPlatformConfig();
+
+    // 构建目标API URL（使用默认的 API 基础 URL）
+    const apiBaseUrl = 'http://192.168.3.26:8081';
+    const targetUrl = `${apiBaseUrl}/functional/case/detail/${testCaseId}`;
+    
+    const headers = {
+      'Csrf-token': platformConfig.csrfToken,
+      'organization': platformConfig.organization,
+      'project': platformConfig.project,
+      'x-auth-token': platformConfig.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模型进行分析（如果配置了MODEL）
+    let modelAnalysis = null;
+    try {
+      modelAnalysis = await analyzeWithModel(aiPrompt);
+      // 如果返回null，说明未配置MODEL，跳过AI分析
+      if (modelAnalysis === null) {
+        modelAnalysis = '';
+      }
+    } catch (error) {
+      console.error('AI模型分析失败:', error);
+      modelAnalysis = `\n\n⚠️ AI模型分析失败: ${error.message}`;
+    }
+
+    // 添加AI测试提示语前缀，强调静态代码分析
+    const fullPrompt = '**重要说明：此工具仅用于静态代码分析，通过分析代码结构、逻辑、配置等来验证测试用例，不涉及实际交互操作。**\n\n请根据下列提示语中的测试点、用例名称、测试类别、测试步骤、分析说明找到当前项目中对应的代码位置，进行静态代码检查：\n- 检查代码逻辑是否正确实现\n- 检查配置参数是否正确设置\n- 检查接口调用是否符合预期\n- 检查数据结构是否正确\n\n**对于涉及用户交互、界面操作、实际运行验证的测试步骤，请明确提示用户需要手动完成测试验证。**\n\n' + aiPrompt;
+
+    let resultText = `## 测试用例详情\n\n` +
+                      `**用例ID**: ${testCaseId}${completedInfo}` +
+                      `## ⚠️ 重要提示\n\n**此工具仅用于静态代码分析**，通过分析代码结构、逻辑、配置等来验证测试用例，不涉及实际交互操作。对于涉及用户交互、界面操作、实际运行验证的测试步骤，需要用户手动完成测试验证。\n\n` +
+                      `## 测试内容\n\n\`\`\`\n${fullPrompt}\n\`\`\`\n`;
+
+    // 只有当AI分析成功时才显示AI分析结果
+    if (modelAnalysis && modelAnalysis.trim() && !modelAnalysis.includes('AI模型分析失败')) {
+      resultText += `\n## AI分析结果\n\n\`\`\`\n${modelAnalysis}\n\`\`\`\n`;
+    } else if (!modelAnalysis || modelAnalysis === '') {
+      // 如果未配置MODEL，添加提示信息
+      resultText += `\n\n💡 **提示**：未配置MODEL相关环境变量，AI分析功能已禁用。如需启用AI分析，请在配置中设置 MODEL_BASE_URL、MODEL_API_KEY、MODEL_ID。`;
+    }
+
+    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();
+
+    // 确保 knownTestCaseIds 存在
+    if (!progress.knownTestCaseIds) {
+      progress.knownTestCaseIds = [];
+    }
+
+    const completedCount = progress.completedCount;
+    // 确保 total 至少等于 completedCount（避免出现负数）
+    // 如果 knownTestCaseIds 存在，使用它的长度；否则使用 completedCount
+    let total = progress.total;
+    if (progress.knownTestCaseIds && progress.knownTestCaseIds.length > 0) {
+      total = progress.knownTestCaseIds.length;
+    } else if (total < completedCount) {
+      // 如果 total 小于已完成数，说明数据不一致，使用已完成数作为总数
+      total = completedCount;
+    }
+
+    if (total === 0 && completedCount === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: '暂无测试进度记录。请先调用 get_test_list 获取测试用例列表。'
+          },
+        ],
+      };
+    }
+
+    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 handleResetTestProgress(args) {
+    const progressPath = getProgressFilePath();
+    const oldProgress = loadProgress();
+    
+    // 重置进度
+    const newProgress = resetProgress();
+    
+    const resetInfo = [
+      `✅ 测试进度文件已重置`,
+      ``,
+      `重置前状态:`,
+      `- 已完成用例数: ${oldProgress.completedCount}`,
+      `- 总用例数: ${oldProgress.total}`,
+      ``,
+      `重置后状态:`,
+      `- 已完成用例数: ${newProgress.completedCount}`,
+      `- 总用例数: ${newProgress.total}`,
+      ``,
+      `进度文件路径: ${progressPath}`
+    ].join('\n');
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: resetInfo
+        },
+      ],
+    };
+  }
+
+  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);