@booyaka/mcp-vet 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to `mcp-vet` are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres
+to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0]
+
+The robustness and precision release. Everything below is covered by the test suite.
+
+### Added
+
+- **Confidence scoring** (`high` / `medium` / `low`) on every finding, plus
+  `--min-confidence` to tune signal-to-noise. Capability findings are `high` only
+  when the key is *structurally* inside a `capabilities` object (AST-verified),
+  `medium` when merely near a `capabilities` mention. `initialize` is `high` only
+  in a registration / `switch` / `req.method ===` context, `low` as a bare string.
+- **SARIF 2.1.0 output** (`--sarif [file]`) for GitHub Advanced Security code
+  scanning, with per-rule metadata, levels, and line/column regions.
+- **Inline suppression**: `mcp-vet-disable-line`, `-next-line`, and `-file`
+  comments, with optional pattern-id lists and a suppressed-count summary.
+- **Rule selection & gating**: `--only`, `--disable`, and `--fail-on
+  breaking|any|none`.
+- **Config file** support (`.mcpvetrc.json` / `mcp-vet.config.json`) and a
+  `.mcpvetignore` file; CLI flags override config.
+- **Ignore globs** (`--ignore`, repeatable) and `--max-file-size`.
+- **Richer findings**: column / end-column, `docUrl`, and the source analyzer
+  (`ts-morph` / `python-ast` / `regex`) on every finding.
+- Distinct **exit code `2`** for operational errors (bad path, bad config,
+  invalid flag) — separate from `1` (findings tripped the gate).
+- `--color` / `--no-color` and `--quiet`.
+
+### Changed
+
+- Python scanning runs in a **chunked subprocess** so one unparseable file can't
+  sink the batch, with a **regex fallback** when no interpreter is present
+  (`--no-py-fallback` to require the AST path).
+- UTF-8 BOM and CRLF files are scanned with correct line numbers.
+- Findings are de-duplicated per `(line, column, rule)`.
+
+## [0.1.0]
+
+Initial release.
+
+- Detects the 7 patterns affected by the MCP `2026-07-28` specification: the
+  `Mcp-Session-Id` header, the `initialize` / `notifications/initialized`
+  handshake, the `-32002` error code, the legacy `tasks/get|update|cancel`
+  methods, and the deprecated `roots` / `sampling` / `logging` capabilities.
+- AST analysis for TypeScript / JavaScript (`ts-morph`) and Python (`ast`), a
+  shared rule engine, and four report formats (terminal, Markdown, JSON, GitHub
+  Actions annotations).
+
+[0.2.0]: https://github.com/Booyaka101/mcp-vet/releases/tag/v0.2.0
+[0.1.0]: https://github.com/Booyaka101/mcp-vet/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mcp-vet contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,265 @@
+# mcp-vet
+
+[![npm version](https://img.shields.io/npm/v/@booyaka/mcp-vet.svg)](https://www.npmjs.com/package/@booyaka/mcp-vet)
+[![CI](https://github.com/Booyaka101/mcp-vet/actions/workflows/ci.yml/badge.svg)](https://github.com/Booyaka101/mcp-vet/actions/workflows/ci.yml)
+[![node](https://img.shields.io/node/v/@booyaka/mcp-vet.svg)](https://nodejs.org)
+[![license: MIT](https://img.shields.io/npm/l/@booyaka/mcp-vet.svg)](./LICENSE)
+
+**On July 28, 2026 the Model Context Protocol ships its `2026-07-28` specification as final** — and it removes several things that today's MCP servers rely on. `mcp-vet` is a zero-config CLI that scans your MCP server source (TypeScript, JavaScript, and Python) for the exact patterns that will break client interop on that date, and tells you what to change.
+
+- Official release candidate: <https://blog.modelcontextprotocol.io/posts/2026-07-28-release-candidate/>
+- Protocol changelog: <https://tokenmix.ai/blog/mcp-updates-changelog-every-protocol-change-2026>
+
+```bash
+npx @booyaka/mcp-vet .
+```
+
+No account, no API key, no network calls — it parses your code locally (ts-morph for TS/JS, a bundled Python `ast` script for `.py`) and exits non-zero if it finds anything **BREAKING**, so you can drop it straight into CI.
+
+---
+
+## Real-world example
+
+Pointed at the [official MCP TypeScript SDK's own example servers](https://github.com/modelcontextprotocol/typescript-sdk/tree/main/examples), `mcp-vet` finds the patterns that the `2026-07-28` spec breaks:
+
+```text
+legacy-routing.ts:36:29  BREAKING   MCP_SESSION_ID [high]
+    const sid = req.headers['mcp-session-id'] as string | undefined;
+legacy-routing.ts:70:26  BREAKING   MCP_SESSION_ID [high]
+    exposedHeaders: ['Mcp-Session-Id', 'WWW-Authenticate', ...]
+sse-polling.ts:34:29     DEPRECATED LOGGING_CAP    [high]
+    capabilities: { logging: {} }
+sse-polling.ts:102:29    BREAKING   MCP_SESSION_ID [high]
+    const sid = req.headers['mcp-session-id'] as string | undefined;
+
+4 finding(s): 3 BREAKING, 1 DEPRECATED
+```
+
+And it stays quiet where it should — the `initialize` mentioned in a *comment* in `dual-era.ts`, and the `sampling/createMessage` **method** in `sampling.ts`, are not flagged, because only the `sampling` **capability declaration** is deprecated, not the method. That precision (structural AST checks, not text matching) is what keeps the noise down on a real codebase.
+
+---
+
+## What it detects
+
+### 🔴 BREAKING (fails the build — exit code 1)
+
+| ID | Pattern |
+| --- | --- |
+| `MCP_SESSION_ID` | `Mcp-Session-Id` header / `mcpSessionId` variable |
+| `INITIALIZE_HANDLER` | `initialize` / `notifications/initialized` handler registration |
+| `ERROR_CODE_32002` | the numeric error code `-32002` |
+| `TASKS_LEGACY` | `tasks/get` · `tasks/update` · `tasks/cancel` legacy method strings |
+
+### 🟡 DEPRECATED (warns only — exit code 0, 12-month grace period)
+
+| ID | Pattern |
+| --- | --- |
+| `ROOTS_CAP` | `roots` capability |
+| `SAMPLING_CAP` | `sampling` capability |
+| `LOGGING_CAP` | `logging` capability |
+
+### Confidence
+
+Every finding carries a **confidence** so you can tune signal-to-noise with `--min-confidence`:
+
+- **high** — exact/deterministic match (session id, `-32002`, tasks methods), a structurally-verified capability (the `roots`/`sampling`/`logging` key is really *inside* a `capabilities` object), or an `initialize` string used as a method name (handler registration, `switch` case, or `req.method === 'initialize'`).
+- **medium** — a `roots`/`sampling`/`logging` key/string within 5 lines of a `capabilities` mention but not structurally verified.
+- **low** — a bare `'initialize'` string with no registration context.
+
+---
+
+## Before / after for each BREAKING pattern
+
+### 1. `Mcp-Session-Id` — sessions are removed
+
+> *"The `Mcp-Session-Id` header and the protocol-level session that came with it are also removed."*
+
+```ts
+// ❌ before
+const sessionId = req.headers['Mcp-Session-Id'];
+res.setHeader('Mcp-Session-Id', sessionId);
+
+// ✅ after — no session header; client info & capabilities arrive in per-request _meta
+function handle(req) {
+  const meta = req.params?._meta ?? {};
+  // route on meta, not on a session id
+}
+```
+
+### 2. `initialize` / `notifications/initialized` — the handshake is removed
+
+> *"The `initialize`/`initialized` handshake is removed. The protocol version, client info, and client capabilities that used to be exchanged once at connection time now travel in `_meta` on every request."*
+
+```ts
+// ❌ before
+server.setRequestHandler('initialize', async (req) => ({ protocolVersion, capabilities }));
+server.setNotificationHandler('notifications/initialized', () => {});
+
+// ✅ after — read the handshake data from _meta on every request
+function handle(req) {
+  const { protocolVersion, clientInfo, capabilities } = req.params?._meta ?? {};
+}
+```
+
+### 3. Error code `-32002` → `-32602`
+
+> *"The error code for a missing resource changes from the MCP-custom `-32002` to the JSON-RPC standard `-32602` Invalid Params."*
+
+```ts
+// ❌ before
+return { error: { code: -32002, message: 'Resource not found' } };
+
+// ✅ after
+return { error: { code: -32602, message: 'Invalid params' } };
+```
+
+### 4. Legacy Tasks methods — redesigned to a handle-based lifecycle
+
+> *"A server can answer `tools/call` with a task handle, and the client drives it with `tasks/get`, `tasks/update`, and `tasks/cancel`. Anyone who shipped against the `2025-11-25` experimental Tasks API will need to migrate to the new lifecycle."*
+
+```ts
+// ❌ before — legacy experimental argument shapes
+switch (method) {
+  case 'tasks/get':    return getTask(id);
+  case 'tasks/update': return updateTask(id);
+  case 'tasks/cancel': return cancelTask(id);
+}
+
+// ✅ after — tools/call returns a task handle; the same method names now carry
+// the NEW argument shapes. mcp-vet flags every use for manual review against
+// the 2026-07-28 schema.
+```
+
+---
+
+## Usage
+
+```bash
+npx @booyaka/mcp-vet [paths...]        # scan directories and/or files (default: current directory)
+npx @booyaka/mcp-vet ./src ./packages  # multiple roots
+npx @booyaka/mcp-vet server.py         # a single file
+```
+
+Globs `**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}` and `**/*.py`, skipping `node_modules`, `.git`, `__pycache__`, `dist`, and `build`.
+
+### Options
+
+| Flag | Description |
+| --- | --- |
+| `--github-annotations` | emit GitHub Actions `::error` / `::warning` annotations to stdout |
+| `--sarif [file]` | write a SARIF 2.1.0 report (default `mcp-vet.sarif`) for GitHub code scanning |
+| `--out-dir <dir>` | where to write `mcp-vet-report.md` / `mcp-vet-results.json` (default: cwd) |
+| `--no-files` | don't write the markdown/json report files |
+| `--only <ids>` | only run these pattern ids (comma/space separated) |
+| `--disable <ids>` | skip these pattern ids |
+| `--fail-on <level>` | non-zero exit on `breaking` (default), `any`, or `none` |
+| `--min-confidence <level>` | report only findings at/above `high`, `medium`, or `low` (default) |
+| `--ignore <glob>` | ignore paths matching a gitignore-style glob (repeatable) |
+| `--max-file-size <kb>` | skip files larger than N KB (default 1536; `0` = no limit) |
+| `--no-py-fallback` | disable the regex fallback used when no Python interpreter is found |
+| `--config <path>` | path to a config file (see below) |
+| `--color` / `--no-color` | force or disable colored output |
+| `--quiet` | suppress the human-readable terminal report |
+| `-v, --version` | print version |
+
+### Suppressing findings inline
+
+Recognized in any comment style (`//` or `#`):
+
+```ts
+const x = -32002; // mcp-vet-disable-line ERROR_CODE_32002
+// mcp-vet-disable-next-line
+const y = 'Mcp-Session-Id';
+```
+
+- `mcp-vet-disable-line [IDS]` — suppress on the same line.
+- `mcp-vet-disable-next-line [IDS]` — suppress on the following line.
+- `mcp-vet-disable-file` — suppress the whole file.
+
+Omitting the pattern ids suppresses **all** rules on that line/file; listing ids (e.g. `ERROR_CODE_32002`) suppresses only those.
+
+### Config file
+
+Drop a `.mcpvetrc.json` (or `mcp-vet.config.json`) in your project root; CLI flags override it.
+
+```json
+{
+  "ignore": ["**/generated/**", "vendor/"],
+  "disable": ["LOGGING_CAP"],
+  "failOn": "breaking",
+  "minConfidence": "medium",
+  "maxFileSizeKb": 2048,
+  "pythonFallback": true
+}
+```
+
+You can also list ignore globs one-per-line in a `.mcpvetignore` file.
+
+### Outputs
+
+1. **Terminal** — compiler-style `file:line:col`, red for BREAKING, yellow for DEPRECATED, grouped by file, with before/after snippets and a `[confidence]` tag.
+2. **`mcp-vet-report.md`** — a Markdown table (File · Line · Pattern · Severity · Confidence · Explanation).
+3. **`mcp-vet-results.json`** — a structured JSON array of every finding (line, column, confidence, docUrl, before/after, source analyzer).
+4. **`--github-annotations`** — native GitHub Actions annotations that surface inline on the PR diff.
+5. **`--sarif`** — SARIF 2.1.0 for GitHub Advanced Security "code scanning" (uploads via `github/codeql-action/upload-sarif`).
+
+### Exit codes
+
+- `0` — clean, only DEPRECATED findings, or `--fail-on none`.
+- `1` — findings that trip `--fail-on` (BREAKING by default).
+- `2` — operational error (bad path, unreadable config, invalid flag/rule id).
+
+---
+
+## Use it in CI
+
+```yaml
+# .github/workflows/mcp-vet.yml
+name: mcp-vet
+on: [push, pull_request]
+jobs:
+  vet:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: '20' }
+      - run: npx @booyaka/mcp-vet . --github-annotations
+```
+
+`setup-node` runners already include Python 3, which `mcp-vet` uses to scan `.py` files. If no interpreter is found, it automatically falls back to a regex scanner (reduced precision) unless you pass `--no-py-fallback`; TypeScript/JavaScript scanning is unaffected either way.
+
+To upload results to GitHub code scanning instead:
+
+```yaml
+      - run: npx @booyaka/mcp-vet . --sarif mcp-vet.sarif --fail-on none
+      - uses: github/codeql-action/upload-sarif@v3
+        with: { sarif_file: mcp-vet.sarif }
+```
+
+---
+
+## How it works
+
+- **TypeScript / JavaScript** — parsed with [`ts-morph`](https://ts-morph.com); the analyzer walks the AST and emits normalized tokens (string literals, signed numeric literals, identifiers, object keys) annotated with structural capability context and registration context.
+- **Python** — a bundled script (`dist/python/mcp_ast_scan.py`) runs `ast.parse` + a context-tracking walk in a subprocess (chunked for large repos) and emits the same token shape. When no interpreter exists, a regex fallback covers the deterministic rules.
+- A single rule engine applies all 7 rules to those tokens, so TS and Python behave identically. Findings are de-duplicated per (line, column, rule) and can be suppressed inline.
+
+## Requirements
+
+- Node.js ≥ 18
+- Python 3 (optional — only needed for full-precision `.py` scanning; `python`, `py`, or `python3` on `PATH`)
+
+## Development
+
+```bash
+npm install      # installs deps and builds (via prepare)
+npm run build    # tsc -> dist/ + copies the Python script
+npm test         # builds, then runs the Node.js built-in test runner (18 tests)
+```
+
+Test fixtures live in `test/fixtures/` (dirty TS + Python servers, a `clean/` server with zero violations, `negatives/` true-negatives, a `confidence/` gradient, and `suppress/` cases).
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/cli.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const scanner_1 = require("./scanner");
+const ignore_1 = require("./ignore");
+const config_1 = require("./config");
+const types_1 = require("./types");
+const constants_1 = require("./constants");
+const reporters_1 = require("./reporters");
+const CONF_VALUES = ['high', 'medium', 'low'];
+const FAILON_VALUES = ['breaking', 'any', 'none'];
+function fail(msg) {
+    console.error(`mcp-vet: ${msg}`);
+    process.exit(2);
+}
+function parsePatternIds(raw) {
+    if (!raw)
+        return undefined;
+    const parts = raw
+        .toUpperCase()
+        .split(/[\s,]+/)
+        .filter(Boolean);
+    const ids = [];
+    for (const p of parts) {
+        if (!types_1.ALL_PATTERN_IDS.includes(p)) {
+            fail(`unknown pattern id "${p}". Valid ids: ${types_1.ALL_PATTERN_IDS.join(', ')}`);
+        }
+        ids.push(p);
+    }
+    return ids;
+}
+function readIgnoreFile(dir) {
+    const p = path.join(dir, '.mcpvetignore');
+    try {
+        return fs
+            .readFileSync(p, 'utf8')
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter((l) => l && !l.startsWith('#'));
+    }
+    catch {
+        return [];
+    }
+}
+const program = new commander_1.Command();
+program
+    .name('mcp-vet')
+    .description('Scan MCP server source code for patterns that break under the 2026-07-28 MCP spec release candidate.')
+    .argument('[paths...]', 'files or directories to scan', ['.'])
+    .option('--github-annotations', 'emit GitHub Actions ::error/::warning annotations to stdout')
+    .option('--sarif [file]', 'write a SARIF 2.1.0 report (default file: mcp-vet.sarif)')
+    .option('--out-dir <dir>', 'directory for mcp-vet-report.md and mcp-vet-results.json', process.cwd())
+    .option('--no-files', 'do not write the markdown/json report files')
+    .option('--only <ids>', 'only run these pattern ids (comma/space separated)')
+    .option('--disable <ids>', 'skip these pattern ids (comma/space separated)')
+    .option('--fail-on <level>', `exit non-zero on: ${FAILON_VALUES.join(' | ')}`, 'breaking')
+    .option('--min-confidence <level>', `report only findings at/above: ${CONF_VALUES.join(' | ')}`, 'low')
+    .option('--ignore <glob>', 'ignore paths matching glob (repeatable)', (v, acc) => {
+    acc.push(v);
+    return acc;
+}, [])
+    .option('--max-file-size <kb>', 'skip files larger than this many KB (0 = no limit)', '1536')
+    .option('--no-py-fallback', 'disable the regex fallback when no Python interpreter is found')
+    .option('--config <path>', 'path to a config file (.mcpvetrc.json)')
+    .option('--color', 'force colored output')
+    .option('--no-color', 'disable colored output')
+    .option('--quiet', 'suppress the human-readable terminal report')
+    .version((0, constants_1.getVersion)(), '-v, --version')
+    .showHelpAfterError();
+program.parse(process.argv);
+const opts = program.opts();
+const paths = program.args.length ? program.args : ['.'];
+// --- Resolve configuration (CLI over config file over defaults) ---
+let config = {};
+try {
+    config = (0, config_1.loadConfig)(process.cwd(), opts.config);
+}
+catch (err) {
+    if (err instanceof config_1.ConfigError)
+        fail(err.message);
+    throw err;
+}
+// Validate enums
+if (!FAILON_VALUES.includes(opts.failOn)) {
+    fail(`invalid --fail-on "${opts.failOn}". Valid: ${FAILON_VALUES.join(', ')}`);
+}
+if (!CONF_VALUES.includes(opts.minConfidence)) {
+    fail(`invalid --min-confidence "${opts.minConfidence}". Valid: ${CONF_VALUES.join(', ')}`);
+}
+// CLI value wins when explicitly set; otherwise fall back to the config file.
+const fromCli = (key) => program.getOptionValueSource(key) === 'cli';
+const failOn = fromCli('failOn')
+    ? opts.failOn
+    : config.failOn ?? opts.failOn;
+const minConfidence = fromCli('minConfidence')
+    ? opts.minConfidence
+    : config.minConfidence ?? opts.minConfidence;
+const normalizeIds = (ids) => ids
+    ?.map((s) => String(s).toUpperCase())
+    .filter((s) => types_1.ALL_PATTERN_IDS.includes(s));
+const cliOnly = parsePatternIds(opts.only);
+const cliDisable = parsePatternIds(opts.disable);
+const only = cliOnly ?? normalizeIds(config.only);
+const disable = cliDisable ?? normalizeIds(config.disable);
+let enabled = new Set(types_1.ALL_PATTERN_IDS);
+if (only && only.length)
+    enabled = new Set(only.filter((id) => types_1.ALL_PATTERN_IDS.includes(id)));
+else if (disable && disable.length) {
+    for (const id of disable)
+        enabled.delete(id);
+}
+if (enabled.size === 0)
+    fail('no rules enabled after applying --only/--disable.');
+const maxKbRaw = Number(opts.maxFileSize);
+if (!Number.isFinite(maxKbRaw) || maxKbRaw < 0)
+    fail(`invalid --max-file-size "${opts.maxFileSize}".`);
+const maxFileSizeKb = fromCli('maxFileSize')
+    ? maxKbRaw
+    : config.maxFileSizeKb != null
+        ? config.maxFileSizeKb
+        : maxKbRaw;
+const pythonFallback = fromCli('pyFallback')
+    ? opts.pyFallback
+    : config.pythonFallback != null
+        ? config.pythonFallback
+        : opts.pyFallback;
+const color = fromCli('color') ? opts.color : undefined;
+// Ignore patterns: config + CLI + .mcpvetignore in cwd and each root dir
+const ignorePatterns = new Set([...(config.ignore ?? []), ...opts.ignore]);
+for (const line of readIgnoreFile(process.cwd()))
+    ignorePatterns.add(line);
+for (const p of paths) {
+    try {
+        const abs = path.resolve(p);
+        if (fs.statSync(abs).isDirectory()) {
+            for (const line of readIgnoreFile(abs))
+                ignorePatterns.add(line);
+        }
+    }
+    catch {
+        /* validated later in scan() */
+    }
+}
+const ignore = new ignore_1.IgnoreMatcher([...ignorePatterns]);
+// --- Scan ---
+let result;
+try {
+    result = (0, scanner_1.scan)(paths, {
+        enabled,
+        ignore,
+        maxFileSizeKb,
+        pythonFallback,
+        minConfidence,
+    });
+}
+catch (err) {
+    if (err instanceof scanner_1.ScanError)
+        fail(err.message);
+    throw err;
+}
+// --- Report ---
+if (opts.githubAnnotations) {
+    (0, reporters_1.printGithubAnnotations)(result.findings);
+}
+if (!opts.quiet) {
+    (0, reporters_1.reportTerminal)(result, { color });
+}
+if (opts.sarif) {
+    const sarifPath = path.resolve(process.cwd(), typeof opts.sarif === 'string' ? opts.sarif : 'mcp-vet.sarif');
+    try {
+        (0, reporters_1.writeSarif)(result, sarifPath);
+        if (!opts.quiet)
+            console.log(`Wrote ${sarifPath}`);
+    }
+    catch (err) {
+        console.error(`mcp-vet: failed to write SARIF: ${err.message}`);
+    }
+}
+if (opts.files) {
+    try {
+        const md = (0, reporters_1.writeMarkdown)(result, opts.outDir);
+        const json = (0, reporters_1.writeJson)(result, opts.outDir);
+        if (!opts.quiet) {
+            console.log(`Wrote ${md}`);
+            console.log(`Wrote ${json}`);
+        }
+    }
+    catch (err) {
+        console.error(`mcp-vet: failed to write report files: ${err.message}`);
+    }
+}
+// --- Exit code ---
+const hasBreaking = result.findings.some((f) => f.severity === 'BREAKING');
+const hasAny = result.findings.length > 0;
+let failing = false;
+if (failOn === 'breaking')
+    failing = hasBreaking;
+else if (failOn === 'any')
+    failing = hasAny;
+else
+    failing = false; // 'none'
+process.exit(failing ? 1 : 0);

package/dist/config.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigError = void 0;
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const CONFIG_NAMES = ['.mcpvetrc.json', 'mcp-vet.config.json'];
+class ConfigError extends Error {
+}
+exports.ConfigError = ConfigError;
+/**
+ * Load config. If `explicitPath` is given it must exist and parse (throws
+ * ConfigError otherwise). Otherwise the first known config file found in `cwd`
+ * is used; missing config is not an error.
+ */
+function loadConfig(cwd, explicitPath) {
+    let file;
+    if (explicitPath) {
+        file = path.resolve(cwd, explicitPath);
+        if (!fs.existsSync(file)) {
+            throw new ConfigError(`config file not found: ${explicitPath}`);
+        }
+    }
+    else {
+        for (const name of CONFIG_NAMES) {
+            const candidate = path.join(cwd, name);
+            if (fs.existsSync(candidate)) {
+                file = candidate;
+                break;
+            }
+        }
+    }
+    if (!file)
+        return {};
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch (err) {
+        throw new ConfigError(`failed to parse ${file}: ${err.message}`);
+    }
+    if (typeof raw !== 'object' || raw === null) {
+        throw new ConfigError(`config must be a JSON object: ${file}`);
+    }
+    return raw;
+}