api-tests-coverage 1.0.21 → 1.0.22

package/dist/src/pipeline/detectors/flaskBlueprintDetector.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * Flask Blueprint detector (Feature 27)
+ *
+ * Detects from raw Python file content:
+ * 1. Blueprint() constructor calls → blueprint-definition nodes
+ * 2. @blueprint.route() decorators with HTTP methods → endpoint nodes (marked
+ *    cross-file-unresolved until url_prefix is resolved by FlaskBlueprintResolver)
+ * 3. app.register_blueprint() calls → blueprint-registration nodes
+ * 4. @use_kwargs({...}) decorator → parameter nodes with location inference
+ * 5. @marshal_with(schema, code=N) → response-schema nodes
+ * 6. @jwt_required / @jwt_optional / @jwt_required(optional=True) → security nodes
+ *
+ * RULE-SA01: never infers role from directory — only from code content
+ * RULE-SA02: endpoint nodes are emitted with resolution: 'cross-file-unresolved'
+ *            when url_prefix is not visible in the same file
+ * RULE-SA04: @jwt_optional → security.optional = true — NEVER classified as public
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlaskBlueprintDetector = void 0;
+const types_1 = require("./types");
+class FlaskBlueprintDetector {
+    constructor() {
+        this.name = 'flask-blueprint';
+    }
+    detect(fileContent, filePath) {
+        if (!filePath.endsWith('.py'))
+            return [];
+        const nodes = [];
+        const lines = fileContent.split('\n');
+        // ── Pass 1: collect Blueprint() constructor calls ─────────────────────
+        // Pattern: varName = Blueprint('name', __name__[, url_prefix='...'])
+        const blueprintCtorPattern = /^(\w+)\s*=\s*Blueprint\s*\(\s*['"]([^'"]+)['"]\s*,\s*__name__(?:\s*,\s*url_prefix\s*=\s*['"]([^'"]*)['"]\s*)?\)/;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            const m = line.match(blueprintCtorPattern);
+            if (!m)
+                continue;
+            const varName = m[1];
+            const bpName = m[2];
+            const urlPrefix = m[3];
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'blueprint-definition', varName, i + 1),
+                kind: 'blueprint-definition',
+                name: varName,
+                filePath,
+                line: i + 1,
+                urlPrefix: urlPrefix !== null && urlPrefix !== void 0 ? urlPrefix : undefined,
+                resolution: urlPrefix ? 'resolved' : 'cross-file-unresolved',
+                diagnosticMessage: urlPrefix
+                    ? undefined
+                    : `Blueprint '${bpName}' has no inline url_prefix — awaiting register_blueprint() call`,
+                validationConstraints: { blueprintName: bpName },
+            });
+        }
+        // ── Pass 2: collect decorator stacks and route registrations ─────────
+        // We walk backwards from each def statement collecting all decorators above it.
+        const decoratorLinePattern = /^\s*@(.+)/;
+        const defLinePattern = /^\s*def\s+(\w+)\s*\(/;
+        // Collect (defLine index → decorators[])
+        const decoratorsByDef = new Map();
+        let pendingDecorators = [];
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            const decMatch = trimmed.match(decoratorLinePattern);
+            if (decMatch) {
+                pendingDecorators.push({ text: decMatch[1].trim(), line: i + 1 });
+                continue;
+            }
+            const defMatch = trimmed.match(defLinePattern);
+            if (defMatch) {
+                decoratorsByDef.set(i, pendingDecorators);
+                pendingDecorators = [];
+                continue;
+            }
+            // Non-decorator, non-def line: reset pending decorators if not blank
+            if (trimmed !== '' && !trimmed.startsWith('#')) {
+                pendingDecorators = [];
+            }
+        }
+        // ── Pass 3: process each def's decorator stack ────────────────────────
+        for (const [defLineIdx, decorators] of decoratorsByDef) {
+            const defLine = lines[defLineIdx].trim();
+            const defMatch = defLine.match(defLinePattern);
+            if (!defMatch)
+                continue;
+            const funcName = defMatch[1];
+            // Separate route decorators from security / kwargs / marshal decorators
+            let routePath;
+            let routeMethods = ['GET'];
+            let routeBlueprintVar;
+            let security = parseSecurity(decorators);
+            const paramNodes = parseUseKwargs(decorators, funcName, filePath, defLineIdx + 1, routeMethods);
+            const responseNodes = parseMarshalWith(decorators, funcName, filePath, defLineIdx + 1);
+            for (const dec of decorators) {
+                // @blueprint.route('/path', methods=(...))
+                const routeMatch = dec.text.match(/^(\w+)\.route\s*\(\s*['"]([^'"]+)['"]\s*(?:,\s*methods\s*=\s*\(([^)]*)\))?\s*\)/);
+                if (routeMatch) {
+                    routeBlueprintVar = routeMatch[1];
+                    routePath = routeMatch[2];
+                    if (routeMatch[3]) {
+                        routeMethods = routeMatch[3]
+                            .split(',')
+                            .map((m) => m.trim().replace(/['"]/g, ''))
+                            .filter((m) => m.length > 0);
+                    }
+                }
+            }
+            if (routePath !== undefined && routeBlueprintVar !== undefined) {
+                // Check if this blueprint var has an inline url_prefix in the same file
+                const bpDef = nodes.find((n) => n.kind === 'blueprint-definition' && n.name === routeBlueprintVar);
+                const isResolved = (bpDef === null || bpDef === void 0 ? void 0 : bpDef.urlPrefix) !== undefined || (bpDef === null || bpDef === void 0 ? void 0 : bpDef.resolution) === 'resolved';
+                nodes.push({
+                    id: (0, types_1.makeNodeId)(filePath, 'endpoint', funcName, defLineIdx + 1),
+                    kind: 'endpoint',
+                    name: funcName,
+                    filePath,
+                    line: defLineIdx + 1,
+                    httpPath: routePath,
+                    httpMethods: routeMethods,
+                    protocol: 'rest',
+                    security,
+                    resolution: isResolved ? 'resolved' : 'cross-file-unresolved',
+                    diagnosticMessage: isResolved
+                        ? undefined
+                        : `Endpoint '${funcName}' url_prefix depends on register_blueprint() call in another file`,
+                });
+                nodes.push(...paramNodes);
+                nodes.push(...responseNodes);
+            }
+        }
+        // ── Pass 4: collect register_blueprint() calls ────────────────────────
+        // Pattern: app.register_blueprint(varName[, url_prefix='/...'])
+        const registerPattern = /\bregister_blueprint\s*\(\s*(\w+)(?:\s*,\s*url_prefix\s*=\s*['"]([^'"]*)['"]\s*)?\)/;
+        for (let i = 0; i < lines.length; i++) {
+            const m = lines[i].match(registerPattern);
+            if (!m)
+                continue;
+            const targetVar = m[1];
+            const urlPrefix = m[2];
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'blueprint-registration', targetVar, i + 1),
+                kind: 'blueprint-registration',
+                name: targetVar,
+                filePath,
+                line: i + 1,
+                urlPrefix: urlPrefix !== null && urlPrefix !== void 0 ? urlPrefix : undefined,
+                targetModule: targetVar,
+                resolution: 'cross-file-unresolved', // target module may be in another file
+                diagnosticMessage: `register_blueprint('${targetVar}') — target may be defined in another file`,
+            });
+        }
+        return nodes;
+    }
+}
+exports.FlaskBlueprintDetector = FlaskBlueprintDetector;
+// ─── Security parsing ─────────────────────────────────────────────────────────
+function parseSecurity(decorators) {
+    for (const dec of decorators) {
+        const text = dec.text;
+        // @jwt_required(optional=True)  — v4+ optional
+        if (/^jwt_required\s*\(\s*optional\s*=\s*True\s*\)/.test(text)) {
+            return { type: 'jwt', required: false, optional: true, sourcePattern: '@jwt_required(optional=True)' };
+        }
+        // @jwt_required(fresh=True)
+        if (/^jwt_required\s*\(\s*fresh\s*=\s*True\s*\)/.test(text)) {
+            return { type: 'jwt', required: true, optional: false, sourcePattern: '@jwt_required(fresh=True)' };
+        }
+        // @jwt_required() or @jwt_required — required auth (RULE-SA04)
+        if (/^jwt_required(\s*\(\s*\))?$/.test(text)) {
+            return { type: 'jwt', required: true, optional: false, sourcePattern: '@jwt_required' };
+        }
+        // @jwt_optional — v3 bare decorator (RULE-SA04: must NEVER be classified as public)
+        if (/^jwt_optional(\s*\(\s*\))?$/.test(text)) {
+            return { type: 'jwt', required: false, optional: true, sourcePattern: '@jwt_optional' };
+        }
+    }
+    return undefined;
+}
+// ─── @use_kwargs parsing ──────────────────────────────────────────────────────
+function parseUseKwargs(decorators, funcName, filePath, baseLine, routeMethods) {
+    const nodes = [];
+    for (const dec of decorators) {
+        // @use_kwargs({...}[, location='...'])
+        if (!dec.text.startsWith('use_kwargs'))
+            continue;
+        // Extract explicit location kwarg
+        const locationMatch = dec.text.match(/location\s*=\s*['"](\w+)['"]/);
+        const explicitLocation = locationMatch ? locationMatch[1] : undefined;
+        // Infer location from HTTP methods if not explicit
+        const inferredLocation = inferParamLocation(routeMethods, explicitLocation);
+        // Extract field names from simple dict patterns like {'tag': fields.Str(), 'limit': fields.Int()}
+        const fieldPattern = /['"](\w+)['"]\s*:\s*fields\.\w+/g;
+        let fieldMatch;
+        while ((fieldMatch = fieldPattern.exec(dec.text)) !== null) {
+            const paramName = fieldMatch[1];
+            const isRequired = new RegExp(`['"]${paramName}['"].*?required\\s*=\\s*True`).test(dec.text);
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'parameter', `${funcName}.${paramName}`, dec.line),
+                kind: 'parameter',
+                name: `${funcName}.${paramName}`,
+                filePath,
+                line: dec.line,
+                parameterName: paramName,
+                parameterLocation: inferredLocation,
+                required: isRequired,
+                resolution: 'resolved',
+            });
+        }
+        // Schema class passed directly: @use_kwargs(UserSchema)
+        const schemaMatch = dec.text.match(/^use_kwargs\s*\(\s*(\w+Schema)\s*\)/);
+        if (schemaMatch) {
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'parameter', `${funcName}.schema:${schemaMatch[1]}`, dec.line),
+                kind: 'parameter',
+                name: `${funcName}.schema:${schemaMatch[1]}`,
+                filePath,
+                line: dec.line,
+                parameterName: schemaMatch[1],
+                parameterLocation: inferredLocation,
+                resolution: 'cross-file-unresolved',
+                diagnosticMessage: `Schema class '${schemaMatch[1]}' fields not resolved — defined in another file`,
+            });
+        }
+    }
+    return nodes;
+}
+function inferParamLocation(methods, explicit) {
+    if (explicit)
+        return explicit;
+    const upper = methods.map((m) => m.toUpperCase());
+    if (upper.some((m) => m === 'POST' || m === 'PUT' || m === 'PATCH'))
+        return 'json';
+    return 'query'; // GET, HEAD, DELETE, OPTIONS
+}
+// ─── @marshal_with parsing ────────────────────────────────────────────────────
+function parseMarshalWith(decorators, funcName, filePath, baseLine) {
+    const nodes = [];
+    for (const dec of decorators) {
+        if (!dec.text.startsWith('marshal_with'))
+            continue;
+        // Extract code= kwarg
+        const codeMatch = dec.text.match(/code\s*=\s*(\d+)/);
+        const statusCode = codeMatch ? parseInt(codeMatch[1], 10) : 200;
+        // Extract schema name (first argument)
+        const schemaMatch = dec.text.match(/^marshal_with\s*\(\s*(\w+)/);
+        const schemaName = schemaMatch ? schemaMatch[1] : 'unknown';
+        nodes.push({
+            id: (0, types_1.makeNodeId)(filePath, 'response-schema', `${funcName}.response:${statusCode}`, dec.line),
+            kind: 'response-schema',
+            name: `${funcName}.response:${statusCode}`,
+            filePath,
+            line: dec.line,
+            responseStatusCode: statusCode,
+            modelName: schemaName !== 'None' ? schemaName : undefined,
+            resolution: schemaName === 'unknown' || schemaName === 'None' ? 'resolved' : 'cross-file-unresolved',
+            diagnosticMessage: schemaName !== 'None' && schemaName !== 'unknown'
+                ? `Response schema '${schemaName}' may be defined in another file`
+                : undefined,
+        });
+    }
+    return nodes;
+}

package/dist/src/pipeline/detectors/springDddDetector.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Spring Boot DDD layer detector (Feature 27)
+ *
+ * Detects from raw Java/Kotlin file content WITHOUT requiring @Service/@Repository
+ * annotations (RULE-SA03). Uses structural inference:
+ *
+ * 1. Repository interfaces — interfaces named XRepository/XRepo/XStore/XGateway
+ *    or interfaces containing findByX / save / delete methods
+ * 2. Repository implementations — classes implementing a XRepository interface
+ * 3. CQRS handlers — classes with execute/handle/apply methods taking XCommand/XQuery
+ * 4. DDD service layer — classes in 'application'/'command'/'query'/'usecase' packages
+ * 5. Domain layer — classes in 'domain' package
+ * 6. Infrastructure layer — classes in 'infrastructure'/'persistence'/'adapter' packages
+ *
+ * RULE-SA01: directory name is used only as a tie-breaker, never as primary evidence
+ * RULE-SA03: @Service/@Repository absence does NOT prevent node creation
+ */
+import type { DetectedNode, Detector } from './types';
+export declare class SpringDddDetector implements Detector {
+    readonly name = "spring-ddd";
+    detect(fileContent: string, filePath: string): DetectedNode[];
+}
+//# sourceMappingURL=springDddDetector.d.ts.map

package/dist/src/pipeline/detectors/springDddDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"springDddDetector.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/detectors/springDddDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,qBAAa,iBAAkB,YAAW,QAAQ;IAChD,QAAQ,CAAC,IAAI,gBAAgB;IAE7B,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE;CAiE9D"}

