@getmikk/intent-engine 1.2.0 → 1.3.1

package/tests/intent-engine.test.ts

@@ -1,210 +1,210 @@
-import { describe, test, expect } from 'bun:test'
-import { IntentInterpreter } from '../src/interpreter'
-import { ConflictDetector } from '../src/conflict-detector'
-import { PreflightPipeline } from '../src/preflight'
-import type { MikkContract, MikkLock } from '@getmikk/core'
-
-const mockContract: MikkContract = {
-    version: '1.0.0',
-    project: {
-        name: 'TestProject',
-        description: 'Test',
-        language: 'TypeScript',
-        entryPoints: ['src/index.ts'],
-    },
-    declared: {
-        modules: [
-            { id: 'auth', name: 'Authentication', description: 'Auth module', paths: ['src/auth/**'], owners: ['alice'] },
-            { id: 'api', name: 'API', description: 'API layer', paths: ['src/api/**'] },
-            { id: 'db', name: 'Database', description: 'DB layer', paths: ['src/db/**'] },
-        ],
-        constraints: [
-            'No direct DB access outside db/',
-            'All auth must go through auth.middleware',
-            'Controllers cannot import from repositories directly',
-            'Never call setTimeout in the payment flow',
-        ],
-        decisions: [
-            { id: 'd1', title: 'Use JWT', reason: 'Stateless auth', date: '2024-01-01' },
-        ],
-    },
-    overwrite: { mode: 'never', requireConfirmation: true },
-}
-
-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: 'a', contractHash: 'b' },
-    modules: {
-        auth: { id: 'auth', files: ['src/auth/verify.ts'], hash: 'h1', fragmentPath: '.mikk/fragments/auth.json' },
-        api: { id: 'api', files: ['src/api/login.ts'], hash: 'h2', fragmentPath: '.mikk/fragments/api.json' },
-    },
-    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: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',
-        },
-    },
-    files: {
-        'src/auth/verify.ts': { path: 'src/auth/verify.ts', hash: 'fh1', moduleId: 'auth', lastModified: new Date().toISOString() },
-        'src/api/login.ts': { path: 'src/api/login.ts', hash: 'fh2', moduleId: 'api', lastModified: new Date().toISOString() },
-    },
-    graph: { nodes: 2, edges: 1, rootHash: 'root' },
-}
-
-describe('IntentInterpreter', () => {
-    const interpreter = new IntentInterpreter(mockContract, mockLock)
-
-    test('detects create action', async () => {
-        const intents = await interpreter.interpret('create a new auth handler')
-        expect(intents.some(i => i.action === 'create')).toBe(true)
-    })
-
-    test('detects modify action from "fix"', async () => {
-        const intents = await interpreter.interpret('fix the verifyToken function')
-        expect(intents.some(i => i.action === 'modify')).toBe(true)
-    })
-
-    test('matches function by name', async () => {
-        const intents = await interpreter.interpret('update verifyToken to use async')
-        const modifyIntent = intents.find(i => i.action === 'modify')
-        expect(modifyIntent?.target.name).toBe('verifyToken')
-        expect(modifyIntent?.target.type).toBe('function')
-    })
-
-    test('matches module by name', async () => {
-        const intents = await interpreter.interpret('refactor the Authentication module')
-        const intent = intents.find(i => i.action === 'refactor')
-        expect(intent?.target.type).toBe('module')
-        expect(intent?.target.moduleId).toBe('auth')
-    })
-
-    test('defaults to modify when no action keyword', async () => {
-        const intents = await interpreter.interpret('something about verifyToken')
-        expect(intents[0].action).toBe('modify')
-    })
-
-    test('fuzzy matches camelCase components', async () => {
-        const intents = await interpreter.interpret('update the token verification')
-        // Should match verifyToken via "token" + "verify" keyword overlap
-        const fns = intents.filter(i => i.target.type === 'function')
-        expect(fns.length).toBeGreaterThanOrEqual(0) // at least attempts matching
-    })
-})
-
-describe('ConflictDetector', () => {
-    test('detects no-import constraint violations', () => {
-        const detector = new ConflictDetector(mockContract, mockLock)
-        const result = detector.detect([{
-            action: 'modify',
-            target: { type: 'function', name: 'handleLogin', moduleId: 'api', filePath: 'src/api/login.ts' },
-            reason: 'Access DB directly from API',
-            confidence: 0.8,
-        }])
-        // The "No direct DB access outside db/" constraint should fire
-        const dbConflict = result.conflicts.find(c =>
-            c.message.toLowerCase().includes('db') || c.message.toLowerCase().includes('restricted')
-        )
-        // This may or may not fire depending on exact matching — test the shape
-        expect(result.conflicts).toBeInstanceOf(Array)
-    })
-
-    test('detects boundary crossing on move', () => {
-        const detector = new ConflictDetector(mockContract, mockLock)
-        const result = detector.detect([{
-            action: 'move',
-            target: { type: 'function', name: 'verifyToken', moduleId: 'auth' },
-            reason: 'Move to API module',
-            confidence: 0.8,
-        }])
-        const crossing = result.conflicts.find(c => c.type === 'boundary-crossing')
-        expect(crossing).toBeDefined()
-        expect(crossing!.message).toContain('verifyToken')
-    })
-
-    test('detects missing function on modify', () => {
-        const detector = new ConflictDetector(mockContract, mockLock)
-        const result = detector.detect([{
-            action: 'modify',
-            target: { type: 'function', name: 'nonExistentFunction' },
-            reason: 'Fix something',
-            confidence: 0.3,
-        }])
-        const missing = result.conflicts.find(c => c.type === 'missing-dependency')
-        expect(missing).toBeDefined()
-        expect(missing!.message).toContain('nonExistentFunction')
-    })
-
-    test('detects ownership warning', () => {
-        const detector = new ConflictDetector(mockContract, mockLock)
-        const result = detector.detect([{
-            action: 'modify',
-            target: { type: 'function', name: 'verifyToken', moduleId: 'auth' },
-            reason: 'Modify auth',
-            confidence: 0.8,
-        }])
-        const ownership = result.conflicts.find(c => c.type === 'ownership-conflict')
-        expect(ownership).toBeDefined()
-        expect(ownership!.message).toContain('alice')
-    })
-
-    test('must-use constraint triggers for auth domain', () => {
-        const detector = new ConflictDetector(mockContract, mockLock)
-        const result = detector.detect([{
-            action: 'create',
-            target: { type: 'function', name: 'authHandler', moduleId: 'auth' },
-            reason: 'New auth handler',
-            confidence: 0.7,
-        }])
-        const mustUse = result.conflicts.find(c =>
-            c.message.includes('auth.middleware') || c.message.includes('must')
-        )
-        expect(mustUse).toBeDefined()
-    })
-
-    test('hasConflicts is false when only warnings', () => {
-        const detector = new ConflictDetector(mockContract, mockLock)
-        const result = detector.detect([{
-            action: 'modify',
-            target: { type: 'function', name: 'verifyToken', moduleId: 'auth' },
-            reason: 'Small fix',
-            confidence: 0.8,
-        }])
-        // Ownership warnings shouldn't block (severity: warning, not error)
-        // hasConflicts should be false unless there's an error severity
-        const hasErrors = result.conflicts.some(c => c.severity === 'error')
-        expect(result.hasConflicts).toBe(hasErrors)
-    })
-})
-
-describe('PreflightPipeline', () => {
-    test('full pipeline produces valid result', async () => {
-        const pipeline = new PreflightPipeline(mockContract, mockLock)
-        const result = await pipeline.run('fix the verifyToken function')
-
-        expect(result.intents.length).toBeGreaterThan(0)
-        expect(result.conflicts).toBeDefined()
-        expect(result.conflicts.conflicts).toBeInstanceOf(Array)
-        expect(result.suggestions).toBeInstanceOf(Array)
-        expect(result.suggestions.length).toBeGreaterThan(0)
-        expect(typeof result.approved).toBe('boolean')
-    })
-
-    test('suggestions include affected files', async () => {
-        const pipeline = new PreflightPipeline(mockContract, mockLock)
-        const result = await pipeline.run('modify verifyToken')
-
-        const suggestion = result.suggestions.find(s =>
-            s.affectedFiles.some(f => f.includes('verify'))
-        )
-        expect(suggestion).toBeDefined()
-    })
-})
+import { describe, test, expect } from 'bun:test'
+import { IntentInterpreter } from '../src/interpreter'
+import { ConflictDetector } from '../src/conflict-detector'
+import { PreflightPipeline } from '../src/preflight'
+import type { MikkContract, MikkLock } from '@getmikk/core'
+
+const mockContract: MikkContract = {
+    version: '1.0.0',
+    project: {
+        name: 'TestProject',
+        description: 'Test',
+        language: 'TypeScript',
+        entryPoints: ['src/index.ts'],
+    },
+    declared: {
+        modules: [
+            { id: 'auth', name: 'Authentication', description: 'Auth module', paths: ['src/auth/**'], owners: ['alice'] },
+            { id: 'api', name: 'API', description: 'API layer', paths: ['src/api/**'] },
+            { id: 'db', name: 'Database', description: 'DB layer', paths: ['src/db/**'] },
+        ],
+        constraints: [
+            'No direct DB access outside db/',
+            'All auth must go through auth.middleware',
+            'Controllers cannot import from repositories directly',
+            'Never call setTimeout in the payment flow',
+        ],
+        decisions: [
+            { id: 'd1', title: 'Use JWT', reason: 'Stateless auth', date: '2024-01-01' },
+        ],
+    },
+    overwrite: { mode: 'never', requireConfirmation: true },
+}
+
+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: 'a', contractHash: 'b' },
+    modules: {
+        auth: { id: 'auth', files: ['src/auth/verify.ts'], hash: 'h1', fragmentPath: '.mikk/fragments/auth.json' },
+        api: { id: 'api', files: ['src/api/login.ts'], hash: 'h2', fragmentPath: '.mikk/fragments/api.json' },
+    },
+    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: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',
+        },
+    },
+    files: {
+        'src/auth/verify.ts': { path: 'src/auth/verify.ts', hash: 'fh1', moduleId: 'auth', lastModified: new Date().toISOString() },
+        'src/api/login.ts': { path: 'src/api/login.ts', hash: 'fh2', moduleId: 'api', lastModified: new Date().toISOString() },
+    },
+    graph: { nodes: 2, edges: 1, rootHash: 'root' },
+}
+
+describe('IntentInterpreter', () => {
+    const interpreter = new IntentInterpreter(mockContract, mockLock)
+
+    test('detects create action', async () => {
+        const intents = await interpreter.interpret('create a new auth handler')
+        expect(intents.some(i => i.action === 'create')).toBe(true)
+    })
+
+    test('detects modify action from "fix"', async () => {
+        const intents = await interpreter.interpret('fix the verifyToken function')
+        expect(intents.some(i => i.action === 'modify')).toBe(true)
+    })
+
+    test('matches function by name', async () => {
+        const intents = await interpreter.interpret('update verifyToken to use async')
+        const modifyIntent = intents.find(i => i.action === 'modify')
+        expect(modifyIntent?.target.name).toBe('verifyToken')
+        expect(modifyIntent?.target.type).toBe('function')
+    })
+
+    test('matches module by name', async () => {
+        const intents = await interpreter.interpret('refactor the Authentication module')
+        const intent = intents.find(i => i.action === 'refactor')
+        expect(intent?.target.type).toBe('module')
+        expect(intent?.target.moduleId).toBe('auth')
+    })
+
+    test('defaults to modify when no action keyword', async () => {
+        const intents = await interpreter.interpret('something about verifyToken')
+        expect(intents[0].action).toBe('modify')
+    })
+
+    test('fuzzy matches camelCase components', async () => {
+        const intents = await interpreter.interpret('update the token verification')
+        // Should match verifyToken via "token" + "verify" keyword overlap
+        const fns = intents.filter(i => i.target.type === 'function')
+        expect(fns.length).toBeGreaterThanOrEqual(0) // at least attempts matching
+    })
+})
+
+describe('ConflictDetector', () => {
+    test('detects no-import constraint violations', () => {
+        const detector = new ConflictDetector(mockContract, mockLock)
+        const result = detector.detect([{
+            action: 'modify',
+            target: { type: 'function', name: 'handleLogin', moduleId: 'api', filePath: 'src/api/login.ts' },
+            reason: 'Access DB directly from API',
+            confidence: 0.8,
+        }])
+        // The "No direct DB access outside db/" constraint should fire
+        const dbConflict = result.conflicts.find(c =>
+            c.message.toLowerCase().includes('db') || c.message.toLowerCase().includes('restricted')
+        )
+        // This may or may not fire depending on exact matching — test the shape
+        expect(result.conflicts).toBeInstanceOf(Array)
+    })
+
+    test('detects boundary crossing on move', () => {
+        const detector = new ConflictDetector(mockContract, mockLock)
+        const result = detector.detect([{
+            action: 'move',
+            target: { type: 'function', name: 'verifyToken', moduleId: 'auth' },
+            reason: 'Move to API module',
+            confidence: 0.8,
+        }])
+        const crossing = result.conflicts.find(c => c.type === 'boundary-crossing')
+        expect(crossing).toBeDefined()
+        expect(crossing!.message).toContain('verifyToken')
+    })
+
+    test('detects missing function on modify', () => {
+        const detector = new ConflictDetector(mockContract, mockLock)
+        const result = detector.detect([{
+            action: 'modify',
+            target: { type: 'function', name: 'nonExistentFunction' },
+            reason: 'Fix something',
+            confidence: 0.3,
+        }])
+        const missing = result.conflicts.find(c => c.type === 'missing-dependency')
+        expect(missing).toBeDefined()
+        expect(missing!.message).toContain('nonExistentFunction')
+    })
+
+    test('detects ownership warning', () => {
+        const detector = new ConflictDetector(mockContract, mockLock)
+        const result = detector.detect([{
+            action: 'modify',
+            target: { type: 'function', name: 'verifyToken', moduleId: 'auth' },
+            reason: 'Modify auth',
+            confidence: 0.8,
+        }])
+        const ownership = result.conflicts.find(c => c.type === 'ownership-conflict')
+        expect(ownership).toBeDefined()
+        expect(ownership!.message).toContain('alice')
+    })
+
+    test('must-use constraint triggers for auth domain', () => {
+        const detector = new ConflictDetector(mockContract, mockLock)
+        const result = detector.detect([{
+            action: 'create',
+            target: { type: 'function', name: 'authHandler', moduleId: 'auth' },
+            reason: 'New auth handler',
+            confidence: 0.7,
+        }])
+        const mustUse = result.conflicts.find(c =>
+            c.message.includes('auth.middleware') || c.message.includes('must')
+        )
+        expect(mustUse).toBeDefined()
+    })
+
+    test('hasConflicts is false when only warnings', () => {
+        const detector = new ConflictDetector(mockContract, mockLock)
+        const result = detector.detect([{
+            action: 'modify',
+            target: { type: 'function', name: 'verifyToken', moduleId: 'auth' },
+            reason: 'Small fix',
+            confidence: 0.8,
+        }])
+        // Ownership warnings shouldn't block (severity: warning, not error)
+        // hasConflicts should be false unless there's an error severity
+        const hasErrors = result.conflicts.some(c => c.severity === 'error')
+        expect(result.hasConflicts).toBe(hasErrors)
+    })
+})
+
+describe('PreflightPipeline', () => {
+    test('full pipeline produces valid result', async () => {
+        const pipeline = new PreflightPipeline(mockContract, mockLock)
+        const result = await pipeline.run('fix the verifyToken function')
+
+        expect(result.intents.length).toBeGreaterThan(0)
+        expect(result.conflicts).toBeDefined()
+        expect(result.conflicts.conflicts).toBeInstanceOf(Array)
+        expect(result.suggestions).toBeInstanceOf(Array)
+        expect(result.suggestions.length).toBeGreaterThan(0)
+        expect(typeof result.approved).toBe('boolean')
+    })
+
+    test('suggestions include affected files', async () => {
+        const pipeline = new PreflightPipeline(mockContract, mockLock)
+        const result = await pipeline.run('modify verifyToken')
+
+        const suggestion = result.suggestions.find(s =>
+            s.affectedFiles.some(f => f.includes('verify'))
+        )
+        expect(suggestion).toBeDefined()
+    })
+})

package/tests/smoke.test.ts

@@ -1,5 +1,5 @@
-import { expect, test } from "bun:test";
-
-test("smoke test - intent-engine", () => {
-    expect(true).toBe(true);
-});
+import { expect, test } from "bun:test";
+
+test("smoke test - intent-engine", () => {
+    expect(true).toBe(true);
+});

package/tsconfig.json

@@ -1,15 +1,15 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "outDir": "dist",
-        "rootDir": "src"
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist",
-        "tests"
-    ]
-}
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src"
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "tests"
+    ]
+}