api-tests-coverage 1.0.0

package/dist/src/endpointCoverage.d.ts

@@ -0,0 +1,70 @@
+import { SupportedLanguage } from './languageDetection';
+import type { DeepAnalysisConfig } from './coverage/deep-analysis/types';
+import type { ResolutionType, ConfidenceLevel } from './coverage/deep-analysis/types';
+import type { AstAnalysisConfig } from './config/types';
+export interface Endpoint {
+    method: string;
+    path: string;
+    /** Regex that matches concrete paths (e.g. /users/123 for /users/{id}) */
+    pathRegex: RegExp;
+}
+/**
+ * Metadata for a single match between a test call and an endpoint.
+ */
+export interface EndpointMatch {
+    /** How the endpoint was resolved */
+    resolutionType: ResolutionType;
+    /** Confidence level of the resolution */
+    confidence: ConfidenceLevel;
+    /** Whether the call was followed by a response assertion */
+    assertionLinked?: boolean;
+    /** The raw call text as seen in the source file */
+    rawCall?: string;
+}
+export interface EndpointCoverage extends Endpoint {
+    covered: boolean;
+    testFiles: string[];
+    /** Languages from which this endpoint is covered (populated when --language is used). */
+    languages?: string[];
+    /** Deep-analysis metadata for each match (populated when deep analysis is enabled). */
+    matches?: EndpointMatch[];
+}
+export interface CoverageReport {
+    total: number;
+    covered: number;
+    percentage: number;
+    endpoints: EndpointCoverage[];
+}
+/**
+ * Convert an OpenAPI path template (e.g. /users/{id}/orders) to a RegExp
+ * that matches concrete paths (e.g. /users/123/orders).
+ */
+export declare function pathToRegex(apiPath: string): RegExp;
+/**
+ * Parse an OpenAPI/Swagger spec file and return a flat list of endpoints.
+ */
+export declare function parseOpenApiSpec(specPath: string): Promise<Endpoint[]>;
+/**
+ * Analyse test files matching the given glob pattern and determine which
+ * endpoints from the spec are covered.
+ *
+ * When `languages` is supplied the appropriate language-specific HTTP-call
+ * extractor is used for each file (based on its extension when `languages`
+ * contains `'auto'`, or the first matching language otherwise).
+ *
+ * When `deepAnalysisConfig` is supplied (and enabled), the deep analysis
+ * layer is also run to catch indirect calls (constants, templates, wrappers, etc.).
+ */
+export declare function analyzeTestCoverage(endpoints: Endpoint[], testGlob: string, languages?: SupportedLanguage[], deepAnalysisConfig?: DeepAnalysisConfig, astAnalysisConfig?: AstAnalysisConfig): Promise<EndpointCoverage[]>;
+/**
+ * Build the coverage summary numbers from a coverage map.
+ */
+export declare function buildCoverageReport(coverageMap: EndpointCoverage[]): CoverageReport;
+/**
+ * Write JSON and HTML coverage reports to the given directory.
+ *
+ * The JSON report includes deep-analysis match metadata per endpoint.
+ * The HTML report shows resolution type and confidence badges.
+ */
+export declare function generateReports(report: CoverageReport, reportsDir: string): void;
+//# sourceMappingURL=endpointCoverage.d.ts.map

package/dist/src/endpointCoverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpointCoverage.d.ts","sourceRoot":"","sources":["../../src/endpointCoverage.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,iBAAiB,EAIlB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,cAAc,EAAE,cAAc,CAAC;IAC/B,yCAAyC;IACzC,UAAU,EAAE,eAAe,CAAC;IAC5B,4DAA4D;IAC5D,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,mDAAmD;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,QAAQ;IAChD,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,uFAAuF;IACvF,OAAO,CAAC,EAAE,aAAa,EAAE,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,gBAAgB,EAAE,CAAC;CAC/B;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAOnD;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAuB5E;AAwHD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,QAAQ,EAAE,EACrB,QAAQ,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,iBAAiB,EAAE,EAC/B,kBAAkB,CAAC,EAAE,kBAAkB,EACvC,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAgF7B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,gBAAgB,EAAE,GAAG,cAAc,CAKnF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CA+GhF"}

