api-tests-coverage 1.0.14 → 1.0.16

package/dist/src/languages/python/testPatternDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testPatternDetector.d.ts","sourceRoot":"","sources":["../../../../src/languages/python/testPatternDetector.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,oBAAoB,CAAC;AAK5E,MAAM,WAAW,iBAAiB;IAChC,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,oCAAoC;IACpC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAiEnG;AAID,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAiBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CA6BzF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,gBAAgB,EAAE,CAUnF;AAID,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,EAAE,CAyC1F;AAID;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAO7D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE1D"}

package/dist/src/languages/python/testPatternDetector.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * Python test pattern detector (Feature 27, Sub-PR 4)
+ *
+ * Detects:
+ * 1. Factory Boy factories (factory.Factory subclasses, SubFactory, Meta.model)
+ * 2. webtest API calls (TestApp, testapp.get/post_json/put_json/delete)
+ * 3. pytest fixture chains (@pytest.fixture, fixture dependencies)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFactoryBoyFactories = detectFactoryBoyFactories;
+exports.detectWebtestCalls = detectWebtestCalls;
+exports.webtestCallsToHttpCalls = webtestCallsToHttpCalls;
+exports.detectPytestFixtures = detectPytestFixtures;
+exports.hasWebtestTestApp = hasWebtestTestApp;
+exports.hasRealDbFixtures = hasRealDbFixtures;
+exports.usesFactoryBoy = usesFactoryBoy;
+/**
+ * Detect Factory Boy factory classes from source text.
+ * Looks for `class XFactory(factory.Factory):` and parses Meta.model, SubFactory, RelatedFactoryList.
+ */
+function detectFactoryBoyFactories(sourceText, filePath) {
+    const factories = [];
+    const lines = sourceText.split('\n');
+    // Regex for class definition inheriting from factory.Factory or factory.DjangoModelFactory etc.
+    const classPattern = /^class\s+(\w+)\s*\(\s*(?:factory\.(?:Factory|DjangoModelFactory|SQLAlchemyModelFactory|MongoEngineFactory)|Factory)\s*\)/;
+    const metaModelPattern = /model\s*=\s*(\w+)/;
+    const subFactoryPattern = /=\s*(?:factory\.)?SubFactory\s*\(\s*['"]?(\w+)/g;
+    const relatedFactoryPattern = /=\s*(?:factory\.)?RelatedFactoryList\s*\(\s*['"]?(\w+)/g;
+    let currentFactory = null;
+    let classIndent = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const indent = line.search(/\S/);
+        // If we're inside a factory class, check for end of class
+        if (currentFactory && indent >= 0 && indent <= classIndent && line.trim().length > 0) {
+            factories.push(currentFactory);
+            currentFactory = null;
+            classIndent = -1;
+        }
+        const classMatch = line.match(classPattern);
+        if (classMatch) {
+            if (currentFactory)
+                factories.push(currentFactory);
+            currentFactory = {
+                className: classMatch[1],
+                subFactories: [],
+                relatedFactoryLists: [],
+                sourceFile: filePath,
+                line: i + 1,
+            };
+            classIndent = indent;
+            continue;
+        }
+        if (currentFactory) {
+            // Meta.model
+            const metaMatch = line.match(metaModelPattern);
+            if (metaMatch) {
+                currentFactory.modelName = metaMatch[1];
+            }
+            // SubFactory
+            let sfMatch;
+            subFactoryPattern.lastIndex = 0;
+            while ((sfMatch = subFactoryPattern.exec(line)) !== null) {
+                currentFactory.subFactories.push(sfMatch[1]);
+            }
+            // RelatedFactoryList
+            let rfMatch;
+            relatedFactoryPattern.lastIndex = 0;
+            while ((rfMatch = relatedFactoryPattern.exec(line)) !== null) {
+                currentFactory.relatedFactoryLists.push(rfMatch[1]);
+            }
+        }
+    }
+    // Push last factory if still open
+    if (currentFactory)
+        factories.push(currentFactory);
+    return factories;
+}
+/** Map webtest methods to HTTP methods */
+const WEBTEST_METHOD_MAP = {
+    get: 'GET',
+    post: 'POST',
+    post_json: 'POST',
+    put: 'PUT',
+    put_json: 'PUT',
+    patch: 'PATCH',
+    patch_json: 'PATCH',
+    delete: 'DELETE',
+    delete_json: 'DELETE',
+    head: 'HEAD',
+    options: 'OPTIONS',
+};
+/**
+ * Detect webtest HTTP calls from source text.
+ * Looks for `testapp.get('/path')`, `testapp.post_json('/path', {...})`, etc.
+ */
+function detectWebtestCalls(sourceText, filePath) {
+    const calls = [];
+    const lines = sourceText.split('\n');
+    // Pattern: any_var.METHOD('/path'...) where METHOD is a webtest HTTP method
+    const webtestMethods = Object.keys(WEBTEST_METHOD_MAP).join('|');
+    const callPattern = new RegExp(`\\w+\\.(${webtestMethods})\\s*\\(\\s*['"]([^'"]+)['"]`, 'g');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        callPattern.lastIndex = 0;
+        let match;
+        while ((match = callPattern.exec(line)) !== null) {
+            const method = WEBTEST_METHOD_MAP[match[1]];
+            if (method) {
+                calls.push({
+                    method,
+                    path: match[2],
+                    sourceFile: filePath,
+                    line: i + 1,
+                });
+            }
+        }
+    }
+    return calls;
+}
+/**
+ * Convert webtest API calls into SemanticHttpCall objects.
+ */
+function webtestCallsToHttpCalls(calls) {
+    return calls.map((call) => ({
+        method: call.method,
+        rawPathArg: call.path,
+        resolvedPath: call.path,
+        normalizedPath: call.path.startsWith('/') ? call.path : undefined,
+        resolutionType: 'direct',
+        confidence: 'high',
+        line: call.line,
+    }));
+}
+/**
+ * Detect @pytest.fixture functions and their parameter dependencies.
+ */
+function detectPytestFixtures(sourceText, filePath) {
+    const fixtures = [];
+    const lines = sourceText.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // @pytest.fixture or @pytest.fixture(scope='...')
+        const fixtureMatch = line.match(/@pytest\.fixture(?:\s*\(([^)]*)\))?/);
+        if (!fixtureMatch)
+            continue;
+        // Parse scope from decorator args
+        let scope = 'function';
+        if (fixtureMatch[1]) {
+            const scopeMatch = fixtureMatch[1].match(/scope\s*=\s*['"](\w+)['"]/);
+            if (scopeMatch)
+                scope = scopeMatch[1];
+        }
+        // Find the next def line (typically the line right after the decorator)
+        for (let j = i + 1; j < Math.min(i + 5, lines.length); j++) {
+            const defMatch = lines[j].match(/def\s+(\w+)\s*\(([^)]*)\)/);
+            if (defMatch) {
+                const name = defMatch[1];
+                const params = defMatch[2]
+                    .split(',')
+                    .map((p) => p.trim().split(':')[0].split('=')[0].trim())
+                    .filter((p) => p.length > 0 && p !== 'request');
+                fixtures.push({
+                    name,
+                    scope,
+                    dependencies: params,
+                    sourceFile: filePath,
+                    line: j + 1,
+                });
+                break;
+            }
+        }
+    }
+    return fixtures;
+}
+// ─── TestApp Detection ──────────────────────────────────────────────────────
+/**
+ * Detect if a file creates a webtest TestApp instance.
+ * Looks for `TestApp(app)` or `TestApp(...)`.
+ */
+function hasWebtestTestApp(sourceText) {
+    return /TestApp\s*\(/.test(sourceText);
+}
+/**
+ * Check if a file uses real DB fixtures (not mocked).
+ * Looks for pytest fixtures that reference db, database, session, engine, etc.
+ */
+function hasRealDbFixtures(sourceText) {
+    // Check for DB fixture names in function parameters
+    const dbFixturePattern = /def\s+\w+\s*\([^)]*\b(db|database|dbsession|db_session|engine|session|connection)\b/;
+    // Also check for common DB setup patterns
+    const dbSetupPattern = /(?:create_all|Base\.metadata|sessionmaker|create_engine|init_db|setup_database)/;
+    return dbFixturePattern.test(sourceText) || dbSetupPattern.test(sourceText);
+}
+/**
+ * Check if a file uses Factory Boy factories.
+ */
+function usesFactoryBoy(sourceText) {
+    return /(?:import\s+factory|from\s+factory\s+import|factory\.Factory|factory\.SubFactory)/.test(sourceText);
+}

package/dist/src/pipeline/stages/ast/astStage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"astStage.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/astStage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAkB9C,qBAAa,QAAS,YAAW,aAAa,CAAC,cAAc,CAAC;IAC5D,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,SAAS;IAEpB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;CAyKjE"}
+{"version":3,"file":"astStage.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/astStage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAmB9C,qBAAa,QAAS,YAAW,aAAa,CAAC,cAAc,CAAC;IAC5D,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,SAAS;IAEpB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;CAoLjE"}

package/dist/src/pipeline/stages/ast/astStage.js

@@ -47,6 +47,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstStage = void 0;
 const astAnalysisOrchestrator_1 = require("../../../ast/astAnalysisOrchestrator");
 const crossFileResolver_1 = require("./crossFileResolver");
+const crossFileResolutionPass_1 = require("./crossFileResolutionPass");
 const abstractLayerTraversal_1 = require("./abstractLayerTraversal");
 const graphBuilder_1 = require("./graphBuilder");
 const fileClassifier_1 = require("../../../discovery/fileClassifier");
@@ -130,6 +131,8 @@ class AstStage {
         }
         // Phase 2: Build cross-file symbol table
         const crossFileTable = (0, crossFileResolver_1.buildCrossFileSymbolTable)(models, context.projectRoot);
+        // Phase 2b: Run cross-file resolution pass (Feature 27)
+        const crossFileResolutionResult = (0, crossFileResolutionPass_1.runCrossFileResolution)(crossFileTable, context.projectRoot, artifacts.apiFrameworks, allSourceFiles);
         // Phase 3: Run abstract layer traversal for test files
         const traversalResults = new Map();
         const depthCap = context.config.traversalDepthCap;
@@ -199,6 +202,8 @@ class AstStage {
                 traversalResultCount: traversalResults.size,
                 graphNodesAdded: nodes.length,
                 graphEdgesAdded: edges.length,
+                crossFileResolversRun: crossFileResolutionResult.resolverResults.length,
+                crossFileEntriesAdded: crossFileResolutionResult.totalEntriesAdded,
             },
         };
         context.diagnostics.set('ast', diagnostics);
