@getmikk/core 1.2.0 → 1.3.0

package/tests/graph.test.ts

@@ -1,169 +1,169 @@
-import { describe, it, expect } from 'bun:test'
-import { GraphBuilder } from '../src/graph/graph-builder'
-import { ImpactAnalyzer } from '../src/graph/impact-analyzer'
-import { ClusterDetector } from '../src/graph/cluster-detector'
-import { mockParsedFile, mockFunction, mockImport, buildTestGraph } from './helpers'
-
-describe('GraphBuilder', () => {
-    const builder = new GraphBuilder()
-
-    it('creates nodes for files', () => {
-        const files = [mockParsedFile('src/auth.ts')]
-        const graph = builder.build(files)
-        expect(graph.nodes.has('src/auth.ts')).toBe(true)
-        expect(graph.nodes.get('src/auth.ts')!.type).toBe('file')
-    })
-
-    it('creates nodes for functions', () => {
-        const files = [
-            mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
-        ]
-        const graph = builder.build(files)
-        expect(graph.nodes.has('fn:src/auth.ts:verifyToken')).toBe(true)
-        expect(graph.nodes.get('fn:src/auth.ts:verifyToken')!.type).toBe('function')
-    })
-
-    it('creates edges for imports', () => {
-        const files = [
-            mockParsedFile(
-                'src/auth.ts',
-                [mockFunction('verifyToken', [], 'src/auth.ts')],
-                [mockImport('../utils/jwt', ['jwtDecode'], 'src/utils/jwt.ts')]
-            ),
-            mockParsedFile('src/utils/jwt.ts', [mockFunction('jwtDecode', [], 'src/utils/jwt.ts')]),
-        ]
-        const graph = builder.build(files)
-        const importEdges = graph.edges.filter(e => e.type === 'imports')
-        expect(importEdges.length).toBeGreaterThanOrEqual(1)
-        expect(importEdges[0].source).toBe('src/auth.ts')
-        expect(importEdges[0].target).toBe('src/utils/jwt.ts')
-    })
-
-    it('creates edges for function calls via imports', () => {
-        const files = [
-            mockParsedFile(
-                'src/auth.ts',
-                [mockFunction('verifyToken', ['jwtDecode'], 'src/auth.ts')],
-                [mockImport('../utils/jwt', ['jwtDecode'], 'src/utils/jwt.ts')]
-            ),
-            mockParsedFile('src/utils/jwt.ts', [mockFunction('jwtDecode', [], 'src/utils/jwt.ts')]),
-        ]
-        const graph = builder.build(files)
-        const callEdges = graph.edges.filter(e => e.type === 'calls')
-        expect(callEdges.length).toBeGreaterThanOrEqual(1)
-        expect(callEdges[0].source).toBe('fn:src/auth.ts:verifyToken')
-        expect(callEdges[0].target).toBe('fn:src/utils/jwt.ts:jwtDecode')
-    })
-
-    it('creates containment edges', () => {
-        const files = [
-            mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
-        ]
-        const graph = builder.build(files)
-        const containEdges = graph.edges.filter(e => e.type === 'contains')
-        expect(containEdges.length).toBeGreaterThanOrEqual(1)
-        expect(containEdges[0].source).toBe('src/auth.ts')
-        expect(containEdges[0].target).toBe('fn:src/auth.ts:verifyToken')
-    })
-
-    it('builds adjacency maps', () => {
-        const files = [
-            mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
-        ]
-        const graph = builder.build(files)
-        expect(graph.outEdges.has('src/auth.ts')).toBe(true)
-        expect(graph.inEdges.has('fn:src/auth.ts:verifyToken')).toBe(true)
-    })
-})
-
-describe('ImpactAnalyzer', () => {
-    it('finds direct dependents', () => {
-        const graph = buildTestGraph([
-            ['A', 'B'],
-            ['B', 'nothing'],
-        ])
-        const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/B.ts:B'])
-        expect(result.impacted).toContain('fn:src/A.ts:A')
-    })
-
-    it('finds transitive dependents', () => {
-        const graph = buildTestGraph([
-            ['A', 'B'],
-            ['B', 'C'],
-            ['C', 'nothing'],
-        ])
-        const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/C.ts:C'])
-        expect(result.impacted).toContain('fn:src/B.ts:B')
-        expect(result.impacted).toContain('fn:src/A.ts:A')
-    })
-
-    it('reports correct depth', () => {
-        const graph = buildTestGraph([
-            ['A', 'B'],
-            ['B', 'C'],
-            ['C', 'D'],
-            ['D', 'nothing'],
-        ])
-        const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/D.ts:D'])
-        expect(result.depth).toBeGreaterThanOrEqual(3)
-    })
-
-    it('assigns high confidence for small impacts', () => {
-        const graph = buildTestGraph([
-            ['A', 'B'],
-            ['B', 'nothing'],
-        ])
-        const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/B.ts:B'])
-        expect(result.confidence).toBe('high')
-    })
-
-    it('does not include changed nodes in impacted', () => {
-        const graph = buildTestGraph([
-            ['A', 'B'],
-            ['B', 'nothing'],
-        ])
-        const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/B.ts:B'])
-        expect(result.impacted).not.toContain('fn:src/B.ts:B')
-        expect(result.changed).toContain('fn:src/B.ts:B')
-    })
-})
-
-describe('ClusterDetector', () => {
-    it('groups files by directory', () => {
-        const files = [
-            mockParsedFile('src/auth/verify.ts',
-                [mockFunction('verifyToken', ['authMiddleware'], 'src/auth/verify.ts')],
-                [mockImport('./middleware', ['authMiddleware'], 'src/auth/middleware.ts')]
-            ),
-            mockParsedFile('src/auth/middleware.ts',
-                [mockFunction('authMiddleware', ['verifyToken'], 'src/auth/middleware.ts')],
-                [mockImport('./verify', ['verifyToken'], 'src/auth/verify.ts')]
-            ),
-            mockParsedFile('src/payments/charge.ts', [mockFunction('charge', [], 'src/payments/charge.ts')]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        // Use minClusterSize=1 so even single-file groups appear
-        const detector = new ClusterDetector(graph, 1)
-        const clusters = detector.detect()
-        expect(clusters.length).toBeGreaterThanOrEqual(2)
-        const authCluster = clusters.find(c => c.id === 'auth')
-        expect(authCluster).toBeDefined()
-        expect(authCluster!.files).toHaveLength(2)
-    })
-
-    it('computes confidence scores', () => {
-        const files = [
-            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        const detector = new ClusterDetector(graph, 1)
-        const score = detector.computeClusterConfidence(['src/auth/verify.ts'])
-        expect(score).toBeGreaterThanOrEqual(0)
-        expect(score).toBeLessThanOrEqual(1)
-    })
-})
+import { describe, it, expect } from 'bun:test'
+import { GraphBuilder } from '../src/graph/graph-builder'
+import { ImpactAnalyzer } from '../src/graph/impact-analyzer'
+import { ClusterDetector } from '../src/graph/cluster-detector'
+import { mockParsedFile, mockFunction, mockImport, buildTestGraph } from './helpers'
+
+describe('GraphBuilder', () => {
+    const builder = new GraphBuilder()
+
+    it('creates nodes for files', () => {
+        const files = [mockParsedFile('src/auth.ts')]
+        const graph = builder.build(files)
+        expect(graph.nodes.has('src/auth.ts')).toBe(true)
+        expect(graph.nodes.get('src/auth.ts')!.type).toBe('file')
+    })
+
+    it('creates nodes for functions', () => {
+        const files = [
+            mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
+        ]
+        const graph = builder.build(files)
+        expect(graph.nodes.has('fn:src/auth.ts:verifyToken')).toBe(true)
+        expect(graph.nodes.get('fn:src/auth.ts:verifyToken')!.type).toBe('function')
+    })
+
+    it('creates edges for imports', () => {
+        const files = [
+            mockParsedFile(
+                'src/auth.ts',
+                [mockFunction('verifyToken', [], 'src/auth.ts')],
+                [mockImport('../utils/jwt', ['jwtDecode'], 'src/utils/jwt.ts')]
+            ),
+            mockParsedFile('src/utils/jwt.ts', [mockFunction('jwtDecode', [], 'src/utils/jwt.ts')]),
+        ]
+        const graph = builder.build(files)
+        const importEdges = graph.edges.filter(e => e.type === 'imports')
+        expect(importEdges.length).toBeGreaterThanOrEqual(1)
+        expect(importEdges[0].source).toBe('src/auth.ts')
+        expect(importEdges[0].target).toBe('src/utils/jwt.ts')
+    })
+
+    it('creates edges for function calls via imports', () => {
+        const files = [
+            mockParsedFile(
+                'src/auth.ts',
+                [mockFunction('verifyToken', ['jwtDecode'], 'src/auth.ts')],
+                [mockImport('../utils/jwt', ['jwtDecode'], 'src/utils/jwt.ts')]
+            ),
+            mockParsedFile('src/utils/jwt.ts', [mockFunction('jwtDecode', [], 'src/utils/jwt.ts')]),
+        ]
+        const graph = builder.build(files)
+        const callEdges = graph.edges.filter(e => e.type === 'calls')
+        expect(callEdges.length).toBeGreaterThanOrEqual(1)
+        expect(callEdges[0].source).toBe('fn:src/auth.ts:verifyToken')
+        expect(callEdges[0].target).toBe('fn:src/utils/jwt.ts:jwtDecode')
+    })
+
+    it('creates containment edges', () => {
+        const files = [
+            mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
+        ]
+        const graph = builder.build(files)
+        const containEdges = graph.edges.filter(e => e.type === 'contains')
+        expect(containEdges.length).toBeGreaterThanOrEqual(1)
+        expect(containEdges[0].source).toBe('src/auth.ts')
+        expect(containEdges[0].target).toBe('fn:src/auth.ts:verifyToken')
+    })
+
+    it('builds adjacency maps', () => {
+        const files = [
+            mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
+        ]
+        const graph = builder.build(files)
+        expect(graph.outEdges.has('src/auth.ts')).toBe(true)
+        expect(graph.inEdges.has('fn:src/auth.ts:verifyToken')).toBe(true)
+    })
+})
+
+describe('ImpactAnalyzer', () => {
+    it('finds direct dependents', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'nothing'],
+        ])
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/B.ts:B'])
+        expect(result.impacted).toContain('fn:src/A.ts:A')
+    })
+
+    it('finds transitive dependents', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'C'],
+            ['C', 'nothing'],
+        ])
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/C.ts:C'])
+        expect(result.impacted).toContain('fn:src/B.ts:B')
+        expect(result.impacted).toContain('fn:src/A.ts:A')
+    })
+
+    it('reports correct depth', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'C'],
+            ['C', 'D'],
+            ['D', 'nothing'],
+        ])
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/D.ts:D'])
+        expect(result.depth).toBeGreaterThanOrEqual(3)
+    })
+
+    it('assigns high confidence for small impacts', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'nothing'],
+        ])
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/B.ts:B'])
+        expect(result.confidence).toBe('high')
+    })
+
+    it('does not include changed nodes in impacted', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'nothing'],
+        ])
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/B.ts:B'])
+        expect(result.impacted).not.toContain('fn:src/B.ts:B')
+        expect(result.changed).toContain('fn:src/B.ts:B')
+    })
+})
+
+describe('ClusterDetector', () => {
+    it('groups files by directory', () => {
+        const files = [
+            mockParsedFile('src/auth/verify.ts',
+                [mockFunction('verifyToken', ['authMiddleware'], 'src/auth/verify.ts')],
+                [mockImport('./middleware', ['authMiddleware'], 'src/auth/middleware.ts')]
+            ),
+            mockParsedFile('src/auth/middleware.ts',
+                [mockFunction('authMiddleware', ['verifyToken'], 'src/auth/middleware.ts')],
+                [mockImport('./verify', ['verifyToken'], 'src/auth/verify.ts')]
+            ),
+            mockParsedFile('src/payments/charge.ts', [mockFunction('charge', [], 'src/payments/charge.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        // Use minClusterSize=1 so even single-file groups appear
+        const detector = new ClusterDetector(graph, 1)
+        const clusters = detector.detect()
+        expect(clusters.length).toBeGreaterThanOrEqual(2)
+        const authCluster = clusters.find(c => c.id === 'auth')
+        expect(authCluster).toBeDefined()
+        expect(authCluster!.files).toHaveLength(2)
+    })
+
+    it('computes confidence scores', () => {
+        const files = [
+            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        const detector = new ClusterDetector(graph, 1)
+        const score = detector.computeClusterConfidence(['src/auth/verify.ts'])
+        expect(score).toBeGreaterThanOrEqual(0)
+        expect(score).toBeLessThanOrEqual(1)
+    })
+})

package/tests/hash.test.ts

@@ -1,49 +1,49 @@
-import { describe, it, expect } from 'bun:test'
-import { hashContent, hashFunctionBody } from '../src/hash/file-hasher'
-import { computeModuleHash, computeRootHash } from '../src/hash/tree-hasher'
-
-describe('hashContent', () => {
-    it('produces consistent hashes', () => {
-        expect(hashContent('hello')).toBe(hashContent('hello'))
-    })
-
-    it('produces different hashes for different content', () => {
-        expect(hashContent('hello')).not.toBe(hashContent('world'))
-    })
-
-    it('returns 64 character hex string (SHA-256)', () => {
-        const hash = hashContent('test')
-        expect(hash.length).toBe(64)
-        expect(hash).toMatch(/^[a-f0-9]{64}$/)
-    })
-})
-
-describe('hashFunctionBody', () => {
-    it('hashes specific line range', () => {
-        const content = 'line1\nline2\nline3\nline4\nline5'
-        const hash = hashFunctionBody(content, 2, 4)
-        expect(hash).toBe(hashContent('line2\nline3\nline4'))
-    })
-})
-
-describe('computeModuleHash', () => {
-    it('produces consistent hash regardless of input order', () => {
-        const hash1 = computeModuleHash(['abc', 'def', 'ghi'])
-        const hash2 = computeModuleHash(['ghi', 'abc', 'def'])
-        expect(hash1).toBe(hash2)
-    })
-
-    it('changes when any file hash changes', () => {
-        const hash1 = computeModuleHash(['abc', 'def'])
-        const hash2 = computeModuleHash(['abc', 'xyz'])
-        expect(hash1).not.toBe(hash2)
-    })
-})
-
-describe('computeRootHash', () => {
-    it('produces consistent hash', () => {
-        const hash1 = computeRootHash({ auth: 'abc', payments: 'def' })
-        const hash2 = computeRootHash({ payments: 'def', auth: 'abc' })
-        expect(hash1).toBe(hash2)
-    })
-})
+import { describe, it, expect } from 'bun:test'
+import { hashContent, hashFunctionBody } from '../src/hash/file-hasher'
+import { computeModuleHash, computeRootHash } from '../src/hash/tree-hasher'
+
+describe('hashContent', () => {
+    it('produces consistent hashes', () => {
+        expect(hashContent('hello')).toBe(hashContent('hello'))
+    })
+
+    it('produces different hashes for different content', () => {
+        expect(hashContent('hello')).not.toBe(hashContent('world'))
+    })
+
+    it('returns 64 character hex string (SHA-256)', () => {
+        const hash = hashContent('test')
+        expect(hash.length).toBe(64)
+        expect(hash).toMatch(/^[a-f0-9]{64}$/)
+    })
+})
+
+describe('hashFunctionBody', () => {
+    it('hashes specific line range', () => {
+        const content = 'line1\nline2\nline3\nline4\nline5'
+        const hash = hashFunctionBody(content, 2, 4)
+        expect(hash).toBe(hashContent('line2\nline3\nline4'))
+    })
+})
+
+describe('computeModuleHash', () => {
+    it('produces consistent hash regardless of input order', () => {
+        const hash1 = computeModuleHash(['abc', 'def', 'ghi'])
+        const hash2 = computeModuleHash(['ghi', 'abc', 'def'])
+        expect(hash1).toBe(hash2)
+    })
+
+    it('changes when any file hash changes', () => {
+        const hash1 = computeModuleHash(['abc', 'def'])
+        const hash2 = computeModuleHash(['abc', 'xyz'])
+        expect(hash1).not.toBe(hash2)
+    })
+})
+
+describe('computeRootHash', () => {
+    it('produces consistent hash', () => {
+        const hash1 = computeRootHash({ auth: 'abc', payments: 'def' })
+        const hash2 = computeRootHash({ payments: 'def', auth: 'abc' })
+        expect(hash1).toBe(hash2)
+    })
+})

package/tests/helpers.ts

@@ -1,83 +1,83 @@
-import { hashContent } from '../src/hash/file-hasher'
-import type { ParsedFile, ParsedFunction, ParsedImport } from '../src/parser/types'
-import { GraphBuilder } from '../src/graph/graph-builder'
-import type { DependencyGraph } from '../src/graph/types'
-
-/** Build a minimal ParsedFile for testing without actually parsing */
-export function mockParsedFile(
-    filePath: string,
-    functions: ParsedFunction[] = [],
-    imports: ParsedImport[] = []
-): ParsedFile {
-    return {
-        path: filePath,
-        language: 'typescript',
-        functions,
-        classes: [],
-        imports,
-        exports: [],
-        hash: hashContent(filePath),
-        parsedAt: Date.now(),
-    }
-}
-
-/** Build a minimal ParsedFunction */
-export function mockFunction(
-    name: string,
-    calls: string[] = [],
-    file: string = 'src/test.ts',
-    isExported: boolean = false
-): ParsedFunction {
-    return {
-        id: `fn:${file}:${name}`,
-        name,
-        file,
-        startLine: 1,
-        endLine: 10,
-        params: [],
-        returnType: 'void',
-        isExported,
-        isAsync: false,
-        calls,
-        hash: hashContent(name),
-    }
-}
-
-/** Build a minimal ParsedImport */
-export function mockImport(
-    source: string,
-    names: string[],
-    resolvedPath: string = ''
-): ParsedImport {
-    return {
-        source,
-        resolvedPath,
-        names,
-        isDefault: false,
-        isDynamic: false,
-    }
-}
-
-/** Build a graph from simple tuple pairs for testing */
-export function buildTestGraph(
-    callPairs: [string, string][]
-): DependencyGraph {
-    const fileNames = [...new Set(callPairs.flat().filter(x => x !== 'nothing'))]
-    const parsedFiles = fileNames.map(name => {
-        const targets = callPairs
-            .filter(([from]) => from === name)
-            .flatMap(([, to]) => to === 'nothing' ? [] : [to])
-
-        // Build proper imports so GraphBuilder can resolve the call edges
-        const imports = targets.map(to =>
-            mockImport(`./${to}`, [to], `src/${to}.ts`)
-        )
-
-        return mockParsedFile(
-            `src/${name}.ts`,
-            [mockFunction(name, targets, `src/${name}.ts`)],
-            imports
-        )
-    })
-    return new GraphBuilder().build(parsedFiles)
-}
+import { hashContent } from '../src/hash/file-hasher'
+import type { ParsedFile, ParsedFunction, ParsedImport } from '../src/parser/types'
+import { GraphBuilder } from '../src/graph/graph-builder'
+import type { DependencyGraph } from '../src/graph/types'
+
+/** Build a minimal ParsedFile for testing without actually parsing */
+export function mockParsedFile(
+    filePath: string,
+    functions: ParsedFunction[] = [],
+    imports: ParsedImport[] = []
+): ParsedFile {
+    return {
+        path: filePath,
+        language: 'typescript',
+        functions,
+        classes: [],
+        imports,
+        exports: [],
+        hash: hashContent(filePath),
+        parsedAt: Date.now(),
+    }
+}
+
+/** Build a minimal ParsedFunction */
+export function mockFunction(
+    name: string,
+    calls: string[] = [],
+    file: string = 'src/test.ts',
+    isExported: boolean = false
+): ParsedFunction {
+    return {
+        id: `fn:${file}:${name}`,
+        name,
+        file,
+        startLine: 1,
+        endLine: 10,
+        params: [],
+        returnType: 'void',
+        isExported,
+        isAsync: false,
+        calls,
+        hash: hashContent(name),
+    }
+}
+
+/** Build a minimal ParsedImport */
+export function mockImport(
+    source: string,
+    names: string[],
+    resolvedPath: string = ''
+): ParsedImport {
+    return {
+        source,
+        resolvedPath,
+        names,
+        isDefault: false,
+        isDynamic: false,
+    }
+}
+
+/** Build a graph from simple tuple pairs for testing */
+export function buildTestGraph(
+    callPairs: [string, string][]
+): DependencyGraph {
+    const fileNames = [...new Set(callPairs.flat().filter(x => x !== 'nothing'))]
+    const parsedFiles = fileNames.map(name => {
+        const targets = callPairs
+            .filter(([from]) => from === name)
+            .flatMap(([, to]) => to === 'nothing' ? [] : [to])
+
+        // Build proper imports so GraphBuilder can resolve the call edges
+        const imports = targets.map(to =>
+            mockImport(`./${to}`, [to], `src/${to}.ts`)
+        )
+
+        return mockParsedFile(
+            `src/${name}.ts`,
+            [mockFunction(name, targets, `src/${name}.ts`)],
+            imports
+        )
+    })
+    return new GraphBuilder().build(parsedFiles)
+}