@getmikk/core 2.0.0 → 2.0.11

package/CHANGELOG.md

@@ -0,0 +1,37 @@
+# @getmikk/core
+
+## 2.0.4
+
+### Patch Changes
+
+- 1217e39: chore: synchronize all packages to v2.0.1 and finalize release infrastructure.
+
+## 2.0.3
+
+### Patch Changes
+
+- 06a410b: chore: synchronize monorepo to v2.0.1 and finalize release infrastructure.
+
+## 2.0.2
+
+### Patch Changes
+
+- 5dfe317: test
+- 9118944: test
+- 36bbb2f: test
+- fe8ac06: chore: synchronize all packages to v2.0.1 and finalize release infrastructure.
+- b00faed: test
+
+## 2.0.1
+
+### Patch Changes
+
+- bd5c050: 2.0.1
+- ff1444f: Use dynamic import for oxc-parser to support ESM-only versions (0.121.0+)
+- 0ccbf45: 2.0.1
+
+## 3.0.0
+
+### Major Changes
+
+- 568a3d5: 2.0.0

package/package.json

@@ -1,38 +1,42 @@
 {
-    "name": "@getmikk/core",
-    "version": "2.0.0",
-    "license": "Apache-2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Ansh-dhanani/mikk"
-    },
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./dist/index.js",
-            "types": "./dist/index.d.ts"
-        }
-    },
-    "scripts": {
-        "build": "tsc",
-        "test": "bun test",
-        "dev": "tsc --watch"
-    },
-    "dependencies": {
-        "@types/better-sqlite3": "^7.6.13",
-        "better-sqlite3": "^12.6.2",
-        "fast-glob": "^3.3.0",
-        "oxc-parser": "^0.121.0",
-        "oxc-resolver": "^11.19.1",
-        "tree-sitter-wasms": "^0.1.13",
-        "web-tree-sitter": "0.20.8",
-        "zod": "^3.22.0",
-        "typescript": "^5.7.0"
-    },
-    "devDependencies": {
-        "@types/bun": "^1.3.10",
-        "@types/node": "^22.0.0"
+  "name": "@getmikk/core",
+  "version": "2.0.11",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ansh-dhanani/mikk"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "dev": "tsc --watch",
+    "lint": "bunx eslint --config ../../eslint.config.mjs ."
+  },
+  "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"
+  }
 }

package/src/graph/cluster-detector.ts

