api-tests-coverage 1.0.0

package/dist/src/lib/index.js

@@ -0,0 +1,486 @@
+"use strict";
+/**
+ * api-test-coverage-analyzer – Public Library API
+ *
+ * Import individual analyze* functions in your own scripts:
+ *
+ *   const { analyzeEndpoints } = require('api-test-coverage-analyzer');
+ *   const results = await analyzeEndpoints({ spec: 'openapi.yaml', tests: 'tests/**\/*.ts' });
+ */
+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.printCiSummary = exports.generatePrComment = exports.writeStepSummary = exports.generateStepSummary = exports.evaluateQualityGate = exports.checkThresholds = exports.parseFormats = exports.generatePrSummary = exports.generateBuildSummary = exports.renderRiskPrioritizationMd = exports.renderMissingTestsMd = exports.renderCoverageIntelligenceMd = exports.writeIntelligenceReports = exports.buildRecommendationFromFinding = exports.runLinkageEngine = exports.scoreToPriority = exports.scoreToRiskBand = exports.computeRiskScore = exports.runIntelligenceEngine = exports.recordIntelligenceMetrics = exports.recordSecurityScanMetrics = exports.normalizeZapOutput = exports.normalizeTrivyOutput = exports.normalizeSemgrepOutput = exports.evaluateSecurityGate = exports.generateSecurityScanReports = exports.buildSecurityScanSummary = exports.runSecurityScan = void 0;
+exports.analyzeEndpoints = analyzeEndpoints;
+exports.analyzeParameters = analyzeParameters;
+exports.analyzeBusinessRules = analyzeBusinessRules;
+exports.analyzeIntegrationFlows = analyzeIntegrationFlows;
+exports.analyzeErrorHandling = analyzeErrorHandling;
+exports.analyzeSecurityControls = analyzeSecurityControls;
+exports.analyzePerfResilience = analyzePerfResilience;
+exports.runSecurityAnalysis = runSecurityAnalysis;
+exports.analyzeCompatibility = analyzeCompatibility;
+exports.runAnalysisAndEnforceQualityGate = runAnalysisAndEnforceQualityGate;
+var index_1 = require("../security/index");
+Object.defineProperty(exports, "runSecurityScan", { enumerable: true, get: function () { return index_1.runSecurityScan; } });
+Object.defineProperty(exports, "buildSecurityScanSummary", { enumerable: true, get: function () { return index_1.buildSecurityScanSummary; } });
+Object.defineProperty(exports, "generateSecurityScanReports", { enumerable: true, get: function () { return index_1.generateSecurityScanReports; } });
+Object.defineProperty(exports, "evaluateSecurityGate", { enumerable: true, get: function () { return index_1.evaluateSecurityGate; } });
+Object.defineProperty(exports, "normalizeSemgrepOutput", { enumerable: true, get: function () { return index_1.normalizeSemgrepOutput; } });
+Object.defineProperty(exports, "normalizeTrivyOutput", { enumerable: true, get: function () { return index_1.normalizeTrivyOutput; } });
+Object.defineProperty(exports, "normalizeZapOutput", { enumerable: true, get: function () { return index_1.normalizeZapOutput; } });
+var observability_1 = require("../observability");
+Object.defineProperty(exports, "recordSecurityScanMetrics", { enumerable: true, get: function () { return observability_1.recordSecurityScanMetrics; } });
+Object.defineProperty(exports, "recordIntelligenceMetrics", { enumerable: true, get: function () { return observability_1.recordIntelligenceMetrics; } });
+var index_2 = require("../intelligence/index");
+Object.defineProperty(exports, "runIntelligenceEngine", { enumerable: true, get: function () { return index_2.runIntelligenceEngine; } });
+Object.defineProperty(exports, "computeRiskScore", { enumerable: true, get: function () { return index_2.computeRiskScore; } });
+Object.defineProperty(exports, "scoreToRiskBand", { enumerable: true, get: function () { return index_2.scoreToRiskBand; } });
+Object.defineProperty(exports, "scoreToPriority", { enumerable: true, get: function () { return index_2.scoreToPriority; } });
+Object.defineProperty(exports, "runLinkageEngine", { enumerable: true, get: function () { return index_2.runLinkageEngine; } });
+Object.defineProperty(exports, "buildRecommendationFromFinding", { enumerable: true, get: function () { return index_2.buildRecommendationFromFinding; } });
+Object.defineProperty(exports, "writeIntelligenceReports", { enumerable: true, get: function () { return index_2.writeIntelligenceReports; } });
+Object.defineProperty(exports, "renderCoverageIntelligenceMd", { enumerable: true, get: function () { return index_2.renderCoverageIntelligenceMd; } });
+Object.defineProperty(exports, "renderMissingTestsMd", { enumerable: true, get: function () { return index_2.renderMissingTestsMd; } });
+Object.defineProperty(exports, "renderRiskPrioritizationMd", { enumerable: true, get: function () { return index_2.renderRiskPrioritizationMd; } });
+// Re-export summary engine
+var index_3 = require("../summary/index");
+Object.defineProperty(exports, "generateBuildSummary", { enumerable: true, get: function () { return index_3.generateBuildSummary; } });
+Object.defineProperty(exports, "generatePrSummary", { enumerable: true, get: function () { return index_3.generatePrSummary; } });
+const path = __importStar(require("path"));
+const index_4 = require("../security/index");
+const endpointCoverage_1 = require("../endpointCoverage");
+const parameterCoverage_1 = require("../parameterCoverage");
+const businessCoverage_1 = require("../businessCoverage");
+const integrationCoverage_1 = require("../integrationCoverage");
+const errorCoverage_1 = require("../errorCoverage");
+const securityCoverage_1 = require("../securityCoverage");
+const perfResilienceCoverage_1 = require("../perfResilienceCoverage");
+const compatibilityCoverage_1 = require("../compatibilityCoverage");
+const reporting_1 = require("../reporting");
+Object.defineProperty(exports, "parseFormats", { enumerable: true, get: function () { return reporting_1.parseFormats; } });
+Object.defineProperty(exports, "checkThresholds", { enumerable: true, get: function () { return reporting_1.checkThresholds; } });
+const languageDetection_1 = require("../languageDetection");
+const qualityGate_1 = require("../qualityGate");
+Object.defineProperty(exports, "evaluateQualityGate", { enumerable: true, get: function () { return qualityGate_1.evaluateQualityGate; } });
+const publishing_1 = require("../publishing");
+const buildSummary_1 = require("../buildSummary");
+Object.defineProperty(exports, "generateStepSummary", { enumerable: true, get: function () { return buildSummary_1.generateStepSummary; } });
+Object.defineProperty(exports, "writeStepSummary", { enumerable: true, get: function () { return buildSummary_1.writeStepSummary; } });
+Object.defineProperty(exports, "generatePrComment", { enumerable: true, get: function () { return buildSummary_1.generatePrComment; } });
+Object.defineProperty(exports, "printCiSummary", { enumerable: true, get: function () { return buildSummary_1.printCiSummary; } });
+const index_5 = require("../summary/index");
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function resolveTestsGlob(tests) {
+    return Array.isArray(tests) ? tests[0] : tests;
+}
+function resolveReportsDir(opts) {
+    var _a;
+    return path.resolve((_a = opts.reportsDir) !== null && _a !== void 0 ? _a : 'reports');
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Analyse which API endpoints are covered by integration tests.
+ *
+ * @example
+ * const { analyzeEndpoints } = require('api-test-coverage-analyzer');
+ * const result = await analyzeEndpoints({ spec: 'openapi.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzeEndpoints(options) {
+    var _a;
+    const specPath = path.resolve(options.spec);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const languages = options.language
+        ? (0, languageDetection_1.parseLanguageOption)(Array.isArray(options.language) ? options.language.join(',') : options.language)
+        : ['auto'];
+    const endpoints = await (0, endpointCoverage_1.parseOpenApiSpec)(specPath);
+    const coverageMap = await (0, endpointCoverage_1.analyzeTestCoverage)(endpoints, testsGlob, languages);
+    const report = (0, endpointCoverage_1.buildCoverageReport)(coverageMap);
+    (0, endpointCoverage_1.generateReports)(report, reportsDir);
+    const result = {
+        type: 'endpoint',
+        totalItems: report.total,
+        coveredItems: report.covered,
+        coveragePercent: report.percentage,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdEndpoint !== undefined && options.thresholdEndpoint > 0) {
+        thresholds['endpoint'] = options.thresholdEndpoint;
+    }
+    (0, reporting_1.generateMultiFormatReports)([result], formats, reportsDir, thresholds);
+    return result;
+}
+/**
+ * Analyse how thoroughly each API parameter is tested.
+ *
+ * @example
+ * const { analyzeParameters } = require('api-test-coverage-analyzer');
+ * const result = await analyzeParameters({ spec: 'openapi.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzeParameters(options) {
+    var _a;
+    const specPath = path.resolve(options.spec);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const parameters = await (0, parameterCoverage_1.parseParameters)(specPath);
+    const coverages = await (0, parameterCoverage_1.analyzeParameterCoverage)(parameters, testsGlob);
+    const report = (0, parameterCoverage_1.buildParameterCoverageReport)(coverages);
+    (0, parameterCoverage_1.generateParameterReports)(report, reportsDir);
+    const result = {
+        type: 'parameter',
+        totalItems: report.totalParameters,
+        coveredItems: coverages.filter((c) => c.ratio > 0).length,
+        coveragePercent: report.averageCoverage,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdParameter !== undefined && options.thresholdParameter > 0) {
+        thresholds['parameter'] = options.thresholdParameter;
+    }
+    (0, reporting_1.generateMultiFormatReports)([result], formats, reportsDir, thresholds);
+    return result;
+}
+/**
+ * Analyse how well tests cover defined business rules.
+ *
+ * @example
+ * const { analyzeBusinessRules } = require('api-test-coverage-analyzer');
+ * const result = await analyzeBusinessRules({ rules: 'business-rules.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzeBusinessRules(options) {
+    var _a;
+    const rulesPath = path.resolve(options.rules);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const rules = (0, businessCoverage_1.parseBusinessRules)(rulesPath);
+    const coverages = await (0, businessCoverage_1.analyzeBusinessCoverage)(rules, testsGlob);
+    const report = (0, businessCoverage_1.buildBusinessCoverageReport)(coverages);
+    (0, businessCoverage_1.generateBusinessReports)(report, reportsDir);
+    const result = {
+        type: 'business',
+        totalItems: report.total,
+        coveredItems: report.covered,
+        coveragePercent: report.percentage,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdBusiness !== undefined && options.thresholdBusiness > 0) {
+        thresholds['business'] = options.thresholdBusiness;
+    }
+    (0, reporting_1.generateMultiFormatReports)([result], formats, reportsDir, thresholds);
+    return result;
+}
+/**
+ * Analyse how well integration tests exercise defined end-to-end flows.
+ *
+ * @example
+ * const { analyzeIntegrationFlows } = require('api-test-coverage-analyzer');
+ * const result = await analyzeIntegrationFlows({ flows: 'integration-flows.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzeIntegrationFlows(options) {
+    var _a;
+    const flowsPath = path.resolve(options.flows);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const flows = (0, integrationCoverage_1.parseIntegrationFlows)(flowsPath);
+    const coverages = await (0, integrationCoverage_1.analyzeIntegrationCoverage)(flows, testsGlob);
+    const report = (0, integrationCoverage_1.buildIntegrationCoverageReport)(coverages);
+    (0, integrationCoverage_1.generateIntegrationReports)(report, reportsDir);
+    const result = {
+        type: 'integration',
+        totalItems: report.total,
+        coveredItems: report.complete,
+        coveragePercent: report.percentage,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdIntegration !== undefined && options.thresholdIntegration > 0) {
+        thresholds['integration'] = options.thresholdIntegration;
+    }
+    (0, reporting_1.generateMultiFormatReports)([result], formats, reportsDir, thresholds);
+    return result;
+}
+/**
+ * Analyse how thoroughly tests cover error handling and negative scenarios.
+ *
+ * @example
+ * const { analyzeErrorCoverage } = require('api-test-coverage-analyzer');
+ * const result = await analyzeErrorCoverage({ spec: 'openapi.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzeErrorHandling(options) {
+    var _a;
+    const specPath = path.resolve(options.spec);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const scenarios = await (0, errorCoverage_1.parseErrorScenarios)(specPath);
+    const coverages = await (0, errorCoverage_1.analyzeErrorCoverage)(scenarios, testsGlob);
+    const report = (0, errorCoverage_1.buildErrorCoverageReport)(coverages);
+    (0, errorCoverage_1.generateErrorReports)(report, reportsDir);
+    const result = {
+        type: 'error',
+        totalItems: report.total,
+        coveredItems: report.covered,
+        coveragePercent: report.percentage,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdError !== undefined && options.thresholdError > 0) {
+        thresholds['error'] = options.thresholdError;
+    }
+    (0, reporting_1.generateMultiFormatReports)([result], formats, reportsDir, thresholds);
+    return result;
+}
+/**
+ * Analyse how comprehensively tests cover security controls defined in the API spec.
+ *
+ * @example
+ * const { analyzeSecurityCoverage } = require('api-test-coverage-analyzer');
+ * const result = await analyzeSecurityCoverage({ spec: 'openapi-security.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzeSecurityControls(options) {
+    var _a;
+    const specPath = path.resolve(options.spec);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const scanReportPath = options.scanReport ? path.resolve(options.scanReport) : undefined;
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const controls = await (0, securityCoverage_1.parseSecurityControls)(specPath);
+    const coverages = await (0, securityCoverage_1.analyzeSecurityCoverage)(controls, testsGlob, scanReportPath);
+    const report = (0, securityCoverage_1.buildSecurityCoverageReport)(coverages, scanReportPath ? coverages.filter((c) => c.coveredByScanReport).length : 0);
+    (0, securityCoverage_1.generateSecurityReports)(report, reportsDir);
+    const result = {
+        type: 'security',
+        totalItems: report.total,
+        coveredItems: report.covered,
+        coveragePercent: report.percentage,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdSecurity !== undefined && options.thresholdSecurity > 0) {
+        thresholds['security'] = options.thresholdSecurity;
+    }
+    (0, reporting_1.generateMultiFormatReports)([result], formats, reportsDir, thresholds);
+    return result;
+}
+/**
+ * Analyse performance and resilience coverage.
+ *
+ * @example
+ * const { analyzePerfResilience } = require('api-test-coverage-analyzer');
+ * const results = await analyzePerfResilience({ spec: 'openapi.yaml', tests: 'tests/**\/*.ts' });
+ */
+async function analyzePerfResilience(options) {
+    var _a, _b, _c;
+    const specPath = path.resolve(options.spec);
+    const testsGlob = resolveTestsGlob(options.tests);
+    const reportsDir = resolveReportsDir(options);
+    const formats = (0, reporting_1.parseFormats)((_a = options.format) !== null && _a !== void 0 ? _a : 'json,html');
+    const perfThresholds = {
+        responseMs: (_b = options.thresholdResponseMs) !== null && _b !== void 0 ? _b : 500,
+        errorRate: (_c = options.thresholdErrorRate) !== null && _c !== void 0 ? _c : 0.05,
+    };
+    const endpoints = await (0, perfResilienceCoverage_1.parseEndpointsFromSpec)(specPath);
+    const loadResultPaths = options.loadResults
+        ? options.loadResults.split(',').map((p) => path.resolve(p.trim()))
+        : [];
+    const metricsMap = loadResultPaths.length > 0 ? (0, perfResilienceCoverage_1.parseLoadTestResults)(loadResultPaths) : new Map();
+    const performanceCoverages = (0, perfResilienceCoverage_1.analyzePerformanceCoverage)(endpoints, metricsMap, perfThresholds);
+    const scenarios = (0, perfResilienceCoverage_1.buildResilienceScenarios)(endpoints);
+    const resilienceCoverages = await (0, perfResilienceCoverage_1.analyzeResilienceCoverage)(scenarios, testsGlob);
+    const report = (0, perfResilienceCoverage_1.buildPerfResilienceReport)(performanceCoverages, resilienceCoverages);
+    (0, perfResilienceCoverage_1.generatePerfResilienceReports)(report, reportsDir);
+    const perfResult = {
+        type: 'performance',
+        totalItems: report.totalEndpoints,
+        coveredItems: report.endpointsWithLoadData,
+        coveragePercent: report.performanceCoveragePercent,
+        details: report,
+    };
+    const resilienceResult = {
+        type: 'resilience',
+        totalItems: report.totalResilienceScenarios,
+        coveredItems: report.coveredResilienceScenarios,
+        coveragePercent: report.resilienceCoveragePercent,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdPerformance !== undefined && options.thresholdPerformance > 0) {
+        thresholds['performance'] = options.thresholdPerformance;
+    }
+    if (options.thresholdResilience !== undefined && options.thresholdResilience > 0) {
+        thresholds['resilience'] = options.thresholdResilience;
+    }
+    (0, reporting_1.generateMultiFormatReports)([perfResult, resilienceResult], formats, reportsDir, thresholds);
+    return [perfResult, resilienceResult];
+}
+/**
+ * Run the integrated security scanning workflow.
+ * Executes configured scanners (Semgrep, Trivy, ZAP), normalizes findings,
+ * evaluates the security gate, and generates reports.
+ *
+ * @example
+ * const { runSecurityAnalysis } = require('api-test-coverage-analyzer');
+ * const summary = await runSecurityAnalysis({
+ *   config: {
+ *     enabled: true,
+ *     workspace: '.',
+ *     scanners: { trivy: { enabled: true, mode: 'import', reportPath: 'trivy.json' } },
+ *     gate: { failOnCritical: true, maxSecrets: 0 }
+ *   }
+ * });
+ */
+async function runSecurityAnalysis(options) {
+    var _a;
+    const reportsDir = path.resolve((_a = options.reportsDir) !== null && _a !== void 0 ? _a : 'reports');
+    return (0, index_4.runSecurityScan)(options.config, reportsDir);
+}
+/**
+ * Compare two API spec versions and verify consumer contracts.
+ *
+ * @example
+ * const { analyzeCompatibility } = require('api-test-coverage-analyzer');
+ * const results = await analyzeCompatibility({ oldSpec: 'v1.yaml', newSpec: 'v2.yaml' });
+ */
+async function analyzeCompatibility(options) {
+    const oldSpecPath = path.resolve(options.oldSpec);
+    const newSpecPath = path.resolve(options.newSpec);
+    const reportsDir = resolveReportsDir(options);
+    const oldApi = await (0, compatibilityCoverage_1.loadSpec)(oldSpecPath);
+    const newApi = await (0, compatibilityCoverage_1.loadSpec)(newSpecPath);
+    const changes = (0, compatibilityCoverage_1.compareSpecs)(oldApi, newApi);
+    const breakingChanges = changes.filter((c) => c.breaking);
+    const contracts = options.contracts ? await (0, compatibilityCoverage_1.parseContractFiles)(options.contracts) : [];
+    const verificationResults = (0, compatibilityCoverage_1.verifyContracts)(contracts, newApi);
+    const report = (0, compatibilityCoverage_1.buildCompatibilityReport)(oldApi, newApi, changes, verificationResults, oldSpecPath, newSpecPath);
+    (0, compatibilityCoverage_1.generateCompatibilityReports)(report, reportsDir);
+    const formats = (0, reporting_1.parseFormats)('json,html');
+    const uniqueAffectedEndpoints = new Set(breakingChanges.filter((c) => c.changeType !== 'added').map((c) => `${c.method}:${c.path}`)).size;
+    const endpointsUnaffectedByBreakingChanges = report.totalOldEndpoints - uniqueAffectedEndpoints;
+    const compatResult = {
+        type: 'compatibility',
+        totalItems: report.totalOldEndpoints,
+        coveredItems: endpointsUnaffectedByBreakingChanges,
+        coveragePercent: report.compatibilityPercent,
+        details: report,
+    };
+    const contractResult = {
+        type: 'contract-coverage',
+        totalItems: report.totalNewEndpoints,
+        coveredItems: report.contractCoveredEndpoints,
+        coveragePercent: report.contractCoveragePercent,
+        details: report,
+    };
+    const thresholds = {};
+    if (options.thresholdCompat !== undefined && options.thresholdCompat > 0) {
+        thresholds['compatibility'] = options.thresholdCompat;
+        thresholds['contract-coverage'] = options.thresholdCompat;
+    }
+    (0, reporting_1.generateMultiFormatReports)([compatResult, contractResult], formats, reportsDir, thresholds);
+    return [compatResult, contractResult];
+}
+/**
+ * Evaluate a quality gate against pre-computed coverage results, generate a
+ * publishable build bundle, write the GitHub Actions step summary (if requested),
+ * and return the exit code.
+ *
+ * This is the **canonical entry-point** for consuming teams. They should not
+ * need to implement any threshold comparison or exit-code logic themselves.
+ *
+ * @example
+ * const { runAnalysisAndEnforceQualityGate } = require('api-test-coverage-analyzer');
+ * const { qualityGate, exitCode } = await runAnalysisAndEnforceQualityGate({
+ *   results,
+ *   config: { thresholds: { global: 100 } },
+ * });
+ * process.exitCode = exitCode;
+ */
+async function runAnalysisAndEnforceQualityGate(options) {
+    var _a, _b, _c, _d, _e;
+    const { results, config, branch, reportsDir, writeGitHubSummary, pagesUrl } = options;
+    // 1. Evaluate quality gate
+    const gateConfig = {
+        thresholds: config.thresholds,
+        thresholdsByBranch: config.thresholdsByBranch,
+        qualityGate: config.qualityGate,
+    };
+    const qualityGate = (0, qualityGate_1.evaluateQualityGate)(results, gateConfig, branch);
+    // 2. Generate the publishable build bundle (always – even on failure)
+    let reports = null;
+    const publishingConfig = (_a = config.publishing) !== null && _a !== void 0 ? _a : {};
+    if (publishingConfig.enabled !== false) {
+        const thresholds = {
+            ...((_b = config.thresholds) !== null && _b !== void 0 ? _b : {}),
+        };
+        reports = (0, publishing_1.generateBuildBundle)(results, qualityGate, publishingConfig, thresholds);
+        // Copy report files into the bundle
+        if (reportsDir) {
+            const artifactsCfg = (_c = publishingConfig.artifacts) !== null && _c !== void 0 ? _c : {};
+            (0, publishing_1.copyReportFilesToBundle)(reportsDir, reports.bundleDir, reports.siteDir, artifactsCfg);
+        }
+    }
+    // 3. Print CI summary
+    (0, buildSummary_1.printCiSummary)(results, qualityGate);
+    // 4. Write GitHub Actions step summary if requested
+    if (writeGitHubSummary && reports) {
+        const summary = (0, buildSummary_1.generateStepSummary)(results, qualityGate, reports.metadata, pagesUrl);
+        (0, buildSummary_1.writeStepSummary)(summary);
+    }
+    // 5. Generate built-in summary files (always – even on failure)
+    const summaryConfig = config.summary;
+    const summaryEnabled = (summaryConfig === null || summaryConfig === void 0 ? void 0 : summaryConfig.enabled) !== false;
+    if (summaryEnabled && reportsDir) {
+        const thresholds = { ...((_d = config.thresholds) !== null && _d !== void 0 ? _d : {}) };
+        const summaryInput = {
+            results,
+            qualityGate,
+            thresholds,
+            summaryConfig,
+            branch,
+            pagesUrl,
+        };
+        await (0, index_5.generateBuildSummary)(summaryInput, reportsDir);
+        await (0, index_5.generatePrSummary)(summaryInput, reportsDir);
+    }
+    // 6. Compute exit code
+    const failBuild = ((_e = config.qualityGate) === null || _e === void 0 ? void 0 : _e.failBuildOnThresholdMiss) !== false;
+    const exitCode = failBuild && !qualityGate.passed ? 1 : 0;
+    return { reports, qualityGate, exitCode };
+}

package/dist/src/mcp/client/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * MCP integration – client.
+ *
+ * Manages transport connections, sends prompts, and returns raw MCP responses.
+ * Supports stdio (child-process) and HTTP transports.
+ *
+ * Security:
+ *  - Server URLs validated against allowlist before connection.
+ *  - Transports validated against allowlist.
+ *  - Payload size validated before sending.
+ *  - Secrets redacted from all outgoing payloads.
+ *  - Hard timeout enforced per request.
+ */
+import * as childProcess from 'child_process';
+import type { McpConfig, McpPromptRequest, McpRawResponse } from '../types';
+/** Spawn function type – injectable for testing */
+export type SpawnFn = typeof childProcess.spawn;
+export declare class McpClient {
+    private readonly globalConfig;
+    private readonly spawnFn;
+    /**
+     * @param globalConfig  MCP configuration block
+     * @param spawnFn       Optional spawn override (useful in unit tests to avoid
+     *                      spawning real child processes)
+     */
+    constructor(globalConfig: McpConfig, spawnFn?: SpawnFn);
+    /**
+     * Send a prompt to the named MCP server and return the raw response.
+     *
+     * @param serverName  Key in config.servers (e.g. "coverageSummary")
+     * @param request     Prompt request to send
+     */
+    send(serverName: string, request: McpPromptRequest): Promise<McpRawResponse>;
+    private sendHttp;
+    private sendStdio;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/mcp/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAY5E,mDAAmD;AACnD,MAAM,MAAM,OAAO,GAAG,OAAO,YAAY,CAAC,KAAK,CAAC;AAIhD,qBAAa,SAAS;IASlB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAR/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAU;IAElC;;;;OAIG;gBAEgB,YAAY,EAAE,SAAS,EACxC,OAAO,CAAC,EAAE,OAAO;IAKnB;;;;;OAKG;IACG,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,cAAc,CAAC;IAiDlF,OAAO,CAAC,QAAQ;IA6EhB,OAAO,CAAC,SAAS;CAwDlB"}