@@ -209,6 +214,7 @@ class AstStage {
             traversalResults,
             analyzedFiles: filesScanned,
             skippedFiles: filesSkipped,
+            crossFileResolutionDiagnostics: crossFileResolutionResult.resolverResults,
         };
         context.stageOutputs.set('ast', output);
         return output;

package/dist/src/pipeline/stages/ast/baseUrlComposer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Base URL composer (Feature 27, Sub-PR 9)
+ *
+ * Unified URL composition across all frameworks:
+ * - Flask: Blueprint url_prefix + route path
+ * - Express: app.use mount prefix + router path + route path
+ * - Spring: @RequestMapping class-level + method-level
+ * - Angular: environment.apiUrl from environments/environment.ts
+ * - Vue: axios.defaults.baseURL
+ * - Slim PHP: $app->group prefix + route path
+ * - HapiJS: explicit path (no composition needed)
+ *
+ * Normalizes: remove double slashes, ensure single leading slash.
+ */
+/**
+ * Compose a full URL from multiple path segments.
+ * Handles: double slashes, missing leading slashes, trailing slashes.
+ */
+export declare function composeUrl(...segments: (string | undefined)[]): string;
+/**
+ * Normalize a path template: ensure leading slash, remove double slashes,
+ * standardize parameter syntax.
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * Convert framework-specific parameter syntax to OpenAPI-style {param}.
+ *
+ * Flask: <param>, <int:param> → {param}
+ * Express: :param → {param}
+ * Slim PHP: {param} (already correct)
+ * HapiJS: {param} (already correct)
+ * Spring: {param} (already correct)
+ */
+export declare function normalizePathParams(path: string): string;
+/**
+ * Compose full URL for a specific framework's route.
+ */
+export declare function composeFrameworkUrl(framework: string, parts: {
+    baseUrl?: string;
+    classPrefix?: string;
+    mountPrefix?: string;
+    routePath: string;
+}): string;
+//# sourceMappingURL=baseUrlComposer.d.ts.map

