api-tests-coverage 1.0.0

package/dist/src/discovery/fileClassifier.d.ts

@@ -0,0 +1,50 @@
+/**
+ * File Classification Engine
+ *
+ * Determines the role of each file in the project. Only files classified as
+ * `test_code` or `bdd_scenarios` may contribute to coverage evidence.
+ *
+ * Specification files, metadata files (business rules, integration flows),
+ * and configuration files are explicitly excluded from coverage calculations.
+ */
+export type FileCategory = 'specification' | 'service_code' | 'test_code' | 'bdd_scenarios' | 'contracts' | 'performance' | 'security_reports' | 'configuration' | 'metadata' | 'unknown';
+export interface ClassifiedFile {
+    filePath: string;
+    category: FileCategory;
+    /** True only when category is test_code or bdd_scenarios */
+    isCoverageEvidence: boolean;
+}
+/** Files that must NEVER contribute to coverage evidence */
+export declare const COVERAGE_EVIDENCE_CATEGORIES: ReadonlySet<FileCategory>;
+/**
+ * Classify a single file path into a `FileCategory`.
+ *
+ * Classification priority (first match wins):
+ *  1. Known specification basenames / includes
+ *  2. Known metadata basenames
+ *  3. Known configuration basenames
+ *  4. `.feature` extension → bdd_scenarios
+ *  5. Contract path patterns
+ *  6. Security report directory patterns
+ *  7. Performance artifact directory patterns
+ *  8. Test file name patterns (*.test.*, *.spec.*, *Test.*, *Tests.*, *Spec.*)
+ *  9. Remaining source extensions → service_code
+ * 10. Fallback → unknown
+ */
+export declare function classifyFile(filePath: string): ClassifiedFile;
+/**
+ * Classify multiple file paths at once.
+ */
+export declare function classifyFiles(filePaths: string[]): ClassifiedFile[];
+/**
+ * Filter a list of classified files to only those that may contribute to
+ * coverage evidence (test_code and bdd_scenarios).
+ */
+export declare function filterCoverageEvidence(files: ClassifiedFile[]): ClassifiedFile[];
+/**
+ * Return true if this file basename looks like a test file.
+ * Supports patterns: *.test.*, *.spec.*, *Test.java, *Tests.java, *Spec.*,
+ * test_*.py, *_test.py, *_spec.rb, spec/**
+ */
+export declare function isTestFile(basename: string): boolean;
+//# sourceMappingURL=fileClassifier.d.ts.map

package/dist/src/discovery/fileClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileClassifier.d.ts","sourceRoot":"","sources":["../../../src/discovery/fileClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,MAAM,MAAM,YAAY,GACpB,eAAe,GACf,cAAc,GACd,WAAW,GACX,eAAe,GACf,WAAW,GACX,aAAa,GACb,kBAAkB,GAClB,eAAe,GACf,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,YAAY,CAAC;IACvB,4DAA4D;IAC5D,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAED,4DAA4D;AAC5D,eAAO,MAAM,4BAA4B,EAAE,WAAW,CAAC,YAAY,CAGjE,CAAC;AAkEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CA4E7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAEnE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,cAAc,EAAE,CAEhF;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAapD"}

