api-tests-coverage 1.0.0

package/dist/src/coverage/deep-analysis/resolveAssertions.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Deep Code Analysis — Assertion Awareness
+ *
+ * Associates HTTP response variables with their downstream assertions to
+ * determine whether a request is "meaningfully" tested (i.e. the response
+ * is actually checked) rather than just called incidentally.
+ *
+ * Supported patterns:
+ *
+ * TypeScript (Jest / Supertest):
+ *   const response = api.get('/users');
+ *   expect(response.status).toBe(200);
+ *   expect(response.body).toEqual({ ... });
+ *
+ * Java (JUnit / RestAssured):
+ *   Response response = api.get("/users");
+ *   assertEquals(200, response.getStatusCode());
+ *   assertThat(response.getBody(), ...).isNotEmpty();
+ *
+ * Python (pytest / unittest):
+ *   response = client.get('/users')
+ *   assert response.status_code == 200
+ *   self.assertEqual(response.status_code, 200)
+ *
+ * Kotlin:
+ *   val response = client.get("/users")
+ *   assertEquals(200, response.status)
+ *   assertThat(response.body).isNotNull()
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssertionLinked = isAssertionLinked;
+exports.extractResponseVariables = extractResponseVariables;
+exports.buildAssertionMap = buildAssertionMap;
+// ─── Assertion detection ──────────────────────────────────────────────────────
+/**
+ * Detect whether a response variable is followed by at least one assertion.
+ *
+ * This is a lightweight heuristic: we check whether the response variable
+ * name appears inside an expect(), assert, assertEquals, assertThat, or
+ * similar assertion call within the same file.
+ *
+ * Returns true when at least one assertion is found.
+ */
+function isAssertionLinked(responseVar, content) {
+    if (!responseVar)
+        return false;
+    // TypeScript/JS: expect(responseName.xxx)
+    const jsExpect = new RegExp(`\\bexpect\\s*\\(\\s*${escapeRegex(responseVar)}\\b`, 'g');
+    if (jsExpect.test(content))
+        return true;
+    // Java/Kotlin: assertEquals(xxx, responseName.getXxx())
+    //              assertThat(responseName.xxx)
+    const javaAssert = new RegExp(`\\b(?:assertEquals|assertNotNull|assertThat|assertFalse|assertTrue|assertNull)\\s*\\([^)]*\\b${escapeRegex(responseVar)}\\b`, 'g');
+    if (javaAssert.test(content))
+        return true;
+    // Python: assert responseName.status_code
+    const pyAssert = new RegExp(`\\bassert\\s+${escapeRegex(responseVar)}\\b`, 'g');
+    if (pyAssert.test(content))
+        return true;
+    // Python unittest: self.assertEqual(xxx, responseName.xxx)
+    const pyUnitAssert = new RegExp(`\\bself\\.assert(?:Equal|NotEqual|In|NotIn|True|False)\\s*\\([^)]*\\b${escapeRegex(responseVar)}\\b`, 'g');
+    if (pyUnitAssert.test(content))
+        return true;
+    // Kotlin / Java: response.status shouldBe 200 (Kotest)
+    const kotestAssert = new RegExp(`\\b${escapeRegex(responseVar)}\\b[^\\n]*\\bshould`, 'g');
+    if (kotestAssert.test(content))
+        return true;
+    // RestAssured: .then().statusCode(200) chained on the same variable
+    const raAssert = new RegExp(`\\b${escapeRegex(responseVar)}\\b[^\\n]*\\.then\\(\\)`, 'g');
+    if (raAssert.test(content))
+        return true;
+    return false;
+}
+/**
+ * Extract all response variable names from HTTP call sites in a file.
+ *
+ * Returns a map of varName → { method, path } for all assignments like:
+ *   const resp = client.get('/users')
+ *   Response res = api.post("/users")
+ *   response = client.get('/path')
+ */
+function extractResponseVariables(content) {
+    const results = [];
+    // TypeScript/JavaScript: const|let|var response = ....(get|post|...)(path)
+    const jsPattern = /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:\w+\.)+?(get|post|put|patch|delete|head|options)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+    let m;
+    while ((m = jsPattern.exec(content)) !== null) {
+        results.push({ varName: m[1], method: m[2].toUpperCase(), path: m[3] });
+    }
+    // Java/Kotlin: Type varName = ....(get|post|...)(path)
+    // Allow method calls with () in the chain: given(), spec(), etc.
+    const javaPattern = /\b(?:Response|HttpResponse|MockHttpServletResponse|ResponseEntity|ValidatableResponse|ExtractableResponse)\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:\w+(?:\([^)]*\))?[.\s]+)*(get|post|put|patch|delete|head|options)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = javaPattern.exec(content)) !== null) {
+        results.push({ varName: m[1], method: m[2].toUpperCase(), path: m[3] });
+    }
+    // Python: response = client.get('/path')  or  res = requests.post('/path')
+    const pyPattern = /^(\s*)([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:self\.)?(?:client|requests?|httpx)\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/gm;
+    while ((m = pyPattern.exec(content)) !== null) {
+        results.push({ varName: m[2], method: m[3].toUpperCase(), path: m[4] });
+    }
+    return results;
+}
+/**
+ * For each response variable in the content, determine if it has an
+ * associated assertion.
+ *
+ * Returns a map: varName → assertionLinked (boolean)
+ */
+function buildAssertionMap(content) {
+    const responseVars = extractResponseVariables(content);
+    const map = new Map();
+    for (const { varName } of responseVars) {
+        map.set(varName, isAssertionLinked(varName, content));
+    }
+    return map;
+}
+// ─── Utility ──────────────────────────────────────────────────────────────────
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/src/coverage/deep-analysis/resolveConstants.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Deep Code Analysis — Constant Resolution
+ *
+ * Given a token that may be a variable or constant reference, looks it up in
+ * the symbol table and returns the resolved literal string value.
+ */
+import type { SymbolTable } from './types';
+/**
+ * Attempt to resolve a raw argument token found in an HTTP call to a concrete
+ * string value.
+ *
+ * Examples:
+ *   resolveToken("USERS_PATH", table)  → "/users"  (when table has USERS_PATH → /users)
+ *   resolveToken("'/users'", table)    → "/users"  (quoted literal, no lookup needed)
+ *   resolveToken("/users", table)      → "/users"  (already a path)
+ *
+ * Returns undefined when the value cannot be resolved.
+ */
+export declare function resolveToken(token: string, table: SymbolTable): string | undefined;
+/**
+ * Given an array of path fragment tokens (e.g. from a concatenation), resolve
+ * each one and join them into a single path string.
+ *
+ * Returns undefined when any segment cannot be resolved to a string.
+ */
+export declare function resolveFragments(fragments: string[], table: SymbolTable): string | undefined;
+/**
+ * Scan source content for all constant/variable assignments with string literal
+ * values and return the discovered symbol names along with their raw values as
+ * a simple Record<string, string>.
+ *
+ * This utility is used by tests to inspect resolution results without going through
+ * the full symbol table builder.
+ */
+export declare function extractStringConstants(content: string): Record<string, string>;
+//# sourceMappingURL=resolveConstants.d.ts.map

