api-tests-coverage 1.0.0

package/dist/src/qualityGate.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesBranchPattern = matchesBranchPattern;
+exports.resolveThresholdsForBranch = resolveThresholdsForBranch;
+exports.effectiveThresholdForCategory = effectiveThresholdForCategory;
+exports.evaluateQualityGate = evaluateQualityGate;
+// ─── Branch matching ──────────────────────────────────────────────────────────
+/**
+ * Determine whether a branch name matches a glob-style pattern.
+ * Supports `*` (single segment) and `**` (any segments).
+ */
+function matchesBranchPattern(branchName, pattern) {
+    const regexStr = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '.+')
+        .replace(/\*/g, '[^/]+');
+    return new RegExp(`^${regexStr}$`).test(branchName);
+}
+/**
+ * Resolve the effective threshold map for the given branch, merging
+ * branch-aware overrides on top of the global threshold config.
+ */
+function resolveThresholdsForBranch(config, branchName) {
+    const baseThresholds = {};
+    // Start from the global thresholds config
+    if (config.thresholds) {
+        for (const [key, value] of Object.entries(config.thresholds)) {
+            if (value !== undefined) {
+                baseThresholds[key] = value;
+            }
+        }
+    }
+    // Apply branch-aware overrides if a branch is specified
+    if (branchName && config.thresholdsByBranch) {
+        for (const [pattern, overrides] of Object.entries(config.thresholdsByBranch)) {
+            if (matchesBranchPattern(branchName, pattern)) {
+                for (const [key, value] of Object.entries(overrides)) {
+                    if (value !== undefined) {
+                        baseThresholds[key] = value;
+                    }
+                }
+                break; // first matching pattern wins
+            }
+        }
+    }
+    return baseThresholds;
+}
+/**
+ * Compute the effective per-category threshold for a given category,
+ * using the 'global' key as the default when no category-specific value exists.
+ */
+function effectiveThresholdForCategory(thresholds, category) {
+    if (thresholds[category] !== undefined)
+        return thresholds[category];
+    if (thresholds['global'] !== undefined)
+        return thresholds['global'];
+    return undefined;
+}
+// ─── Core evaluation ──────────────────────────────────────────────────────────
+/**
+ * Evaluate all coverage results against configured thresholds.
+ *
+ * Default behaviour when no thresholds are configured: every category must
+ * reach 100% (spec requirement: "default threshold = 100%").
+ *
+ * @param results      Coverage results from one or more analysis passes.
+ * @param config       Quality-gate / threshold configuration.
+ * @param branchName   Current git branch name (used for branch-aware thresholds).
+ */
+function evaluateQualityGate(results, config, branchName) {
+    var _a, _b, _c;
+    const gateEnabled = ((_a = config.qualityGate) === null || _a === void 0 ? void 0 : _a.enabled) !== false; // default enabled
+    const mode = (_c = (_b = config.qualityGate) === null || _b === void 0 ? void 0 : _b.mode) !== null && _c !== void 0 ? _c : 'strict';
+    const resolvedThresholds = resolveThresholdsForBranch(config, branchName);
+    const actual = {};
+    for (const r of results) {
+        actual[r.type] = r.coveragePercent;
+    }
+    const failures = [];
+    if (gateEnabled) {
+        for (const result of results) {
+            const category = result.type;
+            let threshold;
+            if (Object.keys(resolvedThresholds).length > 0) {
+                const t = effectiveThresholdForCategory(resolvedThresholds, category);
+                if (t === undefined)
+                    continue; // no threshold for this category
+                threshold = t;
+            }
+            else {
+                // No threshold config at all → default to 100%
+                threshold = 100;
+            }
+            if (result.coveragePercent < threshold) {
+                failures.push({
+                    category,
+                    expected: threshold,
+                    actual: result.coveragePercent,
+                    gap: Number((threshold - result.coveragePercent).toFixed(2)),
+                });
+            }
+        }
+    }
+    // In "warn" mode we still compute failures but mark as passed
+    const passed = mode === 'warn' ? true : failures.length === 0;
+    // Determine the threshold representation for the result
+    const thresholdForResult = Object.keys(resolvedThresholds).length === 1 && resolvedThresholds['global'] !== undefined
+        ? resolvedThresholds['global']
+        : Object.keys(resolvedThresholds).length > 0
+            ? resolvedThresholds
+            : 100;
+    return {
+        passed,
+        threshold: thresholdForResult,
+        actual,
+        failures,
+    };
+}

