@getmikk/core 1.2.0 → 1.3.1

package/src/graph/graph-builder.ts

@@ -1,211 +1,211 @@
-import * as path from 'node:path'
-import type { DependencyGraph, GraphNode, GraphEdge } from './types.js'
-import type { ParsedFile, ParsedFunction, ParsedClass } from '../parser/types.js'
-
-/**
- * GraphBuilder — takes parsed files and builds the dependency graph.
- * Two-pass approach: first add all nodes, then add all edges.
- */
-export class GraphBuilder {
-    /** Main entry point — takes all parsed files and returns the complete graph */
-    build(files: ParsedFile[]): DependencyGraph {
-        const graph: DependencyGraph = {
-            nodes: new Map(),
-            edges: [],
-            outEdges: new Map(),
-            inEdges: new Map(),
-        }
-
-        // First pass: add all nodes
-        for (const file of files) {
-            this.addFileNode(graph, file)
-            for (const fn of file.functions) {
-                this.addFunctionNode(graph, fn)
-            }
-            for (const cls of file.classes || []) {
-                this.addClassNode(graph, cls, file.path)
-            }
-            for (const gen of file.generics || []) {
-                this.addGenericNode(graph, gen)
-            }
-        }
-
-        // Second pass: add all edges
-        for (const file of files) {
-            this.addImportEdges(graph, file)
-            this.addCallEdges(graph, file)
-            this.addContainmentEdges(graph, file)
-        }
-
-        // Third pass: build adjacency maps for fast lookup
-        this.buildAdjacencyMaps(graph)
-
-        return graph
-    }
-
-    private addFileNode(graph: DependencyGraph, file: ParsedFile): void {
-        graph.nodes.set(file.path, {
-            id: file.path,
-            type: 'file',
-            label: path.basename(file.path),
-            file: file.path,
-            metadata: { hash: file.hash },
-        })
-    }
-
-    private addFunctionNode(graph: DependencyGraph, fn: ParsedFunction): void {
-        graph.nodes.set(fn.id, {
-            id: fn.id,
-            type: 'function',
-            label: fn.name,
-            file: fn.file,
-            metadata: {
-                startLine: fn.startLine,
-                endLine: fn.endLine,
-                isExported: fn.isExported,
-                isAsync: fn.isAsync,
-                hash: fn.hash,
-                purpose: fn.purpose,
-                edgeCasesHandled: fn.edgeCasesHandled,
-                errorHandling: fn.errorHandling,
-                detailedLines: fn.detailedLines,
-            },
-        })
-    }
-
-    private addClassNode(graph: DependencyGraph, cls: ParsedClass, filePath: string): void {
-        // Add a node for the class itself
-        graph.nodes.set(cls.id, {
-            id: cls.id,
-            type: 'class',
-            label: cls.name,
-            file: filePath,
-            metadata: {
-                startLine: cls.startLine,
-                endLine: cls.endLine,
-                isExported: cls.isExported,
-                purpose: cls.purpose,
-                edgeCasesHandled: cls.edgeCasesHandled,
-                errorHandling: cls.errorHandling,
-            },
-        })
-        // Add nodes for each method
-        for (const method of cls.methods) {
-            this.addFunctionNode(graph, method)
-        }
-    }
-
-    private addGenericNode(graph: DependencyGraph, gen: any): void {
-        graph.nodes.set(gen.id, {
-            id: gen.id,
-            type: 'generic',
-            label: gen.name,
-            file: gen.file,
-            metadata: {
-                startLine: gen.startLine,
-                endLine: gen.endLine,
-                isExported: gen.isExported,
-                purpose: gen.purpose,
-                hash: gen.type, // reusing hash or just storing the type string
-            },
-        })
-    }
-
-    /** Creates edges for import statements: fileA imports fileB → edge(A, B, 'imports') */
-    private addImportEdges(graph: DependencyGraph, file: ParsedFile): void {
-        for (const imp of file.imports) {
-            if (imp.resolvedPath && graph.nodes.has(imp.resolvedPath)) {
-                graph.edges.push({
-                    source: file.path,
-                    target: imp.resolvedPath,
-                    type: 'imports',
-                })
-            }
-        }
-    }
-
-    /** Creates edges for function calls: fnA calls fnB → edge(A, B, 'calls') */
-    private addCallEdges(graph: DependencyGraph, file: ParsedFile): void {
-        // Build a map of import names to function IDs for resolving calls
-        const importedNames = new Map<string, string>()
-        for (const imp of file.imports) {
-            if (imp.resolvedPath) {
-                for (const name of imp.names) {
-                    importedNames.set(name, `fn:${imp.resolvedPath}:${name}`)
-                }
-            }
-        }
-
-        const allFunctions = [...file.functions, ...file.classes.flatMap(c => c.methods)]
-
-        for (const fn of allFunctions) {
-            for (const call of fn.calls) {
-                // Try to resolve: first check imported names, then local functions
-                const simpleName = call.includes('.') ? call.split('.').pop()! : call
-
-                // Check if it's an imported function
-                const importedId = importedNames.get(simpleName) || importedNames.get(call)
-                if (importedId && graph.nodes.has(importedId)) {
-                    graph.edges.push({
-                        source: fn.id,
-                        target: importedId,
-                        type: 'calls',
-                    })
-                    continue
-                }
-
-                // Check if it's a local function in the same file
-                const localId = `fn:${file.path}:${simpleName}`
-                if (graph.nodes.has(localId) && localId !== fn.id) {
-                    graph.edges.push({
-                        source: fn.id,
-                        target: localId,
-                        type: 'calls',
-                    })
-                }
-            }
-        }
-    }
-
-    /** Creates containment edges: file contains function → edge(file, fn, 'contains') */
-    private addContainmentEdges(graph: DependencyGraph, file: ParsedFile): void {
-        for (const fn of file.functions) {
-            graph.edges.push({
-                source: file.path,
-                target: fn.id,
-                type: 'contains',
-            })
-        }
-        for (const cls of file.classes) {
-            graph.edges.push({
-                source: file.path,
-                target: cls.id,
-                type: 'contains',
-            })
-            for (const method of cls.methods) {
-                graph.edges.push({
-                    source: cls.id,
-                    target: method.id,
-                    type: 'contains',
-                })
-            }
-        }
-    }
-
-    /** Build adjacency maps from edge list for O(1) lookups */
-    private buildAdjacencyMaps(graph: DependencyGraph): void {
-        for (const edge of graph.edges) {
-            // outEdges
-            if (!graph.outEdges.has(edge.source)) {
-                graph.outEdges.set(edge.source, [])
-            }
-            graph.outEdges.get(edge.source)!.push(edge)
-
-            // inEdges
-            if (!graph.inEdges.has(edge.target)) {
-                graph.inEdges.set(edge.target, [])
-            }
-            graph.inEdges.get(edge.target)!.push(edge)
-        }
-    }
-}
+import * as path from 'node:path'
+import type { DependencyGraph, GraphNode, GraphEdge } from './types.js'
+import type { ParsedFile, ParsedFunction, ParsedClass } from '../parser/types.js'
+
+/**
+ * GraphBuilder — takes parsed files and builds the dependency graph.
+ * Two-pass approach: first add all nodes, then add all edges.
+ */
+export class GraphBuilder {
+    /** Main entry point — takes all parsed files and returns the complete graph */
+    build(files: ParsedFile[]): DependencyGraph {
+        const graph: DependencyGraph = {
+            nodes: new Map(),
+            edges: [],
+            outEdges: new Map(),
+            inEdges: new Map(),
+        }
+
+        // First pass: add all nodes
+        for (const file of files) {
+            this.addFileNode(graph, file)
+            for (const fn of file.functions) {
+                this.addFunctionNode(graph, fn)
+            }
+            for (const cls of file.classes || []) {
+                this.addClassNode(graph, cls, file.path)
+            }
+            for (const gen of file.generics || []) {
+                this.addGenericNode(graph, gen)
+            }
+        }
+
+        // Second pass: add all edges
+        for (const file of files) {
+            this.addImportEdges(graph, file)
+            this.addCallEdges(graph, file)
+            this.addContainmentEdges(graph, file)
+        }
+
+        // Third pass: build adjacency maps for fast lookup
+        this.buildAdjacencyMaps(graph)
+
+        return graph
+    }
+
+    private addFileNode(graph: DependencyGraph, file: ParsedFile): void {
+        graph.nodes.set(file.path, {
+            id: file.path,
+            type: 'file',
+            label: path.basename(file.path),
+            file: file.path,
+            metadata: { hash: file.hash },
+        })
+    }
+
+    private addFunctionNode(graph: DependencyGraph, fn: ParsedFunction): void {
+        graph.nodes.set(fn.id, {
+            id: fn.id,
+            type: 'function',
+            label: fn.name,
+            file: fn.file,
+            metadata: {
+                startLine: fn.startLine,
+                endLine: fn.endLine,
+                isExported: fn.isExported,
+                isAsync: fn.isAsync,
+                hash: fn.hash,
+                purpose: fn.purpose,
+                edgeCasesHandled: fn.edgeCasesHandled,
+                errorHandling: fn.errorHandling,
+                detailedLines: fn.detailedLines,
+            },
+        })
+    }
+
+    private addClassNode(graph: DependencyGraph, cls: ParsedClass, filePath: string): void {
+        // Add a node for the class itself
+        graph.nodes.set(cls.id, {
+            id: cls.id,
+            type: 'class',
+            label: cls.name,
+            file: filePath,
+            metadata: {
+                startLine: cls.startLine,
+                endLine: cls.endLine,
+                isExported: cls.isExported,
+                purpose: cls.purpose,
+                edgeCasesHandled: cls.edgeCasesHandled,
+                errorHandling: cls.errorHandling,
+            },
+        })
+        // Add nodes for each method
+        for (const method of cls.methods) {
+            this.addFunctionNode(graph, method)
+        }
+    }
+
+    private addGenericNode(graph: DependencyGraph, gen: any): void {
+        graph.nodes.set(gen.id, {
+            id: gen.id,
+            type: 'generic',
+            label: gen.name,
+            file: gen.file,
+            metadata: {
+                startLine: gen.startLine,
+                endLine: gen.endLine,
+                isExported: gen.isExported,
+                purpose: gen.purpose,
+                hash: gen.type, // reusing hash or just storing the type string
+            },
+        })
+    }
+
+    /** Creates edges for import statements: fileA imports fileB → edge(A, B, 'imports') */
+    private addImportEdges(graph: DependencyGraph, file: ParsedFile): void {
+        for (const imp of file.imports) {
+            if (imp.resolvedPath && graph.nodes.has(imp.resolvedPath)) {
+                graph.edges.push({
+                    source: file.path,
+                    target: imp.resolvedPath,
+                    type: 'imports',
+                })
+            }
+        }
+    }
+
+    /** Creates edges for function calls: fnA calls fnB → edge(A, B, 'calls') */
+    private addCallEdges(graph: DependencyGraph, file: ParsedFile): void {
+        // Build a map of import names to function IDs for resolving calls
+        const importedNames = new Map<string, string>()
+        for (const imp of file.imports) {
+            if (imp.resolvedPath) {
+                for (const name of imp.names) {
+                    importedNames.set(name, `fn:${imp.resolvedPath}:${name}`)
+                }
+            }
+        }
+
+        const allFunctions = [...file.functions, ...file.classes.flatMap(c => c.methods)]
+
+        for (const fn of allFunctions) {
+            for (const call of fn.calls) {
+                // Try to resolve: first check imported names, then local functions
+                const simpleName = call.includes('.') ? call.split('.').pop()! : call
+
+                // Check if it's an imported function
+                const importedId = importedNames.get(simpleName) || importedNames.get(call)
+                if (importedId && graph.nodes.has(importedId)) {
+                    graph.edges.push({
+                        source: fn.id,
+                        target: importedId,
+                        type: 'calls',
+                    })
+                    continue
+                }
+
+                // Check if it's a local function in the same file
+                const localId = `fn:${file.path}:${simpleName}`
+                if (graph.nodes.has(localId) && localId !== fn.id) {
+                    graph.edges.push({
+                        source: fn.id,
+                        target: localId,
+                        type: 'calls',
+                    })
+                }
+            }
+        }
+    }
+
+    /** Creates containment edges: file contains function → edge(file, fn, 'contains') */
+    private addContainmentEdges(graph: DependencyGraph, file: ParsedFile): void {
+        for (const fn of file.functions) {
+            graph.edges.push({
+                source: file.path,
+                target: fn.id,
+                type: 'contains',
+            })
+        }
+        for (const cls of file.classes) {
+            graph.edges.push({
+                source: file.path,
+                target: cls.id,
+                type: 'contains',
+            })
+            for (const method of cls.methods) {
+                graph.edges.push({
+                    source: cls.id,
+                    target: method.id,
+                    type: 'contains',
+                })
+            }
+        }
+    }
+
+    /** Build adjacency maps from edge list for O(1) lookups */
+    private buildAdjacencyMaps(graph: DependencyGraph): void {
+        for (const edge of graph.edges) {
+            // outEdges
+            if (!graph.outEdges.has(edge.source)) {
+                graph.outEdges.set(edge.source, [])
+            }
+            graph.outEdges.get(edge.source)!.push(edge)
+
+            // inEdges
+            if (!graph.inEdges.has(edge.target)) {
+                graph.inEdges.set(edge.target, [])
+            }
+            graph.inEdges.get(edge.target)!.push(edge)
+        }
+    }
+}

