api-tests-coverage 1.0.4 → 1.0.6

package/dist/src/index.js

@@ -55,14 +55,19 @@ const index_3 = require("./intelligence/index");
 const observability_2 = require("./observability");
 const buildSummary_1 = require("./summary/buildSummary");
 const prSummary_1 = require("./summary/prSummary");
+const summaryTypes_1 = require("./summary/summaryTypes");
 const astAnalysisOrchestrator_1 = require("./ast/astAnalysisOrchestrator");
 const projectDiscovery_1 = require("./discovery/projectDiscovery");
 const businessRuleInference_1 = require("./inference/businessRuleInference");
 const integrationFlowInference_1 = require("./inference/integrationFlowInference");
+const routeInference_1 = require("./inference/routeInference");
+const scanManifest_1 = require("./inference/scanManifest");
 const serveDashboard_1 = require("./serveDashboard");
 // Register all language AST analyzers at startup.
 // This side-effect import ensures each language module's registerAnalyzer() call runs.
 (0, astAnalysisOrchestrator_1.registerAllAnalyzers)();
+/** Keywords that indicate a test is exercising an error/failure path. */
+const ERROR_TEST_KEYWORDS = ['error', 'fail', 'throw', 'exception', 'reject', 'invalid', 'blank', 'missing'];
 const program = new commander_1.Command();
 program
     .name('api-tests-coverage-analyzer')
@@ -1349,7 +1354,7 @@ program
     .option('--port <port>', 'Port for the dashboard server (requires --dashboard)', parseInt)
     .option('--open', 'Open the dashboard in your browser automatically (requires --dashboard)')
     .action(async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
     const { metricsPort, serviceName } = setupObservability();
     const logger = (0, observability_1.getLogger)();
     const configPath = program.opts()['config'];
@@ -1377,19 +1382,18 @@ program
         return;
     }
     const warnings = [];
