api-tests-coverage 1.0.13 → 1.0.15

package/dist/src/pipeline/stages/sca/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * SCA (Software Composition Analysis) stage output types.
+ *
+ * The SCA stage is the first stage in the pipeline. It formalizes the existing
+ * discovery engine output and adds dependency classification, version extraction,
+ * and CI platform detection.
+ */
+/**
+ * Category for a classified dependency.
+ */
+export type DependencyCategory = 'httpClient' | 'testFramework' | 'assertionLibrary' | 'mockingLibrary' | 'securityLibrary' | 'performanceTool' | 'e2eFramework' | 'framework' | 'database' | 'logging' | 'utility' | 'unknown';
+/**
+ * CI platform detected from project structure.
+ */
+export type CiPlatform = 'github-actions' | 'gitlab-ci' | 'jenkins' | 'azure-devops' | 'circleci' | 'travis-ci' | 'none';
+/**
+ * Output produced by the SCA stage.
+ * Downstream stages (especially AST and TIA) reference this to select
+ * correct analysis heuristics.
+ */
+export interface ScaOutput {
+    /** Detected programming languages (e.g. ["java", "typescript"]) */
+    languages: string[];
+    /** Detected frameworks (e.g. ["spring-boot", "express", "nestjs"]) */
+    frameworks: string[];
+    /** Detected HTTP client libraries (e.g. ["axios", "retrofit", "okhttp"]) */
+    httpClients: string[];
+    /** Detected test frameworks (e.g. ["jest", "junit5", "pytest"]) */
+    testFrameworks: string[];
+    /** Detected assertion libraries (e.g. ["assertj", "chai", "hamcrest"]) */
+    assertionLibraries: string[];
+    /** Detected security libraries (e.g. ["spring-security", "passport"]) */
+    securityLibraries: string[];
+    /** Detected performance testing tools (e.g. ["k6", "gatling", "locust"]) */
+    performanceTools: string[];
+    /** Detected mocking libraries (e.g. ["mockito", "mockk", "jest.mock", "sinon"]) */
+    mockingLibraries: string[];
+    /** Detected E2E testing frameworks (e.g. ["cypress", "playwright", "selenium"]) */
+    e2eFrameworks: string[];
+    /** All detected dependency names → version strings */
+    dependencyVersions: Record<string, string>;
+    /** Detected CI platform */
+    ciPlatform: CiPlatform;
+}
+/**
+ * A single parsed dependency entry from a manifest file.
+ */
+export interface ParsedDependency {
+    name: string;
+    version: string;
+    scope: 'production' | 'development' | 'test' | 'build' | 'unknown';
+    sourceFile: string;
+}
+/**
+ * Result of parsing all manifest files in a project.
+ */
+export interface DependencyParseResult {
+    dependencies: ParsedDependency[];
+    manifestFiles: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/pipeline/stages/sca/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/sca/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAC1B,YAAY,GACZ,eAAe,GACf,kBAAkB,GAClB,gBAAgB,GAChB,iBAAiB,GACjB,iBAAiB,GACjB,cAAc,GACd,WAAW,GACX,UAAU,GACV,SAAS,GACT,SAAS,GACT,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,gBAAgB,GAChB,WAAW,GACX,SAAS,GACT,cAAc,GACd,UAAU,GACV,WAAW,GACX,MAAM,CAAC;AAEX;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,mEAAmE;IACnE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,sEAAsE;IACtE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mEAAmE;IACnE,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,0EAA0E;IAC1E,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,yEAAyE;IACzE,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,4EAA4E;IAC5E,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mFAAmF;IACnF,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mFAAmF;IACnF,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,sDAAsD;IACtD,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,2BAA2B;IAC3B,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,YAAY,GAAG,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IACnE,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,gBAAgB,EAAE,CAAC;IACjC,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/src/pipeline/stages/sca/types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * SCA (Software Composition Analysis) stage output types.
+ *
+ * The SCA stage is the first stage in the pipeline. It formalizes the existing
+ * discovery engine output and adds dependency classification, version extraction,
+ * and CI platform detection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pipeline/stages/tia/mockBoundaryDetector.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Mock boundary detector — detects mock patterns across all languages
+ * and creates mock boundary records.
+ *
+ * Detects patterns from spec §17:
+ * - Java: @Mock, @Spy, @MockBean, @SpyBean, Mockito.mock(), mockk<>(), every{}
+ * - JS/TS: jest.mock(), jest.fn(), jest.spyOn(), sinon.stub(), sinon.mock(), nock()
+ * - Python: @patch(), @patch.object(), Mock(), MagicMock(), AsyncMock(), mocker.patch()
+ */
+import type { DetectedMockBoundary } from './types';
+/**
+ * Detect mock boundaries in a test file.
+ *
+ * @param filePath - The test file path
+ * @param content - The file content
+ * @param language - The detected language
+ */
+export declare function detectMockBoundaries(filePath: string, content: string, language: string): DetectedMockBoundary[];
+//# sourceMappingURL=mockBoundaryDetector.d.ts.map

package/dist/src/pipeline/stages/tia/mockBoundaryDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockBoundaryDetector.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/mockBoundaryDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAmEpD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,oBAAoB,EAAE,CA8CxB"}

package/dist/src/pipeline/stages/tia/mockBoundaryDetector.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Mock boundary detector — detects mock patterns across all languages
+ * and creates mock boundary records.
+ *
+ * Detects patterns from spec §17:
+ * - Java: @Mock, @Spy, @MockBean, @SpyBean, Mockito.mock(), mockk<>(), every{}
+ * - JS/TS: jest.mock(), jest.fn(), jest.spyOn(), sinon.stub(), sinon.mock(), nock()
+ * - Python: @patch(), @patch.object(), Mock(), MagicMock(), AsyncMock(), mocker.patch()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectMockBoundaries = detectMockBoundaries;
+const JAVA_KOTLIN_PATTERNS = [
+    { regex: /@Mock\b/, library: 'mockito', mockType: 'return-value' },
+    { regex: /@Spy\b/, library: 'mockito', mockType: 'spy' },
+    { regex: /@MockBean\b/, library: 'spring-test', mockType: 'return-value' },
+    { regex: /@SpyBean\b/, library: 'spring-test', mockType: 'spy' },
+    { regex: /Mockito\.mock\(/, library: 'mockito', mockType: 'return-value' },
+    { regex: /Mockito\.spy\(/, library: 'mockito', mockType: 'spy' },
+    { regex: /when\(.*\)\.thenReturn\(/, library: 'mockito', mockType: 'return-value' },
+    { regex: /when\(.*\)\.thenThrow\(/, library: 'mockito', mockType: 'exception' },
+    { regex: /doReturn\(.*\)\.when\(/, library: 'mockito', mockType: 'return-value' },
+    { regex: /doThrow\(.*\)\.when\(/, library: 'mockito', mockType: 'exception' },
+    { regex: /mockk</, library: 'mockk', mockType: 'return-value' },
+    { regex: /spyk\(/, library: 'mockk', mockType: 'spy' },
+    { regex: /every\s*\{/, library: 'mockk', mockType: 'return-value' },
+    { regex: /coEvery\s*\{/, library: 'mockk', mockType: 'return-value' },
+    { regex: /verify\s*\{/, library: 'mockk', mockType: 'spy' },
+];
+const JS_TS_PATTERNS = [
+    { regex: /jest\.mock\(/, library: 'jest', mockType: 'return-value' },
+    { regex: /jest\.fn\(/, library: 'jest', mockType: 'return-value' },
+    { regex: /jest\.spyOn\(/, library: 'jest', mockType: 'spy' },
+    { regex: /\.mockReturnValue\(/, library: 'jest', mockType: 'return-value' },
+    { regex: /\.mockResolvedValue\(/, library: 'jest', mockType: 'return-value' },
+    { regex: /\.mockRejectedValue\(/, library: 'jest', mockType: 'exception' },
+    { regex: /\.mockImplementation\(/, library: 'jest', mockType: 'return-value' },
+    { regex: /sinon\.stub\(/, library: 'sinon', mockType: 'return-value' },
+    { regex: /sinon\.mock\(/, library: 'sinon', mockType: 'return-value' },
+    { regex: /sinon\.spy\(/, library: 'sinon', mockType: 'spy' },
+    { regex: /\.returns\(/, library: 'sinon', mockType: 'return-value' },
+    { regex: /\.throws\(/, library: 'sinon', mockType: 'exception' },
+    { regex: /nock\(/, library: 'nock', mockType: 'return-value' },
+    { regex: /\.useFakeTimers\(/, library: 'jest', mockType: 'timer' },
+    { regex: /sinon\.useFakeTimers\(/, library: 'sinon', mockType: 'timer' },
+];
+const PYTHON_PATTERNS = [
+    { regex: /@patch\(/, library: 'unittest.mock', mockType: 'return-value' },
+    { regex: /@patch\.object\(/, library: 'unittest.mock', mockType: 'return-value' },
+    { regex: /Mock\(\)/, library: 'unittest.mock', mockType: 'return-value' },
+    { regex: /MagicMock\(\)/, library: 'unittest.mock', mockType: 'return-value' },
+    { regex: /AsyncMock\(\)/, library: 'unittest.mock', mockType: 'return-value' },
+    { regex: /mocker\.patch\(/, library: 'pytest-mock', mockType: 'return-value' },
+    { regex: /mocker\.spy\(/, library: 'pytest-mock', mockType: 'spy' },
+    { regex: /\.return_value\s*=/, library: 'unittest.mock', mockType: 'return-value' },
+    { regex: /\.side_effect\s*=/, library: 'unittest.mock', mockType: 'exception' },
+    { regex: /responses\.add\(/, library: 'responses', mockType: 'return-value' },
+    { regex: /requests_mock\./, library: 'requests-mock', mockType: 'return-value' },
+    { regex: /freezegun|freeze_time/, library: 'freezegun', mockType: 'timer' },
+];
+const RUBY_PATTERNS = [
+    { regex: /allow\(.*\)\.to\s+receive\(/, library: 'rspec-mocks', mockType: 'return-value' },
+    { regex: /expect\(.*\)\.to\s+receive\(/, library: 'rspec-mocks', mockType: 'spy' },
+    { regex: /double\(/, library: 'rspec-mocks', mockType: 'return-value' },
+    { regex: /instance_double\(/, library: 'rspec-mocks', mockType: 'return-value' },
+    { regex: /stub_request\(/, library: 'webmock', mockType: 'return-value' },
+];
+/**
+ * Detect mock boundaries in a test file.
+ *
+ * @param filePath - The test file path
+ * @param content - The file content
+ * @param language - The detected language
+ */
+function detectMockBoundaries(filePath, content, language) {
+    var _a;
+    const boundaries = [];
+    const lines = content.split('\n');
+    let patterns;
+    switch (language) {
+        case 'java':
+        case 'kotlin':
+            patterns = JAVA_KOTLIN_PATTERNS;
+            break;
+        case 'javascript':
+        case 'typescript':
+            patterns = JS_TS_PATTERNS;
+            break;
+        case 'python':
+            patterns = PYTHON_PATTERNS;
+            break;
+        case 'ruby':
+            patterns = RUBY_PATTERNS;
+            break;
+        default:
+            // Try all patterns
+            patterns = [...JS_TS_PATTERNS, ...JAVA_KOTLIN_PATTERNS, ...PYTHON_PATTERNS, ...RUBY_PATTERNS];
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of patterns) {
+            if (pattern.regex.test(line)) {
+                // Extract mocked target (heuristic: argument in parentheses)
+                const targetMatch = /[\(][\s]*['"`]?([a-zA-Z0-9_./@]+)['"`]?/.exec(line);
+                const mockedTarget = (_a = targetMatch === null || targetMatch === void 0 ? void 0 : targetMatch[1]) !== null && _a !== void 0 ? _a : 'unknown';
+                boundaries.push({
+                    testFilePath: filePath,
+                    mockingLibrary: pattern.library,
+                    mockType: pattern.mockType,
+                    mockedTarget,
+                    line: i + 1,
+                });
+                break; // One detection per line
+            }
+        }
+    }
+    return boundaries;
+}

package/dist/src/pipeline/stages/tia/parameterizedTestExpander.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parameterized test expander — detects parameterized test patterns and
+ * calculates variant counts.
+ *
+ * Supports:
+ * - JUnit: @ParameterizedTest + @ValueSource, @CsvSource, @MethodSource, @EnumSource
+ * - Jest: test.each(table), describe.each(table), it.each
+ * - pytest: @pytest.mark.parametrize()
+ * - Kotest: data-driven tests
+ */
+import type { ExpandedParameterizedTest } from './types';
+/**
+ * Detect and expand parameterized tests in a file.
+ *
+ * @param filePath - The test file path
+ * @param content - The file content
+ * @param language - The detected language
+ */
+export declare function expandParameterizedTests(filePath: string, content: string, language: string): ExpandedParameterizedTest[];
+//# sourceMappingURL=parameterizedTestExpander.d.ts.map

package/dist/src/pipeline/stages/tia/parameterizedTestExpander.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameterizedTestExpander.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/parameterizedTestExpander.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,yBAAyB,EAAE,CAa7B"}

package/dist/src/pipeline/stages/tia/parameterizedTestExpander.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Parameterized test expander — detects parameterized test patterns and
+ * calculates variant counts.
+ *
+ * Supports:
+ * - JUnit: @ParameterizedTest + @ValueSource, @CsvSource, @MethodSource, @EnumSource
+ * - Jest: test.each(table), describe.each(table), it.each
+ * - pytest: @pytest.mark.parametrize()
+ * - Kotest: data-driven tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandParameterizedTests = expandParameterizedTests;
+/**
+ * Detect and expand parameterized tests in a file.
+ *
+ * @param filePath - The test file path
+ * @param content - The file content
+ * @param language - The detected language
+ */
+function expandParameterizedTests(filePath, content, language) {
+    switch (language) {
+        case 'java':
+        case 'kotlin':
+            return expandJavaKotlinParameterized(filePath, content);
+        case 'javascript':
+        case 'typescript':
+            return expandJestParameterized(filePath, content);
+        case 'python':
+            return expandPytestParameterized(filePath, content);
+        default:
+            return [];
+    }
+}
+// ─── JUnit Parameterized ────────────────────────────────────────────────────
+function expandJavaKotlinParameterized(filePath, content) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // @ParameterizedTest must precede the data source annotation
+        if (!line.includes('@ParameterizedTest'))
+            continue;
+        // Look ahead for data source annotations
+        let testName = 'unknown';
+        let variantCount = 'unresolvable';
+        let pattern = '@ParameterizedTest';
+        for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+            const nextLine = lines[j].trim();
+            // Extract test method name
+            const methodMatch = /(?:void|fun)\s+(\w+)\s*\(/.exec(nextLine);
+            if (methodMatch) {
+                testName = methodMatch[1];
+                break;
+            }
+            // @ValueSource(strings = {"a", "b", "c"})
+            const valueSourceMatch = /@ValueSource\(\s*\w+\s*=\s*\{([^}]+)\}/.exec(nextLine);
+            if (valueSourceMatch) {
+                variantCount = valueSourceMatch[1].split(',').length;
+                pattern = '@ValueSource';
+                continue;
+            }
+            // @CsvSource({"a,1", "b,2", "c,3"})
+            const csvSourceMatch = /@CsvSource\(\s*(?:value\s*=\s*)?\{([^}]+)\}/.exec(nextLine);
+            if (csvSourceMatch) {
+                variantCount = csvSourceMatch[1].split(/",\s*"/).length;
+                pattern = '@CsvSource';
+                continue;
+            }
+            // @MethodSource("methodName")
+            const methodSourceMatch = /@MethodSource\(\s*"(\w+)"/.exec(nextLine);
+            if (methodSourceMatch) {
+                pattern = `@MethodSource(${methodSourceMatch[1]})`;
+                // Try to find the method and count Stream.of() arguments
+                const sourceMethodRegex = new RegExp(`(?:static\\s+)?(?:Stream|List|Collection|Set).*?\\s+${methodSourceMatch[1]}\\s*\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\}`, 'm');
+                const sourceMethodMatch = sourceMethodRegex.exec(content);
+                if (sourceMethodMatch) {
+                    const body = sourceMethodMatch[1];
+                    const argsMatch = body.match(/(?:Arguments\.of|of)\s*\(/g);
+                    if (argsMatch) {
+                        variantCount = argsMatch.length;
+                    }
+                }
+                continue;
+            }
+            // @EnumSource(MyEnum.class)
+            if (nextLine.includes('@EnumSource')) {
+                pattern = '@EnumSource';
+                variantCount = 'unresolvable'; // Would need to find enum declaration
+                continue;
+            }
+        }
+        results.push({
+            testFilePath: filePath,
+            testName,
+            variantCount,
+            pattern,
+            line: i + 1,
+        });
+    }
+    return results;
+}
+// ─── Jest Parameterized ─────────────────────────────────────────────────────
+function expandJestParameterized(filePath, content) {
+    var _a;
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // test.each([...])('name', ...)
+        // it.each([...])('name', ...)
+        // describe.each([...])('name', ...)
+        const eachMatch = /(?:test|it|describe)\.each\s*\(\s*\[/.exec(line);
+        if (eachMatch) {
+            // Try to extract the array and count items
+            const arrayContent = extractBalancedBrackets(content, content.indexOf(eachMatch[0], i > 0 ? content.indexOf(lines[i]) : 0));
+            const variantCount = arrayContent ? countArrayElements(arrayContent) : 'unresolvable';
+            // Extract test name from the next argument
+            const nameMatch = /\)\s*\(\s*['"`]([^'"`]+)['"`]/.exec(content.substring(content.indexOf(eachMatch[0])));
+            const testName = (_a = nameMatch === null || nameMatch === void 0 ? void 0 : nameMatch[1]) !== null && _a !== void 0 ? _a : 'parameterized test';
+            results.push({
+                testFilePath: filePath,
+                testName,
+                variantCount,
+                pattern: 'test.each',
+                line: i + 1,
+            });
+        }
+        // test.each`template`('name', ...)  — tagged template form
+        const templateMatch = /(?:test|it|describe)\.each\s*`/.exec(line);
+        if (templateMatch && !eachMatch) {
+            // Count rows in tagged template (lines between backticks, minus header)
+            let rowCount = 0;
+            for (let j = i + 1; j < lines.length; j++) {
+                if (lines[j].includes('`'))
+                    break;
+                if (lines[j].trim())
+                    rowCount++;
+            }
+            const variantCount = rowCount > 0 ? rowCount : 'unresolvable';
+            results.push({
+                testFilePath: filePath,
+                testName: 'parameterized test',
+                variantCount,
+                pattern: 'test.each (template)',
+                line: i + 1,
+            });
+        }
+    }
+    return results;
+}
+// ─── Pytest Parameterized ───────────────────────────────────────────────────
+function expandPytestParameterized(filePath, content) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // @pytest.mark.parametrize("name", [...])
+        const paramMatch = /@pytest\.mark\.parametrize\s*\(/.exec(line);
+        if (paramMatch) {
+            // Try to extract array content and count elements
+            let variantCount = 'unresolvable';
+            // Look for the bracket content
+            const fullContent = lines.slice(i, Math.min(i + 20, lines.length)).join('\n');
+            const bracketContent = extractBalancedBrackets(fullContent, fullContent.indexOf('['));
+            if (bracketContent) {
+                variantCount = countPytestParams(bracketContent);
+            }
+            // Extract test name from following def line
+            let testName = 'unknown';
+            for (let j = i + 1; j < Math.min(i + 10, lines.length); j++) {
+                const defMatch = /def\s+(\w+)\s*\(/.exec(lines[j]);
+                if (defMatch) {
+                    testName = defMatch[1];
+                    break;
+                }
+            }
+            results.push({
+                testFilePath: filePath,
+                testName,
+                variantCount,
+                pattern: '@pytest.mark.parametrize',
+                line: i + 1,
+            });
+        }
+    }
+    return results;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function extractBalancedBrackets(content, startIndex) {
+    if (startIndex < 0 || startIndex >= content.length || content[startIndex] !== '[') {
+        return undefined;
+    }
+    let depth = 0;
+    let i = startIndex;
+    while (i < content.length) {
+        if (content[i] === '[')
+            depth++;
+        else if (content[i] === ']') {
+            depth--;
+            if (depth === 0) {
+                return content.substring(startIndex + 1, i);
+            }
+        }
+        i++;
+    }
+    return undefined;
+}
+function countArrayElements(arrayContent) {
+    // Count top-level elements (not nested)
+    let depth = 0;
+    let count = 1;
+    for (const char of arrayContent) {
+        if (char === '[' || char === '(' || char === '{')
+            depth++;
+        else if (char === ']' || char === ')' || char === '}')
+            depth--;
+        else if (char === ',' && depth === 0)
+            count++;
+    }
+    // If only whitespace, return 0
+    if (arrayContent.trim().length === 0)
+        return 0;
+    return count;
+}
+function countPytestParams(bracketContent) {
+    // Each top-level tuple/value is a test case
+    const trimmed = bracketContent.trim();
+    if (!trimmed)
+        return 0;
+    // Count top-level commas for simple values
+    // For tuples, count each (...) group
+    const tupleMatches = trimmed.match(/\([^)]*\)/g);
+    if (tupleMatches)
+        return tupleMatches.length;
+    // Otherwise count comma-separated values
+    return countArrayElements(trimmed);
+}

package/dist/src/pipeline/stages/tia/testEndpointMapper.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Test-to-endpoint mapper — maps test files to endpoints using multiple evidence sources.
+ *
+ * Evidence types:
+ * 1. Explicit URL: Direct URL string in test file
+ * 2. Resolved constant: URL from resolved constant/variable
+ * 3. Import graph: Linked via import chain
+ * 4. Naming convention: Test file name matches endpoint handler
+ * 5. Framework metadata: Framework annotations link test to endpoint
+ * 6. Helper traversal: URL resolved through helper function chain
+ * 7. Page object: URL resolved through page object pattern
+ */
+import type { TestEndpointMapping } from './types';
+import type { CoverageKnowledgeGraph } from '../../graph';
+/**
+ * Map test files to endpoints using available evidence in the graph.
+ *
+ * @param graph - The coverage knowledge graph (from AST stage)
+ * @param testFiles - List of test file paths
+ */
+export declare function mapTestsToEndpoints(graph: CoverageKnowledgeGraph, testFiles: string[]): TestEndpointMapping[];
+//# sourceMappingURL=testEndpointMapper.d.ts.map

package/dist/src/pipeline/stages/tia/testEndpointMapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testEndpointMapper.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/testEndpointMapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAG1D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,sBAAsB,EAC7B,SAAS,EAAE,MAAM,EAAE,GAClB,mBAAmB,EAAE,CAqFvB"}

package/dist/src/pipeline/stages/tia/testEndpointMapper.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Test-to-endpoint mapper — maps test files to endpoints using multiple evidence sources.
+ *
+ * Evidence types:
+ * 1. Explicit URL: Direct URL string in test file
+ * 2. Resolved constant: URL from resolved constant/variable
+ * 3. Import graph: Linked via import chain
+ * 4. Naming convention: Test file name matches endpoint handler
+ * 5. Framework metadata: Framework annotations link test to endpoint
+ * 6. Helper traversal: URL resolved through helper function chain
+ * 7. Page object: URL resolved through page object pattern
+ */
+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.mapTestsToEndpoints = mapTestsToEndpoints;
+const path = __importStar(require("path"));
+/**
+ * Map test files to endpoints using available evidence in the graph.
+ *
+ * @param graph - The coverage knowledge graph (from AST stage)
+ * @param testFiles - List of test file paths
+ */
+function mapTestsToEndpoints(graph, testFiles) {
+    var _a, _b;
+    const mappings = [];
+    // Get all endpoint nodes
+    const endpointNodes = graph.getNodesByType('endpoint');
+    if (endpointNodes.length === 0)
+        return mappings;
+    for (const testFile of testFiles) {
+        const fileNodeId = `file:${testFile}`;
+        // 1. Check for existing 'tests' edges from AST stage
+        if (graph.hasNode(fileNodeId)) {
+            const testEdges = graph.getEdgesFrom(fileNodeId).filter((e) => e.type === 'tests');
+            for (const edge of testEdges) {
+                mappings.push({
+                    testFilePath: testFile,
+                    endpointId: edge.targetNodeId,
+                    evidenceType: 'explicit-url',
+                    confidence: 'high',
+                });
+            }
+        }
+        // 2. Check for 'asserts' edges (higher confidence than just 'tests')
+        if (graph.hasNode(fileNodeId)) {
+            const assertEdges = graph.getEdgesFrom(fileNodeId).filter((e) => e.type === 'asserts');
+            for (const edge of assertEdges) {
+                // Don't duplicate if already mapped via 'tests'
+                if (!mappings.some((m) => m.testFilePath === testFile && m.endpointId === edge.targetNodeId)) {
+                    mappings.push({
+                        testFilePath: testFile,
+                        endpointId: edge.targetNodeId,
+                        evidenceType: 'explicit-url',
+                        confidence: 'high',
+                    });
+                }
+            }
+        }
+        // 3. Naming convention matching
+        const testBasename = path.basename(testFile, path.extname(testFile))
+            .replace(/\.(test|spec|Test|Tests|Spec|IT)$/, '')
+            .replace(/^test_|_test$/, '')
+            .replace(/^Test|Test$/, '');
+        for (const endpoint of endpointNodes) {
+            const handlerName = (_b = (_a = endpoint.metadata) === null || _a === void 0 ? void 0 : _a.handlerFunction) !== null && _b !== void 0 ? _b : '';
+            const endpointLabel = endpoint.label.toLowerCase();
+            // Match test file name to handler/controller name
+            if (testBasename.toLowerCase().includes(handlerName.toLowerCase()) && handlerName.length > 3) {
+                if (!mappings.some((m) => m.testFilePath === testFile && m.endpointId === endpoint.id)) {
+                    mappings.push({
+                        testFilePath: testFile,
+                        endpointId: endpoint.id,
+                        evidenceType: 'naming-convention',
+                        confidence: 'low',
+                    });
+                }
+            }
+        }
+        // 4. Import graph traversal: follow imports from test file to find endpoint connections
+        if (graph.hasNode(fileNodeId)) {
+            const importEdges = graph.getEdgesFrom(fileNodeId).filter((e) => e.type === 'imports-helper');
+            for (const importEdge of importEdges) {
+                // Check if the imported file defines any endpoints
+                const importedFileEdges = graph.getEdgesFrom(importEdge.targetNodeId);
+                for (const fileEdge of importedFileEdges) {
+                    if (fileEdge.type === 'tests' || fileEdge.type === 'defines') {
+                        if (!mappings.some((m) => m.testFilePath === testFile && m.endpointId === fileEdge.targetNodeId)) {
+                            mappings.push({
+                                testFilePath: testFile,
+                                endpointId: fileEdge.targetNodeId,
+                                evidenceType: 'import-graph',
+                                confidence: 'medium',
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return mappings;
+}

package/dist/src/pipeline/stages/tia/testLayerClassifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Test layer classifier — classifies test files into 7 layers:
+ * unit, component, integration, api, e2e, performance, security.
+ *
+ * Uses multiple signals: directory patterns, naming patterns,
+ * framework annotations, and import analysis.
+ */
+import type { TestClassification } from './types';
+/**
+ * Classify a test file into a layer.
+ *
+ * @param filePath - The test file path
+ * @param content - Optional file content for content-based classification
+ */
+export declare function classifyTestLayer(filePath: string, content?: string): TestClassification;
+//# sourceMappingURL=testLayerClassifier.d.ts.map

package/dist/src/pipeline/stages/tia/testLayerClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testLayerClassifier.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/tia/testLayerClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAyGlD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,GACf,kBAAkB,CA0DpB"}