package/dist/src/pipeline/detectors/springDddDetector.js

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * Spring Boot DDD layer detector (Feature 27)
+ *
+ * Detects from raw Java/Kotlin file content WITHOUT requiring @Service/@Repository
+ * annotations (RULE-SA03). Uses structural inference:
+ *
+ * 1. Repository interfaces — interfaces named XRepository/XRepo/XStore/XGateway
+ *    or interfaces containing findByX / save / delete methods
+ * 2. Repository implementations — classes implementing a XRepository interface
+ * 3. CQRS handlers — classes with execute/handle/apply methods taking XCommand/XQuery
+ * 4. DDD service layer — classes in 'application'/'command'/'query'/'usecase' packages
+ * 5. Domain layer — classes in 'domain' package
+ * 6. Infrastructure layer — classes in 'infrastructure'/'persistence'/'adapter' packages
+ *
+ * RULE-SA01: directory name is used only as a tie-breaker, never as primary evidence
+ * RULE-SA03: @Service/@Repository absence does NOT prevent node creation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpringDddDetector = void 0;
+const types_1 = require("./types");
+class SpringDddDetector {
+    constructor() {
+        this.name = 'spring-ddd';
+    }
+    detect(fileContent, filePath) {
+        if (!filePath.endsWith('.java') && !filePath.endsWith('.kt'))
+            return [];
+        const nodes = [];
+        const lines = fileContent.split('\n');
+        // Infer DDD layer from package path (tie-breaker only — RULE-SA01)
+        const dddLayer = inferDddLayerFromPath(filePath);
+        // ── Detect repository interfaces ──────────────────────────────────────
+        const repoInterfaces = detectRepositoryInterfaces(fileContent, filePath);
+        for (const repo of repoInterfaces) {
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'ddd-repository-interface', repo.name, repo.line),
+                kind: 'ddd-repository-interface',
+                name: repo.name,
+                filePath,
+                line: repo.line,
+                dddLayer: dddLayer !== null && dddLayer !== void 0 ? dddLayer : 'domain',
+                resolution: 'resolved',
+                validationConstraints: { methods: repo.methods.join(',') },
+            });
+        }
+        // ── Detect repository implementations ─────────────────────────────────
+        const repoImpls = detectRepositoryImplementations(fileContent, filePath);
+        for (const impl of repoImpls) {
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'ddd-repository-impl', impl.className, impl.line),
+                kind: 'ddd-repository-impl',
+                name: impl.className,
+                filePath,
+                line: impl.line,
+                dddLayer: dddLayer !== null && dddLayer !== void 0 ? dddLayer : 'infrastructure',
+                implementsInterface: impl.interfaceName,
+                resolution: impl.interfaceResolved ? 'resolved' : 'cross-file-unresolved',
+                diagnosticMessage: impl.interfaceResolved
+                    ? undefined
+                    : `Interface '${impl.interfaceName}' may be defined in another file`,
+            });
+        }
+        // ── Detect CQRS handlers ───────────────────────────────────────────────
+        const cqrsHandlers = detectCqrsHandlers(fileContent, filePath);
+        for (const handler of cqrsHandlers) {
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'cqrs-handler', handler.className, handler.line),
+                kind: 'cqrs-handler',
+                name: handler.className,
+                filePath,
+                line: handler.line,
+                dddLayer: dddLayer !== null && dddLayer !== void 0 ? dddLayer : 'application',
+                cqrsHandlerType: handler.handlerType,
+                cqrsParameterType: handler.parameterType,
+                resolution: 'resolved',
+                validationConstraints: { handleMethod: handler.handleMethod },
+            });
+        }
+        // ── Detect application service classes ────────────────────────────────
+        const serviceClasses = detectServiceClasses(lines, filePath, dddLayer);
+        nodes.push(...serviceClasses);
+        return nodes;
+    }
+}
+exports.SpringDddDetector = SpringDddDetector;
+function detectRepositoryInterfaces(source, filePath) {
+    var _a, _b;
+    const results = [];
+    const lines = source.split('\n');
+    // Named interfaces: interface ArticleRepository / ArticleRepo / ArticleStore / ArticleGateway
+    const namedPattern = /(?:public\s+)?interface\s+(\w+(?:Repository|Repo|Store|Gateway))\b/;
+    let currentIface = null;
+    let braceDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!currentIface) {
+            const m = line.match(namedPattern);
+            if (m) {
+                currentIface = { name: m[1], methods: [], line: i + 1 };
+                braceDepth = 0;
+            }
+        }
+        if (currentIface) {
+            braceDepth += ((_a = line.match(/\{/g)) !== null && _a !== void 0 ? _a : []).length;
+            braceDepth -= ((_b = line.match(/\}/g)) !== null && _b !== void 0 ? _b : []).length;
+            const methodMatch = line.match(/\b(findBy\w+|find\w+|getBy\w+|save|saveAll|delete|deleteById|existsBy\w+|countBy\w+)\s*\(/);
+            if (methodMatch)
+                currentIface.methods.push(methodMatch[1]);
+            if (braceDepth <= 0) {
+                if (currentIface.methods.length > 0)
+                    results.push(currentIface);
+                currentIface = null;
+            }
+        }
+    }
+    // Also detect generic interfaces that have at least 2 repository-style methods
+    const genericPattern = /(?:public\s+)?interface\s+(\w+)\b/g;
+    let gm;
+    while ((gm = genericPattern.exec(source)) !== null) {
+        const name = gm[1];
+        if (results.some((r) => r.name === name))
+            continue;
+        const startIdx = gm.index;
+        const braceStart = source.indexOf('{', startIdx);
+        if (braceStart < 0)
+            continue;
+        const body = extractBraceBody(source, braceStart);
+        const repoMethodPattern = /\b(findBy\w+|save|delete|deleteById)\s*\(/g;
+        const methods = [];
+        let rm;
+        while ((rm = repoMethodPattern.exec(body)) !== null)
+            methods.push(rm[1]);
+        if (methods.length >= 2) {
+            const lineNum = source.substring(0, startIdx).split('\n').length;
+            results.push({ name, methods, line: lineNum });
+        }
+    }
+    return results;
+}
+function detectRepositoryImplementations(source, filePath) {
+    const results = [];
+    const implPattern = /class\s+(\w+)(?:\s+extends\s+\w+)?\s+implements\s+([\w,\s<>]+?)(?:\{|$)/gm;
+    let m;
+    while ((m = implPattern.exec(source)) !== null) {
+        const className = m[1];
+        const ifaceList = m[2];
+        // Look for *Repository/*Repo/*Store/*Gateway in the implements list
+        const repoIfaceMatch = ifaceList.match(/\b(\w+(?:Repository|Repo|Store|Gateway))\b/);
+        if (!repoIfaceMatch)
+            continue;
+        const lineNum = source.substring(0, m.index).split('\n').length;
+        results.push({
+            className,
+            interfaceName: repoIfaceMatch[1],
+            interfaceResolved: false, // cross-file resolution needed
+            line: lineNum,
+        });
+    }
+    return results;
+}
+function detectCqrsHandlers(source, filePath) {
+    const results = [];
+    const lines = source.split('\n');
+    // Pattern: public ReturnType execute/handle/apply(CreateArticleCommand cmd)
+    const handlerPattern = /(?:public\s+\S+\s+)?(execute|handle|apply)\s*\(\s*(\w+(Command|Query|Event))\s+\w+\s*\)/;
+    let currentClass = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const classMatch = line.match(/class\s+(\w+)/);
+        if (classMatch)
+            currentClass = classMatch[1];
+        const handlerMatch = line.match(handlerPattern);
+        if (handlerMatch && currentClass) {
+            const handlerTypeSuffix = handlerMatch[3].toLowerCase();
+            results.push({
+                className: currentClass,
+                handlerType: handlerTypeSuffix,
+                handleMethod: handlerMatch[1],
+                parameterType: handlerMatch[2],
+                line: i + 1,
+            });
+        }
+    }
+    return results;
+}
+function detectServiceClasses(lines, filePath, dddLayer) {
+    const nodes = [];
+    let currentClass = '';
+    let currentClassLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // class ArticleCommandService / ArticleQueryService / ArticleApplicationService
+        const classMatch = line.match(/class\s+(\w+(?:CommandService|QueryService|ApplicationService|UseCase|Interactor))\b/);
+        if (classMatch) {
+            currentClass = classMatch[1];
+            currentClassLine = i + 1;
+            nodes.push({
+                id: (0, types_1.makeNodeId)(filePath, 'ddd-service', currentClass, currentClassLine),
+                kind: 'ddd-service',
+                name: currentClass,
+                filePath,
+                line: currentClassLine,
+                dddLayer: dddLayer !== null && dddLayer !== void 0 ? dddLayer : 'application',
+                resolution: 'resolved',
+            });
+        }
+    }
+    return nodes;
+}
+function inferDddLayerFromPath(filePath) {
+    const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+    if (normalized.includes('/domain/'))
+        return 'domain';
+    if (normalized.includes('/application/') ||
+        normalized.includes('/command/') ||
+        normalized.includes('/query/') ||
+        normalized.includes('/usecase/'))
+        return 'application';
+    if (normalized.includes('/infrastructure/') ||
+        normalized.includes('/persistence/') ||
+        normalized.includes('/adapter/'))
+        return 'infrastructure';
+    return undefined;
+}
+function extractBraceBody(source, openBrace) {
+    let depth = 1;
+    let i = openBrace + 1;
+    while (i < source.length && depth > 0) {
+        if (source[i] === '{')
+            depth++;
+        if (source[i] === '}')
+            depth--;
+        i++;
+    }
+    return source.substring(openBrace, i);
+}