package/dist/src/pipeline/stages/ast/baseUrlComposer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseUrlComposer.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/baseUrlComposer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,QAAQ,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GAAG,MAAM,CAStE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkBlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQxD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE;IACL,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,GACA,MAAM,CAUR"}

package/dist/src/pipeline/stages/ast/baseUrlComposer.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Base URL composer (Feature 27, Sub-PR 9)
+ *
+ * Unified URL composition across all frameworks:
+ * - Flask: Blueprint url_prefix + route path
+ * - Express: app.use mount prefix + router path + route path
+ * - Spring: @RequestMapping class-level + method-level
+ * - Angular: environment.apiUrl from environments/environment.ts
+ * - Vue: axios.defaults.baseURL
+ * - Slim PHP: $app->group prefix + route path
+ * - HapiJS: explicit path (no composition needed)
+ *
+ * Normalizes: remove double slashes, ensure single leading slash.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeUrl = composeUrl;
+exports.normalizePath = normalizePath;
+exports.normalizePathParams = normalizePathParams;
+exports.composeFrameworkUrl = composeFrameworkUrl;
+/**
+ * Compose a full URL from multiple path segments.
+ * Handles: double slashes, missing leading slashes, trailing slashes.
+ */
+function composeUrl(...segments) {
+    const parts = segments
+        .filter((s) => typeof s === 'string' && s.length > 0)
+        .map((s) => s.replace(/^\/+|\/+$/g, ''));
+    const joined = parts.join('/');
+    const normalized = '/' + joined.replace(/\/+/g, '/');
+    return normalized === '/' ? '/' : normalized.replace(/\/+$/, '');
+}
+/**
+ * Normalize a path template: ensure leading slash, remove double slashes,
+ * standardize parameter syntax.
+ */
+function normalizePath(path) {
+    if (!path)
+        return '/';
+    // Ensure leading slash
+    let normalized = path.startsWith('/') ? path : '/' + path;
+    // Remove double slashes (but not from protocol like http://)
+    // First handle leading double slashes
+    normalized = normalized.replace(/^\/\/+/, '/');
+    // Then handle double slashes in the middle
+    normalized = normalized.replace(/([^:])\/\/+/g, '$1/');
+    // Remove trailing slash (unless it's just "/")
+    if (normalized.length > 1) {
+        normalized = normalized.replace(/\/+$/, '');
+    }
+    return normalized;
+}
+/**
+ * Convert framework-specific parameter syntax to OpenAPI-style {param}.
+ *
+ * Flask: <param>, <int:param> → {param}
+ * Express: :param → {param}
+ * Slim PHP: {param} (already correct)
+ * HapiJS: {param} (already correct)
+ * Spring: {param} (already correct)
+ */
+function normalizePathParams(path) {
+    // Flask/Python: <param> or <type:param>
+    let normalized = path.replace(/<(?:\w+:)?(\w+)>/g, '{$1}');
+    // Express: :param (but not :// from URLs)
+    normalized = normalized.replace(/(?<=\/):([\w]+)/g, '{$1}');
+    return normalized;
+}
+/**
+ * Compose full URL for a specific framework's route.
+ */
+function composeFrameworkUrl(framework, parts) {
+    const segments = [];
+    if (parts.baseUrl)
+        segments.push(parts.baseUrl);
+    if (parts.classPrefix)
+        segments.push(parts.classPrefix);
+    if (parts.mountPrefix)
+        segments.push(parts.mountPrefix);
+    segments.push(parts.routePath);
+    const raw = composeUrl(...segments);
+    return normalizePathParams(raw);
+}

