@getmikk/core 1.9.1 → 2.0.10

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,40 @@
 {
-    "name": "@getmikk/core",
-    "version": "1.9.1",
-    "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.10",
+  "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",
+      "types": "./dist/index.d.ts"
     }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "dev": "tsc --watch",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "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/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/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

@@ -137,12 +137,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,14 +52,16 @@ 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 '';
 
             const resolved = result.path.replace(/\\/g, '/');
@@ -70,14 +78,16 @@ export class OxcResolver {
         }
     }
 
+
     /** 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),
+            }))),
+        })));
     }
 }
+

package/src/parser/tree-sitter/parser.ts

@@ -5,14 +5,20 @@ import { BaseParser } from '../base-parser.js'
 import type { ParsedFile, ParsedFunction, ParsedClass, ParsedParam, ParsedImport } from '../types.js'
 import * as Queries from './queries.js'
 
-// Safely require web-tree-sitter via CJS
+// Safely require web-tree-sitter via CJS.
+// Wrapped in try/catch so that importing this module never throws when the
+// package is absent — callers receive an empty ParsedFile instead.
 const getRequire = () => {
     if (typeof require !== 'undefined') return require
     return createRequire(import.meta.url)
 }
 const _require = getRequire()
-const ParserModule = _require('web-tree-sitter')
-const Parser = ParserModule.Parser || ParserModule
+
+let Parser: any = null
+try {
+    const ParserModule = _require('web-tree-sitter')
+    Parser = ParserModule.Parser ?? ParserModule
+} catch { /* web-tree-sitter not installed — Parser stays null */ }
 
 // ---------------------------------------------------------------------------
 // Language-specific export visibility rules
