Test Analyzer MCP Server

Instructions

Implementation Reference

• src/index.ts:300-342 (handler)

  The primary handler function that executes the 'get_test_summary' tool. Validates repoPath input, orchestrates test setup analysis and coverage checking, then generates and returns a comprehensive summary report.
  private async getTestSummary(args: any) { if (!args.repoPath || typeof args.repoPath !== 'string') { throw new McpError(ErrorCode.InvalidParams, 'repoPath is required'); } try { const repoPath = path.resolve(args.repoPath); // Get test setup analysis const setupResult = await this.analyzeTestSetup({ repoPath }); const setup = JSON.parse(setupResult.content[0].text); // Get coverage data const coverageResult = await this.checkCoverage({ repoPath, runTests: false }); const coverage = coverageResult.content[0].text.includes('No coverage data') ? null : JSON.parse(coverageResult.content[0].text); // Generate comprehensive summary const summary = this.generateComprehensiveSummary(setup, coverage); return { content: [ { type: 'text', text: summary, }, ], }; } catch (error) { if (error instanceof McpError) throw error; return { content: [ { type: 'text', text: `Error generating summary: ${error instanceof Error ? error.message : String(error)}`, }, ], isError: true, }; } }
• src/index.ts:155-170 (registration)

  The CallToolRequestSchema handler with switch statement that dispatches 'get_test_summary' calls to the getTestSummary method.
  this.server.setRequestHandler(CallToolRequestSchema, async (request) => { switch (request.params.name) { case 'analyze_test_setup': return await this.analyzeTestSetup(request.params.arguments); case 'check_coverage': return await this.checkCoverage(request.params.arguments); case 'get_test_summary': return await this.getTestSummary(request.params.arguments); default: throw new McpError( ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}` ); } }); }
• src/index.ts:138-151 (registration)

  Registers the 'get_test_summary' tool in the ListToolsRequestSchema response, providing name, description, and input schema.
  { name: 'get_test_summary', description: 'Get a comprehensive summary of the test setup, coverage, and recommendations', inputSchema: { type: 'object', properties: { repoPath: { type: 'string', description: 'Path to the repository', }, }, required: ['repoPath'], }, },
• src/index.ts:141-150 (schema)

  Input schema definition for the 'get_test_summary' tool, specifying a required 'repoPath' string parameter.
  inputSchema: { type: 'object', properties: { repoPath: { type: 'string', description: 'Path to the repository', }, }, required: ['repoPath'], },
• src/index.ts:342-688 (helper)

  Key helper function called by the handler to generate the final comprehensive markdown summary report with sections for setup, coverage, dependencies, and recommendations.
  } private async detectTestFramework(repoPath: string): Promise<TestFramework | null> { for (const framework of this.frameworks) { for (const configFile of framework.configFiles) { const configPath = path.join(repoPath, configFile); try { await fs.access(configPath); // Special check for Jest in package.json if (configFile === 'package.json' && framework.name === 'jest') { const packageJson = JSON.parse(await fs.readFile(configPath, 'utf-8')); if (packageJson.jest || (packageJson.scripts && Object.values(packageJson.scripts).some((script: any) => script.includes('jest')))) { return framework; } } else { return framework; } } catch { // Config file doesn't exist, continue checking } } } // Check package.json for test dependencies try { const packageJsonPath = path.join(repoPath, 'package.json'); const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8')); const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies }; for (const framework of this.frameworks) { if (allDeps[framework.name]) { return framework; } } } catch { // No package.json or error reading it } return null; } private async findTestFiles(repoPath: string, framework: TestFramework | null): Promise<string[]> { const patterns = framework?.testFilePatterns || [ '**/*.test.{js,jsx,ts,tsx}', '**/*.spec.{js,jsx,ts,tsx}', '**/__tests__/**/*.{js,jsx,ts,tsx}', ]; const testFiles: string[] = []; for (const pattern of patterns) { const files = await glob(pattern, { cwd: repoPath, absolute: true, ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/coverage/**'], }); testFiles.push(...files); } // Remove duplicates return [...new Set(testFiles)]; } private async analyzeTestStructure(testFiles: string[]): Promise<any> { let suites = 0; let tests = 0; const hooks = new Set<string>(); for (const file of testFiles) { try { const content = await fs.readFile(file, 'utf-8'); const ast = parser.parse(content, { sourceType: 'module', plugins: ['jsx', 'typescript'], }); traverse.default(ast, { CallExpression(path: any) { const callee = path.node.callee; if (callee.type === 'Identifier') { const name = callee.name; // Count test suites if (['describe', 'suite', 'context'].includes(name)) { suites++; } // Count individual tests if (['it', 'test', 'specify'].includes(name)) { tests++; } // Track hooks if (['beforeEach', 'afterEach', 'beforeAll', 'afterAll', 'before', 'after'].includes(name)) { hooks.add(name); } } }, }); } catch { // Error parsing file, skip it } } return { suites, tests, hooks: Array.from(hooks), }; } private async getCoverageConfig(repoPath: string, framework: TestFramework | null): Promise<any> { const configs: any = {}; // Check for NYC/Istanbul config const nycConfigFiles = ['.nycrc', '.nycrc.json', '.nycrc.yml', '.nycrc.yaml']; for (const configFile of nycConfigFiles) { try { const configPath = path.join(repoPath, configFile); const content = await fs.readFile(configPath, 'utf-8'); configs.nyc = JSON.parse(content); break; } catch { // Config doesn't exist or can't be parsed } } // Check package.json for coverage config try { const packageJsonPath = path.join(repoPath, 'package.json'); const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8')); if (packageJson.nyc) { configs.nyc = packageJson.nyc; } if (packageJson.jest?.collectCoverage !== undefined || packageJson.jest?.coverageDirectory) { configs.jest = packageJson.jest; } } catch { // No package.json or error reading it } // Check for framework-specific coverage config if (framework?.name === 'jest') { try { const jestConfigPath = path.join(repoPath, 'jest.config.js'); await fs.access(jestConfigPath); configs.jestConfigFile = true; } catch { // No jest.config.js } } return configs; } private async getTestDependencies(repoPath: string): Promise<string[]> { const testDeps: string[] = []; try { const packageJsonPath = path.join(repoPath, 'package.json'); const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8')); const devDeps = packageJson.devDependencies || {}; const testRelatedPackages = [ 'jest', 'vitest', 'mocha', 'chai', 'sinon', 'cypress', 'playwright', '@testing-library/react', '@testing-library/jest-dom', '@testing-library/user-event', 'enzyme', 'react-test-renderer', 'karma', 'jasmine', 'qunit', 'nyc', 'c8', 'istanbul', '@vitest/coverage-c8', '@vitest/coverage-istanbul', ]; for (const pkg of testRelatedPackages) { if (devDeps[pkg]) { testDeps.push(`${pkg}@${devDeps[pkg]}`); } } } catch { // Error reading package.json } return testDeps; } private async runTestsWithCoverage(repoPath: string): Promise<CoverageResult | null> { try { // Try common test coverage commands const commands = [ 'npm run test:coverage', 'npm run coverage', 'npm test -- --coverage', 'yarn test:coverage', 'yarn coverage', 'yarn test --coverage', 'npx jest --coverage', 'npx vitest run --coverage', ]; for (const cmd of commands) { try { const { stdout } = await execAsync(cmd, { cwd: repoPath }); // Try to parse coverage from output const coverage = this.parseCoverageFromOutput(stdout); if (coverage) { return coverage; } } catch { // Command failed, try next one } } return null; } catch { return null; } } private async readExistingCoverage(repoPath: string): Promise<CoverageResult | null> { // Common coverage output locations const coverageFiles = [ 'coverage/coverage-summary.json', 'coverage/lcov-report/index.html', 'coverage-final.json', '.nyc_output/processinfo/index.json', ]; for (const file of coverageFiles) { try { const coveragePath = path.join(repoPath, file); const content = await fs.readFile(coveragePath, 'utf-8'); if (file.endsWith('.json')) { const data = JSON.parse(content); // Parse coverage-summary.json format if (data.total) { return { lines: data.total.lines, statements: data.total.statements, functions: data.total.functions, branches: data.total.branches, summary: this.generateCoverageSummary(data.total), }; } } } catch { // File doesn't exist or can't be parsed } } return null; } private parseCoverageFromOutput(output: string): CoverageResult | null { // Try to parse coverage table from console output const lines = output.split('\n'); for (let i = 0; i < lines.length; i++) { const line = lines[i]; // Look for coverage summary patterns if (line.includes('Statements') && line.includes('%')) { try { // Parse Jest/Vitest style output const stmtMatch = line.match(/Statements\s*:\s*([\d.]+)%/); const branchMatch = lines[i + 1]?.match(/Branches\s*:\s*([\d.]+)%/); const funcMatch = lines[i + 2]?.match(/Functions\s*:\s*([\d.]+)%/); const lineMatch = lines[i + 3]?.match(/Lines\s*:\s*([\d.]+)%/); if (stmtMatch) { const result: CoverageResult = { statements: { percentage: parseFloat(stmtMatch[1]), covered: 0, total: 0 }, branches: { percentage: parseFloat(branchMatch?.[1] || '0'), covered: 0, total: 0 }, functions: { percentage: parseFloat(funcMatch?.[1] || '0'), covered: 0, total: 0 }, lines: { percentage: parseFloat(lineMatch?.[1] || '0'), covered: 0, total: 0 }, summary: '', }; result.summary = this.generateCoverageSummary(result); return result; } } catch { // Continue searching } } } return null; } private generateCoverageSummary(coverage: any): string { const getStatus = (percentage: number) => { if (percentage >= 80) return '✅ Good'; if (percentage >= 60) return '⚠️ Fair'; return '❌ Poor'; }; const lines = coverage.lines?.percentage || coverage.lines?.pct || 0; const statements = coverage.statements?.percentage || coverage.statements?.pct || 0; const functions = coverage.functions?.percentage || coverage.functions?.pct || 0; const branches = coverage.branches?.percentage || coverage.branches?.pct || 0; return `Coverage Summary: - Lines: ${lines.toFixed(1)}% ${getStatus(lines)} - Statements: ${statements.toFixed(1)}% ${getStatus(statements)} - Functions: ${functions.toFixed(1)}% ${getStatus(functions)} - Branches: ${branches.toFixed(1)}% ${getStatus(branches)} Overall: ${getStatus((lines + statements + functions + branches) / 4)}`; } private generateTestSetupSummary(data: any): string { const { framework, testFiles, testStructure, coverageConfig, dependencies } = data; let summary = `Test Setup Analysis:\n\n`; summary += `📦 Framework: ${framework || 'None detected'}\n`; summary += `📁 Test Files: ${testFiles.length} files found\n`; summary += `🧪 Tests: ${testStructure.tests} tests in ${testStructure.suites} suites\n`; if (testStructure.hooks.length > 0) { summary += `🔧 Hooks: ${testStructure.hooks.join(', ')}\n`; } if (Object.keys(coverageConfig).length > 0) { summary += `\n📊 Coverage Configuration:\n`; Object.keys(coverageConfig).forEach((key: string) => { summary += ` - ${key}: Configured\n`; }); } if (dependencies.length > 0) { summary += `\n📚 Test Dependencies:\n`; dependencies.slice(0, 10).forEach((dep: string) => { summary += ` - ${dep}\n`; }); if (dependencies.length > 10) { summary += ` ... and ${dependencies.length - 10} more\n`; } } return summary; } private generateComprehensiveSummary(setup: TestAnalysisResult, coverage: CoverageResult | null): string {