api-tests-coverage 1.0.15 → 1.0.17

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

@@ -97,6 +97,8 @@ function extractJavaFunctions(root, constants) {
             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');
+        // Extract method parameters
+        const parameters = extractMethodParameters(method);
         const bodyHttpCalls = [];
         const calledFunctions = [];
         let returnValue;
@@ -109,7 +111,7 @@ function extractJavaFunctions(root, constants) {
         const cucumberPattern = extractCucumberPattern(annotations, method);
         graph.set(name, {
             name,
-            parameters: [],
+            parameters,
             bodyHttpCalls,
             calledFunctions,
             returnValue,
@@ -121,14 +123,44 @@ function extractJavaFunctions(root, constants) {
 }
 // ─── HTTP call extraction ─────────────────────────────────────────────────────
 function extractJavaHttpCalls(block, constants, out) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
     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();
+        // MockMvc: perform(get("/path")) — extract the inner HTTP method call
+        if (lowerMethod === 'perform') {
+            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;
+            // The argument to perform() is a method invocation like get("/path") or post("/path")
+            const innerInvocations = (0, treeSitterUtils_1.findNodes)(argList, ['method_invocation']);
+            for (const innerInvoc of innerInvocations) {
+                const innerMethodName = (_m = (_k = (_j = (_h = innerInvoc.childForFieldName) === null || _h === void 0 ? void 0 : _h.call(innerInvoc, 'name')) === null || _j === void 0 ? void 0 : _j.text) !== null && _k !== void 0 ? _k : (_l = firstChildNamed(innerInvoc, 'identifier')) === null || _l === void 0 ? void 0 : _l.text) !== null && _m !== void 0 ? _m : '';
+                const innerLower = innerMethodName.toLowerCase();
+                if (!HTTP_METHODS.has(innerLower))
+                    continue;
+                const innerArgList = (_p = (_o = innerInvoc.childForFieldName) === null || _o === void 0 ? void 0 : _o.call(innerInvoc, 'arguments')) !== null && _p !== void 0 ? _p : (0, treeSitterUtils_1.firstChildOfType)(innerInvoc, 'argument_list');
+                if (!innerArgList)
+                    continue;
+                const innerStringArg = findFirstStringInArgList(innerArgList, constants);
+                if (!innerStringArg)
+                    continue;
+                const normalizedPath = innerStringArg.value.startsWith('/') ? (0, resolvePaths_1.normalizePathToTemplate)(innerStringArg.value) : undefined;
+                out.push({
+                    method: innerLower.toUpperCase(),
+                    rawPathArg: (_q = innerStringArg.varName) !== null && _q !== void 0 ? _q : innerStringArg.value,
+                    resolvedPath: innerStringArg.value,
+                    normalizedPath,
+                    resolutionType: innerStringArg.isDirect ? 'direct' : 'constant',
+                    confidence: innerStringArg.isDirect ? 'high' : 'medium',
+                });
+            }
+            continue;
+        }
         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');
+        const argList = (_s = (_r = invoc.childForFieldName) === null || _r === void 0 ? void 0 : _r.call(invoc, 'arguments')) !== null && _s !== void 0 ? _s : (0, treeSitterUtils_1.firstChildOfType)(invoc, 'argument_list');
         if (!argList)
             continue;
         // Extract the first string argument (path)
@@ -138,15 +170,6 @@ function extractJavaHttpCalls(block, constants, out) {
         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);
@@ -224,6 +247,40 @@ function extractJavaFlowRefs(root) {
     return refs;
 }
 // ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Extract method parameters with their annotations (e.g. @RequestParam, @PathVariable, @RequestBody).
+ */
+function extractMethodParameters(method) {
+    var _a;
+    const params = [];
+    const formalParams = (0, treeSitterUtils_1.firstChildOfType)(method, 'formal_parameters');
+    if (!formalParams)
+        return params;
+    const paramNodes = (0, treeSitterUtils_1.findNodes)(formalParams, ['formal_parameter', 'spread_parameter']);
+    for (const paramNode of paramNodes) {
+        const paramAnnotations = [];
+        (0, treeSitterUtils_1.walkTree)(paramNode, (n) => {
+            var _a;
+            if (n.type === 'annotation' || n.type === 'marker_annotation') {
+                const nameNode = (0, treeSitterUtils_1.firstChildOfType)(n, 'identifier');
+                if (nameNode)
+                    paramAnnotations.push('@' + ((_a = nameNode.text) !== null && _a !== void 0 ? _a : ''));
+            }
+        });
+        const nameNode = firstChildNamed(paramNode, 'identifier');
+        const name = (_a = nameNode === null || nameNode === void 0 ? void 0 : nameNode.text) !== null && _a !== void 0 ? _a : '';
+        if (!name)
+            continue;
+        // Include annotation prefix for annotated params (Spring @RequestParam, @PathVariable, etc.)
+        if (paramAnnotations.length > 0) {
+            params.push(`${paramAnnotations.join(' ')} ${name}`);
+        }
+        else {
+            params.push(name);
+        }
+    }
+    return params;
+}
 function extractModifierTexts(node) {
     const modifiers = [];
     (0, treeSitterUtils_1.walkTree)(node, (n) => {

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

@@ -0,0 +1,74 @@
+/**
+ * Angular pattern detector (Feature 27, Sub-PR 7)
+ *
+ * Detects:
+ * 1. @Injectable services with HttpClient injection
+ * 2. this.http.get/post/put/delete/patch() API calls
+ * 3. inject(HttpClient) functional style
+ * 4. environment.api_url usage
+ * 5. CanActivateFn / CanActivateChildFn / CanDeactivateFn / ResolveFn guards
+ * 6. implements HttpInterceptor / HttpInterceptorFn interceptors
+ * 7. TestBed.configureTestingModule with HttpClientTestingModule
+ * 8. httpMock.expectOne(url) assertion nodes
+ * 9. signal<T>(), toSignal() patterns
+ */
+export interface AngularHttpCall {
+    method: string;
+    urlPattern: string;
+    usesEnvironmentUrl: boolean;
+    sourceFile: string;
+    line?: number;
+}
+export interface AngularInjection {
+    /** Class that receives the injection */
+    consumerClass: string;
+    /** Service class being injected */
+    serviceClass: string;
+    /** Injection style: constructor, inject function, decorator */
+    style: 'constructor' | 'inject-fn';
+    sourceFile: string;
+    line?: number;
+}
+export interface AngularGuard {
+    name: string;
+    type: 'functional' | 'class-based';
+    guardType: 'CanActivate' | 'CanActivateChild' | 'CanDeactivate' | 'Resolve' | 'CanMatch';
+    sourceFile: string;
+    line?: number;
+}
+export interface AngularInterceptor {
+    name: string;
+    type: 'class-based' | 'functional';
+    sourceFile: string;
+    line?: number;
+}
+export interface AngularTestSetup {
+    usesHttpClientTestingModule: boolean;
+    httpMockExpectations: string[];
+    sourceFile: string;
+}
+/**
+ * Detect Angular HttpClient API calls from source text.
+ */
+export declare function detectAngularHttpCalls(sourceText: string, filePath: string): AngularHttpCall[];
+/**
+ * Detect Angular constructor injections and inject() calls.
+ */
+export declare function detectAngularInjections(sourceText: string, filePath: string): AngularInjection[];
+/**
+ * Detect Angular guards (functional and class-based).
+ */
+export declare function detectAngularGuards(sourceText: string, filePath: string): AngularGuard[];
+/**
+ * Detect Angular HTTP interceptors.
+ */
+export declare function detectAngularInterceptors(sourceText: string, filePath: string): AngularInterceptor[];
+/**
+ * Detect Angular test setup patterns (HttpClientTestingModule, httpMock).
+ */
+export declare function detectAngularTestSetup(sourceText: string, filePath: string): AngularTestSetup;
+/**
+ * Check if source text contains Angular HttpClient usage.
+ */
+export declare function hasAngularHttpClient(sourceText: string): boolean;
+//# sourceMappingURL=angularDetector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"angularDetector.d.ts","sourceRoot":"","sources":["../../../../src/languages/javascript/angularDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,wCAAwC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,mCAAmC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,+DAA+D;IAC/D,KAAK,EAAE,aAAa,GAAG,WAAW,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,GAAG,aAAa,CAAC;IACnC,SAAS,EAAE,aAAa,GAAG,kBAAkB,GAAG,eAAe,GAAG,SAAS,GAAG,UAAU,CAAC;IACzF,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,2BAA2B,EAAE,OAAO,CAAC;IACrC,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe,EAAE,CAyC9F;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,EAAE,CA2EhG;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE,CAyCxF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAgCpG;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAY7F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEhE"}

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

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Angular pattern detector (Feature 27, Sub-PR 7)
+ *
+ * Detects:
+ * 1. @Injectable services with HttpClient injection
+ * 2. this.http.get/post/put/delete/patch() API calls
+ * 3. inject(HttpClient) functional style
+ * 4. environment.api_url usage
+ * 5. CanActivateFn / CanActivateChildFn / CanDeactivateFn / ResolveFn guards
+ * 6. implements HttpInterceptor / HttpInterceptorFn interceptors
+ * 7. TestBed.configureTestingModule with HttpClientTestingModule
+ * 8. httpMock.expectOne(url) assertion nodes
+ * 9. signal<T>(), toSignal() patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAngularHttpCalls = detectAngularHttpCalls;
+exports.detectAngularInjections = detectAngularInjections;
+exports.detectAngularGuards = detectAngularGuards;
+exports.detectAngularInterceptors = detectAngularInterceptors;
+exports.detectAngularTestSetup = detectAngularTestSetup;
+exports.hasAngularHttpClient = hasAngularHttpClient;
+/**
+ * Detect Angular HttpClient API calls from source text.
+ */
+function detectAngularHttpCalls(sourceText, filePath) {
+    const calls = [];
+    const lines = sourceText.split('\n');
+    // this.http.METHOD<Type>('url') or this.httpClient.METHOD('url')
+    const httpCallPattern = /this\.(?:http|httpClient)\.(get|post|put|patch|delete|head|options)(?:<[^>]+>)?\s*\(\s*[`'"]([^`'"]+)[`'"]/;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const match = line.match(httpCallPattern);
+        if (match) {
+            const usesEnvironmentUrl = match[2].includes('environment') || match[2].includes('${');
+            calls.push({
+                method: match[1].toUpperCase(),
+                urlPattern: match[2],
+                usesEnvironmentUrl,
+                sourceFile: filePath,
+                line: i + 1,
+            });
+        }
+    }
+    // Also detect template literal calls: this.http.get(`${this.apiUrl}/articles`)
+    const templatePattern = /this\.(?:http|httpClient)\.(get|post|put|patch|delete)(?:<[^>]+>)?\s*\(\s*`([^`]+)`/g;
+    let tmatch;
+    while ((tmatch = templatePattern.exec(sourceText)) !== null) {
+        const url = tmatch[2];
+        // Avoid duplicates
+        if (!calls.some((c) => c.urlPattern === url)) {
+            const lineNum = sourceText.substring(0, tmatch.index).split('\n').length;
+            calls.push({
+                method: tmatch[1].toUpperCase(),
+                urlPattern: url,
+                usesEnvironmentUrl: url.includes('environment') || url.includes('${'),
+                sourceFile: filePath,
+                line: lineNum,
+            });
+        }
+    }
+    return calls;
+}
+/**
+ * Detect Angular constructor injections and inject() calls.
+ */
+function detectAngularInjections(sourceText, filePath) {
+    const injections = [];
+    const lines = sourceText.split('\n');
+    let currentClass = '';
+    let currentConstHost = '';
+    let inConstructorParams = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Track current class
+        const classMatch = line.match(/class\s+(\w+)/);
+        if (classMatch)
+            currentClass = classMatch[1];
+        // Track current const/export const assignment as potential host for inject() outside class.
+        // Only update when the line is NOT itself an inject() call (e.g. skip `const x = inject(Y)`).
+        if (!currentClass) {
+            const constHostMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*(?::\s*\S+)?\s*=/);
+            if (constHostMatch && !line.match(/=\s*inject\s*\(/)) {
+                currentConstHost = constHostMatch[1];
+            }
+        }
+        // Track constructor parameter block boundaries
+        if (/\bconstructor\s*\(/.test(line)) {
+            inConstructorParams = true;
+        }
+        if (inConstructorParams && line.includes(')')) {
+            // Process this line (it's still inside the constructor params), then close
+            // We'll close after checking for injections below
+        }
+        // Constructor injection: constructor(private http: HttpClient)
+        // Only match visibility-modified parameters when inside a constructor(...) block
+        if (inConstructorParams) {
+            const ctorParamPattern = /(?:private|protected|public|readonly)\s+(\w+)\s*:\s*(\w+)/g;
+            let ctorMatch;
+            while ((ctorMatch = ctorParamPattern.exec(line)) !== null) {
+                if (currentClass) {
+                    injections.push({
+                        consumerClass: currentClass,
+                        serviceClass: ctorMatch[2],
+                        style: 'constructor',
+                        sourceFile: filePath,
+                        line: i + 1,
+                    });
+                }
+            }
+        }
+        // Close the constructor param block after processing (handles closing paren on same line)
+        if (inConstructorParams && line.includes(')')) {
+            inConstructorParams = false;
+        }
+        // Functional inject: inject(HttpClient)
+        const injectMatch = line.match(/(\w+)\s*=\s*inject\s*\(\s*(\w+)\s*\)/);
+        if (injectMatch) {
+            // Use the enclosing class, or fall back to the enclosing const/export const host
+            // (e.g. functional guards/interceptors: `export const authGuard: CanActivateFn = ...`)
+            const hostName = currentClass || currentConstHost;
+            if (hostName) {
+                injections.push({
+                    consumerClass: hostName,
+                    serviceClass: injectMatch[2],
+                    style: 'inject-fn',
+                    sourceFile: filePath,
+                    line: i + 1,
+                });
+            }
+        }
+    }
+    return injections;
+}
+/**
+ * Detect Angular guards (functional and class-based).
+ */
+function detectAngularGuards(sourceText, filePath) {
+    var _a;
+    const guards = [];
+    const lines = sourceText.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Functional guard: export const authGuard: CanActivateFn = ...
+        const functionalMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*:\s*(CanActivateFn|CanActivateChildFn|CanDeactivateFn|ResolveFn|CanMatchFn)/);
+        if (functionalMatch) {
+            const guardTypeMap = {
+                CanActivateFn: 'CanActivate',
+                CanActivateChildFn: 'CanActivateChild',
+                CanDeactivateFn: 'CanDeactivate',
+                ResolveFn: 'Resolve',
+                CanMatchFn: 'CanMatch',
+            };
+            guards.push({
+                name: functionalMatch[1],
+                type: 'functional',
+                guardType: (_a = guardTypeMap[functionalMatch[2]]) !== null && _a !== void 0 ? _a : 'CanActivate',
+                sourceFile: filePath,
+                line: i + 1,
+            });
+            continue;
+        }
+        // Class-based guard: implements CanActivate
+        const classMatch = line.match(/class\s+(\w+).*implements\s+(?:.*,\s*)?(CanActivate|CanActivateChild|CanDeactivate|Resolve|CanMatch)/);
+        if (classMatch) {
+            guards.push({
+                name: classMatch[1],
+                type: 'class-based',
+                guardType: classMatch[2],
+                sourceFile: filePath,
+                line: i + 1,
+            });
+        }
+    }
+    return guards;
+}
+/**
+ * Detect Angular HTTP interceptors.
+ */
+function detectAngularInterceptors(sourceText, filePath) {
+    const interceptors = [];
+    const lines = sourceText.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Class-based: implements HttpInterceptor
+        const classMatch = line.match(/class\s+(\w+).*implements\s+(?:.*,\s*)?HttpInterceptor/);
+        if (classMatch) {
+            interceptors.push({
+                name: classMatch[1],
+                type: 'class-based',
+                sourceFile: filePath,
+                line: i + 1,
+            });
+            continue;
+        }
+        // Functional: HttpInterceptorFn
+        const fnMatch = line.match(/(?:export\s+)?(?:const|let)\s+(\w+)\s*:\s*HttpInterceptorFn/);
+        if (fnMatch) {
+            interceptors.push({
+                name: fnMatch[1],
+                type: 'functional',
+                sourceFile: filePath,
+                line: i + 1,
+            });
+        }
+    }
+    return interceptors;
+}
+/**
+ * Detect Angular test setup patterns (HttpClientTestingModule, httpMock).
+ */
+function detectAngularTestSetup(sourceText, filePath) {
+    const usesHttpClientTestingModule = /HttpClientTestingModule|provideHttpClientTesting/.test(sourceText);
+    const httpMockExpectations = [];
+    const expectOnePattern = /httpMock\.expectOne\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+    let match;
+    while ((match = expectOnePattern.exec(sourceText)) !== null) {
+        httpMockExpectations.push(match[1]);
+    }
+    return { usesHttpClientTestingModule, httpMockExpectations, sourceFile: filePath };
+}
+/**
+ * Check if source text contains Angular HttpClient usage.
+ */
+function hasAngularHttpClient(sourceText) {
+    return /HttpClient|this\.http\.(get|post|put|patch|delete)/.test(sourceText);
+}

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

@@ -66,8 +66,8 @@ function tryExtractAssertion(callNode) {
             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);
+            const { variable, assertionType: subjectType } = classifyExpectSubject(subject);
+            const assertionType = classifyAssertionMethod(methodName, subjectType);
             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 };
         }
     }
@@ -132,13 +132,15 @@ function classifyExpectSubject(subject) {
     }
     return { variable: undefined, assertionType: 'body-field' };
 }
-function classifyAssertionMethod(methodName) {
+function classifyAssertionMethod(methodName, subjectType) {
     if (methodName === 'tobe' ||
         methodName === 'toequal' ||
         methodName === 'tostrictequal' ||
         methodName === 'tobetruthy' ||
         methodName === 'tobefalsy') {
-        return 'status-code'; // Could be either, default to status-code
+        // These methods are ambiguous — use subject context to decide.
+        // Only classify as status-code when the subject involves status.
+        return subjectType === 'status-code' ? 'status-code' : 'body-field';
     }
     if (methodName === 'tohaveproperty' || methodName === 'tocontain' || methodName === 'tomatch') {
         return 'body-field';

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

@@ -0,0 +1,40 @@
+/**
+ * HapiJS pattern detector (Feature 27, Sub-PR 8)
+ *
+ * Detects:
+ * 1. server.route({ method, path, options: { auth, validate, handler } })
+ * 2. Joi validator chains: Joi.string().required(), Joi.number().min().max().default()
+ * 3. auth: 'jwt' = required, auth: { mode: 'try' } = optional
+ * 4. Boom error responses: Boom.notFound(), Boom.unauthorized()
+ */
+export interface HapiRoute {
+    method: string;
+    path: string;
+    auth?: HapiAuth;
+    validation?: HapiValidation;
+    sourceFile: string;
+    line?: number;
+}
+export interface HapiAuth {
+    strategy?: string;
+    mode: 'required' | 'optional' | 'try';
+}
+export interface HapiValidation {
+    queryParams: string[];
+    payloadParams: string[];
+}
+export interface HapiBoomError {
+    errorType: string;
+    statusCode?: number;
+    sourceFile: string;
+    line?: number;
+}
+/**
+ * Detect HapiJS route definitions from source text.
+ */
+export declare function detectHapiRoutes(sourceText: string, filePath: string): HapiRoute[];
+/**
+ * Detect Boom error responses.
+ */
+export declare function detectBoomErrors(sourceText: string, filePath: string): HapiBoomError[];
+//# sourceMappingURL=hapiDetector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hapiDetector.d.ts","sourceRoot":"","sources":["../../../../src/languages/javascript/hapiDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,KAAK,CAAC;CACvC;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAkBD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CA6HlF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAmBtF"}