api-tests-coverage 1.0.20 → 1.0.22

package/dist/src/generation/engine.js

@@ -1,10 +1,13 @@
 "use strict";
 /**
- * Feature 28 — TestGenerationEngine
- * Main orchestrator for the test generation pipeline.
+ * Test Generation Engine (Feature F-TGE)
  *
- * Pipeline:
- *   GapList → GapClassifier → ContextBuilder → TemplateRenderer → FileRouter → FileWriter
+ * Entry point: TestGenerationEngine
+ * CLI commands: generate-tests, export-ai-flows, score-tests
+ *
+ * Every generated file starts with: // AUTO-GENERATED by api-test-coverage-analyzer
+ * expect(response.status) ALWAYS before expect(response.body)
+ * NEVER use toBeTruthy() or toBeDefined() — use specific matchers
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -39,166 +42,337 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestGenerationEngine = void 0;
-exports.generateTests = generateTests;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
 const gap_extractor_1 = require("./gap-extractor");
 const context_builder_1 = require("./context-builder");
 const template_renderer_1 = require("./template-renderer");
 const file_router_1 = require("./file-router");
-// ─── Priority ordering ────────────────────────────────────────────────────────
-const PRIORITY_VALUES = {
-    P0: 0, P1: 1, P2: 2, P3: 3, P4: 4, P5: 5,
-};
-function priorityGte(a, b) {
-    return PRIORITY_VALUES[a] <= PRIORITY_VALUES[b];
-}
-// ─── Gap → test type mapping (Section 1.1 of spec) ───────────────────────────
-const GAP_GENERATOR_MAP = {
-    endpoint: ['unit', 'integration', 'cypress'],
-    parameter: ['unit', 'integration'],
-    error: ['unit', 'integration'],
-    business: ['unit', 'integration'],
-    integration: ['integration', 'cypress'],
-    security: ['security', 'unit'],
-    auth: ['unit', 'integration', 'security'],
-};
-// ─── Discovery info loader ────────────────────────────────────────────────────
-function loadDiscoveryInfo(reportsDir) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const summaryPath = path.join(reportsDir, 'coverage-summary.json');
-    if (fs.existsSync(summaryPath)) {
-        try {
-            const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
-            const di = (_a = summary.discoveryInfo) !== null && _a !== void 0 ? _a : {};
-            return {
-                name: (_d = (_b = di.name) !== null && _b !== void 0 ? _b : (_c = summary.project) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : 'my-api',
-                language: (_e = di.language) !== null && _e !== void 0 ? _e : 'typescript',
-                framework: (_f = di.framework) !== null && _f !== void 0 ? _f : 'express',
-                testFramework: (_g = di.testFramework) !== null && _g !== void 0 ? _g : 'jest',
-                baseUrl: 'http://localhost:3000',
-                projectRoot: process.cwd(),
-                appImportPath: di.appImportPath,
-            };
-        }
-        catch {
-            // Fall through to defaults
-        }
-    }
-    return {
-        name: 'my-api',
-        language: 'typescript',
-        framework: 'express',
-        testFramework: 'jest',
-        baseUrl: 'http://localhost:3000',
-        projectRoot: process.cwd(),
-    };
-}
-// ─── Engine ───────────────────────────────────────────────────────────────────
+// ─── Test Generation Engine ──────────────────────────────────────────────────
 class TestGenerationEngine {
-    constructor(opts) {
-        this.opts = opts;
-        this.discovery = loadDiscoveryInfo(opts.reportsDir);
-        // Override detection with CLI options
-        if (opts.language)
-            this.discovery.language = opts.language;
-        if (opts.framework)
-            this.discovery.framework = opts.framework;
+    constructor(projectRoot, reportsDir = 'reports') {
+        this.projectRoot = path.resolve(projectRoot);
+        this.reportsDir = path.resolve(this.projectRoot, reportsDir);
     }
-    async run() {
-        var _a, _b;
-        const result = {
-            files: [],
-            dryRun: (_a = this.opts.dryRun) !== null && _a !== void 0 ? _a : false,
-            totalGaps: 0,
-            generatedCount: 0,
-            skippedCount: 0,
-            errors: [],
-        };
-        // 1. Extract gaps from reports
-        let gaps = (0, gap_extractor_1.extractGapsFromReports)(this.opts.reportsDir);
-        // 2. Filter by specific gap ID if requested
-        if (this.opts.gapId) {
-            gaps = gaps.filter(g => g.id === this.opts.gapId);
+    /**
+     * Generate test files for all detected coverage gaps.
+     * In dry-run mode, files are not written to disk.
+     */
+    generateTests(options = {}) {
+        var _a;
+        const gaps = (0, gap_extractor_1.extractGaps)(this.reportsDir);
+        const context = (0, context_builder_1.buildContext)(this.projectRoot, gaps, {
+            baseUrl: options.baseUrl,
+            authHeader: options.authHeader,
+        });
+        const outDir = (_a = options.outDir) !== null && _a !== void 0 ? _a : this.projectRoot;
+        const generated = [];
+        for (const gap of context.gaps) {
+            const content = (0, template_renderer_1.renderTemplate)(gap, context);
+            const outputPath = (0, file_router_1.routeOutputPath)(gap, context, outDir);
+            const templateUsed = (0, template_renderer_1.getTemplateName)(gap, context);
+            generated.push({
+                outputPath,
+                content,
+                gapId: gap.id,
+                templateUsed,
+            });
+            if (!options.dryRun) {
+                fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs.writeFileSync(outputPath, content, 'utf-8');
+            }
         }
-        // 3. Filter by priority
-        const minPriority = (_b = this.opts.priority) !== null && _b !== void 0 ? _b : 'P1';
-        gaps = gaps.filter(g => priorityGte(g.priority, minPriority));
-        // 4. Filter by type
-        if (this.opts.types && this.opts.types.length > 0) {
-            gaps = gaps.filter(g => this.opts.types.includes(g.type));
+        // Write manifest
+        const manifest = {
+            generatedAt: new Date().toISOString(),
+            totalFiles: generated.length,
+            files: generated.map((f) => ({
+                outputPath: f.outputPath,
+                gapId: f.gapId,
+                templateUsed: f.templateUsed,
+            })),
+        };
+        if (!options.dryRun) {
+            fs.mkdirSync(this.reportsDir, { recursive: true });
+            fs.writeFileSync(path.join(this.reportsDir, 'generated-tests-manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
         }
-        // 5. Sort by priority (P0 first)
-        gaps = (0, file_router_1.sortGapsByPriority)(gaps);
-        result.totalGaps = gaps.length;
-        // 6. Generate files for each gap
-        for (const gap of gaps) {
+        return generated;
+    }
+    /**
+     * Score existing test files for quality.
+     * Dimensions: statusAssertion, bodyAssertion, errorPath, noGenericMatchers, descriptiveName.
+     */
+    scoreTests(testsGlob) {
+        const testFiles = fast_glob_1.default.sync(testsGlob, { absolute: true })
+            .filter((f) => isTestFile(f));
+        const reports = [];
+        for (const testFile of testFiles) {
+            let content;
             try {
-                const generated = this.generateForGap(gap);
-                for (const file of generated) {
-                    result.files.push(file);
-                    if (!this.opts.dryRun) {
-                        this.writeFile(file);
-                    }
-                    result.generatedCount++;
-                }
+                content = fs.readFileSync(testFile, 'utf-8');
             }
-            catch (err) {
-                result.errors.push({
-                    gapId: gap.id,
-                    message: err instanceof Error ? err.message : String(err),
-                });
+            catch {
+                continue;
             }
+            const report = scoreTestFile(testFile, content);
+            reports.push(report);
         }
-        return result;
+        return reports;
     }
-    generateForGap(gap) {
-        const files = [];
-        const testTypes = this.getTestTypes(gap);
-        const language = this.discovery.language;
-        const convention = 'kebab';
-        for (const testType of testTypes) {
-            const outputPath = (0, file_router_1.routeOutputFile)(gap, testType, this.opts.outDir, language, convention);
-            const ctx = (0, context_builder_1.buildContext)(gap, outputPath, this.discovery);
-            const content = (0, template_renderer_1.renderTemplate)(ctx, { language, testType });
-            files.push({
+    /**
+     * Export AI-ready flows: structured prompts for Copilot / LLM consumption.
+     * RULE-AI05: prompt ≤ 800 tokens (~3200 chars)
+     */
+    exportAiFlows(options = {}) {
+        var _a;
+        const gaps = (0, gap_extractor_1.extractGaps)(this.reportsDir);
+        const context = (0, context_builder_1.buildContext)(this.projectRoot, gaps);
+        const flows = [];
+        const byType = {};
+        for (const gap of gaps) {
+            const outputPath = (0, file_router_1.routeOutputPath)(gap, context, this.projectRoot);
+            // Build a prompt within token budget (RULE-AI05: ≤ 800 tokens ≈ 3200 chars)
+            const prompt = buildCopilotPrompt(gap, context, outputPath);
+            let truncatedPrompt = prompt;
+            if (truncatedPrompt.length > 3200) {
+                const suffix = '\n...';
+                const maxBody = 3200 - suffix.length; // 3196 chars for body, 4 for suffix
+                const cutoff = truncatedPrompt.lastIndexOf('\n', maxBody);
+                truncatedPrompt = truncatedPrompt.substring(0, cutoff > 0 ? cutoff : maxBody) + suffix;
+            }
+            flows.push({
+                id: `flow-${gap.id}`,
                 gapId: gap.id,
-                filePath: path.resolve(outputPath),
-                relativePath: outputPath,
-                content,
-                testType,
-                language,
-                framework: this.discovery.testFramework,
+                gapType: gap.type,
+                suggestedOutputPath: outputPath, // RULE-AI01
+                copilotPrompt: truncatedPrompt, // RULE-AI02, AI03, AI05, AI06
+                existingSimilarTests: gap.existingSimilarTests, // RULE-AI04
+                estimatedComplexity: estimateComplexity(gap),
+                riskScore: gap.riskScore,
             });
+            byType[gap.type] = ((_a = byType[gap.type]) !== null && _a !== void 0 ? _a : 0) + 1;
         }
-        return files;
+        const manifest = {
+            generatedAt: new Date().toISOString(),
+            totalFlows: flows.length,
+            byType: byType,
+            flows,
+        };
+        // Write JSON
+        fs.mkdirSync(this.reportsDir, { recursive: true });
+        fs.writeFileSync(path.join(this.reportsDir, 'ai-ready-flows.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+        // Write markdown summary
+        const md = renderAiFlowsMarkdown(manifest);
+        fs.writeFileSync(path.join(this.reportsDir, 'ai-ready-flows.md'), md, 'utf-8');
+        return manifest;
     }
-    getTestTypes(gap) {
-        var _a;
-        let types = (_a = GAP_GENERATOR_MAP[gap.type]) !== null && _a !== void 0 ? _a : ['unit'];
-        // Apply exclusion flags
-        if (this.opts.noSecurity) {
-            types = types.filter(t => t !== 'security');
-        }
-        if (this.opts.noCypress) {
-            types = types.filter(t => t !== 'cypress');
+}
+exports.TestGenerationEngine = TestGenerationEngine;
+// ─── Scoring helpers ─────────────────────────────────────────────────────────
+/** Only score actual test files, not helpers, fixtures, or utility modules. */
+function isTestFile(filePath) {
+    const base = path.basename(filePath);
+    const isTest = /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(base) ||
+        /test\.(ts|js|tsx|jsx)$/.test(base);
+    // Exclude fixture directories — these contain sample test data, not real tests
+    const isFixture = /[/\\]fixtures[/\\]/.test(filePath);
+    return isTest && !isFixture;
+}
+/** HTTP client package names whose presence in imports indicates an API test. */
+const HTTP_CLIENT_PACKAGES = [
+    'supertest', 'axios', 'node-fetch', 'got',
+];
+/** Angular-specific HTTP client identifiers in imports. */
+const HTTP_CLIENT_IDENTIFIERS = [
+    'HttpClient', 'HttpTestingController',
+];
+/**
+ * Detect whether a test file is an API/HTTP integration test (vs a unit/library test).
+ * Only checks the file's own import/require statements —
+ * NOT inline strings that test code might analyze as content.
+ */
+function isApiTest(content) {
+    const importSection = extractImportSection(content);
+    return HTTP_CLIENT_PACKAGES.some((pkg) => new RegExp(`import\\b.*['"]${pkg}['"]`).test(importSection) ||
+        new RegExp(`require\\s*\\(\\s*['"]${pkg}['"]`).test(importSection)) || HTTP_CLIENT_IDENTIFIERS.some((id) => new RegExp(`import\\b.*${id}`).test(importSection));
+}
+/** Extract the import/require section at the top of the file, before any test blocks. */
+function extractImportSection(content) {
+    const lines = content.split('\n');
+    const importLines = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^(describe|it|test|beforeAll|beforeEach|afterAll|afterEach)\s*\(/.test(trimmed)) {
+            break;
         }
-        return types;
+        importLines.push(line);
     }
-    writeFile(file) {
-        const dir = path.dirname(file.relativePath);
-        fs.mkdirSync(dir, { recursive: true });
-        if (fs.existsSync(file.relativePath) && !this.opts.overwrite) {
-            return;
-        }
-        fs.writeFileSync(file.relativePath, file.content, 'utf8');
+    return importLines.join('\n');
+}
+/** Test name keywords that indicate negative / error / edge-case testing. */
+const ERROR_PATH_NAME_KEYWORDS = [
+    'fail', 'invalid', 'throw', 'missing', 'empty', '\\bnot\\b', 'negative',
+    'reject', 'undefined', 'null', 'zero', 'without', 'default', 'skip',
+    'ignore', '\\bno\\s', 'none', 'unknown', 'error',
+];
+/** Content-level patterns that indicate error/edge-case handling. */
+const ERROR_PATH_CONTENT_PATTERNS = [
+    /\.catch\b/,
+    /expect\([^)]*\.status\)\s*\.toBe\(\s*(4|5)\d{2}\s*\)/,
+    /\.expect\(\s*(4|5)\d{2}\s*\)/,
+    /describe.*error/i,
+    /toThrow/,
+    /rejects\.toThrow/,
+    /throw new Error/,
+    /console\.warn/,
+    /expect\([^)]*\)\.toBe\(\s*false\s*\)/,
+    /expect\([^)]*\)\.toEqual\(\s*\[\s*\]\s*\)/,
+    /expect\([^)]*\)\.toBe\(\s*0\s*\)/,
+    /expect\([^)]*\)\.toBeNull/,
+    /expect\([^)]*\)\.toBeUndefined/,
+];
+/** Specific matcher patterns (as opposed to generic toBeTruthy/toBeDefined). */
+const SPECIFIC_MATCHER_PATTERNS = [
+    /\.toBe\(/, /\.toEqual\(/, /\.toContain\(/, /\.toHaveLength\(/,
+    /\.toMatch\(/, /\.toThrow/, /\.toBeGreaterThan/, /\.toBeLessThan/,
+    /\.toHaveProperty\(/, /\.toHaveBeenCalled/, /\.toBeNull\(/,
+    /\.toBeUndefined\(/, /\.toBeInstanceOf\(/, /\.toStrictEqual\(/,
+    /\.toMatchObject\(/,
+];
+function scoreTestFile(filePath, content) {
+    const apiTest = isApiTest(content);
+    // Status and body assertions only apply to API tests.
+    // For unit/library tests, these are automatically satisfied.
+    const hasStatusAssertion = !apiTest ||
+        /expect\([^)]*\.status\b/.test(content) ||
+        /expect\([^)]*statusCode\b/.test(content) ||
+        /\.expect\(\s*\d{3}\s*\)/.test(content);
+    const hasBodyAssertion = !apiTest ||
+        /expect\([^)]*\.body\b/.test(content) ||
+        /expect\([^)]*\.data\b/.test(content) ||
+        /expect\([^)]*\.text\b/.test(content);
+    const hasErrorPath = ERROR_PATH_CONTENT_PATTERNS.some((p) => p.test(content)) ||
+        ERROR_PATH_NAME_KEYWORDS.some((kw) => new RegExp(`(it|test)\\s*\\(.*${kw}`, 'i').test(content));
+    // For unit/library tests, toBeDefined()/toBeTruthy() are acceptable when
+    // the test also uses specific matchers (toBe, toEqual, toContain, etc.).
+    // Only flag when generic matchers are used without any specific ones.
+    const usesGenericMatchers = /toBeTruthy\(\)/.test(content) || /toBeDefined\(\)/.test(content);
+    const usesSpecificMatchers = SPECIFIC_MATCHER_PATTERNS.some((p) => p.test(content));
+    const hasNoGenericMatchers = !usesGenericMatchers ||
+        (!apiTest && usesSpecificMatchers);
+    const hasDescriptiveName = (/describe\(\s*['"`][^'"`]{5,}['"`]/.test(content) ||
+        /test\(\s*['"`][^'"`]{15,}['"`]/.test(content)) && (/it\(\s*['"`][^'"`]{10,}['"`]/.test(content) ||
+        /test\(\s*['"`][^'"`]{15,}['"`]/.test(content));
+    const dimensions = {
+        hasStatusAssertion,
+        hasBodyAssertion,
+        hasErrorPath,
+        hasNoGenericMatchers,
+        hasDescriptiveName,
+    };
+    const score = Object.values(dimensions).filter(Boolean).length * 20;
+    const violations = [];
+    if (!hasStatusAssertion)
+        violations.push('Missing status code assertion');
+    if (!hasBodyAssertion)
+        violations.push('Missing body/data assertion');
+    if (!hasErrorPath)
+        violations.push('Missing error/negative path');
+    if (!hasNoGenericMatchers)
+        violations.push('Uses toBeTruthy() or toBeDefined() — prefer specific matchers');
+    if (!hasDescriptiveName)
+        violations.push('Test names not sufficiently descriptive');
+    return {
+        file: filePath,
+        overallScore: score,
+        dimensions,
+        violations,
+    };
+}
+// ─── AI Flow helpers ─────────────────────────────────────────────────────────
+/** RULE-AI02: exact import path; RULE-AI03: ALL missing test cases; RULE-AI06: English only */
+function buildCopilotPrompt(gap, ctx, suggestedOutputPath) {
+    // RULE-AI02: derive concrete import path from gap.sourceFile when available
+    const importPath = gap.sourceFile
+        ? path.relative(path.dirname(suggestedOutputPath), gap.sourceFile).replace(/\.[jt]sx?$/, '')
+        : path.relative(path.dirname(suggestedOutputPath), ctx.projectRoot);
+    const lines = [
+        `Write a ${ctx.testFramework} test file at: ${suggestedOutputPath}`, // RULE-AI01
+        `Import from: ${importPath}`, // RULE-AI02
+        '',
+        `Gap type: ${gap.type}`,
+        `Risk score: ${gap.riskScore}/100`,
+    ];
+    // RULE-AI03: ALL missing test cases
+    if (gap.endpoint) {
+        lines.push(`Test: ${gap.endpoint.method} ${gap.endpoint.path}`);
+        lines.push('Include: success case, validation error, auth required');
+    }
+    if (gap.parameter) {
+        lines.push(`Test parameter: ${gap.parameter.name} (${gap.parameter.in}, required: ${gap.parameter.required})`);
+        lines.push('Include: valid value, missing value, invalid type');
+    }
+    if (gap.businessRule) {
+        lines.push(`Test business rule: ${gap.businessRule.description}`);
+        lines.push('Include: rule satisfied, rule violated, edge case');
+    }
+    if (gap.integrationFlow) {
+        lines.push(`Test flow: ${gap.integrationFlow.name} — missing step: ${gap.integrationFlow.missingStep}`);
     }
+    // RULE-AI04: reference existingSimilarTests[0] when available
+    if (gap.existingSimilarTests.length > 0) {
+        lines.push('');
+        lines.push(`Reference existing test: ${gap.existingSimilarTests[0]}`);
+    }
+    lines.push('');
+    lines.push('Rules:');
+    lines.push('- expect(response.status) ALWAYS before expect(response.body)');
+    lines.push('- NEVER use toBeTruthy() or toBeDefined()');
+    lines.push('- First line: // AUTO-GENERATED by api-test-coverage-analyzer');
+    return lines.join('\n');
 }
-exports.TestGenerationEngine = TestGenerationEngine;
-// ─── Public API ───────────────────────────────────────────────────────────────
-async function generateTests(opts) {
-    const engine = new TestGenerationEngine(opts);
-    return engine.run();
+function estimateComplexity(gap) {
+    if (gap.riskScore >= 80)
+        return 'high';
+    if (gap.riskScore >= 50)
+        return 'medium';
+    return 'low';
+}
+function renderAiFlowsMarkdown(manifest) {
+    const lines = [
+        '# AI-Ready Test Generation Flows',
+        '',
+        `Generated: ${manifest.generatedAt}`,
+        `Total flows: ${manifest.totalFlows}`,
+        '',
+        '## By Type',
+        '',
+        '| Gap Type | Count |',
+        '|----------|-------|',
+    ];
+    for (const [type, count] of Object.entries(manifest.byType)) {
+        lines.push(`| ${type} | ${count} |`);
+    }
+    lines.push('');
+    lines.push('## Flows');
+    lines.push('');
+    for (const flow of manifest.flows) {
+        lines.push(`### ${flow.id}`);
+        lines.push('');
+        lines.push(`- **Gap:** ${flow.gapType}`);
+        lines.push(`- **Risk:** ${flow.riskScore}/100`);
+        lines.push(`- **Complexity:** ${flow.estimatedComplexity}`);
+        lines.push(`- **Output:** \`${flow.suggestedOutputPath}\``);
+        if (flow.existingSimilarTests.length > 0) {
+            lines.push(`- **Reference:** ${flow.existingSimilarTests[0]}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
 }

package/dist/src/generation/file-router.d.ts

@@ -1,8 +1,7 @@
+import type { GenerationContext, DetectedGap } from './types';
 /**
- * Feature 28 — FileRouter
- * Determines output file paths for generated test files.
+ * Determines the output file path for a generated test based on
+ * the language, framework, and gap type.
  */
-import type { DetectedGap, TestType, FileNamingConvention } from './types';
-export declare function routeOutputFile(gap: DetectedGap, testType: TestType, outDir: string, language: string, convention?: FileNamingConvention): string;
-export declare function sortGapsByPriority(gaps: DetectedGap[]): DetectedGap[];
+export declare function routeOutputPath(gap: DetectedGap, context: GenerationContext, outDir: string): string;
 //# sourceMappingURL=file-router.d.ts.map

package/dist/src/generation/file-router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-router.d.ts","sourceRoot":"","sources":["../../../src/generation/file-router.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAyC3E,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,oBAA8B,GACzC,MAAM,CAoBR;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAErE"}
+{"version":3,"file":"file-router.d.ts","sourceRoot":"","sources":["../../../src/generation/file-router.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE9D;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,CAiBR"}

package/dist/src/generation/file-router.js

@@ -1,8 +1,4 @@
 "use strict";
-/**
- * Feature 28 — FileRouter
- * Determines output file paths for generated test files.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -37,62 +33,47 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.routeOutputFile = routeOutputFile;
-exports.sortGapsByPriority = sortGapsByPriority;
-const path = __importStar(require("path"));
-const PRIORITY_ORDER = { P0: 0, P1: 1, P2: 2, P3: 3, P4: 4, P5: 5 };
-function toKebab(s) {
-    return s
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/[^a-zA-Z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .toLowerCase();
-}
-function toCamel(s) {
-    return toKebab(s)
-        .split('-')
-        .map((w, i) => (i === 0 ? w : w.charAt(0).toUpperCase() + w.slice(1)))
-        .join('');
-}
-function toSnake(s) {
-    return toKebab(s).replace(/-/g, '_');
-}
-function applyNaming(name, convention) {
-    switch (convention) {
-        case 'camelCase': return toCamel(name);
-        case 'snake_case': return toSnake(name);
-        case 'kebab':
-        default: return toKebab(name);
+exports.routeOutputPath = routeOutputPath;
+const path = __importStar(require("node:path"));
+/**
+ * Determines the output file path for a generated test based on
+ * the language, framework, and gap type.
+ */
+function routeOutputPath(gap, context, outDir) {
+    const { framework, language } = context;
+    let baseDir;
+    if (framework === 'cypress') {
+        baseDir = path.join(outDir, 'cypress', 'e2e', 'generated');
     }
+    else if (language === 'java' || language === 'kotlin') {
+        baseDir = path.join(outDir, 'src', 'test', 'generated');
+    }
+    else {
+        baseDir = path.join(outDir, 'tests', 'generated');
+    }
+    const ext = getFileExtension(language);
+    const filename = buildFilename(gap, language);
+    return path.join(baseDir, filename + ext);
 }
-function pathToFileName(method, apiPath, convention) {
-    const parts = apiPath
-        .split('/')
-        .filter(Boolean)
-        .map(p => p.replace(/[{}]/g, '').replace(/[^a-zA-Z0-9]/g, '-'));
-    const base = [...parts, method.toLowerCase()].join('-');
-    return applyNaming(base, convention);
-}
-function routeOutputFile(gap, testType, outDir, language, convention = 'kebab') {
-    const method = gap.endpoint.method.toLowerCase();
-    const apiPath = gap.endpoint.path;
-    const baseName = pathToFileName(method, apiPath, convention);
-    switch (testType) {
-        case 'security':
-            return path.join(outDir, 'security', `${baseName}.security.test.ts`);
-        case 'cypress':
-            return path.join('cypress', 'e2e', 'generated', `${baseName}.cy.js`);
-        case 'integration':
-            if (gap.flow) {
-                const flowName = applyNaming(gap.flow.name, convention);
-                return path.join(outDir, 'flows', `${flowName}.flow.test.ts`);
-            }
-            return path.join(outDir, `${baseName}.integration.test.ts`);
-        case 'unit':
-        default:
-            return path.join(outDir, `${baseName}.test.ts`);
+function getFileExtension(language) {
+    switch (language) {
+        case 'typescript': return '.test.ts';
+        case 'javascript': return '.test.js';
+        case 'python': return '_test.py';
+        case 'java': return 'Test.java';
+        case 'kotlin': return 'Test.kt';
+        default: return '.test.ts';
     }
 }
-function sortGapsByPriority(gaps) {
-    return [...gaps].sort((a, b) => { var _a, _b; return ((_a = PRIORITY_ORDER[a.priority]) !== null && _a !== void 0 ? _a : 99) - ((_b = PRIORITY_ORDER[b.priority]) !== null && _b !== void 0 ? _b : 99); });
+function buildFilename(gap, language) {
+    // Sanitise the gap id to produce a valid filename
+    const sanitised = gap.id.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-');
+    // For Java/Kotlin, use PascalCase class names
+    if (language === 'java' || language === 'kotlin') {
+        return sanitised
+            .split('-')
+            .map((p) => p.charAt(0).toUpperCase() + p.slice(1))
+            .join('');
+    }
+    return sanitised;
 }

package/dist/src/generation/gap-extractor.d.ts

@@ -1,7 +1,12 @@
+import type { DetectedGap } from './types';
 /**
- * Feature 28 — GapExtractor
- * Reads coverage-summary.json (or coverage reports) and extracts DetectedGap objects.
+ * Builds 5 synthetic sample gaps for onboarding / dry-run purposes.
+ * Used when coverage-summary.json has zero gaps or does not exist.
  */
-import type { DetectedGap } from './types';
-export declare function extractGapsFromReports(reportsDir: string): DetectedGap[];
+export declare function buildSampleGaps(): DetectedGap[];
+/**
+ * Reads reports/coverage-summary.json and extracts uncovered items as DetectedGap[].
+ * When there are zero gaps (perfect coverage), returns buildSampleGaps() instead of [].
+ */
+export declare function extractGaps(reportsDir: string): DetectedGap[];
 //# sourceMappingURL=gap-extractor.d.ts.map

package/dist/src/generation/gap-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gap-extractor.d.ts","sourceRoot":"","sources":["../../../src/generation/gap-extractor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAoC,MAAM,SAAS,CAAC;AA4D7E,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,EAAE,CAmLxE"}
+{"version":3,"file":"gap-extractor.d.ts","sourceRoot":"","sources":["../../../src/generation/gap-extractor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAW,MAAM,SAAS,CAAC;AAcpD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,WAAW,EAAE,CA4C/C;AAmBD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,EAAE,CA6D7D"}