+    let inferredRulesResult = null;
+    let inferredFlowsResult = null;
     // ── 2. Business rule inference ─────────────────────────────────────────
     if (doInferRules) {
-        console.log('\nNo business-rules.yaml file detected.');
-        console.log('Business rules will be inferred automatically.');
-        const rulesResult = (0, businessRuleInference_1.inferBusinessRules)(artifacts.serviceFiles, warnings);
-        const rulesPath = (0, businessRuleInference_1.writeInferredBusinessRules)(rulesResult, reportsDir);
-        console.log(`\nBusiness Rule Coverage`);
-        console.log(`  Source: inferred`);
-        console.log(`  Rules detected: ${rulesResult.rules.length}`);
+        inferredRulesResult = (0, businessRuleInference_1.inferBusinessRules)(artifacts.serviceFiles, warnings);
+        const rulesPath = (0, businessRuleInference_1.writeInferredBusinessRules)(inferredRulesResult, reportsDir);
+        console.log(`\nBusiness Rule Inference`);
+        console.log(`  Rules detected in service code: ${inferredRulesResult.rules.length}`);
         console.log(`  Written to: ${rulesPath}`);
         if (options['exportInferredRules']) {
             const fsMod = require('fs');
-            const yaml = rulesResult.rules.map((r) => [
+            const yaml = inferredRulesResult.rules.map((r) => [
                 `- id: ${r.id}`,
                 `  name: ${r.name}`,
                 `  type: ${r.type}`,
@@ -1403,17 +1407,14 @@ program
     }
     // ── 3. Integration flow inference ──────────────────────────────────────
     if (doInferFlows) {
-        console.log('\nNo integration-flows.yaml file detected.');
-        console.log('Integration flows will be inferred automatically.');
-        const flowsResult = (0, integrationFlowInference_1.inferIntegrationFlows)(artifacts.testFiles, warnings);
-        const flowsPath = (0, integrationFlowInference_1.writeInferredIntegrationFlows)(flowsResult, reportsDir);
-        console.log(`\nIntegration Flow Coverage`);
-        console.log(`  Source: inferred`);
-        console.log(`  Flows detected: ${flowsResult.flows.length}`);
+        inferredFlowsResult = (0, integrationFlowInference_1.inferIntegrationFlows)(artifacts.testFiles, warnings);
+        const flowsPath = (0, integrationFlowInference_1.writeInferredIntegrationFlows)(inferredFlowsResult, reportsDir);
+        console.log(`\nIntegration Flow Inference`);
+        console.log(`  Multi-step flows detected in tests: ${inferredFlowsResult.flows.length}`);
         console.log(`  Written to: ${flowsPath}`);
         if (options['exportInferredRules']) {
             const fs = require('fs');
-            const yaml = flowsResult.flows.map((f) => [
+            const yaml = inferredFlowsResult.flows.map((f) => [
                 `- id: ${f.id}`,
                 `  name: "${f.name}"`,
                 `  steps:`,
@@ -1423,14 +1424,16 @@ program
             console.log('  Exported: generated-integration-flows.yaml');
         }
     }
-    // ── 4. Endpoint coverage analysis → coverage-summary.json ─────────────
+    // ── 4. Full coverage analysis → coverage-summary.json ─────────────────
     const allCoverageResults = [];
+    const fsMod = require('fs');
+    const testsGlob = artifacts.testFiles.length > 0
+        ? '{' + artifacts.testFiles.join(',') + '}'
+        : path.join(rootDir, '**', '*');
+    const detectedLanguages = artifacts.languages;
     if (artifacts.specs.length > 0) {
-        const testsGlob = artifacts.testFiles.length > 0
-            ? '{' + artifacts.testFiles.join(',') + '}'
-            : path.join(rootDir, '**', '*');
-        const detectedLanguages = artifacts.languages;
         for (const specPath of artifacts.specs) {
+            // ── 4a. Endpoint coverage ───────────────────────────────────────────
             try {
                 console.log(`\nAnalyzing endpoint coverage for: ${path.basename(specPath)}`);
                 const endpoints = await (0, endpointCoverage_1.parseOpenApiSpec)(specPath);
@@ -1450,15 +1453,412 @@ program
                 warnings.push(`Endpoint coverage failed for ${path.basename(specPath)}: ` +
                     `${err instanceof Error ? err.message : String(err)}`);
             }
-        }
-        if (allCoverageResults.length > 0) {
-            const observabilityInfo = (0, observability_1.buildObservabilityInfo)(metricsPort);
-            (0, reporting_1.generateMultiFormatReports)(allCoverageResults, ['json'], reportsDir, {}, observabilityInfo);
-            console.log(`\nReports written to: ${reportsDir}`);
+            // ── 4b. Parameter coverage ──────────────────────────────────────────
+            try {
+                const parameters = await (0, parameterCoverage_1.parseParameters)(specPath);
+                const astParamOptions = {
+                    astConfig: (_m = (_l = analyzerCfg.analysis) === null || _l === void 0 ? void 0 : _l.ast) !== null && _m !== void 0 ? _m : {},
+                    deepConfig: undefined,
+                };
+                const paramCoverages = await (0, parameterCoverage_1.analyzeParameterCoverage)(parameters, testsGlob, astParamOptions);
+                const paramReport = (0, parameterCoverage_1.buildParameterCoverageReport)(paramCoverages);
+                const paramResult = {
+                    type: 'parameter',
+                    totalItems: paramReport.totalParameters,
+                    coveredItems: paramCoverages.filter((c) => c.ratio > 0).length,
+                    coveragePercent: paramReport.averageCoverage,
+                    details: paramReport,
+                };
+                allCoverageResults.push(paramResult);
+                console.log(`  ${paramResult.coveredItems}/${paramResult.totalItems} parameters covered (${paramReport.averageCoverage}%)`);
+            }
+            catch (err) {
+                warnings.push(`Parameter coverage failed for ${path.basename(specPath)}: ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
+            // ── 4c. Error scenario coverage ─────────────────────────────────────
+            try {
+                const scenarios = await (0, errorCoverage_1.parseErrorScenarios)(specPath);
+                if (scenarios.length > 0) {
+                    const astErrorOptions = {
+                        astConfig: (_p = (_o = analyzerCfg.analysis) === null || _o === void 0 ? void 0 : _o.ast) !== null && _p !== void 0 ? _p : {},
+                        deepConfig: undefined,
+                    };
+                    const errorCoverages = await (0, errorCoverage_1.analyzeErrorCoverage)(scenarios, testsGlob, astErrorOptions);
+                    const errorReport = (0, errorCoverage_1.buildErrorCoverageReport)(errorCoverages);
+                    const errorResult = {
+                        type: 'error',
+                        totalItems: errorReport.total,
+                        coveredItems: errorReport.covered,
+                        coveragePercent: errorReport.percentage,
+                        details: errorReport,
+                    };
+                    allCoverageResults.push(errorResult);
+                    console.log(`  ${errorReport.covered}/${errorReport.total} error scenarios covered (${errorReport.percentage}%)`);
+                }
+            }
+            catch (err) {
+                warnings.push(`Error coverage failed for ${path.basename(specPath)}: ` +
+                    `${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     else {
-        warnings.push('No API spec files found; endpoint coverage analysis skipped.');
+        warnings.push('No API spec files found; attempting route inference for endpoint/error coverage.');
+        // ── 4a-alt. Inferred route endpoint coverage ──────────────────────────
+        try {
+            const routeResult = (0, routeInference_1.inferRoutes)(artifacts.serviceFiles);
+            if (routeResult.routes.length > 0) {
+                const routesPath = (0, routeInference_1.writeInferredRoutes)(routeResult, reportsDir);
+                console.log(`\nRoute Inference`);
+                console.log(`  Routes detected in service code: ${routeResult.routes.length}`);
+                console.log(`  Written to: ${routesPath}`);
+                console.log(`\nAnalyzing endpoint coverage (from inferred routes)...`);
+                // Read test file contents for matching
+                const testContents = artifacts.testFiles.map((tf) => {
+                    try {
+                        return { file: tf, content: fsMod.readFileSync(tf, 'utf-8') };
+                    }
+                    catch {
+                        return { file: tf, content: '' };
+                    }
+                });
+                // Extract test descriptions for fine-grained matching
+                const TEST_DECL_PATTERN = /\b(?:test|it)\s*\(\s*(['"`])([\s\S]*?)\1/g;
+                const testEntries = testContents.map(({ file, content }) => {
+                    const descriptions = [];
+                    const contentLower = content.toLowerCase();
+                    let m;
+                    TEST_DECL_PATTERN.lastIndex = 0;
+                    while ((m = TEST_DECL_PATTERN.exec(content)) !== null) {
+                        descriptions.push(m[2].toLowerCase());
+                    }
+                    return { file, contentLower, descriptions };
+                });
+                const endpointItems = routeResult.routes.map((route) => {
+                    var _a;
+                    const pathSegments = route.path.split('/').filter((s) => s.length > 1 && !s.startsWith(':'));
+                    const method = route.method.toLowerCase();
+                    // Leaf path segment is the most specific identifier (e.g., "comments", "favorite", "feed")
+                    const leafSegment = (_a = pathSegments[pathSegments.length - 1]) !== null && _a !== void 0 ? _a : '';
+                    const matchedTests = [];
+                    for (const { file, contentLower, descriptions } of testEntries) {
+                        let matched = false;
+                        // Priority 1: handler function name appears in test file imports/calls
+                        if (route.handlerFunction) {
+                            const fnLower = route.handlerFunction.toLowerCase();
+                            if (contentLower.includes(fnLower)) {
+                                matched = true;
+                            }
+                        }
+                        // Priority 2: test description mentions method + leaf path segment
+                        if (!matched && leafSegment.length > 2) {
+                            matched = descriptions.some((desc) => desc.includes(method) && desc.includes(leafSegment));
+                        }
+                        // Priority 3: test description mentions the exact path
+                        if (!matched && route.path.length >= 1) {
+                            matched = descriptions.some((desc) => desc.includes(route.path.toLowerCase()));
+                        }
+                        // Priority 4: test file directly calls the URL path (e.g., axios.get('/articles'))
+                        if (!matched && pathSegments.length > 0) {
+                            // Check for full path string in file (e.g., axios.get('/articles/feed'))
+                            const quotedPathPattern = new RegExp(`['"\`]${route.path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"\`]`);
+                            if (quotedPathPattern.test(contentLower)) {
+                                matched = true;
+                            }
+                        }
+                        if (matched) {
+                            matchedTests.push(path.basename(file));
+                        }
+                    }
+                    const covered = matchedTests.length > 0;
+                    return {
+                        id: `${route.method.toUpperCase()} ${route.path}`,
+                        covered,
+                        matchedTests,
+                        handler_function: route.handlerFunction,
+                        source_file: route.sourceFile,
+                        line_number: route.lineNumber,
+                    };
+                });
+                const coveredCount = endpointItems.filter((i) => i.covered).length;
+                const pct = endpointItems.length > 0 ? Math.round((coveredCount / endpointItems.length) * 100) : 0;
+                const endpointResult = {
+                    type: 'endpoint',
+                    totalItems: endpointItems.length,
+                    coveredItems: coveredCount,
+                    coveragePercent: pct,
+                    details: {
+                        total: endpointItems.length,
+                        covered: coveredCount,
+                        percentage: pct,
+                        items: endpointItems,
+                        source: 'inferred',
+                    },
+                };
+                allCoverageResults.push(endpointResult);
+                console.log(`  ${coveredCount}/${endpointItems.length} inferred routes have test coverage (${pct}%)`);
+                // ── 4c-alt. Error coverage from inferred routes + rules ──────────
+                if (inferredRulesResult && inferredRulesResult.rules.length > 0) {
+                    console.log(`\nAnalyzing error coverage (from inferred business rules)...`);
+                    const errorCandidateRules = inferredRulesResult.rules.filter((r) => r.type === 'validation' || r.type === 'business_logic');
+                    const errorItems = errorCandidateRules.map((rule) => {
+                        var _a;
+                        const matchedTestDescriptions = [];
+                        for (const { file, descriptions } of testEntries) {
+                            // Match at TEST DESCRIPTION level, not file level
+                            // Require: description contains an error indicator + at least one specific keyword
+                            const specificKws = (_a = rule.specificKeywords) !== null && _a !== void 0 ? _a : [];
+                            const matchingDescs = descriptions.filter((desc) => {
+                                const hasErrorKeyword = ERROR_TEST_KEYWORDS.some((kw) => desc.includes(kw));
+                                if (!hasErrorKeyword)
+                                    return false;
+                                // If we have specific keywords, at least one must match in the description
+                                if (specificKws.length > 0) {
+                                    return specificKws.some((kw) => desc.includes(kw.toLowerCase()));
+                                }
+                                // No specific keywords — use handler function name as fallback
+                                return true;
+                            });
+                            if (matchingDescs.length > 0) {
+                                matchedTestDescriptions.push(...matchingDescs.map((d) => `[${path.basename(file)}] ${d}`));
+                            }
+                        }
+                        return {
+                            id: rule.id,
+                            description: rule.condition,
+                            covered: matchedTestDescriptions.length > 0,
+                            matchedTests: matchedTestDescriptions,
+                            source_location: rule.source_location,
+                            code_snippet: rule.code_snippet,
+                        };
+                    });
+                    const errorCovered = errorItems.filter((i) => i.covered).length;
+                    const errorPct = errorItems.length > 0 ? Math.round((errorCovered / errorItems.length) * 100) : 0;
+                    const errorResult = {
+                        type: 'error',
+                        totalItems: errorItems.length,
+                        coveredItems: errorCovered,
+                        coveragePercent: errorPct,
+                        details: {
+                            total: errorItems.length,
+                            covered: errorCovered,
+                            percentage: errorPct,
+                            items: errorItems,
+                            source: 'inferred',
+                        },
+                    };
+                    allCoverageResults.push(errorResult);
+                    console.log(`  ${errorCovered}/${errorItems.length} inferred error scenarios have test coverage (${errorPct}%)`);
+                }
+            }
+            else {
+                warnings.push('No routes detected in service files; endpoint coverage skipped.');
+            }
+        }
+        catch (err) {
+            warnings.push(`Route/error inference failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── 4d. Business rules coverage ─────────────────────────────────────────
+    const businessRulesYaml = path.join(rootDir, 'business-rules.yaml');
+    if (fsMod.existsSync(businessRulesYaml)) {
+        // Explicit YAML takes precedence
+        try {
+            console.log(`\nAnalyzing business rules coverage...`);
+            const rules = (0, businessCoverage_1.parseBusinessRules)(businessRulesYaml);
+            const bizCoverages = await (0, businessCoverage_1.analyzeBusinessCoverage)(rules, testsGlob);
+            const bizReport = (0, businessCoverage_1.buildBusinessCoverageReport)(bizCoverages);
+            const bizResult = {
+                type: 'business',
+                totalItems: bizReport.total,
+                coveredItems: bizReport.covered,
+                coveragePercent: bizReport.percentage,
+                details: bizReport,
+            };
+            allCoverageResults.push(bizResult);
+            console.log(`  ${bizReport.covered}/${bizReport.total} business rules covered (${bizReport.percentage}%)`);
+        }
+        catch (err) {
+            warnings.push(`Business rules coverage failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (inferredRulesResult && inferredRulesResult.rules.length > 0) {
+        // Auto-inferred: use specificKeywords from rule for accurate test matching
+        try {
+            console.log(`\nAnalyzing business rules coverage (from inferred rules)...`);
+            const syntheticRules = inferredRulesResult.rules.map((r) => {
+                const kwSet = new Set();
+                // Use specificKeywords extracted from the condition (most accurate)
+                if (r.specificKeywords && r.specificKeywords.length > 0) {
+                    r.specificKeywords.forEach((kw) => { if (!businessRuleInference_1.KEYWORD_STOP_WORDS.has(kw))
+                        kwSet.add(kw); });
+                }
+                else {
+                    // Fallback: words from rule name only (filter stop words)
+                    r.name.toLowerCase().split(/[-_\s]+/).forEach((w) => {
+                        if (w.length > 2 && !businessRuleInference_1.KEYWORD_STOP_WORDS.has(w))
+                            kwSet.add(w);
+                    });
+                }
+                // Non-trivial path segments from endpoint
+                if (r.endpoint) {
+                    r.endpoint.toLowerCase().split(/[/.\s:]+/)
+                        .forEach((w) => { if (w.length > 2 && !/^(api|v\d)$/.test(w) && !businessRuleInference_1.KEYWORD_STOP_WORDS.has(w))
+                        kwSet.add(w); });
+                }
+                return {
+                    id: r.id,
+                    description: r.name,
+                    endpoints: r.endpoint ? [r.endpoint] : [],
+                    keywords: [...kwSet],
+                    scenarios: [],
+                };
+            });
+            const bizCoverages = await (0, businessCoverage_1.analyzeBusinessCoverage)(syntheticRules, testsGlob);
+            const bizReport = (0, businessCoverage_1.buildBusinessCoverageReport)(bizCoverages);
+            const bizResult = {
+                type: 'business',
+                totalItems: bizReport.total,
+                coveredItems: bizReport.covered,
+                coveragePercent: bizReport.percentage,
+                details: {
+                    ...bizReport,
+                    inferred_details: inferredRulesResult.rules.reduce((acc, r) => {
+                        acc[r.id] = {
+                            source_location: r.source_location,
+                            condition: r.condition,
+                            code_snippet: r.code_snippet,
+                            type: r.type,
+                            specificKeywords: r.specificKeywords,
+                        };
+                        return acc;
+                    }, {}),
+                },
+            };
+            allCoverageResults.push(bizResult);
+            console.log(`  ${bizReport.covered}/${bizReport.total} inferred business rules have test coverage (${bizReport.percentage}%)`);
+        }
+        catch (err) {
+            warnings.push(`Business rules coverage failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // ── 4e. Integration flows coverage ──────────────────────────────────────
+    const integrationFlowsYaml = path.join(rootDir, 'integration-flows.yaml');
+    if (fsMod.existsSync(integrationFlowsYaml)) {
+        // Explicit YAML takes precedence
+        try {
+            console.log(`\nAnalyzing integration flows coverage...`);
+            const flows = (0, integrationCoverage_1.parseIntegrationFlows)(integrationFlowsYaml);
+            const flowCoverages = await (0, integrationCoverage_1.analyzeIntegrationCoverage)(flows, testsGlob);
+            const flowReport = (0, integrationCoverage_1.buildIntegrationCoverageReport)(flowCoverages);
+            const flowResult = {
+                type: 'integration',
+                totalItems: flowReport.total,
+                coveredItems: flowReport.complete,
+                coveragePercent: flowReport.percentage,
+                details: flowReport,
+            };
+            allCoverageResults.push(flowResult);
+            console.log(`  ${flowReport.complete}/${flowReport.total} integration flows covered (${flowReport.percentage}%)`);
+        }
+        catch (err) {
+            warnings.push(`Integration flows coverage failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    else if (inferredFlowsResult && inferredFlowsResult.flows.length > 0) {
+        // Auto-inferred: flows are extracted FROM tests, so by definition they're all covered
+        console.log(`\nIntegration flows coverage (from inferred flows)...`);
+        const syntheticItems = inferredFlowsResult.flows.map((f) => ({
+            id: f.id,
+            name: f.name,
+            total: f.steps.length,
+            covered: f.steps.length,
+            complete: true,
+            percentage: 100,
+            uncoveredSteps: [],
+        }));
+        const syntheticReport = {
+            total: syntheticItems.length,
+            complete: syntheticItems.length,
+            percentage: 100,
+            items: syntheticItems,
+        };
+        const flowResult = {
+            type: 'integration',
+            totalItems: syntheticReport.total,
+            coveredItems: syntheticReport.complete,
+            coveragePercent: syntheticReport.percentage,
+            details: syntheticReport,
+        };
+        allCoverageResults.push(flowResult);
+        console.log(`  ${syntheticReport.complete}/${syntheticReport.total} multi-step flows detected and covered (100%)`);
+    }
+    if (allCoverageResults.length > 0) {
+        const observabilityInfo = (0, observability_1.buildObservabilityInfo)(metricsPort);
+        (0, reporting_1.generateMultiFormatReports)(allCoverageResults, ['json'], reportsDir, {}, observabilityInfo);
+        // Append discoveryInfo to coverage-summary.json for the dashboard
+        const summaryPath = path.join(reportsDir, 'coverage-summary.json');
+        try {
+            const summaryJson = JSON.parse(fsMod.readFileSync(summaryPath, 'utf-8'));
+            summaryJson.discoveryInfo = {
+                projectRoot: rootDir,
+                analyzedAt: new Date().toISOString(),
+                languages: artifacts.languages,
+                frameworks: artifacts.frameworks,
+                serviceFilesCount: artifacts.serviceFiles.length,
+                testFilesCount: artifacts.testFiles.length,
+                specFilesCount: artifacts.specs.length,
+                analysisMode: artifacts.specs.length > 0 ? 'explicit-spec' : 'inferred',
+            };
+            fsMod.writeFileSync(summaryPath, JSON.stringify(summaryJson, null, 2), 'utf-8');
+        }
+        catch {
+            // Non-fatal — discovery info is also in scan-manifest.json
+        }
+        console.log(`\nReports written to: ${reportsDir}`);
+    }
+    // ── 4f. Write scan manifest ────────────────────────────────────────────
+    try {
+        const scanTypes = allCoverageResults.map((r) => ({
+            type: r.type,
+            source: artifacts.specs.length > 0 ? 'explicit' : 'inferred',
+            itemsFound: r.totalItems,
+            itemsCovered: r.coveredItems,
+            coveragePercent: r.coveragePercent,
+        }));
+        // Add skipped types (exclude 'business' and 'integration' since these are always attempted
+        // via rule/flow inference regardless of whether a spec file is present; their absence from
+        // allCoverageResults means no rules or flows were discovered, which is informative on its own.)
+        const coveredTypes = new Set(allCoverageResults.map((r) => r.type));
+        for (const skippedType of summaryTypes_1.KNOWN_METRIC_TYPES.filter((t) => t !== 'business' && t !== 'integration')) {
+            if (!coveredTypes.has(skippedType)) {
+                scanTypes.push({
+                    type: skippedType,
+                    source: 'skipped',
+                    reason: artifacts.specs.length === 0 ? 'No API spec and no routes detected' : 'No data available',
+                    itemsFound: 0,
+                    itemsCovered: 0,
+                    coveragePercent: 0,
+                });
+            }
+        }
+        const manifestPath = (0, scanManifest_1.writeScanManifest)({
+            projectRoot: rootDir,
+            analyzedAt: new Date().toISOString(),
+            discoveredFiles: {
+                serviceFiles: artifacts.serviceFiles,
+                testFiles: artifacts.testFiles,
+                specFiles: artifacts.specs,
+            },
+            languages: artifacts.languages,
+            frameworks: artifacts.frameworks,
+            scanTypes,
+        }, reportsDir);
+        console.log(`Scan manifest written to: ${manifestPath}`);
+    }
+    catch (err) {
+        warnings.push(`Scan manifest write failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     // ── 5. Emit warnings ───────────────────────────────────────────────────
     for (const w of warnings) {
@@ -1477,7 +1877,7 @@ program
     if (options['dashboard']) {
         (0, serveDashboard_1.serveDashboard)({
             reportsDir: reportsDir,
-            port: (_l = options['port']) !== null && _l !== void 0 ? _l : 4000,
+            port: (_q = options['port']) !== null && _q !== void 0 ? _q : 4000,
             open: Boolean(options['open']),
         });
         // Keep the process alive — the HTTP server holds the event loop open

package/dist/src/inference/businessRuleInference.d.ts

@@ -34,6 +34,8 @@ export interface InferredBusinessRule {
     source_location: string;
     /** Raw matched code snippet */
     code_snippet: string;
+    /** Most specific identifiable terms from the condition, for accurate test matching */
+    specificKeywords: string[];
 }
 export interface BusinessRuleInferenceResult {
     rules: InferredBusinessRule[];
@@ -60,4 +62,10 @@ export declare function inferBusinessRules(serviceFiles: string[], warnings?: st
  * Returns the path of the written file.
  */
 export declare function writeInferredBusinessRules(result: BusinessRuleInferenceResult, reportsDir: string): string;
+export declare const KEYWORD_STOP_WORDS: Set<string>;
+/**
+ * Extract the most specific identifiable terms from a rule condition string.
+ * Prioritises quoted field names and message fragments over generic identifiers.
+ */
+export declare function extractSpecificKeywords(condition: string): string[];
 //# sourceMappingURL=businessRuleInference.d.ts.map

package/dist/src/inference/businessRuleInference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"businessRuleInference.d.ts","sourceRoot":"","sources":["../../../src/inference/businessRuleInference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AACjD,MAAM,MAAM,QAAQ,GAChB,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,YAAY,CAAC;AAEjB,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,UAAU,CAAC;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,8BAA8B;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,uCAAuC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,EAAE,OAAO,CAAC;IAClB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AA2ID;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,EAAE,CA2C3E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,EAAE,EACtB,QAAQ,GAAE,MAAM,EAAO,GACtB,2BAA2B,CAuB7B;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,2BAA2B,EACnC,UAAU,EAAE,MAAM,GACjB,MAAM,CAYR"}
+{"version":3,"file":"businessRuleInference.d.ts","sourceRoot":"","sources":["../../../src/inference/businessRuleInference.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAOH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,UAAU,CAAC;AACjD,MAAM,MAAM,QAAQ,GAChB,YAAY,GACZ,eAAe,GACf,gBAAgB,GAChB,YAAY,CAAC;AAEjB,MAAM,WAAW,oBAAoB;IACnC,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,UAAU,CAAC;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,8BAA8B;IAC9B,eAAe,EAAE,MAAM,CAAC;IACxB,+BAA+B;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,sFAAsF;IACtF,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,uCAAuC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,QAAQ,EAAE,OAAO,CAAC;IAClB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AA2ID;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,EAAE,CA4C3E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,MAAM,EAAE,EACtB,QAAQ,GAAE,MAAM,EAAO,GACtB,2BAA2B,CAuB7B;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,2BAA2B,EACnC,UAAU,EAAE,MAAM,GACjB,MAAM,CAYR;AAID,eAAO,MAAM,kBAAkB,aAM7B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwCnE"}

package/dist/src/inference/businessRuleInference.js

@@ -50,9 +50,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEYWORD_STOP_WORDS = void 0;
 exports.inferRulesFromFile = inferRulesFromFile;
 exports.inferBusinessRules = inferBusinessRules;
 exports.writeInferredBusinessRules = writeInferredBusinessRules;
+exports.extractSpecificKeywords = extractSpecificKeywords;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const INFERENCE_PATTERNS = [
@@ -208,6 +210,7 @@ function inferRulesFromFile(filePath) {
                 expected_behavior: ip.behaviorTemplate(match),
                 source_location: sourceLocation,
                 code_snippet: line.trim().slice(0, 200),
+                specificKeywords: extractSpecificKeywords(condition),
             });
         }
     }
@@ -258,6 +261,55 @@ function writeInferredBusinessRules(result, reportsDir) {
     return outputPath;
 }
 // ─── Helpers ─────────────────────────────────────────────────────────────────
+exports.KEYWORD_STOP_WORDS = new Set([
+    'http', 'exception', 'error', 'errors', 'throw', 'throws', 'raise', 'raises',
+    'new', 'return', 'returns', 'status', 'response', 'request', 'abort',
+    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'not', 'has',
+    'can', 'cant', 'be', 'been', 'must', 'will', 'was', 'are', 'have',
+    'its', 'too', 'also', 'just', 'only', 'than', 'then', 'when',
+]);
+/**
+ * Extract the most specific identifiable terms from a rule condition string.
+ * Prioritises quoted field names and message fragments over generic identifiers.
+ */
+function extractSpecificKeywords(condition) {
+    var _a, _b, _c;
+    const kwSet = new Set();
+    // 1. Extract contents of quoted strings (field names, messages)
+    // Minimum length of 2 prevents single-character tokens like punctuation or abbreviations
+    // from polluting the keyword set (e.g. single-char matches from `{ e: [...] }`).
+    const quotedMatches = (_a = condition.match(/['"]([^'"]{2,})['"]/g)) !== null && _a !== void 0 ? _a : [];
+    for (const q of quotedMatches) {
+        const inner = q.slice(1, -1);
+        // Split on common separators and add each non-trivial token
+        inner.toLowerCase().split(/[\s\-_.,!?:;/\\]+/).forEach((tok) => {
+            if (tok.length >= 2 && !exports.KEYWORD_STOP_WORDS.has(tok) && /[a-z]/.test(tok)) {
+                kwSet.add(tok);
+            }
+        });
+    }
+    // 2. Extract object key identifiers from patterns like { fieldName: [...] }
+    const objKeyMatches = (_b = condition.match(/\{\s*(?:'([^']+)'|"([^"]+)"|(\w+))\s*:/g)) !== null && _b !== void 0 ? _b : [];
+    for (const m of objKeyMatches) {
+        const inner = m.replace(/^\{\s*/, '').replace(/\s*:$/, '').replace(/['"]/g, '').toLowerCase();
+        if (inner.length >= 2 && !exports.KEYWORD_STOP_WORDS.has(inner)) {
+            kwSet.add(inner);
+        }
+    }
+    // 3. Camel-case parts of exception / class names (e.g. "HttpException" → "http")
+    //    but only non-stop identifiers of reasonable length
+    const identifiers = (_c = condition.match(/\b[A-Za-z][A-Za-z0-9]{2,}\b/g)) !== null && _c !== void 0 ? _c : [];
+    for (const id of identifiers) {
+        // Split camelCase into parts
+        const parts = id.replace(/([A-Z])/g, ' $1').toLowerCase().trim().split(/\s+/);
+        for (const part of parts) {
+            if (part.length >= 3 && !exports.KEYWORD_STOP_WORDS.has(part)) {
+                kwSet.add(part);
+            }
+        }
+    }
+    return [...kwSet];
+}
 function toSnakeCase(str) {
     return str
         .replace(/([A-Z])/g, '_$1')