@getmikk/intent-engine 2.0.14 → 2.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmikk/intent-engine",
-  "version": "2.0.14",
+  "version": "2.0.16",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -27,7 +27,8 @@
     "lint": "bunx eslint --config ../../eslint.config.mjs ."
   },
   "dependencies": {
-    "@getmikk/core": "^2.0.11",
+    "@getmikk/core": "^2.0.16",
+    "@xenova/transformers": "^2.17.2",
     "zod": "^3.22.0"
   },
   "devDependencies": {

package/src/auto-correction.ts

@@ -60,8 +60,8 @@ export class AutoCorrectionEngine {
                     } else {
                         failedFixes.push(`${file}:${issue.line} — ${issue.message}`)
                     }
-                } catch {
-                    failedFixes.push(`${file}:${issue.line} — ${issue.message}`)
+                } catch (err) {
+                    failedFixes.push(`${file}:${issue.line} — ${issue.message}: ${err instanceof Error ? err.message : String(err)}`)
                 }
             }
         }

package/src/conflict-detector.ts

@@ -149,7 +149,7 @@ export class ConflictDetector {
             return null
         }
 
-        const [, _accessType, allowedPath] = match
+        const [, , allowedPath] = match
         const allowed = allowedPath.trim().replace(/[/\\*]*/g, '')
         const targetModule = intent.target.moduleId || ''
 

package/src/interpreter.ts

@@ -1,5 +1,5 @@
 import type { MikkContract, MikkLock } from '@getmikk/core'
-import { IntentSchema, type Intent } from './types.js'
+import type { Intent } from './types.js'
 
 /**
  * IntentInterpreter — parses a natural-language prompt into structured

package/src/pre-edit-validation.ts

@@ -209,7 +209,7 @@ export class PreEditValidation {
     }
 
     /** Build a zero-impact result when no tracked functions exist. */