package/dist/src/coverage/deep-analysis/resolveConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveConstants.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/resolveConstants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAuBlF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAQ5F;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2B9E"}

package/dist/src/coverage/deep-analysis/resolveConstants.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Deep Code Analysis — Constant Resolution
+ *
+ * Given a token that may be a variable or constant reference, looks it up in
+ * the symbol table and returns the resolved literal string value.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveToken = resolveToken;
+exports.resolveFragments = resolveFragments;
+exports.extractStringConstants = extractStringConstants;
+const symbolTable_1 = require("./symbolTable");
+/**
+ * Attempt to resolve a raw argument token found in an HTTP call to a concrete
+ * string value.
+ *
+ * Examples:
+ *   resolveToken("USERS_PATH", table)  → "/users"  (when table has USERS_PATH → /users)
+ *   resolveToken("'/users'", table)    → "/users"  (quoted literal, no lookup needed)
+ *   resolveToken("/users", table)      → "/users"  (already a path)
+ *
+ * Returns undefined when the value cannot be resolved.
+ */
+function resolveToken(token, table) {
+    const trimmed = token.trim();
+    // Already a quoted string literal — strip quotes
+    if (/^['"`]/.test(trimmed) && /['"`]$/.test(trimmed)) {
+        return trimmed.slice(1, -1);
+    }
+    // Already a bare path
+    if (trimmed.startsWith('/'))
+        return trimmed;
+    // Dotted access: e.g. Routes.USERS, Paths.USERS_BY_ID
+    if (trimmed.includes('.')) {
+        const resolved = (0, symbolTable_1.resolveSymbol)(trimmed, table);
+        if (resolved !== undefined)
+            return resolved;
+        // Try just the member part (Foo.BAR → look up BAR)
+        const member = trimmed.split('.').pop();
+        return (0, symbolTable_1.resolveSymbol)(member, table);
+    }
+    // Simple identifier
+    return (0, symbolTable_1.resolveSymbol)(trimmed, table);
+}
+/**
+ * Given an array of path fragment tokens (e.g. from a concatenation), resolve
+ * each one and join them into a single path string.
+ *
+ * Returns undefined when any segment cannot be resolved to a string.
+ */
+function resolveFragments(fragments, table) {
+    const parts = [];
+    for (const frag of fragments) {
+        const resolved = resolveToken(frag.trim(), table);
+        if (resolved === undefined)
+            return undefined;
+        parts.push(resolved);
+    }
+    return parts.join('');
+}
+/**
+ * Scan source content for all constant/variable assignments with string literal
+ * values and return the discovered symbol names along with their raw values as
+ * a simple Record<string, string>.
+ *
+ * This utility is used by tests to inspect resolution results without going through
+ * the full symbol table builder.
+ */
+function extractStringConstants(content) {
+    const result = {};
+    // TypeScript/JavaScript: const/let/var NAME = 'value'
+    const jsPattern = /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*['"`]([^'"`\n]+)['"`]/g;
+    let m;
+    while ((m = jsPattern.exec(content)) !== null) {
+        result[m[1]] = m[2];
+    }
+    // Java/Kotlin: String/val NAME = "value"
+    const javaPattern = /\bString\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*"([^"\n]+)"/g;
+    while ((m = javaPattern.exec(content)) !== null) {
+        result[m[1]] = m[2];
+    }
+    const kotlinPattern = /\b(?:const\s+)?val\s+([A-Za-z_][A-Za-z0-9_]*)\s*=\s*["']([^"'\n]+)["']/g;
+    while ((m = kotlinPattern.exec(content)) !== null) {
+        result[m[1]] = m[2];
+    }
+    // Python: NAME = 'value'  (allow optional leading whitespace for indented blocks)
+    const pyPattern = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*['"]([^'"\n]+)['"]/gm;
+    while ((m = pyPattern.exec(content)) !== null) {
+        result[m[1]] = m[2];
+    }
+    return result;
+}

package/dist/src/coverage/deep-analysis/resolveEnums.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Deep Code Analysis — Enum Resolution
+ *
+ * Resolves enum member references used as endpoint path arguments across all
+ * supported languages.
+ *
+ * Supported patterns:
+ *
+ * TypeScript:
+ *   enum Routes { USERS = '/users' }
+ *   client.get(Routes.USERS)  →  GET /users
+ *
+ * Java:
+ *   enum Routes { USERS("/users"); ... }
+ *   api.get(Routes.USERS.getPath())  →  GET /users
+ *
+ * Kotlin:
+ *   enum class Routes(val path: String) { USERS("/users") }
+ *   client.get(Routes.USERS.path)  →  GET /users
+ *
+ * Python:
+ *   class Routes(Enum): USERS = "/users"
+ *   client.get(Routes.USERS.value)  →  GET /users
+ */
+import type { SymbolTable } from './types';
+/**
+ * Attempt to resolve an enum reference token to its literal path value.
+ *
+ * The token may be in any of these forms:
+ *   Routes.USERS
+ *   Routes.USERS.path  (Kotlin)
+ *   Routes.USERS.value  (Python)
+ *   Routes.USERS.getPath()  (Java)
+ */
+export declare function resolveEnumToken(token: string, table: SymbolTable): string | undefined;
+/**
+ * Extract all enum declarations from TypeScript/JavaScript source and return
+ * a map of EnumName.MEMBER → value.
+ */
+export declare function extractTsEnumValues(content: string): Record<string, string>;
+/**
+ * Extract all enum values from Java source.
+ * Supports constructor-style enums: MEMBER("value")
+ */
+export declare function extractJavaEnumValues(content: string): Record<string, string>;
+/**
+ * Extract all enum values from Kotlin source.
+ */
+export declare function extractKotlinEnumValues(content: string): Record<string, string>;
+/**
+ * Extract all enum values from Python source.
+ * Supports class Routes(Enum): MEMBER = "value"
+ */
+export declare function extractPythonEnumValues(content: string): Record<string, string>;
+//# sourceMappingURL=resolveEnums.d.ts.map

package/dist/src/coverage/deep-analysis/resolveEnums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveEnums.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/resolveEnums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CA4BtF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB3E;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAgB7E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAe/E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkB/E"}

package/dist/src/coverage/deep-analysis/resolveEnums.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Deep Code Analysis — Enum Resolution
+ *
+ * Resolves enum member references used as endpoint path arguments across all
+ * supported languages.
+ *
+ * Supported patterns:
+ *
+ * TypeScript:
+ *   enum Routes { USERS = '/users' }
+ *   client.get(Routes.USERS)  →  GET /users
+ *
+ * Java:
+ *   enum Routes { USERS("/users"); ... }
+ *   api.get(Routes.USERS.getPath())  →  GET /users
+ *
+ * Kotlin:
+ *   enum class Routes(val path: String) { USERS("/users") }
+ *   client.get(Routes.USERS.path)  →  GET /users
+ *
+ * Python:
+ *   class Routes(Enum): USERS = "/users"
+ *   client.get(Routes.USERS.value)  →  GET /users
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnumToken = resolveEnumToken;
+exports.extractTsEnumValues = extractTsEnumValues;
+exports.extractJavaEnumValues = extractJavaEnumValues;
+exports.extractKotlinEnumValues = extractKotlinEnumValues;
+exports.extractPythonEnumValues = extractPythonEnumValues;
+const symbolTable_1 = require("./symbolTable");
+/**
+ * Attempt to resolve an enum reference token to its literal path value.
+ *
+ * The token may be in any of these forms:
+ *   Routes.USERS
+ *   Routes.USERS.path  (Kotlin)
+ *   Routes.USERS.value  (Python)
+ *   Routes.USERS.getPath()  (Java)
+ */
+function resolveEnumToken(token, table) {
+    const t = token.trim();
+    // Direct table lookup (handles Routes.USERS and bare USERS)
+    const direct = (0, symbolTable_1.resolveSymbol)(t, table);
+    if (direct !== undefined)
+        return direct;
+    // Strip trailing .path, .value, .getPath(), .name, .ordinal()
+    const withoutSuffix = t.replace(/\.(path|value|getPath\(\)|name|ordinal\(\)|get[A-Za-z]+\(\))$/, '');
+    if (withoutSuffix !== t) {
+        const resolved = (0, symbolTable_1.resolveSymbol)(withoutSuffix, table);
+        if (resolved !== undefined)
+            return resolved;
+        // Try just the member (last segment before stripped suffix)
+        const parts = withoutSuffix.split('.');
+        if (parts.length >= 2) {
+            const member = parts[parts.length - 1];
+            const resolved2 = (0, symbolTable_1.resolveSymbol)(member, table);
+            if (resolved2 !== undefined)
+                return resolved2;
+            // Try Enum.MEMBER compound
+            const compound = parts.slice(-2).join('.');
+            const resolved3 = (0, symbolTable_1.resolveSymbol)(compound, table);
+            if (resolved3 !== undefined)
+                return resolved3;
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract all enum declarations from TypeScript/JavaScript source and return
+ * a map of EnumName.MEMBER → value.
+ */
+function extractTsEnumValues(content) {
+    const result = {};
+    // Allow {param} segments inside enum body strings (e.g. "/users/{id}")
+    const enumPattern = /\benum\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\{((?:[^{}]|\{[^}]*\})*)\}/g;
+    let m;
+    while ((m = enumPattern.exec(content)) !== null) {
+        const enumName = m[1];
+        const body = m[2];
+        const memberPattern = /([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*['"`]([^'"`\n]+)['"`]/g;
+        let mm;
+        while ((mm = memberPattern.exec(body)) !== null) {
+            result[`${enumName}.${mm[1]}`] = mm[2];
+            result[mm[1]] = mm[2];
+        }
+    }
+    return result;
+}
+/**
+ * Extract all enum values from Java source.
+ * Supports constructor-style enums: MEMBER("value")
+ */
+function extractJavaEnumValues(content) {
+    const result = {};
+    // Allow {param} segments inside enum body strings (e.g. "/users/{id}")
+    const enumBlock = /enum\s+([A-Za-z_][A-Za-z0-9_]*)\s*(?:implements[^{]*)?\{((?:[^{}]|\{[^}]*\})*)\}/gs;
+    let m;
+    while ((m = enumBlock.exec(content)) !== null) {
+        const enumName = m[1];
+        const body = m[2];
+        const memberPattern = /([A-Z_][A-Z0-9_]*)\s*\(\s*"([^"]+)"/g;
+        let mm;
+        while ((mm = memberPattern.exec(body)) !== null) {
+            result[`${enumName}.${mm[1]}`] = mm[2];
+            result[mm[1]] = mm[2];
+        }
+    }
+    return result;
+}
+/**
+ * Extract all enum values from Kotlin source.
+ */
+function extractKotlinEnumValues(content) {
+    const result = {};
+    const enumBlock = /enum\s+class\s+([A-Za-z_][A-Za-z0-9_]*)[^{]*\{([^}]+)\}/gs;
+    let m;
+    while ((m = enumBlock.exec(content)) !== null) {
+        const enumName = m[1];
+        const body = m[2];
+        const memberPattern = /([A-Z_][A-Z0-9_]*)\s*\(\s*["']([^"']+)["']/g;
+        let mm;
+        while ((mm = memberPattern.exec(body)) !== null) {
+            result[`${enumName}.${mm[1]}`] = mm[2];
+            result[mm[1]] = mm[2];
+        }
+    }
+    return result;
+}
+/**
+ * Extract all enum values from Python source.
+ * Supports class Routes(Enum): MEMBER = "value"
+ */
+function extractPythonEnumValues(content) {
+    const result = {};
+    // Note: no \s* after colon — the \n must be left for the body group to match
+    // Use [ \t]* (not \s*) for trailing whitespace to avoid consuming next line's \n
+    const enumBlock = /class\s+([A-Za-z_][A-Za-z0-9_]*)\s*\([^)]*Enum[^)]*\):((?:\n[ \t]+[A-Z_][A-Z0-9_]*\s*=\s*['"][^'"]+['"][ \t]*)+)/g;
+    let m;
+    while ((m = enumBlock.exec(content)) !== null) {
+        const enumName = m[1];
+        const body = m[2];
+        const memberPattern = /([A-Z_][A-Z0-9_]*)\s*=\s*['"]([^'"]+)['"]/g;
+        let mm;
+        while ((mm = memberPattern.exec(body)) !== null) {
+            result[`${enumName}.${mm[1]}`] = mm[2];
+            result[mm[1]] = mm[2];
+        }
+    }
+    return result;
+}