package/dist/src/pipeline/detectors/types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Shared types for pipeline detectors (Feature 27).
+ *
+ * Detectors analyse raw file content (string) and return DetectedNode[]
+ * that the cross-file resolution pass consumes to build graph nodes.
+ */
+import type { SecurityClassification, NodeResolution, EndpointProtocol, DecoratorStack } from '../../ast/astTypes';
+export type DetectedNodeKind = 'endpoint' | 'api-call' | 'route-prefix' | 'auth-guard' | 'auth-interceptor' | 'auth-middleware' | 'injectable-service' | 'ddd-service' | 'ddd-repository-interface' | 'ddd-repository-impl' | 'cqrs-handler' | 'model' | 'model-field' | 'validation-rule' | 'model-method' | 'model-hook' | 'response-schema' | 'vuex-action' | 'vuex-dispatch' | 'error-handler' | 'exception-branch' | 'router-mount' | 'middleware-chain' | 'blueprint-definition' | 'blueprint-registration' | 'parameter' | 'mybatis-mapper' | 'mybatis-query';
+/**
+ * A node detected by a file-content detector.
+ *
+ * Detectors never emit endpoint nodes before url_prefix / router.use() prefix
+ * is resolved (RULE-SA02). When the URL depends on cross-file data that is not
+ * yet available the detector emits the node with `resolution: 'cross-file-unresolved'`.
+ */
+export interface DetectedNode {
+    /** Stable within a single scan — derived from filePath + kind + name + line */
+    id: string;
+    /** Kind of semantic construct this node represents */
+    kind: DetectedNodeKind;
+    /** Human-readable name of the construct (function name, class name, path, etc.) */
+    name: string;
+    /** Absolute path to the file that was scanned */
+    filePath: string;
+    /** 1-based line number of the primary token */
+    line?: number;
+    /** HTTP path as written in source — may be a prefix or a full path */
+    httpPath?: string;
+    /** HTTP methods for this endpoint */
+    httpMethods?: string[];
+    /** Transport protocol */
+    protocol?: EndpointProtocol;
+    /** Security classification when statically determinable */
+    security?: SecurityClassification;
+    /**
+     * Resolution status:
+     * - `resolved`               — all required cross-file data is available
+     * - `cross-file-unresolved`  — depends on data from another file not yet scanned
+     * - `partial`                — some data resolved, some not
+     */
+    resolution: NodeResolution;
+    /** Human-readable reason when resolution is not 'resolved' */
+    diagnosticMessage?: string;
+    /** All decorators / annotations associated with this node */
+    decoratorStack?: DecoratorStack;
+    /** Parameter name when kind is 'parameter' */
+    parameterName?: string;
+    /** Parameter location: 'query' | 'json' | 'headers' | 'path' */
+    parameterLocation?: string;
+    /** Whether the parameter is required */
+    required?: boolean;
+    /** Validation constraints (type, min, max, pattern, etc.) */
+    validationConstraints?: Record<string, string | number | boolean>;
+    /** For injectable-service nodes: the injected token/class name */
+    injectedClass?: string;
+    /** How injection was detected */
+    injectionStyle?: 'constructor' | 'inject-fn' | 'decorator' | 'property';
+    /** The url_prefix / mount path when kind is 'route-prefix' or 'router-mount' */
+    urlPrefix?: string;
+    /** Target module or variable being mounted */
+    targetModule?: string;
+    /** Linked model/class name for validation / method nodes */
+    modelName?: string;
+    /** For response-schema nodes: the HTTP status code */
+    responseStatusCode?: number;
+    /** DDD layer classification inferred from code (RULE-SA03) */
+    dddLayer?: 'domain' | 'application' | 'infrastructure' | 'adapter';
+    /** Interface name being implemented */
+    implementsInterface?: string;
+    /** CQRS handler type */
+    cqrsHandlerType?: 'command' | 'query' | 'event';
+    /** CQRS parameter type (e.g. 'CreateArticleCommand') */
+    cqrsParameterType?: string;
+    /** For error-handler / exception-branch nodes: the error name or type matched */
+    errorName?: string;
+    /** HTTP status code produced by this error branch */
+    errorStatusCode?: number;
+}
+/**
+ * Common interface every detector must implement.
+ */
+export interface Detector {
+    /** Human-readable detector name */
+    readonly name: string;
+    /**
+     * Analyse the raw file content and return all detected nodes.
+     *
+     * Rules that apply to ALL detectors:
+     * - NEVER infer node type from directory name (RULE-SA01)
+     * - NEVER emit an endpoint node before url_prefix is resolved (RULE-SA02)
+     * - Flag unresolved nodes as `resolution: 'cross-file-unresolved'` — do NOT drop them
+     * - @jwt_optional → security.optional = true, NEVER security = 'public'
+     */
+    detect(fileContent: string, filePath: string): DetectedNode[];
+}
+export declare function makeNodeId(filePath: string, kind: DetectedNodeKind, name: string, line?: number): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/pipeline/detectors/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/pipeline/detectors/types.ts"],"names":[],"mappings":"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"}

