api-tests-coverage 1.0.0

package/dist/src/integrationCoverage.d.ts

@@ -0,0 +1,72 @@
+export type FlowStepType = 'api' | 'event' | 'external';
+export interface FlowStep {
+    /** Unique step ID, e.g. "FLOW001-step1" */
+    id: string;
+    /** Human-readable description of what this step does */
+    description: string;
+    /** The type of interaction: api call, published event, external service, etc. */
+    type?: FlowStepType;
+    /** HTTP method for api-type steps, e.g. "GET" */
+    method?: string;
+    /** URL path for api-type steps, e.g. "/users/{id}" */
+    path?: string;
+    /**
+     * Keywords used to detect this step in a test's description or body.
+     * A test trace is matched to a step when at least one keyword appears.
+     */
+    keywords: string[];
+}
+export interface IntegrationFlow {
+    /** Unique flow ID, e.g. "FLOW001" */
+    id: string;
+    /** Short human-readable name for the flow */
+    name: string;
+    /** Detailed description of the end-to-end business scenario */
+    description: string;
+    /** The ordered list of steps that make up this flow */
+    steps: FlowStep[];
+}
+export interface IntegrationFlowsFile {
+    flows: IntegrationFlow[];
+}
+export interface StepCoverage {
+    step: FlowStep;
+    covered: boolean;
+    matchedTests: string[];
+}
+export interface FlowCoverage {
+    flow: IntegrationFlow;
+    /** "complete" if all steps covered, "partial" if some steps covered, "missing" if none covered */
+    status: 'complete' | 'partial' | 'missing';
+    /** Test files that contain at least one matching trace for this flow */
+    testFiles: string[];
+    /** Coverage detail for each individual step */
+    steps: StepCoverage[];
+}
+export interface IntegrationCoverageReport {
+    total: number;
+    complete: number;
+    partial: number;
+    missing: number;
+    percentage: number;
+    flows: FlowCoverage[];
+}
+/**
+ * Parse a YAML or JSON integration flows definition file.
+ * The file must contain a top-level `flows` array.
+ */
+export declare function parseIntegrationFlows(flowsPath: string): IntegrationFlow[];
+/**
+ * Analyse test files matching the given glob pattern and determine which
+ * integration flows are covered, partially covered, or missing.
+ */
+export declare function analyzeIntegrationCoverage(flows: IntegrationFlow[], testGlob: string): Promise<FlowCoverage[]>;
+/**
+ * Build the coverage summary from a list of per-flow coverages.
+ */
+export declare function buildIntegrationCoverageReport(coverages: FlowCoverage[]): IntegrationCoverageReport;
+/**
+ * Write JSON and HTML integration-coverage reports to the given directory.
+ */
+export declare function generateIntegrationReports(report: IntegrationCoverageReport, reportsDir: string): void;
+//# sourceMappingURL=integrationCoverage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"integrationCoverage.d.ts","sourceRoot":"","sources":["../../src/integrationCoverage.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,OAAO,GAAG,UAAU,CAAC;AAExD,MAAM,WAAW,QAAQ;IACvB,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,qCAAqC;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,eAAe,CAAC;IACtB,kGAAkG;IAClG,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;IAC3C,wEAAwE;IACxE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,eAAe,EAAE,CAsB1E;AAkFD;;;GAGG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,eAAe,EAAE,EACxB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,EAAE,CAAC,CAqDzB;AAID;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,YAAY,EAAE,GACxB,yBAAyB,CAQ3B;AAID;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,yBAAyB,EACjC,UAAU,EAAE,MAAM,GACjB,IAAI,CAgIN"}

package/dist/src/integrationCoverage.js