package/dist/src/coverage/deep-analysis/resolveMethodChains.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Deep Code Analysis — Method Chain Resolution
+ *
+ * Traces method calls to helper/wrapper functions within the same file,
+ * following the call graph up to a configurable depth.
+ *
+ * Also detects builder-style method chains that resolve to HTTP calls.
+ *
+ * Supported patterns:
+ *
+ * TypeScript/JavaScript:
+ *   function getUsers(client) { return client.get('/users'); }
+ *   getUsers(apiClient);  → GET /users
+ *
+ * Java:
+ *   private Response fetchUser(String id) { return api.get("/users/" + id); }
+ *   fetchUser(userId);  → GET /users/{id}
+ *
+ * Python:
+ *   def fetch_customer(customer_id): return client.get(build_path(customer_id))
+ */
+import type { CallGraph, ResolvedHttpCall } from './types';
+import type { SymbolTable } from './types';
+/**
+ * Given a function call expression like `getUsers(apiClient)`, look up the
+ * callee in the call graph, recurse into its body (up to maxDepth), and return
+ * any HTTP calls found inside.
+ */
+export declare function resolveWrapperCall(callee: string, graph: CallGraph, table: SymbolTable, sourceFile: string, sourceLanguage: string, maxDepth: number, currentDepth?: number): ResolvedHttpCall[];
+/**
+ * Resolve the path returned by a helper function when it is passed as the
+ * argument to an HTTP call.
+ *
+ * Example: client.get(getUserPath(userId))
+ *   → getUserPath is in the call graph, returns `/users/${userId}`
+ *   → normalized: /users/{id}
+ */
+export declare function resolveHelperReturnPath(calleeName: string, graph: CallGraph, table: SymbolTable, maxDepth: number, currentDepth?: number): string | undefined;
+/**
+ * Detect calls to local helper functions inside HTTP call argument positions
+ * in Python source.
+ *
+ * Example:
+ *   client.get(build_customer_path(customer_id))
+ *   → extracts 'build_customer_path' as a path-builder call
+ */
+export declare function extractPythonHelperCallsInHttpArgs(content: string): Array<{
+    method: string;
+    helperName: string;
+}>;
+/**
+ * Detect calls to local helper functions inside HTTP call argument positions
+ * in TypeScript/JavaScript source.
+ *
+ * Example:
+ *   client.get(getUserPath(userId))
+ */
+export declare function extractJsHelperCallsInHttpArgs(content: string): Array<{
+    method: string;
+    helperName: string;
+}>;
+/**
+ * Detect calls to local helper functions inside HTTP call argument positions
+ * in Java/Kotlin source.
+ */
+export declare function extractJavaHelperCallsInHttpArgs(content: string): Array<{
+    method: string;
+    helperName: string;
+}>;
+//# sourceMappingURL=resolveMethodChains.d.ts.map

package/dist/src/coverage/deep-analysis/resolveMethodChains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveMethodChains.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/resolveMethodChains.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAK3C;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,YAAY,SAAI,GACf,gBAAgB,EAAE,CA4CpB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,SAAI,GACf,MAAM,GAAG,SAAS,CAyBpB;AAID;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,OAAO,EAAE,MAAM,GACd,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAY/C;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,MAAM,GACd,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAW/C;AAED;;;GAGG;AACH,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,MAAM,GACd,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAY/C"}