api-tests-coverage 1.0.0

package/dist/src/summary/prSummary.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Summary engine – PR comment summary generator.
+ *
+ * Generates concise PR comment markdown from analysis results.
+ * Uses the same gate-aware inclusion logic as generateBuildSummary
+ * but produces a shorter format suitable for PR comments.
+ *
+ * Public API:
+ *   generatePrSummary(input): Promise<SummaryResult>
+ */
+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.generatePrSummary = generatePrSummary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const markdownRenderer_1 = require("./markdownRenderer");
+const evaluateMetrics_1 = require("./evaluateMetrics");
+// ─── PR summary generator ─────────────────────────────────────────────────────
+/**
+ * Generate a concise PR comment summary from analysis results.
+ *
+ * The PR summary is shorter than the build summary – it shows the key status
+ * table and links to the full report, while still honouring gate-aware
+ * inclusion rules.
+ *
+ * @param input     All analysis results and configuration.
+ * @param outDir    Optional directory to write pr-summary.md to.
+ */
+async function generatePrSummary(input, outDir) {
+    var _a, _b, _c, _d, _e, _f;
+    const sections = buildPrSections(input);
+    const included = sections.filter((s) => s.included);
+    const lines = [];
+    const overallPassed = (_b = (_a = input.qualityGate) === null || _a === void 0 ? void 0 : _a.passed) !== null && _b !== void 0 ? _b : true;
+    const statusEmoji = overallPassed ? '✅' : '❌';
+    lines.push(`${statusEmoji} **API Coverage: ${overallPassed ? 'PASSED' : 'FAILED'}**`);
+    if (input.buildId)
+        lines.push(`Build \`${input.buildId}\``);
+    lines.push('');
+    // Compact coverage table — uses evaluated metrics for correct PASS/FAIL/N/A/SKIPPED
+    if (input.results.length > 0) {
+        const evaluatedMetrics = (0, evaluateMetrics_1.evaluateMetrics)(input.results, (_c = input.thresholds) !== null && _c !== void 0 ? _c : {}, input.qualityGate);
+        lines.push('| Category | Coverage | Status |');
+        lines.push('|---|---|---|');
+        for (const m of evaluatedMetrics) {
+            const coverageCell = m.applicable ? (0, markdownRenderer_1.pct)(m.coveragePercent) : '—';
+            lines.push(`| ${m.category} | ${coverageCell} | ${(0, markdownRenderer_1.metricStatusCell)(m.status)} |`);
+        }
+        lines.push('');
+    }
+    // Security scan summary row if present
+    if (input.securityScan) {
+        const gatePassed = (_d = input.securityScan.gateResult) === null || _d === void 0 ? void 0 : _d.passed;
+        const gateStatus = gatePassed === undefined ? '—' : gatePassed ? '✅ PASS' : '❌ FAIL';
+        lines.push(`**Security scan findings:** ${input.securityScan.totalFindings} total`);
+        lines.push(`**Security gate:** ${gateStatus}`);
+        lines.push('');
+    }
+    // Intelligence summary row if present
+    if (input.intelligenceSummary) {
+        const intel = input.intelligenceSummary;
+        const p0 = (_e = intel.recommendationsByPriority['P0']) !== null && _e !== void 0 ? _e : 0;
+        const p1 = (_f = intel.recommendationsByPriority['P1']) !== null && _f !== void 0 ? _f : 0;
+        const criticalFlag = p0 > 0 ? ' ⚠️' : '';
+        lines.push(`**Coverage Intelligence:**${criticalFlag} ${intel.totalFindings} finding(s), ${intel.totalRecommendations} recommendation(s) (P0: ${p0}, P1: ${p1})`);
+        lines.push(`**Max risk score:** ${intel.maxRiskScore} | **Critical uncovered:** ${intel.criticalUncoveredItems}`);
+        lines.push('');
+    }
+    // Failed gates detail
+    if (input.qualityGate && input.qualityGate.failures.length > 0) {
+        lines.push('**Failed gates:**');
+        for (const f of input.qualityGate.failures) {
+            lines.push(`- ${f.category}: ${(0, markdownRenderer_1.pct)(f.actual)} < ${(0, markdownRenderer_1.pct)(f.expected)} (gap: ${(0, markdownRenderer_1.pct)(f.gap)})`);
+        }
+        lines.push('');
+    }
+    if (input.pagesUrl) {
+        lines.push(`[📊 View full report](${input.pagesUrl})`);
+        lines.push('');
+    }
+    // Include per-section detail for included sections (collapsed)
+    const detailSections = included.filter((s) => s.gateEvaluated && s.passed === false);
+    if (detailSections.length > 0) {
+        lines.push('<details>');
+        lines.push('<summary>Failed gate details</summary>');
+        lines.push('');
+        for (const s of detailSections) {
+            lines.push(s.markdown);
+        }
+        lines.push('</details>');
+        lines.push('');
+    }
+    const markdown = lines.join('\n');
+    const aiMarkdown = (0, markdownRenderer_1.renderAiSummary)(input, sections);
+    const json = buildPrJsonSummary(input, sections);
+    if (outDir) {
+        await writePrOutputFiles(outDir, markdown, aiMarkdown, json);
+    }
+    return { markdown, sections, json };
+}
+// ─── Internals ────────────────────────────────────────────────────────────────
+function buildPrSections(input) {
+    var _a, _b, _c, _d, _e, _f;
+    const sections = [];
+    const thresholds = (_a = input.thresholds) !== null && _a !== void 0 ? _a : {};
+    const onlyEvaluated = (_c = (_b = input.summaryConfig) === null || _b === void 0 ? void 0 : _b.includeOnlyEvaluatedSections) !== null && _c !== void 0 ? _c : false;
+    for (const result of input.results) {
+        const threshold = thresholds[result.type];
+        const gateEvaluated = threshold !== undefined;
+        const failure = (_d = input.qualityGate) === null || _d === void 0 ? void 0 : _d.failures.find((f) => f.category === result.type);
+        const passed = gateEvaluated ? failure === undefined : undefined;
+        const included = onlyEvaluated ? gateEvaluated : true;
+        sections.push({
+            id: result.type,
+            title: (0, markdownRenderer_1.coverageTypeTitle)(result.type),
+            included,
+            gateEvaluated,
+            passed,
+            markdown: included
+                ? (0, markdownRenderer_1.renderCoverageSection)(result, threshold, failure !== undefined)
+                : '',
+        });
+    }
+    if (input.securityScan) {
+        const scannerResults = (_e = input.scannerResults) !== null && _e !== void 0 ? _e : [];
+        const gatePassed = (_f = input.securityScan.gateResult) === null || _f === void 0 ? void 0 : _f.passed;
+        const included = !onlyEvaluated || (input.securityScan.gateResult !== undefined);
+        sections.push({
+            id: 'security-scan',
+            title: 'Security Scanning',
+            included,
+            gateEvaluated: input.securityScan.gateResult !== undefined,
+            passed: gatePassed,
+            markdown: included
+                ? (0, markdownRenderer_1.renderSecurityScanSection)(input.securityScan, scannerResults, input.securityScan.gateResult !== undefined, gatePassed)
+                : '',
+        });
+    }
+    // Coverage Intelligence section
+    if (input.intelligenceSummary) {
+        sections.push({
+            id: 'coverage-intelligence',
+            title: 'Coverage Intelligence',
+            included: true,
+            gateEvaluated: false,
+            passed: undefined,
+            markdown: (0, markdownRenderer_1.renderIntelligenceSection)(input.intelligenceSummary),
+        });
+    }
+    return sections;
+}
+function buildPrJsonSummary(input, sections) {
+    var _a, _b, _c, _d;
+    return {
+        generatedAt: new Date().toISOString(),
+        type: 'pr-summary',
+        projectName: input.projectName,
+        branch: input.branch,
+        commitSha: input.commitSha,
+        buildId: input.buildId,
+        overallPassed: (_b = (_a = input.qualityGate) === null || _a === void 0 ? void 0 : _a.passed) !== null && _b !== void 0 ? _b : true,
+        coverage: input.results.map((r) => {
+            var _a, _b;
+            return ({
+                type: r.type,
+                coveragePercent: r.coveragePercent,
+                threshold: (_a = input.thresholds) === null || _a === void 0 ? void 0 : _a[r.type],
+                passed: !((_b = input.qualityGate) === null || _b === void 0 ? void 0 : _b.failures.some((f) => f.category === r.type)),
+            });
+        }),
+        failedGates: (_d = (_c = input.qualityGate) === null || _c === void 0 ? void 0 : _c.failures) !== null && _d !== void 0 ? _d : [],
+        sections: sections.map((s) => ({
+            id: s.id,
+            included: s.included,
+            gateEvaluated: s.gateEvaluated,
+            passed: s.passed,
+        })),
+        intelligence: input.intelligenceSummary
+            ? {
+                totalFindings: input.intelligenceSummary.totalFindings,
+                totalRecommendations: input.intelligenceSummary.totalRecommendations,
+                maxRiskScore: input.intelligenceSummary.maxRiskScore,
+                criticalUncoveredItems: input.intelligenceSummary.criticalUncoveredItems,
+                unprotectedSecurityFindings: input.intelligenceSummary.unprotectedSecurityFindings,
+                recommendationsByPriority: input.intelligenceSummary.recommendationsByPriority,
+            }
+            : undefined,
+    };
+}
+async function writePrOutputFiles(outDir, prMarkdown, aiMarkdown, json) {
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(path.join(outDir, 'pr-summary.md'), prMarkdown, 'utf-8');
+    // Also write ai-summary files if not already written by build summary
+    if (!fs.existsSync(path.join(outDir, 'ai-summary.md'))) {
+        fs.writeFileSync(path.join(outDir, 'ai-summary.md'), aiMarkdown, 'utf-8');
+    }
+    if (!fs.existsSync(path.join(outDir, 'summary.json'))) {
+        fs.writeFileSync(path.join(outDir, 'summary.json'), JSON.stringify(json, null, 2), 'utf-8');
+    }
+}