package/dist/src/discovery/fileClassifier.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * File Classification Engine
+ *
+ * Determines the role of each file in the project. Only files classified as
+ * `test_code` or `bdd_scenarios` may contribute to coverage evidence.
+ *
+ * Specification files, metadata files (business rules, integration flows),
+ * and configuration files are explicitly excluded from coverage calculations.
+ */
+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.COVERAGE_EVIDENCE_CATEGORIES = void 0;
+exports.classifyFile = classifyFile;
+exports.classifyFiles = classifyFiles;
+exports.filterCoverageEvidence = filterCoverageEvidence;
+exports.isTestFile = isTestFile;
+const path = __importStar(require("path"));
+/** Files that must NEVER contribute to coverage evidence */
+exports.COVERAGE_EVIDENCE_CATEGORIES = new Set([
+    'test_code',
+    'bdd_scenarios',
+]);
+// ─── Classification rules ────────────────────────────────────────────────────
+/** Basename/path patterns for specification files */
+const SPEC_BASENAMES = new Set([
+    'openapi.yaml',
+    'openapi.yml',
+    'openapi.json',
+    'swagger.yaml',
+    'swagger.yml',
+    'swagger.json',
+]);
+/** Basename patterns that match when the file name includes one of these */
+const SPEC_INCLUDES = ['openapi', 'swagger'];
+/** Basename patterns for metadata files (rules / flows / contracts) */
+const METADATA_BASENAMES = new Set([
+    'business-rules.yaml',
+    'business-rules.yml',
+    'business-rules.json',
+    'integration-flows.yaml',
+    'integration-flows.yml',
+    'integration-flows.json',
+]);
+/** Basename patterns for analyzer / project configuration */
+const CONFIG_BASENAMES = new Set([
+    'qintel-analyzer.yaml',
+    'qintel-analyzer.yml',
+    'config.yaml',
+    'config.yml',
+    'coverage.config.json',
+    'package.json',
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'requirements.txt',
+    'Gemfile',
+    'Gemfile.lock',
+    'tsconfig.json',
+    'jest.config.js',
+    'jest.config.ts',
+    '.eslintrc.json',
+    '.eslintrc.js',
+    '.eslintrc.yaml',
+    '.eslintrc.yml',
+]);
+/** Extensions mapped directly to a category */
+const EXTENSION_MAP = {
+    '.feature': 'bdd_scenarios',
+};
+/** Glob-style path-segment patterns for security reports */
+const SECURITY_REPORT_DIRS = ['zap', 'trivy', 'semgrep'];
+/** Glob-style path-segment patterns for performance artifacts */
+const PERFORMANCE_DIRS = ['jmeter', 'k6', 'gatling', 'locust'];
+/** Extensions for contract files */
+const CONTRACT_EXTENSIONS = new Set(['.pact.json']);
+// ─── Core classifier ─────────────────────────────────────────────────────────
+/**
+ * Classify a single file path into a `FileCategory`.
+ *
+ * Classification priority (first match wins):
+ *  1. Known specification basenames / includes
+ *  2. Known metadata basenames
+ *  3. Known configuration basenames
+ *  4. `.feature` extension → bdd_scenarios
+ *  5. Contract path patterns
+ *  6. Security report directory patterns
+ *  7. Performance artifact directory patterns
+ *  8. Test file name patterns (*.test.*, *.spec.*, *Test.*, *Tests.*, *Spec.*)
+ *  9. Remaining source extensions → service_code
+ * 10. Fallback → unknown
+ */
+function classifyFile(filePath) {
+    const basename = path.basename(filePath).toLowerCase();
+    const ext = path.extname(filePath).toLowerCase();
+    const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
+    const segments = normalizedPath.split('/');
+    // 1. Specification
+    if (SPEC_BASENAMES.has(basename)) {
+        return make(filePath, 'specification');
+    }
+    for (const inc of SPEC_INCLUDES) {
+        if (basename.includes(inc) && (ext === '.yaml' || ext === '.yml' || ext === '.json')) {
+            return make(filePath, 'specification');
+        }
+    }
+    // 2. Metadata (business rules / integration flows)
+    if (METADATA_BASENAMES.has(basename)) {
+        return make(filePath, 'metadata');
+    }
+    // 3. Configuration
+    if (CONFIG_BASENAMES.has(basename) || ext === '.env' || basename.endsWith('.config.json') || basename.endsWith('.config.js') || basename.endsWith('.config.ts')) {
+        return make(filePath, 'configuration');
+    }
+    // 4. BDD feature files
+    if (ext === '.feature') {
+        return make(filePath, 'bdd_scenarios');
+    }
+    // 5. Contract files (*.pact.json, contracts/**/*.json)
+    if (basename.endsWith('.pact.json')) {
+        return make(filePath, 'contracts');
+    }
+    if (segments.includes('contracts') && ext === '.json') {
+        return make(filePath, 'contracts');
+    }
+    // 6. Security reports
+    for (const dir of SECURITY_REPORT_DIRS) {
+        if (segments.includes(dir) && ext === '.json') {
+            return make(filePath, 'security_reports');
+        }
+    }
+    // 7. Performance artifacts
+    for (const dir of PERFORMANCE_DIRS) {
+        if (segments.includes(dir) && (ext === '.jtl' || ext === '.json' || ext === '.csv')) {
+            return make(filePath, 'performance');
+        }
+    }
+    // 8. Test code — matches *.test.*, *.spec.*, *Test.*, *Tests.*, *Spec.*
+    const basenameOriginal = path.basename(filePath);
+    if (isTestFile(basenameOriginal)) {
+        return make(filePath, 'test_code');
+    }
+    // 9. Service code by extension
+    const SERVICE_CODE_EXTS = new Set([
+        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+        '.java', '.kt', '.kts',
+        '.py',
+        '.rb',
+        '.go',
+        '.cs',
+        '.cpp', '.cc', '.h',
+        '.rs',
+    ]);
+    if (SERVICE_CODE_EXTS.has(ext)) {
+        return make(filePath, 'service_code');
+    }
+    // 10. Unknown
+    return make(filePath, 'unknown');
+}
+/**
+ * Classify multiple file paths at once.
+ */
+function classifyFiles(filePaths) {
+    return filePaths.map(classifyFile);
+}
+/**
+ * Filter a list of classified files to only those that may contribute to
+ * coverage evidence (test_code and bdd_scenarios).
+ */
+function filterCoverageEvidence(files) {
+    return files.filter((f) => exports.COVERAGE_EVIDENCE_CATEGORIES.has(f.category));
+}
+/**
+ * Return true if this file basename looks like a test file.
+ * Supports patterns: *.test.*, *.spec.*, *Test.java, *Tests.java, *Spec.*,
+ * test_*.py, *_test.py, *_spec.rb, spec/**
+ */
+function isTestFile(basename) {
+    // Exact extension-based patterns
+    if (/\.(test|spec)\.[a-zA-Z]+$/.test(basename))
+        return true;
+    // Java / Kotlin test class conventions
+    if (/Test\.(java|kt|kts)$/.test(basename))
+        return true;
+    if (/Tests\.(java|kt|kts)$/.test(basename))
+        return true;
+    if (/Spec\.(java|kt|kts|rb|ts|js)$/.test(basename))
+        return true;
+    // Python conventions
+    if (/^test_/.test(basename))
+        return true;
+    if (/_test\.py$/.test(basename))
+        return true;
+    // Ruby conventions
+    if (/_spec\.rb$/.test(basename))
+        return true;
+    return false;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function make(filePath, category) {
+    return {
+        filePath,
+        category,
+        isCoverageEvidence: exports.COVERAGE_EVIDENCE_CATEGORIES.has(category),
+    };
+}

package/dist/src/discovery/projectDiscovery.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Agnostic Project Discovery Engine
+ *
+ * Scans the repository tree, classifies files, detects languages and test
+ * frameworks, and groups artifacts by function so each analysis pipeline
+ * receives the right inputs — even when no configuration file exists.
+ *
+ * Discovery pipeline:
+ *   project root → file system scan → file classification →
+ *   artifact grouping → language detection → framework detection
+ */
+import { ClassifiedFile } from './fileClassifier';
+export type DetectedLanguage = 'java' | 'kotlin' | 'python' | 'ruby' | 'javascript' | 'typescript' | 'go' | 'csharp';
+export type DetectedFramework = 'junit' | 'testng' | 'restassured' | 'pytest' | 'unittest' | 'rspec' | 'minitest' | 'jest' | 'mocha' | 'cypress' | 'playwright' | 'cucumber' | 'gherkin';
+export interface DiscoveredArtifacts {
+    /** Detected project root */
+    projectRoot: string;
+    /** All classified files found under the root */
+    allFiles: ClassifiedFile[];
+    /** OpenAPI / Swagger definition files */
+    specs: string[];
+    /** Test source files (test_code + bdd_scenarios) */
+    testFiles: string[];
+    /** BDD feature files specifically */
+    featureFiles: string[];
+    /** Contract files (Pact, etc.) */
+    contractFiles: string[];
+    /** Performance test result files (JMeter, k6, etc.) */
+    performanceFiles: string[];
+    /** Security scan report files */
+    securityReportFiles: string[];
+    /** Service source code files */
+    serviceFiles: string[];
+    /** Detected programming languages */
+    languages: DetectedLanguage[];
+    /** Detected test frameworks */
+    frameworks: DetectedFramework[];
+    /** Whether each artifact type was explicitly configured vs auto-discovered */
+    discoverySource: Record<keyof Omit<DiscoveredArtifacts, 'allFiles' | 'projectRoot' | 'discoverySource' | 'languages' | 'frameworks'>, 'explicit' | 'discovered'>;
+}
+export interface DiscoveryOptions {
+    /** Root directory to scan. Defaults to process.cwd() */
+    rootDir?: string;
+    /**
+     * Directories to exclude from the scan.
+     * Defaults to node_modules, .git, dist, build, target, .cache, coverage
+     */
+    excludeDirs?: string[];
+    /** Maximum depth for recursive scan. Defaults to 20 */
+    maxDepth?: number;
+    /** If provided, these paths override the auto-discovered spec files */
+    explicitSpecs?: string[];
+    /** If provided, these paths override the auto-discovered test files */
+    explicitTests?: string[];
+    /** If provided, these paths override the auto-discovered contract files */
+    explicitContracts?: string[];
+}
+/**
+ * Discover all project artifacts from `rootDir`.
+ *
+ * When explicit inputs are provided (e.g. from config.yaml), they are used
+ * directly and the corresponding discovery step is skipped. This ensures
+ * "always discovers" behaviour while respecting explicit configuration.
+ */
+export declare function discoverProject(options?: DiscoveryOptions): DiscoveredArtifacts;
+//# sourceMappingURL=projectDiscovery.d.ts.map

package/dist/src/discovery/projectDiscovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectDiscovery.d.ts","sourceRoot":"","sources":["../../../src/discovery/projectDiscovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAgB,cAAc,EAAgB,MAAM,kBAAkB,CAAC;AAI9E,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,YAAY,GACZ,YAAY,GACZ,IAAI,GACJ,QAAQ,CAAC;AAEb,MAAM,MAAM,iBAAiB,GAEzB,OAAO,GACP,QAAQ,GACR,aAAa,GAEb,QAAQ,GACR,UAAU,GAEV,OAAO,GACP,UAAU,GAEV,MAAM,GACN,OAAO,GACP,SAAS,GACT,YAAY,GAEZ,UAAU,GACV,SAAS,CAAC;AAEd,MAAM,WAAW,mBAAmB;IAClC,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,yCAAyC;IACzC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oDAAoD;IACpD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qCAAqC;IACrC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,kCAAkC;IAClC,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,uDAAuD;IACvD,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iCAAiC;IACjC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,gCAAgC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,qCAAqC;IACrC,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,+BAA+B;IAC/B,UAAU,EAAE,iBAAiB,EAAE,CAAC;IAChC,8EAA8E;IAC9E,eAAe,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,aAAa,GAAG,iBAAiB,GAAG,WAAW,GAAG,YAAY,CAAC,EAAE,UAAU,GAAG,YAAY,CAAC,CAAC;CAClK;AAED,MAAM,WAAW,gBAAgB;IAC/B,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAiHD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,mBAAmB,CA8EnF"}

package/dist/src/discovery/projectDiscovery.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * Agnostic Project Discovery Engine
+ *
+ * Scans the repository tree, classifies files, detects languages and test
+ * frameworks, and groups artifacts by function so each analysis pipeline
+ * receives the right inputs — even when no configuration file exists.
+ *
+ * Discovery pipeline:
+ *   project root → file system scan → file classification →
+ *   artifact grouping → language detection → framework detection
+ */
+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.discoverProject = discoverProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const fileClassifier_1 = require("./fileClassifier");
+// ─── Default exclude list ─────────────────────────────────────────────────────
+const DEFAULT_EXCLUDE_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'target',
+    '.cache',
+    'coverage',
+    '.nyc_output',
+    '__pycache__',
+    '.pytest_cache',
+    '.tox',
+    'vendor',
+    '.bundle',
+    '.gradle',
+]);
+// ─── Language detection ───────────────────────────────────────────────────────
+/** Map build-file basenames to language */
+const BUILD_FILE_LANGUAGE_MAP = {
+    'pom.xml': ['java'],
+    'build.gradle': ['java', 'kotlin'],
+    'build.gradle.kts': ['kotlin'],
+    'settings.gradle': ['java', 'kotlin'],
+    'gradlew': ['java', 'kotlin'],
+    'package.json': ['javascript', 'typescript'],
+    'requirements.txt': ['python'],
+    'setup.py': ['python'],
+    'setup.cfg': ['python'],
+    'pyproject.toml': ['python'],
+    'Gemfile': ['ruby'],
+    'go.mod': ['go'],
+    '*.csproj': ['csharp'],
+};
+const EXTENSION_LANGUAGE_MAP = {
+    '.java': 'java',
+    '.kt': 'kotlin',
+    '.kts': 'kotlin',
+    '.py': 'python',
+    '.rb': 'ruby',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.mjs': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.go': 'go',
+    '.cs': 'csharp',
+};
+// ─── Framework detection ──────────────────────────────────────────────────────
+/**
+ * Detect test frameworks from test file contents (first 4 KB).
+ * This is a deliberate regex-based heuristic — fast for CI usage.
+ */
+function detectFrameworksFromContent(content) {
+    const found = [];
+    if (/import\s+.*JUnit|@Test\b|@RunWith/.test(content))
+        found.push('junit');
+    if (/testng|@Test.*groups/.test(content))
+        found.push('testng');
+    if (/RestAssured|given\(\)|when\(\)|then\(\)/.test(content))
+        found.push('restassured');
+    if (/import\s+pytest|def\s+test_/.test(content))
+        found.push('pytest');
+    if (/import\s+unittest|class\s+\w+\(.*TestCase\)/.test(content))
+        found.push('unittest');
+    if (/RSpec\.describe|describe\s+['"]/.test(content))
+        found.push('rspec');
+    if (/Minitest::Test|test\s+"/.test(content))
+        found.push('minitest');
+    if (/describe\(|it\(|expect\(|jest\./.test(content))
+        found.push('jest');
+    if (/require\('mocha'\)|describe\(.*done\)|it\(.*done/.test(content))
+        found.push('mocha');
+    if (/cy\.|Cypress\./.test(content))
+        found.push('cypress');
+    if (/test\.goto|page\.click|playwright/.test(content))
+        found.push('playwright');
+    if (/Given|When|Then|Scenario:/.test(content))
+        found.push('cucumber');
+    return found;
+}
+// ─── File system scanner ─────────────────────────────────────────────────────
+/**
+ * Recursively collect all file paths under `dir`, respecting excludes and depth.
+ */
+function scanDirectory(dir, excludeDirs, maxDepth, currentDepth = 0) {
+    if (currentDepth > maxDepth)
+        return [];
+    let results = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') && entry.name !== '.env')
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!excludeDirs.has(entry.name)) {
+                results = results.concat(scanDirectory(fullPath, excludeDirs, maxDepth, currentDepth + 1));
+            }
+        }
+        else if (entry.isFile()) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+// ─── Discovery engine ─────────────────────────────────────────────────────────
+/**
+ * Discover all project artifacts from `rootDir`.
+ *
+ * When explicit inputs are provided (e.g. from config.yaml), they are used
+ * directly and the corresponding discovery step is skipped. This ensures
+ * "always discovers" behaviour while respecting explicit configuration.
+ */
+function discoverProject(options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const rootDir = (_a = options.rootDir) !== null && _a !== void 0 ? _a : process.cwd();
+    const excludeDirs = new Set([
+        ...DEFAULT_EXCLUDE_DIRS,
+        ...((_b = options.excludeDirs) !== null && _b !== void 0 ? _b : []),
+    ]);
+    const maxDepth = (_c = options.maxDepth) !== null && _c !== void 0 ? _c : 20;
+    // ── Scan + classify ────────────────────────────────────────────────────────
+    const rawPaths = scanDirectory(rootDir, excludeDirs, maxDepth);
+    const allFiles = rawPaths.map(fileClassifier_1.classifyFile);
+    const byCategory = groupByCategory(allFiles);
+    // ── Artifact resolution ────────────────────────────────────────────────────
+    const discoverySource = {
+        specs: 'discovered',
+        testFiles: 'discovered',
+        featureFiles: 'discovered',
+        contractFiles: 'discovered',
+        performanceFiles: 'discovered',
+        securityReportFiles: 'discovered',
+        serviceFiles: 'discovered',
+    };
+    let specs = paths((_d = byCategory.specification) !== null && _d !== void 0 ? _d : []);
+    if (options.explicitSpecs && options.explicitSpecs.length > 0) {
+        specs = options.explicitSpecs;
+        discoverySource.specs = 'explicit';
+    }
+    const featureFiles = paths((_e = byCategory.bdd_scenarios) !== null && _e !== void 0 ? _e : []);
+    let testFiles = [
+        ...paths((_f = byCategory.test_code) !== null && _f !== void 0 ? _f : []),
+        ...featureFiles,
+    ];
+    if (options.explicitTests && options.explicitTests.length > 0) {
+        testFiles = options.explicitTests;
+        discoverySource.testFiles = 'explicit';
+        discoverySource.featureFiles = 'explicit';
+    }
+    let contractFiles = paths((_g = byCategory.contracts) !== null && _g !== void 0 ? _g : []);
+    if (options.explicitContracts && options.explicitContracts.length > 0) {
+        contractFiles = options.explicitContracts;
+        discoverySource.contractFiles = 'explicit';
+    }
+    const performanceFiles = paths((_h = byCategory.performance) !== null && _h !== void 0 ? _h : []);
+    const securityReportFiles = paths((_j = byCategory.security_reports) !== null && _j !== void 0 ? _j : []);
+    const serviceFiles = paths((_k = byCategory.service_code) !== null && _k !== void 0 ? _k : []);
+    // ── Language detection ─────────────────────────────────────────────────────
+    const languages = detectLanguages(rawPaths);
+    // ── Framework detection ────────────────────────────────────────────────────
+    const frameworks = detectFrameworks(testFiles);
+    // Add 'cucumber' when feature files are present
+    if (featureFiles.length > 0 && !frameworks.includes('cucumber')) {
+        frameworks.push('cucumber');
+    }
+    return {
+        projectRoot: rootDir,
+        allFiles,
+        specs,
+        testFiles,
+        featureFiles,
+        contractFiles,
+        performanceFiles,
+        securityReportFiles,
+        serviceFiles,
+        languages: [...new Set(languages)],
+        frameworks: [...new Set(frameworks)],
+        discoverySource,
+    };
+}
+// ─── Language detection helpers ───────────────────────────────────────────────
+function detectLanguages(filePaths) {
+    const found = new Set();
+    for (const fp of filePaths) {
+        const basename = path.basename(fp);
+        const ext = path.extname(fp);
+        // Check build file mapping
+        const byBuild = BUILD_FILE_LANGUAGE_MAP[basename];
+        if (byBuild) {
+            byBuild.forEach((lang) => found.add(lang));
+        }
+        // Check extension mapping
+        const byExt = EXTENSION_LANGUAGE_MAP[ext];
+        if (byExt) {
+            found.add(byExt);
+        }
+    }
+    return [...found];
+}
+// ─── Framework detection helpers ──────────────────────────────────────────────
+function detectFrameworks(testFilePaths) {
+    const found = new Set();
+    // Sample up to 50 test files to limit I/O
+    const sample = testFilePaths.slice(0, 50);
+    for (const fp of sample) {
+        try {
+            const content = fs.readFileSync(fp, 'utf-8').slice(0, 4096);
+            for (const fw of detectFrameworksFromContent(content)) {
+                found.add(fw);
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return [...found];
+}
+// ─── Utility ─────────────────────────────────────────────────────────────────
+function groupByCategory(files) {
+    const groups = {};
+    for (const f of files) {
+        if (!groups[f.category])
+            groups[f.category] = [];
+        groups[f.category].push(f);
+    }
+    return groups;
+}
+function paths(files) {
+    return files.map((f) => f.filePath);
+}