package/dist/src/pipeline/detectors/types.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Shared types for pipeline detectors (Feature 27).
+ *
+ * Detectors analyse raw file content (string) and return DetectedNode[]
+ * that the cross-file resolution pass consumes to build graph nodes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNodeId = makeNodeId;
+// ─── Utility: deterministic node ID ──────────────────────────────────────────
+function makeNodeId(filePath, kind, name, line) {
+    const safeFile = filePath.replace(/\\/g, '/');
+    const safeName = name.replace(/\s+/g, '_');
+    return `${safeFile}:${kind}:${safeName}${line != null ? `:${line}` : ''}`;
+}

package/dist/src/reporting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../src/reporting.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,+GAA+G;IAC/G,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;AAE7D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,EAAE,CAMxD;AAwND;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,cAAc,EAAE,EACzB,OAAO,EAAE,YAAY,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACvC,aAAa,CAAC,EAAE,iBAAiB,GAChC,IAAI,CAqBN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,cAAc,EAAE,EACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,MAAM,EAAE,CAYV"}
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../src/reporting.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAIzD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,+GAA+G;IAC/G,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC;AAE7D;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,EAAE,CAMxD;AAwND;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,cAAc,EAAE,EACzB,OAAO,EAAE,YAAY,EAAE,EACvB,UAAU,EAAE,MAAM,EAClB,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACvC,aAAa,CAAC,EAAE,iBAAiB,GAChC,IAAI,CAqBN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,cAAc,EAAE,EACzB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,MAAM,EAAE,CAaV"}