package/dist/src/summary/summaryTypes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared types for the metric evaluation model.
+ *
+ * MetricStatus encodes the four possible outcomes for a metric row:
+ *   PASS     – ran, has items, gate configured, threshold met
+ *   FAIL     – ran, has items, gate configured, threshold missed
+ *   N/A      – ran but totalItems === 0 (nothing to measure), OR no threshold
+ *   SKIPPED  – did not run at all (not present in coverage-summary.json)
+ *
+ * Critical invariant: totalItems === 0 → always N/A, never PASS.
+ * ⚠️ PASS does not exist anywhere in the codebase.
+ */
+export type MetricStatus = 'PASS' | 'FAIL' | 'SKIPPED' | 'N/A';
+export interface EvaluatedMetric {
+    /** Coverage type identifier, e.g. "endpoint", "error" */
+    category: string;
+    /** True when this type appeared in coverage-summary.json */
+    executed: boolean;
+    /** True when executed AND totalItems > 0 */
+    applicable: boolean;
+    totalItems: number;
+    coveredItems: number;
+    coveragePercent: number;
+    threshold: number | undefined;
+    /** True when a threshold is configured for this type */
+    gateEvaluated: boolean;
+    status: MetricStatus;
+    /** Human-readable explanation of the status */
+    reason: string;
+    /** Up to 5 uncovered item descriptions (for FAIL / low coverage) */
+    topGaps: string[];
+}
+/** Canonical ordered list of all built-in metric types. */
+export declare const KNOWN_METRIC_TYPES: string[];
+//# sourceMappingURL=summaryTypes.d.ts.map