package/dist/src/pipeline/stages/ast/crossFileResolutionPass.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Cross-file resolution pass (Feature 27)
+ *
+ * Orchestrates all registered cross-file resolvers after the initial AST
+ * parsing pass. Each resolver enriches the CrossFileSymbolTable with
+ * framework-specific resolution data (Blueprint prefixes, Angular injection
+ * chains, DDD interface mappings, etc.).
+ *
+ * Resolvers are registered via `registerCrossFileResolver()` and discovered
+ * via `getCrossFileResolvers()`. Each resolver implements the `CrossFileResolver`
+ * interface and self-declares which API frameworks it applies to.
+ */
+import type { CrossFileResolver, CrossFileSymbolTable } from './types';
+import type { DetectedApiFramework } from '../../../discovery/frameworkDetector';
+/**
+ * Register a cross-file resolver. Resolvers are run in registration order.
+ */
+export declare function registerCrossFileResolver(resolver: CrossFileResolver): void;
+/**
+ * Return all registered cross-file resolvers.
+ */
+export declare function getCrossFileResolvers(): readonly CrossFileResolver[];
+/**
+ * Clear all registered resolvers (for testing).
+ */
+export declare function clearCrossFileResolvers(): void;
+export interface CrossFileResolutionPassResult {
+    /** Per-resolver diagnostics */
+    resolverResults: Array<{
+        resolverName: string;
+        entriesAdded: number;
+        diagnostics: string[];
+        unresolvedRefs: Array<{
+            ref: string;
+            reason: string;
+        }>;
+    }>;
+    /** Total entries added across all resolvers */
+    totalEntriesAdded: number;
+}
+/**
+ * Run all applicable cross-file resolvers against the symbol table.
+ *
+ * Each resolver mutates the symbol table in place, adding router mounts,
+ * injection chains, interface implementations, and middleware inheritance data.
+ *
+ * @param symbolTable - The cross-file symbol table to enrich
+ * @param projectRoot - Project root directory
+ * @param apiFrameworks - Detected API frameworks
+ * @param allSourceFiles - All source file paths
+ * @returns Aggregated diagnostics from all resolvers
+ */
+export declare function runCrossFileResolution(symbolTable: CrossFileSymbolTable, projectRoot: string, apiFrameworks: DetectedApiFramework[], allSourceFiles: string[]): CrossFileResolutionPassResult;
+//# sourceMappingURL=crossFileResolutionPass.d.ts.map