@@ -0,0 +1,317 @@
+"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.parseIntegrationFlows = parseIntegrationFlows;
+exports.analyzeIntegrationCoverage = analyzeIntegrationCoverage;
+exports.buildIntegrationCoverageReport = buildIntegrationCoverageReport;
+exports.generateIntegrationReports = generateIntegrationReports;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+// ─── Parsing ──────────────────────────────────────────────────────────────────
+/**
+ * Parse a YAML or JSON integration flows definition file.
+ * The file must contain a top-level `flows` array.
+ */
+function parseIntegrationFlows(flowsPath) {
+    const raw = fs.readFileSync(flowsPath, 'utf-8');
+    const ext = path.extname(flowsPath).toLowerCase();
+    let parsed;
+    if (ext === '.json') {
+        parsed = JSON.parse(raw);
+    }
+    else {
+        parsed = yaml.load(raw);
+    }
+    if (!parsed ||
+        typeof parsed !== 'object' ||
+        !Array.isArray(parsed.flows)) {
+        throw new Error(`Invalid integration flows file: expected a top-level "flows" array in ${flowsPath}`);
+    }
+    return parsed.flows;
+}
+/**
+ * Extract all test/it declarations from a file, together with their
+ * description string and the surrounding code up to the next declaration.
+ */
+function extractTestEntries(filePath, fileContents) {
+    const entries = [];
+    const declPattern = /\b(?:test|it)\s*\(\s*(['"`])([\s\S]*?)\1/g;
+    const positions = [];
+    let m;
+    while ((m = declPattern.exec(fileContents)) !== null) {
+        positions.push({ start: m.index, desc: m[2] });
+    }
+    for (let i = 0; i < positions.length; i++) {
+        const start = positions[i].start;
+        const end = i + 1 < positions.length ? positions[i + 1].start : fileContents.length;
+        entries.push({
+            description: positions[i].desc,
+            content: fileContents.slice(start, end),
+            filePath,
+        });
+    }
+    return entries;
+}
+/**
+ * Determine whether a test entry matches a given step via keywords or step-ID annotation.
+ *
+ * A match occurs when:
+ *   1. The test description or content contains `@step <stepId>` (case-insensitive), OR
+ *   2. The test description (lowercased) contains at least one of the keywords, OR
+ *   3. The test is annotated with `@flow <flowId>` AND a keyword appears anywhere in the content.
+ *
+ * Keywords are checked against the description for general matching to avoid false positives.
+ * When a @flow annotation is present, content-based keyword matching is also allowed since
+ * the test explicitly declares it exercises that flow.
+ */
+function testMatchesStep(entry, step, flowId) {
+    const descLower = entry.description.toLowerCase();
+    // Annotation-based match: @step FLOW001-step1
+    const stepAnnotationPattern = new RegExp(`@step\\s+${step.id}`, 'i');
+    if (stepAnnotationPattern.test(entry.description) || stepAnnotationPattern.test(entry.content)) {
+        return true;
+    }
+    // Keyword-based match (checked against description only for precision)
+    for (const kw of step.keywords) {
+        if (descLower.includes(kw.toLowerCase())) {
+            return true;
+        }
+    }
+    // When a test is annotated with @flow <flowId>, also match keywords against content
+    const flowAnnotationPattern = new RegExp(`@flow\\s+${flowId}`, 'i');
+    if (flowAnnotationPattern.test(entry.description) ||
+        flowAnnotationPattern.test(entry.content)) {
+        const contentLower = entry.content.toLowerCase();
+        for (const kw of step.keywords) {
+            if (contentLower.includes(kw.toLowerCase())) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Analyse test files matching the given glob pattern and determine which
+ * integration flows are covered, partially covered, or missing.
+ */
+async function analyzeIntegrationCoverage(flows, testGlob) {
+    const testFiles = await (0, fast_glob_1.default)(testGlob, { onlyFiles: true });
+    // Pre-read all test files and extract test entries
+    const allEntries = [];
+    for (const filePath of testFiles) {
+        const contents = fs.readFileSync(filePath, 'utf-8');
+        allEntries.push(...extractTestEntries(filePath, contents));
+    }
+    return flows.map((flow) => {
+        const matchedFiles = new Set();
+        // For each step, find the tests that exercise it
+        const stepCoverages = flow.steps.map((step) => {
+            const matchedTests = [];
+            for (const entry of allEntries) {
+                // A test matches a step if:
+                //   - the test is annotated with @flow <flowId> AND matches step keywords/annotation, OR
+                //   - the test matches step keywords/annotation regardless of flow annotation
+                if (testMatchesStep(entry, step, flow.id)) {
+                    matchedTests.push(entry.description);
+                    matchedFiles.add(entry.filePath);
+                }
+            }
+            return {
+                step,
+                covered: matchedTests.length > 0,
+                matchedTests,
+            };
+        });
+        const coveredSteps = stepCoverages.filter((s) => s.covered).length;
+        const totalSteps = stepCoverages.length;
+        let status;
+        if (totalSteps === 0 || coveredSteps === 0) {
+            status = 'missing';
+        }
+        else if (coveredSteps === totalSteps) {
+            status = 'complete';
+        }
+        else {
+            status = 'partial';
+        }
+        return {
+            flow,
+            status,
+            testFiles: Array.from(matchedFiles),
+            steps: stepCoverages,
+        };
+    });
+}
+// ─── Report building ──────────────────────────────────────────────────────────
+/**
+ * Build the coverage summary from a list of per-flow coverages.
+ */
+function buildIntegrationCoverageReport(coverages) {
+    const total = coverages.length;
+    const complete = coverages.filter((c) => c.status === 'complete').length;
+    const partial = coverages.filter((c) => c.status === 'partial').length;
+    const missing = coverages.filter((c) => c.status === 'missing').length;
+    const percentage = total === 0 ? 0 : Math.round((complete / total) * 10000) / 100;
+    return { total, complete, partial, missing, percentage, flows: coverages };
+}
+// ─── Report generation ────────────────────────────────────────────────────────
+/**
+ * Write JSON and HTML integration-coverage reports to the given directory.
+ */
+function generateIntegrationReports(report, reportsDir) {
+    if (!fs.existsSync(reportsDir)) {
+        fs.mkdirSync(reportsDir, { recursive: true });
+    }
+    // ── JSON ─────────────────────────────────────────────────────────────────
+    const jsonPath = path.join(reportsDir, 'integration-coverage.json');
+    const jsonReport = {
+        total: report.total,
+        complete: report.complete,
+        partial: report.partial,
+        missing: report.missing,
+        percentage: report.percentage,
+        flows: report.flows.map(({ flow, status, testFiles, steps }) => ({
+            id: flow.id,
+            name: flow.name,
+            description: flow.description,
+            status,
+            testFiles,
+            steps: steps.map(({ step, covered, matchedTests }) => ({
+                id: step.id,
+                description: step.description,
+                type: step.type,
+                method: step.method,
+                path: step.path,
+                covered,
+                matchedTests,
+            })),
+        })),
+    };
+    fs.writeFileSync(jsonPath, JSON.stringify(jsonReport, null, 2), 'utf-8');
+    // ── HTML ─────────────────────────────────────────────────────────────────
+    const htmlPath = path.join(reportsDir, 'integration-coverage.html');
+    const statusIcon = (s) => {
+        if (s === 'complete')
+            return '✅ Complete';
+        if (s === 'partial')
+            return '⚠️ Partial';
+        return '❌ Missing';
+    };
+    const flowRows = report.flows
+        .map(({ flow, status, steps }) => {
+        const rowClass = status === 'complete' ? 'complete' : status === 'partial' ? 'partial' : 'missing';
+        const stepRows = steps
+            .map(({ step, covered, matchedTests }) => {
+            var _a;
+            const stepClass = covered ? 'covered' : 'uncovered';
+            const stepStatus = covered ? '✅' : '❌';
+            const tests = matchedTests.length > 0 ? matchedTests.join('<br>') : '—';
+            const methodPath = step.method && step.path ? `${step.method} ${step.path}` : (_a = step.type) !== null && _a !== void 0 ? _a : '—';
+            return `      <tr class="step ${stepClass}">
+        <td></td>
+        <td class="step-id">${step.id}</td>
+        <td>${step.description}</td>
+        <td>${methodPath}</td>
+        <td>${stepStatus}</td>
+        <td>${tests}</td>
+      </tr>`;
+        })
+            .join('\n');
+        return `    <tr class="flow ${rowClass}">
+      <td><strong>${flow.id}</strong></td>
+      <td>${flow.name}</td>
+      <td>${flow.description}</td>
+      <td>${statusIcon(status)}</td>
+      <td></td>
+      <td></td>
+    </tr>
+${stepRows}`;
+    })
+        .join('\n');
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Integration Flow 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.flow.complete { background: #e6ffe6; font-weight: bold; }
+    tr.flow.partial { background: #fff9e6; font-weight: bold; }
+    tr.flow.missing { background: #ffe6e6; font-weight: bold; }
+    tr.step { font-size: 0.9rem; }
+    tr.step td { padding: 0.3rem 1rem; }
+    tr.step.covered { background: #f0fff0; }
+    tr.step.uncovered { background: #fff0f0; }
+    td.step-id { font-style: italic; padding-left: 2rem; }
+  </style>
+</head>
+<body>
+  <h1>Integration Flow Coverage Report</h1>
+  <div class="summary">
+    Total flows: <strong>${report.total}</strong> &nbsp;|&nbsp;
+    Complete: <strong>${report.complete}</strong> &nbsp;|&nbsp;
+    Partial: <strong>${report.partial}</strong> &nbsp;|&nbsp;
+    Missing: <strong>${report.missing}</strong> &nbsp;|&nbsp;
+    Coverage: <strong>${report.percentage}%</strong>
+  </div>
+  <table>
+    <thead>
+      <tr>
+        <th>Flow ID</th>
+        <th>Name</th>
+        <th>Description</th>
+        <th>Status</th>
+        <th>Step</th>
+        <th>Matched Tests</th>
+      </tr>
+    </thead>
+    <tbody>
+${flowRows}
+    </tbody>
+  </table>
+</body>
+</html>`;
+    fs.writeFileSync(htmlPath, html, 'utf-8');
+}

package/dist/src/intelligence/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Coverage Intelligence – Main Engine & Public API.
+ *
+ * Orchestrates the linkage engine, risk scorer, summary builder, and markdown
+ * reporter to produce a complete IntelligenceReport from coverage inputs.
+ */
+export * from './types';
+export * from './riskScoring';
+export { runLinkageEngine, buildRecommendationFromFinding } from './linkageEngine';
+export { renderCoverageIntelligenceMd, renderMissingTestsMd, renderRiskPrioritizationMd, writeIntelligenceReports, } from './markdownReporter';
+import type { IntelligenceInput, IntelligenceReport } from './types';
+/**
+ * Run the full Coverage Intelligence engine.
+ *
+ * Inspects all coverage results and security findings, produces functional
+ * findings, missing-test recommendations, risk scores, and (optionally) writes
+ * AI-friendly reports to disk.
+ */
+export declare function runIntelligenceEngine(input: IntelligenceInput): IntelligenceReport;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/intelligence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/intelligence/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AACnF,OAAO,EACL,4BAA4B,EAC5B,oBAAoB,EACpB,0BAA0B,EAC1B,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAInB,MAAM,SAAS,CAAC;AAgEjB;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,iBAAiB,GACvB,kBAAkB,CAkBpB"}

package/dist/src/intelligence/index.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Coverage Intelligence – Main Engine & Public API.
+ *
+ * Orchestrates the linkage engine, risk scorer, summary builder, and markdown
+ * reporter to produce a complete IntelligenceReport from coverage inputs.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeIntelligenceReports = exports.renderRiskPrioritizationMd = exports.renderMissingTestsMd = exports.renderCoverageIntelligenceMd = exports.buildRecommendationFromFinding = exports.runLinkageEngine = void 0;
+exports.runIntelligenceEngine = runIntelligenceEngine;
+__exportStar(require("./types"), exports);
+__exportStar(require("./riskScoring"), exports);
+var linkageEngine_1 = require("./linkageEngine");
+Object.defineProperty(exports, "runLinkageEngine", { enumerable: true, get: function () { return linkageEngine_1.runLinkageEngine; } });
+Object.defineProperty(exports, "buildRecommendationFromFinding", { enumerable: true, get: function () { return linkageEngine_1.buildRecommendationFromFinding; } });
+var markdownReporter_1 = require("./markdownReporter");
+Object.defineProperty(exports, "renderCoverageIntelligenceMd", { enumerable: true, get: function () { return markdownReporter_1.renderCoverageIntelligenceMd; } });
+Object.defineProperty(exports, "renderMissingTestsMd", { enumerable: true, get: function () { return markdownReporter_1.renderMissingTestsMd; } });
+Object.defineProperty(exports, "renderRiskPrioritizationMd", { enumerable: true, get: function () { return markdownReporter_1.renderRiskPrioritizationMd; } });
+Object.defineProperty(exports, "writeIntelligenceReports", { enumerable: true, get: function () { return markdownReporter_1.writeIntelligenceReports; } });
+const linkageEngine_2 = require("./linkageEngine");
+const markdownReporter_2 = require("./markdownReporter");
+// ─── Summary builder ──────────────────────────────────────────────────────────
+function buildSummary(findings, recommendations) {
+    var _a, _b, _c, _d;
+    const findingsBySeverity = {
+        LOW: 0, MEDIUM: 0, HIGH: 0, CRITICAL: 0,
+    };
+    for (const f of findings) {
+        findingsBySeverity[f.severity] = ((_a = findingsBySeverity[f.severity]) !== null && _a !== void 0 ? _a : 0) + 1;
+    }
+    const recommendationsByPriority = {
+        P0: 0, P1: 0, P2: 0, P3: 0,
+    };
+    for (const r of recommendations) {
+        recommendationsByPriority[r.priority] = ((_b = recommendationsByPriority[r.priority]) !== null && _b !== void 0 ? _b : 0) + 1;
+    }
+    const scores = recommendations.map((r) => r.riskScore);
+    const maxRiskScore = scores.length ? Math.max(...scores) : 0;
+    const avgRiskScore = scores.length
+        ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length)
+        : 0;
+    const criticalUncoveredItems = ((_c = findingsBySeverity.CRITICAL) !== null && _c !== void 0 ? _c : 0) + ((_d = findingsBySeverity.HIGH) !== null && _d !== void 0 ? _d : 0);
+    const unprotectedSecurityFindings = findings.filter((f) => f.source === 'security-scan' ||
+        f.category === 'security-finding-unprotected' ||
+        f.category === 'missing-auth-test').length;
+    // Top risk areas = endpoints / rules with highest-scored recommendations
+    const topRiskAreas = recommendations
+        .slice(0, 5)
+        .map((r) => {
+        var _a;
+        return r.endpoint
+            ? `${(_a = r.endpoint.method) !== null && _a !== void 0 ? _a : 'GET'} ${r.endpoint.path} (score ${r.riskScore})`
+            : `${r.title} (score ${r.riskScore})`;
+    });
+    return {
+        totalFindings: findings.length,
+        findingsBySeverity,
+        totalRecommendations: recommendations.length,
+        recommendationsByPriority,
+        maxRiskScore,
+        avgRiskScore,
+        criticalUncoveredItems,
+        unprotectedSecurityFindings,
+        topRiskAreas,
+    };
+}
+// ─── Main entry point ─────────────────────────────────────────────────────────
+/**
+ * Run the full Coverage Intelligence engine.
+ *
+ * Inspects all coverage results and security findings, produces functional
+ * findings, missing-test recommendations, risk scores, and (optionally) writes
+ * AI-friendly reports to disk.
+ */
+function runIntelligenceEngine(input) {
+    var _a;
+    const { findings, recommendations } = (0, linkageEngine_2.runLinkageEngine)(input);
+    const summary = buildSummary(findings, recommendations);
+    const report = {
+        generatedAt: new Date().toISOString(),
+        projectName: (_a = input.projectName) !== null && _a !== void 0 ? _a : 'unknown',
+        findings,
+        recommendations,
+        summary,
+    };
+    if (input.outDir) {
+        (0, markdownReporter_2.writeIntelligenceReports)(report, input.outDir);
+    }
+    return report;
+}

package/dist/src/intelligence/linkageEngine.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Coverage Intelligence – Linkage Engine.
+ *
+ * Inspects coverage results and security findings to produce FunctionalFinding
+ * objects and link them to MissingTestRecommendation records.
+ *
+ * The engine is deterministic and does not require MCP to run.
+ */
+import type { FunctionalFinding, MissingTestRecommendation, IntelligenceInput } from './types';
+export declare function buildRecommendationFromFinding(finding: FunctionalFinding, primaryLanguage?: string, primaryFramework?: string): MissingTestRecommendation;
+export interface LinkageResult {
+    findings: FunctionalFinding[];
+    recommendations: MissingTestRecommendation[];
+}
+/**
+ * Run the full linkage engine over coverage + security results.
+ * Returns all functional findings and deduplicated recommendations.
+ */
+export declare function runLinkageEngine(input: IntelligenceInput): LinkageResult;
+//# sourceMappingURL=linkageEngine.d.ts.map

package/dist/src/intelligence/linkageEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkageEngine.d.ts","sourceRoot":"","sources":["../../../src/intelligence/linkageEngine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EACzB,iBAAiB,EAIlB,MAAM,SAAS,CAAC;AA0ejB,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,iBAAiB,EAC1B,eAAe,CAAC,EAAE,MAAM,EACxB,gBAAgB,CAAC,EAAE,MAAM,GACxB,yBAAyB,CAgD3B;AAwBD,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,eAAe,EAAE,yBAAyB,EAAE,CAAC;CAC9C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,aAAa,CAmDxE"}