api-tests-coverage 1.0.13 → 1.0.14

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

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * Graph builder — converts SemanticModels, cross-file results, and traversal
+ * results into GraphNode[] and GraphEdge[] for the Coverage Knowledge Graph.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAstGraph = buildAstGraph;
+const fileClassifier_1 = require("../../../discovery/fileClassifier");
+const path = __importStar(require("path"));
+/**
+ * Build graph nodes and edges from parsed semantic models and analysis results.
+ */
+function buildAstGraph(models, crossFileTable, traversalResults, interactions) {
+    const nodes = [];
+    const edges = [];
+    const addedNodeIds = new Set();
+    const addedEdgeIds = new Set();
+    function addNode(node) {
+        if (addedNodeIds.has(node.id))
+            return;
+        addedNodeIds.add(node.id);
+        nodes.push(node);
+    }
+    function addEdge(edge) {
+        if (addedEdgeIds.has(edge.id))
+            return;
+        addedEdgeIds.add(edge.id);
+        edges.push(edge);
+    }
+    // 1. Create file nodes for every parsed file
+    for (const [filePath, model] of models) {
+        const basename = path.basename(filePath);
+        const isTest = (0, fileClassifier_1.isTestFile)(basename);
+        const fileNodeType = isTest ? 'test-file' : 'file';
+        addNode({
+            id: `file:${filePath}`,
+            type: fileNodeType,
+            label: basename,
+            sourceStage: 'ast',
+            filePath,
+            metadata: { language: model.language, isTestFile: isTest },
+        });
+    }
+    // 2. Create endpoint nodes from HTTP interactions
+    for (const [filePath, fileInteractions] of interactions) {
+        for (const interaction of fileInteractions) {
+            const endpointId = `endpoint:${interaction.method}:${interaction.path}`;
+            addNode({
+                id: endpointId,
+                type: 'endpoint',
+                label: `${interaction.method} ${interaction.path}`,
+                sourceStage: 'ast',
+                filePath: interaction.sourceFile,
+                metadata: {
+                    method: interaction.method,
+                    path: interaction.path,
+                    normalizedPath: interaction.normalizedPath,
+                    resolutionType: interaction.resolutionType,
+                    confidence: interaction.confidence,
+                },
+            });
+            // Create 'tests' edge from test file to endpoint
+            const basename = path.basename(filePath);
+            if ((0, fileClassifier_1.isTestFile)(basename)) {
+                addEdge({
+                    id: `file:${filePath}->tests->${endpointId}`,
+                    type: 'tests',
+                    sourceNodeId: `file:${filePath}`,
+                    targetNodeId: endpointId,
+                    sourceStage: 'ast',
+                    metadata: {
+                        resolutionType: interaction.resolutionType,
+                        confidence: interaction.confidence,
+                    },
+                });
+            }
+            // Create 'asserts' edge if assertion-linked
+            if (interaction.assertionLinked && interaction.assertionType && interaction.assertionType !== 'none') {
+                addEdge({
+                    id: `file:${filePath}->asserts->${endpointId}`,
+                    type: 'asserts',
+                    sourceNodeId: `file:${filePath}`,
+                    targetNodeId: endpointId,
+                    sourceStage: 'ast',
+                    metadata: { assertionType: interaction.assertionType },
+                });
+            }
+        }
+    }
+    // 3. Create function/class nodes from semantic models
+    for (const [filePath, model] of models) {
+        for (const [funcName, func] of model.functions) {
+            const funcNodeId = `function:${filePath}:${funcName}`;
+            addNode({
+                id: funcNodeId,
+                type: 'function',
+                label: funcName,
+                sourceStage: 'ast',
+                filePath,
+                metadata: {
+                    parameters: func.parameters,
+                    annotations: func.annotations,
+                    httpCallCount: func.bodyHttpCalls.length,
+                    calledFunctions: func.calledFunctions,
+                },
+            });
+            // Create 'calls' edges to other functions
+            for (const calledFunc of func.calledFunctions) {
+                // Try to find the called function in the same file or imported files
+                const targetFile = findFunctionFile(calledFunc, filePath, crossFileTable);
+                if (targetFile) {
+                    const targetId = `function:${targetFile}:${calledFunc}`;
+                    addEdge({
+                        id: `${funcNodeId}->calls->${targetId}`,
+                        type: 'calls',
+                        sourceNodeId: funcNodeId,
+                        targetNodeId: targetId,
+                        sourceStage: 'ast',
+                        metadata: {},
+                    });
+                }
+            }
+            // Create edges from function to endpoints it defines (for controller methods)
+            for (const httpCall of func.bodyHttpCalls) {
+                if (httpCall.resolvedPath) {
+                    const endpointId = `endpoint:${httpCall.method}:${httpCall.resolvedPath}`;
+                    if (addedNodeIds.has(endpointId)) {
+                        addEdge({
+                            id: `${funcNodeId}->defines->${endpointId}`,
+                            type: 'defines',
+                            sourceNodeId: funcNodeId,
+                            targetNodeId: endpointId,
+                            sourceStage: 'ast',
+                            metadata: {},
+                        });
+                    }
+                }
+            }
+        }
+    }
+    // 4. Create class nodes from cross-file table
+    for (const [className, classDecl] of crossFileTable.classes) {
+        const classNodeId = `class:${classDecl.filePath}:${className}`;
+        addNode({
+            id: classNodeId,
+            type: 'class',
+            label: className,
+            sourceStage: 'ast',
+            filePath: classDecl.filePath,
+            line: classDecl.line,
+            metadata: {
+                methods: classDecl.methods,
+                extendsClass: classDecl.extendsClass,
+                implementsInterfaces: classDecl.implementsInterfaces,
+            },
+        });
+        // Create 'extends' edge if there's a base class
+        if (classDecl.extendsClass) {
+            const baseDecl = crossFileTable.classes.get(classDecl.extendsClass);
+            if (baseDecl) {
+                const baseNodeId = `class:${baseDecl.filePath}:${classDecl.extendsClass}`;
+                addEdge({
+                    id: `${classNodeId}->extends->${baseNodeId}`,
+                    type: 'extends',
+                    sourceNodeId: classNodeId,
+                    targetNodeId: baseNodeId,
+                    sourceStage: 'ast',
+                    metadata: {},
+                });
+            }
+        }
+    }
+    // 5. Create assertion nodes from traversal results
+    for (const [filePath, result] of traversalResults) {
+        if (result.resolvedAssertions.length > 0) {
+            const assertionNodeId = `assertion:${filePath}`;
+            addNode({
+                id: assertionNodeId,
+                type: 'assertion',
+                label: `Assertions (${result.assertionSource})`,
+                sourceStage: 'ast',
+                filePath,
+                metadata: {
+                    assertionSource: result.assertionSource,
+                    assertionCount: result.resolvedAssertions.length,
+                    traversalDepth: result.traversalDepth,
+                    resolution: result.resolution,
+                },
+            });
+        }
+    }
+    // 6. Create import edges from the import graph
+    for (const [filePath, importedFiles] of crossFileTable.importGraph) {
+        const sourceId = `file:${filePath}`;
+        if (!addedNodeIds.has(sourceId))
+            continue;
+        for (const importedFile of importedFiles) {
+            const targetId = `file:${importedFile}`;
+            if (!addedNodeIds.has(targetId))
+                continue;
+            addEdge({
+                id: `${sourceId}->imports-helper->${targetId}`,
+                type: 'imports-helper',
+                sourceNodeId: sourceId,
+                targetNodeId: targetId,
+                sourceStage: 'ast',
+                metadata: {},
+            });
+        }
+    }
+    return { nodes, edges };
+}
+/**
+ * Find the file containing a function definition.
+ */
+function findFunctionFile(funcName, fromFile, table) {
+    var _a;
+    // Check current file first
+    const currentModel = table.models.get(fromFile);
+    if (currentModel === null || currentModel === void 0 ? void 0 : currentModel.functions.has(funcName))
+        return fromFile;
+    // Check imported files
+    const importedFiles = (_a = table.importGraph.get(fromFile)) !== null && _a !== void 0 ? _a : [];
+    for (const importedFile of importedFiles) {
+        const model = table.models.get(importedFile);
+        if (model === null || model === void 0 ? void 0 : model.functions.has(funcName))
+            return importedFile;
+    }
+    // Search all models as fallback
+    for (const [filePath, model] of table.models) {
+        if (model.functions.has(funcName))
+            return filePath;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Import resolver — resolves import paths to absolute file paths.
+ *
+ * Supports:
+ * - TypeScript/JavaScript: relative paths, index files, .ts/.js extension resolution
+ * - Java: package-based imports to file paths
+ * - Kotlin: same as Java
+ * - Python: relative and absolute module imports
+ * - Ruby: require/require_relative
+ */
+import type { SupportedLanguage } from '../../../ast/astTypes';
+/**
+ * Resolve an import source to an absolute file path.
+ *
+ * @param importSource - The import specifier (e.g. './utils', 'express', 'com.example.Service')
+ * @param fromFile - The absolute path of the file containing the import
+ * @param projectRoot - The project root directory
+ * @param language - The language of the importing file
+ * @returns The resolved absolute file path, or undefined if unresolvable
+ */
+export declare function resolveImportPath(importSource: string, fromFile: string, projectRoot: string, language: SupportedLanguage): string | undefined;
+//# sourceMappingURL=importResolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"importResolver.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/importResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,iBAAiB,GAC1B,MAAM,GAAG,SAAS,CAepB"}

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

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Import resolver — resolves import paths to absolute file paths.
+ *
+ * Supports:
+ * - TypeScript/JavaScript: relative paths, index files, .ts/.js extension resolution
+ * - Java: package-based imports to file paths
+ * - Kotlin: same as Java
+ * - Python: relative and absolute module imports
+ * - Ruby: require/require_relative
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveImportPath = resolveImportPath;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Resolve an import source to an absolute file path.
+ *
+ * @param importSource - The import specifier (e.g. './utils', 'express', 'com.example.Service')
+ * @param fromFile - The absolute path of the file containing the import
+ * @param projectRoot - The project root directory
+ * @param language - The language of the importing file
+ * @returns The resolved absolute file path, or undefined if unresolvable
+ */
+function resolveImportPath(importSource, fromFile, projectRoot, language) {
+    switch (language) {
+        case 'typescript':
+        case 'javascript':
+            return resolveJsTsImport(importSource, fromFile, projectRoot);
+        case 'java':
+        case 'kotlin':
+            return resolveJavaKotlinImport(importSource, fromFile, projectRoot, language);
+        case 'python':
+            return resolvePythonImport(importSource, fromFile, projectRoot);
+        case 'ruby':
+            return resolveRubyImport(importSource, fromFile, projectRoot);
+        default:
+            return undefined;
+    }
+}
+// ─── JS/TS Import Resolution ─────────────────────────────────────────────────
+const JS_TS_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+function resolveJsTsImport(importSource, fromFile, projectRoot) {
+    // Skip bare module specifiers (node_modules packages)
+    if (!importSource.startsWith('.') && !importSource.startsWith('/')) {
+        return undefined;
+    }
+    const fromDir = path.dirname(fromFile);
+    const basePath = path.resolve(fromDir, importSource);
+    // Try exact match first
+    if (existsAsFile(basePath))
+        return basePath;
+    // Try with extensions
+    for (const ext of JS_TS_EXTENSIONS) {
+        const withExt = basePath + ext;
+        if (existsAsFile(withExt))
+            return withExt;
+    }
+    // Try as directory with index file
+    for (const ext of JS_TS_EXTENSIONS) {
+        const indexFile = path.join(basePath, `index${ext}`);
+        if (existsAsFile(indexFile))
+            return indexFile;
+    }
+    return undefined;
+}
+// ─── Java/Kotlin Import Resolution ───────────────────────────────────────────
+function resolveJavaKotlinImport(importSource, _fromFile, projectRoot, language) {
+    // Java import: com.example.service.UserService → src/main/java/com/example/service/UserService.java
+    // Handle wildcard imports: com.example.service.* → directory
+    const cleanImport = importSource.replace(/\.\*$/, '');
+    const pathParts = cleanImport.split('.');
+    const extensions = language === 'kotlin' ? ['.kt', '.kts', '.java'] : ['.java', '.kt'];
+    const sourceDirs = ['src/main/java', 'src/main/kotlin', 'src/test/java', 'src/test/kotlin', 'src'];
+    for (const sourceDir of sourceDirs) {
+        for (const ext of extensions) {
+            const filePath = path.join(projectRoot, sourceDir, ...pathParts) + ext;
+            if (existsAsFile(filePath))
+                return filePath;
+        }
+    }
+    return undefined;
+}
+// ─── Python Import Resolution ────────────────────────────────────────────────
+function resolvePythonImport(importSource, fromFile, projectRoot) {
+    // Relative import: .utils or ..models
+    const dotMatch = /^(\.+)(.*)$/.exec(importSource);
+    if (dotMatch) {
+        const dots = dotMatch[1].length;
+        const rest = dotMatch[2];
+        let baseDir = path.dirname(fromFile);
+        for (let i = 1; i < dots; i++) {
+            baseDir = path.dirname(baseDir);
+        }
+        const parts = rest ? rest.split('.') : [];
+        return resolvePythonPath(path.join(baseDir, ...parts));
+    }
+    // Absolute import: package.module
+    const parts = importSource.split('.');
+    // Try from project root and common source directories
+    const searchDirs = [projectRoot, path.join(projectRoot, 'src'), path.join(projectRoot, 'tests')];
+    for (const dir of searchDirs) {
+        const result = resolvePythonPath(path.join(dir, ...parts));
+        if (result)
+            return result;
+    }
+    return undefined;
+}
+function resolvePythonPath(basePath) {
+    // Try as .py file
+    const asFile = basePath + '.py';
+    if (existsAsFile(asFile))
+        return asFile;
+    // Try as package (__init__.py)
+    const asPackage = path.join(basePath, '__init__.py');
+    if (existsAsFile(asPackage))
+        return asPackage;
+    return undefined;
+}
+// ─── Ruby Import Resolution ─────────────────────────────────────────────────
+function resolveRubyImport(importSource, fromFile, projectRoot) {
+    // require_relative './utils' → relative to current file
+    // require 'app/models/user' → relative to project root / lib
+    if (importSource.startsWith('.')) {
+        const fromDir = path.dirname(fromFile);
+        const basePath = path.resolve(fromDir, importSource);
+        return tryRubyExtensions(basePath);
+    }
+    const searchDirs = [projectRoot, path.join(projectRoot, 'lib'), path.join(projectRoot, 'app')];
+    for (const dir of searchDirs) {
+        const result = tryRubyExtensions(path.join(dir, importSource));
+        if (result)
+            return result;
+    }
+    return undefined;
+}
+function tryRubyExtensions(basePath) {
+    if (existsAsFile(basePath))
+        return basePath;
+    const withRb = basePath + '.rb';
+    if (existsAsFile(withRb))
+        return withRb;
+    return undefined;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function existsAsFile(filePath) {
+    try {
+        return fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,85 @@
+/**
+ * AST stage types — cross-file analysis, import resolution, and abstract layer traversal.
+ */
+import type { SemanticModel, SemanticHttpCall, SemanticAssertion } from '../../../ast/astTypes';
+import type { AssertionSource } from '../../types';
+/**
+ * An import declaration extracted from a source file.
+ */
+export interface ImportDeclaration {
+    /** The import source specifier (e.g. './utils', 'express', '@nestjs/common') */
+    source: string;
+    /** The resolved absolute file path (undefined if unresolvable) */
+    resolvedPath?: string;
+    /** Names imported (e.g. ['Router', 'Response'] or ['default']) */
+    importedNames: string[];
+    /** Whether this is a default import */
+    isDefault: boolean;
+    /** Line number in source file */
+    line?: number;
+}
+/**
+ * A class declaration extracted from a source file.
+ */
+export interface ClassDeclaration {
+    name: string;
+    extendsClass?: string;
+    implementsInterfaces?: string[];
+    methods: string[];
+    filePath: string;
+    line?: number;
+}
+/**
+ * Multi-file symbol table aggregating all parsed file models.
+ */
+export interface CrossFileSymbolTable {
+    /** All parsed semantic models keyed by file path */
+    models: Map<string, SemanticModel>;
+    /** Exported symbols: symbolName → { filePath, value } */
+    exportedSymbols: Map<string, {
+        filePath: string;
+        value: string;
+    }>;
+    /** All classes: className → declaration */
+    classes: Map<string, ClassDeclaration>;
+    /** Import graph: filePath → array of resolved import file paths */
+    importGraph: Map<string, string[]>;
+}
+/**
+ * Result of abstract layer traversal (inheritance, helpers, fixtures).
+ */
+export interface TraversalResult {
+    /** Assertions resolved from base classes, helpers, or fixtures */
+    resolvedAssertions: SemanticAssertion[];
+    /** HTTP calls resolved from abstract layers */
+    resolvedHttpCalls: SemanticHttpCall[];
+    /** How the assertion was sourced */
+    assertionSource: AssertionSource;
+    /** How deep the traversal went */
+    traversalDepth: number;
+    /** Whether resolution is full or partial */
+    resolution: 'full' | 'partial';
+    /** Chain of unresolved references (for diagnostics) */
+    unresolvedChain?: string[];
+    /** Whether a cycle was detected during traversal */
+    cycleDetected: boolean;
+}
+/**
+ * Output of the AST pipeline stage.
+ */
+export interface AstStageOutput {
+    /** All parsed semantic models */
+    models: Map<string, SemanticModel>;
+    /** Cross-file symbol table */
+    crossFileTable: CrossFileSymbolTable;
+    /** Traversal results per test file */
+    traversalResults: Map<string, TraversalResult>;
+    /** Files that were successfully analyzed */
+    analyzedFiles: string[];
+    /** Files that failed or were skipped */
+    skippedFiles: Array<{
+        file: string;
+        reason: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,iBAAiB,EAAuC,MAAM,uBAAuB,CAAC;AACrI,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAC;IACf,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,uCAAuC;IACvC,SAAS,EAAE,OAAO,CAAC;IACnB,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACnC,yDAAyD;IACzD,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,2CAA2C;IAC3C,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvC,mEAAmE;IACnE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;IACxC,+CAA+C;IAC/C,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,oCAAoC;IACpC,eAAe,EAAE,eAAe,CAAC;IACjC,kCAAkC;IAClC,cAAc,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,oDAAoD;IACpD,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACnC,8BAA8B;IAC9B,cAAc,EAAE,oBAAoB,CAAC;IACrC,sCAAsC;IACtC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC/C,4CAA4C;IAC5C,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,wCAAwC;IACxC,YAAY,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvD"}

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

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * AST stage types — cross-file analysis, import resolution, and abstract layer traversal.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pipeline/stages/dast/conflictEmitter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * DAST conflict emitter — detects conflicts between DAST probe results and
+ * AST-declared endpoints.
+ *
+ * Conflict rules from spec §7:
+ *
+ * | DAST Result              | AST Declared          | Conflict Type                      |
+ * |--------------------------|-----------------------|------------------------------------|
+ * | Not reachable            | Endpoint exists       | dast-unreachable                   |
+ * | Reachable, no auth check | @Secured present      | security-annotation-not-enforced   |
+ * | Returns 500              | No error handler      | unhandled-server-error             |
+ * | New endpoint found       | Not in AST            | undeclared-endpoint                |
+ */
+import type { ConflictNode } from '../../types';
+import type { CoverageKnowledgeGraph } from '../../graph';
+import type { DastProbeResult } from './types';
+/**
+ * Emit conflicts by comparing DAST results with the AST-declared graph.
+ *
+ * @param results - DAST probe results
+ * @param graph - Current coverage knowledge graph
+ * @returns Array of conflict nodes to be added to the graph
+ */
+export declare function emitDastConflicts(results: DastProbeResult[], graph: CoverageKnowledgeGraph): ConflictNode[];
+//# sourceMappingURL=conflictEmitter.d.ts.map

package/dist/src/pipeline/stages/dast/conflictEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflictEmitter.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/dast/conflictEmitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkC,MAAM,aAAa,CAAC;AAChF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,eAAe,EAAE,EAC1B,KAAK,EAAE,sBAAsB,GAC5B,YAAY,EAAE,CA0EhB"}