agentic-qe 2.6.4 → 2.6.6

package/dist/code-intelligence/service/CodeIntelligenceService.js.map

@@ -1 +1 @@
-{"version":3,"file":"CodeIntelligenceService.js","sourceRoot":"","sources":["../../../src/code-intelligence/service/CodeIntelligenceService.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"CodeIntelligenceService.js","sourceRoot":"","sources":["../../../src/code-intelligence/service/CodeIntelligenceService.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuXH,gEAEC;AAED,gEAIC;AAED,gFAEC;AAjYD,qGAA+F;AAI/F,2CAA6B;AA+C7B,qBAAqB;AACrB,IAAI,QAAQ,GAAmC,IAAI,CAAC;AAEpD;;;;;;;GAOG;AACH,MAAa,uBAAuB;IAOlC,YAAoB,SAAwC,EAAE;QANtD,iBAAY,GAAwC,IAAI,CAAC;QAEzD,gBAAW,GAAY,KAAK,CAAC;QAC7B,iBAAY,GAAyB,IAAI,CAAC;QAIhD,0CAA0C;QAC1C,MAAM,UAAU,GAAG,MAAM,IAAI,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM,GAAG;YACZ,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE;YAC5C,YAAY,EAAE,UAAU,CAAC,YAAY,IAAI,KAAK;YAC9C,UAAU,EAAE,UAAU,CAAC,UAAU,IAAI,IAAI;YACzC,SAAS,EAAE,UAAU,CAAC,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,wBAAwB;YACrF,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI;gBAC/B,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,WAAW;gBAC9C,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC;gBACnD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,aAAa;gBACxD,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,UAAU;gBAC7C,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,UAAU;aACtD;SACF,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,MAAsC;QACvD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,QAAQ,GAAG,IAAI,uBAAuB,CAAC,MAAM,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,aAAa;QAClB,IAAI,QAAQ,EAAE,CAAC;YACb,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACzC,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,kBAAkB;QAO7B,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,IAAI,MAAM,GAAG,KAAK,CAAC;QACnB,IAAI,WAAW,GAAG,KAAK,CAAC;QACxB,IAAI,QAAQ,GAAG,KAAK,CAAC;QAErB,eAAe;QACf,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,wBAAwB,CAAC;YACrE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,SAAS,WAAW,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC7F,IAAI,QAAQ,CAAC,EAAE,EAAE,CAAC;gBAChB,MAAM,GAAG,IAAI,CAAC;gBACd,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAA0C,CAAC;gBAC3E,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC;gBACjC,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAmB,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAC;gBACxF,IAAI,CAAC,WAAW,EAAE,CAAC;oBACjB,QAAQ,CAAC,IAAI,CAAC,wFAAwF,CAAC,CAAC;gBAC1G,CAAC;YACH,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,QAAQ,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;QAClE,CAAC;QAED,4BAA4B;QAC5B,IAAI,CAAC;YACH,MAAM,EAAE,IAAI,EAAE,GAAG,wDAAa,IAAI,GAAC,CAAC;YACpC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC;gBACpB,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,WAAW;gBAC9C,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,MAAM,CAAC;gBACnD,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,aAAa;gBACxD,IAAI,EAAE,OAAO,CAAC,GAAG,CAAC,aAAa,IAAI,UAAU;gBAC7C,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,UAAU;gBACrD,uBAAuB,EAAE,IAAI;aAC9B,CAAC,CAAC;YACH,MAAM,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;YAC7B,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;YACjB,QAAQ,GAAG,IAAI,CAAC;QAClB,CAAC;QAAC,MAAM,CAAC;YACP,QAAQ,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;QACzF,CAAC;QAED,OAAO;YACL,MAAM;YACN,WAAW;YACX,QAAQ;YACR,QAAQ,EAAE,MAAM,IAAI,WAAW,IAAI,QAAQ;YAC3C,QAAQ;SACT,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,OAAO;QACT,CAAC;QAED,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QACzC,MAAM,IAAI,CAAC,YAAY,CAAC;QACxB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,aAAa;QACzB,sBAAsB;QACtB,MAAM,OAAO,GAAG,MAAM,uBAAuB,CAAC,kBAAkB,EAAE,CAAC;QACnE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACb,6CAA6C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3E,CAAC;QACJ,CAAC;QAED,2CAA2C;QAC3C,MAAM,kBAAkB,GAAgC;YACtD,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,EAAE;YAC7C,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,YAAY,IAAI,KAAK;YAC/C,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,UAAU,IAAI,IAAI;YAC1C,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,wBAAwB;YAC5D,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;SAC/B,CAAC;QAEF,0BAA0B;QAC1B,IAAI,CAAC,YAAY,GAAG,IAAI,8DAA4B,CAAC,kBAAkB,CAAC,CAAC;QACzE,MAAM,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,CAAC;QACrC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QAExB,OAAO,CAAC,GAAG,CAAC,oDAAoD,CAAC,CAAC;IACpE,CAAC;IAED;;;;;OAKG;IACH,aAAa;QACX,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,mEAAmE,CAAC,CAAC;QACvF,CAAC;QAED,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE;YACjD,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE;YACjD,YAAY,EAAE,IAAI,CAAC,YAAY;SAChC,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,cAAc;QAKZ,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAC5B,CAAC;QAED,OAAO;YACL,OAAO,EAAE,IAAI;YACb,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE;YACjD,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE;SAClD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,YAAY,KAAK,IAAI,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS;QACb,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,OAAO;gBACL,WAAW,EAAE,KAAK;gBAClB,OAAO,EAAE,KAAK;gBACd,aAAa,EAAE,CAAC;gBAChB,UAAU,EAAE,CAAC;gBACb,UAAU,EAAE,CAAC;gBACb,KAAK,EAAE,yBAAyB;aACjC,CAAC;QACJ,CAAC;QAED,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC3C,OAAO;gBACL,WAAW,EAAE,IAAI;gBACjB,OAAO,EAAE,IAAI;gBACb,aAAa,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW;gBACxC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS;gBACjC,UAAU,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS;gBACjC,aAAa,EAAE,IAAI,CAAC,aAAa;aAClC,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,WAAW,EAAE,IAAI;gBACjB,OAAO,EAAE,KAAK;gBACd,aAAa,EAAE,CAAC;gBAChB,UAAU,EAAE,CAAC;gBACb,UAAU,EAAE,CAAC;gBACb,KAAK,EAAG,KAAe,CAAC,OAAO;aAChC,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,cAAc,CAClB,SAAiB,EACjB,UAAsG;QAStG,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QAED,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;YAC7C,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAQ,EAAE,SAAS,CAAC,CAAC;QAE/C,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;QAC9E,IAAI,CAAC,aAAa,GAAG,IAAI,IAAI,EAAE,CAAC;QAEhC,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM,CACV,KAAa,EACb,UAII,EAAE;QAEN,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5C,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QAED,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;YAC7B,KAAK;YACL,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,EAAE;YACxB,mBAAmB,EAAE,OAAO,CAAC,mBAAmB,IAAI,IAAI;YACxD,UAAU,EAAE,OAAO,CAAC,UAAU,IAAI,CAAC;SACpC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YACnC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,OAAO,CAAC,GAAG,CAAC,6CAA6C,CAAC,CAAC;IAC7D,CAAC;CACF;AApTD,0DAoTC;AAED,+BAA+B;AAC/B,SAAgB,0BAA0B,CAAC,MAAsC;IAC/E,OAAO,uBAAuB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC;AAEM,KAAK,UAAU,0BAA0B,CAAC,MAAsC;IACrF,MAAM,OAAO,GAAG,uBAAuB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5D,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC;IAC3B,OAAO,OAAO,CAAC;AACjB,CAAC;AAEM,KAAK,UAAU,kCAAkC;IACtD,OAAO,uBAAuB,CAAC,kBAAkB,EAAE,CAAC;AACtD,CAAC"}

package/dist/core/memory/HNSWVectorMemory.js

@@ -507,7 +507,7 @@ class HNSWVectorMemory {
     getImplementationInfo() {
         return {
             type: 'agentdb',
-            version: '2.6.4',
+            version: '2.6.6',
             features: ['hnsw', 'vector-search', 'persistence', 'batch-operations'],
         };
     }

package/dist/coverage/CriticalPathDetector.d.ts

@@ -0,0 +1,240 @@
+/**
+ * CriticalPathDetector - Identify critical execution paths using MinCut analysis
+ *
+ * This component uses graph-theoretic minimum cut algorithms to identify:
+ * - Bottleneck code paths that many execution flows depend on
+ * - Critical edges in the dependency graph
+ * - High-priority coverage gaps based on structural importance
+ *
+ * @module coverage/CriticalPathDetector
+ * @version 1.0.0
+ */
+import { CutEdge } from '../code-intelligence/analysis/mincut/types.js';
+/**
+ * Represents a node in the coverage dependency graph
+ */
+export interface CoverageNode {
+    /** Unique identifier (typically file path or function ID) */
+    id: string;
+    /** Human-readable label */
+    label: string;
+    /** Type of code entity */
+    type: 'file' | 'function' | 'class' | 'method' | 'module';
+    /** Current coverage percentage (0-100) */
+    coverage: number;
+    /** Number of lines in this entity */
+    lines: number;
+    /** Cyclomatic complexity (if available) */
+    complexity?: number;
+    /** Whether this node is an entry point */
+    isEntryPoint?: boolean;
+    /** Whether this node is an exit point (e.g., API endpoint) */
+    isExitPoint?: boolean;
+}
+/**
+ * Represents an edge in the coverage dependency graph
+ */
+export interface CoverageEdge {
+    /** Source node ID */
+    source: string;
+    /** Target node ID */
+    target: string;
+    /** Edge weight (call frequency, dependency strength, etc.) */
+    weight: number;
+    /** Type of dependency */
+    type: 'calls' | 'imports' | 'extends' | 'implements' | 'uses';
+}
+/**
+ * Input for critical path detection
+ */
+export interface CriticalPathInput {
+    /** Nodes in the coverage graph */
+    nodes: CoverageNode[];
+    /** Edges representing dependencies */
+    edges: CoverageEdge[];
+    /** Optional: Specific entry points to analyze from */
+    entryPoints?: string[];
+    /** Optional: Specific exit points to analyze to */
+    exitPoints?: string[];
+}
+/**
+ * A critical path identified by the detector
+ */
+export interface CriticalPath {
+    /** Unique path identifier */
+    id: string;
+    /** Nodes in this critical path (ordered) */
+    nodes: string[];
+    /** Edges in this critical path */
+    edges: CutEdge[];
+    /** Criticality score (0-1, higher = more critical) */
+    criticality: number;
+    /** Total weight of dependencies flowing through this path */
+    flowWeight: number;
+    /** Average coverage of nodes in this path */
+    averageCoverage: number;
+    /** Reason why this path is critical */
+    reason: string;
+}
+/**
+ * A coverage gap with priority ranking
+ */
+export interface PrioritizedCoverageGap {
+    /** Node ID with the coverage gap */
+    nodeId: string;
+    /** Node label */
+    label: string;
+    /** Current coverage percentage */
+    currentCoverage: number;
+    /** Priority rank (1 = highest priority) */
+    priority: number;
+    /** Criticality score based on MinCut analysis */
+    criticality: number;
+    /** Impact score if this gap is filled */
+    impactScore: number;
+    /** Which critical paths this node belongs to */
+    criticalPaths: string[];
+    /** Suggested test focus areas */
+    testSuggestions: string[];
+    /** Estimated effort to achieve coverage */
+    estimatedEffort: 'low' | 'medium' | 'high';
+}
+/**
+ * Result of critical path detection
+ */
+export interface CriticalPathResult {
+    /** Identified critical paths */
+    criticalPaths: CriticalPath[];
+    /** Prioritized coverage gaps */
+    prioritizedGaps: PrioritizedCoverageGap[];
+    /** Bottleneck nodes (appear in multiple critical paths) */
+    bottlenecks: BottleneckNode[];
+    /** Overall graph metrics */
+    metrics: GraphMetrics;
+    /** Computation time in milliseconds */
+    computationTimeMs: number;
+}
+/**
+ * A bottleneck node in the dependency graph
+ */
+export interface BottleneckNode {
+    /** Node ID */
+    nodeId: string;
+    /** Node label */
+    label: string;
+    /** Number of critical paths this node appears in */
+    pathCount: number;
+    /** Total flow weight through this node */
+    totalFlowWeight: number;
+    /** Current coverage */
+    coverage: number;
+    /** Risk level if this bottleneck is not covered */
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
+}
+/**
+ * Metrics about the analyzed graph
+ */
+export interface GraphMetrics {
+    /** Total number of nodes */
+    totalNodes: number;
+    /** Total number of edges */
+    totalEdges: number;
+    /** Number of critical paths identified */
+    criticalPathCount: number;
+    /** Average coverage across all nodes */
+    averageCoverage: number;
+    /** Graph connectivity score (0-1) */
+    connectivityScore: number;
+    /** Minimum cut value of the graph */
+    minCutValue: number;
+}
+/**
+ * Configuration for the CriticalPathDetector
+ */
+export interface CriticalPathConfig {
+    /** Minimum criticality threshold for paths (0-1) */
+    criticalityThreshold?: number;
+    /** Maximum number of critical paths to return */
+    maxCriticalPaths?: number;
+    /** Coverage threshold below which a node is considered a gap */
+    coverageGapThreshold?: number;
+    /** Timeout for MinCut computation in milliseconds */
+    timeout?: number;
+}
+/**
+ * CriticalPathDetector uses MinCut algorithms to identify critical execution paths
+ * and prioritize coverage gaps based on their structural importance in the codebase.
+ *
+ * @example
+ * ```typescript
+ * const detector = new CriticalPathDetector();
+ * const result = await detector.detectCriticalPaths({
+ *   nodes: [
+ *     { id: 'auth.ts', label: 'AuthService', type: 'file', coverage: 45, lines: 200 },
+ *     { id: 'user.ts', label: 'UserService', type: 'file', coverage: 80, lines: 150 },
+ *   ],
+ *   edges: [
+ *     { source: 'user.ts', target: 'auth.ts', weight: 5, type: 'calls' },
+ *   ],
+ * });
+ * console.log('Critical paths:', result.criticalPaths);
+ * console.log('Priority gaps:', result.prioritizedGaps);
+ * ```
+ */
+export declare class CriticalPathDetector {
+    private config;
+    private minCutAnalyzer;
+    constructor(config?: CriticalPathConfig);
+    /**
+     * Detect critical paths and prioritize coverage gaps
+     *
+     * @param input - Coverage graph with nodes and edges
+     * @returns Promise resolving to CriticalPathResult
+     */
+    detectCriticalPaths(input: CriticalPathInput): Promise<CriticalPathResult>;
+    /**
+     * Get prioritized coverage gaps only (simpler API)
+     */
+    getPrioritizedGaps(input: CriticalPathInput): Promise<PrioritizedCoverageGap[]>;
+    /**
+     * Validate input data
+     */
+    private validateInput;
+    /**
+     * Convert coverage graph to MinCut input format
+     */
+    private toMinCutGraph;
+    /**
+     * Build critical paths from MinCut results
+     */
+    private buildCriticalPaths;
+    /**
+     * Generate human-readable reason for why a path is critical
+     */
+    private generateCriticalPathReason;
+    /**
+     * Identify bottleneck nodes that appear in multiple critical paths
+     */
+    private identifyBottlenecks;
+    /**
+     * Calculate risk level for a bottleneck node
+     */
+    private calculateRiskLevel;
+    /**
+     * Prioritize coverage gaps based on critical path analysis
+     */
+    private prioritizeCoverageGaps;
+    /**
+     * Generate test suggestions for a coverage gap
+     */
+    private generateTestSuggestions;
+    /**
+     * Estimate effort to achieve coverage
+     */
+    private estimateEffort;
+    /**
+     * Calculate overall graph metrics
+     */
+    private calculateMetrics;
+}
+//# sourceMappingURL=CriticalPathDetector.d.ts.map

package/dist/coverage/CriticalPathDetector.d.ts.map

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

package/dist/coverage/CriticalPathDetector.js

@@ -0,0 +1,388 @@
+"use strict";
+/**
+ * CriticalPathDetector - Identify critical execution paths using MinCut analysis
+ *
+ * This component uses graph-theoretic minimum cut algorithms to identify:
+ * - Bottleneck code paths that many execution flows depend on
+ * - Critical edges in the dependency graph
+ * - High-priority coverage gaps based on structural importance
+ *
+ * @module coverage/CriticalPathDetector
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriticalPathDetector = void 0;
+const MinCutAnalyzer_js_1 = require("../code-intelligence/analysis/mincut/MinCutAnalyzer.js");
+const Logger_js_1 = require("../utils/Logger.js");
+const logger = Logger_js_1.Logger.getInstance();
+const DEFAULT_CONFIG = {
+    criticalityThreshold: 0.3,
+    maxCriticalPaths: 10,
+    coverageGapThreshold: 80,
+    timeout: 10000,
+};
+/**
+ * CriticalPathDetector uses MinCut algorithms to identify critical execution paths
+ * and prioritize coverage gaps based on their structural importance in the codebase.
+ *
+ * @example
+ * ```typescript
+ * const detector = new CriticalPathDetector();
+ * const result = await detector.detectCriticalPaths({
+ *   nodes: [
+ *     { id: 'auth.ts', label: 'AuthService', type: 'file', coverage: 45, lines: 200 },
+ *     { id: 'user.ts', label: 'UserService', type: 'file', coverage: 80, lines: 150 },
+ *   ],
+ *   edges: [
+ *     { source: 'user.ts', target: 'auth.ts', weight: 5, type: 'calls' },
+ *   ],
+ * });
+ * console.log('Critical paths:', result.criticalPaths);
+ * console.log('Priority gaps:', result.prioritizedGaps);
+ * ```
+ */
+class CriticalPathDetector {
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.minCutAnalyzer = new MinCutAnalyzer_js_1.MinCutAnalyzer({
+            timeout: this.config.timeout,
+            maxNodes: 5000,
+        });
+        logger.debug('CriticalPathDetector initialized', { config: this.config });
+    }
+    /**
+     * Detect critical paths and prioritize coverage gaps
+     *
+     * @param input - Coverage graph with nodes and edges
+     * @returns Promise resolving to CriticalPathResult
+     */
+    async detectCriticalPaths(input) {
+        const startTime = Date.now();
+        try {
+            // Validate input
+            this.validateInput(input);
+            // Convert to MinCut graph format
+            const minCutGraph = this.toMinCutGraph(input);
+            // Find minimum cuts (identifies critical edges)
+            const minCutResults = await this.minCutAnalyzer.findAllMinCuts(minCutGraph, this.config.maxCriticalPaths);
+            // Build critical paths from cut results
+            const criticalPaths = this.buildCriticalPaths(input, minCutResults);
+            // Identify bottleneck nodes
+            const bottlenecks = this.identifyBottlenecks(input, criticalPaths);
+            // Prioritize coverage gaps
+            const prioritizedGaps = this.prioritizeCoverageGaps(input, criticalPaths, bottlenecks);
+            // Calculate graph metrics
+            const metrics = this.calculateMetrics(input, minCutResults, criticalPaths);
+            const computationTimeMs = Date.now() - startTime;
+            logger.info('Critical path detection completed', {
+                criticalPathCount: criticalPaths.length,
+                bottleneckCount: bottlenecks.length,
+                gapCount: prioritizedGaps.length,
+                computationTimeMs,
+            });
+            return {
+                criticalPaths,
+                prioritizedGaps,
+                bottlenecks,
+                metrics,
+                computationTimeMs,
+            };
+        }
+        catch (error) {
+            logger.error('Critical path detection failed', { error });
+            throw error;
+        }
+    }
+    /**
+     * Get prioritized coverage gaps only (simpler API)
+     */
+    async getPrioritizedGaps(input) {
+        const result = await this.detectCriticalPaths(input);
+        return result.prioritizedGaps;
+    }
+    /**
+     * Validate input data
+     */
+    validateInput(input) {
+        if (!input.nodes || input.nodes.length === 0) {
+            throw new Error('Input must have at least one node');
+        }
+        if (!input.edges) {
+            throw new Error('Input must have edges array (can be empty)');
+        }
+        const nodeIds = new Set(input.nodes.map(n => n.id));
+        for (const edge of input.edges) {
+            if (!nodeIds.has(edge.source)) {
+                throw new Error(`Edge source '${edge.source}' not found in nodes`);
+            }
+            if (!nodeIds.has(edge.target)) {
+                throw new Error(`Edge target '${edge.target}' not found in nodes`);
+            }
+        }
+    }
+    /**
+     * Convert coverage graph to MinCut input format
+     */
+    toMinCutGraph(input) {
+        return {
+            nodes: input.nodes.map(n => ({
+                id: n.id,
+                label: n.label,
+                properties: {
+                    type: n.type,
+                    coverage: n.coverage,
+                    lines: n.lines,
+                    complexity: n.complexity,
+                    isEntryPoint: n.isEntryPoint,
+                    isExitPoint: n.isExitPoint,
+                },
+            })),
+            edges: input.edges.map(e => ({
+                source: e.source,
+                target: e.target,
+                weight: e.weight,
+                edgeType: e.type,
+            })),
+            directed: false, // MinCut works on undirected graphs
+        };
+    }
+    /**
+     * Build critical paths from MinCut results
+     */
+    buildCriticalPaths(input, minCutResults) {
+        const nodeMap = new Map(input.nodes.map(n => [n.id, n]));
+        const criticalPaths = [];
+        for (let i = 0; i < minCutResults.length; i++) {
+            const result = minCutResults[i];
+            if (result.cutValue === 0 || result.cutEdges.length === 0) {
+                continue;
+            }
+            // Calculate average coverage for nodes in this cut
+            const cutNodeIds = new Set([
+                ...result.cutEdges.map(e => e.source),
+                ...result.cutEdges.map(e => e.target),
+            ]);
+            const cutNodes = Array.from(cutNodeIds)
+                .map(id => nodeMap.get(id))
+                .filter((n) => n !== undefined);
+            const averageCoverage = cutNodes.length > 0
+                ? cutNodes.reduce((sum, n) => sum + n.coverage, 0) / cutNodes.length
+                : 0;
+            // Calculate criticality based on cut value and position
+            const maxWeight = Math.max(...input.edges.map(e => e.weight), 1);
+            const normalizedCutValue = result.cutValue / maxWeight;
+            const criticality = Math.min(1, normalizedCutValue * (1 / (i + 1)));
+            if (criticality < this.config.criticalityThreshold) {
+                continue;
+            }
+            criticalPaths.push({
+                id: `critical-path-${i + 1}`,
+                nodes: Array.from(cutNodeIds),
+                edges: result.cutEdges,
+                criticality,
+                flowWeight: result.cutValue,
+                averageCoverage,
+                reason: this.generateCriticalPathReason(result, cutNodes, criticality),
+            });
+        }
+        return criticalPaths.slice(0, this.config.maxCriticalPaths);
+    }
+    /**
+     * Generate human-readable reason for why a path is critical
+     */
+    generateCriticalPathReason(result, nodes, criticality) {
+        const lowCoverageNodes = nodes.filter(n => n.coverage < this.config.coverageGapThreshold);
+        const avgCoverage = nodes.length > 0
+            ? nodes.reduce((sum, n) => sum + n.coverage, 0) / nodes.length
+            : 0;
+        if (lowCoverageNodes.length > 0) {
+            return `Contains ${lowCoverageNodes.length} low-coverage node(s) with ${result.cutEdges.length} critical edge(s). Average coverage: ${avgCoverage.toFixed(1)}%`;
+        }
+        if (criticality > 0.7) {
+            return `High-traffic path with ${result.cutEdges.length} edge(s) carrying ${result.cutValue.toFixed(2)} total weight`;
+        }
+        return `Structural bottleneck connecting ${result.partition1.length} and ${result.partition2.length} components`;
+    }
+    /**
+     * Identify bottleneck nodes that appear in multiple critical paths
+     */
+    identifyBottlenecks(input, criticalPaths) {
+        const nodeMap = new Map(input.nodes.map(n => [n.id, n]));
+        const nodePathCount = new Map();
+        const nodeFlowWeight = new Map();
+        // Count appearances in critical paths
+        for (const path of criticalPaths) {
+            for (const nodeId of path.nodes) {
+                nodePathCount.set(nodeId, (nodePathCount.get(nodeId) || 0) + 1);
+                nodeFlowWeight.set(nodeId, (nodeFlowWeight.get(nodeId) || 0) + path.flowWeight);
+            }
+        }
+        // Build bottleneck list
+        const bottlenecks = [];
+        for (const [nodeId, pathCount] of nodePathCount.entries()) {
+            if (pathCount >= 2 || (pathCount >= 1 && criticalPaths.length <= 2)) {
+                const node = nodeMap.get(nodeId);
+                if (!node)
+                    continue;
+                const flowWeight = nodeFlowWeight.get(nodeId) || 0;
+                const riskLevel = this.calculateRiskLevel(node, pathCount, flowWeight);
+                bottlenecks.push({
+                    nodeId,
+                    label: node.label,
+                    pathCount,
+                    totalFlowWeight: flowWeight,
+                    coverage: node.coverage,
+                    riskLevel,
+                });
+            }
+        }
+        // Sort by risk (critical first) then by path count
+        return bottlenecks.sort((a, b) => {
+            const riskOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+            const riskDiff = riskOrder[a.riskLevel] - riskOrder[b.riskLevel];
+            if (riskDiff !== 0)
+                return riskDiff;
+            return b.pathCount - a.pathCount;
+        });
+    }
+    /**
+     * Calculate risk level for a bottleneck node
+     */
+    calculateRiskLevel(node, pathCount, flowWeight) {
+        const coverageWeight = (100 - node.coverage) / 100;
+        const pathWeight = Math.min(pathCount / 5, 1);
+        const complexityWeight = node.complexity ? Math.min(node.complexity / 20, 1) : 0.5;
+        const riskScore = (coverageWeight * 0.4) + (pathWeight * 0.35) + (complexityWeight * 0.25);
+        if (riskScore >= 0.75)
+            return 'critical';
+        if (riskScore >= 0.5)
+            return 'high';
+        if (riskScore >= 0.25)
+            return 'medium';
+        return 'low';
+    }
+    /**
+     * Prioritize coverage gaps based on critical path analysis
+     */
+    prioritizeCoverageGaps(input, criticalPaths, bottlenecks) {
+        const gaps = [];
+        const bottleneckSet = new Set(bottlenecks.map(b => b.nodeId));
+        // Create node-to-paths mapping
+        const nodeToPathsMap = new Map();
+        for (const path of criticalPaths) {
+            for (const nodeId of path.nodes) {
+                const paths = nodeToPathsMap.get(nodeId) || [];
+                paths.push(path.id);
+                nodeToPathsMap.set(nodeId, paths);
+            }
+        }
+        // Find all nodes below coverage threshold
+        for (const node of input.nodes) {
+            if (node.coverage >= this.config.coverageGapThreshold) {
+                continue;
+            }
+            const criticalPathIds = nodeToPathsMap.get(node.id) || [];
+            const isBottleneck = bottleneckSet.has(node.id);
+            // Calculate criticality score
+            const pathCriticality = criticalPathIds.length > 0
+                ? criticalPaths
+                    .filter(p => criticalPathIds.includes(p.id))
+                    .reduce((sum, p) => sum + p.criticality, 0) / criticalPathIds.length
+                : 0;
+            const criticality = isBottleneck ? Math.min(1, pathCriticality + 0.3) : pathCriticality;
+            // Calculate impact score
+            const coverageGap = this.config.coverageGapThreshold - node.coverage;
+            const impactScore = (coverageGap / 100) * (1 + criticality) * (node.lines / 100);
+            // Generate test suggestions
+            const testSuggestions = this.generateTestSuggestions(node, criticalPathIds.length);
+            // Estimate effort
+            const estimatedEffort = this.estimateEffort(node, coverageGap);
+            gaps.push({
+                nodeId: node.id,
+                label: node.label,
+                currentCoverage: node.coverage,
+                priority: 0, // Will be set after sorting
+                criticality,
+                impactScore,
+                criticalPaths: criticalPathIds,
+                testSuggestions,
+                estimatedEffort,
+            });
+        }
+        // Sort by criticality (descending), then by impact score (descending)
+        gaps.sort((a, b) => {
+            const critDiff = b.criticality - a.criticality;
+            if (Math.abs(critDiff) > 0.1)
+                return critDiff;
+            return b.impactScore - a.impactScore;
+        });
+        // Assign priority ranks
+        gaps.forEach((gap, index) => {
+            gap.priority = index + 1;
+        });
+        return gaps;
+    }
+    /**
+     * Generate test suggestions for a coverage gap
+     */
+    generateTestSuggestions(node, criticalPathCount) {
+        const suggestions = [];
+        if (node.type === 'function' || node.type === 'method') {
+            suggestions.push(`Add unit tests for ${node.label}`);
+            if (node.complexity && node.complexity > 10) {
+                suggestions.push(`Test edge cases for complex logic (complexity: ${node.complexity})`);
+            }
+        }
+        if (node.type === 'class') {
+            suggestions.push(`Add integration tests for ${node.label}`);
+            suggestions.push(`Test class instantiation and public methods`);
+        }
+        if (node.isEntryPoint) {
+            suggestions.push(`Add API/endpoint tests for ${node.label}`);
+        }
+        if (criticalPathCount > 0) {
+            suggestions.push(`Priority: On ${criticalPathCount} critical path(s) - test thoroughly`);
+        }
+        if (node.coverage < 20) {
+            suggestions.push(`Low coverage (${node.coverage}%) - start with basic happy path tests`);
+        }
+        return suggestions;
+    }
+    /**
+     * Estimate effort to achieve coverage
+     */
+    estimateEffort(node, coverageGap) {
+        const complexity = node.complexity || 5;
+        const lines = node.lines;
+        // Factor in complexity, lines, and coverage gap
+        const effortScore = (complexity / 10) * (lines / 200) * (coverageGap / 50);
+        if (effortScore < 0.5)
+            return 'low';
+        if (effortScore < 1.5)
+            return 'medium';
+        return 'high';
+    }
+    /**
+     * Calculate overall graph metrics
+     */
+    calculateMetrics(input, minCutResults, criticalPaths) {
+        const totalCoverage = input.nodes.reduce((sum, n) => sum + n.coverage, 0);
+        const averageCoverage = input.nodes.length > 0 ? totalCoverage / input.nodes.length : 0;
+        // Calculate connectivity score based on edge density
+        const maxPossibleEdges = (input.nodes.length * (input.nodes.length - 1)) / 2;
+        const connectivityScore = maxPossibleEdges > 0
+            ? Math.min(1, input.edges.length / maxPossibleEdges * 2) // *2 because sparse graphs are typical
+            : 0;
+        const minCutValue = minCutResults.length > 0 ? minCutResults[0].cutValue : 0;
+        return {
+            totalNodes: input.nodes.length,
+            totalEdges: input.edges.length,
+            criticalPathCount: criticalPaths.length,
+            averageCoverage,
+            connectivityScore,
+            minCutValue,
+        };
+    }
+}
+exports.CriticalPathDetector = CriticalPathDetector;
+//# sourceMappingURL=CriticalPathDetector.js.map