Test Intel

io.github.barissozudogruPublished by GitHub account barissozudogruv0.8.1Updated Oct 24, 2026

Coverage analysis, untested function detection and complexity scoring for TS and JS.

VerifiedSTDIODesktop onlyDeveloper ToolsData & Analytics

Overview

AI-generated overview

Analyzes local JavaScript and TypeScript coverage artifacts to find untested functions, score complexity, and suggest test cases.

What you can do
Reads local coverage files in lcov, Istanbul JSON, and Cobertura formats and reports which files, functions, lines, and branches remain uncovered. Additional tools find source functions without a matching test file, rank functions by cyclomatic complexity, branches, and loops, and suggest happy path, boundary, error, async, and type test cases. A separate command-line report tool and a GitHub Action produce the same priorities for CI. All analysis runs locally.
When to use it
Useful when a JS or TS project already produces coverage output and you want help deciding which uncovered code deserves tests first. It fits local review sessions in an MCP client and CI runs that pass an existing coverage artifact. It is not a replacement for native coverage data or human review.
Requirements
Runs as a local stdio process via npx, so Node.js 18 or newer is required. No account, API key, or hosted service is needed, and no environment variables are declared. File access is limited to the directory where the server starts; an optional HTTP mode listens on localhost and honors PORT.
Before you install
Function discovery, source-to-test matching, and complexity scoring are heuristic, and a missing matching test filename does not prove a function is behaviorally untested. Analysis is local and does not require network access, and the GitHub Action analyzes an existing artifact without uploading source or coverage data.

Installation

In SourceWeft

  1. Open Test Intel in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

[test-intel-mcp]

[npm version] [npm downloads] [CI] [MCP Registry] [MIT license]

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

[test-intel-mcp analyzing real p-limit coverage]

Start in one minute

Add one local server entry to any stdio-compatible MCP client:

json
{  "mcpServers": {    "test-intel": {      "command": "npx",      "args": ["-y", "@barissozudogru/test-intel-mcp"]    }  }}

Then ask the client to inspect an existing coverage file:

text
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.

Proof on this repository

Running the complexity tool against the real src/paths.ts file produces:

text
Function complexity analysis for: src/paths.tsTotal functions analyzed: 1
Priority | Function        | Line | Cyclomatic | Branches | Loops---------|-----------------|------|------------|----------|------low      | deriveTestPaths | 11   | 3          | 1        | 1
Summary: 0 critical, 0 high, 0 medium, 1 low priority

The 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

ToolWhat it answers
analyze_test_coverageWhich files, functions, lines, and branches remain uncovered?
find_untested_functionsWhich source functions have no corresponding test file?
get_function_complexityWhich functions deserve testing attention first?
suggest_test_casesWhich happy path, boundary, error, async, and type cases should be reviewed?

Supported coverage formats:

FormatCommon producers
lcovJest, Vitest, nyc, Istanbul
Istanbul JSONJest, nyc, Istanbul
Cobertura XMLJest, 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:

bash
npx -y -p @barissozudogru/test-intel-mcp test-intel-report coverage/lcov.info

An explicit format can be supplied when the filename is ambiguous:

bash
test-intel-report coverage/result.xml cobertura

GitHub Action

Generate coverage with the project's own test runner, then pass the resulting artifact to the action:

yaml
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/[email protected]        with:          coverage-path: coverage/lcov.info

The 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

Claude Desktop, Cursor, Windsurf, Cline, and similar clients

Use the stdio configuration from the quickstart. Config file locations differ by client, but the server entry is the same:

json
{  "mcpServers": {    "test-intel": {      "command": "npx",      "args": ["-y", "@barissozudogru/test-intel-mcp"]    }  }}
VS Code with Copilot

Create .vscode/mcp.json:

json
{  "servers": {    "test-intel": {      "type": "stdio",      "command": "npx",      "args": ["-y", "@barissozudogru/test-intel-mcp"]    }  }}
Streamable HTTP

Start the local endpoint:

bash
npx @barissozudogru/test-intel-mcp --http

The MCP endpoint is http://localhost:3000/mcp and the health endpoint is http://localhost:3000/health. Set PORT to use another port.

Docker
bash
docker build -t test-intel-mcp .docker run -p 3000:3000 -v "$(pwd):/project" -w /project test-intel-mcp

Connect an HTTP client to http://localhost:3000/mcp.

Local development

bash
npm installnpm testnpm run buildnode dist/index.js

Requirements: 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

MIT

Source: README.md at commit 4e2364e

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v0.8.1LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts