api-tests-coverage 1.0.0

package/dist/src/languageDetection.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Language detection and language-specific HTTP call extraction for the
+ * API test coverage analyzer.
+ *
+ * Supports: JavaScript, TypeScript, Java, Kotlin, Python, Ruby, Cucumber.
+ */
+export type SupportedLanguage = 'javascript' | 'typescript' | 'java' | 'kotlin' | 'python' | 'ruby' | 'cucumber' | 'auto';
+export declare const SUPPORTED_LANGUAGES: SupportedLanguage[];
+export interface HttpCall {
+    method: string;
+    path: string;
+}
+/**
+ * Detect the language of a single file from its extension.
+ * Returns `null` if the extension is not recognised.
+ */
+export declare function detectLanguageFromExtension(filePath: string): SupportedLanguage | null;
+/**
+ * Detect all languages present in a list of file paths.
+ */
+export declare function detectLanguages(filePaths: string[]): SupportedLanguage[];
+/**
+ * Return the default glob patterns used to locate test files for a given language.
+ */
+export declare function getDefaultGlobsForLanguage(language: SupportedLanguage): string[];
+/**
+ * Extract HTTP calls from JavaScript/TypeScript test content.
+ *
+ * Detects patterns like:
+ *   - `GET /users` (string literals)
+ *   - `fetch('/users', { method: 'GET' })`
+ *   - `supertest(app).get('/users')`
+ *   - `axios.get('/users')`
+ */
+export declare function extractHttpCallsFromJs(content: string): HttpCall[];
+/**
+ * Extract HTTP calls from Java/Kotlin test content.
+ *
+ * Detects:
+ *   - RestAssured: `given().when().get("/path")`, `.when().post("/path")`
+ *   - Spring MockMvc: `perform(get("/path"))`, `perform(MockMvcRequestBuilders.get(...))`
+ *   - WebTestClient: `webTestClient.get().uri("/path")`
+ *   - OkHttp / Ktor: `client.get("/path")`
+ *   - Generic strings: `"GET /path"`
+ */
+export declare function extractHttpCallsFromJava(content: string): HttpCall[];
+/**
+ * Extract HTTP calls from Python test content.
+ *
+ * Detects:
+ *   - `requests.get('/path')`, `requests.post('/path')`, etc.
+ *   - `httpx.get('/path')`
+ *   - `client.get('/path')` (Flask/Django test client)
+ *   - `self.client.get('/path')`
+ *   - `response = client.get('/api/users')`
+ */
+export declare function extractHttpCallsFromPython(content: string): HttpCall[];
+/**
+ * Extract HTTP calls from Ruby test content.
+ *
+ * Detects:
+ *   - Rails request specs / integration tests: `get '/path'`, `post '/path'`
+ *   - HTTParty: `HTTParty.get('/path')`
+ *   - Faraday: `conn.get('/path')`
+ *   - Net::HTTP (generic patterns)
+ *   - Generic "METHOD /path" strings
+ */
+export declare function extractHttpCallsFromRuby(content: string): HttpCall[];
+/**
+ * Extract HTTP calls from Cucumber feature files and step definition files.
+ *
+ * Detects:
+ *   - Gherkin steps: `When I send a GET request to "/users"`
+ *   - Gherkin steps: `When I call "GET /users"`
+ *   - Step definition files in any supported language (falls through to respective extractor)
+ */
+export declare function extractHttpCallsFromCucumber(content: string): HttpCall[];
+/**
+ * Extract HTTP calls from file content using the most appropriate strategy
+ * for the detected or specified language.
+ */
+export declare function extractHttpCalls(content: string, language: SupportedLanguage): HttpCall[];
+/**
+ * Parse a `--language` CLI option value into an array of `SupportedLanguage` values.
+ *
+ * Accepts:
+ *   - A single value: `java`
+ *   - A comma-separated list: `java,kotlin`
+ *   - Multiple invocations are handled by Commander's `.collect()` middleware
+ *
+ * @throws if no valid languages are found in the input.
+ */
+export declare function parseLanguageOption(value: string): SupportedLanguage[];
+/**
+ * Extract the path portion from a URL string.
+ * If the string is already a path (starts with `/`), it is returned as-is.
+ * Full URLs like `http://localhost:8080/api/users` → `/api/users`.
+ */
+export declare function extractPathFromUrl(urlOrPath: string): string;
+//# sourceMappingURL=languageDetection.d.ts.map

package/dist/src/languageDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageDetection.d.ts","sourceRoot":"","sources":["../../src/languageDetection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ,YAAY,GACZ,MAAM,GACN,QAAQ,GACR,QAAQ,GACR,MAAM,GACN,UAAU,GACV,MAAM,CAAC;AAEX,eAAO,MAAM,mBAAmB,EAAE,iBAAiB,EASlD,CAAC;AAEF,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd;AAiBD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAKtF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE,CAOxE;AAID;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,EAAE,CA4BhF;AAID;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CA0BlE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CAyCpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CA6BtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CA6BpE;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,EAAE,CAsBxE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CAkBzF;AAID;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAatE;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAO5D"}

package/dist/src/languageDetection.js

@@ -0,0 +1,349 @@
+"use strict";
+/**
+ * Language detection and language-specific HTTP call extraction for the
+ * API test coverage analyzer.
+ *
+ * Supports: JavaScript, TypeScript, Java, Kotlin, Python, Ruby, Cucumber.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_LANGUAGES = void 0;
+exports.detectLanguageFromExtension = detectLanguageFromExtension;
+exports.detectLanguages = detectLanguages;
+exports.getDefaultGlobsForLanguage = getDefaultGlobsForLanguage;
+exports.extractHttpCallsFromJs = extractHttpCallsFromJs;
+exports.extractHttpCallsFromJava = extractHttpCallsFromJava;
+exports.extractHttpCallsFromPython = extractHttpCallsFromPython;
+exports.extractHttpCallsFromRuby = extractHttpCallsFromRuby;
+exports.extractHttpCallsFromCucumber = extractHttpCallsFromCucumber;
+exports.extractHttpCalls = extractHttpCalls;
+exports.parseLanguageOption = parseLanguageOption;
+exports.extractPathFromUrl = extractPathFromUrl;
+exports.SUPPORTED_LANGUAGES = [
+    'javascript',
+    'typescript',
+    'java',
+    'kotlin',
+    'python',
+    'ruby',
+    'cucumber',
+    'auto',
+];
+// ─── Extension → language mapping ─────────────────────────────────────────────
+const EXTENSION_TO_LANGUAGE = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.java': 'java',
+    '.kt': 'kotlin',
+    '.kts': 'kotlin',
+    '.py': 'python',
+    '.rb': 'ruby',
+    '.feature': 'cucumber',
+};
+/**
+ * Detect the language of a single file from its extension.
+ * Returns `null` if the extension is not recognised.
+ */
+function detectLanguageFromExtension(filePath) {
+    var _a;
+    const dotIndex = filePath.lastIndexOf('.');
+    if (dotIndex === -1)
+        return null;
+    const ext = filePath.slice(dotIndex).toLowerCase();
+    return (_a = EXTENSION_TO_LANGUAGE[ext]) !== null && _a !== void 0 ? _a : null;
+}
+/**
+ * Detect all languages present in a list of file paths.
+ */
+function detectLanguages(filePaths) {
+    const langs = new Set();
+    for (const fp of filePaths) {
+        const lang = detectLanguageFromExtension(fp);
+        if (lang)
+            langs.add(lang);
+    }
+    return Array.from(langs);
+}
+// ─── Default glob patterns per language ───────────────────────────────────────
+/**
+ * Return the default glob patterns used to locate test files for a given language.
+ */
+function getDefaultGlobsForLanguage(language) {
+    switch (language) {
+        case 'java':
+            return ['**/*Test.java', '**/*Tests.java', '**/*Spec.java', '**/test/**/*.java', '**/tests/**/*.java'];
+        case 'kotlin':
+            return ['**/*Test.kt', '**/*Tests.kt', '**/*Spec.kt', '**/test/**/*.kt', '**/tests/**/*.kt'];
+        case 'python':
+            return ['**/test_*.py', '**/*_test.py', '**/tests/**/*.py', '**/test/**/*.py'];
+        case 'ruby':
+            return ['**/*_spec.rb', '**/spec/**/*.rb', '**/test/**/*.rb'];
+        case 'cucumber':
+            return ['**/*.feature', '**/step_definitions/**/*.rb', '**/step_definitions/**/*.java', '**/step_definitions/**/*.py', '**/step_definitions/**/*.kt'];
+        case 'typescript':
+            return ['**/*.test.ts', '**/*.spec.ts', '**/tests/**/*.ts'];
+        case 'javascript':
+            return ['**/*.test.js', '**/*.spec.js', '**/tests/**/*.js'];
+        case 'auto':
+        default:
+            return [
+                '**/*.test.ts', '**/*.spec.ts', '**/tests/**/*.ts',
+                '**/*.test.js', '**/*.spec.js', '**/tests/**/*.js',
+                '**/*Test.java', '**/*Tests.java', '**/test/**/*.java',
+                '**/*Test.kt', '**/*Spec.kt', '**/test/**/*.kt',
+                '**/test_*.py', '**/*_test.py', '**/tests/**/*.py',
+                '**/*_spec.rb', '**/spec/**/*.rb',
+                '**/*.feature',
+            ];
+    }
+}
+// ─── HTTP call extraction ─────────────────────────────────────────────────────
+/**
+ * Extract HTTP calls from JavaScript/TypeScript test content.
+ *
+ * Detects patterns like:
+ *   - `GET /users` (string literals)
+ *   - `fetch('/users', { method: 'GET' })`
+ *   - `supertest(app).get('/users')`
+ *   - `axios.get('/users')`
+ */
+function extractHttpCallsFromJs(content) {
+    const calls = [];
+    // Bare "METHOD /path" string (e.g. in test descriptions or request helpers)
+    const bare = /\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\s+(\/[^\s'"`,)]*)/gi;
+    let m;
+    while ((m = bare.exec(content)) !== null) {
+        const p = m[2];
+        if (!p.includes('{')) {
+            calls.push({ method: m[1].toUpperCase(), path: p });
+        }
+    }
+    // axios / superagent / got: axios.get('/path'), axios.post('/path')
+    const axiosLike = /\b(?:axios|request|supertest|got|agent)\.(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+    while ((m = axiosLike.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // supertest(app).get('/path')
+    const supertestChain = /\)\s*\.(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+    while ((m = supertestChain.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    return deduplicateCalls(calls);
+}
+/**
+ * Extract HTTP calls from Java/Kotlin test content.
+ *
+ * Detects:
+ *   - RestAssured: `given().when().get("/path")`, `.when().post("/path")`
+ *   - Spring MockMvc: `perform(get("/path"))`, `perform(MockMvcRequestBuilders.get(...))`
+ *   - WebTestClient: `webTestClient.get().uri("/path")`
+ *   - OkHttp / Ktor: `client.get("/path")`
+ *   - Generic strings: `"GET /path"`
+ */
+function extractHttpCallsFromJava(content) {
+    const calls = [];
+    let m;
+    // RestAssured: .when().get("/path")
+    const raWhen = /\.when\(\)\s*\.\s*(get|post|put|patch|delete|head|options)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = raWhen.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // RestAssured shorthand: given().get("/path") or RestAssured.get("/path")
+    const raGiven = /(?:given\(\)|RestAssured)[^;.(]*\.(get|post|put|patch|delete|head|options)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = raGiven.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // Spring MockMvc / WebMvcTest: perform(get("/path"))
+    const mockMvc = /perform\s*\(\s*(?:\w+\s*\.\s*)?(get|post|put|patch|delete|head|options)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = mockMvc.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // WebTestClient: webTestClient.get().uri("/path")
+    const webTest = /webTestClient\s*\.\s*(get|post|put|patch|delete|head|options)\s*\(\s*\)\s*\.uri\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = webTest.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // OkHttp / Ktor client: client.get("/path")
+    const okHttp = /\bclient\s*\.\s*(get|post|put|patch|delete|head|options)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = okHttp.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // Generic quoted "METHOD /path"
+    const generic = /["'`](GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\s+(\/[^"'`\s]+)["'`]/gi;
+    while ((m = generic.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    return deduplicateCalls(calls);
+}
+/**
+ * Extract HTTP calls from Python test content.
+ *
+ * Detects:
+ *   - `requests.get('/path')`, `requests.post('/path')`, etc.
+ *   - `httpx.get('/path')`
+ *   - `client.get('/path')` (Flask/Django test client)
+ *   - `self.client.get('/path')`
+ *   - `response = client.get('/api/users')`
+ */
+function extractHttpCallsFromPython(content) {
+    const calls = [];
+    let m;
+    // requests.METHOD('/path')
+    const reqPattern = /\brequests\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/gi;
+    while ((m = reqPattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // httpx.METHOD('/path')
+    const httpxPattern = /\bhttpx\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/gi;
+    while ((m = httpxPattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // client.METHOD('/path'), self.client.METHOD('/path')
+    const clientPattern = /(?:self\.)?\bclient\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/gi;
+    while ((m = clientPattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // Generic "METHOD /path"
+    const generic = /['"]?(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\s+(\/[^'")\s]+)['"]?/gi;
+    while ((m = generic.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    return deduplicateCalls(calls);
+}
+/**
+ * Extract HTTP calls from Ruby test content.
+ *
+ * Detects:
+ *   - Rails request specs / integration tests: `get '/path'`, `post '/path'`
+ *   - HTTParty: `HTTParty.get('/path')`
+ *   - Faraday: `conn.get('/path')`
+ *   - Net::HTTP (generic patterns)
+ *   - Generic "METHOD /path" strings
+ */
+function extractHttpCallsFromRuby(content) {
+    const calls = [];
+    let m;
+    // Rails request specs: get '/path', post '/path', etc.
+    const railsPattern = /\b(get|post|put|patch|delete|head|options)\s+['"]([^'"]+)['"]/gi;
+    while ((m = railsPattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // HTTParty: HTTParty.get('/path')
+    const httpartyPattern = /HTTParty\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/gi;
+    while ((m = httpartyPattern.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // Faraday: conn.get('/path'), connection.post('/path')
+    const faradaySimple = /(?:conn|connection|faraday)\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/gi;
+    while ((m = faradaySimple.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: extractPathFromUrl(m[2]) });
+    }
+    // Generic "METHOD /path"
+    const generic = /["'](GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\s+(\/[^"'\s]+)["']/gi;
+    while ((m = generic.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    return deduplicateCalls(calls);
+}
+/**
+ * Extract HTTP calls from Cucumber feature files and step definition files.
+ *
+ * Detects:
+ *   - Gherkin steps: `When I send a GET request to "/users"`
+ *   - Gherkin steps: `When I call "GET /users"`
+ *   - Step definition files in any supported language (falls through to respective extractor)
+ */
+function extractHttpCallsFromCucumber(content) {
+    const calls = [];
+    let m;
+    // "When I send a GET request to /users" or "When I make a POST request to /users"
+    const gherkin1 = /\b(?:When|Given|Then|And)\s+I\s+(?:send|make|perform)\s+(?:an?\s+)?["']?(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)["']?\s+request\s+to\s+["']?(\/[^"'\s]+)["']?/gi;
+    while ((m = gherkin1.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // 'When I call "GET /users"'
+    const gherkin2 = /\b(?:When|Given|Then|And)[^"']*["'](GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|TRACE)\s+(\/[^"'\s]+)["']/gi;
+    while ((m = gherkin2.exec(content)) !== null) {
+        calls.push({ method: m[1].toUpperCase(), path: m[2] });
+    }
+    // Also apply language-specific extractors (for step definition files)
+    calls.push(...extractHttpCallsFromJava(content));
+    calls.push(...extractHttpCallsFromPython(content));
+    calls.push(...extractHttpCallsFromRuby(content));
+    return deduplicateCalls(calls);
+}
+/**
+ * Extract HTTP calls from file content using the most appropriate strategy
+ * for the detected or specified language.
+ */
+function extractHttpCalls(content, language) {
+    switch (language) {
+        case 'java':
+        case 'kotlin':
+            return extractHttpCallsFromJava(content);
+        case 'python':
+            return extractHttpCallsFromPython(content);
+        case 'ruby':
+            return extractHttpCallsFromRuby(content);
+        case 'cucumber':
+            return extractHttpCallsFromCucumber(content);
+        case 'typescript':
+        case 'javascript':
+        case 'auto':
+        default:
+            // For 'auto', use JS patterns (good for TS/JS) as the baseline
+            return extractHttpCallsFromJs(content);
+    }
+}
+// ─── CLI option parsing ────────────────────────────────────────────────────────
+/**
+ * Parse a `--language` CLI option value into an array of `SupportedLanguage` values.
+ *
+ * Accepts:
+ *   - A single value: `java`
+ *   - A comma-separated list: `java,kotlin`
+ *   - Multiple invocations are handled by Commander's `.collect()` middleware
+ *
+ * @throws if no valid languages are found in the input.
+ */
+function parseLanguageOption(value) {
+    const parts = value
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter(Boolean);
+    const valid = parts.filter((p) => exports.SUPPORTED_LANGUAGES.includes(p));
+    if (valid.length === 0) {
+        throw new Error(`Invalid language value: "${value}". Supported values: ${exports.SUPPORTED_LANGUAGES.join(', ')}`);
+    }
+    return valid;
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Extract the path portion from a URL string.
+ * If the string is already a path (starts with `/`), it is returned as-is.
+ * Full URLs like `http://localhost:8080/api/users` → `/api/users`.
+ */
+function extractPathFromUrl(urlOrPath) {
+    if (urlOrPath.startsWith('/'))
+        return urlOrPath;
+    try {
+        return new URL(urlOrPath).pathname;
+    }
+    catch {
+        return urlOrPath;
+    }
+}
+/**
+ * Remove duplicate HTTP calls (same method + path).
+ */
+function deduplicateCalls(calls) {
+    const seen = new Set();
+    return calls.filter((c) => {
+        const key = `${c.method}:${c.path}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/src/languages/java/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Java language analyzer.
+ * Uses tree-sitter-java for AST parsing.
+ */
+import type { LanguageAnalyzer } from '../../ast/languageAnalyzer';
+import type { SupportedLanguage, ParsedSourceFile, SemanticModel, ResolvedHttpInteraction, SemanticAssertion, BusinessRuleRef, FlowRef, AnalysisContext } from '../../ast/astTypes';
+export declare class JavaAnalyzer implements LanguageAnalyzer {
+    readonly language: SupportedLanguage;
+    parse(filePath: string, content: string): ParsedSourceFile;
+    buildSemanticModel(parsed: ParsedSourceFile, _context: AnalysisContext): SemanticModel;
+    extractHttpInteractions(model: SemanticModel, _context: AnalysisContext): ResolvedHttpInteraction[];
+    extractAssertions(model: SemanticModel): SemanticAssertion[];
+    extractBusinessRuleRefs(model: SemanticModel): BusinessRuleRef[];
+    extractFlowRefs(model: SemanticModel): FlowRef[];
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/languages/java/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/languages/java/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,uBAAuB,EACvB,iBAAiB,EACjB,eAAe,EACf,OAAO,EACP,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAY5B,qBAAa,YAAa,YAAW,gBAAgB;IACnD,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAU;IAE9C,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB;IAI1D,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,eAAe,GAAG,aAAa;IA0BtF,uBAAuB,CACrB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,eAAe,GACxB,uBAAuB,EAAE;IAoC5B,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,iBAAiB,EAAE;IAI5D,uBAAuB,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,EAAE;IAIhE,eAAe,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,EAAE;CAGjD"}

package/dist/src/languages/java/index.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Java language analyzer.
+ * Uses tree-sitter-java for AST parsing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JavaAnalyzer = void 0;
+const parserRegistry_1 = require("../../ast/parserRegistry");
+const parser_1 = require("./parser");
+const semanticBuilder_1 = require("./semanticBuilder");
+const resolvePaths_1 = require("../../coverage/deep-analysis/resolvePaths");
+class JavaAnalyzer {
+    constructor() {
+        this.language = 'java';
+    }
+    parse(filePath, content) {
+        return (0, parser_1.parseJava)(filePath, content);
+    }
+    buildSemanticModel(parsed, _context) {
+        var _a, _b;
+        const root = (_b = (_a = parsed.ast) === null || _a === void 0 ? void 0 : _a.rootNode) !== null && _b !== void 0 ? _b : parsed.ast;
+        if (!root) {
+            return emptyModel(parsed.filePath, 'java');
+        }
+        const { constants, enums } = (0, semanticBuilder_1.extractJavaSymbols)(root);
+        const functions = (0, semanticBuilder_1.extractJavaFunctions)(root, constants);
+        const assertions = (0, semanticBuilder_1.extractJavaAssertions)(root);
+        const businessRuleRefs = (0, semanticBuilder_1.extractJavaBusinessRuleRefs)(root);
+        const flowRefs = (0, semanticBuilder_1.extractJavaFlowRefs)(root);
+        return {
+            filePath: parsed.filePath,
+            language: 'java',
+            localVariables: new Map(),
+            constants,
+            enums,
+            functions,
+            httpInteractions: [],
+            assertions,
+            businessRuleRefs,
+            flowRefs,
+        };
+    }
+    extractHttpInteractions(model, _context) {
+        var _a;
+        const results = [];
+        const seen = new Set();
+        function add(call) {
+            var _a;
+            const key = `${call.method}:${(_a = call.normalizedPath) !== null && _a !== void 0 ? _a : call.path}`;
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            results.push(call);
+        }
+        for (const fn of model.functions.values()) {
+            for (const c of fn.bodyHttpCalls) {
+                const path = (_a = c.resolvedPath) !== null && _a !== void 0 ? _a : c.rawPathArg;
+                if (!path)
+                    continue;
+                const normalizedPath = path.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(path) : undefined;
+                add({
+                    method: c.method,
+                    path,
+                    normalizedPath,
+                    sourceFile: model.filePath,
+                    sourceLanguage: 'java',
+                    resolutionType: c.resolutionType,
+                    confidence: c.confidence,
+                    assertionLinked: false,
+                    rawCall: c.rawPathArg,
+                    // Cucumber metadata
+                    ...(fn.cucumberPattern ? { resolutionType: 'cucumber-step' } : {}),
+                });
+            }
+        }
+        return results;
+    }
+    extractAssertions(model) {
+        return model.assertions;
+    }
+    extractBusinessRuleRefs(model) {
+        return model.businessRuleRefs;
+    }
+    extractFlowRefs(model) {
+        return model.flowRefs;
+    }
+}
+exports.JavaAnalyzer = JavaAnalyzer;
+function emptyModel(filePath, language) {
+    return {
+        filePath,
+        language,
+        localVariables: new Map(),
+        constants: new Map(),
+        enums: new Map(),
+        functions: new Map(),
+        httpInteractions: [],
+        assertions: [],
+        businessRuleRefs: [],
+        flowRefs: [],
+    };
+}
+(0, parserRegistry_1.registerAnalyzer)('java', () => new JavaAnalyzer());

package/dist/src/languages/java/parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Java AST parser.
+ * Uses tree-sitter-java with lazy loading; sets parseError on failure.
+ */
+import type { ParsedSourceFile } from '../../ast/astTypes';
+export declare function parseJava(filePath: string, content: string): ParsedSourceFile;
+//# sourceMappingURL=parser.d.ts.map

package/dist/src/languages/java/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../../src/languages/java/parser.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAoB3D,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,gBAAgB,CAwB7E"}

package/dist/src/languages/java/parser.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Java AST parser.
+ * Uses tree-sitter-java with lazy loading; sets parseError on failure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJava = parseJava;
+const treeSitterUtils_1 = require("../shared/treeSitterUtils");
+let cachedParser = undefined;
+let parserLoaded = false;
+function getJavaParser() {
+    if (!parserLoaded) {
+        parserLoaded = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const grammar = require('tree-sitter-java');
+            cachedParser = (0, treeSitterUtils_1.createParser)(grammar);
+        }
+        catch {
+            cachedParser = null;
+        }
+    }
+    return cachedParser;
+}
+function parseJava(filePath, content) {
+    const parser = getJavaParser();
+    if (!parser) {
+        return {
+            filePath,
+            language: 'java',
+            ast: null,
+            content,
+            parseError: new Error('tree-sitter-java not available'),
+        };
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const tree = parser.parse(content);
+        return { filePath, language: 'java', ast: tree, content };
+    }
+    catch (err) {
+        return {
+            filePath,
+            language: 'java',
+            ast: null,
+            content,
+            parseError: err instanceof Error ? err : new Error(String(err)),
+        };
+    }
+}

package/dist/src/languages/java/semanticBuilder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Java semantic model builder.
+ *
+ * Walks the tree-sitter Java CST to extract:
+ *   - static final String constants and enum members
+ *   - method definitions with their HTTP call bodies
+ *   - assertion patterns
+ *   - Cucumber step definition annotations
+ */
+import type { SemanticSymbol, SemanticFunction, SemanticHttpCall, SemanticAssertion, BusinessRuleRef, FlowRef } from '../../ast/astTypes';
+import { type TsNode } from '../shared/treeSitterUtils';
+export declare function extractJavaSymbols(root: TsNode): {
+    constants: Map<string, SemanticSymbol>;
+    enums: Map<string, Map<string, string>>;
+};
+export declare function extractJavaFunctions(root: TsNode, constants: Map<string, SemanticSymbol>): Map<string, SemanticFunction>;
+export declare function extractJavaHttpCalls(block: TsNode, constants: Map<string, SemanticSymbol>, out: SemanticHttpCall[]): void;
+export declare function extractJavaAssertions(root: TsNode): SemanticAssertion[];
+export declare function extractJavaBusinessRuleRefs(root: TsNode): BusinessRuleRef[];
+export declare function extractJavaFlowRefs(root: TsNode): FlowRef[];
+//# sourceMappingURL=semanticBuilder.d.ts.map

package/dist/src/languages/java/semanticBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semanticBuilder.d.ts","sourceRoot":"","sources":["../../../../src/languages/java/semanticBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAEV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,OAAO,EACR,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKL,KAAK,MAAM,EACZ,MAAM,2BAA2B,CAAC;AAOnC,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GACX;IAAE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAmErF;AAID,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,GACrC,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAqC/B;AAID,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,EACtC,GAAG,EAAE,gBAAgB,EAAE,GACtB,IAAI,CA6DN;AAID,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAyBvE;AAID,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,EAAE,CAa3E;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,EAAE,CAa3D"}