api-tests-coverage 1.0.0

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

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ * Deep Code Analysis — Deep Endpoint Resolver
+ *
+ * Orchestrates all deep-analysis sub-modules to extract HTTP calls from a
+ * single source file, resolving constants, enums, string templates, wrapper
+ * methods, request builders, and assertion linkage.
+ *
+ * The main entry point is `deepResolveFile()`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResponseVariables = void 0;
+exports.deepResolveFile = deepResolveFile;
+const types_1 = require("./types");
+const symbolTable_1 = require("./symbolTable");
+const resolveConstants_1 = require("./resolveConstants");
+const resolveEnums_1 = require("./resolveEnums");
+const resolvePaths_1 = require("./resolvePaths");
+const callGraph_1 = require("./callGraph");
+const resolveMethodChains_1 = require("./resolveMethodChains");
+const resolveRequestWrappers_1 = require("./resolveRequestWrappers");
+const resolveAssertions_1 = require("./resolveAssertions");
+Object.defineProperty(exports, "extractResponseVariables", { enumerable: true, get: function () { return resolveAssertions_1.extractResponseVariables; } });
+// ─── Main entry point ─────────────────────────────────────────────────────────
+/**
+ * Run deep endpoint analysis on a single source file.
+ *
+ * @param content       Raw file content
+ * @param filePath      Absolute path (used in output metadata)
+ * @param language      Detected language
+ * @param config        Deep analysis feature configuration
+ * @returns Array of resolved HTTP calls with resolution metadata
+ */
+function deepResolveFile(content, filePath, language, config = types_1.DEFAULT_DEEP_ANALYSIS_CONFIG) {
+    if (!config.enabled)
+        return [];
+    const results = [];
+    const seen = new Set();
+    // ── 1. Build symbol table ────────────────────────────────────────────────
+    const table = (0, symbolTable_1.buildSymbolTable)(content, language);
+    // ── 2. Build call graph ──────────────────────────────────────────────────
+    const graph = language === 'java' || language === 'kotlin'
+        ? (0, callGraph_1.buildJavaCallGraph)(content)
+        : language === 'python'
+            ? (0, callGraph_1.buildPythonCallGraph)(content)
+            : (0, callGraph_1.buildJsCallGraph)(content);
+    // ── 3. Build assertion map ───────────────────────────────────────────────
+    const assertionMap = config.assertionAware ? (0, resolveAssertions_1.buildAssertionMap)(content) : new Map();
+    // ── 4. Resolve constant-backed HTTP calls ────────────────────────────────
+    if (config.resolveConstants || config.resolveEnums) {
+        const calls = extractHttpCallsWithVariableArgs(content, language);
+        for (const call of calls) {
+            const resolved = resolveCallArg(call.rawArg, table, config);
+            if (resolved) {
+                const path = stripUrlBase(resolved);
+                const normalized = (0, resolvePaths_1.normalizePathToTemplate)(path);
+                const assertionLinked = lookupAssertionLinked(call.responseVar, assertionMap);
+                addUnique(results, seen, {
+                    method: call.method,
+                    path,
+                    normalizedPath: normalized !== path ? normalized : undefined,
+                    sourceFile: filePath,
+                    sourceLanguage: language,
+                    resolutionType: call.resolutionType,
+                    confidence: call.confidence,
+                    assertionLinked,
+                    rawCall: call.rawCall,
+                });
+            }
+        }
+    }
+    // ── 5. Resolve template literal paths ────────────────────────────────────
+    if (config.resolveStringTemplates) {
+        const templateCalls = extractTemplateArgHttpCalls(content, language);
+        for (const call of templateCalls) {
+            let resolved;
+            if (language === 'python') {
+                resolved = (0, resolvePaths_1.resolvePythonFString)(call.rawPath, table);
+            }
+            else if (language === 'java' || language === 'kotlin') {
+                resolved = (0, resolvePaths_1.resolveJavaConcatenation)(call.rawPath, table);
+            }
+            else {
+                // Check for template literal
+                if (call.rawPath.includes('${')) {
+                    resolved = (0, resolvePaths_1.resolveTemplateLiteral)(call.rawPath, table);
+                }
+                else {
+                    resolved = (0, resolvePaths_1.resolveStringConcatenation)(call.rawPath, table);
+                }
+            }
+            if (resolved && resolved.includes('/')) {
+                const path = stripUrlBase(resolved);
+                const normalized = (0, resolvePaths_1.normalizePathToTemplate)(path);
+                const assertionLinked = lookupAssertionLinked(call.responseVar, assertionMap);
+                addUnique(results, seen, {
+                    method: call.method,
+                    path,
+                    normalizedPath: normalized !== path ? normalized : undefined,
+                    sourceFile: filePath,
+                    sourceLanguage: language,
+                    resolutionType: 'string-template',
+                    confidence: resolved.includes('{') ? 'medium' : 'high',
+                    assertionLinked,
+                    rawCall: call.rawCall,
+                });
+            }
+        }
+    }
+    // ── 6. Resolve request builder / object patterns ─────────────────────────
+    if (config.resolveRequestBuilders) {
+        const builderCalls = (0, resolveRequestWrappers_1.extractRequestBuilders)(content, language, table);
+        for (const call of builderCalls) {
+            const assertionLinked = false; // Cannot easily trace for builders without var tracking
+            addUnique(results, seen, {
+                method: call.method,
+                path: call.path,
+                normalizedPath: call.normalizedPath,
+                sourceFile: filePath,
+                sourceLanguage: language,
+                resolutionType: 'request-builder',
+                confidence: call.confidence,
+                assertionLinked,
+            });
+        }
+    }
+    // ── 7. Resolve wrapper/helper method calls ────────────────────────────────
+    if (config.resolveWrappers) {
+        // Find top-level calls that reference local functions
+        const helperCalls = language === 'java' || language === 'kotlin'
+            ? (0, resolveMethodChains_1.extractJavaHelperCallsInHttpArgs)(content)
+            : language === 'python'
+                ? (0, resolveMethodChains_1.extractPythonHelperCallsInHttpArgs)(content)
+                : (0, resolveMethodChains_1.extractJsHelperCallsInHttpArgs)(content);
+        for (const { method, helperName } of helperCalls) {
+            // First, try to get a return path from the helper
+            const returnPath = (0, resolveMethodChains_1.resolveHelperReturnPath)(helperName, graph, table, config.maxCallDepth);
+            if (returnPath) {
+                const resolved = language === 'python'
+                    ? (0, resolvePaths_1.resolvePythonFString)(returnPath, table)
+                    : (0, resolvePaths_1.resolveTemplateLiteral)(returnPath, table);
+                const path = stripUrlBase(resolved);
+                const normalized = (0, resolvePaths_1.normalizePathToTemplate)(path);
+                addUnique(results, seen, {
+                    method,
+                    path,
+                    normalizedPath: normalized !== path ? normalized : undefined,
+                    sourceFile: filePath,
+                    sourceLanguage: language,
+                    resolutionType: 'wrapper-method',
+                    confidence: 'high',
+                });
+            }
+            else {
+                // Try resolving the entire wrapper body for HTTP calls
+                const wrapperResults = (0, resolveMethodChains_1.resolveWrapperCall)(helperName, graph, table, filePath, language, config.maxCallDepth);
+                for (const r of wrapperResults) {
+                    addUnique(results, seen, r);
+                }
+            }
+        }
+        // Also scan all call graph nodes for direct HTTP calls inside them
+        // (catches helpers called from wrapper functions)
+        for (const [fnName, node] of graph.entries()) {
+            for (const { method, path } of node.directHttpCalls) {
+                // Only include if the function is called from the top-level content
+                const calledFromTopLevel = new RegExp(`\\b${escapeRegex(fnName)}\\s*\\(`).test(content);
+                if (calledFromTopLevel) {
+                    const normalized = (0, resolvePaths_1.normalizePathToTemplate)(path);
+                    addUnique(results, seen, {
+                        method,
+                        path,
+                        normalizedPath: normalized !== path ? normalized : undefined,
+                        sourceFile: filePath,
+                        sourceLanguage: language,
+                        resolutionType: 'wrapper-method',
+                        confidence: 'medium',
+                    });
+                }
+            }
+        }
+    }
+    // ── 8. Client mapping resolution ─────────────────────────────────────────
+    if (config.resolveClientMappings && config.clientMappings && config.clientMappings.length > 0) {
+        for (const mapping of config.clientMappings) {
+            const callPattern = new RegExp(`\\b${escapeRegex(mapping.classOrObject)}\\.${escapeRegex(mapping.method)}\\s*\\(`, 'g');
+            if (callPattern.test(content)) {
+                addUnique(results, seen, {
+                    method: mapping.httpMethod.toUpperCase(),
+                    path: mapping.pathTemplate,
+                    sourceFile: filePath,
+                    sourceLanguage: language,
+                    resolutionType: 'client-mapping',
+                    confidence: 'high',
+                });
+            }
+        }
+    }
+    // ── 9. Enrich with assertion linkage for response variable calls ──────────
+    if (config.assertionAware) {
+        const responseVarCalls = (0, resolveAssertions_1.extractResponseVariables)(content);
+        for (const { varName, method, path } of responseVarCalls) {
+            const assertionLinked = isAssertionLinked_local(varName, content);
+            if (assertionLinked) {
+                const normalized = (0, resolvePaths_1.normalizePathToTemplate)(path);
+                addUnique(results, seen, {
+                    method,
+                    path,
+                    normalizedPath: normalized !== path ? normalized : undefined,
+                    sourceFile: filePath,
+                    sourceLanguage: language,
+                    resolutionType: 'direct',
+                    confidence: 'high',
+                    assertionLinked: true,
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Extract HTTP call sites where the path argument is a variable (not a literal).
+ *
+ * Example:
+ *   client.get(USERS_PATH)   → rawArg = USERS_PATH
+ *   api.post(Routes.USERS)   → rawArg = Routes.USERS
+ */
+function extractHttpCallsWithVariableArgs(content, language) {
+    const calls = [];
+    let m;
+    if (language === 'java' || language === 'kotlin') {
+        // .get(IDENTIFIER) or .get(Enum.MEMBER)
+        const javaVarPattern = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*(?:\.[a-z]+\(\))?)\s*\)/gi;
+        while ((m = javaVarPattern.exec(content)) !== null) {
+            const arg = m[2];
+            if (!arg.includes('"') && !arg.startsWith('/')) {
+                const isEnum = arg.includes('.') && /^[A-Z]/.test(arg.split('.')[0]);
+                calls.push({
+                    method: m[1].toUpperCase(),
+                    rawArg: arg,
+                    rawCall: m[0],
+                    resolutionType: isEnum ? 'enum' : 'constant',
+                    confidence: 'high',
+                });
+            }
+        }
+    }
+    else if (language === 'python') {
+        // .get(IDENTIFIER) or requests.get(IDENTIFIER)
+        const pyVarPattern = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)\s*(?:[,)])/gi;
+        while ((m = pyVarPattern.exec(content)) !== null) {
+            const arg = m[2];
+            if (!arg.startsWith('/') && !arg.startsWith('"') && !arg.startsWith("'")) {
+                const isEnum = arg.includes('.') && /^[A-Z]/.test(arg.split('.')[0]);
+                calls.push({
+                    method: m[1].toUpperCase(),
+                    rawArg: arg,
+                    rawCall: m[0],
+                    resolutionType: isEnum ? 'enum' : 'constant',
+                    confidence: 'high',
+                });
+            }
+        }
+    }
+    else {
+        // TypeScript/JavaScript
+        const jsVarPattern = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$]*(?:\.[A-Za-z_$][A-Za-z0-9_$]*)*)\s*[),]/gi;
+        while ((m = jsVarPattern.exec(content)) !== null) {
+            const arg = m[2];
+            // Skip if it looks like a function call (.get(someCall()) already handled)
+            if (arg.endsWith(')') || arg.startsWith('/'))
+                continue;
+            const isEnum = arg.includes('.') && /^[A-Z]/.test(arg.split('.')[0]);
+            calls.push({
+                method: m[1].toUpperCase(),
+                rawArg: arg,
+                rawCall: m[0],
+                resolutionType: isEnum ? 'enum' : 'constant',
+                confidence: 'high',
+            });
+        }
+    }
+    return calls;
+}
+/**
+ * Extract HTTP call sites where the path argument is a template literal or
+ * string concatenation.
+ */
+function extractTemplateArgHttpCalls(content, language) {
+    const calls = [];
+    let m;
+    if (language === 'java' || language === 'kotlin') {
+        // .get(BASE + "/users/" + id)
+        const javaConcat = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_$][A-Za-z0-9_$"' +.]*)\s*\)/gi;
+        while ((m = javaConcat.exec(content)) !== null) {
+            const arg = m[2];
+            if (arg.includes('+') && (arg.includes('"') || /[A-Z_]/.test(arg))) {
+                calls.push({ method: m[1].toUpperCase(), rawPath: arg, rawCall: m[0] });
+            }
+        }
+    }
+    else if (language === 'python') {
+        // .get(f"{BASE}/users/{id}")
+        const pyFString = /\.(get|post|put|patch|delete|head|options)\s*\(\s*f['"]([^'"]+)['"]/gi;
+        while ((m = pyFString.exec(content)) !== null) {
+            calls.push({ method: m[1].toUpperCase(), rawPath: m[2], rawCall: m[0] });
+        }
+        // .get(BASE + "/users/" + str(id))
+        const pyConcat = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([^'")\n]*\+[^'")\n]*)[^)\n]*\)/gi;
+        while ((m = pyConcat.exec(content)) !== null) {
+            if (m[2].includes('/')) {
+                calls.push({ method: m[1].toUpperCase(), rawPath: m[2].trim(), rawCall: m[0] });
+            }
+        }
+    }
+    else {
+        // TypeScript/JS: .get(`${BASE}/users/${id}`)
+        const tsTemplate = /\.(get|post|put|patch|delete|head|options)\s*\(\s*`([^`]+)`/gi;
+        while ((m = tsTemplate.exec(content)) !== null) {
+            if (m[2].includes('/')) {
+                calls.push({ method: m[1].toUpperCase(), rawPath: m[2], rawCall: m[0] });
+            }
+        }
+        // .get(BASE + '/users/' + id)
+        const jsConcat = /\.(get|post|put|patch|delete|head|options)\s*\(\s*([A-Za-z_$][^'"()\n]*\+[^'"`()\n]+)/gi;
+        while ((m = jsConcat.exec(content)) !== null) {
+            if (m[2].includes('/')) {
+                calls.push({ method: m[1].toUpperCase(), rawPath: m[2].trim(), rawCall: m[0] });
+            }
+        }
+    }
+    return calls;
+}
+/**
+ * Resolve a call argument using symbol table (constants + enums).
+ */
+function resolveCallArg(rawArg, table, config) {
+    // Try enum resolution first (dotted access looks like enum)
+    if (config.resolveEnums && rawArg.includes('.')) {
+        const r = (0, resolveEnums_1.resolveEnumToken)(rawArg, table);
+        if (r !== undefined)
+            return r;
+    }
+    if (config.resolveConstants) {
+        const r = (0, resolveConstants_1.resolveToken)(rawArg, table);
+        if (r !== undefined)
+            return r;
+    }
+    return undefined;
+}
+/** Deduplicate results using a method:path key */
+function addUnique(results, seen, call) {
+    const key = `${call.method}:${call.path}:${call.resolutionType}`;
+    if (!seen.has(key)) {
+        seen.add(key);
+        results.push(call);
+    }
+}
+/** Look up assertion linkage for a response variable name */
+function lookupAssertionLinked(responseVar, assertionMap) {
+    if (!responseVar)
+        return undefined;
+    const linked = assertionMap.get(responseVar);
+    return linked !== undefined ? linked : undefined;
+}
+/** Inline assertion check (used inside deepResolveFile without importing) */
+function isAssertionLinked_local(varName, content) {
+    if (!varName)
+        return false;
+    const jsExpect = new RegExp(`\\bexpect\\s*\\(\\s*${escapeRegex(varName)}\\b`);
+    if (jsExpect.test(content))
+        return true;
+    const javaAssert = new RegExp(`\\b(?:assertEquals|assertNotNull|assertThat)\\s*\\([^)]*\\b${escapeRegex(varName)}\\b`);
+    if (javaAssert.test(content))
+        return true;
+    const pyAssert = new RegExp(`\\bassert\\s+${escapeRegex(varName)}\\b`);
+    if (pyAssert.test(content))
+        return true;
+    return false;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function stripUrlBase(value) {
+    if (value.startsWith('/') || value.startsWith('{'))
+        return value;
+    try {
+        const url = new URL(value);
+        return url.pathname;
+    }
+    catch {
+        return value;
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Deep Code Analysis — Public API
+ *
+ * Re-exports the public interface of the deep-endpoint-analysis feature.
+ */
+export type { ResolvedHttpCall, ResolutionType, ConfidenceLevel, SymbolEntry, SymbolTable, SymbolKind, DeepAnalysisConfig, ClientMethodMapping, CallGraphNode, CallGraph, } from './types';
+export { DEFAULT_DEEP_ANALYSIS_CONFIG } from './types';
+export { deepResolveFile } from './deepEndpointResolver';
+export { buildSymbolTable, buildSymbolTableFromJs, buildSymbolTableFromJava, buildSymbolTableFromKotlin, buildSymbolTableFromPython, resolveSymbol, } from './symbolTable';
+export { resolveToken, resolveFragments, extractStringConstants, } from './resolveConstants';
+export { resolveEnumToken, extractTsEnumValues, extractJavaEnumValues, extractKotlinEnumValues, extractPythonEnumValues, } from './resolveEnums';
+export { normalizePathToTemplate, resolveTemplateLiteral, resolveStringConcatenation, resolveJavaConcatenation, resolvePythonFString, resolveRubyInterpolation, extractTemplateLiterals, extractPythonFStrings, stripUrlBase, } from './resolvePaths';
+export { buildJsCallGraph, buildJavaCallGraph, buildPythonCallGraph, extractJsFunctions, extractJavaKotlinFunctions, extractPythonFunctions, extractBalancedBraces, } from './callGraph';
+export { resolveWrapperCall, resolveHelperReturnPath, extractJsHelperCallsInHttpArgs, extractJavaHelperCallsInHttpArgs, extractPythonHelperCallsInHttpArgs, } from './resolveMethodChains';
+export { extractRequestBuilders, extractJsRequestBuilders, extractJavaRequestBuilders, extractKotlinRequestBuilders, extractPythonRequestBuilders, } from './resolveRequestWrappers';
+export { isAssertionLinked, extractResponseVariables, buildAssertionMap, } from './resolveAssertions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,WAAW,EACX,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,SAAS,GACV,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,0BAA0B,EAC1B,aAAa,GACd,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,0BAA0B,EAC1B,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,YAAY,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EAClB,0BAA0B,EAC1B,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,kBAAkB,EAClB,uBAAuB,EACvB,8BAA8B,EAC9B,gCAAgC,EAChC,kCAAkC,GACnC,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,sBAAsB,EACtB,wBAAwB,EACxB,0BAA0B,EAC1B,4BAA4B,EAC5B,4BAA4B,GAC7B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,iBAAiB,GAClB,MAAM,qBAAqB,CAAC"}

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

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Deep Code Analysis — Public API
+ *
+ * Re-exports the public interface of the deep-endpoint-analysis feature.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAssertionMap = exports.extractResponseVariables = exports.isAssertionLinked = exports.extractPythonRequestBuilders = exports.extractKotlinRequestBuilders = exports.extractJavaRequestBuilders = exports.extractJsRequestBuilders = exports.extractRequestBuilders = exports.extractPythonHelperCallsInHttpArgs = exports.extractJavaHelperCallsInHttpArgs = exports.extractJsHelperCallsInHttpArgs = exports.resolveHelperReturnPath = exports.resolveWrapperCall = exports.extractBalancedBraces = exports.extractPythonFunctions = exports.extractJavaKotlinFunctions = exports.extractJsFunctions = exports.buildPythonCallGraph = exports.buildJavaCallGraph = exports.buildJsCallGraph = exports.stripUrlBase = exports.extractPythonFStrings = exports.extractTemplateLiterals = exports.resolveRubyInterpolation = exports.resolvePythonFString = exports.resolveJavaConcatenation = exports.resolveStringConcatenation = exports.resolveTemplateLiteral = exports.normalizePathToTemplate = exports.extractPythonEnumValues = exports.extractKotlinEnumValues = exports.extractJavaEnumValues = exports.extractTsEnumValues = exports.resolveEnumToken = exports.extractStringConstants = exports.resolveFragments = exports.resolveToken = exports.resolveSymbol = exports.buildSymbolTableFromPython = exports.buildSymbolTableFromKotlin = exports.buildSymbolTableFromJava = exports.buildSymbolTableFromJs = exports.buildSymbolTable = exports.deepResolveFile = exports.DEFAULT_DEEP_ANALYSIS_CONFIG = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "DEFAULT_DEEP_ANALYSIS_CONFIG", { enumerable: true, get: function () { return types_1.DEFAULT_DEEP_ANALYSIS_CONFIG; } });
+var deepEndpointResolver_1 = require("./deepEndpointResolver");
+Object.defineProperty(exports, "deepResolveFile", { enumerable: true, get: function () { return deepEndpointResolver_1.deepResolveFile; } });
+var symbolTable_1 = require("./symbolTable");
+Object.defineProperty(exports, "buildSymbolTable", { enumerable: true, get: function () { return symbolTable_1.buildSymbolTable; } });
+Object.defineProperty(exports, "buildSymbolTableFromJs", { enumerable: true, get: function () { return symbolTable_1.buildSymbolTableFromJs; } });
+Object.defineProperty(exports, "buildSymbolTableFromJava", { enumerable: true, get: function () { return symbolTable_1.buildSymbolTableFromJava; } });
+Object.defineProperty(exports, "buildSymbolTableFromKotlin", { enumerable: true, get: function () { return symbolTable_1.buildSymbolTableFromKotlin; } });
+Object.defineProperty(exports, "buildSymbolTableFromPython", { enumerable: true, get: function () { return symbolTable_1.buildSymbolTableFromPython; } });
+Object.defineProperty(exports, "resolveSymbol", { enumerable: true, get: function () { return symbolTable_1.resolveSymbol; } });
+var resolveConstants_1 = require("./resolveConstants");
+Object.defineProperty(exports, "resolveToken", { enumerable: true, get: function () { return resolveConstants_1.resolveToken; } });
+Object.defineProperty(exports, "resolveFragments", { enumerable: true, get: function () { return resolveConstants_1.resolveFragments; } });
+Object.defineProperty(exports, "extractStringConstants", { enumerable: true, get: function () { return resolveConstants_1.extractStringConstants; } });
+var resolveEnums_1 = require("./resolveEnums");
+Object.defineProperty(exports, "resolveEnumToken", { enumerable: true, get: function () { return resolveEnums_1.resolveEnumToken; } });
+Object.defineProperty(exports, "extractTsEnumValues", { enumerable: true, get: function () { return resolveEnums_1.extractTsEnumValues; } });
+Object.defineProperty(exports, "extractJavaEnumValues", { enumerable: true, get: function () { return resolveEnums_1.extractJavaEnumValues; } });
+Object.defineProperty(exports, "extractKotlinEnumValues", { enumerable: true, get: function () { return resolveEnums_1.extractKotlinEnumValues; } });
+Object.defineProperty(exports, "extractPythonEnumValues", { enumerable: true, get: function () { return resolveEnums_1.extractPythonEnumValues; } });
+var resolvePaths_1 = require("./resolvePaths");
+Object.defineProperty(exports, "normalizePathToTemplate", { enumerable: true, get: function () { return resolvePaths_1.normalizePathToTemplate; } });
+Object.defineProperty(exports, "resolveTemplateLiteral", { enumerable: true, get: function () { return resolvePaths_1.resolveTemplateLiteral; } });
+Object.defineProperty(exports, "resolveStringConcatenation", { enumerable: true, get: function () { return resolvePaths_1.resolveStringConcatenation; } });
+Object.defineProperty(exports, "resolveJavaConcatenation", { enumerable: true, get: function () { return resolvePaths_1.resolveJavaConcatenation; } });
+Object.defineProperty(exports, "resolvePythonFString", { enumerable: true, get: function () { return resolvePaths_1.resolvePythonFString; } });
+Object.defineProperty(exports, "resolveRubyInterpolation", { enumerable: true, get: function () { return resolvePaths_1.resolveRubyInterpolation; } });
+Object.defineProperty(exports, "extractTemplateLiterals", { enumerable: true, get: function () { return resolvePaths_1.extractTemplateLiterals; } });
+Object.defineProperty(exports, "extractPythonFStrings", { enumerable: true, get: function () { return resolvePaths_1.extractPythonFStrings; } });
+Object.defineProperty(exports, "stripUrlBase", { enumerable: true, get: function () { return resolvePaths_1.stripUrlBase; } });
+var callGraph_1 = require("./callGraph");
+Object.defineProperty(exports, "buildJsCallGraph", { enumerable: true, get: function () { return callGraph_1.buildJsCallGraph; } });
+Object.defineProperty(exports, "buildJavaCallGraph", { enumerable: true, get: function () { return callGraph_1.buildJavaCallGraph; } });
+Object.defineProperty(exports, "buildPythonCallGraph", { enumerable: true, get: function () { return callGraph_1.buildPythonCallGraph; } });
+Object.defineProperty(exports, "extractJsFunctions", { enumerable: true, get: function () { return callGraph_1.extractJsFunctions; } });
+Object.defineProperty(exports, "extractJavaKotlinFunctions", { enumerable: true, get: function () { return callGraph_1.extractJavaKotlinFunctions; } });
+Object.defineProperty(exports, "extractPythonFunctions", { enumerable: true, get: function () { return callGraph_1.extractPythonFunctions; } });
+Object.defineProperty(exports, "extractBalancedBraces", { enumerable: true, get: function () { return callGraph_1.extractBalancedBraces; } });
+var resolveMethodChains_1 = require("./resolveMethodChains");
+Object.defineProperty(exports, "resolveWrapperCall", { enumerable: true, get: function () { return resolveMethodChains_1.resolveWrapperCall; } });
+Object.defineProperty(exports, "resolveHelperReturnPath", { enumerable: true, get: function () { return resolveMethodChains_1.resolveHelperReturnPath; } });
+Object.defineProperty(exports, "extractJsHelperCallsInHttpArgs", { enumerable: true, get: function () { return resolveMethodChains_1.extractJsHelperCallsInHttpArgs; } });
+Object.defineProperty(exports, "extractJavaHelperCallsInHttpArgs", { enumerable: true, get: function () { return resolveMethodChains_1.extractJavaHelperCallsInHttpArgs; } });
+Object.defineProperty(exports, "extractPythonHelperCallsInHttpArgs", { enumerable: true, get: function () { return resolveMethodChains_1.extractPythonHelperCallsInHttpArgs; } });
+var resolveRequestWrappers_1 = require("./resolveRequestWrappers");
+Object.defineProperty(exports, "extractRequestBuilders", { enumerable: true, get: function () { return resolveRequestWrappers_1.extractRequestBuilders; } });
+Object.defineProperty(exports, "extractJsRequestBuilders", { enumerable: true, get: function () { return resolveRequestWrappers_1.extractJsRequestBuilders; } });
+Object.defineProperty(exports, "extractJavaRequestBuilders", { enumerable: true, get: function () { return resolveRequestWrappers_1.extractJavaRequestBuilders; } });
+Object.defineProperty(exports, "extractKotlinRequestBuilders", { enumerable: true, get: function () { return resolveRequestWrappers_1.extractKotlinRequestBuilders; } });
+Object.defineProperty(exports, "extractPythonRequestBuilders", { enumerable: true, get: function () { return resolveRequestWrappers_1.extractPythonRequestBuilders; } });
+var resolveAssertions_1 = require("./resolveAssertions");
+Object.defineProperty(exports, "isAssertionLinked", { enumerable: true, get: function () { return resolveAssertions_1.isAssertionLinked; } });
+Object.defineProperty(exports, "extractResponseVariables", { enumerable: true, get: function () { return resolveAssertions_1.extractResponseVariables; } });
+Object.defineProperty(exports, "buildAssertionMap", { enumerable: true, get: function () { return resolveAssertions_1.buildAssertionMap; } });

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

@@ -0,0 +1,60 @@
+/**
+ * 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()
+ */
+/**
+ * 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.
+ */
+export declare function isAssertionLinked(responseVar: string, content: string): boolean;
+/**
+ * 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')
+ */
+export declare function extractResponseVariables(content: string): Array<{
+    varName: string;
+    method: string;
+    path: string;
+}>;
+/**
+ * For each response variable in the content, determine if it has an
+ * associated assertion.
+ *
+ * Returns a map: varName → assertionLinked (boolean)
+ */
+export declare function buildAssertionMap(content: string): Map<string, boolean>;
+//# sourceMappingURL=resolveAssertions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveAssertions.d.ts","sourceRoot":"","sources":["../../../../src/coverage/deep-analysis/resolveAssertions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAmC/E;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,GACd,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA2B1D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CASvE"}