@getmikk/core 1.7.1 → 1.8.1

package/src/utils/minimatch.ts

@@ -1,19 +1,28 @@
 /**
- * Simple minimatch-like glob matching utility.
- * Supports ** (any depth directory) and * (wildcard) patterns.
+ * minimatch — glob matching with plain-path prefix fallback.
+ *
+ * Rules:
+ *   - Pattern with no glob chars (*, ?, {, [) → directory prefix match
+ *     "src/auth" matches "src/auth/jwt.ts" and "src/auth" itself
+ *   - "**" matches any depth
+ *   - "*"  matches within a single directory segment
  */
 export function minimatch(filePath: string, pattern: string): boolean {
-    // Normalize both to forward slashes
-    const normalizedPath = filePath.replace(/\\/g, '/')
-    const normalizedPattern = pattern.replace(/\\/g, '/')
+  const normalizedPath = filePath.replace(/\\/g, '/')
+  const normalizedPattern = pattern.replace(/\\/g, '/')
 
-    // Convert glob pattern to regex
-    const regexStr = normalizedPattern
-        .replace(/\./g, '\\.')
-        .replace(/\*\*\//g, '(?:.+/)?')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
+  // Plain path (no glob chars) → prefix match
+  if (!/[*?{[]/.test(normalizedPattern)) {
+    const bare = normalizedPattern.replace(/\/$/, '')
+    return normalizedPath === bare || normalizedPath.startsWith(bare + '/')
+  }
 
-    const regex = new RegExp(`^${regexStr}$`)
-    return regex.test(normalizedPath)
-}
+  // Convert glob to regex
+  const regexStr = normalizedPattern
+    .replace(/\./g, '\\.')
+    .replace(/\*\*\//g, '(?:.+/)?')
+    .replace(/\*\*/g, '.*')
+    .replace(/\*/g, '[^/]*')
+
+  return new RegExp(`^${regexStr}$`).test(normalizedPath)
+}

package/tests/go-parser.test.ts

@@ -320,9 +320,9 @@ describe('GoParser', () => {
         expect(parser.getSupportedExtensions()).toContain('.go')
     })
 
-    test('parse returns a well-formed ParsedFile', () => {
+    test('parse returns a well-formed ParsedFile', async () => {
         const parser = new GoParser()
-        const result = parser.parse('auth/service.go', SIMPLE_GO)
+        const result = await parser.parse('auth/service.go', SIMPLE_GO)
         expect(result.path).toBe('auth/service.go')
         expect(result.language).toBe('go')
         expect(Array.isArray(result.functions)).toBe(true)
@@ -334,31 +334,31 @@ describe('GoParser', () => {
         expect(result.hash.length).toBeGreaterThan(0)
     })
 
-    test('parse populates functions from a real Go service', () => {
+    test('parse populates functions from a real Go service', async () => {
         const parser = new GoParser()
-        const result = parser.parse('auth/service.go', SIMPLE_GO)
+        const result = await parser.parse('auth/service.go', SIMPLE_GO)
         // Top-level funcs: hashPassword, keyFunc
         expect(result.functions.some(f => f.name === 'hashPassword')).toBe(true)
         expect(result.functions.some(f => f.name === 'keyFunc')).toBe(true)
     })
 
-    test('parse populates classes for structs with methods', () => {
+    test('parse populates classes for structs with methods', async () => {
         const parser = new GoParser()
-        const result = parser.parse('auth/service.go', SIMPLE_GO)
+        const result = await parser.parse('auth/service.go', SIMPLE_GO)
         const authService = result.classes.find(c => c.name === 'AuthService')
         expect(authService).toBeDefined()
         expect(authService!.methods.length).toBeGreaterThan(0)
     })
 
-    test('parse detects routes in a Gin router file', () => {
+    test('parse detects routes in a Gin router file', async () => {
         const parser = new GoParser()
-        const result = parser.parse('api/routes.go', ROUTES_GO)
+        const result = await parser.parse('api/routes.go', ROUTES_GO)
         expect(result.routes.length).toBeGreaterThanOrEqual(4)
     })
 
-    test('resolveImports passes through without crashing on no go.mod', () => {
+    test('resolveImports passes through without crashing on no go.mod', async () => {
         const parser = new GoParser()
-        const files = [parser.parse('utils/format.go', TOPLEVEL_GO)]
+        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())
         expect(resolved.length).toBe(1)

package/tests/js-parser.test.ts

@@ -468,6 +468,21 @@ describe('JavaScriptExtractor', () => {
             const greetExports = exports.filter(e => e.name === 'greet')
             expect(greetExports.length).toBe(1)
         })
+
+        test('malformed code gracefully degrades without crashing', () => {
+            const malformed = `
+                function breakMe() {
+                    const x = 
+                    if (true) {
+                // missing braces, missing assignments
+            `
+            const ext = new JavaScriptExtractor('src/malformed.js', malformed)
+            // TS compiler API is very fault tolerant, so it might extract breakMe anyway, 
+            // but the key assertion is that it doesn't throw.
+            expect(() => ext.extractFunctions()).not.toThrow()
+            const fn = ext.extractFunctions().find(f => f.name === 'breakMe')
+            expect(fn).toBeDefined()
+        })
     })
 })
 
@@ -482,47 +497,47 @@ describe('JavaScriptParser', () => {
         expect(exts).toContain('.jsx')
     })
 
-    test('parse returns language: javascript', () => {
-        const result = parser.parse('src/index.js', CJS_MODULE)
+    test('parse returns language: javascript', async () => {
+        const result = await parser.parse('src/index.js', CJS_MODULE)
         expect(result.language).toBe('javascript')
     })
 
-    test('parse includes hash and parsedAt', () => {
-        const result = parser.parse('src/index.js', CJS_MODULE)
+    test('parse includes hash and parsedAt', async () => {
+        const result = await parser.parse('src/index.js', CJS_MODULE)
         expect(typeof result.hash).toBe('string')
         expect(result.hash.length).toBe(64) // SHA-256 hex
         expect(typeof result.parsedAt).toBe('number')
     })
 
-    test('CJS-exported functions are marked isExported via cross-reference', () => {
-        const result = parser.parse('src/auth.js', CJS_MODULE)
-        const hashPw = result.functions.find(f => f.name === 'hashPassword')
+    test('CJS-exported functions are marked isExported via cross-reference', async () => {
+        const result = await parser.parse('src/auth.js', CJS_MODULE)
+        const hashPw = result.functions.find((f: any) => f.name === 'hashPassword')
         expect(hashPw).toBeDefined()
         expect(hashPw!.isExported).toBe(true)
     })
 
-    test('resolveImports resolves relative paths with .js extension probing', () => {
-        const files = [
+    test('resolveImports resolves relative paths with .js extension probing', async () => {
+        const files = await Promise.all([
             parser.parse('src/auth.js', CJS_MODULE),
             parser.parse('src/loader.js', ESM_MODULE),
-        ]
+        ])
         const resolved = parser.resolveImports(files, '/project')
-        const authFile = resolved.find(f => f.path === 'src/auth.js')!
-        const dbImport = authFile.imports.find(i => i.source === './db')
+        const authFile = resolved.find((f: any) => f.path === 'src/auth.js')!
+        const dbImport = authFile.imports.find((i: any) => i.source === './db')
         expect(dbImport!.resolvedPath).toMatch(/src\/db/)
         expect(dbImport!.resolvedPath).toMatch(/\.js$/)
     })
 
-    test('resolveImports leaves external packages unresolved (empty resolvedPath)', () => {
-        const files = [parser.parse('src/auth.js', CJS_MODULE)]
+    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 file = resolved[0]
-        const cryptoImp = file.imports.find(i => i.source === 'crypto')
+        const cryptoImp = file.imports.find((i: any) => i.source === 'crypto')
         expect(cryptoImp!.resolvedPath).toBe('')
     })
 
-    test('parse .jsx file language is javascript', () => {
-        const result = parser.parse('src/UserCard.jsx', JSX_COMPONENT)
+    test('parse .jsx file language is javascript', async () => {
+        const result = await parser.parse('src/UserCard.jsx', JSX_COMPONENT)
         expect(result.language).toBe('javascript')
     })
 })
@@ -610,7 +625,7 @@ describe('getParser — JS extensions', () => {
         expect(p.getSupportedExtensions()).toContain('.ts')
     })
 
-    test('still throws UnsupportedLanguageError for .py', () => {
-        expect(() => getParser('src/app.py')).toThrow()
+    test('still throws UnsupportedLanguageError for .xyz', () => {
+        expect(() => getParser('src/app.xyz')).toThrow()
     })
 })

package/tests/parser.test.ts

@@ -134,13 +134,13 @@ describe('TypeScriptExtractor', () => {
 describe('TypeScriptParser', () => {
     const parser = new TypeScriptParser()
 
-    it('returns correct language', () => {
-        const result = parser.parse('src/test.ts', 'const x = 1')
+    it('returns correct language', async () => {
+        const result = await parser.parse('src/test.ts', 'const x = 1')
         expect(result.language).toBe('typescript')
     })
 
-    it('parses a complete file', () => {
-        const result = parser.parse('src/auth.ts', `
+    it('parses a complete file', async () => {
+        const result = await parser.parse('src/auth.ts', `
       import { jwtDecode } from '../utils/jwt'
       export function verifyToken(token: string): boolean {
         return jwtDecode(token).exp > Date.now()
@@ -213,6 +213,6 @@ describe('getParser', () => {
     })
 
     it('throws for unsupported extensions', () => {
-        expect(() => getParser('src/auth.rb')).toThrow(UnsupportedLanguageError)
+        expect(() => getParser('src/auth.xyz')).toThrow(UnsupportedLanguageError)
     })
 })

package/tests/tree-sitter-parser.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from 'bun:test'
+import { TreeSitterParser } from '../src/parser/tree-sitter/parser.js'
+import { resolve } from 'node:path'
+
+describe('TreeSitterParser', () => {
+    test('parses Python correctly', async () => {
+        const parser = new TreeSitterParser()
+        const pyContent = `
+import os
+from sys import argv
+
+class User:
+    def __init__(self, name: str):
+        self.name = name
+    
+    def get_name(self) -> str:
+        return self.name
+
+def main():
+    u = User("Alice")
+    print(u.get_name())
+`
+        const result = await parser.parse('test.py', pyContent)
+        
+        expect(result.classes.length).toBe(1)
+        expect(result.classes[0].name).toBe('User')
+        
+        expect(result.functions.length).toBe(3) // __init__, get_name, main
+        const mainFn = result.functions.find((f: any) => f.name === 'main')
+        expect(mainFn).toBeDefined()
+        
+        expect(result.imports.length).toBe(2)
+        expect(result.imports.map((i: any) => i.source)).toContain('os')
+        expect(result.imports.map((i: any) => i.source)).toContain('sys')
+        
+        expect(result.functions[0].calls).toContain('User')
+        expect(result.functions[0].calls).toContain('print')
+        expect(result.functions[0].calls).toContain('get_name')
+    })
+
+    test('parses Java correctly', async () => {
+        const parser = new TreeSitterParser()
+        const javaContent = `
+import java.util.List;
+
+public class App {
+    public static void main(String[] args) {
+        System.out.println("Hello");
+    }
+
+    private int calculate(int a, int b) {
+        return a + b;
+    }
+}
+`
+        const result = await parser.parse('App.java', javaContent)
+        
+        expect(result.classes.length).toBe(1)
+        expect(result.classes[0].name).toBe('App')
+        
+        expect(result.functions.length).toBe(2) // main, calculate
+        
+        expect(result.imports.length).toBe(1)
+        expect(result.imports[0].source).toBe('java.util.List')
+    })
+    
+    test('parses Go correctly', async () => {
+        const parser = new TreeSitterParser()
+        const goContent = `
+package main
+
+import (
+    "fmt"
+    "net/http"
+)
+
+type Server struct {
+    port int
+}
+
+func (s *Server) Start() {
+    fmt.Println("Starting")
+}
+
+func main() {
+    s := Server{port: 8080}
+    s.Start()
+}
+`
+        const result = await parser.parse('main.go', goContent)
+        
+        expect(result.classes.length).toBe(1)
+        // struct maps to class in our universal AST
+        expect(result.classes[0].name).toBe('Server')
+        
+        expect(result.functions.length).toBe(2) // Start, main
+        
+        expect(result.imports.length).toBe(2)
+        expect(result.imports.map((i: any) => i.source)).toContain('fmt')
+    })
+    
+    // EDGE CASES & ERROR HANDLING
+    
+    test('handles empty files gracefully', async () => {
+        const parser = new TreeSitterParser()
+        const result = await parser.parse('empty.py', '')
+        
+        expect(result.functions.length).toBe(0)
+        expect(result.classes.length).toBe(0)
+        expect(result.imports.length).toBe(0)
+        expect(result.path).toBe('empty.py')
+        expect(result.language).toBe('python')
+    })
+
+    test('handles syntax errors in Python code gracefully', async () => {
+        const parser = new TreeSitterParser()
+        const badPyContent = `
+def good_function():
+    print("This is fine")
+
+def bad_function(
+    print("Missing closing paren and colon"
+    
+class GoodClass:
+    pass
+`
+        // Tree-sitter is fault-tolerant, so it should not crash.
+        const result = await parser.parse('malformed.py', badPyContent)
+        
+        // We assert that it successfully returns a ParsedFile object without throwing any errors
+        expect(result.path).toBe('malformed.py')
+        expect(result.language).toBe('python')
+        expect(Array.isArray(result.functions)).toBe(true)
+        expect(Array.isArray(result.classes)).toBe(true)
+    })
+    
+    test('handles unsupported extensions gracefully', async () => {
+        const parser = new TreeSitterParser()
+        const result = await parser.parse('unknown.xyz', 'some weird content')
+        
+        // Should return a fallback ParsedFile without crashing
+        expect(result.functions.length).toBe(0)
+        expect(result.classes.length).toBe(0)
+        // TreeSitter fallback is 'unknown' for unsupported extensions
+        expect(result.language).toBe('unknown')
+    })
+    
+    test('handles syntax errors in Java gracefully', async () => {
+        const parser = new TreeSitterParser()
+        const badJavaContent = `
+public class Main {
+    public void goodMethod() {
+        int x = 5;
+    }
+    
+    public void badMethod( { // Syntax error here
+        System.out.println("Hello"
+    }
+}
+`
+        // Ensure no crash on parse
+        const result = await parser.parse('Main.java', badJavaContent)
+        
+        expect(result.path).toBe('Main.java')
+        expect(result.language).toBe('java')
+        expect(Array.isArray(result.classes)).toBe(true)
+    })
+})

package/tests/ts-parser.test.ts

@@ -74,7 +74,7 @@ describe('ts-parser config "extends" resolution', () => {
         `)
 
         // Parse and resolve imports
-        const parsed = parser.parse(filePath, await fs.readFile(filePath, 'utf-8'))
+        const parsed = await parser.parse(filePath, await fs.readFile(filePath, 'utf-8'))
         const resolved = parser.resolveImports([parsed], FIXTURE_DIR)[0]
 
         // Check if the aliases mapped correctly using all 3 layers of paths
@@ -91,3 +91,51 @@ describe('ts-parser config "extends" resolution', () => {
         expect(impApp?.resolvedPath).toBe('src/app/local.ts')
     })
 })
+
+describe('TypeScriptParser Edge Cases & Fault Tolerance', () => {
+    const parser = new TypeScriptParser()
+
+    it('handles completely empty files', async () => {
+        const result = await parser.parse('src/empty.ts', '')
+        expect(result.functions).toHaveLength(0)
+        expect(result.classes).toHaveLength(0)
+        expect(result.language).toBe('typescript')
+        expect(result.hash).toBeDefined()
+    })
+
+    it('gracefully degrades on severe syntax errors', async () => {
+        const malformedCode = `
+            export interface Broke {
+                val: string
+            // missing closing brace
+            
+            function doThing() {
+                const x = 
+            }
+            
+            @Injectable()
+            export class HalfClass implements {
+        `
+        const result = await parser.parse('src/broken.ts', malformedCode)
+        
+        // Should not crash, and should extract whatever it can
+        expect(result.functions.length).toBeGreaterThanOrEqual(0)
+        expect(result.classes.length).toBeGreaterThanOrEqual(0)
+        // Must maintain object structure
+        expect(Array.isArray(result.imports)).toBe(true)
+        expect(typeof result.hash).toBe('string')
+        expect(result.language).toBe('typescript')
+    })
+    
+    it('handles files with only comments', async () => {
+        const commentsCode = `
+            /**
+             * This file is just documentation
+             */
+            // End of file
+        `
+        const result = await parser.parse('src/docs.ts', commentsCode)
+        expect(result.functions).toHaveLength(0)
+        expect(result.hash).toBeDefined()
+    })
+})