package/dist/src/pipeline/stages/ast/crossFileResolutionPass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossFileResolutionPass.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/crossFileResolutionPass.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,iBAAiB,EAGjB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAMjF;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAK3E;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,SAAS,iBAAiB,EAAE,CAEpE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAID,MAAM,WAAW,6BAA6B;IAC5C,+BAA+B;IAC/B,eAAe,EAAE,KAAK,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,cAAc,EAAE,KAAK,CAAC;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACxD,CAAC,CAAC;IACH,+CAA+C;IAC/C,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,oBAAoB,EACjC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,oBAAoB,EAAE,EACrC,cAAc,EAAE,MAAM,EAAE,GACvB,6BAA6B,CAoC/B"}

package/dist/src/pipeline/stages/ast/crossFileResolutionPass.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Cross-file resolution pass (Feature 27)
+ *
+ * Orchestrates all registered cross-file resolvers after the initial AST
+ * parsing pass. Each resolver enriches the CrossFileSymbolTable with
+ * framework-specific resolution data (Blueprint prefixes, Angular injection
+ * chains, DDD interface mappings, etc.).
+ *
+ * Resolvers are registered via `registerCrossFileResolver()` and discovered
+ * via `getCrossFileResolvers()`. Each resolver implements the `CrossFileResolver`
+ * interface and self-declares which API frameworks it applies to.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCrossFileResolver = registerCrossFileResolver;
+exports.getCrossFileResolvers = getCrossFileResolvers;
+exports.clearCrossFileResolvers = clearCrossFileResolvers;
+exports.runCrossFileResolution = runCrossFileResolution;
+// ─── Resolver registry ────────────────────────────────────────────────────────
+const resolverRegistry = [];
+/**
+ * Register a cross-file resolver. Resolvers are run in registration order.
+ */
+function registerCrossFileResolver(resolver) {
+    // Avoid duplicate registrations
+    if (!resolverRegistry.some((r) => r.name === resolver.name)) {
+        resolverRegistry.push(resolver);
+    }
+}
+/**
+ * Return all registered cross-file resolvers.
+ */
+function getCrossFileResolvers() {
+    return resolverRegistry;
+}
+/**
+ * Clear all registered resolvers (for testing).
+ */
+function clearCrossFileResolvers() {
+    resolverRegistry.length = 0;
+}
+/**
+ * Run all applicable cross-file resolvers against the symbol table.
+ *
+ * Each resolver mutates the symbol table in place, adding router mounts,
+ * injection chains, interface implementations, and middleware inheritance data.
+ *
+ * @param symbolTable - The cross-file symbol table to enrich
+ * @param projectRoot - Project root directory
+ * @param apiFrameworks - Detected API frameworks
+ * @param allSourceFiles - All source file paths
+ * @returns Aggregated diagnostics from all resolvers
+ */
+function runCrossFileResolution(symbolTable, projectRoot, apiFrameworks, allSourceFiles) {
+    const ctx = {
+        symbolTable,
+        projectRoot,
+        apiFrameworks,
+        allSourceFiles,
+    };
+    const resolverResults = [];
+    let totalEntriesAdded = 0;
+    for (const resolver of resolverRegistry) {
+        // Only run resolvers that apply to the detected frameworks
+        if (!resolver.appliesTo(apiFrameworks))
+            continue;
+        try {
+            const result = resolver.resolve(ctx);
+            resolverResults.push({
+                resolverName: resolver.name,
+                entriesAdded: result.entriesAdded,
+                diagnostics: result.diagnostics,
+                unresolvedRefs: result.unresolvedRefs,
+            });
+            totalEntriesAdded += result.entriesAdded;
+        }
+        catch (err) {
+            // Never let a resolver crash the pipeline
+            resolverResults.push({
+                resolverName: resolver.name,
+                entriesAdded: 0,
+                diagnostics: [`resolver-error: ${err instanceof Error ? err.message : String(err)}`],
+                unresolvedRefs: [],
+            });
+        }
+    }
+    return { resolverResults, totalEntriesAdded };
+}

