@getmikk/core 1.8.3 → 1.9.0

package/src/graph/impact-analyzer.ts

@@ -1,144 +1,155 @@
-import type { DependencyGraph, GraphEdge, ImpactResult, ClassifiedImpact, RiskLevel } from './types.js'
+import type { DependencyGraph, ImpactResult, ClassifiedImpact } from './types.js'
+import { RiskEngine } from './risk-engine.js'
+import { ConfidenceEngine } from './confidence-engine.js'
 
 /**
- * ImpactAnalyzer — Given changed nodes, walks the graph backwards (BFS)
- * to find everything that depends on them.
- * Powers "what breaks if I change X?"
- *
- * Risk classification:
- *   CRITICAL = direct caller (depth 1) that crosses a module boundary
- *   HIGH     = direct caller (depth 1) within the same module
- *   MEDIUM   = depth 2
- *   LOW      = depth 3+
- *
- * Confidence is derived from the quality of resolved edges in the traversal
- * path, not from the size of the result set. A small impact set built from
- * low-confidence (unresolved/fuzzy) edges is still LOW confidence.
+ * Mikk 2.0: Impact Analyzer
+ * Given changed nodes, walks the graph backwards (reverse dependency)
+ * to find everything impacted, computing quantitative risk and confidence.
  */
 export class ImpactAnalyzer {
-    constructor(private graph: DependencyGraph) { }
+    private riskEngine: RiskEngine;
+    private confidenceEngine: ConfidenceEngine;
+
+    constructor(private graph: DependencyGraph) {
+        this.riskEngine = new RiskEngine(graph);
+        this.confidenceEngine = new ConfidenceEngine(graph);
+    }
 
     /** Given a list of changed node IDs, find everything impacted */
-    analyze(changedNodeIds: string[]): ImpactResult {
-        const visited = new Set<string>()
-        const depthMap = new Map<string, number>()
-        // Track the minimum confidence seen along the path to each node
-        const pathConfidence = new Map<string, number>()
-
-        const queue: { id: string; depth: number; confidence: number }[] =
-            changedNodeIds.map(id => ({ id, depth: 0, confidence: 1.0 }))
-        // Use an index pointer instead of queue.shift() to avoid O(n) cost per dequeue.
-        let queueHead = 0
-        let maxDepth = 0
-
-        const changedSet = new Set(changedNodeIds)
-
-        // Collect module IDs of the changed nodes — filter out undefined so that
-        // nodes without a moduleId don't accidentally match every other unmoduled node
-        // and cause everything to appear "same module".
-        const changedModules = new Set<string>()
-        for (const id of changedNodeIds) {
-            const node = this.graph.nodes.get(id)
-            if (node?.moduleId) changedModules.add(node.moduleId)
-        }
+    public analyze(changedNodeIds: string[]): ImpactResult {
+        // depth and shortest-path tracking per visited node
+        const visited = new Map<string, { depth: number, paths: string[][] }>();
+        // Use an index pointer instead of queue.shift() to avoid O(n) dequeue cost.
+        const queue: { id: string, depth: number, path: string[], pathSet: Set<string> }[] =
+            changedNodeIds.map(id => ({ id, depth: 0, path: [id], pathSet: new Set([id]) }));
+        let queueHead = 0;
+
+        let maxDepth = 0;
+        const entryPoints = new Set<string>();
+        const criticalModules = new Set<string>();
 
         while (queueHead < queue.length) {
-            const { id: current, depth, confidence: pathConf } = queue[queueHead++]
-            if (visited.has(current)) continue
-            visited.add(current)
-            depthMap.set(current, depth)
-            pathConfidence.set(current, pathConf)
-            maxDepth = Math.max(maxDepth, depth)
-
-            // Find everything that depends on current (incoming edges)
-            const dependents = this.graph.inEdges.get(current) || []
-            for (const edge of dependents) {
-                if (!visited.has(edge.source) && edge.type !== 'contains') {
-                    // Propagate the minimum confidence seen so far on this path.
-                    // A chain is only as trustworthy as its weakest link.
-                    const edgeConf = edge.confidence ?? 1.0
-                    const newPathConf = Math.min(pathConf, edgeConf)
-                    queue.push({ id: edge.source, depth: depth + 1, confidence: newPathConf })
+            const { id: current, depth, path, pathSet } = queue[queueHead++];
+
+            if (!visited.has(current)) {
+                visited.set(current, { depth, paths: [path] });
+            } else {
+                visited.get(current)!.paths.push(path);
+                if (depth < visited.get(current)!.depth) {
+                    visited.get(current)!.depth = depth;
                 }
             }
-        }
 
-        const impacted = [...visited].filter(id => !changedSet.has(id))
+            maxDepth = Math.max(maxDepth, depth);
+            const node = this.graph.nodes.get(current);
 
-        // Classify each impacted node by risk level
-        const classified: ImpactResult['classified'] = {
-            critical: [],
-            high: [],
-            medium: [],
-            low: [],
-        }
+            if (node?.metadata?.isExported) {
+                entryPoints.add(current);
+            }
 
-        for (const id of impacted) {
-            const node = this.graph.nodes.get(id)
-            if (!node) continue
+            const dependents = this.graph.inEdges.get(current) || [];
+            for (const edge of dependents) {
+                if (edge.type === 'contains') continue;
+                // Use pathSet (O(1) lookup) instead of path.includes() (O(depth))
+                if (!pathSet.has(edge.from)) {
+                    const newPathSet = new Set(pathSet);
+                    newPathSet.add(edge.from);
+                    queue.push({
+                        id: edge.from,
+                        depth: depth + 1,
+                        path: [...path, edge.from],
+                        pathSet: newPathSet,
+                    });
+                }
+            }
+        }
 
-            const depth = depthMap.get(id) ?? 999
-            // A node crosses a module boundary when its module differs from ALL changed modules.
-            // If the node has no moduleId, treat it as crossing a boundary (unknown module ≠ known).
-            const crossesBoundary = !node.moduleId || !changedModules.has(node.moduleId)
+        const impactedIds = Array.from(visited.keys()).filter(id => !changedNodeIds.includes(id));
+        
+        let totalRisk = 0;
+        let totalConfidence = 0;
+
+        const classified = {
+            critical: [] as ClassifiedImpact[],
+            high: [] as ClassifiedImpact[],
+            medium: [] as ClassifiedImpact[],
+            low: [] as ClassifiedImpact[]
+        };
+
+        for (const id of impactedIds) {
+            const context = visited.get(id)!;
+            const node = this.graph.nodes.get(id);
+            let risk = this.riskEngine.scoreNode(id);
+
+            // Path reversal for confidence calculation (since BFS walks backwards)
+            const reversedPaths = context.paths.map(p => [...p].reverse());
+            const confidence = this.confidenceEngine.calculateNodeAggregatedConfidence(reversedPaths);
+
+            // Mikk 2.0 Hybrid Risk: Boost if boundary crossed at depth 1
+            // Check if ANY changed node crosses module boundary (not just first one)
+            if (context.depth === 1 && node?.moduleId) {
+                const crossesBoundary = changedNodeIds.some(id => {
+                    const changedNode = this.graph.nodes.get(id);
+                    // Add proper null checks for module IDs
+                    if (!changedNode?.moduleId || !node.moduleId) {
+                        return false;
+                    }
+                    return changedNode.moduleId !== node.moduleId;
+                });
+                if (crossesBoundary) {
+                    risk = Math.max(risk, 80);
+                }
+            }
 
-            const risk: RiskLevel =
-                depth === 1 && crossesBoundary ? 'critical' :
-                depth === 1                    ? 'high'     :
-                depth === 2                    ? 'medium'   :
-                                                 'low'
+            totalRisk += risk;
+            totalConfidence += confidence;
 
-            const entry: ClassifiedImpact = {
+            const impactEntry: ClassifiedImpact = {
                 nodeId: id,
-                label: node.label,
-                file: node.file,
-                moduleId: node.moduleId,
-                risk,
-                depth,
+                label: node?.name || 'unknown',
+                file: node?.file || 'unknown',
+                risk: (risk >= 80 ? 'CRITICAL' : risk >= 60 ? 'HIGH' : risk >= 40 ? 'MEDIUM' : 'LOW'),
+                riskScore: risk,
+                depth: context.depth
+            };
+
+            if (risk >= 80) classified.critical.push(impactEntry);
+            else if (risk >= 60) classified.high.push(impactEntry);
+            else if (risk >= 40) classified.medium.push(impactEntry);
+            else classified.low.push(impactEntry);
+
+            if (risk > 70 && node?.moduleId) {
+                criticalModules.add(node.moduleId);
             }
-
-            classified[risk].push(entry)
-        }
-
-        return {
-            changed: changedNodeIds,
-            impacted,
-            depth: maxDepth,
-            confidence: this.computeConfidence(impacted, pathConfidence),
-            classified,
         }
-    }
 
-    /**
-     * Derive confidence from the actual quality of edges traversed, not from
-     * result size. A small result built from fuzzy/unresolved edges is LOW
-     * confidence; a large result built from high-confidence AST edges is HIGH.
-     *
-     * Algorithm:
-     *   - Compute the average minimum-path-confidence across all impacted nodes.
-     *   - Penalise for deep chains (they amplify uncertainty).
-     *   - Map the combined score to HIGH / MEDIUM / LOW.
-     */
-    private computeConfidence(
-        impacted: string[],
-        pathConfidence: Map<string, number>,
-    ): 'high' | 'medium' | 'low' {
-        if (impacted.length === 0) return 'high'
-
-        // Average path confidence across all impacted nodes
-        let total = 0
-        for (const id of impacted) {
-            total += pathConfidence.get(id) ?? 1.0
-        }
-        const avgConf = total / impacted.length
+        const avgConfidence = impactedIds.length > 0 
+            ? totalConfidence / impactedIds.length 
+            : 1.0;
 
-        // Penalise for large impact sets: confidence erodes with result size
-        const sizePenalty = impacted.length > 20 ? 0.15 : impacted.length > 10 ? 0.08 : 0
+        const riskScore = impactedIds.length > 0
+            ? Math.min(Math.max(totalRisk / impactedIds.length, 0), 100)
+            : 0;
 
-        const score = avgConf - sizePenalty
+        const allImpacted: ClassifiedImpact[] = [
+            ...classified.critical,
+            ...classified.high,
+            ...classified.medium,
+            ...classified.low
+        ];
 
-        if (score >= 0.75) return 'high'
-        if (score >= 0.50) return 'medium'
-        return 'low'
+        return {
+            changed: changedNodeIds,
+            impacted: impactedIds,
+            allImpacted,
+            depth: maxDepth,
+            entryPoints: Array.from(entryPoints),
+            criticalModules: Array.from(criticalModules),
+            paths: Array.from(visited.values()).flatMap(v => v.paths),
+            confidence: Number(avgConfidence.toFixed(3)),
+            riskScore: Math.round(riskScore),
+            classified
+        };
     }
 }

package/src/graph/index.ts

@@ -4,4 +4,8 @@ export { ImpactAnalyzer } from './impact-analyzer.js'
 export { ClusterDetector } from './cluster-detector.js'
 export { DeadCodeDetector } from './dead-code-detector.js'
 export type { DeadCodeResult, DeadCodeEntry } from './dead-code-detector.js'
+export { RiskEngine } from './risk-engine.js'
+export type { RiskContext, RiskModifiers } from './risk-engine.js'
+export { ConfidenceEngine } from './confidence-engine.js'
+export { QueryEngine } from './query-engine.js'
 

package/src/graph/memory-manager.ts

@@ -0,0 +1,345 @@
+/**
+ * Memory Manager for Large Graph Operations
+ * 
+ * Provides memory monitoring, cleanup, and optimization for graph operations
+ * that can consume significant amounts of memory in large codebases.
+ */
+
+// Memory thresholds in bytes
+const MEMORY_THRESHOLDS = {
+    WARNING: 100 * 1024 * 1024,    // 100MB
+    CRITICAL: 200 * 1024 * 1024,   // 200MB
+    EMERGENCY: 400 * 1024 * 1024,  // 400MB
+}
+
+// Default cleanup configuration
+const DEFAULT_CLEANUP_CONFIG = {
+    maxAge: 30 * 60 * 1000,        // 30 minutes
+    maxNodes: 10000,                // Maximum nodes to keep in memory
+    gcInterval: 60 * 1000,          // GC check interval (1 minute)
+}
+
+export interface MemoryStats {
+    heapUsed: number
+    heapTotal: number
+    external: number
+    rss: number
+    percentage: number
+    status: 'normal' | 'warning' | 'critical' | 'emergency'
+}
+
+export interface MemoryManagerConfig {
+    maxAge?: number
+    maxNodes?: number
+    gcInterval?: number
+    enableAutoGC?: boolean
+}
+
+/**
+ * Memory Manager for graph operations
+ */
+export class MemoryManager {
+    private config: Required<MemoryManagerConfig>
+    private lastGC = Date.now()
+    private nodeCache = new Map<string, { data: any; timestamp: number }>()
+    private gcTimer?: NodeJS.Timeout
+
+    constructor(config: MemoryManagerConfig = {}) {
+        this.config = {
+            maxAge: config.maxAge ?? DEFAULT_CLEANUP_CONFIG.maxAge,
+            maxNodes: config.maxNodes ?? DEFAULT_CLEANUP_CONFIG.maxNodes,
+            gcInterval: config.gcInterval ?? DEFAULT_CLEANUP_CONFIG.gcInterval,
+            enableAutoGC: config.enableAutoGC ?? true,
+        }
+
+        if (this.config.enableAutoGC) {
+            this.startAutoGC()
+        }
+    }
+
+    /**
+     * Get current memory statistics
+     */
+    getMemoryStats(): MemoryStats {
+        const usage = process.memoryUsage()
+        const percentage = (usage.heapUsed / usage.heapTotal) * 100
+
+        let status: MemoryStats['status'] = 'normal'
+        if (usage.heapUsed > MEMORY_THRESHOLDS.EMERGENCY) {
+            status = 'emergency'
+        } else if (usage.heapUsed > MEMORY_THRESHOLDS.CRITICAL) {
+            status = 'critical'
+        } else if (usage.heapUsed > MEMORY_THRESHOLDS.WARNING) {
+            status = 'warning'
+        }
+
+        return {
+            heapUsed: usage.heapUsed,
+            heapTotal: usage.heapTotal,
+            external: usage.external,
+            rss: usage.rss,
+            percentage,
+            status,
+        }
+    }
+
+    /**
+     * Check if memory usage is critical
+     */
+    isMemoryCritical(): boolean {
+        const stats = this.getMemoryStats()
+        return stats.status === 'critical' || stats.status === 'emergency'
+    }
+
+    /**
+     * Force garbage collection if available
+     */
+    forceGC(): void {
+        if (global.gc) {
+            global.gc()
+            this.lastGC = Date.now()
+        }
+    }
+
+    /**
+     * Cache a node with automatic cleanup
+     */
+    cacheNode(id: string, data: any): void {
+        // If we're at the node limit, remove oldest entries
+        if (this.nodeCache.size >= this.config.maxNodes) {
+            this.evictOldestNodes(Math.floor(this.config.maxNodes * 0.1)) // Remove 10%
+        }
+
+        this.nodeCache.set(id, {
+            data,
+            timestamp: Date.now(),
+        })
+    }
+
+    /**
+     * Get cached node data
+     */
+    getCachedNode(id: string): any | null {
+        const cached = this.nodeCache.get(id)
+        if (!cached) return null
+
+        // Check if expired
+        if (Date.now() - cached.timestamp > this.config.maxAge) {
+            this.nodeCache.delete(id)
+            return null
+        }
+
+        return cached.data
+    }
+
+    /**
+     * Clear node cache
+     */
+    clearCache(): void {
+        this.nodeCache.clear()
+    }
+
+    /**
+     * Perform comprehensive memory cleanup
+     */
+    cleanup(): void {
+        // Clear expired cache entries
+        const now = Date.now()
+        for (const [id, cached] of this.nodeCache.entries()) {
+            if (now - cached.timestamp > this.config.maxAge) {
+                this.nodeCache.delete(id)
+            }
+        }
+
+        // Force garbage collection
+        this.forceGC()
+    }
+
+    /**
+     * Evict oldest nodes from cache
+     */
+    private evictOldestNodes(count: number): void {
+        const entries = Array.from(this.nodeCache.entries())
+            .sort((a, b) => a[1].timestamp - b[1].timestamp)
+
+        for (let i = 0; i < Math.min(count, entries.length); i++) {
+            this.nodeCache.delete(entries[i][0])
+        }
+    }
+
+    /**
+     * Start automatic garbage collection
+     */
+    private startAutoGC(): void {
+        this.gcTimer = setInterval(() => {
+            const stats = this.getMemoryStats()
+            
+            // If memory usage is high, perform cleanup
+            if (stats.status !== 'normal') {
+                this.cleanup()
+            }
+
+            // Periodic cleanup regardless of memory pressure
+            if (Date.now() - this.lastGC > this.config.gcInterval) {
+                this.cleanup()
+            }
+        }, this.config.gcInterval)
+    }
+
+    /**
+     * Stop automatic garbage collection
+     */
+    stopAutoGC(): void {
+        if (this.gcTimer) {
+            clearInterval(this.gcTimer)
+            this.gcTimer = undefined
+        }
+    }
+
+    /**
+     * Dispose of memory manager
+     */
+    dispose(): void {
+        this.stopAutoGC()
+        this.clearCache()
+        this.forceGC()
+    }
+}
+
+/**
+ * Memory-aware graph builder wrapper
+ */
+export class MemoryAwareGraphBuilder {
+    private memoryManager: MemoryManager
+
+    constructor(config?: MemoryManagerConfig) {
+        this.memoryManager = new MemoryManager(config)
+    }
+
+    /**
+     * Build graph with memory monitoring
+     */
+    buildGraph(lock: any): any {
+        const stats = this.memoryManager.getMemoryStats()
+        
+        // Check memory before starting
+        if (this.memoryManager.isMemoryCritical()) {
+            console.warn('Memory usage is critical, performing cleanup before graph build')
+            this.memoryManager.cleanup()
+        }
+
+        try {
+            // Build graph implementation here
+            return this.buildGraphInternal(lock)
+        } finally {
+            // Cleanup after build
+            this.memoryManager.cleanup()
+        }
+    }
+
+    /**
+     * Internal graph building implementation
+     */
+    private buildGraphInternal(lock: any): any {
+        const nodes = new Map<string, any>()
+        const edges: any[] = []
+        const outEdges = new Map<string, any[]>()
+        const inEdges = new Map<string, any[]>()
+
+        // Process functions with memory monitoring
+        for (const [id, fn] of Object.entries(lock.functions || {})) {
+            // Check memory periodically
+            if (nodes.size % 1000 === 0) {
+                if (this.memoryManager.isMemoryCritical()) {
+                    console.warn('Memory pressure detected during graph build, forcing cleanup')
+                    this.memoryManager.cleanup()
+                }
+            }
+
+            const node = {
+                id,
+                name: (fn as any).name,
+                file: (fn as any).file,
+                type: 'function',
+                moduleId: (fn as any).moduleId,
+                metadata: {
+                    isExported: (fn as any).isExported,
+                    isAsync: (fn as any).isAsync,
+                },
+            }
+
+            nodes.set(id, node)
+            outEdges.set(id, [])
+            inEdges.set(id, [])
+        }
+
+        // Process edges
+        for (const [id, fn] of Object.entries(lock.functions || {})) {
+            const calls = (fn as any).calls || []
+            for (const targetId of calls) {
+                if (nodes.has(targetId)) {
+                    const edge = {
+                        from: id,
+                        to: targetId,
+                        type: 'calls',
+                    }
+                    edges.push(edge)
+                    outEdges.get(id)?.push(edge)
+                    inEdges.get(targetId)?.push(edge)
+                }
+            }
+        }
+
+        return {
+            nodes,
+            edges,
+            outEdges,
+            inEdges,
+        }
+    }
+
+    /**
+     * Get memory statistics
+     */
+    getMemoryStats(): MemoryStats {
+        return this.memoryManager.getMemoryStats()
+    }
+
+    /**
+     * Dispose of the graph builder
+     */
+    dispose(): void {
+        this.memoryManager.dispose()
+    }
+}
+
+/**
+ * Utility function to monitor memory usage during operations
+ */
+export function withMemoryMonitoring<T>(
+    operation: () => T,
+    memoryManager?: MemoryManager
+): T {
+    const manager = memoryManager || new MemoryManager({ enableAutoGC: false })
+    
+    const initialStats = manager.getMemoryStats()
+    console.log(`Memory before operation: ${(initialStats.heapUsed / 1024 / 1024).toFixed(1)}MB`)
+
+    try {
+        const result = operation()
+        
+        const finalStats = manager.getMemoryStats()
+        const delta = finalStats.heapUsed - initialStats.heapUsed
+        console.log(`Memory after operation: ${(finalStats.heapUsed / 1024 / 1024).toFixed(1)}MB (${delta >= 0 ? '+' : ''}${(delta / 1024 / 1024).toFixed(1)}MB)`)
+        
+        if (finalStats.status !== 'normal') {
+            console.warn(`Memory status: ${finalStats.status}`)
+        }
+
+        return result
+    } finally {
+        if (!memoryManager) {
+            manager.dispose()
+        }
+    }
+}