test-intel-mcp
This server turns JavaScript/TypeScript coverage artifacts and source files into practical test prioritization insights, all locally without sending code externally.
Analyze coverage reports (lcov, Istanbul JSON, Cobertura XML) to reveal uncovered files, functions, lines, and branches.
Find source functions that lack a corresponding test file, with configurable source/test directories and file extensions.
Score functions by cyclomatic complexity to identify which deserve testing attention first.
Suggest structured test cases (happy path, boundary, error, async, type) for specific functions.
Generate terminal/CI coverage reports via the
test-intel-reportcommand.Integrate with MCP clients (stdio or HTTP) and GitHub Actions for automated test-priority summaries.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@test-intel-mcp find untested functions in src and suggest test cases"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
test-intel-mcp
Turn JavaScript and TypeScript coverage artifacts into practical test priorities. The server reads local coverage and source files, identifies gaps, scores function complexity, and suggests focused test cases without sending code to an external service.
Tool page · npm · Listed in the official MCP Registry

Start in one minute
Add one local server entry to any stdio-compatible MCP client:
{
"mcpServers": {
"test-intel": {
"command": "npx",
"args": ["-y", "@barissozudogru/test-intel-mcp"]
}
}
}Then ask the client to inspect an existing coverage file:
Use test-intel to analyze coverage/lcov.info, identify the highest-impact gaps,
and suggest tests for the most complex uncovered function.No account, API key, or hosted service is required. File access is restricted to the directory where the server starts.
Related MCP server: Chisel
Proof on this repository
Running the complexity tool against the real src/paths.ts file produces:
Function complexity analysis for: src/paths.ts
Total functions analyzed: 1
Priority | Function | Line | Cyclomatic | Branches | Loops
---------|-----------------|------|------------|----------|------
low | deriveTestPaths | 11 | 3 | 1 | 1
Summary: 0 critical, 0 high, 0 medium, 1 low priorityThe same server reads lcov, Istanbul JSON, and Cobertura files to surface uncovered functions, lines, and branches.
A pinned p-limit 7.3.1 case study reproduces
coverage from the upstream project's 22 passing tests. test-intel-report
reduces its lcov artifact to two uncovered lines and one uncovered branch while
preserving the original coverage file for inspection.
If this saves you time, consider starring the repository. It helps other developers find it.
Tools
Tool | What it answers |
| Which files, functions, lines, and branches remain uncovered? |
| Which source functions have no corresponding test file? |
| Which functions deserve testing attention first? |
| Which happy path, boundary, error, async, and type cases should be reviewed? |
Supported coverage formats:
Format | Common producers |
lcov | Jest, Vitest, nyc, Istanbul |
Istanbul JSON | Jest, nyc, Istanbul |
Cobertura XML | Jest, pytest-cov, JaCoCo |
Heuristic source-to-test matching and complexity scores are prioritization signals. Native coverage data and human review remain the source of truth.
Coverage report command
The package also includes a non-MCP command for CI and terminal use:
npx -y -p @barissozudogru/test-intel-mcp test-intel-report coverage/lcov.infoAn explicit format can be supplied when the filename is ambiguous:
test-intel-report coverage/result.xml coberturaGitHub Action
Generate coverage with the project's own test runner, then pass the resulting artifact to the action:
name: Test priorities
on: [pull_request]
jobs:
test-intel:
runs-on: ubuntu-latest
permissions:
contents: read
steps:
- uses: actions/checkout@v4
- name: Run tests with coverage
run: npm ci && npm test -- --coverage
- uses: barissozudogru/test-intel-mcp@v0.8.1
with:
coverage-path: coverage/lcov.infoThe report is written to the workflow summary. The action analyzes an artifact that already exists and does not upload source or coverage data.
Client setup
Use the stdio configuration from the quickstart. Config file locations differ by client, but the server entry is the same:
{
"mcpServers": {
"test-intel": {
"command": "npx",
"args": ["-y", "@barissozudogru/test-intel-mcp"]
}
}
}Create .vscode/mcp.json:
{
"servers": {
"test-intel": {
"type": "stdio",
"command": "npx",
"args": ["-y", "@barissozudogru/test-intel-mcp"]
}
}
}Start the local endpoint:
npx @barissozudogru/test-intel-mcp --httpThe MCP endpoint is http://localhost:3000/mcp and the health endpoint is http://localhost:3000/health. Set PORT to use another port.
docker build -t test-intel-mcp .
docker run -p 3000:3000 -v "$(pwd):/project" -w /project test-intel-mcpConnect an HTTP client to http://localhost:3000/mcp.
Local development
npm install
npm test
npm run build
node dist/index.jsRequirements: Node.js 18 or newer.
See CONTRIBUTING.md for the development workflow.
Security and limits
Analysis runs locally and does not require network access.
Paths outside the server's starting directory are rejected.
Function discovery, source-to-test matching, and complexity scoring are heuristic.
A missing matching test filename does not prove a function is behaviorally untested.
License
Available Tools
4 toolsanalyze_test_coverageAnalyze Test CoverageA
Parse a coverage report (lcov, istanbul JSON, or cobertura XML) and return uncovered files, functions, lines, and branch gaps.
Inputs: coverage_path (required), format.
find_untested_functionsFind Untested FunctionsA
Scan source files for function/method declarations and identify those with no corresponding test file.
Inputs: source_dir (required), test_dir, extensions.
get_function_complexityGet Function ComplexityA
Analyze a file's functions for cyclomatic complexity to prioritize which functions need tests most urgently.
Inputs: file_path (required).
suggest_test_casesSuggest Test CasesA
Analyze a specific function and generate structured test case suggestions based on its logic, branches, and type signatures.
Inputs: file_path (required), function_name (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a distinct focus: generating test cases, parsing coverage reports, finding untested functions, and analyzing complexity. However, find_untested_functions and get_function_complexity both aim at identifying functions that need testing, which could cause some initial confusion.
All tool names follow a consistent snake_case verb_noun pattern, e.g., suggest_test_cases, analyze_test_coverage, find_untested_functions, get_function_complexity. This makes the toolset predictable and easy for an agent to navigate.
Four tools is well-scoped for a testing intelligence server, with each tool serving a clear and non-redundant purpose. There is no bloat, and the count feels sufficient for the stated domain.
The set covers a natural workflow of testing intelligence: generating tests, assessing coverage, identifying untested functions, and prioritizing via complexity. This is a solid read-only surface, though additional tools like listing existing test files or summarizing coverage trends could round it out further.
Maintenance
Related MCP Connectors
Repository knowledge graph MCP server for codebase understanding and debugging.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Official MCP server for Qase — manage test cases, runs, suites, defects via AI tools.
MCP server for understanding Javascript internals from ECMAScript specification.
Related MCP Servers
- AlicenseAqualityFmaintenanceMCP server for Codecov that provides tools to get commit coverage totals and prompts to suggest tests to write.16ISC
- AlicenseNot gradedqualityBmaintenanceMCP server for test impact analysis and code intelligence. Maps tests to code and git history to determine impacted tests, risk scores, and ownership for AI coding agents.8MIT
- FlicenseAqualityDmaintenanceMCP server for Java branch coverage analysis using JaCoCo. Enables agent-style coverage feedback with per-test-class granularity and uncovered line identification.2-
- AlicenseNot gradedqualityDmaintenanceMCP server that provides instant, token-efficient test coverage data for any programming language, allowing agents to query coverage summaries and track session progress.100 npm42MIT