package/dist/src/summary/summaryTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summaryTypes.d.ts","sourceRoot":"","sources":["../../../src/summary/summaryTypes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC;AAE/D,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,wDAAwD;IACxD,aAAa,EAAE,OAAO,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;IACrB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,2DAA2D;AAC3D,eAAO,MAAM,kBAAkB,EAAE,MAAM,EAUtC,CAAC"}

package/dist/src/summary/summaryTypes.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Shared types for the metric evaluation model.
+ *
+ * MetricStatus encodes the four possible outcomes for a metric row:
+ *   PASS     – ran, has items, gate configured, threshold met
+ *   FAIL     – ran, has items, gate configured, threshold missed
+ *   N/A      – ran but totalItems === 0 (nothing to measure), OR no threshold
+ *   SKIPPED  – did not run at all (not present in coverage-summary.json)
+ *
+ * Critical invariant: totalItems === 0 → always N/A, never PASS.
+ * ⚠️ PASS does not exist anywhere in the codebase.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_METRIC_TYPES = void 0;
+/** Canonical ordered list of all built-in metric types. */
+exports.KNOWN_METRIC_TYPES = [
+    'endpoint',
+    'parameter',
+    'business',
+    'integration',
+    'error',
+    'security',
+    'performance',
+    'resilience',
+    'compatibility',
+];

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "api-tests-coverage",
+  "version": "1.0.0",
+  "description": "CLI and library to measure how thoroughly your test suite exercises your API surface area",
+  "main": "dist/src/lib/index.js",
+  "types": "dist/src/lib/index.d.ts",
+  "bin": {
+    "api-tests-coverage": "./dist/src/index.js"
+  },
+  "files": [
+    "dist/src/",
+    "dist/action/",
+    "README.md",
+    "config.yaml.example"
+  ],
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "api",
+    "coverage",
+    "test",
+    "openapi",
+    "swagger",
+    "typescript",
+    "cli",
+    "github-action"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/skaliber/apiTestsCoverageAnalyzer.git"
+  },
+  "homepage": "https://github.com/skaliber/apiTestsCoverageAnalyzer#readme",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/src/index.js",
+    "test": "jest",
+    "coverage": "node scripts/run-coverage.js",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:check": "node scripts/docs-check.js && npm run docs:build",
+    "docs:test": "cypress run --config-file cypress.config.js",
+    "docs:test:open": "cypress open --config-file cypress.config.js",
+    "dashboard:test": "cypress run --config-file cypress.dashboard.config.js",
+    "dashboard:test:open": "cypress open --config-file cypress.dashboard.config.js"
+  },
+  "dependencies": {
+    "@actions/core": "^1.11.1",
+    "@actions/github": "^6.0.1",
+    "@apidevtools/swagger-parser": "^10.0.2",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
+    "@opentelemetry/sdk-node": "^0.213.0",
+    "@types/js-yaml": "^4.0.9",
+    "@typescript-eslint/typescript-estree": "^8.56.1",
+    "commander": "^11.0.0",
+    "fast-glob": "^3.3.3",
+    "globby": "^13.2.2",
+    "js-yaml": "^4.1.1",
+    "openapi-types": "^12.1.3",
+    "pino": "^10.3.1",
+    "prom-client": "^15.1.3",
+    "tree-sitter": "^0.25.0",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-python": "^0.25.0",
+    "tree-sitter-ruby": "^0.23.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.4.2",
+    "@types/pino": "^7.0.4",
+    "cypress": "^13.17.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.2.0",
+    "vitepress": "^1.6.4",
+    "wait-on": "^9.0.4"
+  }
+}