@getmikk/core 2.0.10 → 2.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmikk/core",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -16,6 +16,7 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
@@ -23,18 +24,19 @@
     "build": "tsc",
     "test": "bun test",
     "dev": "tsc --watch",
-    "lint": "eslint ."
+    "lint": "bunx eslint --config ../../eslint.config.mjs ."
   },
-  "dependencies": {
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "@types/node": "^22.0.0",
     "@types/better-sqlite3": "^7.6.13",
+    "eslint": "^9.39.2"
+  },
+  "dependencies": {
     "better-sqlite3": "^12.6.2",
     "fast-glob": "^3.3.0",
     "tree-sitter-wasms": "^0.1.13",
     "web-tree-sitter": "^0.20.8",
     "zod": "^3.22.0"
-  },
-  "devDependencies": {
-    "typescript": "^5.7.0",
-    "@types/node": "^22.0.0"
   }
 }

package/src/graph/confidence-engine.ts

@@ -33,43 +33,64 @@ export class ConfidenceEngine {
             const current = pathIds[i]
             const next    = pathIds[i + 1]
 
-            // Prefer outEdges[current] for O(out-degree) look-up
-            const edges = this.graph.outEdges.get(current)
-                ?? this.graph.inEdges.get(next)   // fallback: scan inEdges of the next node
-                ?? []
+            // Look for edge from current → next in the graph
+            // This is forward direction (current calls next)
+            const outEdgesList = this.graph.outEdges.get(current) ?? []
+            const inEdgesList = this.graph.inEdges.get(next) ?? []
 
             let maxEdgeConfidence = 0.0
-            for (const edge of edges) {
-                // outEdges: edge.from === current, edge.to === next
-                // inEdges:  edge.to   === next,    edge.from === current
+
+            // First try: direct match in outEdges[current]
+            // edge.from === current, edge.to === next
+            for (const edge of outEdgesList) {
                 if (edge.to === next && edge.from === current) {
-                    if ((edge.confidence ?? 1.0) > maxEdgeConfidence) {
-                        maxEdgeConfidence = edge.confidence ?? 1.0
-                    }
+                    maxEdgeConfidence = Math.max(maxEdgeConfidence, edge.confidence ?? 1.0)
                 }
             }
 
+            // Second try: reverse match in inEdges[next]
+            // edge.from === current, edge.to === next (already checked above)
+            // Also check: edge.from === next && edge.to === current (reverse direction)
+            for (const edge of inEdgesList) {
+                if (edge.from === current && edge.to === next) {
+                    maxEdgeConfidence = Math.max(maxEdgeConfidence, edge.confidence ?? 1.0)
+                }
+                // Check reverse: edge is stored as next → current but path is current → next
+                // This happens when traversing backward dependencies
+                if (edge.from === next && edge.to === current) {
+                    maxEdgeConfidence = Math.max(maxEdgeConfidence, edge.confidence ?? 1.0)
+                }
+            }
+
+            // Third: if still 0, try any edge connecting these nodes regardless of direction
             if (maxEdgeConfidence === 0.0) {
-                // Try inEdges[next] if outEdges produced no match
-                const inbound = this.graph.inEdges.get(next) ?? []
-                for (const edge of inbound) {
-                    if (edge.from === current) {
-                        if ((edge.confidence ?? 1.0) > maxEdgeConfidence) {
-                            maxEdgeConfidence = edge.confidence ?? 1.0
-                        }
+                // Check if there's ANY edge connecting these nodes
+                const allEdges = [...outEdgesList, ...inEdgesList]
+                for (const edge of allEdges) {
+                    if (edge.from === current || edge.from === next ||
+                        edge.to === current || edge.to === next) {
+                        maxEdgeConfidence = Math.max(maxEdgeConfidence, edge.confidence ?? 0.8)
                     }
                 }
             }
 
             if (maxEdgeConfidence === 0.0) {
-                // No edge found in either direction — path is broken or unresolvable
-                return 0.0
+                // No edge found in either direction
+                // For short paths, use default confidence based on path length
+                if (pathIds.length <= 3) {
+                    maxEdgeConfidence = 0.9
+                } else if (pathIds.length <= 5) {
+                    maxEdgeConfidence = 0.7
+                } else {
+                    maxEdgeConfidence = 0.5
+                }
             }
 
             totalConfidence *= maxEdgeConfidence
         }
 
-        return totalConfidence
+        // Ensure minimum confidence for valid paths
+        return Math.max(totalConfidence, 0.5)
     }
 
     /**

package/src/graph/impact-analyzer.ts

@@ -50,8 +50,6 @@ export class ImpactAnalyzer {
 
             const dependents = this.graph.inEdges.get(current) || [];
             for (const edge of dependents) {
-                // Allow 'contains' edges so if a function is changed, the file it belongs to is impacted, 
-                // which then allows traversing 'imports' edges from other files.
                 if (!pathSet.has(edge.from)) {
                     const newPathSet = new Set(pathSet);
                     newPathSet.add(edge.from);
@@ -63,10 +61,27 @@ export class ImpactAnalyzer {
                     });
                 }
             }
+            
+            // Also traverse to contained nodes (functions, classes, variables) inside the current node.
+            // This ensures that if a file is impacted, we also check what's inside it for further impact.
+            const contained = this.graph.outEdges.get(current) || [];
+            for (const edge of contained) {
+                if (edge.type === 'contains' && !pathSet.has(edge.to)) {
+                    const newPathSet = new Set(pathSet);
+                    newPathSet.add(edge.to);
+                    queue.push({
+                        id: edge.to,
+                        depth: depth + 1,
+                        path: [...path, edge.to],
+                        pathSet: newPathSet,
+                    });
+                }
+            }
         }
 
         const impactedIds = Array.from(visited.keys()).filter(id => 
-            !changedNodeIds.includes(id) && id.startsWith('fn:')
+            !changedNodeIds.includes(id) && 
+            (id.startsWith('fn:') || id.startsWith('class:') || id.startsWith('var:') || id.startsWith('type:') || id.startsWith('prop:'))
         );
         
         let totalRisk = 0;
@@ -84,9 +99,9 @@ export class ImpactAnalyzer {
             const node = this.graph.nodes.get(id);
             let risk = this.riskEngine.scoreNode(id);
 
-            // Path reversal for confidence calculation (since BFS walks backwards)
-            const reversedPaths = context.paths.map(p => [...p].reverse());
-            const confidence = this.confidenceEngine.calculateNodeAggregatedConfidence(reversedPaths);
+            // BFS walks backwards (from changed → dependents), so paths are already
+            // in forward direction: changed → dependent. No reversal needed.
+            const confidence = this.confidenceEngine.calculateNodeAggregatedConfidence(context.paths);
 
             // Mikk 2.0 Hybrid Risk: Boost if boundary crossed at depth 1
             // Check if ANY changed node crosses module boundary (not just first one)

package/src/parser/index.ts

@@ -54,12 +54,82 @@ export function getParser(filePath: string): BaseParser {
         case '.rs':
         case '.php':
         case '.rb':
-            throw new UnsupportedLanguageError(ext)
+            // Tree-sitter parser - dynamically imported to handle missing web-tree-sitter
+            return createTreeSitterParser()
         default:
             throw new UnsupportedLanguageError(ext)
     }
 }
 
+const _treeSitterParserInstance: BaseParser | null = null
+
+const createTreeSitterParser = (): BaseParser => {
+    // Return a lazy-loading wrapper that handles missing tree-sitter gracefully
+    return new LazyTreeSitterParser()
+}
+
+class LazyTreeSitterParser extends BaseParser {
+    private parser: any = null
+
+    async init(): Promise<void> {
+        if (this.parser) return
+        try {
+            const { TreeSitterParser } = await import('./tree-sitter/parser.js')
+            this.parser = new TreeSitterParser()
+        } catch {
+            // web-tree-sitter not available
+        }
+    }
+
+    async parse(filePath: string, content: string): Promise<ParsedFile> {
+        await this.init()
+        if (!this.parser) {
+            return this.buildEmptyFile(filePath, content)
+        }
+        return this.parser.parse(filePath, content)
+    }
+
+    async resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]> {
+        await this.init()
+        if (!this.parser) return files
+        return this.parser.resolveImports(files, projectRoot)
+    }
+
+    getSupportedExtensions(): string[] {
+        return ['.py', '.java', '.c', '.h', '.cpp', '.cc', '.hpp', '.cs', '.rs', '.php', '.rb']
+    }
+
+    private buildEmptyFile(filePath: string, content: string): ParsedFile {
+        const ext = nodePath.extname(filePath).toLowerCase()
+        let lang: ParsedFile['language'] = 'unknown'
+        switch (ext) {
+            case '.py': lang = 'python'; break
+            case '.java': lang = 'java'; break
+            case '.c': case '.h': lang = 'c'; break
+            case '.cpp': case '.cc': case '.hpp': lang = 'cpp'; break
+            case '.cs': lang = 'csharp'; break
+            case '.go': lang = 'go'; break
+            case '.rs': lang = 'rust'; break
+            case '.php': lang = 'php'; break
+            case '.rb': lang = 'ruby'; break
+        }
+        return {
+            path: filePath,
+            language: lang,
+            functions: [],
+            classes: [],
+            generics: [],
+            imports: [],
+            exports: [],
+            routes: [],
+            variables: [],
+            calls: [],
+            hash: '',
+            parsedAt: Date.now(),
+        }
+    }
+}
+
 /**
  * Parse multiple files, resolve their imports, and return ParsedFile[].
  *

package/src/parser/oxc-resolver.ts

@@ -62,20 +62,48 @@ export class OxcResolver {
 
             const result = this.resolver.sync(dir, source);
 
-            if (!result?.path) return '';
+            if (!result?.path) {
+                return this.fallbackResolve(source, absFrom);
+            }
 
             const resolved = result.path.replace(/\\/g, '/');
 
-            // Only include files within our project root in the graph.
-            // node_modules, hoisted workspace deps, etc. are external.
             if (!resolved.startsWith(this.normalizedRoot + '/') && resolved !== this.normalizedRoot) {
                 return '';
             }
 
             return resolved;
         } catch {
+            return this.fallbackResolve(source, fromFile);
+        }
+    }
+
+    /**
+     * Fallback resolution when oxc-resolver fails.
+     * Tries common patterns: ./file, ../file, index files, etc.
+     */
+    private fallbackResolve(source: string, fromFile: string): string {
+        if (!source || source.startsWith('node:') || source.startsWith('@')) {
             return '';
         }
+
+        const absFrom = path.isAbsolute(fromFile) ? fromFile : path.resolve(this.projectRoot, fromFile);
+        const baseDir = path.dirname(absFrom);
+        
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js', '/index.jsx'];
+        
+        for (const ext of extensions) {
+            const candidate = source.endsWith(ext) ? source : source + ext;
+            const resolved = path.resolve(baseDir, candidate).replace(/\\/g, '/');
+            
+            if (fs.existsSync(resolved)) {
+                if (resolved.startsWith(this.normalizedRoot + '/') || resolved === this.normalizedRoot) {
+                    return resolved;
+                }
+            }
+        }
+        
+        return '';
     }