api-tests-coverage 1.0.16 → 1.0.18

package/dist/src/generation/gap-extractor.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * Feature 28 — GapExtractor
+ * Reads coverage-summary.json (or coverage reports) and extracts DetectedGap objects.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractGapsFromReports = extractGapsFromReports;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// ─── Priority logic ───────────────────────────────────────────────────────────
+function computePriority(type, authRequired, riskScore) {
+    if (type === 'security' || (type === 'auth' && authRequired))
+        return 'P0';
+    if (type === 'endpoint')
+        return 'P1';
+    if (type === 'error')
+        return 'P2';
+    if (type === 'business')
+        return 'P3';
+    if (type === 'parameter')
+        return 'P4';
+    if (type === 'integration')
+        return 'P5';
+    return 'P3';
+}
+function buildGapId(type, method, apiPath, condition) {
+    return `${type}:${method.toUpperCase()}:${apiPath}:${condition}`;
+}
+// ─── Summary JSON reader ──────────────────────────────────────────────────────
+function readJson(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+function extractGapsFromReports(reportsDir) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24;
+    const gaps = [];
+    // Try coverage-summary.json first
+    const summaryPath = path.join(reportsDir, 'coverage-summary.json');
+    const summary = readJson(summaryPath);
+    if (!summary) {
+        // Return synthetic sample gaps for smoke-test / dry-run mode
+        return buildSampleGaps();
+    }
+    // ── Endpoint gaps ─────────────────────────────────────────────────────────
+    const endpointItems = (_c = (_b = (_a = summary.details) === null || _a === void 0 ? void 0 : _a.endpoint) === null || _b === void 0 ? void 0 : _b.items) !== null && _c !== void 0 ? _c : [];
+    for (const item of endpointItems) {
+        if (item.covered)
+            continue;
+        const method = ((_d = item.method) !== null && _d !== void 0 ? _d : 'GET').toUpperCase();
+        const apiPath = (_e = item.path) !== null && _e !== void 0 ? _e : '/unknown';
+        const authRequired = (_f = item.authRequired) !== null && _f !== void 0 ? _f : false;
+        const authOptional = (_g = item.authOptional) !== null && _g !== void 0 ? _g : false;
+        const riskScore = authRequired ? 85 : 60;
+        gaps.push({
+            id: buildGapId('endpoint', method, apiPath, 'uncovered'),
+            type: 'endpoint',
+            priority: computePriority('endpoint', authRequired, riskScore),
+            riskScore,
+            endpoint: {
+                method,
+                path: apiPath,
+                operationId: item.operationId,
+                tags: item.tags,
+                auth: {
+                    required: authRequired,
+                    optional: authOptional,
+                    type: authRequired ? 'jwt' : undefined,
+                    headerName: authRequired ? 'Authorization' : undefined,
+                    scheme: authRequired ? 'Bearer' : undefined,
+                },
+            },
+            responses: [
+                { statusCode: 200, description: 'Success' },
+                ...(authRequired ? [{ statusCode: 401, description: 'Unauthorized' }] : []),
+                { statusCode: 422, description: 'Unprocessable Entity' },
+            ],
+        });
+    }
+    // ── Security gaps ─────────────────────────────────────────────────────────
+    const securityItems = (_k = (_j = (_h = summary.details) === null || _h === void 0 ? void 0 : _h.security) === null || _j === void 0 ? void 0 : _j.items) !== null && _k !== void 0 ? _k : [];
+    for (const item of securityItems) {
+        if (item.covered)
+            continue;
+        const parts = ((_l = item.endpoint) !== null && _l !== void 0 ? _l : 'GET /unknown').split(' ');
+        const method = ((_m = parts[0]) !== null && _m !== void 0 ? _m : 'GET').toUpperCase();
+        const apiPath = (_o = parts[1]) !== null && _o !== void 0 ? _o : '/unknown';
+        gaps.push({
+            id: buildGapId('security', method, apiPath, (_p = item.controlType) !== null && _p !== void 0 ? _p : 'auth-bypass'),
+            type: 'security',
+            priority: 'P0',
+            riskScore: 95,
+            endpoint: {
+                method,
+                path: apiPath,
+                auth: { required: true, optional: false, type: 'jwt', headerName: 'Authorization', scheme: 'Bearer' },
+            },
+            securityControl: {
+                type: (_q = item.controlType) !== null && _q !== void 0 ? _q : 'auth-bypass',
+                description: `Security control not tested for ${item.endpoint}`,
+                attackVector: 'Missing auth validation test',
+                expectedStatusCode: 401,
+            },
+        });
+    }
+    // ── Error gaps ────────────────────────────────────────────────────────────
+    const errorItems = (_t = (_s = (_r = summary.details) === null || _r === void 0 ? void 0 : _r.error) === null || _s === void 0 ? void 0 : _s.items) !== null && _t !== void 0 ? _t : [];
+    for (const item of errorItems) {
+        if (item.covered)
+            continue;
+        const parts = ((_u = item.endpoint) !== null && _u !== void 0 ? _u : 'GET /unknown').split(' ');
+        const method = ((_v = parts[0]) !== null && _v !== void 0 ? _v : 'GET').toUpperCase();
+        const apiPath = (_w = parts[1]) !== null && _w !== void 0 ? _w : '/unknown';
+        const statusCode = (_x = item.statusCode) !== null && _x !== void 0 ? _x : 500;
+        gaps.push({
+            id: buildGapId('error', method, apiPath, String(statusCode)),
+            type: 'error',
+            priority: 'P2',
+            riskScore: 65,
+            endpoint: {
+                method,
+                path: apiPath,
+                auth: { required: false, optional: false },
+            },
+            responses: [{ statusCode, description: `Error ${statusCode} not tested` }],
+        });
+    }
+    // ── Business rule gaps ────────────────────────────────────────────────────
+    const businessItems = (_0 = (_z = (_y = summary.details) === null || _y === void 0 ? void 0 : _y.business) === null || _z === void 0 ? void 0 : _z.items) !== null && _0 !== void 0 ? _0 : [];
+    for (const item of businessItems) {
+        if (item.covered)
+            continue;
+        const parts = ((_1 = item.endpoint) !== null && _1 !== void 0 ? _1 : 'GET /unknown').split(' ');
+        const method = ((_2 = parts[0]) !== null && _2 !== void 0 ? _2 : 'GET').toUpperCase();
+        const apiPath = (_3 = parts[1]) !== null && _3 !== void 0 ? _3 : '/unknown';
+        gaps.push({
+            id: buildGapId('business', method, apiPath, (_4 = item.ruleId) !== null && _4 !== void 0 ? _4 : 'business-rule'),
+            type: 'business',
+            priority: 'P3',
+            riskScore: 55,
+            endpoint: {
+                method,
+                path: apiPath,
+                auth: { required: false, optional: false },
+            },
+            businessRule: {
+                id: (_5 = item.ruleId) !== null && _5 !== void 0 ? _5 : 'rule-1',
+                description: (_6 = item.description) !== null && _6 !== void 0 ? _6 : 'Business rule not covered',
+                condition: 'When condition is met',
+                acceptanceCriteria: ['Expected behavior is verified'],
+            },
+        });
+    }
+    // ── Integration flow gaps ─────────────────────────────────────────────────
+    const integrationItems = (_9 = (_8 = (_7 = summary.details) === null || _7 === void 0 ? void 0 : _7.integration) === null || _8 === void 0 ? void 0 : _8.items) !== null && _9 !== void 0 ? _9 : [];
+    for (const item of integrationItems) {
+        if (item.covered)
+            continue;
+        gaps.push({
+            id: `integration:${(_10 = item.flowId) !== null && _10 !== void 0 ? _10 : 'flow'}:step-${(_11 = item.missingStepIndex) !== null && _11 !== void 0 ? _11 : 0}-missing`,
+            type: 'integration',
+            priority: 'P5',
+            riskScore: 45,
+            endpoint: {
+                method: 'GET',
+                path: '/unknown',
+                auth: { required: false, optional: false },
+            },
+            flow: {
+                id: (_12 = item.flowId) !== null && _12 !== void 0 ? _12 : 'flow-1',
+                name: (_13 = item.name) !== null && _13 !== void 0 ? _13 : 'Integration Flow',
+                steps: (_14 = item.steps) !== null && _14 !== void 0 ? _14 : [],
+                missingStepIndex: (_15 = item.missingStepIndex) !== null && _15 !== void 0 ? _15 : 0,
+            },
+        });
+    }
+    // ── Parameter gaps ────────────────────────────────────────────────────────
+    const parameterItems = (_18 = (_17 = (_16 = summary.details) === null || _16 === void 0 ? void 0 : _16.parameter) === null || _17 === void 0 ? void 0 : _17.items) !== null && _18 !== void 0 ? _18 : [];
+    for (const item of parameterItems) {
+        const parts = ((_19 = item.endpoint) !== null && _19 !== void 0 ? _19 : 'GET /unknown').split(' ');
+        const method = ((_20 = parts[0]) !== null && _20 !== void 0 ? _20 : 'GET').toUpperCase();
+        const apiPath = (_21 = parts[1]) !== null && _21 !== void 0 ? _21 : '/unknown';
+        const paramName = (_22 = item.parameter) !== null && _22 !== void 0 ? _22 : 'param';
+        const missingCases = ((_23 = item.missingCases) !== null && _23 !== void 0 ? _23 : ['boundary-min']);
+        const condition = (_24 = missingCases[0]) !== null && _24 !== void 0 ? _24 : 'boundary';
+        gaps.push({
+            id: buildGapId('parameter', method, apiPath, `${paramName}:${condition}`),
+            type: 'parameter',
+            priority: 'P4',
+            riskScore: 40,
+            endpoint: {
+                method,
+                path: apiPath,
+                auth: { required: false, optional: false },
+            },
+            parameters: [{
+                    name: paramName,
+                    in: 'query',
+                    required: false,
+                    schema: { type: 'string' },
+                    missingCases,
+                }],
+        });
+    }
+    return gaps;
+}
+/** Build a minimal set of synthetic gaps for smoke-test / dry-run mode */
+function buildSampleGaps() {
+    return [
+        {
+            id: 'endpoint:POST:/api/articles:uncovered',
+            type: 'endpoint',
+            priority: 'P1',
+            riskScore: 85,
+            endpoint: {
+                method: 'POST',
+                path: '/api/articles',
+                operationId: 'createArticle',
+                summary: 'Create Article',
+                auth: { required: true, optional: false, type: 'jwt', headerName: 'Authorization', scheme: 'Bearer' },
+            },
+            parameters: [
+                {
+                    name: 'title',
+                    in: 'body',
+                    required: true,
+                    schema: { type: 'string', minLength: 1 },
+                    missingCases: ['missing-required'],
+                },
+                {
+                    name: 'body',
+                    in: 'body',
+                    required: true,
+                    schema: { type: 'string' },
+                    missingCases: ['missing-required'],
+                },
+                {
+                    name: 'description',
+                    in: 'body',
+                    required: true,
+                    schema: { type: 'string' },
+                    missingCases: ['missing-required'],
+                },
+            ],
+            responses: [
+                { statusCode: 201, description: 'Created' },
+                { statusCode: 401, description: 'Unauthorized' },
+                { statusCode: 422, description: 'Unprocessable Entity' },
+            ],
+        },
+    ];
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Feature 28 — Test Generation & Quality Intelligence Engine
+ * Public API exports
+ */
+export { TestGenerationEngine, generateTests } from './engine';
+export { scoreTests, scoreFile } from './quality-scorer';
+export { exportAiFlows } from './ai-flow-exporter';
+export type { DetectedGap, GeneratedFile, GenerationResult, GenerationOptions, TestQualityReport, FileQualityScore, AiReadyFlows, AiFlowGap, AiFlowExporterOptions, GenerationConfig, TestQualityConfig, AiFlowsConfig, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generation/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACV,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACT,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,GACd,MAAM,SAAS,CAAC"}

package/dist/src/generation/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Feature 28 — Test Generation & Quality Intelligence Engine
+ * Public API exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportAiFlows = exports.scoreFile = exports.scoreTests = exports.generateTests = exports.TestGenerationEngine = void 0;
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "TestGenerationEngine", { enumerable: true, get: function () { return engine_1.TestGenerationEngine; } });
+Object.defineProperty(exports, "generateTests", { enumerable: true, get: function () { return engine_1.generateTests; } });
+var quality_scorer_1 = require("./quality-scorer");
+Object.defineProperty(exports, "scoreTests", { enumerable: true, get: function () { return quality_scorer_1.scoreTests; } });
+Object.defineProperty(exports, "scoreFile", { enumerable: true, get: function () { return quality_scorer_1.scoreFile; } });
+var ai_flow_exporter_1 = require("./ai-flow-exporter");
+Object.defineProperty(exports, "exportAiFlows", { enumerable: true, get: function () { return ai_flow_exporter_1.exportAiFlows; } });

package/dist/src/generation/quality-scorer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Feature 28 — QualityScorer
+ * Scores existing test files on 5 dimensions (0–100 total).
+ *
+ * Dimensions (20 pts each):
+ *   1. Assertion Depth
+ *   2. Negative Path Coverage
+ *   3. Auth Coverage
+ *   4. Boundary Coverage
+ *   5. Test Independence
+ */
+import type { FileQualityScore, TestQualityReport, QualityScorerOptions } from './types';
+export declare function scoreFile(filePath: string): FileQualityScore;
+export declare function scoreTests(opts: QualityScorerOptions): Promise<TestQualityReport>;
+//# sourceMappingURL=quality-scorer.d.ts.map

package/dist/src/generation/quality-scorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quality-scorer.d.ts","sourceRoot":"","sources":["../../../src/generation/quality-scorer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EACV,gBAAgB,EAEhB,iBAAiB,EACjB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AA8JjB,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAoB5D;AAID,wBAAsB,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAsEvF"}

package/dist/src/generation/quality-scorer.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * Feature 28 — QualityScorer
+ * Scores existing test files on 5 dimensions (0–100 total).
+ *
+ * Dimensions (20 pts each):
+ *   1. Assertion Depth
+ *   2. Negative Path Coverage
+ *   3. Auth Coverage
+ *   4. Boundary Coverage
+ *   5. Test Independence
+ */
+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.scoreFile = scoreFile;
+exports.scoreTests = scoreTests;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+// ─── Assertion depth scoring ──────────────────────────────────────────────────
+function scoreAssertionDepth(content) {
+    // +20 — specific field value assertions
+    if (/expect\([^)]+\)\.(toBe|toEqual|toStrictEqual|toContain|toHaveProperty)\(/.test(content)) {
+        // Check if it's a specific value (not just existence)
+        if (/\.toBe\([^)]{3,}\)/.test(content) || /\.toEqual\([^)]{3,}\)/.test(content)) {
+            return 20;
+        }
+        // toHaveProperty with a value
+        if (/\.toHaveProperty\('[^']+',/.test(content)) {
+            return 20;
+        }
+        return 15;
+    }
+    // +10 — only status code assertions
+    if (/expect\(response\.status\)\.toBe\(/.test(content) && !/expect\(response\.body\)/.test(content)) {
+        return 10;
+    }
+    // +5 — weak assertions
+    if (/\.toBeTruthy\(\)|\.toBeDefined\(\)/.test(content)) {
+        return 5;
+    }
+    // +15 — property existence checks
+    if (/\.toHaveProperty\(/.test(content)) {
+        return 15;
+    }
+    // +10 — has some assertions
+    if (/expect\(/.test(content)) {
+        return 10;
+    }
+    return 0;
+}
+// ─── Negative path coverage ───────────────────────────────────────────────────
+function scoreNegativePathCoverage(content) {
+    const has4xx = /toBe\(4\d{2}\)|toBe\(401\)|toBe\(403\)|toBe\(404\)|toBe\(422\)|toBe\(400\)/.test(content);
+    const has5xx = /toBe\(5\d{2}\)|toBe\(500\)/.test(content);
+    const hasErrorPath = /error|invalid|fail|missing|unauthorized|forbidden|not.found/i.test(content);
+    if (has4xx && (has5xx || hasErrorPath))
+        return 20;
+    if (has4xx)
+        return 15;
+    if (hasErrorPath)
+        return 10;
+    return 0;
+}
+// ─── Auth coverage ────────────────────────────────────────────────────────────
+function scoreAuthCoverage(content) {
+    const hasAuthTest = /401|403|Authorization|auth.*token|token.*auth/i.test(content);
+    const hasBothPaths = /401/.test(content) && /200|201/.test(content);
+    const hasOptionalAuth = /optional.*auth|without.*auth|with.*auth/i.test(content);
+    if (hasBothPaths && hasOptionalAuth)
+        return 20;
+    if (hasBothPaths)
+        return 15;
+    if (hasAuthTest)
+        return 10;
+    return 0;
+}
+// ─── Boundary coverage ────────────────────────────────────────────────────────
+function scoreBoundaryCoverage(content) {
+    const hasBoundaryMax = /max|maximum|overflow|too.long|too.large/i.test(content);
+    const hasBoundaryMin = /min|minimum|empty|too.short|too.small/i.test(content);
+    const hasNullTest = /null|undefined|missing.*required/i.test(content);
+    if (hasBoundaryMax && hasBoundaryMin && hasNullTest)
+        return 20;
+    if ((hasBoundaryMax || hasBoundaryMin) && hasNullTest)
+        return 15;
+    if (hasBoundaryMax || hasBoundaryMin)
+        return 10;
+    if (hasNullTest)
+        return 8;
+    return 0;
+}
+// ─── Test independence ────────────────────────────────────────────────────────
+function scoreTestIndependence(content) {
+    // Deduct points for ordered dependencies
+    const hasAfterEach = /afterEach|afterAll/.test(content);
+    const hasBeforeEach = /beforeEach/.test(content);
+    const hasSharedMutableState = /let\s+\w+\s*;/.test(content) && !/beforeAll/.test(content);
+    // Has cleanup
+    if (hasAfterEach)
+        return 20;
+    // Uses beforeEach for isolation (good pattern for unit tests)
+    if (hasBeforeEach && !hasSharedMutableState)
+        return 18;
+    // Shared mutable state without cleanup (risky for parallelism)
+    if (hasSharedMutableState)
+        return 10;
+    // Simple independent tests
+    return 15;
+}
+// ─── Issue detection ──────────────────────────────────────────────────────────
+function detectIssues(content, dimensions) {
+    const issues = [];
+    if (dimensions.assertionDepth < 10) {
+        issues.push('No meaningful assertions found — tests may pass even if the endpoint is broken');
+    }
+    else if (dimensions.assertionDepth < 15) {
+        issues.push('Only status code assertions, no body validation');
+    }
+    if (dimensions.negativePathCoverage < 10) {
+        issues.push('No error path coverage — 4xx/5xx scenarios not tested');
+    }
+    if (dimensions.authCoverage < 10 && /Authorization|auth.*token/i.test(content)) {
+        issues.push('Auth coverage incomplete: only happy path tested, no 401 scenario');
+    }
+    else if (dimensions.authCoverage < 15) {
+        issues.push('Auth coverage incomplete: optional-auth path not tested');
+    }
+    if (dimensions.boundaryCoverage < 8) {
+        issues.push('No boundary tests found (min/max/null/empty values not tested)');
+    }
+    if (dimensions.testIndependence < 15) {
+        issues.push('Tests may have ordering dependencies — shared mutable state without cleanup');
+    }
+    return issues;
+}
+function detectStrengths(content, dimensions) {
+    const strengths = [];
+    if (dimensions.assertionDepth >= 18) {
+        strengths.push('Good assertion depth on response body fields');
+    }
+    if (dimensions.negativePathCoverage >= 18) {
+        strengths.push('All error scenarios covered');
+    }
+    if (dimensions.authCoverage >= 18) {
+        strengths.push('Both authenticated and unauthenticated paths tested');
+    }
+    if (dimensions.boundaryCoverage >= 18) {
+        strengths.push('Comprehensive boundary testing');
+    }
+    if (dimensions.testIndependence >= 18) {
+        strengths.push('Tests are well-isolated and independent');
+    }
+    return strengths;
+}
+// ─── File scorer ──────────────────────────────────────────────────────────────
+function scoreFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const dimensions = {
+        assertionDepth: scoreAssertionDepth(content),
+        negativePathCoverage: scoreNegativePathCoverage(content),
+        authCoverage: scoreAuthCoverage(content),
+        boundaryCoverage: scoreBoundaryCoverage(content),
+        testIndependence: scoreTestIndependence(content),
+    };
+    const score = Object.values(dimensions).reduce((sum, v) => sum + v, 0);
+    return {
+        file: filePath,
+        score,
+        dimensions,
+        issues: detectIssues(content, dimensions),
+        strengths: detectStrengths(content, dimensions),
+    };
+}
+// ─── Report builder ───────────────────────────────────────────────────────────
+async function scoreTests(opts) {
+    var _a, _b;
+    const testsGlob = (_a = opts.testsGlob) !== null && _a !== void 0 ? _a : 'tests/**/*.test.ts';
+    const reportsDir = (_b = opts.reportsDir) !== null && _b !== void 0 ? _b : 'reports';
+    const files = await (0, fast_glob_1.default)(testsGlob, { cwd: process.cwd(), absolute: true });
+    const byFile = [];
+    for (const file of files) {
+        try {
+            byFile.push(scoreFile(file));
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    const overallScore = byFile.length > 0
+        ? Math.round(byFile.reduce((sum, f) => sum + f.score, 0) / byFile.length)
+        : 0;
+    const sorted = [...byFile].sort((a, b) => a.score - b.score);
+    const lowestQualityFiles = sorted.slice(0, 3).map(f => path.relative(process.cwd(), f.file));
+    // Build high-risk + low-quality gaps (stub — would cross-reference with gap data)
+    const highestRiskLowQualityGaps = sorted
+        .filter(f => f.score < 60)
+        .slice(0, 5)
+        .map(f => {
+        var _a;
+        return ({
+            endpoint: path.relative(process.cwd(), f.file),
+            qualityScore: f.score,
+            riskScore: 70,
+            primaryIssue: (_a = f.issues[0]) !== null && _a !== void 0 ? _a : 'Low quality score',
+        });
+    });
+    const report = {
+        overallScore,
+        byFile: byFile.map(f => ({ ...f, file: path.relative(process.cwd(), f.file) })),
+        lowestQualityFiles,
+        highestRiskLowQualityGaps,
+    };
+    // Write output
+    fs.mkdirSync(reportsDir, { recursive: true });
+    const outputPath = path.join(reportsDir, 'test-quality.json');
+    fs.writeFileSync(outputPath, JSON.stringify(report, null, 2), 'utf8');
+    // Also update coverage-summary.json if present
+    const summaryPath = path.join(reportsDir, 'coverage-summary.json');
+    if (fs.existsSync(summaryPath)) {
+        try {
+            const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf8'));
+            summary['testQuality'] = report;
+            fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), 'utf8');
+        }
+        catch {
+            // Non-fatal
+        }
+    }
+    if (opts.failBelow && opts.failBelow > 0) {
+        const failing = byFile.filter(f => f.score < opts.failBelow);
+        if (failing.length > 0) {
+            throw new Error(`Quality gate failed: ${failing.length} test file(s) scored below ${opts.failBelow}.\n` +
+                failing.map(f => `  ${path.relative(process.cwd(), f.file)}: ${f.score}/100`).join('\n'));
+        }
+    }
+    return report;
+}

package/dist/src/generation/template-renderer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Feature 28 — TemplateRenderer
+ * Renders test scaffolds from GenerationContext.
+ * Uses string-based templates (no external dependency required).
+ */
+import type { GenerationContext, TestType } from './types';
+export interface RenderOptions {
+    language: string;
+    testType: TestType;
+}
+export declare function renderTemplate(ctx: GenerationContext, opts: RenderOptions): string;
+//# sourceMappingURL=template-renderer.d.ts.map

package/dist/src/generation/template-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderer.d.ts","sourceRoot":"","sources":["../../../src/generation/template-renderer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAW,QAAQ,EAAE,MAAM,SAAS,CAAC;AAujBpE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;CACpB;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,iBAAiB,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,CA8BlF"}