@getmikk/intent-engine 1.3.1 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@getmikk/intent-engine",
-    "version": "1.3.1",
+    "version": "1.5.0",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -21,7 +21,7 @@
         "dev": "tsc --watch"
     },
     "dependencies": {
-        "@getmikk/core": "^1.3.1",
+        "@getmikk/core": "^1.5.0",
         "zod": "^3.22.0"
     },
     "devDependencies": {

package/src/interpreter.ts

@@ -45,16 +45,51 @@ export class IntentInterpreter {
             actions.push('modify')
         }
 
-        // Find the best matching target — try functions first, then modules
+        // Find the best matching target — try functions first, then classes, then modules
         const matchedFunctions = this.findMatchingFunctions(prompt)
+        const matchedClasses = this.findMatchingClasses(prompt)
         const matchedModule = this.findMatchingModule(prompt)
 
+        // If prompt mentions "class" and we have a class match, prefer class-level targeting
+        const prefersClass = promptLower.includes('class') && matchedClasses.length > 0
+
         for (const action of actions) {
-            if (matchedFunctions.length > 0) {
+            let resolvedAction = action
+
+            // Smart reclassification:
+            // - If action is "create" but a SPECIFIC FUNCTION already matches → "modify"
+            //   (e.g., "add error handling to createZap" where createZap exists)
+            // - Module-level matches are NOT reclassified — creating new things
+            //   in existing modules is valid (e.g., "create a new auth handler")
+            if (action === 'create') {
+                if (matchedFunctions.length > 0 && matchedFunctions[0].score >= 0.5) {
+                    resolvedAction = 'modify'
+                }
+                if (matchedClasses.length > 0 && matchedClasses[0].score >= 0.5) {
+                    resolvedAction = 'modify'
+                }
+            }
+
+            if (prefersClass) {
+                // User explicitly mentioned "class" — target class-level
+                for (const cls of matchedClasses.slice(0, 3)) {
+                    intents.push({
+                        action: resolvedAction,
+                        target: {
+                            type: 'class',
+                            name: cls.name,
+                            moduleId: cls.moduleId,
+                            filePath: cls.file,
+                        },
+                        reason: prompt,
+                        confidence: cls.score,
+                    })
+                }
+            } else if (matchedFunctions.length > 0) {
                 // Create an intent for each matched function (up to 3)
                 for (const fn of matchedFunctions.slice(0, 3)) {
                     intents.push({
-                        action,
+                        action: resolvedAction,
                         target: {
                             type: 'function',
                             name: fn.name,
@@ -67,7 +102,7 @@ export class IntentInterpreter {
                 }
             } else if (matchedModule) {
                 intents.push({
-                    action,
+                    action: resolvedAction,
                     target: {
                         type: 'module',
                         name: matchedModule.name,
@@ -79,7 +114,7 @@ export class IntentInterpreter {
             } else {
                 // No match — use extracted name
                 intents.push({
-                    action,
+                    action: resolvedAction,
                     target: {
                         type: this.inferTargetType(prompt),
                         name: this.extractName(prompt),
@@ -90,7 +125,19 @@ export class IntentInterpreter {
             }
         }
 
-        return intents
+        // Deduplicate: if both "create" (reclassified to "modify") and "modify" exist
+        // for the same target, keep only one
+        const deduped: Intent[] = []
+        const seen = new Set<string>()
+        for (const intent of intents) {
+            const key = `${intent.action}:${intent.target.name}:${intent.target.moduleId || ''}`
+            if (!seen.has(key)) {
+                seen.add(key)
+                deduped.push(intent)
+            }
+        }
+
+        return deduped
     }
 
     // ── Fuzzy Matching ───────────────────────────────────────────
@@ -100,7 +147,19 @@ export class IntentInterpreter {
         const keywords = this.extractKeywords(prompt)
         const results: Array<{ name: string; file: string; moduleId: string; score: number }> = []
 
-        for (const fn of Object.values(this.lock.functions)) {
+        // Pre-compute keyword frequency across all function names for IDF-like penalization.
+        // A keyword that matches many functions is less discriminative.
+        const allFns = Object.values(this.lock.functions)
+        const keywordFreq = new Map<string, number>()
+        for (const kw of keywords) {
+            let count = 0
+            for (const fn of allFns) {
+                if (fn.name.toLowerCase().includes(kw)) count++
+            }
+            keywordFreq.set(kw, count)
+        }
+
+        for (const fn of allFns) {
             let score = 0
             const fnNameLower = fn.name.toLowerCase()
             const fileLower = fn.file.toLowerCase()
@@ -110,19 +169,39 @@ export class IntentInterpreter {
                 score += 0.9
             }
 
-            // Keyword matches in function name
+            // Keyword matches in function name — penalize if keyword is too common
             for (const kw of keywords) {
-                if (fnNameLower.includes(kw)) score += 0.3
-                if (fileLower.includes(kw)) score += 0.15
+                const freq = keywordFreq.get(kw) || 0
+                // IDF-like penalization: if a keyword matches >40% of functions, reduce weight
+                const idfPenalty = freq > allFns.length * 0.4 ? 0.3 : 1.0
+                // Short keywords (3-4 chars) get reduced weight: "file" matches too many things
+                const lengthPenalty = kw.length <= 4 ? 0.5 : 1.0
+
+                const kwWeight = 0.3 * idfPenalty * lengthPenalty
+
+                if (fnNameLower.includes(kw)) score += kwWeight
+                if (fileLower.includes(kw)) score += 0.15 * idfPenalty * lengthPenalty
             }
 
-            // CamelCase decomposition partial matches
+            // CamelCase decomposition — compound matches worth more
             const fnWords = this.splitCamelCase(fn.name).map(w => w.toLowerCase())
+            let camelMatchCount = 0
             for (const kw of keywords) {
                 if (fnWords.some(w => w.startsWith(kw) || kw.startsWith(w))) {
-                    score += 0.2
+                    camelMatchCount++
                 }
             }
+            // Multi-word compound matches are more meaningful
+            if (camelMatchCount >= 2) {
+                score += 0.4  // Strong multi-word match
+            } else if (camelMatchCount === 1) {
+                const freq = keywords.length > 0
+                    ? keywordFreq.get(keywords.find(kw =>
+                        fnWords.some(w => w.startsWith(kw) || kw.startsWith(w))) || '') || 0
+                    : 0
+                const idfPenalty = freq > allFns.length * 0.4 ? 0.3 : 1.0
+                score += 0.2 * idfPenalty
+            }
 
             // Cap score at 1.0
             if (score > 0.3) {
@@ -167,6 +246,47 @@ export class IntentInterpreter {
         return bestMatch && bestMatch.score > 0.3 ? bestMatch : null
     }
 
+    private findMatchingClasses(prompt: string): Array<{ name: string; file: string; moduleId: string; score: number }> {
+        if (!this.lock.classes) return []
+        const promptLower = prompt.toLowerCase()
+        const keywords = this.extractKeywords(prompt)
+        const results: Array<{ name: string; file: string; moduleId: string; score: number }> = []
+
+        for (const cls of Object.values(this.lock.classes)) {
+            let score = 0
+            const clsNameLower = cls.name.toLowerCase()
+
+            // Exact class name match in prompt → very high score
+            if (promptLower.includes(clsNameLower) && clsNameLower.length > 3) {
+                score += 0.95  // Classes get slightly higher score than functions when explicitly named
+            }
+
+            // Keyword matches against class name
+            for (const kw of keywords) {
+                if (clsNameLower.includes(kw)) score += 0.3
+            }
+
+            // CamelCase decomposition
+            const clsWords = this.splitCamelCase(cls.name).map(w => w.toLowerCase())
+            for (const kw of keywords) {
+                if (clsWords.some(w => w.startsWith(kw) || kw.startsWith(w))) {
+                    score += 0.2
+                }
+            }
+
+            if (score > 0.3) {
+                results.push({
+                    name: cls.name,
+                    file: cls.file,
+                    moduleId: cls.moduleId,
+                    score: Math.min(score, 1.0),
+                })
+            }
+        }
+
+        return results.sort((a, b) => b.score - a.score)
+    }
+
     // ── Helpers ───────────────────────────────────────────────────
 
     private inferTargetType(prompt: string): Intent['target']['type'] {
@@ -186,8 +306,13 @@ export class IntentInterpreter {
         const code = prompt.match(/`([^`]+)`/)
         if (code) return code[1]
 
-        // Fall back to last meaningful word
-        const words = prompt.split(/\s+/).filter(w => w.length > 2)
+        // Prefer CamelCase/PascalCase identifiers (likely code names)
+        const camelCase = prompt.match(/\b([a-z]+[A-Z][a-zA-Z]*|[A-Z][a-z]+[A-Z][a-zA-Z]*)\b/)
+        if (camelCase) return camelCase[1]
+
+        // Filter out structural words from the last word fallback
+        const structuralWords = new Set(['function', 'class', 'method', 'module', 'file', 'route', 'endpoint', 'handler', 'component', 'service', 'package'])
+        const words = prompt.split(/\s+/).filter(w => w.length > 2 && !structuralWords.has(w.toLowerCase()))
         return words[words.length - 1] || 'unknown'
     }
 
@@ -198,6 +323,8 @@ export class IntentInterpreter {
             'add', 'create', 'modify', 'change', 'update', 'delete', 'remove',
             'fix', 'move', 'refactor', 'new', 'old', 'all', 'this', 'that',
             'should', 'can', 'will', 'must', 'need', 'want', 'please',
+            'function', 'method', 'class', 'module', 'file', 'package',
+            'endpoint', 'route', 'handler', 'component', 'service',
         ])
         return text
             .toLowerCase()

package/src/preflight.ts

@@ -31,14 +31,29 @@ export class PreflightPipeline {
         // 2. Check for conflicts
         const conflicts = this.conflictDetector.detect(intents)
 
-        // 3. Generate suggestions
+        // 3. Low-confidence rejection: if the best intent has very low confidence,
+        //    add a warning so the AI doesn't blindly proceed
+        const maxConfidence = intents.length > 0
+            ? Math.max(...intents.map(i => i.confidence))
+            : 0
+        if (maxConfidence < 0.4 && intents.length > 0) {
+            conflicts.conflicts.push({
+                type: 'low-confidence',
+                severity: 'warning',
+                message: `Low confidence (${(maxConfidence * 100).toFixed(0)}%) — the intent could not be reliably matched to existing code. The suggestion may be inaccurate.`,
+                relatedIntent: intents[0],
+                suggestedFix: 'Be more specific about the function or module name in your prompt.',
+            })
+        }
+
+        // 4. Generate suggestions
         const suggestions = this.suggester.suggest(intents)
 
         return {
             intents,
             conflicts,
             suggestions,
-            approved: !conflicts.hasConflicts,
+            approved: !conflicts.hasConflicts && maxConfidence >= 0.4,
         }
     }
 }

package/src/suggester.ts

@@ -54,6 +54,21 @@ export class Suggester {
             case 'delete': {
                 if (intent.target.filePath) {
                     affectedFiles.push(intent.target.filePath)
+                } else if (intent.target.type === 'function') {
+                    // Only delete the specific function, not the whole module
+                    const fn = Object.values(this.lock.functions).find(
+                        f => f.name === intent.target.name
+                    )
+                    if (fn) {
+                        affectedFiles.push(fn.file)
+                        // Add callers that will need updating
+                        for (const callerId of fn.calledBy) {
+                            const caller = this.lock.functions[callerId]
+                            if (caller && !affectedFiles.includes(caller.file)) {
+                                affectedFiles.push(caller.file)
+                            }
+                        }
+                    }
                 }
                 break
             }

package/src/types.ts

@@ -22,7 +22,7 @@ export interface ConflictResult {
 }
 
 export interface Conflict {
-    type: 'constraint-violation' | 'ownership-conflict' | 'boundary-crossing' | 'missing-dependency'
+    type: 'constraint-violation' | 'ownership-conflict' | 'boundary-crossing' | 'missing-dependency' | 'low-confidence'
     severity: 'error' | 'warning'
     message: string
     relatedIntent: Intent