api-tests-coverage 1.0.0

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

@@ -0,0 +1,358 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJavaSymbols = extractJavaSymbols;
+exports.extractJavaFunctions = extractJavaFunctions;
+exports.extractJavaHttpCalls = extractJavaHttpCalls;
+exports.extractJavaAssertions = extractJavaAssertions;
+exports.extractJavaBusinessRuleRefs = extractJavaBusinessRuleRefs;
+exports.extractJavaFlowRefs = extractJavaFlowRefs;
+const treeSitterUtils_1 = require("../shared/treeSitterUtils");
+const resolvePaths_1 = require("../../coverage/deep-analysis/resolvePaths");
+const HTTP_METHODS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'request']);
+// ─── Symbol extraction ────────────────────────────────────────────────────────
+function extractJavaSymbols(root) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    const constants = new Map();
+    const enums = new Map();
+    // Field declarations: private static final String USERS = "/users";
+    const fieldDecls = (0, treeSitterUtils_1.findNodes)(root, ['field_declaration']);
+    for (const field of fieldDecls) {
+        const modifiers = extractModifierTexts(field);
+        if (!modifiers.includes('static') || !modifiers.includes('final'))
+            continue;
+        const declarators = (0, treeSitterUtils_1.findNodes)(field, ['variable_declarator']);
+        for (const decl of declarators) {
+            const nameNode = (0, treeSitterUtils_1.firstChildOfType)(decl, 'identifier');
+            const valueNode = (0, treeSitterUtils_1.firstChildOfType)(decl, 'string_literal');
+            if (nameNode && valueNode) {
+                const name = (_a = nameNode.text) !== null && _a !== void 0 ? _a : '';
+                const value = (_b = (0, treeSitterUtils_1.extractStringValue)(valueNode)) !== null && _b !== void 0 ? _b : '';
+                constants.set(name, { name, kind: 'const', value, resolvedValue: value });
+            }
+        }
+    }
+    // Local variable declarations inside methods: String USERS = "/users";
+    const localDecls = (0, treeSitterUtils_1.findNodes)(root, ['local_variable_declaration']);
+    for (const decl of localDecls) {
+        const declarators = (0, treeSitterUtils_1.findNodes)(decl, ['variable_declarator']);
+        for (const vd of declarators) {
+            const nameNode = (0, treeSitterUtils_1.firstChildOfType)(vd, 'identifier');
+            const valueNode = (0, treeSitterUtils_1.firstChildOfType)(vd, 'string_literal');
+            if (nameNode && valueNode) {
+                const name = (_c = nameNode.text) !== null && _c !== void 0 ? _c : '';
+                const value = (_d = (0, treeSitterUtils_1.extractStringValue)(valueNode)) !== null && _d !== void 0 ? _d : '';
+                constants.set(name, { name, kind: 'let', value, resolvedValue: value });
+            }
+        }
+    }
+    // Enum declarations
+    const enumDecls = (0, treeSitterUtils_1.findNodes)(root, ['enum_declaration']);
+    for (const enumDecl of enumDecls) {
+        const enumName = (_f = (_e = (0, treeSitterUtils_1.firstChildOfType)(enumDecl, 'identifier')) === null || _e === void 0 ? void 0 : _e.text) !== null && _f !== void 0 ? _f : '';
+        if (!enumName)
+            continue;
+        const memberMap = new Map();
+        const constants2 = (0, treeSitterUtils_1.findNodes)(enumDecl, ['enum_constant']);
+        for (const constant of constants2) {
+            const memberName = (_h = (_g = (0, treeSitterUtils_1.firstChildOfType)(constant, 'identifier')) === null || _g === void 0 ? void 0 : _g.text) !== null && _h !== void 0 ? _h : '';
+            const argList = (0, treeSitterUtils_1.firstChildOfType)(constant, 'argument_list');
+            if (argList) {
+                const strLit = (0, treeSitterUtils_1.firstChildOfType)(argList, 'string_literal');
+                if (strLit && memberName) {
+                    const value = (_j = (0, treeSitterUtils_1.extractStringValue)(strLit)) !== null && _j !== void 0 ? _j : '';
+                    memberMap.set(memberName, value);
+                    const fullName = `${enumName}.${memberName}`;
+                    constants.set(fullName, {
+                        name: fullName,
+                        kind: 'enum-member',
+                        value,
+                        resolvedValue: value,
+                    });
+                }
+            }
+        }
+        if (memberMap.size > 0)
+            enums.set(enumName, memberMap);
+    }
+    return { constants, enums };
+}
+// ─── Function/method extraction ───────────────────────────────────────────────
+function extractJavaFunctions(root, constants) {
+    var _a, _b, _c, _d, _e;
+    const graph = new Map();
+    const methodDecls = (0, treeSitterUtils_1.findNodes)(root, ['method_declaration']);
+    for (const method of methodDecls) {
+        const nameNode = (_b = (_a = method.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(method, 'name')) !== null && _b !== void 0 ? _b : (0, treeSitterUtils_1.firstChildOfType)(method, 'identifier');
+        const name = (_c = nameNode === null || nameNode === void 0 ? void 0 : nameNode.text) !== null && _c !== void 0 ? _c : '';
+        if (!name)
+            continue;
+        const annotations = extractAnnotationNames(method);
+        const block = (_e = (_d = method.childForFieldName) === null || _d === void 0 ? void 0 : _d.call(method, 'body')) !== null && _e !== void 0 ? _e : (0, treeSitterUtils_1.firstChildOfType)(method, 'block');
+        const bodyHttpCalls = [];
+        const calledFunctions = [];
+        let returnValue;
+        if (block) {
+            extractJavaHttpCalls(block, constants, bodyHttpCalls);
+            extractCalledMethods(block, calledFunctions);
+            returnValue = extractJavaReturnValue(block, constants);
+        }
+        // Cucumber step pattern from annotation
+        const cucumberPattern = extractCucumberPattern(annotations, method);
+        graph.set(name, {
+            name,
+            parameters: [],
+            bodyHttpCalls,
+            calledFunctions,
+            returnValue,
+            annotations,
+            cucumberPattern,
+        });
+    }
+    return graph;
+}
+// ─── HTTP call extraction ─────────────────────────────────────────────────────
+function extractJavaHttpCalls(block, constants, out) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const methodInvocations = (0, treeSitterUtils_1.findNodes)(block, ['method_invocation']);
+    for (const invoc of methodInvocations) {
+        const methodName = (_e = (_c = (_b = (_a = invoc.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(invoc, 'name')) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : (_d = firstChildNamed(invoc, 'identifier')) === null || _d === void 0 ? void 0 : _d.text) !== null && _e !== void 0 ? _e : '';
+        const lowerMethod = methodName.toLowerCase();
+        if (!HTTP_METHODS.has(lowerMethod))
+            continue;
+        const argList = (_g = (_f = invoc.childForFieldName) === null || _f === void 0 ? void 0 : _f.call(invoc, 'arguments')) !== null && _g !== void 0 ? _g : (0, treeSitterUtils_1.firstChildOfType)(invoc, 'argument_list');
+        if (!argList)
+            continue;
+        // Extract the first string argument (path)
+        const firstStringArg = findFirstStringInArgList(argList, constants);
+        if (!firstStringArg)
+            continue;
+        const { value: path, isDirect, varName } = firstStringArg;
+        // Try to detect the HTTP method from context
+        let httpMethod = lowerMethod.toUpperCase();
+        // RestAssured: .when().get("/path") or .given().get("/path")
+        // The method name IS the HTTP method in RestAssured style
+        if (!HTTP_METHODS.has(lowerMethod))
+            continue;
+        // MockMvc: perform(get("/path")) — perform wraps a method call
+        if (lowerMethod === 'perform') {
+            // The arg is another method invocation
+            continue; // Handled when we process the inner get/post
+        }
+        if (lowerMethod === 'request') {
+            // generic request(method, path) — try to get HTTP method from first arg
+            const stringArgs = findAllStringsInArgList(argList, constants);
+            if (stringArgs.length >= 2) {
+                httpMethod = stringArgs[0].value.toUpperCase();
+                const pathVal = stringArgs[1].value;
+                const normalizedPath = pathVal.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(pathVal) : undefined;
+                out.push({
+                    method: httpMethod,
+                    rawPathArg: varName !== null && varName !== void 0 ? varName : pathVal,
+                    resolvedPath: pathVal,
+                    normalizedPath,
+                    resolutionType: isDirect ? 'direct' : 'constant',
+                    confidence: isDirect ? 'high' : 'medium',
+                });
+                continue;
+            }
+        }
+        const normalizedPath = path.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(path) : undefined;
+        out.push({
+            method: httpMethod,
+            rawPathArg: varName !== null && varName !== void 0 ? varName : path,
+            resolvedPath: path,
+            normalizedPath,
+            resolutionType: isDirect ? 'direct' : 'constant',
+            confidence: isDirect ? 'high' : 'medium',
+        });
+    }
+}
+// ─── Assertion extraction ─────────────────────────────────────────────────────
+function extractJavaAssertions(root) {
+    var _a, _b, _c, _d, _e;
+    const assertions = [];
+    const methodInvocations = (0, treeSitterUtils_1.findNodes)(root, ['method_invocation']);
+    for (const invoc of methodInvocations) {
+        const name = (_e = (_c = (_b = (_a = invoc.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(invoc, 'name')) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : (_d = firstChildNamed(invoc, 'identifier')) === null || _d === void 0 ? void 0 : _d.text) !== null && _e !== void 0 ? _e : '';
+        const lowerName = name.toLowerCase();
+        if (lowerName.startsWith('assertequals') ||
+            lowerName.startsWith('assertthat') ||
+            lowerName.startsWith('assertnotnull') ||
+            lowerName.startsWith('assert') ||
+            lowerName === 'statuscode' ||
+            lowerName === 'statusmustbe') {
+            const type = lowerName.includes('status') ? 'status-code' : 'body-field';
+            assertions.push({ assertionType: type });
+        }
+    }
+    return assertions;
+}
+// ─── Business rule and flow ref extraction ────────────────────────────────────
+function extractJavaBusinessRuleRefs(root) {
+    var _a;
+    const refs = [];
+    const annotations = (0, treeSitterUtils_1.findNodes)(root, ['annotation', 'marker_annotation']);
+    for (const ann of annotations) {
+        const annText = (_a = ann.text) !== null && _a !== void 0 ? _a : '';
+        const brMatch = annText.match(/@(?:BusinessRule|businessRule|Tag)\s*\(\s*["']?([^)"'\s]+)/);
+        if (brMatch) {
+            refs.push({ ruleId: brMatch[1], source: 'annotation' });
+        }
+    }
+    return refs;
+}
+function extractJavaFlowRefs(root) {
+    var _a;
+    const refs = [];
+    const annotations = (0, treeSitterUtils_1.findNodes)(root, ['annotation', 'marker_annotation']);
+    for (const ann of annotations) {
+        const annText = (_a = ann.text) !== null && _a !== void 0 ? _a : '';
+        const flowMatch = annText.match(/@(?:Flow|IntegrationFlow|FlowId)\s*\(\s*["']?([^)"'\s]+)/);
+        if (flowMatch) {
+            refs.push({ flowId: flowMatch[1], source: 'annotation' });
+        }
+    }
+    return refs;
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function extractModifierTexts(node) {
+    const modifiers = [];
+    (0, treeSitterUtils_1.walkTree)(node, (n) => {
+        var _a;
+        if (n.type === 'modifier' || n.type === 'final' || n.type === 'static' || n.type === 'public' ||
+            n.type === 'private' || n.type === 'protected') {
+            modifiers.push((_a = n.text) !== null && _a !== void 0 ? _a : '');
+        }
+    });
+    return modifiers;
+}
+function extractAnnotationNames(node) {
+    var _a;
+    const names = [];
+    for (let i = 0; i < ((_a = node === null || node === void 0 ? void 0 : node.childCount) !== null && _a !== void 0 ? _a : 0); i++) {
+        const child = node.child(i);
+        if ((child === null || child === void 0 ? void 0 : child.type) === 'modifiers') {
+            (0, treeSitterUtils_1.walkTree)(child, (n) => {
+                var _a;
+                if (n.type === 'annotation' || n.type === 'marker_annotation') {
+                    // Get the annotation name
+                    const nameNode = (0, treeSitterUtils_1.firstChildOfType)(n, 'identifier');
+                    if (nameNode)
+                        names.push('@' + ((_a = nameNode.text) !== null && _a !== void 0 ? _a : ''));
+                }
+            });
+        }
+    }
+    return names;
+}
+function extractCucumberPattern(annotations, methodNode) {
+    const cucumberAnnotations = ['@Given', '@When', '@Then', '@And', '@But'];
+    for (const ann of annotations) {
+        if (cucumberAnnotations.some((ca) => ann.startsWith(ca))) {
+            // Extract the pattern string from the annotation
+            const annNodes = (0, treeSitterUtils_1.findNodes)(methodNode, ['annotation']);
+            for (const annNode of annNodes) {
+                const strLit = (0, treeSitterUtils_1.firstChildOfType)(annNode, 'string_literal');
+                if (strLit)
+                    return (0, treeSitterUtils_1.extractStringValue)(strLit);
+            }
+        }
+    }
+    return undefined;
+}
+function firstChildNamed(node, type) {
+    var _a;
+    if (!node)
+        return undefined;
+    // Find last identifier child (method name is usually at end of member access)
+    let found;
+    for (let i = 0; i < ((_a = node.childCount) !== null && _a !== void 0 ? _a : 0); i++) {
+        const child = node.child(i);
+        if ((child === null || child === void 0 ? void 0 : child.type) === type)
+            found = child;
+    }
+    return found;
+}
+function findFirstStringInArgList(argList, constants) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    for (let i = 0; i < ((_a = argList === null || argList === void 0 ? void 0 : argList.childCount) !== null && _a !== void 0 ? _a : 0); i++) {
+        const child = argList.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'string_literal') {
+            const value = (_b = (0, treeSitterUtils_1.extractStringValue)(child)) !== null && _b !== void 0 ? _b : '';
+            if (value)
+                return { value, isDirect: true };
+        }
+        if (child.type === 'identifier') {
+            const varName = (_c = child.text) !== null && _c !== void 0 ? _c : '';
+            const resolved = (_d = constants.get(varName)) === null || _d === void 0 ? void 0 : _d.resolvedValue;
+            if (resolved)
+                return { value: resolved, isDirect: false, varName };
+        }
+        // Field access: Routes.USERS
+        if (child.type === 'field_access' || child.type === 'member_access') {
+            const objName = (_g = (_f = (_e = child.childForFieldName) === null || _e === void 0 ? void 0 : _e.call(child, 'object')) === null || _f === void 0 ? void 0 : _f.text) !== null && _g !== void 0 ? _g : '';
+            const fieldName = (_k = (_j = (_h = child.childForFieldName) === null || _h === void 0 ? void 0 : _h.call(child, 'field')) === null || _j === void 0 ? void 0 : _j.text) !== null && _k !== void 0 ? _k : '';
+            if (objName && fieldName) {
+                const key = `${objName}.${fieldName}`;
+                const resolved = (_l = constants.get(key)) === null || _l === void 0 ? void 0 : _l.resolvedValue;
+                if (resolved)
+                    return { value: resolved, isDirect: false, varName: key };
+            }
+        }
+    }
+    return undefined;
+}
+function findAllStringsInArgList(argList, constants) {
+    var _a, _b, _c, _d;
+    const results = [];
+    for (let i = 0; i < ((_a = argList === null || argList === void 0 ? void 0 : argList.childCount) !== null && _a !== void 0 ? _a : 0); i++) {
+        const child = argList.child(i);
+        if (!child)
+            continue;
+        if (child.type === 'string_literal') {
+            const value = (_b = (0, treeSitterUtils_1.extractStringValue)(child)) !== null && _b !== void 0 ? _b : '';
+            if (value)
+                results.push({ value, isDirect: true });
+        }
+        if (child.type === 'identifier') {
+            const resolved = (_d = constants.get((_c = child.text) !== null && _c !== void 0 ? _c : '')) === null || _d === void 0 ? void 0 : _d.resolvedValue;
+            if (resolved)
+                results.push({ value: resolved, isDirect: false });
+        }
+    }
+    return results;
+}
+function extractCalledMethods(block, out) {
+    var _a, _b, _c, _d, _e;
+    const invocations = (0, treeSitterUtils_1.findNodes)(block, ['method_invocation']);
+    for (const inv of invocations) {
+        const name = (_e = (_c = (_b = (_a = inv.childForFieldName) === null || _a === void 0 ? void 0 : _a.call(inv, 'name')) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : (_d = firstChildNamed(inv, 'identifier')) === null || _d === void 0 ? void 0 : _d.text) !== null && _e !== void 0 ? _e : '';
+        if (name && !out.includes(name))
+            out.push(name);
+    }
+}
+function extractJavaReturnValue(block, constants) {
+    var _a, _b;
+    const returnStmts = (0, treeSitterUtils_1.findNodes)(block, ['return_statement']);
+    for (const ret of returnStmts) {
+        const strLit = (0, treeSitterUtils_1.firstChildOfType)(ret, 'string_literal');
+        if (strLit)
+            return (0, treeSitterUtils_1.extractStringValue)(strLit);
+        const identifier = (0, treeSitterUtils_1.firstChildOfType)(ret, 'identifier');
+        if (identifier) {
+            return (_b = constants.get((_a = identifier.text) !== null && _a !== void 0 ? _a : '')) === null || _b === void 0 ? void 0 : _b.resolvedValue;
+        }
+    }
+    return undefined;
+}

package/dist/src/languages/javascript/annotationExtractor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Business rule and integration flow annotation extractor for JS/TS.
+ *
+ * Detects annotations in test files as:
+ *   - JSDoc-style comments: @businessRule BR-001, @flowId FLOW-001
+ *   - jest.each tags or describe block labels with rule IDs
+ *   - Cucumber-style tags in describe/it names: 'BR-001 user can login'
+ */
+import type { BusinessRuleRef, FlowRef } from '../../ast/astTypes';
+type AstNode = any;
+/**
+ * Extract business rule references from JSDoc comments and string labels in the AST.
+ */
+export declare function extractBusinessRuleRefs(ast: AstNode): BusinessRuleRef[];
+/**
+ * Extract flow references from JSDoc comments and string labels in the AST.
+ */
+export declare function extractFlowRefs(ast: AstNode): FlowRef[];
+export {};
+//# sourceMappingURL=annotationExtractor.d.ts.map

package/dist/src/languages/javascript/annotationExtractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotationExtractor.d.ts","sourceRoot":"","sources":["../../../../src/languages/javascript/annotationExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAGnE,KAAK,OAAO,GAAG,GAAG,CAAC;AAKnB;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,EAAE,CAoBvE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,EAAE,CAgBvD"}

package/dist/src/languages/javascript/annotationExtractor.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Business rule and integration flow annotation extractor for JS/TS.
+ *
+ * Detects annotations in test files as:
+ *   - JSDoc-style comments: @businessRule BR-001, @flowId FLOW-001
+ *   - jest.each tags or describe block labels with rule IDs
+ *   - Cucumber-style tags in describe/it names: 'BR-001 user can login'
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractBusinessRuleRefs = extractBusinessRuleRefs;
+exports.extractFlowRefs = extractFlowRefs;
+const BUSINESS_RULE_PATTERN = /(?:@businessRule|@business-rule|BR-?(\w+))\s*([\w-]+)?/gi;
+const FLOW_ID_PATTERN = /(?:@flowId|@flow-id|FLOW-?(\w+))\s*([\w-]+)?/gi;
+/**
+ * Extract business rule references from JSDoc comments and string labels in the AST.
+ */
+function extractBusinessRuleRefs(ast) {
+    var _a, _b, _c, _d, _e, _f;
+    const refs = [];
+    if (!ast)
+        return refs;
+    // Check comments
+    for (const comment of (_a = ast.comments) !== null && _a !== void 0 ? _a : []) {
+        const text = (_b = comment.value) !== null && _b !== void 0 ? _b : '';
+        const matches = [...text.matchAll(BUSINESS_RULE_PATTERN)];
+        for (const match of matches) {
+            const ruleId = ((_d = (_c = match[1]) !== null && _c !== void 0 ? _c : match[2]) !== null && _d !== void 0 ? _d : '').trim();
+            if (ruleId) {
+                refs.push({ ruleId, source: 'comment', line: (_f = (_e = comment.loc) === null || _e === void 0 ? void 0 : _e.start) === null || _f === void 0 ? void 0 : _f.line });
+            }
+        }
+    }
+    // Check string literals in describe/it block labels
+    extractFromStringLabels(ast, BUSINESS_RULE_PATTERN, refs, 'comment');
+    return refs;
+}
+/**
+ * Extract flow references from JSDoc comments and string labels in the AST.
+ */
+function extractFlowRefs(ast) {
+    var _a, _b, _c, _d, _e, _f;
+    const refs = [];
+    if (!ast)
+        return refs;
+    for (const comment of (_a = ast.comments) !== null && _a !== void 0 ? _a : []) {
+        const text = (_b = comment.value) !== null && _b !== void 0 ? _b : '';
+        const matches = [...text.matchAll(FLOW_ID_PATTERN)];
+        for (const match of matches) {
+            const flowId = ((_d = (_c = match[1]) !== null && _c !== void 0 ? _c : match[2]) !== null && _d !== void 0 ? _d : '').trim();
+            if (flowId) {
+                refs.push({ flowId, source: 'comment', line: (_f = (_e = comment.loc) === null || _e === void 0 ? void 0 : _e.start) === null || _f === void 0 ? void 0 : _f.line });
+            }
+        }
+    }
+    return refs;
+}
+function extractFromStringLabels(ast, pattern, refs, source) {
+    if (!(ast === null || ast === void 0 ? void 0 : ast.body))
+        return;
+    for (const node of ast.body) {
+        walkStringLabels(node, pattern, refs, source);
+    }
+}
+function walkStringLabels(node, pattern, refs, source) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (!node || typeof node !== 'object')
+        return;
+    if (node.type === 'CallExpression' &&
+        (((_a = node.callee) === null || _a === void 0 ? void 0 : _a.name) === 'describe' || ((_b = node.callee) === null || _b === void 0 ? void 0 : _b.name) === 'it' || ((_c = node.callee) === null || _c === void 0 ? void 0 : _c.name) === 'test')) {
+        const label = (_d = node.arguments) === null || _d === void 0 ? void 0 : _d[0];
+        if ((label === null || label === void 0 ? void 0 : label.type) === 'Literal' && typeof label.value === 'string') {
+            pattern.lastIndex = 0;
+            const matches = [...label.value.matchAll(pattern)];
+            for (const match of matches) {
+                const ruleId = ((_f = (_e = match[1]) !== null && _e !== void 0 ? _e : match[2]) !== null && _f !== void 0 ? _f : '').trim();
+                if (ruleId)
+                    refs.push({ ruleId, source, line: (_h = (_g = label.loc) === null || _g === void 0 ? void 0 : _g.start) === null || _h === void 0 ? void 0 : _h.line });
+            }
+        }
+    }
+    for (const key of ['body', 'expression', 'declaration', 'declarations', 'arguments']) {
+        const child = node[key];
+        if (Array.isArray(child)) {
+            for (const c of child) {
+                if (c && typeof c === 'object')
+                    walkStringLabels(c, pattern, refs, source);
+            }
+        }
+        else if (child && typeof child === 'object') {
+            walkStringLabels(child, pattern, refs, source);
+        }
+    }
+}

package/dist/src/languages/javascript/assertionResolver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * JavaScript/TypeScript assertion resolver.
+ *
+ * Detects assertion patterns linked to HTTP response variables:
+ *   - expect(response).toHaveProperty(...)  → body-field
+ *   - expect(response.status).toBe(200)     → status-code
+ *   - expect(response.statusCode).toEqual(200) → status-code
+ *   - response.expect(200)                  → fluent-chain (supertest)
+ *   - .expect(res => { ... })               → fluent-chain
+ */
+import type { SemanticAssertion } from '../../ast/astTypes';
+type AstNode = any;
+/**
+ * Extract all assertion nodes from an AST subtree.
+ */
+export declare function extractAssertions(ast: AstNode): SemanticAssertion[];
+export {};
+//# sourceMappingURL=assertionResolver.d.ts.map

package/dist/src/languages/javascript/assertionResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertionResolver.d.ts","sourceRoot":"","sources":["../../../../src/languages/javascript/assertionResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D,KAAK,OAAO,GAAG,GAAG,CAAC;AAEnB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,iBAAiB,EAAE,CAKnE"}

package/dist/src/languages/javascript/assertionResolver.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * JavaScript/TypeScript assertion resolver.
+ *
+ * Detects assertion patterns linked to HTTP response variables:
+ *   - expect(response).toHaveProperty(...)  → body-field
+ *   - expect(response.status).toBe(200)     → status-code
+ *   - expect(response.statusCode).toEqual(200) → status-code
+ *   - response.expect(200)                  → fluent-chain (supertest)
+ *   - .expect(res => { ... })               → fluent-chain
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAssertions = extractAssertions;
+/**
+ * Extract all assertion nodes from an AST subtree.
+ */
+function extractAssertions(ast) {
+    const assertions = [];
+    if (!ast)
+        return assertions;
+    walkForAssertions(ast, assertions);
+    return assertions;
+}
+function walkForAssertions(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (node.type === 'CallExpression') {
+        const assertion = tryExtractAssertion(node);
+        if (assertion) {
+            out.push(assertion);
+        }
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'parent' || key === 'tokens' || key === 'comments')
+            continue;
+        const child = node[key];
+        if (Array.isArray(child)) {
+            for (const c of child) {
+                if (c && typeof c === 'object' && c.type)
+                    walkForAssertions(c, out);
+            }
+        }
+        else if (child && typeof child === 'object' && child.type) {
+            walkForAssertions(child, out);
+        }
+    }
+}
+function tryExtractAssertion(callNode) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+    const callee = callNode.callee;
+    if (!callee)
+        return null;
+    // expect(subject) — the start of a Jest/Jasmine assertion chain
+    if (callee.type === 'Identifier' && callee.name === 'expect') {
+        const subject = (_a = callNode.arguments) === null || _a === void 0 ? void 0 : _a[0];
+        if (!subject)
+            return null;
+        const { variable, assertionType } = classifyExpectSubject(subject);
+        return { assertionType, subjectVariable: variable, line: (_c = (_b = callNode.loc) === null || _b === void 0 ? void 0 : _b.start) === null || _c === void 0 ? void 0 : _c.line };
+    }
+    // expect(subject).toBe / toEqual / toHaveProperty etc.
+    if (callee.type === 'MemberExpression' && ((_d = callee.object) === null || _d === void 0 ? void 0 : _d.type) === 'CallExpression') {
+        const innerCall = callee.object;
+        if (((_e = innerCall.callee) === null || _e === void 0 ? void 0 : _e.name) === 'expect') {
+            const subject = (_f = innerCall.arguments) === null || _f === void 0 ? void 0 : _f[0];
+            if (!subject)
+                return null;
+            const methodName = (_j = (_h = (_g = callee.property) === null || _g === void 0 ? void 0 : _g.name) === null || _h === void 0 ? void 0 : _h.toLowerCase()) !== null && _j !== void 0 ? _j : '';
+            const assertionType = classifyAssertionMethod(methodName);
+            const { variable } = classifyExpectSubject(subject);
+            return { assertionType, subjectVariable: variable, line: (_l = (_k = callNode.loc) === null || _k === void 0 ? void 0 : _k.start) === null || _l === void 0 ? void 0 : _l.line };
+        }
+    }
+    // supertest fluent: response.expect(200) or .expect(res => { ... })
+    if (callee.type === 'MemberExpression' && ((_m = callee.property) === null || _m === void 0 ? void 0 : _m.name) === 'expect') {
+        const obj = callee.object;
+        const varName = (obj === null || obj === void 0 ? void 0 : obj.type) === 'Identifier'
+            ? obj.name
+            : (obj === null || obj === void 0 ? void 0 : obj.type) === 'CallExpression'
+                ? undefined // chained call — variable is unknown
+                : undefined;
+        const firstArg = (_o = callNode.arguments) === null || _o === void 0 ? void 0 : _o[0];
+        if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.type) === 'Literal' && typeof firstArg.value === 'number') {
+            return {
+                assertionType: 'status-code',
+                subjectVariable: varName,
+                line: (_q = (_p = callNode.loc) === null || _p === void 0 ? void 0 : _p.start) === null || _q === void 0 ? void 0 : _q.line,
+            };
+        }
+        return {
+            assertionType: 'fluent-chain',
+            subjectVariable: varName,
+            line: (_s = (_r = callNode.loc) === null || _r === void 0 ? void 0 : _r.start) === null || _s === void 0 ? void 0 : _s.line,
+        };
+    }
+    // assert(condition), assert.equal, chai assert
+    if (callee.type === 'Identifier' && callee.name === 'assert') {
+        return { assertionType: 'status-code', line: (_u = (_t = callNode.loc) === null || _t === void 0 ? void 0 : _t.start) === null || _u === void 0 ? void 0 : _u.line };
+    }
+    if (callee.type === 'MemberExpression' &&
+        (((_v = callee.object) === null || _v === void 0 ? void 0 : _v.name) === 'assert' || ((_w = callee.object) === null || _w === void 0 ? void 0 : _w.name) === 'chai')) {
+        return {
+            assertionType: 'body-field',
+            line: (_y = (_x = callNode.loc) === null || _x === void 0 ? void 0 : _x.start) === null || _y === void 0 ? void 0 : _y.line,
+        };
+    }
+    return null;
+}
+function classifyExpectSubject(subject) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (subject.type === 'Identifier') {
+        return { variable: subject.name, assertionType: 'body-field' };
+    }
+    if (subject.type === 'MemberExpression') {
+        const obj = subject.object;
+        const prop = (_c = (_b = (_a = subject.property) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : '';
+        const variable = (obj === null || obj === void 0 ? void 0 : obj.type) === 'Identifier' ? obj.name : undefined;
+        if (prop === 'status' || prop === 'statuscode' || prop === 'status_code') {
+            return { variable, assertionType: 'status-code' };
+        }
+        if (prop === 'body' || prop === 'data' || prop === 'json') {
+            return { variable, assertionType: 'body-field' };
+        }
+        return { variable, assertionType: 'body-field' };
+    }
+    if (subject.type === 'CallExpression') {
+        const methodName = (_g = (_f = (_e = (_d = subject.callee) === null || _d === void 0 ? void 0 : _d.property) === null || _e === void 0 ? void 0 : _e.name) === null || _f === void 0 ? void 0 : _f.toLowerCase()) !== null && _g !== void 0 ? _g : '';
+        const variable = (_j = (_h = subject.callee) === null || _h === void 0 ? void 0 : _h.object) === null || _j === void 0 ? void 0 : _j.name;
+        if (methodName === 'json' || methodName === 'text') {
+            return { variable, assertionType: 'body-field' };
+        }
+    }
+    return { variable: undefined, assertionType: 'body-field' };
+}
+function classifyAssertionMethod(methodName) {
+    if (methodName === 'tobe' ||
+        methodName === 'toequal' ||
+        methodName === 'tostrictequal' ||
+        methodName === 'tobetruthy' ||
+        methodName === 'tobefalsy') {
+        return 'status-code'; // Could be either, default to status-code
+    }
+    if (methodName === 'tohaveproperty' || methodName === 'tocontain' || methodName === 'tomatch') {
+        return 'body-field';
+    }
+    if (methodName === 'tothrow' || methodName === 'tothrowserror') {
+        return 'exception-catch';
+    }
+    return 'body-field';
+}