package/dist/src/pipeline/stages/ast/crossFileResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crossFileResolver.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/crossFileResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAAE,oBAAoB,EAAuC,MAAM,SAAS,CAAC;AAGzF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EAClC,WAAW,EAAE,MAAM,GAClB,oBAAoB,CAuDtB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,oBAAoB,GAC1B,MAAM,GAAG,SAAS,CA4BpB"}
+{"version":3,"file":"crossFileResolver.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/crossFileResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAAE,oBAAoB,EAAuC,MAAM,SAAS,CAAC;AAGzF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EAClC,WAAW,EAAE,MAAM,GAClB,oBAAoB,CAgEtB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,oBAAoB,GAC1B,MAAM,GAAG,SAAS,CA4BpB"}

package/dist/src/pipeline/stages/ast/crossFileResolver.js

@@ -63,7 +63,16 @@ function buildCrossFileSymbolTable(models, projectRoot) {
         }
         importGraph.set(filePath, resolvedPaths);
     }
-    return { models, exportedSymbols, classes, importGraph };
+    return {
+        models,
+        exportedSymbols,
+        classes,
+        importGraph,
+        routerMounts: new Map(),
+        injectionChains: new Map(),
+        interfaceImplementations: new Map(),
+        middlewareInheritance: new Map(),
+    };
 }
 /**
  * Resolve a symbol name using the cross-file symbol table.

package/dist/src/pipeline/stages/ast/optionalAuthUnifier.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Optional auth unifier (Feature 27, Sub-PR 9)
+ *
+ * Normalizes all framework-specific auth classifications to a unified SecurityClassification.
+ * Maps framework-specific patterns:
+ *   Flask @jwt_optional → { optional: true }
+ *   Express auth.optional / credentialsRequired: false → { optional: true }
+ *   HapiJS auth: { mode: 'try' } → { optional: true }
+ *   Spring @PreAuthorize → { required: true }
+ *   Angular route guard → depends on guard type
+ */
+import type { SecurityClassification } from '../../../ast/astTypes';
+export interface AuthClassificationEntry {
+    framework: string;
+    sourcePattern: string;
+    classification: SecurityClassification;
+}
+/**
+ * Framework-specific auth pattern → unified SecurityClassification.
+ */
+export declare function unifyAuthClassification(framework: string, pattern: string): SecurityClassification | undefined;
+/**
+ * Detect auth coverage gaps.
+ */
+export interface AuthCoverageGap {
+    type: 'missing-401-test' | 'missing-optional-dual-path';
+    endpointPath: string;
+    security: SecurityClassification;
+    sourceFile: string;
+}
+/**
+ * Analyze auth coverage gaps in endpoints vs tests.
+ */
+export declare function detectAuthCoverageGaps(endpoints: Array<{
+    path: string;
+    security?: SecurityClassification;
+    sourceFile: string;
+}>, testAssertionPaths: Set<string>): AuthCoverageGap[];
+//# sourceMappingURL=optionalAuthUnifier.d.ts.map

package/dist/src/pipeline/stages/ast/optionalAuthUnifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optionalAuthUnifier.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/optionalAuthUnifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAEpE,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,sBAAsB,CAAC;CACxC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,sBAAsB,GAAG,SAAS,CAwCpC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,kBAAkB,GAAG,4BAA4B,CAAC;IACxD,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,sBAAsB,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EACzF,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,GAC9B,eAAe,EAAE,CA0BnB"}