package/src/graph/impact-analyzer.ts

@@ -1,55 +1,55 @@
-import type { DependencyGraph, ImpactResult } 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?"
- */
-export class ImpactAnalyzer {
-    constructor(private graph: DependencyGraph) { }
-
-    /** Given a list of changed node IDs, find everything impacted */
-    analyze(changedNodeIds: string[]): ImpactResult {
-        const visited = new Set<string>()
-        const queue: { id: string; depth: number }[] = changedNodeIds.map(id => ({ id, depth: 0 }))
-        let maxDepth = 0
-
-        while (queue.length > 0) {
-            const { id: current, depth } = queue.shift()!
-            if (visited.has(current)) continue
-            visited.add(current)
-            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') {
-                    queue.push({ id: edge.source, depth: depth + 1 })
-                }
-            }
-        }
-
-        const impacted = [...visited].filter(id => !changedNodeIds.includes(id))
-
-        return {
-            changed: changedNodeIds,
-            impacted,
-            depth: maxDepth,
-            confidence: this.computeConfidence(impacted.length, maxDepth),
-        }
-    }
-
-    /**
-     * How confident are we in this impact analysis?
-     * High = few nodes affected, shallow depth
-     * Low = many nodes affected, deep chains
-     */
-    private computeConfidence(
-        impactedCount: number,
-        depth: number
-    ): 'high' | 'medium' | 'low' {
-        if (impactedCount < 5 && depth < 3) return 'high'
-        if (impactedCount < 20 && depth < 6) return 'medium'
-        return 'low'
-    }
-}
+import type { DependencyGraph, ImpactResult } 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?"
+ */
+export class ImpactAnalyzer {
+    constructor(private graph: DependencyGraph) { }
+
+    /** Given a list of changed node IDs, find everything impacted */
+    analyze(changedNodeIds: string[]): ImpactResult {
+        const visited = new Set<string>()
+        const queue: { id: string; depth: number }[] = changedNodeIds.map(id => ({ id, depth: 0 }))
+        let maxDepth = 0
+
+        while (queue.length > 0) {
+            const { id: current, depth } = queue.shift()!
+            if (visited.has(current)) continue
+            visited.add(current)
+            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') {
+                    queue.push({ id: edge.source, depth: depth + 1 })
+                }
+            }
+        }
+
+        const impacted = [...visited].filter(id => !changedNodeIds.includes(id))
+
+        return {
+            changed: changedNodeIds,
+            impacted,
+            depth: maxDepth,
+            confidence: this.computeConfidence(impacted.length, maxDepth),
+        }
+    }
+
+    /**
+     * How confident are we in this impact analysis?
+     * High = few nodes affected, shallow depth
+     * Low = many nodes affected, deep chains
+     */
+    private computeConfidence(
+        impactedCount: number,
+        depth: number
+    ): 'high' | 'medium' | 'low' {
+        if (impactedCount < 5 && depth < 3) return 'high'
+        if (impactedCount < 20 && depth < 6) return 'medium'
+        return 'low'
+    }
+}