package/dist/src/reporting.d.ts

@@ -0,0 +1,41 @@
+import type { ObservabilityInfo } from './observability';
+/**
+ * Standardized coverage result object produced by each coverage command.
+ * All analysis commands return one of these so the reporting module can
+ * handle them uniformly.
+ */
+export interface CoverageResult {
+    /** Identifies which analysis produced this result (e.g. "endpoint", "parameter", "business", "integration") */
+    type: string;
+    /** Total number of items analysed (endpoints, parameters, rules, flows…) */
+    totalItems: number;
+    /** Number of items that are considered covered */
+    coveredItems: number;
+    /** Coverage percentage (0‑100, two decimal places) */
+    coveragePercent: number;
+    /** Arbitrary per-type detail data serialisable to JSON */
+    details: unknown;
+}
+export type ReportFormat = 'json' | 'html' | 'csv' | 'junit';
+/**
+ * Parse a comma-separated format string (e.g. "json,html") into an array of
+ * validated `ReportFormat` values. Unknown tokens are silently ignored.
+ */
+export declare function parseFormats(raw: string): ReportFormat[];
+/**
+ * Write coverage reports in the requested formats to `reportsDir`.
+ * The directory is created if it does not exist.
+ *
+ * @param results       Array of standardised coverage results
+ * @param formats       Which output formats to generate
+ * @param reportsDir    Absolute path to the output directory
+ * @param thresholds    Optional per-type threshold percentages (used in HTML and JUnit outputs)
+ * @param observability Optional observability metadata embedded in JSON and HTML outputs
+ */
+export declare function generateMultiFormatReports(results: CoverageResult[], formats: ReportFormat[], reportsDir: string, thresholds?: Record<string, number>, observability?: ObservabilityInfo): void;
+/**
+ * Check whether any coverage result falls below its threshold.
+ * Returns an array of failure descriptions (empty means all pass).
+ */
+export declare function checkThresholds(results: CoverageResult[], thresholds: Record<string, number>): string[];
+//# sourceMappingURL=reporting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../src/reporting.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,+GAA+G;IAC/G,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;AAE7D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,EAAE,CAMxD;AAwND;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,cAAc,EAAE,EACzB,OAAO,EAAE,YAAY,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACvC,aAAa,CAAC,EAAE,iBAAiB,GAChC,IAAI,CAqBN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,cAAc,EAAE,EACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,MAAM,EAAE,CAYV"}

package/dist/src/reporting.js