@@ -150,6 +156,7 @@ export class TreeSitterParser extends BaseParser {
 
     private async init() {
         if (!this.parser) {
+            if (!Parser) return // web-tree-sitter not available
             await Parser.init()
             this.parser = new Parser()
         }
@@ -159,6 +166,12 @@ export class TreeSitterParser extends BaseParser {
         this.nameCounter.clear()
         await this.init()
         const ext = path.extname(filePath).toLowerCase()
+
+        if (!this.parser) {
+            // web-tree-sitter unavailable — return structurally valid empty file
+            return this.buildEmptyFile(filePath, content, ext)
+        }
+
         const config = await this.getLanguageConfig(ext)
 
         if (!config || !config.lang) {
@@ -224,7 +237,7 @@ export class TreeSitterParser extends BaseParser {
                     this.nameCounter.set(fnName, count)
 
                     // Unique ID: use stable format with counter for collisions
-                    let fnId = count === 1 ? `fn:${filePath}:${fnName}` : `fn:${filePath}:${fnName}#${count}`
+                    const fnId = count === 1 ? `fn:${filePath}:${fnName}` : `fn:${filePath}:${fnName}#${count}`
                     if (seenFnIds.has(fnId)) {
                         continue
                     }
@@ -345,7 +358,7 @@ export class TreeSitterParser extends BaseParser {
         }
     }
 
-    resolveImports(files: ParsedFile[], _projectRoot: string): ParsedFile[] {
+    async resolveImports(files: ParsedFile[], _projectRoot: string): Promise<ParsedFile[]> {
         // Tree-sitter resolver: no cross-file resolution implemented.
         // Imports are left with resolvedPath = '' which signals unresolved to the graph builder.
         // A future pass can resolve Go/Python/Java imports using language-specific rules.
@@ -472,9 +485,8 @@ function extractDocComment(content: string, startLine: number): string {
         // Walk back to find the first meaningful JSDoc line
         for (let i = targetIdx - 1; i >= 0; i--) {
             const line = lines[i].trim()
-            if (line.startsWith('/*') || line.startsWith('/**')) break
             const cleaned = line.replace(/^\*+\s?/, '')
-            if (cleaned && !/^[\-_=*]{3,}$/.test(cleaned)) return cleaned
+            if (cleaned && !/^[ \-_=*]{3,}$/.test(cleaned)) return cleaned
         }
     }
     return ''

package/src/parser/typescript/ts-parser.ts

@@ -24,7 +24,7 @@ export class TypeScriptParser extends BaseParser {
         }
     }
 
-    public resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+    public async resolveImports(files: ParsedFile[], projectRoot: string): Promise<ParsedFile[]> {
         const resolver = new TypeScriptResolver(projectRoot)
         return resolver.resolveBatch(files)
     }

package/tests/esm-resolver.test.ts

@@ -1,3 +1,4 @@
+
 import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
 import * as path from 'node:path'
 import * as fs from 'node:fs/promises'
@@ -49,19 +50,19 @@ describe('OxcResolver - ESM and CJS Resolution', () => {
         await fs.rm(FIXTURE_DIR, { recursive: true, force: true })
     })
 
-    it('resolves ESM exports correctly', () => {
+    it('resolves ESM exports correctly', async () => {
         const resolver = new OxcResolver(FIXTURE_DIR)
         
         // Resolve 'some-pkg' (should hit exports['.'].import)
-        const res = resolver.resolve('some-pkg', path.join(FIXTURE_DIR, 'index.ts'))
+        const res = await resolver.resolve('some-pkg', path.join(FIXTURE_DIR, 'index.ts'))
         expect(res).toContain('node_modules/some-pkg/dist/esm/index.js')
     })
 
-    it('resolves subpath exports correctly', () => {
+    it('resolves subpath exports correctly', async () => {
         const resolver = new OxcResolver(FIXTURE_DIR)
         
         // Resolve 'some-pkg/subpath'
-        const res = resolver.resolve('some-pkg/subpath', path.join(FIXTURE_DIR, 'index.ts'))
+        const res = await resolver.resolve('some-pkg/subpath', path.join(FIXTURE_DIR, 'index.ts'))
         expect(res).toContain('node_modules/some-pkg/dist/sub.js')
     })
 
@@ -69,7 +70,7 @@ describe('OxcResolver - ESM and CJS Resolution', () => {
         const resolver = new OxcResolver(FIXTURE_DIR)
         await fs.writeFile(path.join(FIXTURE_DIR, 'local.ts'), 'export const x = 1')
         
-        const res = resolver.resolve('./local', path.join(FIXTURE_DIR, 'index.ts'))
+        const res = await resolver.resolve('./local', path.join(FIXTURE_DIR, 'index.ts'))
         expect(res).toContain('.test-fixture-esm/local.ts')
     })
 })

package/tests/go-parser.test.ts

@@ -360,7 +360,7 @@ describe('GoParser', () => {
         const parser = new GoParser()
         const files = [await parser.parse('utils/format.go', TOPLEVEL_GO)]
         // Should not throw even without go.mod
-        const resolved = parser.resolveImports(files, '/tmp/no-gomod-' + Date.now())
+        const resolved = await parser.resolveImports(files, '/tmp/no-gomod-' + Date.now())
         expect(resolved.length).toBe(1)
     })
 })

package/tests/js-parser.test.ts

@@ -550,7 +550,7 @@ describe('JavaScriptParser', () => {
 
     test('resolveImports leaves external packages unresolved (empty resolvedPath)', async () => {
         const files = [await parser.parse('src/auth.js', CJS_MODULE)]
-        const resolved = parser.resolveImports(files, '/project')
+        const resolved = await parser.resolveImports(files, '/project')
         const file = resolved[0]
         const cryptoImp = file.imports.find((i: any) => i.source === 'crypto')
         expect(cryptoImp!.resolvedPath).toBe('')

package/tests/ts-parser.test.ts

@@ -57,7 +57,7 @@ describe('ts-parser config resolution', () => {
 
         // Parse and resolve imports
         const parsed = await parser.parse(filePath, await fs.readFile(filePath, 'utf-8'))
-        const resolved = parser.resolveImports([parsed], FIXTURE_DIR)[0]
+        const resolved = (await parser.resolveImports([parsed], FIXTURE_DIR))[0]
 
         const impApp = resolved.imports.find(i => i.source === '@app/local')
         expect(impApp?.resolvedPath).toBe(path.join(FIXTURE_DIR, 'src/app/local.ts').replace(/\\/g, '/'))