@@ -600,7 +600,7 @@ export class ClusterDetector {
             const split = id
                 .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
                 .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-                .split(/[\s_\-\.]+/)
+                .split(/[\s_\-.]+/)
                 .map(w => w.toLowerCase())
                 .filter(w => w.length > 1)
             words.push(...split)

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/base-parser.ts

@@ -9,7 +9,7 @@ export abstract class BaseParser {
     abstract parse(filePath: string, content: string): Promise<ParsedFile>
 
     /** Given a list of parsed files, resolve all import paths to absolute project paths */
-    abstract resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[]
+    abstract resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]>
 
     /** Returns which file extensions this parser handles */
     abstract getSupportedExtensions(): string[]

package/src/parser/go/go-extractor.ts

@@ -523,7 +523,7 @@ function parseImportLine(line: string): ParsedImport | null {
  * Statefully track brace depth through content, handling:
  *  - string literals ("...", `...`), rune literals ('.')
  *  - line comments (//)
- *  - block comments (/* ... *​/)
+ *  - block comments (/* ... * /)
  */
 function findBodyBounds(lines: string[], startLine: number): { bodyStart: number; bodyEnd: number } {
     let braceDepth = 0

package/src/parser/go/go-parser.ts

@@ -29,7 +29,7 @@ export class GoParser extends BaseParser {
         }
     }
 
-    resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+    async resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]> {
         const resolver = new GoResolver(projectRoot)
         return files.map(file => ({
             ...file,

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[].
  *
@@ -137,12 +207,12 @@ export async function parseFiles(
     let resolvedTreeFiles: ParsedFile[] = treeFiles
     if (treeFiles.length > 0) {
         const treeParser = treeSitterParser ?? await getTreeSitter()
-        resolvedTreeFiles = treeParser.resolveImports(treeFiles, normalizedRoot)
+        resolvedTreeFiles = await treeParser.resolveImports(treeFiles, normalizedRoot)
     }
 
     const resolved: ParsedFile[] = [
-        ...oxcParser.resolveImports(oxcFiles, normalizedRoot),
-        ...goParser.resolveImports(goFiles, normalizedRoot),
+        ...await oxcParser.resolveImports(oxcFiles, normalizedRoot),
+        ...await goParser.resolveImports(goFiles, normalizedRoot),
         ...resolvedTreeFiles,
     ]
 

package/src/parser/javascript/js-parser.ts

@@ -55,7 +55,7 @@ export class JavaScriptParser extends BaseParser {
         }
     }
 
-    resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+    async resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]> {
         const aliases = loadAliases(projectRoot)
         // Only pass the file list when it represents a reasonably complete scan.
         // A sparse list (< MIN_FILES_FOR_COMPLETE_SCAN files) causes valid alias-resolved

package/src/parser/oxc-parser.ts

@@ -1,5 +1,4 @@
 import path from 'node:path';
-import { parseSync } from 'oxc-parser';
 import { BaseParser } from './base-parser.js';
 import { OxcResolver } from './oxc-resolver.js';
 import { hashContent } from '../hash/file-hasher.js';
@@ -283,6 +282,7 @@ export class OxcParser extends BaseParser {
 
         let ast: any;
         try {
+            const { parseSync } = await import('oxc-parser');
             const result = parseSync(filePath, content, {
                 sourceType: 'module',
                 lang: isTS ? 'ts' : 'js',
@@ -389,8 +389,8 @@ export class OxcParser extends BaseParser {
                             const key = member.key;
                             if (!key) continue;
                             const mName = key.type === 'Identifier' ? key.name :
-                                          key.type === 'PrivateIdentifier' ? `#${key.name}` :
-                                          null;
+                                key.type === 'PrivateIdentifier' ? `#${key.name}` :
+                                    null;
                             if (!mName) continue;
 
                             if (member.type === 'MethodDefinition') {
@@ -613,7 +613,7 @@ export class OxcParser extends BaseParser {
                         const callExpr = node.expression;
                         const calls = extractCalls(callExpr, lineIndex);
                         moduleCalls.push(...calls);
-                        
+
                         // Route detection
                         const callee = callExpr.callee;
                         if (callee && (callee.type === 'StaticMemberExpression' || callee.type === 'MemberExpression')) {
@@ -624,14 +624,14 @@ export class OxcParser extends BaseParser {
                                 const pathArg = args[0];
                                 if (pathArg && (pathArg.type === 'StringLiteral' || pathArg.type === 'Literal' || pathArg.type === 'TemplateLiteral')) {
                                     const pathVal = pathArg.value || (pathArg.quasis && pathArg.quasis[0]?.value?.raw) || '';
-                                    
+
                                     const handlerArg = args[args.length - 1];
                                     const handlerStr = handlerArg ? content.slice(getSpan(handlerArg).start, getSpan(handlerArg).end).replace(/\s+/g, ' ').trim() : 'unknown';
-                                    
-                                    const middlewares = args.slice(1, -1).map((a: any) => 
+
+                                    const middlewares = args.slice(1, -1).map((a: any) =>
                                         content.slice(getSpan(a).start, getSpan(a).end).replace(/\s+/g, ' ').trim()
                                     );
-                                    
+
                                     routes.push({
                                         method: propName.toUpperCase() as any,
                                         path: String(pathVal),
@@ -680,9 +680,9 @@ export class OxcParser extends BaseParser {
         };
     }
 
-    public resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+    public async resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]> {
         const resolver = new OxcResolver(projectRoot);
-        return resolver.resolveBatch(files);
+        return await resolver.resolveBatch(files);
     }
 
     public getSupportedExtensions(): string[] {

package/src/parser/oxc-resolver.ts

@@ -1,8 +1,9 @@
-import { ResolverFactory } from 'oxc-resolver';
+
 import path from 'node:path';
 import fs from 'node:fs';
 import type { ParsedFile } from './types.js';
 
+
 /**
  * OxcResolver — Rust-backed compiler-grade module resolution.
  *
@@ -21,10 +22,15 @@ export class OxcResolver {
     private resolver: any;
     private readonly normalizedRoot: string;
 
+
     constructor(private readonly projectRoot: string) {
         this.normalizedRoot = path.resolve(projectRoot).replace(/\\/g, '/');
+    }
 
-        const tsconfigPath = path.resolve(projectRoot, 'tsconfig.json');
+    private async ensureResolver() {
+        if (this.resolver) return;
+        const { ResolverFactory } = await import('oxc-resolver');
+        const tsconfigPath = path.resolve(this.projectRoot, 'tsconfig.json');
         const hasTsConfig = fs.existsSync(tsconfigPath);
 
         this.resolver = new ResolverFactory({
@@ -46,38 +52,70 @@ export class OxcResolver {
      * fromFile MUST be an absolute path (as produced by parseFiles).
      * Returns an absolute posix path, or '' if unresolvable/external.
      */
-    public resolve(source: string, fromFile: string): string {
+    public async resolve(source: string, fromFile: string): Promise<string> {
         try {
+            await this.ensureResolver();
             const absFrom = path.isAbsolute(fromFile)
                 ? fromFile
                 : path.resolve(this.projectRoot, fromFile);
             const dir = path.dirname(absFrom);
 
             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 '';
     }
 
+
     /** Resolve all imports for a batch of files in one pass */
-    public resolveBatch(files: ParsedFile[]): ParsedFile[] {
-        return files.map(file => ({
+    public async resolveBatch(files: ParsedFile[]): Promise<ParsedFile[]> {
+        return Promise.all(files.map(async file => ({
             ...file,
-            imports: file.imports.map(imp => ({
+            imports: await Promise.all(file.imports.map(async imp => ({
                 ...imp,
-                resolvedPath: this.resolve(imp.source, file.path),
-            })),
-        }));
+                resolvedPath: await this.resolve(imp.source, file.path),
+            }))),
+        })));
     }
 }
+