@getmikk/core 1.5.1 → 1.7.0

package/src/graph/impact-analyzer.ts

@@ -1,9 +1,15 @@
-import type { DependencyGraph, ImpactResult } from './types.js'
+import type { DependencyGraph, ImpactResult, ClassifiedImpact, RiskLevel } from './types.js'
 
 /**
  * ImpactAnalyzer — Given changed nodes, walks the graph backwards (BFS)
  * to find everything that depends on them.
  * Powers "what breaks if I change X?"
+ *
+ * Now includes 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+
  */
 export class ImpactAnalyzer {
     constructor(private graph: DependencyGraph) { }
@@ -11,13 +17,24 @@ export class ImpactAnalyzer {
     /** 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>()
         const queue: { id: string; depth: number }[] = changedNodeIds.map(id => ({ id, depth: 0 }))
         let maxDepth = 0
 
+        const changedSet = new Set(changedNodeIds)
+
+        // Collect module IDs of the changed nodes
+        const changedModules = new Set<string | undefined>()
+        for (const id of changedNodeIds) {
+            const node = this.graph.nodes.get(id)
+            if (node) changedModules.add(node.moduleId)
+        }
+
         while (queue.length > 0) {
             const { id: current, depth } = queue.shift()!
             if (visited.has(current)) continue
             visited.add(current)
+            depthMap.set(current, depth)
             maxDepth = Math.max(maxDepth, depth)
 
             // Find everything that depends on current (incoming edges)
@@ -29,13 +46,47 @@ export class ImpactAnalyzer {
             }
         }
 
-        const impacted = [...visited].filter(id => !changedNodeIds.includes(id))
+        const impacted = [...visited].filter(id => !changedSet.has(id))
+
+        // Classify each impacted node by risk level
+        const classified: ImpactResult['classified'] = {
+            critical: [],
+            high: [],
+            medium: [],
+            low: [],
+        }
+
+        for (const id of impacted) {
+            const node = this.graph.nodes.get(id)
+            if (!node) continue
+
+            const depth = depthMap.get(id) ?? 999
+            const crossesBoundary = !changedModules.has(node.moduleId)
+
+            const risk: RiskLevel =
+                depth === 1 && crossesBoundary ? 'critical' :
+                    depth === 1 ? 'high' :
+                        depth === 2 ? 'medium' :
+                            'low'
+
+            const entry: ClassifiedImpact = {
+                nodeId: id,
+                label: node.label,
+                file: node.file,
+                moduleId: node.moduleId,
+                risk,
+                depth,
+            }
+
+            classified[risk].push(entry)
+        }
 
         return {
             changed: changedNodeIds,
             impacted,
             depth: maxDepth,
             confidence: this.computeConfidence(impacted.length, maxDepth),
+            classified,
         }
     }
 

package/src/graph/index.ts

@@ -1,4 +1,7 @@
-export type { DependencyGraph, GraphNode, GraphEdge, ImpactResult, NodeType, EdgeType, ModuleCluster } from './types.js'
+export type { DependencyGraph, GraphNode, GraphEdge, ImpactResult, NodeType, EdgeType, ModuleCluster, RiskLevel, ClassifiedImpact } from './types.js'
 export { GraphBuilder } from './graph-builder.js'
 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'
+

package/src/graph/types.ts

@@ -33,6 +33,7 @@ export interface GraphEdge {
     target: string          // "fn:src/utils/jwt.ts:jwtDecode"
     type: EdgeType
     weight?: number         // How often this call happens (for coupling metrics)
+    confidence?: number     // 0.0–1.0: 1.0 = direct AST call, 0.8 = via interface, 0.5 = fuzzy/inferred
 }
 
 /** The full dependency graph */
@@ -43,12 +44,32 @@ export interface DependencyGraph {
     inEdges: Map<string, GraphEdge[]>    // node → [edges coming in]
 }
 
+/** Risk level for an impacted node */
+export type RiskLevel = 'critical' | 'high' | 'medium' | 'low'
+
+/** A single node in the classified impact result */
+export interface ClassifiedImpact {
+    nodeId: string
+    label: string
+    file: string
+    moduleId?: string
+    risk: RiskLevel
+    depth: number           // hops from change
+}
+
 /** Result of impact analysis */
 export interface ImpactResult {
     changed: string[]        // The directly changed nodes
     impacted: string[]       // Everything that depends on changed nodes
     depth: number            // How many hops from change to furthest impact
     confidence: 'high' | 'medium' | 'low'
+    /** Risk-classified breakdown of impacted nodes */
+    classified: {
+        critical: ClassifiedImpact[]
+        high: ClassifiedImpact[]
+        medium: ClassifiedImpact[]
+        low: ClassifiedImpact[]
+    }
 }
 
 /** A cluster of files that naturally belong together */

package/src/index.ts

@@ -10,4 +10,4 @@ export * from './utils/logger.js'
 export { discoverFiles, discoverContextFiles, readFileContent, writeFileContent, fileExists, setupMikkDirectory, readMikkIgnore, parseMikkIgnore, detectProjectLanguage, getDiscoveryPatterns, generateMikkIgnore } from './utils/fs.js'
 export type { ContextFile, ContextFileType, ProjectLanguage } from './utils/fs.js'
 export { minimatch } from './utils/minimatch.js'
-export { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from './utils/fuzzy-match.js'
+export { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from './utils/fuzzy-match.js'