package/src/graph/index.ts

@@ -1,4 +1,4 @@
-export type { DependencyGraph, GraphNode, GraphEdge, ImpactResult, NodeType, EdgeType, ModuleCluster } from './types.js'
-export { GraphBuilder } from './graph-builder.js'
-export { ImpactAnalyzer } from './impact-analyzer.js'
-export { ClusterDetector } from './cluster-detector.js'
+export type { DependencyGraph, GraphNode, GraphEdge, ImpactResult, NodeType, EdgeType, ModuleCluster } from './types.js'
+export { GraphBuilder } from './graph-builder.js'
+export { ImpactAnalyzer } from './impact-analyzer.js'
+export { ClusterDetector } from './cluster-detector.js'

package/src/graph/types.ts

@@ -1,59 +1,59 @@
-/**
- * Graph types — nodes, edges, and the dependency graph itself.
- */
-
-export type NodeType = 'function' | 'file' | 'module' | 'class' | 'generic'
-export type EdgeType = 'calls' | 'imports' | 'exports' | 'contains'
-
-/** A single node in the dependency graph */
-export interface GraphNode {
-    id: string              // "fn:src/auth/verify.ts:verifyToken"
-    type: NodeType
-    label: string           // "verifyToken"
-    file: string            // "src/auth/verify.ts"
-    moduleId?: string       // "auth" — which declared module this belongs to
-    metadata: {
-        startLine?: number
-        endLine?: number
-        isExported?: boolean
-        isAsync?: boolean
-        hash?: string
-        purpose?: string
-        edgeCasesHandled?: string[]
-        errorHandling?: { line: number; type: 'try-catch' | 'throw'; detail: string }[]
-        detailedLines?: { startLine: number; endLine: number; blockType: string }[]
-    }
-}
-
-/** A single edge in the dependency graph */
-export interface GraphEdge {
-    source: string          // "fn:src/auth/verify.ts:verifyToken"
-    target: string          // "fn:src/utils/jwt.ts:jwtDecode"
-    type: EdgeType
-    weight?: number         // How often this call happens (for coupling metrics)
-}
-
-/** The full dependency graph */
-export interface DependencyGraph {
-    nodes: Map<string, GraphNode>
-    edges: GraphEdge[]
-    outEdges: Map<string, GraphEdge[]>   // node → [edges going out]
-    inEdges: Map<string, GraphEdge[]>    // node → [edges coming in]
-}
-
-/** 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'
-}
-
-/** A cluster of files that naturally belong together */
-export interface ModuleCluster {
-    id: string
-    files: string[]
-    confidence: number      // 0.0 to 1.0
-    suggestedName: string   // inferred from folder names
-    functions: string[]     // function IDs in this cluster
-}
+/**
+ * Graph types — nodes, edges, and the dependency graph itself.
+ */
+
+export type NodeType = 'function' | 'file' | 'module' | 'class' | 'generic'
+export type EdgeType = 'calls' | 'imports' | 'exports' | 'contains'
+
+/** A single node in the dependency graph */
+export interface GraphNode {
+    id: string              // "fn:src/auth/verify.ts:verifyToken"
+    type: NodeType
+    label: string           // "verifyToken"
+    file: string            // "src/auth/verify.ts"
+    moduleId?: string       // "auth" — which declared module this belongs to
+    metadata: {
+        startLine?: number
+        endLine?: number
+        isExported?: boolean
+        isAsync?: boolean
+        hash?: string
+        purpose?: string
+        edgeCasesHandled?: string[]
+        errorHandling?: { line: number; type: 'try-catch' | 'throw'; detail: string }[]
+        detailedLines?: { startLine: number; endLine: number; blockType: string }[]
+    }
+}
+
+/** A single edge in the dependency graph */
+export interface GraphEdge {
+    source: string          // "fn:src/auth/verify.ts:verifyToken"
+    target: string          // "fn:src/utils/jwt.ts:jwtDecode"
+    type: EdgeType
+    weight?: number         // How often this call happens (for coupling metrics)
+}
+
+/** The full dependency graph */
+export interface DependencyGraph {
+    nodes: Map<string, GraphNode>
+    edges: GraphEdge[]
+    outEdges: Map<string, GraphEdge[]>   // node → [edges going out]
+    inEdges: Map<string, GraphEdge[]>    // node → [edges coming in]
+}
+
+/** 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'
+}
+
+/** A cluster of files that naturally belong together */
+export interface ModuleCluster {
+    id: string
+    files: string[]
+    confidence: number      // 0.0 to 1.0
+    suggestedName: string   // inferred from folder names
+    functions: string[]     // function IDs in this cluster
+}