@@ -0,0 +1,278 @@
+"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.parseFormats = parseFormats;
+exports.generateMultiFormatReports = generateMultiFormatReports;
+exports.checkThresholds = checkThresholds;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse a comma-separated format string (e.g. "json,html") into an array of
+ * validated `ReportFormat` values. Unknown tokens are silently ignored.
+ */
+function parseFormats(raw) {
+    const valid = ['json', 'html', 'csv', 'junit'];
+    return raw
+        .split(',')
+        .map((f) => f.trim().toLowerCase())
+        .filter((f) => valid.includes(f));
+}
+// ─── Report writers ───────────────────────────────────────────────────────────
+/** Write `reports/coverage-summary.json`, merging with any existing file so that
+ *  successive per-type runs accumulate a complete summary across all 8 metrics. */
+function writeJson(results, reportsDir, observability) {
+    var _a;
+    const outPath = path.join(reportsDir, 'coverage-summary.json');
+    // Load existing summary/details so that successive single-type runs accumulate
+    // all coverage types into one file rather than overwriting each other.
+    let existingSummary = [];
+    let existingDetails = {};
+    try {
+        if (fs.existsSync(outPath)) {
+            const existing = JSON.parse(fs.readFileSync(outPath, 'utf-8'));
+            if (Array.isArray(existing.summary)) {
+                existingSummary = existing.summary;
+            }
+            if (existing.details && typeof existing.details === 'object') {
+                existingDetails = existing.details;
+            }
+        }
+    }
+    catch {
+        // Corrupt file — start fresh
+    }
+    // New results replace any existing entry for the same type; others are kept.
+    const newTypes = new Set(results.map((r) => r.type));
+    const mergedSummary = [
+        ...existingSummary.filter((s) => !newTypes.has(s.type)),
+        ...results.map((r) => ({
+            type: r.type,
+            totalItems: r.totalItems,
+            coveredItems: r.coveredItems,
+            coveragePercent: r.coveragePercent,
+        })),
+    ];
+    const mergedDetails = {
+        ...existingDetails,
+        ...results.reduce((acc, r) => {
+            acc[r.type] = r.details;
+            return acc;
+        }, {}),
+    };
+    const payload = {
+        generatedAt: new Date().toISOString(),
+        summary: mergedSummary,
+        details: mergedDetails,
+    };
+    if (observability) {
+        payload.observability = {
+            metricsUrl: observability.metricsUrl,
+            note: observability.metricsUrl
+                ? `Prometheus metrics available at ${observability.metricsUrl}`
+                : 'Prometheus metrics export not enabled (use --metrics-port to enable)',
+            metricNames: observability.metricNames,
+            tracing: {
+                enabled: observability.tracingEnabled,
+                otlpEndpoint: observability.otlpEndpoint,
+                note: observability.tracingEnabled
+                    ? `Traces are exported to ${(_a = observability.otlpEndpoint) !== null && _a !== void 0 ? _a : 'in-memory (no OTLP endpoint configured)'}`
+                    : 'Tracing not enabled (use --trace to enable)',
+            },
+        };
+    }
+    fs.writeFileSync(outPath, JSON.stringify(payload, null, 2), 'utf-8');
+}
+/** Write `reports/coverage-summary.html` */
+function writeHtml(results, reportsDir, thresholds = {}, observability) {
+    const rows = results
+        .map((r) => {
+        var _a;
+        const threshold = (_a = thresholds[r.type]) !== null && _a !== void 0 ? _a : 0;
+        const belowThreshold = r.coveragePercent < threshold;
+        const rowClass = belowThreshold ? 'below' : r.coveragePercent >= 80 ? 'good' : 'warn';
+        const thresholdCell = threshold > 0
+            ? `<td class="${belowThreshold ? 'fail' : 'pass'}">${threshold}% ${belowThreshold ? '❌' : '✅'}</td>`
+            : '<td>—</td>';
+        return `    <tr class="${rowClass}">
+      <td>${r.type}</td>
+      <td>${r.coveredItems}/${r.totalItems}</td>
+      <td>${r.coveragePercent}%</td>
+      ${thresholdCell}
+    </tr>`;
+    })
+        .join('\n');
+    const observabilitySection = observability
+        ? `
+  <hr>
+  <h2>Observability</h2>
+  ${observability.metricsUrl
+            ? `<p>📊 Prometheus metrics available at <a href="${observability.metricsUrl}">${observability.metricsUrl}</a></p>
+  <p>Metric names (replace <code>&lt;type&gt;</code> with the coverage type, e.g. <code>endpoint</code>):</p>
+  <ul>
+    <li><code>api_coverage_total{coverage_type="&lt;type&gt;"}</code> — total items</li>
+    <li><code>api_coverage_covered{coverage_type="&lt;type&gt;"}</code> — covered items</li>
+    <li><code>api_coverage_ratio{coverage_type="&lt;type&gt;"}</code> — coverage ratio (0–1)</li>
+    <li><code>api_coverage_threshold_failure{coverage_type="&lt;type&gt;"}</code> — 1 if below threshold</li>
+  </ul>`
+            : '<p>Prometheus metrics export not enabled. Use <code>--metrics-port &lt;port&gt;</code> to enable.</p>'}
+  ${observability.tracingEnabled
+            ? `<p>🔭 OpenTelemetry tracing enabled${observability.otlpEndpoint ? ` → <code>${observability.otlpEndpoint}</code>` : ' (in-memory only)'}. View traces in Jaeger or Grafana Tempo.</p>`
+            : '<p>OpenTelemetry tracing not enabled. Use <code>--trace</code> to enable.</p>'}`
+        : '';
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Coverage Summary Report</title>
+  <style>
+    body { font-family: sans-serif; padding: 2rem; background: #fafafa; }
+    h1 { margin-bottom: 0.25rem; }
+    .meta { color: #666; font-size: 0.9rem; margin-bottom: 1.5rem; }
+    table { border-collapse: collapse; width: 100%; max-width: 800px; }
+    th, td { border: 1px solid #ccc; padding: 0.5rem 1rem; text-align: left; }
+    th { background: #f0f0f0; }
+    tr.good { background: #e6ffe6; }
+    tr.warn { background: #fff9e6; }
+    tr.below { background: #ffe6e6; }
+    td.pass { color: #2a7a2a; font-weight: bold; }
+    td.fail { color: #aa2222; font-weight: bold; }
+  </style>
+</head>
+<body>
+  <h1>Coverage Summary Report</h1>
+  <p class="meta">Generated: ${new Date().toISOString()}</p>
+  <table>
+    <thead>
+      <tr>
+        <th>Coverage Type</th>
+        <th>Covered / Total</th>
+        <th>Coverage %</th>
+        <th>Threshold</th>
+      </tr>
+    </thead>
+    <tbody>
+${rows}
+    </tbody>
+  </table>${observabilitySection}
+</body>
+</html>`;
+    const outPath = path.join(reportsDir, 'coverage-summary.html');
+    fs.writeFileSync(outPath, html, 'utf-8');
+}
+/** Write `reports/coverage-summary.csv` */
+function writeCsv(results, reportsDir) {
+    const lines = ['type,total,covered,percent'];
+    for (const r of results) {
+        lines.push(`${r.type},${r.totalItems},${r.coveredItems},${r.coveragePercent}`);
+    }
+    const outPath = path.join(reportsDir, 'coverage-summary.csv');
+    fs.writeFileSync(outPath, lines.join('\n') + '\n', 'utf-8');
+}
+/** Write `reports/coverage-summary-junit.xml` (JUnit-compatible XML) */
+function writeJunit(results, reportsDir, thresholds = {}) {
+    const testCases = results
+        .map((r) => {
+        var _a;
+        const threshold = (_a = thresholds[r.type]) !== null && _a !== void 0 ? _a : 0;
+        const passed = r.coveragePercent >= threshold;
+        const name = `${r.type} coverage`;
+        if (passed) {
+            return `    <testcase name="${name}" classname="CoverageThreshold" time="0"/>`;
+        }
+        const diff = (threshold - r.coveragePercent).toFixed(2);
+        return `    <testcase name="${name}" classname="CoverageThreshold" time="0">
+      <failure message="${r.type} coverage ${r.coveragePercent}% is below threshold ${threshold}% (gap: ${diff}%)">
+        Coverage: ${r.coveragePercent}% / Threshold: ${threshold}% / Gap: ${diff}%
+      </failure>
+    </testcase>`;
+    })
+        .join('\n');
+    const failures = results.filter((r) => { var _a; return r.coveragePercent < ((_a = thresholds[r.type]) !== null && _a !== void 0 ? _a : 0); }).length;
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="API Coverage" tests="${results.length}" failures="${failures}" time="0">
+  <testsuite name="Coverage Thresholds" tests="${results.length}" failures="${failures}" time="0">
+${testCases}
+  </testsuite>
+</testsuites>`;
+    const outPath = path.join(reportsDir, 'coverage-summary-junit.xml');
+    fs.writeFileSync(outPath, xml, 'utf-8');
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Write coverage reports in the requested formats to `reportsDir`.
+ * The directory is created if it does not exist.
+ *
+ * @param results       Array of standardised coverage results
+ * @param formats       Which output formats to generate
+ * @param reportsDir    Absolute path to the output directory
+ * @param thresholds    Optional per-type threshold percentages (used in HTML and JUnit outputs)
+ * @param observability Optional observability metadata embedded in JSON and HTML outputs
+ */
+function generateMultiFormatReports(results, formats, reportsDir, thresholds = {}, observability) {
+    if (!fs.existsSync(reportsDir)) {
+        fs.mkdirSync(reportsDir, { recursive: true });
+    }
+    for (const fmt of formats) {
+        switch (fmt) {
+            case 'json':
+                writeJson(results, reportsDir, observability);
+                break;
+            case 'html':
+                writeHtml(results, reportsDir, thresholds, observability);
+                break;
+            case 'csv':
+                writeCsv(results, reportsDir);
+                break;
+            case 'junit':
+                writeJunit(results, reportsDir, thresholds);
+                break;
+        }
+    }
+}
+/**
+ * Check whether any coverage result falls below its threshold.
+ * Returns an array of failure descriptions (empty means all pass).
+ */
+function checkThresholds(results, thresholds) {
+    const failures = [];
+    for (const result of results) {
+        const threshold = thresholds[result.type];
+        if (threshold !== undefined && result.coveragePercent < threshold) {
+            const gap = (threshold - result.coveragePercent).toFixed(2);
+            failures.push(`${result.type} coverage ${result.coveragePercent}% is below threshold ${threshold}% (gap: ${gap}%)`);
+        }
+    }
+    return failures;
+}

package/dist/src/screenshots.d.ts

@@ -0,0 +1,71 @@
+export interface ScreenshotResult {
+    page: string;
+    filePath: string | null;
+    captured: boolean;
+    error?: string;
+}
+export interface ScreenshotCaptureConfig {
+    /** Whether screenshot capture is enabled */
+    enabled?: boolean;
+    /** If true, missing screenshots cause a build failure */
+    strict?: boolean;
+    /** Dashboard URL to screenshot (defaults to http://localhost:4173) */
+    dashboardUrl?: string;
+    /** Output directory for screenshots */
+    outputDir?: string;
+    /** Build ID to include in path */
+    buildId?: string;
+}
+/** Dashboard pages to capture */
+export declare const SCREENSHOT_PAGES: readonly [{
+    readonly name: "overview";
+    readonly path: "/";
+}, {
+    readonly name: "endpoint-coverage";
+    readonly path: "/endpoint";
+}, {
+    readonly name: "parameter-coverage";
+    readonly path: "/parameter";
+}, {
+    readonly name: "business-coverage";
+    readonly path: "/business";
+}, {
+    readonly name: "integration-flows";
+    readonly path: "/integration";
+}, {
+    readonly name: "security-coverage";
+    readonly path: "/security";
+}, {
+    readonly name: "error-coverage";
+    readonly path: "/error";
+}, {
+    readonly name: "performance-resilience";
+    readonly path: "/performance";
+}, {
+    readonly name: "compatibility";
+    readonly path: "/compatibility";
+}, {
+    readonly name: "ai-analysis";
+    readonly path: "/ai";
+}];
+/**
+ * Attempt to capture screenshots of the dashboard using Playwright or Puppeteer.
+ *
+ * This function **never throws** when `strict` is false (the default).
+ * When headless screenshot tooling is unavailable, it returns results with
+ * `captured: false` for each page and includes an informative error message.
+ *
+ * When `strict: true`, a thrown error will propagate if any screenshot fails.
+ */
+export declare function captureScreenshots(config: ScreenshotCaptureConfig): Promise<ScreenshotResult[]>;
+/**
+ * Return the relative paths of successfully captured screenshots,
+ * suitable for embedding into HTML.
+ */
+export declare function getScreenshotRelativePaths(results: ScreenshotResult[], siteDir: string, basePath?: string): string[];
+/**
+ * Check whether screenshots are available.
+ * Returns `true` when at least one screenshot was captured.
+ */
+export declare function hasScreenshots(results: ScreenshotResult[]): boolean;
+//# sourceMappingURL=screenshots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"screenshots.d.ts","sourceRoot":"","sources":["../../src/screenshots.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,4CAA4C;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,iCAAiC;AACjC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWnB,CAAC;AAIX;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAqC7B;AAgDD;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY,GACrB,MAAM,EAAE,CAOV;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAEnE"}

package/dist/src/screenshots.js

@@ -0,0 +1,141 @@
+"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.SCREENSHOT_PAGES = void 0;
+exports.captureScreenshots = captureScreenshots;
+exports.getScreenshotRelativePaths = getScreenshotRelativePaths;
+exports.hasScreenshots = hasScreenshots;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Dashboard pages to capture */
+exports.SCREENSHOT_PAGES = [
+    { name: 'overview', path: '/' },
+    { name: 'endpoint-coverage', path: '/endpoint' },
+    { name: 'parameter-coverage', path: '/parameter' },
+    { name: 'business-coverage', path: '/business' },
+    { name: 'integration-flows', path: '/integration' },
+    { name: 'security-coverage', path: '/security' },
+    { name: 'error-coverage', path: '/error' },
+    { name: 'performance-resilience', path: '/performance' },
+    { name: 'compatibility', path: '/compatibility' },
+    { name: 'ai-analysis', path: '/ai' },
+];
+// ─── Capture ──────────────────────────────────────────────────────────────────
+/**
+ * Attempt to capture screenshots of the dashboard using Playwright or Puppeteer.
+ *
+ * This function **never throws** when `strict` is false (the default).
+ * When headless screenshot tooling is unavailable, it returns results with
+ * `captured: false` for each page and includes an informative error message.
+ *
+ * When `strict: true`, a thrown error will propagate if any screenshot fails.
+ */
+async function captureScreenshots(config) {
+    var _a, _b, _c;
+    if (config.enabled === false) {
+        return exports.SCREENSHOT_PAGES.map((p) => ({
+            page: p.name,
+            filePath: null,
+            captured: false,
+            error: 'Screenshot capture is disabled',
+        }));
+    }
+    const baseUrl = (_a = config.dashboardUrl) !== null && _a !== void 0 ? _a : 'http://localhost:4173';
+    const siteDir = (_b = config.outputDir) !== null && _b !== void 0 ? _b : 'site';
+    const buildId = (_c = config.buildId) !== null && _c !== void 0 ? _c : 'latest';
+    const screenshotDir = path.join(siteDir, 'assets', 'screenshots', buildId);
+    fs.mkdirSync(screenshotDir, { recursive: true });
+    const results = [];
+    for (const page of exports.SCREENSHOT_PAGES) {
+        const filePath = path.join(screenshotDir, `${page.name}.png`);
+        try {
+            await captureOnePage(baseUrl + page.path, filePath);
+            results.push({ page: page.name, filePath, captured: true });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            if (config.strict) {
+                throw new Error(`Failed to capture screenshot for page "${page.name}": ${error}`);
+            }
+            results.push({ page: page.name, filePath: null, captured: false, error });
+        }
+    }
+    return results;
+}
+/**
+ * Attempt to capture a single page screenshot.
+ * Tries Playwright first, then falls back to a clear "unavailable" error.
+ */
+async function captureOnePage(url, outputPath) {
+    // Try Playwright (chromium) — it is an optional peer dependency
+    let playwright;
+    try {
+        // Dynamic require to avoid hard dependency
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        playwright = require('playwright');
+    }
+    catch {
+        throw new Error('Playwright is not installed. Install it with: npm install --save-dev playwright');
+    }
+    const browser = await playwright.chromium.launch({ headless: true });
+    try {
+        const page = await browser.newPage();
+        await page.goto(url, { waitUntil: 'networkidle', timeout: 15000 });
+        await page.screenshot({ path: outputPath, fullPage: true });
+    }
+    finally {
+        await browser.close();
+    }
+}
+// ─── Helper ───────────────────────────────────────────────────────────────────
+/**
+ * Return the relative paths of successfully captured screenshots,
+ * suitable for embedding into HTML.
+ */
+function getScreenshotRelativePaths(results, siteDir, basePath = '/') {
+    return results
+        .filter((r) => r.captured && r.filePath !== null)
+        .map((r) => {
+        const rel = path.relative(siteDir, r.filePath).replace(/\\/g, '/');
+        return `${basePath}${rel}`;
+    });
+}
+/**
+ * Check whether screenshots are available.
+ * Returns `true` when at least one screenshot was captured.
+ */
+function hasScreenshots(results) {
+    return results.some((r) => r.captured);
+}

package/dist/src/security/gate/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Security gate evaluator.
+ * Evaluates normalized findings against configured thresholds and returns a pass/fail result.
+ */
+import { SecurityFinding, SecurityGateConfig, SecurityGateResult } from '../types';
+/**
+ * Evaluate the security gate against normalized findings.
+ * Returns a SecurityGateResult with pass/fail status and detailed reasons.
+ */
+export declare function evaluateSecurityGate(findings: SecurityFinding[], config: SecurityGateConfig): SecurityGateResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/security/gate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/security/gate/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,eAAe,EACf,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAWlB;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,eAAe,EAAE,EAC3B,MAAM,EAAE,kBAAkB,GACzB,kBAAkB,CA+EpB"}