api-tests-coverage 1.0.15 → 1.0.16

package/dist/src/inference/routeInference.js

@@ -134,6 +134,12 @@ function inferRoutesFromFile(filePath) {
     if (ext === '.java' || ext === '.kt' || ext === '.kts') {
         return inferRoutesFromJavaFile(filePath);
     }
+    if (ext === '.py') {
+        return inferRoutesFromPythonFile(filePath);
+    }
+    if (ext === '.php') {
+        return inferRoutesFromPhpFile(filePath);
+    }
     let content;
     try {
         content = fs.readFileSync(filePath, 'utf-8');
@@ -203,7 +209,17 @@ function inferRoutesFromFile(filePath) {
                 addRoute(method, routePath, lineIdx + 1, 'code');
             }
         }
-        // 4. AngularJS / fetch / axios — { url: base + '/path', method: 'GET' }
+        // 4. HapiJS server.route({ method: 'GET', path: '/path', ... })
+        const hapiMethodMatch = line.match(/method\s*:\s*['"](\w+)['"]/);
+        const hapiPathMatch = line.match(/path\s*:\s*['"]([^'"]+)['"]/);
+        if (hapiMethodMatch && hapiPathMatch) {
+            const method = hapiMethodMatch[1].toLowerCase();
+            if (exports.HTTP_METHODS.includes(method)) {
+                addRoute(method, hapiPathMatch[1], lineIdx + 1, 'code');
+                continue;
+            }
+        }
+        // 5. AngularJS / fetch / axios — { url: base + '/path', method: 'GET' }
         //    Only active when the file contains an HTTP-client signal.
         if (usesHttpClient) {
             const httpMethodKey = line.match(ANGULAR_HTTP_METHOD_KEY);
@@ -259,6 +275,22 @@ const SPRING_CLASS_BASE_PATH = /@RequestMapping\s*\(\s*(?:path\s*=\s*)?["']([^"'
 const SPRING_METHOD_MAPPING = /@(Get|Post|Put|Patch|Delete)Mapping(?:\s*\(\s*(?:path\s*=\s*)?["']([^"']*)["'])?/i;
 /** Matches @RequestMapping with explicit method= (used when special HTTP method needed) */
 const SPRING_REQUEST_MAPPING_EXPLICIT = /@RequestMapping\s*\((?:[^)]*?\bpath\s*=\s*["']([^"']+)["'][^)]*?\bmethod\s*=\s*(?:RequestMethod\.)?([A-Z]+)|(?:[^)]*?\bmethod\s*=\s*(?:RequestMethod\.)?([A-Z]+)[^)]*?\bpath\s*=\s*["']([^"']+)["']))/;
+/**
+ * Matches DGS @DgsQuery and @DgsMutation annotations.
+ *   @DgsQuery                          → Query field (method name = field name)
+ *   @DgsQuery(field = "articles")      → Query field "articles"
+ *   @DgsMutation(field = "createArticle") → Mutation field "createArticle"
+ */
+const DGS_QUERY = /@DgsQuery(?:\s*\(\s*(?:field\s*=\s*)?["']?(\w+)["']?\s*\))?/;
+const DGS_MUTATION = /@DgsMutation(?:\s*\(\s*(?:field\s*=\s*)?["']?(\w+)["']?\s*\))?/;
+/**
+ * Matches Spring GraphQL @QueryMapping and @MutationMapping.
+ *   @QueryMapping                      → Query (method name)
+ *   @QueryMapping("articles")          → Query "articles"
+ *   @MutationMapping("createArticle")  → Mutation "createArticle"
+ */
+const SPRING_QUERY_MAPPING = /@QueryMapping(?:\s*\(\s*["']?(\w+)["']?\s*\))?/;
+const SPRING_MUTATION_MAPPING = /@MutationMapping(?:\s*\(\s*["']?(\w+)["']?\s*\))?/;
 /**
  * Infer Spring routes from a  Java or Kotlin source file.
  * Works in two passes:
@@ -318,6 +350,197 @@ function inferRoutesFromJavaFile(filePath) {
                 addRoute(rawMethod, fullPath, i + 1);
             }
         }
+        // DGS @DgsQuery / @DgsMutation — detect as POST /graphql (convention)
+        const dgsQ = line.match(DGS_QUERY);
+        if (dgsQ) {
+            const fieldName = dgsQ[1] || findNextMethodNameInJava(lines, i);
+            if (fieldName) {
+                addRoute('post', '/graphql', i + 1);
+            }
+            continue;
+        }
+        const dgsM = line.match(DGS_MUTATION);
+        if (dgsM) {
+            const fieldName = dgsM[1] || findNextMethodNameInJava(lines, i);
+            if (fieldName) {
+                addRoute('post', '/graphql', i + 1);
+            }
+            continue;
+        }
+        // Spring GraphQL @QueryMapping / @MutationMapping — detect as POST /graphql
+        const sqm = line.match(SPRING_QUERY_MAPPING);
+        if (sqm) {
+            addRoute('post', '/graphql', i + 1);
+            continue;
+        }
+        const smm = line.match(SPRING_MUTATION_MAPPING);
+        if (smm) {
+            addRoute('post', '/graphql', i + 1);
+            continue;
+        }
+    }
+    return [...byKey.values()];
+}
+/** Find the next method name after an annotation line (for DGS/GraphQL) */
+function findNextMethodNameInJava(javaLines, fromLine) {
+    for (let j = fromLine + 1; j < Math.min(fromLine + 5, javaLines.length); j++) {
+        const methodMatch = javaLines[j].match(/(?:public|private|protected|fun)\s+\S+\s+(\w+)\s*\(/);
+        if (methodMatch)
+            return methodMatch[1];
+        const kotlinMatch = javaLines[j].match(/fun\s+(\w+)\s*\(/);
+        if (kotlinMatch)
+            return kotlinMatch[1];
+    }
+    return undefined;
+}
+// ─── Python / Flask / FastAPI inference ───────────────────────────────────────
+/**
+ * Matches Flask @app.route() and @blueprint.route() decorators.
+ *   @app.route('/articles', methods=['GET', 'POST'])
+ *   @blueprint.route('/articles/<slug>', methods=['PUT'])
+ *   @app.route('/tags')   ← defaults to GET
+ */
+const FLASK_ROUTE = /@(\w+)\.route\s*\(\s*['"]([^'"]+)['"](?:\s*,\s*methods\s*=\s*\[([^\]]+)\])?\s*\)/;
+/**
+ * Matches FastAPI decorators.
+ *   @app.get('/articles')
+ *   @router.post('/users')
+ *   @app.delete('/articles/{slug}')
+ */
+const FASTAPI_ROUTE = /@(\w+)\.(get|post|put|patch|delete|head|options)\s*\(\s*['"]([^'"]+)['"]/i;
+/**
+ * Matches Flask Blueprint constructor.
+ *   articles = Blueprint('articles', __name__)
+ *   bp = Blueprint("users", __name__, url_prefix="/users")
+ */
+const FLASK_BLUEPRINT_CTOR = /(\w+)\s*=\s*Blueprint\s*\(\s*['"][^'"]+['"](?:\s*,\s*[^,)]+)*?(?:\s*,\s*url_prefix\s*=\s*['"]([^'"]+)['"])?\s*\)/;
+/**
+ * Matches FastAPI APIRouter constructor with prefix.
+ *   router = APIRouter(prefix="/articles")
+ */
+const FASTAPI_APIROUTER = /(\w+)\s*=\s*APIRouter\s*\([^)]*?prefix\s*=\s*['"]([^'"]+)['"]/;
+/**
+ * Infer routes from a Python (Flask/FastAPI) source file.
+ */
+function inferRoutesFromPythonFile(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split('\n');
+    const byKey = new Map();
+    const addRoute = (method, routePath, lineNumber) => {
+        const key = `${method}:${routePath}`;
+        if (!byKey.has(key)) {
+            byKey.set(key, { method, path: routePath, sourceFile: filePath, lineNumber, discoveredVia: 'code' });
+        }
+    };
+    // Pass 1: Detect blueprint/router prefix for the file
+    let localPrefix = '';
+    for (const line of lines) {
+        const bpMatch = line.match(FLASK_BLUEPRINT_CTOR);
+        if (bpMatch && bpMatch[2]) {
+            localPrefix = bpMatch[2];
+            break;
+        }
+        const arMatch = line.match(FASTAPI_APIROUTER);
+        if (arMatch && arMatch[2]) {
+            localPrefix = arMatch[2];
+            break;
+        }
+    }
+    // Pass 2: Detect routes
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Flask @xxx.route('/path', methods=[...])
+        const flaskMatch = line.match(FLASK_ROUTE);
+        if (flaskMatch) {
+            const routePath = flaskMatch[2];
+            const methodsList = flaskMatch[3];
+            const fullPath = localPrefix + (routePath.startsWith('/') ? routePath : '/' + routePath);
+            // Normalize Flask <param> to {param}
+            const normalizedPath = fullPath.replace(/<(?:\w+:)?(\w+)>/g, '{$1}');
+            if (methodsList) {
+                // Parse methods=['GET', 'POST'] → individual routes
+                const methods = methodsList.replace(/['"]/g, '').split(',').map((m) => m.trim().toLowerCase());
+                for (const m of methods) {
+                    if (exports.HTTP_METHODS.includes(m)) {
+                        addRoute(m, normalizedPath, i + 1);
+                    }
+                }
+            }
+            else {
+                // Default to GET
+                addRoute('get', normalizedPath, i + 1);
+            }
+            continue;
+        }
+        // FastAPI @xxx.get('/path'), @xxx.post('/path'), etc.
+        const fastapiMatch = line.match(FASTAPI_ROUTE);
+        if (fastapiMatch) {
+            const httpMethod = fastapiMatch[2].toLowerCase();
+            const routePath = fastapiMatch[3];
+            const fullPath = localPrefix + (routePath.startsWith('/') ? routePath : '/' + routePath);
+            // FastAPI uses {param} natively
+            addRoute(httpMethod, fullPath, i + 1);
+            continue;
+        }
+    }
+    return [...byKey.values()];
+}
+// ─── PHP / Slim inference ─────────────────────────────────────────────────────
+/**
+ * Matches Slim PHP route definitions:
+ *   $app->get('/articles', Controller::class . ':method')
+ *   $app->post('/articles/{slug}', 'Controller:method')
+ *   $group->get('/articles', ArticleController::class . ':list')
+ */
+const SLIM_ROUTE = /\$\w+->(get|post|put|patch|delete|options|head)\s*\(\s*['"]([^'"]+)['"]/i;
+/**
+ * Matches Slim group definitions:
+ *   $app->group('/api', function($group) { ... })
+ *   $app->group('/api/articles', function(RouteCollectorProxy $group) { ... })
+ */
+const SLIM_GROUP = /\$\w+->group\s*\(\s*['"]([^'"]+)['"]/;
+function inferRoutesFromPhpFile(filePath) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split('\n');
+    const byKey = new Map();
+    const addRoute = (method, routePath, lineNumber) => {
+        const key = `${method}:${routePath}`;
+        if (!byKey.has(key)) {
+            byKey.set(key, { method, path: routePath, sourceFile: filePath, lineNumber, discoveredVia: 'code' });
+        }
+    };
+    // Track group prefixes
+    let groupPrefix = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Group prefix
+        const groupMatch = line.match(SLIM_GROUP);
+        if (groupMatch) {
+            groupPrefix = groupMatch[1];
+            continue;
+        }
+        // Route definition
+        const routeMatch = line.match(SLIM_ROUTE);
+        if (routeMatch) {
+            const method = routeMatch[1].toLowerCase();
+            const path = routeMatch[2];
+            const fullPath = groupPrefix
+                ? groupPrefix + (path.startsWith('/') ? path : '/' + path)
+                : path;
+            addRoute(method, fullPath, i + 1);
+        }
     }
     return [...byKey.values()];
 }

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

@@ -0,0 +1,65 @@
+/**
+ * GraphQL schema parser (Feature 27, Sub-PR 5)
+ *
+ * Parses .graphqls and .graphql schema files to extract:
+ * 1. type Query { ... } fields as endpoint nodes with protocol: graphql
+ * 2. type Mutation { ... } fields as endpoint nodes with protocol: graphql
+ * 3. input types as parameter definitions
+ *
+ * Also detects DGS data fetcher annotations: @DgsQuery, @DgsMutation, @DgsData
+ */
+export interface GraphqlField {
+    /** The field name (e.g. 'articles', 'createArticle') */
+    name: string;
+    /** 'query' or 'mutation' or 'subscription' */
+    operationType: 'query' | 'mutation' | 'subscription';
+    /** Return type as written in the schema */
+    returnType: string;
+    /** Arguments with their types */
+    arguments: Array<{
+        name: string;
+        type: string;
+    }>;
+    line?: number;
+}
+export interface GraphqlInputType {
+    name: string;
+    fields: Array<{
+        name: string;
+        type: string;
+    }>;
+    line?: number;
+}
+export interface GraphqlSchema {
+    filePath: string;
+    queries: GraphqlField[];
+    mutations: GraphqlField[];
+    subscriptions: GraphqlField[];
+    inputTypes: GraphqlInputType[];
+}
+/**
+ * Parse a .graphqls or .graphql schema file.
+ * Uses targeted regex parsing for the well-structured format.
+ */
+export declare function parseGraphqlSchema(content: string, filePath: string): GraphqlSchema;
+export interface DgsDataFetcher {
+    /** Java/Kotlin method name */
+    methodName: string;
+    /** The annotation type: @DgsQuery, @DgsMutation, @DgsData, etc. */
+    annotation: string;
+    /** The parent type (from @DgsData parentType=) or implicit from @DgsQuery/@DgsMutation */
+    parentType: string;
+    /** The field name (from annotation value or method name) */
+    fieldName: string;
+    sourceFile: string;
+    line?: number;
+}
+/**
+ * Detect DGS data fetcher annotations from Java/Kotlin source.
+ */
+export declare function detectDgsAnnotations(sourceContent: string, filePath: string): DgsDataFetcher[];
+/**
+ * Check if a file is a GraphQL schema file.
+ */
+export declare function isGraphqlSchemaFile(filePath: string): boolean;
+//# sourceMappingURL=graphqlSchemaParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlSchemaParser.d.ts","sourceRoot":"","sources":["../../../../src/languages/java/graphqlSchemaParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,aAAa,EAAE,OAAO,GAAG,UAAU,GAAG,cAAc,CAAC;IACrD,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,SAAS,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,UAAU,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAOnF;AAkFD,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,UAAU,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CA2D9F;AAcD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE7D"}

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

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * GraphQL schema parser (Feature 27, Sub-PR 5)
+ *
+ * Parses .graphqls and .graphql schema files to extract:
+ * 1. type Query { ... } fields as endpoint nodes with protocol: graphql
+ * 2. type Mutation { ... } fields as endpoint nodes with protocol: graphql
+ * 3. input types as parameter definitions
+ *
+ * Also detects DGS data fetcher annotations: @DgsQuery, @DgsMutation, @DgsData
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphqlSchema = parseGraphqlSchema;
+exports.detectDgsAnnotations = detectDgsAnnotations;
+exports.isGraphqlSchemaFile = isGraphqlSchemaFile;
+/**
+ * Parse a .graphqls or .graphql schema file.
+ * Uses targeted regex parsing for the well-structured format.
+ */
+function parseGraphqlSchema(content, filePath) {
+    const queries = extractTypeFields(content, 'Query', 'query');
+    const mutations = extractTypeFields(content, 'Mutation', 'mutation');
+    const subscriptions = extractTypeFields(content, 'Subscription', 'subscription');
+    const inputTypes = extractInputTypes(content);
+    return { filePath, queries, mutations, subscriptions, inputTypes };
+}
+function extractTypeFields(content, typeName, operationType) {
+    const fields = [];
+    // Match type Query { ... } or extend type Query { ... }
+    const typePattern = new RegExp(`(?:extend\\s+)?type\\s+${typeName}\\s*\\{([\\s\\S]*?)\\}`, 'g');
+    let typeMatch;
+    while ((typeMatch = typePattern.exec(content)) !== null) {
+        const body = typeMatch[1];
+        const bodyStartLine = content.substring(0, typeMatch.index).split('\n').length;
+        const lines = body.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            // Field pattern: fieldName(arg1: Type1, arg2: Type2): ReturnType
+            const fieldMatch = line.match(/^(\w+)\s*(?:\(([^)]*)\))?\s*:\s*(.+?)(?:\s*@.*)?$/);
+            if (fieldMatch) {
+                const args = [];
+                if (fieldMatch[2]) {
+                    const argParts = fieldMatch[2].split(',');
+                    for (const part of argParts) {
+                        const argMatch = part.trim().match(/(\w+)\s*:\s*(.+)/);
+                        if (argMatch) {
+                            args.push({ name: argMatch[1], type: argMatch[2].trim() });
+                        }
+                    }
+                }
+                fields.push({
+                    name: fieldMatch[1],
+                    operationType,
+                    returnType: fieldMatch[3].trim(),
+                    arguments: args,
+                    line: bodyStartLine + i,
+                });
+            }
+        }
+    }
+    return fields;
+}
+function extractInputTypes(content) {
+    const inputs = [];
+    const inputPattern = /input\s+(\w+)\s*\{([\s\S]*?)\}/g;
+    let match;
+    while ((match = inputPattern.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const line = content.substring(0, match.index).split('\n').length;
+        const fields = [];
+        const fieldLines = body.split('\n');
+        for (const fl of fieldLines) {
+            const trimmed = fl.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const fieldMatch = trimmed.match(/(\w+)\s*:\s*(.+)/);
+            if (fieldMatch) {
+                fields.push({ name: fieldMatch[1], type: fieldMatch[2].trim() });
+            }
+        }
+        inputs.push({ name, fields, line });
+    }
+    return inputs;
+}
+/**
+ * Detect DGS data fetcher annotations from Java/Kotlin source.
+ */
+function detectDgsAnnotations(sourceContent, filePath) {
+    const fetchers = [];
+    const lines = sourceContent.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // @DgsQuery or @DgsQuery(field = "articles")
+        const queryMatch = line.match(/@DgsQuery(?:\s*\(\s*(?:field\s*=\s*)?["']?(\w+)["']?\s*\))?/);
+        if (queryMatch) {
+            const methodName = findNextMethodName(lines, i);
+            if (methodName) {
+                fetchers.push({
+                    methodName,
+                    annotation: '@DgsQuery',
+                    parentType: 'Query',
+                    fieldName: queryMatch[1] || methodName,
+                    sourceFile: filePath,
+                    line: i + 1,
+                });
+            }
+            continue;
+        }
+        // @DgsMutation
+        const mutationMatch = line.match(/@DgsMutation(?:\s*\(\s*(?:field\s*=\s*)?["']?(\w+)["']?\s*\))?/);
+        if (mutationMatch) {
+            const methodName = findNextMethodName(lines, i);
+            if (methodName) {
+                fetchers.push({
+                    methodName,
+                    annotation: '@DgsMutation',
+                    parentType: 'Mutation',
+                    fieldName: mutationMatch[1] || methodName,
+                    sourceFile: filePath,
+                    line: i + 1,
+                });
+            }
+            continue;
+        }
+        // @DgsData(parentType = "Article", field = "author")
+        const dataMatch = line.match(/@DgsData\s*\(\s*parentType\s*=\s*["'](\w+)["'](?:\s*,\s*field\s*=\s*["'](\w+)["'])?\s*\)/);
+        if (dataMatch) {
+            const methodName = findNextMethodName(lines, i);
+            if (methodName) {
+                fetchers.push({
+                    methodName,
+                    annotation: '@DgsData',
+                    parentType: dataMatch[1],
+                    fieldName: dataMatch[2] || methodName,
+                    sourceFile: filePath,
+                    line: i + 1,
+                });
+            }
+        }
+    }
+    return fetchers;
+}
+function findNextMethodName(lines, fromLine) {
+    for (let j = fromLine + 1; j < Math.min(fromLine + 5, lines.length); j++) {
+        // Java: public List<Article> articles(...) or fun articles(...)
+        const methodMatch = lines[j].match(/(?:public|private|protected|fun)\s+\S+\s+(\w+)\s*\(/);
+        if (methodMatch)
+            return methodMatch[1];
+        // Kotlin shorthand: fun articles(
+        const kotlinMatch = lines[j].match(/fun\s+(\w+)\s*\(/);
+        if (kotlinMatch)
+            return kotlinMatch[1];
+    }
+    return undefined;
+}
+/**
+ * Check if a file is a GraphQL schema file.
+ */
+function isGraphqlSchemaFile(filePath) {
+    return /\.graphqls?$/.test(filePath);
+}

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

@@ -0,0 +1,52 @@
+/**
+ * MyBatis XML mapper parser (Feature 27, Sub-PR 5)
+ *
+ * Parses MyBatis XML mapper files to extract:
+ * 1. <mapper namespace="..."> — linking to Java @Mapper interface
+ * 2. <select>, <insert>, <update>, <delete> — as repository-query nodes
+ * 3. <if>, <choose>/<when>/<otherwise>, <foreach> — as conditional branch nodes
+ * 4. <resultMap>, <association> — as DB schema evidence
+ */
+export interface MyBatisQuery {
+    /** The SQL operation id (method name in the mapper interface) */
+    id: string;
+    /** SQL operation type */
+    type: 'select' | 'insert' | 'update' | 'delete';
+    /** The result type if specified */
+    resultType?: string;
+    /** The result map id if specified */
+    resultMap?: string;
+    /** The parameter type if specified */
+    parameterType?: string;
+    /** Whether the query has conditional branches (<if>, <choose>) */
+    hasConditionals: boolean;
+    /** Number of conditional branches */
+    conditionalCount: number;
+    line?: number;
+}
+export interface MyBatisResultMap {
+    id: string;
+    type: string;
+    associations: string[];
+    collections: string[];
+}
+export interface MyBatisMapperFile {
+    /** Java interface FQCN from namespace attribute */
+    namespace: string;
+    /** Path to the XML file */
+    filePath: string;
+    /** Parsed queries */
+    queries: MyBatisQuery[];
+    /** Parsed result maps */
+    resultMaps: MyBatisResultMap[];
+}
+/**
+ * Parse a MyBatis mapper XML file.
+ * Uses regex-based parsing since MyBatis XML is highly structured.
+ */
+export declare function parseMyBatisMapper(xmlContent: string, filePath: string): MyBatisMapperFile | null;
+/**
+ * Check if a file is a MyBatis XML mapper.
+ */
+export declare function isMyBatisMapperXml(content: string): boolean;
+//# sourceMappingURL=mybatisXmlParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mybatisXmlParser.d.ts","sourceRoot":"","sources":["../../../../src/languages/java/mybatisXmlParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,YAAY;IAC3B,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAChD,mCAAmC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,eAAe,EAAE,OAAO,CAAC;IACzB,qCAAqC;IACrC,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB;IACrB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,yBAAyB;IACzB,UAAU,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAUjG;AA0FD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI3D"}

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

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * MyBatis XML mapper parser (Feature 27, Sub-PR 5)
+ *
+ * Parses MyBatis XML mapper files to extract:
+ * 1. <mapper namespace="..."> — linking to Java @Mapper interface
+ * 2. <select>, <insert>, <update>, <delete> — as repository-query nodes
+ * 3. <if>, <choose>/<when>/<otherwise>, <foreach> — as conditional branch nodes
+ * 4. <resultMap>, <association> — as DB schema evidence
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMyBatisMapper = parseMyBatisMapper;
+exports.isMyBatisMapperXml = isMyBatisMapperXml;
+/**
+ * Parse a MyBatis mapper XML file.
+ * Uses regex-based parsing since MyBatis XML is highly structured.
+ */
+function parseMyBatisMapper(xmlContent, filePath) {
+    // Extract namespace
+    const namespaceMatch = xmlContent.match(/<mapper\s+namespace\s*=\s*["']([^"']+)["']/);
+    if (!namespaceMatch)
+        return null;
+    const namespace = namespaceMatch[1];
+    const queries = extractQueries(xmlContent);
+    const resultMaps = extractResultMaps(xmlContent);
+    return { namespace, filePath, queries, resultMaps };
+}
+function extractQueries(xml) {
+    const queries = [];
+    const queryTypes = ['select', 'insert', 'update', 'delete'];
+    for (const type of queryTypes) {
+        // Match opening tag with attributes
+        const tagPattern = new RegExp(`<${type}\\s+([^>]*)>([\\s\\S]*?)</${type}>`, 'gi');
+        let match;
+        while ((match = tagPattern.exec(xml)) !== null) {
+            const attrs = match[1];
+            const body = match[2];
+            const idMatch = attrs.match(/id\s*=\s*["']([^"']+)["']/);
+            if (!idMatch)
+                continue;
+            const resultTypeMatch = attrs.match(/resultType\s*=\s*["']([^"']+)["']/);
+            const resultMapMatch = attrs.match(/resultMap\s*=\s*["']([^"']+)["']/);
+            const paramTypeMatch = attrs.match(/parameterType\s*=\s*["']([^"']+)["']/);
+            // Count conditionals
+            const ifCount = (body.match(/<if\b/g) || []).length;
+            const chooseCount = (body.match(/<choose\b/g) || []).length;
+            const foreachCount = (body.match(/<foreach\b/g) || []).length;
+            const conditionalCount = ifCount + chooseCount + foreachCount;
+            // Compute approximate line number
+            const prefix = xml.substring(0, match.index);
+            const line = (prefix.match(/\n/g) || []).length + 1;
+            queries.push({
+                id: idMatch[1],
+                type,
+                resultType: resultTypeMatch === null || resultTypeMatch === void 0 ? void 0 : resultTypeMatch[1],
+                resultMap: resultMapMatch === null || resultMapMatch === void 0 ? void 0 : resultMapMatch[1],
+                parameterType: paramTypeMatch === null || paramTypeMatch === void 0 ? void 0 : paramTypeMatch[1],
+                hasConditionals: conditionalCount > 0,
+                conditionalCount,
+                line,
+            });
+        }
+    }
+    return queries;
+}
+function extractResultMaps(xml) {
+    const resultMaps = [];
+    const rmPattern = /<resultMap\s+([^>]*)>([\s\S]*?)<\/resultMap>/gi;
+    let match;
+    while ((match = rmPattern.exec(xml)) !== null) {
+        const attrs = match[1];
+        const body = match[2];
+        const idMatch = attrs.match(/id\s*=\s*["']([^"']+)["']/);
+        const typeMatch = attrs.match(/type\s*=\s*["']([^"']+)["']/);
+        if (!idMatch || !typeMatch)
+            continue;
+        // Extract associations
+        const associations = [];
+        const assocPattern = /javaType\s*=\s*["']([^"']+)["']/g;
+        let assocMatch;
+        while ((assocMatch = assocPattern.exec(body)) !== null) {
+            associations.push(assocMatch[1]);
+        }
+        // Extract collections
+        const collections = [];
+        const collPattern = /<collection[^>]*ofType\s*=\s*["']([^"']+)["']/g;
+        let collMatch;
+        while ((collMatch = collPattern.exec(body)) !== null) {
+            collections.push(collMatch[1]);
+        }
+        resultMaps.push({
+            id: idMatch[1],
+            type: typeMatch[1],
+            associations,
+            collections,
+        });
+    }
+    return resultMaps;
+}
+/**
+ * Check if a file is a MyBatis XML mapper.
+ */
+function isMyBatisMapperXml(content) {
+    return /<mapper\s+namespace\s*=/.test(content) &&
+        (/<select\b/.test(content) || /<insert\b/.test(content) ||
+            /<update\b/.test(content) || /<delete\b/.test(content));
+}