-    private emptyImpact(files: string[]): ImpactResult {
+    private emptyImpact(_files: string[]): ImpactResult {
         return {
             changed:        [],
             impacted:       [],
@@ -251,6 +251,7 @@ export class PreEditValidation {
         }
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     private buildRecommendations(intent: any, impact: ImpactResult, gates: any[], corrections: any): string[] {
         const recs: string[] = []
 
@@ -268,6 +269,7 @@ export class PreEditValidation {
 
         const warnings = gates.filter(g => g.severity === 'WARNING' && !g.canProceed)
         if (warnings.length > 0) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             recs.push(`Address warnings: ${warnings.map((w: any) => w.gate).join(', ')}`)
         }
         if (corrections.issues.length > 0) {

package/src/semantic-searcher.ts

@@ -1,6 +1,8 @@
 import * as path from 'node:path'
 import * as fs from 'node:fs/promises'
-import type { MikkLock } from '@getmikk/core'
+import type { MikkLock, MikkLockFunction } from '@getmikk/core'
+
+const MAX_BODY_TOKENS = 150
 
 interface EmbeddingCache {
     lockFingerprint: string
@@ -35,6 +37,7 @@ export class SemanticSearcher {
     static readonly MODEL = 'Xenova/all-MiniLM-L6-v2'
 
     private readonly cachePath: string
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     private pipeline: any = null
     private cache: EmbeddingCache | null = null
 
@@ -77,7 +80,9 @@ export class SemanticSearcher {
                 this.cache = cached
                 return
             }
-        } catch { /* miss or corrupt -- rebuild */ }
+        } catch (err) {
+            console.warn(`[mikk] Semantic search cache miss/rebuild: ${err instanceof Error ? err.message : String(err)}`)
+        }
 
         // -- Empty lock fast-path -- nothing to embed ------------------------
         const fns = Object.values(lock.functions)
@@ -86,16 +91,8 @@ export class SemanticSearcher {
             return
         }
 
-        // Text representation: name + purpose + param names (no bodies, keeps it fast)
-        const texts = fns.map(fn => {
-            const parts: string[] = [fn.name]
-            if (fn.purpose) parts.push(fn.purpose)
-            if (fn.params?.length) parts.push(fn.params.map((p: any) => p.name).join(' '))
-            if (fn.returnType && fn.returnType !== 'void' && fn.returnType !== 'any') {
-                parts.push('returns ' + fn.returnType)
-            }
-            return parts.join(' ')
-        })
+        // Text representation: name + purpose + params + types + return type + body snippet
+        const texts = await Promise.all(fns.map(fn => buildRichText(fn, this.projectRoot)))
 
         await this.ensurePipeline()
         const embeddings: Record<string, number[]> = {}
@@ -109,8 +106,12 @@ export class SemanticSearcher {
         }
 
         this.cache = { lockFingerprint: fingerprint, model: SemanticSearcher.MODEL, embeddings }
-        await fs.mkdir(path.dirname(this.cachePath), { recursive: true })
-        await fs.writeFile(this.cachePath, JSON.stringify(this.cache))
+        try {
+            await fs.mkdir(path.dirname(this.cachePath), { recursive: true })
+            await fs.writeFile(this.cachePath, JSON.stringify(this.cache))
+        } catch (err) {
+            console.warn(`[mikk] Failed to write semantic search cache: ${err instanceof Error ? err.message : String(err)}`)
+        }
     }
 
     /**
@@ -154,12 +155,97 @@ export class SemanticSearcher {
     }
 }
 
-// --- Helpers -----------------------------------------------------------------
+async function buildRichText(fn: MikkLockFunction, projectRoot: string): Promise<string> {
+    const parts: string[] = [fn.name]
+
+    if (fn.purpose) {
+        parts.push(fn.purpose)
+    }
+
+    if (fn.params?.length) {
+        const paramStr = fn.params.map((p) => p.name).join(' ')
+        const typeStr = fn.params.map((p) => p.type || '').filter(Boolean).join(' ')
+        parts.push(paramStr, typeStr)
+    }
+
+    if (fn.returnType && fn.returnType !== 'void' && fn.returnType !== 'any') {
+        parts.push('returns', fn.returnType)
+    }
+
+    const body = await getFunctionBodySnippet(fn, projectRoot)
+    if (body) {
+        parts.push(body)
+    }
+
+    return parts.join(' ')
+}
+
+async function getFunctionBodySnippet(fn: MikkLockFunction, projectRoot: string): Promise<string> {
+    try {
+        const fullPath = path.join(projectRoot, fn.file)
+        const content = await fs.readFile(fullPath, 'utf-8')
+        const lines = content.split('\n')
+        const start = Math.max(0, fn.startLine - 1)
+        const end = Math.min(lines.length, fn.endLine)
+        const bodyLines = lines.slice(start, end)
+        const bodyText = bodyLines.join(' ')
 
-/** Lightweight fingerprint: function count + first 20 sorted IDs */
+        const cleaned = cleanCodeForEmbedding(bodyText)
+
+        const tokens = cleaned.split(/\s+/).filter(Boolean)
+        if (tokens.length <= MAX_BODY_TOKENS) {
+            return cleaned
+        }
+
+        const truncated = tokens.slice(0, MAX_BODY_TOKENS).join(' ')
+        return truncated + ' ...'
+    } catch {
+        return ''
+    }
+}
+
+function cleanCodeForEmbedding(code: string): string {
+    return code
+        .replace(/\/\*\*[\s\S]*?\*\//g, ' ')
+        .replace(/\/\/[^\n]*/g, ' ')
+        .replace(/#.*$/gm, ' ')
+        .replace(/['"`][^'"`]*['"`]/g, ' ')
+        .replace(/\{[^}]*\}/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+}
+
+async function _readFileCached(filePath: string, cache: Map<string, string>): Promise<string> {
+    if (cache.has(filePath)) {
+        return cache.get(filePath)!
+    }
+    try {
+        const content = await fs.readFile(filePath, 'utf-8')
+        cache.set(filePath, content)
+        return content
+    } catch {
+        return ''
+    }
+}
+
+/** Improved fingerprint: function count + all sorted IDs + metadata */
 function lockFingerprint(lock: MikkLock): string {
-    const ids = Object.keys(lock.functions).sort().slice(0, 20).join('|')
-    return `${Object.keys(lock.functions).length}:${ids}`
+    const ids = Object.keys(lock.functions).sort().join('|')
+    const fnCount = Object.keys(lock.functions).length
+    const fileCount = Object.keys(lock.files ?? {}).length
+    const moduleCount = Object.keys(lock.modules ?? {}).length
+    const hash = hashContent(`${fnCount}:${fileCount}:${moduleCount}:${ids}`)
+    return hash.slice(0, 32)
+}
+
+function hashContent(content: string): string {
+    let hash = 0
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i)
+        hash = ((hash << 5) - hash) + char
+        hash = hash & hash
+    }
+    return Math.abs(hash).toString(16)
 }
 
 function cosineSimilarity(a: number[], b: number[]): number {

package/tests/intent-engine.test.ts

@@ -119,7 +119,7 @@ describe('ConflictDetector', () => {
             confidence: 0.8,
         }])
         // The "No direct DB access outside db/" constraint should fire
-        const dbConflict = result.conflicts.find(c =>
+        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