@getmikk/core 1.2.0 → 1.3.1

package/tests/contract.test.ts

@@ -1,134 +1,134 @@
-import { describe, it, expect } from 'bun:test'
-import { MikkContractSchema, MikkLockSchema } from '../src/contract/schema'
-import { LockCompiler } from '../src/contract/lock-compiler'
-import { ContractGenerator } from '../src/contract/contract-generator'
-import { GraphBuilder } from '../src/graph/graph-builder'
-import { ClusterDetector } from '../src/graph/cluster-detector'
-import { mockParsedFile, mockFunction, mockImport } from './helpers'
-
-describe('MikkContractSchema', () => {
-    const validContract = {
-        version: '1.0.0',
-        project: {
-            name: 'my-api',
-            description: 'REST API',
-            language: 'typescript',
-            entryPoints: ['src/index.ts'],
-        },
-        declared: {
-            modules: [{
-                id: 'auth',
-                name: 'Authentication',
-                description: 'Handles auth',
-                paths: ['src/auth/**'],
-            }],
-            constraints: ['No direct DB access outside db/'],
-            decisions: [{
-                id: 'adr-001',
-                title: 'JWT over sessions',
-                reason: 'Scaling',
-                date: '2024-01-15',
-            }],
-        },
-    }
-
-    it('validates correct mikk.json', () => {
-        const result = MikkContractSchema.safeParse(validContract)
-        expect(result.success).toBe(true)
-    })
-
-    it('rejects mikk.json with missing required fields', () => {
-        const result = MikkContractSchema.safeParse({ version: '1.0.0' })
-        expect(result.success).toBe(false)
-    })
-
-    it('applies default overwrite mode', () => {
-        const result = MikkContractSchema.safeParse(validContract)
-        expect(result.success).toBe(true)
-        if (result.success) {
-            expect(result.data.overwrite.mode).toBe('never')
-        }
-    })
-})
-
-describe('LockCompiler', () => {
-    const compiler = new LockCompiler()
-    const contract = MikkContractSchema.parse({
-        version: '1.0.0',
-        project: { name: 'test', description: 'Test', language: 'typescript', entryPoints: ['src/index.ts'] },
-        declared: {
-            modules: [
-                { id: 'auth', name: 'Auth', description: 'Auth module', paths: ['src/auth/**'] },
-                { id: 'utils', name: 'Utils', description: 'Utils', paths: ['src/utils/**'] },
-            ],
-        },
-    })
-
-    it('compiles a valid lock file', () => {
-        const files = [
-            mockParsedFile(
-                'src/auth/verify.ts',
-                [mockFunction('verifyToken', ['jwtDecode'], 'src/auth/verify.ts', true)],
-                [mockImport('../utils/jwt', ['jwtDecode'], 'src/utils/jwt.ts')]
-            ),
-            mockParsedFile('src/utils/jwt.ts', [mockFunction('jwtDecode', [], 'src/utils/jwt.ts', true)]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        const lock = compiler.compile(graph, contract, files)
-
-        expect(lock.version).toBe('1.0.0')
-        expect(lock.syncState.status).toBe('clean')
-        expect(Object.keys(lock.functions).length).toBeGreaterThan(0)
-        expect(Object.keys(lock.modules).length).toBeGreaterThanOrEqual(1)
-        expect(Object.keys(lock.files).length).toBe(2)
-    })
-
-    it('assigns functions to correct modules', () => {
-        const files = [
-            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        const lock = compiler.compile(graph, contract, files)
-        expect(lock.functions['fn:src/auth/verify.ts:verifyToken']?.moduleId).toBe('auth')
-    })
-
-    it('computes stable module hash', () => {
-        const files = [
-            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        const lock1 = compiler.compile(graph, contract, files)
-        const lock2 = compiler.compile(graph, contract, files)
-        expect(lock1.modules['auth']?.hash).toBe(lock2.modules['auth']?.hash)
-    })
-
-    it('validates against MikkLockSchema', () => {
-        const files = [
-            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        const lock = compiler.compile(graph, contract, files)
-        const result = MikkLockSchema.safeParse(lock)
-        expect(result.success).toBe(true)
-    })
-})
-
-describe('ContractGenerator', () => {
-    it('generates contract from clusters', () => {
-        const files = [
-            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts', true)]),
-            mockParsedFile('src/auth/middleware.ts', [mockFunction('authMiddleware', [], 'src/auth/middleware.ts', true)]),
-        ]
-        const graph = new GraphBuilder().build(files)
-        const detector = new ClusterDetector(graph, 1)
-        const clusters = detector.detect()
-
-        const generator = new ContractGenerator()
-        const contract = generator.generateFromClusters(clusters, files, 'test-project')
-
-        expect(contract.version).toBe('1.0.0')
-        expect(contract.project.name).toBe('test-project')
-        expect(contract.declared.modules.length).toBeGreaterThan(0)
-        expect(contract.overwrite.mode).toBe('never')
-    })
-})
+import { describe, it, expect } from 'bun:test'
+import { MikkContractSchema, MikkLockSchema } from '../src/contract/schema'
+import { LockCompiler } from '../src/contract/lock-compiler'
+import { ContractGenerator } from '../src/contract/contract-generator'
+import { GraphBuilder } from '../src/graph/graph-builder'
+import { ClusterDetector } from '../src/graph/cluster-detector'
+import { mockParsedFile, mockFunction, mockImport } from './helpers'
+
+describe('MikkContractSchema', () => {
+    const validContract = {
+        version: '1.0.0',
+        project: {
+            name: 'my-api',
+            description: 'REST API',
+            language: 'typescript',
+            entryPoints: ['src/index.ts'],
+        },
+        declared: {
+            modules: [{
+                id: 'auth',
+                name: 'Authentication',
+                description: 'Handles auth',
+                paths: ['src/auth/**'],
+            }],
+            constraints: ['No direct DB access outside db/'],
+            decisions: [{
+                id: 'adr-001',
+                title: 'JWT over sessions',
+                reason: 'Scaling',
+                date: '2024-01-15',
+            }],
+        },
+    }
+
+    it('validates correct mikk.json', () => {
+        const result = MikkContractSchema.safeParse(validContract)
+        expect(result.success).toBe(true)
+    })
+
+    it('rejects mikk.json with missing required fields', () => {
+        const result = MikkContractSchema.safeParse({ version: '1.0.0' })
+        expect(result.success).toBe(false)
+    })
+
+    it('applies default overwrite mode', () => {
+        const result = MikkContractSchema.safeParse(validContract)
+        expect(result.success).toBe(true)
+        if (result.success) {
+            expect(result.data.overwrite.mode).toBe('never')
+        }
+    })
+})
+
+describe('LockCompiler', () => {
+    const compiler = new LockCompiler()
+    const contract = MikkContractSchema.parse({
+        version: '1.0.0',
+        project: { name: 'test', description: 'Test', language: 'typescript', entryPoints: ['src/index.ts'] },
+        declared: {
+            modules: [
+                { id: 'auth', name: 'Auth', description: 'Auth module', paths: ['src/auth/**'] },
+                { id: 'utils', name: 'Utils', description: 'Utils', paths: ['src/utils/**'] },
+            ],
+        },
+    })
+
+    it('compiles a valid lock file', () => {
+        const files = [
+            mockParsedFile(
+                'src/auth/verify.ts',
+                [mockFunction('verifyToken', ['jwtDecode'], 'src/auth/verify.ts', true)],
+                [mockImport('../utils/jwt', ['jwtDecode'], 'src/utils/jwt.ts')]
+            ),
+            mockParsedFile('src/utils/jwt.ts', [mockFunction('jwtDecode', [], 'src/utils/jwt.ts', true)]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        const lock = compiler.compile(graph, contract, files)
+
+        expect(lock.version).toBe('1.0.0')
+        expect(lock.syncState.status).toBe('clean')
+        expect(Object.keys(lock.functions).length).toBeGreaterThan(0)
+        expect(Object.keys(lock.modules).length).toBeGreaterThanOrEqual(1)
+        expect(Object.keys(lock.files).length).toBe(2)
+    })
+
+    it('assigns functions to correct modules', () => {
+        const files = [
+            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        const lock = compiler.compile(graph, contract, files)
+        expect(lock.functions['fn:src/auth/verify.ts:verifyToken']?.moduleId).toBe('auth')
+    })
+
+    it('computes stable module hash', () => {
+        const files = [
+            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        const lock1 = compiler.compile(graph, contract, files)
+        const lock2 = compiler.compile(graph, contract, files)
+        expect(lock1.modules['auth']?.hash).toBe(lock2.modules['auth']?.hash)
+    })
+
+    it('validates against MikkLockSchema', () => {
+        const files = [
+            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        const lock = compiler.compile(graph, contract, files)
+        const result = MikkLockSchema.safeParse(lock)
+        expect(result.success).toBe(true)
+    })
+})
+
+describe('ContractGenerator', () => {
+    it('generates contract from clusters', () => {
+        const files = [
+            mockParsedFile('src/auth/verify.ts', [mockFunction('verifyToken', [], 'src/auth/verify.ts', true)]),
+            mockParsedFile('src/auth/middleware.ts', [mockFunction('authMiddleware', [], 'src/auth/middleware.ts', true)]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        const detector = new ClusterDetector(graph, 1)
+        const clusters = detector.detect()
+
+        const generator = new ContractGenerator()
+        const contract = generator.generateFromClusters(clusters, files, 'test-project')
+
+        expect(contract.version).toBe('1.0.0')
+        expect(contract.project.name).toBe('test-project')
+        expect(contract.declared.modules.length).toBeGreaterThan(0)
+        expect(contract.overwrite.mode).toBe('never')
+    })
+})

package/tests/fixtures/simple-api/package.json

@@ -1,5 +1,5 @@
-{
-    "name": "simple-api",
-    "private": true,
-    "version": "1.0.0"
-}
+{
+    "name": "simple-api",
+    "private": true,
+    "version": "1.0.0"
+}

package/tests/fixtures/simple-api/src/auth/middleware.ts

@@ -1,9 +1,9 @@
-import { verifyToken } from './verify'
-
-export function authMiddleware(req: any, res: any, next: any) {
-    const token = req.headers.authorization
-    if (!verifyToken(token)) {
-        return res.status(401).json({ error: 'Unauthorized' })
-    }
-    next()
-}
+import { verifyToken } from './verify'
+
+export function authMiddleware(req: any, res: any, next: any) {
+    const token = req.headers.authorization
+    if (!verifyToken(token)) {
+        return res.status(401).json({ error: 'Unauthorized' })
+    }
+    next()
+}

package/tests/fixtures/simple-api/src/auth/verify.ts

@@ -1,6 +1,6 @@
-import { jwtDecode } from '../utils/jwt'
-
-export function verifyToken(token: string): boolean {
-    const decoded = jwtDecode(token)
-    return decoded.exp > Date.now()
-}
+import { jwtDecode } from '../utils/jwt'
+
+export function verifyToken(token: string): boolean {
+    const decoded = jwtDecode(token)
+    return decoded.exp > Date.now()
+}

package/tests/fixtures/simple-api/src/index.ts

@@ -1,9 +1,9 @@
-import { authMiddleware } from './auth/middleware'
-
-const app = {
-    use: (handler: any) => { },
-    listen: (port: number) => console.log(`Listening on ${port}`)
-}
-
-app.use(authMiddleware)
-app.listen(3000)
+import { authMiddleware } from './auth/middleware'
+
+const app = {
+    use: (handler: any) => { },
+    listen: (port: number) => console.log(`Listening on ${port}`)
+}
+
+app.use(authMiddleware)
+app.listen(3000)

package/tests/fixtures/simple-api/src/utils/jwt.ts

@@ -1,3 +1,3 @@
-export function jwtDecode(token: string): { exp: number } {
-    return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString())
-}
+export function jwtDecode(token: string): { exp: number } {
+    return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString())
+}

package/tests/fixtures/simple-api/tsconfig.json

@@ -1,8 +1,8 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "ESNext",
-        "moduleResolution": "bundler",
-        "strict": true
-    }
-}
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "strict": true
+    }
+}

package/tests/fuzzy-match.test.ts

@@ -1,142 +1,142 @@
-import { describe, test, expect } from 'bun:test'
-import { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from '../src/utils/fuzzy-match'
-import type { MikkLock } from '../src/contract/schema'
-
-const mockLock: MikkLock = {
-    version: '1.0.0',
-    generatedAt: new Date().toISOString(),
-    generatorVersion: '1.1.0',
-    projectRoot: '/test',
-    syncState: { status: 'clean', lastSyncAt: new Date().toISOString(), lockHash: 'abc', contractHash: 'def' },
-    modules: {},
-    functions: {
-        'fn:auth:verifyToken': {
-            id: 'fn:auth:verifyToken', name: 'verifyToken', file: 'src/auth/verify.ts',
-            startLine: 1, endLine: 10, hash: 'h1', calls: [], calledBy: ['fn:api:handleLogin'],
-            moduleId: 'auth',
-        },
-        'fn:auth:refreshToken': {
-            id: 'fn:auth:refreshToken', name: 'refreshToken', file: 'src/auth/refresh.ts',
-            startLine: 1, endLine: 15, hash: 'h2', calls: [], calledBy: [],
-            moduleId: 'auth',
-        },
-        'fn:api:handleLogin': {
-            id: 'fn:api:handleLogin', name: 'handleLogin', file: 'src/api/login.ts',
-            startLine: 1, endLine: 20, hash: 'h3', calls: ['fn:auth:verifyToken'], calledBy: [],
-            moduleId: 'api',
-        },
-        'fn:db:queryUsers': {
-            id: 'fn:db:queryUsers', name: 'queryUsers', file: 'src/db/users.ts',
-            startLine: 1, endLine: 8, hash: 'h4', calls: [], calledBy: [],
-            moduleId: 'db',
-        },
-        'fn:api:validateUserInput': {
-            id: 'fn:api:validateUserInput', name: 'validateUserInput', file: 'src/api/validation.ts',
-            startLine: 1, endLine: 12, hash: 'h5', calls: [], calledBy: [],
-            moduleId: 'api',
-        },
-    },
-    files: {},
-    graph: { nodes: 5, edges: 1, rootHash: 'root' },
-}
-
-describe('levenshtein', () => {
-    test('identical strings → 0', () => {
-        expect(levenshtein('hello', 'hello')).toBe(0)
-    })
-
-    test('empty vs non-empty', () => {
-        expect(levenshtein('', 'abc')).toBe(3)
-        expect(levenshtein('abc', '')).toBe(3)
-    })
-
-    test('single char difference', () => {
-        expect(levenshtein('cat', 'bat')).toBe(1)
-    })
-
-    test('completely different strings', () => {
-        expect(levenshtein('abc', 'xyz')).toBe(3)
-    })
-
-    test('insertion', () => {
-        expect(levenshtein('test', 'tests')).toBe(1)
-    })
-})
-
-describe('splitCamelCase', () => {
-    test('camelCase', () => {
-        expect(splitCamelCase('verifyToken')).toEqual(['verify', 'Token'])
-    })
-
-    test('PascalCase', () => {
-        expect(splitCamelCase('VerifyToken')).toEqual(['Verify', 'Token'])
-    })
-
-    test('snake_case', () => {
-        expect(splitCamelCase('verify_token')).toEqual(['verify', 'token'])
-    })
-
-    test('multiple words', () => {
-        expect(splitCamelCase('validateUserInput')).toEqual(['validate', 'User', 'Input'])
-    })
-})
-
-describe('extractKeywords', () => {
-    test('removes stop words', () => {
-        const keywords = extractKeywords('fix the auth token bug')
-        expect(keywords).toContain('auth')
-        expect(keywords).toContain('token')
-        expect(keywords).not.toContain('the')
-    })
-
-    test('lowercases everything', () => {
-        const keywords = extractKeywords('Token Validation')
-        expect(keywords).toEqual(['token', 'validation'])
-    })
-})
-
-describe('scoreFunctions', () => {
-    test('exact name match scores highest', () => {
-        const results = scoreFunctions('fix verifyToken', mockLock, 5)
-        expect(results.length).toBeGreaterThan(0)
-        expect(results[0].name).toBe('verifyToken')
-    })
-
-    test('keyword match works', () => {
-        const results = scoreFunctions('fix the token issue', mockLock, 5)
-        const names = results.map(r => r.name)
-        // Should find token-related functions
-        expect(names).toContain('verifyToken')
-        expect(names).toContain('refreshToken')
-    })
-
-    test('module match boosts score', () => {
-        const results = scoreFunctions('auth problem', mockLock, 5)
-        // Auth module functions should appear
-        const authFns = results.filter(r => r.moduleId === 'auth')
-        expect(authFns.length).toBeGreaterThan(0)
-    })
-
-    test('maxResults limits output', () => {
-        const results = scoreFunctions('function', mockLock, 2)
-        expect(results.length).toBeLessThanOrEqual(2)
-    })
-})
-
-describe('findFuzzyMatches', () => {
-    test('finds similar names', () => {
-        const matches = findFuzzyMatches('verifyTokens', mockLock, 3)
-        expect(matches).toContain('verifyToken')
-    })
-
-    test('finds substring matches', () => {
-        const matches = findFuzzyMatches('Token', mockLock, 5)
-        expect(matches).toContain('verifyToken')
-        expect(matches).toContain('refreshToken')
-    })
-
-    test('returns empty for very dissimilar terms', () => {
-        const matches = findFuzzyMatches('xyzzyplugh', mockLock, 5)
-        expect(matches.length).toBe(0)
-    })
-})
+import { describe, test, expect } from 'bun:test'
+import { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from '../src/utils/fuzzy-match'
+import type { MikkLock } from '../src/contract/schema'
+
+const mockLock: MikkLock = {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    generatorVersion: '1.1.0',
+    projectRoot: '/test',
+    syncState: { status: 'clean', lastSyncAt: new Date().toISOString(), lockHash: 'abc', contractHash: 'def' },
+    modules: {},
+    functions: {
+        'fn:auth:verifyToken': {
+            id: 'fn:auth:verifyToken', name: 'verifyToken', file: 'src/auth/verify.ts',
+            startLine: 1, endLine: 10, hash: 'h1', calls: [], calledBy: ['fn:api:handleLogin'],
+            moduleId: 'auth',
+        },
+        'fn:auth:refreshToken': {
+            id: 'fn:auth:refreshToken', name: 'refreshToken', file: 'src/auth/refresh.ts',
+            startLine: 1, endLine: 15, hash: 'h2', calls: [], calledBy: [],
+            moduleId: 'auth',
+        },
+        'fn:api:handleLogin': {
+            id: 'fn:api:handleLogin', name: 'handleLogin', file: 'src/api/login.ts',
+            startLine: 1, endLine: 20, hash: 'h3', calls: ['fn:auth:verifyToken'], calledBy: [],
+            moduleId: 'api',
+        },
+        'fn:db:queryUsers': {
+            id: 'fn:db:queryUsers', name: 'queryUsers', file: 'src/db/users.ts',
+            startLine: 1, endLine: 8, hash: 'h4', calls: [], calledBy: [],
+            moduleId: 'db',
+        },
+        'fn:api:validateUserInput': {
+            id: 'fn:api:validateUserInput', name: 'validateUserInput', file: 'src/api/validation.ts',
+            startLine: 1, endLine: 12, hash: 'h5', calls: [], calledBy: [],
+            moduleId: 'api',
+        },
+    },
+    files: {},
+    graph: { nodes: 5, edges: 1, rootHash: 'root' },
+}
+
+describe('levenshtein', () => {
+    test('identical strings → 0', () => {
+        expect(levenshtein('hello', 'hello')).toBe(0)
+    })
+
+    test('empty vs non-empty', () => {
+        expect(levenshtein('', 'abc')).toBe(3)
+        expect(levenshtein('abc', '')).toBe(3)
+    })
+
+    test('single char difference', () => {
+        expect(levenshtein('cat', 'bat')).toBe(1)
+    })
+
+    test('completely different strings', () => {
+        expect(levenshtein('abc', 'xyz')).toBe(3)
+    })
+
+    test('insertion', () => {
+        expect(levenshtein('test', 'tests')).toBe(1)
+    })
+})
+
+describe('splitCamelCase', () => {
+    test('camelCase', () => {
+        expect(splitCamelCase('verifyToken')).toEqual(['verify', 'Token'])
+    })
+
+    test('PascalCase', () => {
+        expect(splitCamelCase('VerifyToken')).toEqual(['Verify', 'Token'])
+    })
+
+    test('snake_case', () => {
+        expect(splitCamelCase('verify_token')).toEqual(['verify', 'token'])
+    })
+
+    test('multiple words', () => {
+        expect(splitCamelCase('validateUserInput')).toEqual(['validate', 'User', 'Input'])
+    })
+})
+
+describe('extractKeywords', () => {
+    test('removes stop words', () => {
+        const keywords = extractKeywords('fix the auth token bug')
+        expect(keywords).toContain('auth')
+        expect(keywords).toContain('token')
+        expect(keywords).not.toContain('the')
+    })
+
+    test('lowercases everything', () => {
+        const keywords = extractKeywords('Token Validation')
+        expect(keywords).toEqual(['token', 'validation'])
+    })
+})
+
+describe('scoreFunctions', () => {
+    test('exact name match scores highest', () => {
+        const results = scoreFunctions('fix verifyToken', mockLock, 5)
+        expect(results.length).toBeGreaterThan(0)
+        expect(results[0].name).toBe('verifyToken')
+    })
+
+    test('keyword match works', () => {
+        const results = scoreFunctions('fix the token issue', mockLock, 5)
+        const names = results.map(r => r.name)
+        // Should find token-related functions
+        expect(names).toContain('verifyToken')
+        expect(names).toContain('refreshToken')
+    })
+
+    test('module match boosts score', () => {
+        const results = scoreFunctions('auth problem', mockLock, 5)
+        // Auth module functions should appear
+        const authFns = results.filter(r => r.moduleId === 'auth')
+        expect(authFns.length).toBeGreaterThan(0)
+    })
+
+    test('maxResults limits output', () => {
+        const results = scoreFunctions('function', mockLock, 2)
+        expect(results.length).toBeLessThanOrEqual(2)
+    })
+})
+
+describe('findFuzzyMatches', () => {
+    test('finds similar names', () => {
+        const matches = findFuzzyMatches('verifyTokens', mockLock, 3)
+        expect(matches).toContain('verifyToken')
+    })
+
+    test('finds substring matches', () => {
+        const matches = findFuzzyMatches('Token', mockLock, 5)
+        expect(matches).toContain('verifyToken')
+        expect(matches).toContain('refreshToken')
+    })
+
+    test('returns empty for very dissimilar terms', () => {
+        const matches = findFuzzyMatches('xyzzyplugh', mockLock, 5)
+        expect(matches.length).toBe(0)
+    })
+})