package/dist/src/endpointCoverage.js

@@ -0,0 +1,381 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToRegex = pathToRegex;
+exports.parseOpenApiSpec = parseOpenApiSpec;
+exports.analyzeTestCoverage = analyzeTestCoverage;
+exports.buildCoverageReport = buildCoverageReport;
+exports.generateReports = generateReports;
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const languageDetection_1 = require("./languageDetection");
+const types_1 = require("./coverage/deep-analysis/types");
+const astAnalysisOrchestrator_1 = require("./ast/astAnalysisOrchestrator");
+/**
+ * Convert an OpenAPI path template (e.g. /users/{id}/orders) to a RegExp
+ * that matches concrete paths (e.g. /users/123/orders).
+ */
+function pathToRegex(apiPath) {
+    // Split on parameter placeholders, escape each static segment, then rejoin
+    const pattern = apiPath
+        .split(/\{[^}]+\}/)
+        .map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+        .join('[^\\/]+');
+    return new RegExp(`^${pattern}$`);
+}
+/**
+ * Parse an OpenAPI/Swagger spec file and return a flat list of endpoints.
+ */
+async function parseOpenApiSpec(specPath) {
+    const api = await swagger_parser_1.default.dereference(specPath);
+    const endpoints = [];
+    const paths = api.paths;
+    if (!paths)
+        return endpoints;
+    const httpMethods = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'];
+    for (const [apiPath, pathItem] of Object.entries(paths)) {
+        if (!pathItem || typeof pathItem !== 'object')
+            continue;
+        for (const method of httpMethods) {
+            if (method in pathItem) {
+                endpoints.push({
+                    method: method.toUpperCase(),
+                    path: apiPath,
+                    pathRegex: pathToRegex(apiPath),
+                });
+            }
+        }
+    }
+    return endpoints;
+}
+/**
+ * Search a file's contents for HTTP calls matching any of the given endpoints.
+ * Returns an array of matched endpoint indices.
+ *
+ * When `language` is provided the appropriate language-specific extractor is
+ * used; otherwise the JavaScript/TypeScript extractor is used as a fallback.
+ */
+function findCoveredEndpoints(fileContents, endpoints, language) {
+    const covered = new Set();
+    // Choose extractor based on language hint
+    const httpCalls = language && language !== 'auto'
+        ? (0, languageDetection_1.extractHttpCalls)(fileContents, language)
+        : (0, languageDetection_1.extractHttpCallsFromJs)(fileContents);
+    for (const call of httpCalls) {
+        // Skip OpenAPI path templates that appear in comments/descriptions
+        if (call.path.includes('{'))
+            continue;
+        endpoints.forEach((endpoint, idx) => {
+            if (endpoint.method === call.method && endpoint.pathRegex.test(call.path)) {
+                covered.add(idx);
+            }
+        });
+    }
+    return covered;
+}
+/**
+ * Run deep analysis on a single file and return a set of endpoint indices
+ * that are covered along with their match metadata.
+ *
+ * Returns a Map of endpoint index → EndpointMatch[] (may be multiple matches).
+ */
+function findDeepCoveredEndpoints(fileContents, filePath, endpoints, language, deepConfig, astConfig) {
+    const deepMatches = new Map();
+    // Use the AST orchestrator as primary path (falls back to regex automatically)
+    const context = (0, astAnalysisOrchestrator_1.buildAnalysisContext)(astConfig, deepConfig);
+    const resolvedCalls = (0, astAnalysisOrchestrator_1.analyzeFile)(fileContents, filePath, language, context);
+    for (const resolved of resolvedCalls) {
+        // Try both the raw path and the normalized path against each endpoint
+        const pathsToTry = [resolved.path];
+        if (resolved.normalizedPath && resolved.normalizedPath !== resolved.path) {
+            pathsToTry.push(resolved.normalizedPath);
+        }
+        endpoints.forEach((endpoint, idx) => {
+            if (endpoint.method !== resolved.method)
+                return;
+            for (const candidatePath of pathsToTry) {
+                // Skip if it still contains unresolved placeholders that don't match templates
+                // Accept both concrete paths matching the regex and template paths matching the spec path
+                const matchesConcrete = !candidatePath.includes('{') && endpoint.pathRegex.test(candidatePath);
+                const matchesTemplate = candidatePath === endpoint.path;
+                // Also try matching normalized path patterns
+                const matchesNormalized = candidatePath.includes('{') && templatePathsMatch(candidatePath, endpoint.path);
+                if (matchesConcrete || matchesTemplate || matchesNormalized) {
+                    const match = {
+                        resolutionType: resolved.resolutionType,
+                        confidence: resolved.confidence,
+                        assertionLinked: resolved.assertionLinked,
+                        rawCall: resolved.rawCall,
+                    };
+                    const existing = deepMatches.get(idx);
+                    if (existing) {
+                        // Avoid duplicate resolution types for same endpoint
+                        const isDuplicate = existing.some((m) => m.resolutionType === match.resolutionType && m.confidence === match.confidence);
+                        if (!isDuplicate)
+                            existing.push(match);
+                    }
+                    else {
+                        deepMatches.set(idx, [match]);
+                    }
+                    break;
+                }
+            }
+        });
+    }
+    return deepMatches;
+}
+/**
+ * Compare two OpenAPI-style path templates for structural equivalence.
+ * e.g. /users/{id} matches /users/{userId}
+ */
+function templatePathsMatch(a, b) {
+    const partsA = a.split('/');
+    const partsB = b.split('/');
+    if (partsA.length !== partsB.length)
+        return false;
+    return partsA.every((seg, i) => {
+        const segB = partsB[i];
+        // Both are params → match
+        if (/^\{.+\}$/.test(seg) && /^\{.+\}$/.test(segB))
+            return true;
+        // One is param, other isn't
+        if (/^\{.+\}$/.test(seg) || /^\{.+\}$/.test(segB))
+            return false;
+        return seg === segB;
+    });
+}
+/**
+ * Analyse test files matching the given glob pattern and determine which
+ * endpoints from the spec are covered.
+ *
+ * When `languages` is supplied the appropriate language-specific HTTP-call
+ * extractor is used for each file (based on its extension when `languages`
+ * contains `'auto'`, or the first matching language otherwise).
+ *
+ * When `deepAnalysisConfig` is supplied (and enabled), the deep analysis
+ * layer is also run to catch indirect calls (constants, templates, wrappers, etc.).
+ */
+async function analyzeTestCoverage(endpoints, testGlob, languages, deepAnalysisConfig, astAnalysisConfig) {
+    var _a, _b;
+    const testFiles = await (0, fast_glob_1.default)(testGlob, { onlyFiles: true });
+    const coverageMap = endpoints.map((ep) => ({
+        ...ep,
+        covered: false,
+        testFiles: [],
+        languages: [],
+        matches: [],
+    }));
+    const deepConfig = deepAnalysisConfig !== null && deepAnalysisConfig !== void 0 ? deepAnalysisConfig : types_1.DEFAULT_DEEP_ANALYSIS_CONFIG;
+    for (const filePath of testFiles) {
+        const contents = fs.readFileSync(filePath, 'utf-8');
+        // Determine the language for this file
+        let lang;
+        if (languages && languages.length > 0 && !languages.includes('auto')) {
+            // Use the first explicitly provided language
+            lang = languages[0];
+        }
+        else {
+            // Auto-detect from extension
+            lang = (_a = (0, languageDetection_1.detectLanguageFromExtension)(filePath)) !== null && _a !== void 0 ? _a : undefined;
+        }
+        const fileLanguage = lang !== null && lang !== void 0 ? lang : 'javascript';
+        // ── Direct regex-based coverage detection ─────────────────────────────
+        const directCoveredIndices = findCoveredEndpoints(contents, endpoints, lang);
+        for (const idx of directCoveredIndices) {
+            coverageMap[idx].covered = true;
+            if (!coverageMap[idx].testFiles.includes(filePath)) {
+                coverageMap[idx].testFiles.push(filePath);
+            }
+            if (!coverageMap[idx].languages.includes(fileLanguage)) {
+                coverageMap[idx].languages.push(fileLanguage);
+            }
+            // Record as a direct match
+            const alreadyHasDirect = (_b = coverageMap[idx].matches) === null || _b === void 0 ? void 0 : _b.some((m) => m.resolutionType === 'direct');
+            if (!alreadyHasDirect) {
+                coverageMap[idx].matches.push({ resolutionType: 'direct', confidence: 'high' });
+            }
+        }
+        // ── Deep analysis coverage detection ──────────────────────────────────
+        if (deepConfig.enabled) {
+            const deepCovered = findDeepCoveredEndpoints(contents, filePath, endpoints, fileLanguage, deepConfig, astAnalysisConfig);
+            for (const [idx, matches] of deepCovered.entries()) {
+                // Skip if already covered by direct detection (don't downgrade)
+                coverageMap[idx].covered = true;
+                if (!coverageMap[idx].testFiles.includes(filePath)) {
+                    coverageMap[idx].testFiles.push(filePath);
+                }
+                if (!coverageMap[idx].languages.includes(fileLanguage)) {
+                    coverageMap[idx].languages.push(fileLanguage);
+                }
+                for (const match of matches) {
+                    // Don't add duplicate match entries
+                    const isDuplicate = coverageMap[idx].matches.some((m) => m.resolutionType === match.resolutionType && m.rawCall === match.rawCall);
+                    if (!isDuplicate) {
+                        coverageMap[idx].matches.push(match);
+                    }
+                }
+            }
+        }
+    }
+    return coverageMap;
+}
+/**
+ * Build the coverage summary numbers from a coverage map.
+ */
+function buildCoverageReport(coverageMap) {
+    const total = coverageMap.length;
+    const coveredCount = coverageMap.filter((ep) => ep.covered).length;
+    const percentage = total === 0 ? 0 : Math.round((coveredCount / total) * 10000) / 100;
+    return { total, covered: coveredCount, percentage, endpoints: coverageMap };
+}
+/**
+ * Write JSON and HTML coverage reports to the given directory.
+ *
+ * The JSON report includes deep-analysis match metadata per endpoint.
+ * The HTML report shows resolution type and confidence badges.
+ */
+function generateReports(report, reportsDir) {
+    if (!fs.existsSync(reportsDir)) {
+        fs.mkdirSync(reportsDir, { recursive: true });
+    }
+    // ── JSON report ──────────────────────────────────────────────────────────
+    const jsonPath = path.join(reportsDir, 'endpoint-coverage.json');
+    const jsonReport = {
+        total: report.total,
+        covered: report.covered,
+        percentage: report.percentage,
+        endpoints: report.endpoints.map(({ method, path: p, covered, testFiles, languages, matches }) => ({
+            method,
+            path: p,
+            covered,
+            testFiles,
+            ...(languages && languages.length > 0 ? { languages } : {}),
+            ...(matches && matches.length > 0 ? { matches } : {}),
+        })),
+    };
+    fs.writeFileSync(jsonPath, JSON.stringify(jsonReport, null, 2), 'utf-8');
+    // ── HTML report ──────────────────────────────────────────────────────────
+    const htmlPath = path.join(reportsDir, 'endpoint-coverage.html');
+    const rows = report.endpoints
+        .map(({ method, path: p, covered, testFiles, languages, matches }) => {
+        const rowClass = covered ? 'covered' : 'uncovered';
+        const status = covered ? '&#10003; Covered' : '&#10007; Not covered';
+        const files = testFiles.length > 0 ? testFiles.join('<br>') : '&mdash;';
+        const langs = languages && languages.length > 0 ? languages.join(', ') : '&mdash;';
+        // Resolution type + confidence badges
+        let matchBadges = '&mdash;';
+        if (matches && matches.length > 0) {
+            const uniqueTypes = [...new Set(matches.map((m) => m.resolutionType))];
+            matchBadges = uniqueTypes
+                .map((rt) => {
+                var _a;
+                const bestMatch = matches.find((m) => m.resolutionType === rt);
+                const conf = (_a = bestMatch === null || bestMatch === void 0 ? void 0 : bestMatch.confidence) !== null && _a !== void 0 ? _a : 'medium';
+                const assertLinked = (bestMatch === null || bestMatch === void 0 ? void 0 : bestMatch.assertionLinked) ? ' &#10003;' : '';
+                const confClass = conf === 'high' ? 'conf-high' : conf === 'medium' ? 'conf-medium' : 'conf-low';
+                return `<span class="badge badge-${rt}">${rt}</span> <span class="${confClass}">${conf}${assertLinked}</span>`;
+            })
+                .join(' ');
+        }
+        return `    <tr class="${rowClass}">
+      <td>${method}</td>
+      <td>${p}</td>
+      <td>${status}</td>
+      <td>${files}</td>
+      <td>${langs}</td>
+      <td>${matchBadges}</td>
+    </tr>`;
+    })
+        .join('\n');
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Endpoint Coverage Report</title>
+  <style>
+    body { font-family: sans-serif; padding: 2rem; }
+    h1 { margin-bottom: 0.5rem; }
+    .summary { margin-bottom: 1.5rem; font-size: 1.1rem; }
+    table { border-collapse: collapse; width: 100%; }
+    th, td { border: 1px solid #ccc; padding: 0.5rem 1rem; text-align: left; }
+    th { background: #f0f0f0; }
+    tr.covered { background: #e6ffe6; }
+    tr.uncovered { background: #ffe6e6; }
+    .badge { display: inline-block; padding: 0.1rem 0.4rem; border-radius: 3px;
+             font-size: 0.75rem; font-weight: 600; color: #fff;
+             background: #555; margin-right: 0.2rem; }
+    .badge-direct { background: #2a9d8f; }
+    .badge-constant { background: #457b9d; }
+    .badge-enum { background: #6a4c93; }
+    .badge-string-template { background: #e9c46a; color: #333; }
+    .badge-wrapper-method { background: #e76f51; }
+    .badge-request-builder { background: #264653; }
+    .badge-client-mapping { background: #c77dff; }
+    .badge-heuristic { background: #aaa; }
+    .conf-high { color: #2a9d8f; font-weight: 600; font-size: 0.8rem; }
+    .conf-medium { color: #e9c46a; font-weight: 600; font-size: 0.8rem; }
+    .conf-low { color: #e76f51; font-weight: 600; font-size: 0.8rem; }
+  </style>
+</head>
+<body>
+  <h1>Endpoint Coverage Report</h1>
+  <div class="summary">
+    Covered: <strong>${report.covered}/${report.total}</strong> endpoints
+    (<strong>${report.percentage}%</strong>)
+  </div>
+  <table>
+    <thead>
+      <tr>
+        <th>Method</th>
+        <th>Path</th>
+        <th>Status</th>
+        <th>Test Files</th>
+        <th>Languages</th>
+        <th>Resolution</th>
+      </tr>
+    </thead>
+    <tbody>
+${rows}
+    </tbody>
+  </table>
+</body>
+</html>`;
+    fs.writeFileSync(htmlPath, html, 'utf-8');
+}

package/dist/src/errorCoverage.d.ts

@@ -0,0 +1,93 @@
+import type { AstAnalysisConfig, DeepAnalysisCoverageConfig } from './config/types';
+export type ErrorCategory = 'missing-parameter' | 'invalid-value' | 'unauthorized' | 'forbidden' | 'not-found' | 'conflict' | 'server-error';
+export declare const ERROR_CATEGORIES: ErrorCategory[];
+export interface ErrorScenario {
+    /** Unique key, e.g. "POST /users:400" */
+    id: string;
+    endpoint: string;
+    method: string;
+    path: string;
+    statusCode: number;
+    description: string;
+    categories: ErrorCategory[];
+}
+export interface ErrorScenarioCoverage {
+    scenario: ErrorScenario;
+    covered: boolean;
+    /** Test description strings that matched this scenario */
+    matchedTests: string[];
+    /**
+     * AST metadata when coverage was informed by semantic analysis.
+     */
+    astMetadata?: {
+        sourceLanguage?: string;
+        resolutionType?: string;
+        confidence?: string;
+    };
+}
+/**
+ * Options to enable AST-augmented error coverage analysis.
+ */
+export interface AstErrorAnalysisOptions {
+    astConfig: AstAnalysisConfig;
+    deepConfig?: DeepAnalysisCoverageConfig;
+}
+export interface CategorySummary {
+    total: number;
+    covered: number;
+}
+export interface ErrorCoverageReport {
+    total: number;
+    covered: number;
+    percentage: number;
+    scenarios: ErrorScenarioCoverage[];
+    categorySummary: Record<ErrorCategory, CategorySummary>;
+}
+/**
+ * Map a HTTP status code (and optional description) to one or more error
+ * categories that are relevant for heuristic matching.
+ */
+export declare function statusCodeToCategories(statusCode: number, description: string): ErrorCategory[];
+/**
+ * Parse an OpenAPI 3 spec and return all non-2xx (error) response scenarios.
+ */
+export declare function parseErrorScenarios(specPath: string): Promise<ErrorScenario[]>;
+interface TestSegment {
+    description: string;
+    content: string;
+}
+/**
+ * Return true if the test segment appears to exercise the endpoint associated
+ * with the given error scenario.
+ *
+ * Detection strategy (in order):
+ *  1. Description contains "METHOD /pathBase" (e.g. "POST /users")
+ *  2. Description contains the path base
+ *  3. Content contains the path base AND the HTTP method as a string literal
+ */
+export declare function segmentMentionsEndpoint(segment: TestSegment, scenario: ErrorScenario): boolean;
+/**
+ * Return true when a segment's description or content hints that it is
+ * exercising the given error category.
+ */
+export declare function matchesCategoryHeuristic(segment: TestSegment, category: ErrorCategory): boolean;
+/**
+ * Decide whether a single test segment covers the given error scenario.
+ */
+export declare function segmentCoversScenario(segment: TestSegment, scenario: ErrorScenario): boolean;
+/**
+ * Scan test files matching testGlob and determine which error scenarios are
+ * covered. Optionally augments text-scan results with AST-derived semantic
+ * signals when `astOptions` is provided.
+ */
+export declare function analyzeErrorCoverage(scenarios: ErrorScenario[], testGlob: string, astOptions?: AstErrorAnalysisOptions): Promise<ErrorScenarioCoverage[]>;
+/**
+ * Aggregate error coverage results into a summary report.
+ */
+export declare function buildErrorCoverageReport(coverages: ErrorScenarioCoverage[]): ErrorCoverageReport;
+/**
+ * Write JSON and HTML error-coverage reports to reportsDir.
+ */
+export declare function generateErrorReports(report: ErrorCoverageReport, reportsDir: string): void;
+export {};
+//# sourceMappingURL=errorCoverage.d.ts.map

package/dist/src/errorCoverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorCoverage.d.ts","sourceRoot":"","sources":["../../src/errorCoverage.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAUpF,MAAM,MAAM,aAAa,GACrB,mBAAmB,GACnB,eAAe,GACf,cAAc,GACd,WAAW,GACX,WAAW,GACX,UAAU,GACV,cAAc,CAAC;AAEnB,eAAO,MAAM,gBAAgB,EAAE,aAAa,EAQ3C,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,aAAa,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;;OAEG;IACH,WAAW,CAAC,EAAE;QACZ,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,qBAAqB,EAAE,CAAC;IACnC,eAAe,EAAE,MAAM,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;CACzD;AAUD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,EAAE,CAkD/F;AAID;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CA2CpF;AAID,UAAU,WAAW;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAqB9F;AAID;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CA8G/F;AA2DD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,aAAa,GAAG,OAAO,CAe5F;AA8HD;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,aAAa,EAAE,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,uBAAuB,GACnC,OAAO,CAAC,qBAAqB,EAAE,CAAC,CA0ElC;AAID;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,qBAAqB,EAAE,GACjC,mBAAmB,CAsBrB;AAID;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAkH1F"}