@getmikk/core 2.0.12 → 2.0.13

package/tests/fs.test.ts

@@ -75,6 +75,12 @@ describe('detectProjectLanguage', () => {
         })
     })
 
+    it('detects Swift from Package.swift', async () => {
+        await withFile('Package.swift', async () => {
+            expect(await detectProjectLanguage(tmpDir)).toBe('swift')
+        })
+    })
+
     it('detects C# from .csproj file', async () => {
         await withFile('MyApp.csproj', async () => {
             expect(await detectProjectLanguage(tmpDir)).toBe('csharp')
@@ -116,7 +122,7 @@ describe('detectProjectLanguage', () => {
 describe('getDiscoveryPatterns', () => {
     const languages: ProjectLanguage[] = [
         'typescript', 'javascript', 'python', 'go', 'rust',
-        'java', 'ruby', 'php', 'csharp', 'unknown',
+        'java', 'swift', 'ruby', 'php', 'csharp', 'unknown',
     ]
 
     for (const lang of languages) {
@@ -143,6 +149,21 @@ describe('getDiscoveryPatterns', () => {
         expect(patterns).toContain('**/*.py')
     })
 
+    it('java discovery patterns include Kotlin scripts for mixed JVM codebases', () => {
+        const { patterns } = getDiscoveryPatterns('java')
+        expect(patterns).toContain('**/*.kts')
+    })
+
+    it('swift patterns include .swift', () => {
+        const { patterns } = getDiscoveryPatterns('swift')
+        expect(patterns).toContain('**/*.swift')
+    })
+
+    it('cpp patterns include .hh headers', () => {
+        const { patterns } = getDiscoveryPatterns('cpp')
+        expect(patterns).toContain('**/*.hh')
+    })
+
     it('all languages ignore .mikk and .git', () => {
         for (const lang of languages) {
             const { ignore } = getDiscoveryPatterns(lang)

package/tests/fuzzy-match.test.ts

@@ -61,6 +61,12 @@ describe('levenshtein', () => {
     test('insertion', () => {
         expect(levenshtein('test', 'tests')).toBe(1)
     })
+
+    test('distance is symmetric', () => {
+        expect(levenshtein('verifyToken', 'tokenVerify')).toBe(
+            levenshtein('tokenVerify', 'verifyToken'),
+        )
+    })
 })
 
 describe('splitCamelCase', () => {

package/tests/go-parser.test.ts

@@ -363,4 +363,11 @@ describe('GoParser', () => {
         const resolved = await parser.resolveImports(files, '/tmp/no-gomod-' + Date.now())
         expect(resolved.length).toBe(1)
     })
+
+    test('parse keeps deterministic hash for identical input', async () => {
+        const parser = new GoParser()
+        const a = await parser.parse('auth/service.go', SIMPLE_GO)
+        const b = await parser.parse('auth/service.go', SIMPLE_GO)
+        expect(a.hash).toBe(b.hash)
+    })
 })

package/tests/graph.test.ts

@@ -167,4 +167,14 @@ describe('ClusterDetector', () => {
         expect(score).toBeGreaterThanOrEqual(0)
         expect(score).toBeLessThanOrEqual(1)
     })
+
+    it('keeps distinct function nodes for same function names in different files', () => {
+        const files = [
+            mockParsedFile('src/auth/a.ts', [mockFunction('shared', [], 'src/auth/a.ts')]),
+            mockParsedFile('src/db/b.ts', [mockFunction('shared', [], 'src/db/b.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        expect(graph.nodes.has('fn:src/auth/a.ts:shared')).toBe(true)
+        expect(graph.nodes.has('fn:src/db/b.ts:shared')).toBe(true)
+    })
 })

package/tests/hash.test.ts

@@ -46,4 +46,10 @@ describe('computeRootHash', () => {
         const hash2 = computeRootHash({ payments: 'def', auth: 'abc' })
         expect(hash1).toBe(hash2)
     })
+
+    it('changes when a module hash changes', () => {
+        const base = computeRootHash({ auth: 'abc', payments: 'def' })
+        const changed = computeRootHash({ auth: 'abc', payments: 'xyz' })
+        expect(base).not.toBe(changed)
+    })
 })

package/tests/impact-classified.test.ts

@@ -71,4 +71,17 @@ describe('ImpactAnalyzer - Classified', () => {
         expect(result.classified.low).toHaveLength(1)
         expect(result.classified.low[0].nodeId).toBe('fn:src/highriskauthservice.ts:highriskauthservice')
     })
+
+    it('deduplicates impacted nodes when changed list includes duplicates', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'C'],
+            ['C', 'nothing'],
+        ])
+
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/c.ts:c', 'fn:src/c.ts:c'])
+        const unique = new Set(result.impacted)
+        expect(unique.size).toBe(result.impacted.length)
+    })
 })

package/tests/js-parser.test.ts

@@ -1042,6 +1042,16 @@ describe('JavaScript - Additional Edge Cases', () => {
         })
     })
 
+    describe('Deterministic parsing', () => {
+        test('produces identical file hash for identical source', async () => {
+            const parser = new JavaScriptParser()
+            const source = 'export function stable() { return 1 }'
+            const a = await parser.parse('src/stable.js', source)
+            const b = await parser.parse('src/stable.js', source)
+            expect(a.hash).toBe(b.hash)
+        })
+    })
+
     describe('Chained Methods', () => {
         test('handles method chaining', () => {
             const src = `

package/tests/language-registry.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'bun:test'
+import {
+    parserKindForExtension,
+    languageForExtension,
+    getParserExtensions,
+    getDiscoveryExtensions,
+    isTreeSitterExtension,
+} from '../src/utils/language-registry'
+
+describe('language-registry', () => {
+    it('maps parser kinds correctly', () => {
+        expect(parserKindForExtension('.ts')).toBe('oxc')
+        expect(parserKindForExtension('.go')).toBe('go')
+        expect(parserKindForExtension('.py')).toBe('tree-sitter')
+        expect(parserKindForExtension('.unknown')).toBe('unknown')
+    })
+
+    it('maps parser kinds case-insensitively', () => {
+        expect(parserKindForExtension('.TS')).toBe('oxc')
+        expect(parserKindForExtension('.Go')).toBe('go')
+        expect(parserKindForExtension('.RB')).toBe('tree-sitter')
+    })
+
+    it('maps languages correctly across major ecosystems', () => {
+        expect(languageForExtension('.ts')).toBe('typescript')
+        expect(languageForExtension('.js')).toBe('typescript')
+        expect(languageForExtension('.py')).toBe('python')
+        expect(languageForExtension('.go')).toBe('go')
+        expect(languageForExtension('.rs')).toBe('rust')
+        expect(languageForExtension('.java')).toBe('java')
+        expect(languageForExtension('.kt')).toBe('kotlin')
+        expect(languageForExtension('.kts')).toBe('kotlin')
+        expect(languageForExtension('.swift')).toBe('swift')
+        expect(languageForExtension('.rb')).toBe('ruby')
+        expect(languageForExtension('.php')).toBe('php')
+        expect(languageForExtension('.cs')).toBe('csharp')
+        expect(languageForExtension('.c')).toBe('c')
+        expect(languageForExtension('.cpp')).toBe('cpp')
+    })
+
+    it('returns parser extension sets', () => {
+        expect(getParserExtensions('oxc')).toContain('.tsx')
+        expect(getParserExtensions('go')).toEqual(['.go'])
+        expect(getParserExtensions('tree-sitter')).toContain('.swift')
+    })
+
+    it('returns discovery extension sets for mixed JVM repos', () => {
+        const javaDiscovery = getDiscoveryExtensions('java')
+        expect(javaDiscovery).toContain('.java')
+        expect(javaDiscovery).toContain('.kt')
+        expect(javaDiscovery).toContain('.kts')
+
+        // Even though Java discovery includes Kotlin files, extension-to-language remains Kotlin.
+        expect(languageForExtension('.kt')).toBe('kotlin')
+        expect(languageForExtension('.kts')).toBe('kotlin')
+    })
+
+    it('identifies tree-sitter extensions', () => {
+        expect(isTreeSitterExtension('.py')).toBe(true)
+        expect(isTreeSitterExtension('.swift')).toBe(true)
+        expect(isTreeSitterExtension('.ts')).toBe(false)
+        expect(isTreeSitterExtension('.go')).toBe(false)
+    })
+})

package/tests/parse-diagnostics.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'bun:test'
+import { parseFilesWithDiagnostics } from '../src/parser/index'
+
+describe('parseFilesWithDiagnostics preflight', () => {
+    it('returns parser-unavailable diagnostic and no files in strict preflight mode', async () => {
+        const result = await parseFilesWithDiagnostics(
+            ['src/example.py'],
+            '/project',
+            async () => 'def run():\n  return 1\n',
+            {
+                strictParserPreflight: true,
+                treeSitterRuntimeAvailable: false,
+            },
+        )
+
+        expect(result.files).toHaveLength(0)
+        expect(result.summary.requestedFiles).toBe(1)
+        expect(result.summary.parsedFiles).toBe(0)
+        expect(result.summary.diagnostics).toBeGreaterThan(0)
+        expect(result.diagnostics.some(d => d.reason === 'parser-unavailable')).toBe(true)
+    })
+
+    it('falls back and continues in non-strict mode when parser runtime is unavailable', async () => {
+        const result = await parseFilesWithDiagnostics(
+            ['src/example.py'],
+            '/project',
+            async () => 'def run():\n  return 1\n',
+            {
+                strictParserPreflight: false,
+                treeSitterRuntimeAvailable: false,
+            },
+        )
+
+        expect(result.files).toHaveLength(1)
+        expect(result.summary.diagnostics).toBeGreaterThan(0)
+        expect(result.diagnostics.some(d => d.reason === 'parser-unavailable')).toBe(true)
+    })
+
+    it('skips tree-sitter preflight when only oxc/go files are requested', async () => {
+        const result = await parseFilesWithDiagnostics(
+            ['src/index.ts'],
+            '/project',
+            async () => 'export function ok(): number { return 1 }',
+            {
+                strictParserPreflight: true,
+                treeSitterRuntimeAvailable: false,
+            },
+        )
+
+        expect(result.summary.requestedFiles).toBe(1)
+        expect(result.summary.parsedFiles).toBe(1)
+        expect(result.diagnostics.some(d => d.reason === 'parser-unavailable')).toBe(false)
+    })
+
+    it('returns language-correct fallback files for multiple tree-sitter languages in non-strict mode', async () => {
+        const files = [
+            'src/main.py',
+            'src/App.java',
+            'src/service.kt',
+            'src/tool.swift',
+            'src/lib.rs',
+            'src/Program.cs',
+            'src/main.php',
+            'src/app.rb',
+            'src/native.c',
+            'src/native.cpp',
+        ]
+
+        const result = await parseFilesWithDiagnostics(
+            files,
+            '/project',
+            async () => '',
+            {
+                strictParserPreflight: false,
+                treeSitterRuntimeAvailable: false,
+            },
+        )
+
+        expect(result.files).toHaveLength(files.length)
+        expect(result.diagnostics.some(d => d.reason === 'parser-unavailable')).toBe(true)
+
+        const languageBySuffix = (suffix: string): string | undefined => {
+            const hit = result.files.find(f => f.path.replace(/\\/g, '/').endsWith(suffix))
+            return hit?.language
+        }
+
+        expect(languageBySuffix('/src/main.py')).toBe('python')
+        expect(languageBySuffix('/src/App.java')).toBe('java')
+        expect(languageBySuffix('/src/service.kt')).toBe('kotlin')
+        expect(languageBySuffix('/src/tool.swift')).toBe('swift')
+        expect(languageBySuffix('/src/lib.rs')).toBe('rust')
+        expect(languageBySuffix('/src/Program.cs')).toBe('csharp')
+        expect(languageBySuffix('/src/main.php')).toBe('php')
+        expect(languageBySuffix('/src/app.rb')).toBe('ruby')
+        expect(languageBySuffix('/src/native.c')).toBe('c')
+        expect(languageBySuffix('/src/native.cpp')).toBe('cpp')
+    })
+
+    it('aborts full batch in strict preflight when any tree-sitter file is present', async () => {
+        const result = await parseFilesWithDiagnostics(
+            ['src/index.ts', 'src/main.py'],
+            '/project',
+            async () => 'export const ok = 1',
+            {
+                strictParserPreflight: true,
+                treeSitterRuntimeAvailable: false,
+            },
+        )
+
+        expect(result.files).toHaveLength(0)
+        expect(result.summary.requestedFiles).toBe(2)
+        expect(result.summary.parsedFiles).toBe(0)
+        expect(result.diagnostics.some(d => d.reason === 'parser-unavailable')).toBe(true)
+    })
+})

package/tests/parser.test.ts

@@ -729,6 +729,26 @@ describe('getParser - Comprehensive', () => {
         const parser = getParser('src/lib/utils/helper.ts')
         expect(parser).toBeInstanceOf(OxcParser)
     })
+
+    it('supports C++ variant extensions via tree-sitter parser', () => {
+      const cxxParser = getParser('src/engine.cxx')
+      const hxxParser = getParser('src/engine.hxx')
+      const hhParser = getParser('src/engine.hh')
+
+      expect(cxxParser.getSupportedExtensions()).toContain('.cxx')
+      expect(hxxParser.getSupportedExtensions()).toContain('.hxx')
+      expect(hhParser.getSupportedExtensions()).toContain('.hh')
+    })
+
+    it('supports Rust/C#/Swift extensions via tree-sitter parser', () => {
+      const rustParser = getParser('src/lib.rs')
+      const csharpParser = getParser('src/Program.cs')
+      const swiftParser = getParser('Sources/App/main.swift')
+
+      expect(rustParser.getSupportedExtensions()).toContain('.rs')
+      expect(csharpParser.getSupportedExtensions()).toContain('.cs')
+      expect(swiftParser.getSupportedExtensions()).toContain('.swift')
+    })
 })
 
 describe('OxcParser - Direct', () => {
@@ -751,4 +771,20 @@ describe('OxcParser - Direct', () => {
         const result = await parser.parse('large.ts', content)
         expect(result.functions.length).toBe(1000)
     })
+
+    it('extracts direct and method call expressions', async () => {
+      const result = await parser.parse('calls.ts', `
+        function b() { return 1 }
+        const svc = { run() { return 2 } }
+        export function a() {
+          b()
+          svc.run()
+        }
+      `)
+
+      const a = result.functions.find(f => f.name === 'a')
+      expect(a).toBeDefined()
+      expect(a!.calls.some(c => c.name === 'b')).toBe(true)
+      expect(a!.calls.some(c => c.name === 'svc.run')).toBe(true)
+    })
 })

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

@@ -268,6 +268,34 @@ struct PrivateStruct {
             expect(pubStruct?.isExported).toBe(true)
             expect(privStruct?.isExported).toBe(false)
         })
+
+        test('parses Rust traits and impl blocks', async () => {
+            const content = `
+pub trait UserRepository {
+    fn find_user(&self, id: String) -> Option<String>;
+}
+
+pub struct InMemoryRepo;
+
+impl UserRepository for InMemoryRepo {
+    fn find_user(&self, id: String) -> Option<String> {
+        Some(id)
+    }
+}
+`
+            const result = await parser.parse('repository.rs', content)
+
+            expect(result.path).toBe('repository.rs')
+            expect(result.language).toBe('rust')
+
+            if (result.classes.length > 0) {
+                expect(result.classes.some(c => c.name === 'UserRepository')).toBe(true)
+                expect(result.classes.some(c => c.name === 'InMemoryRepo')).toBe(true)
+            }
+            if (result.functions.length > 0) {
+                expect(result.functions.some(f => f.name === 'find_user')).toBe(true)
+            }
+        })
     })
 
     // ==========================================
@@ -337,6 +365,31 @@ public:
             expect(result.classes[0].name).toBe('Calculator')
             expect(result.functions.length).toBeGreaterThanOrEqual(1)
         })
+
+        test('parses C++ templates with macro-heavy headers', async () => {
+            const content = `
+#ifndef VECTOR_UTILS_H
+#define VECTOR_UTILS_H
+
+#include <vector>
+
+#define INLINE inline
+
+template <typename T>
+INLINE T max_value(const T& a, const T& b) {
+    return a > b ? a : b;
+}
+
+#endif
+`
+            const result = await parser.parse('vector_utils.hpp', content)
+
+            expect(result.path).toBe('vector_utils.hpp')
+            expect(result.language).toBe('cpp')
+            if (result.functions.length > 0) {
+                expect(result.functions.some(f => f.name === 'max_value')).toBe(true)
+            }
+        })
     })
 
     // ==========================================
@@ -393,6 +446,36 @@ class VisibilityTest {
             expect(priv?.isExported).toBe(false)
             expect(prot?.isExported).toBe(false)
         })
+
+        test('parses framework-style PHP controller classes', async () => {
+            const content = `
+<?php
+namespace App\\Http\\Controllers;
+
+use Illuminate\\Http\\Request;
+
+class UserController extends Controller {
+    public function index(Request $request): array {
+        return [];
+    }
+
+    public function show(string $id): array {
+        return ['id' => $id];
+    }
+}
+`
+            const result = await parser.parse('UserController.php', content)
+
+            expect(result.path).toBe('UserController.php')
+            expect(result.language).toBe('php')
+            if (result.classes.length > 0) {
+                expect(result.classes.some(c => c.name === 'UserController')).toBe(true)
+            }
+            if (result.functions.length > 0) {
+                expect(result.functions.some(f => f.name === 'index')).toBe(true)
+                expect(result.functions.some(f => f.name === 'show')).toBe(true)
+            }
+        })
     })
 
     // ==========================================
@@ -432,6 +515,93 @@ namespace App.Services {
                 expect(result.path).toBe('UserService.cs')
             }
         })
+
+        test('parses C# attributes and ASP.NET controller routes', async () => {
+            const content = `
+using Microsoft.AspNetCore.Mvc;
+
+namespace App.Api.Controllers {
+    [ApiController]
+    [Route("api/[controller]")]
+    public class UsersController : ControllerBase {
+        [HttpGet("{id}")]
+        public ActionResult<string> GetById(string id) {
+            return id;
+        }
+
+        [HttpPost]
+        public IActionResult Create([FromBody] object payload) {
+            return Ok(payload);
+        }
+    }
+}
+`
+            const result = await parser.parse('UsersController.cs', content)
+
+            expect(result.path).toBe('UsersController.cs')
+            expect(result.language).toBe('csharp')
+            if (result.functions.length > 0) {
+                expect(result.functions.some(f => f.name === 'GetById')).toBe(true)
+                expect(result.functions.some(f => f.name === 'Create')).toBe(true)
+            }
+        })
+    })
+
+    describe('Kotlin - Coroutines & Extensions', () => {
+        test('parses Kotlin coroutine and extension functions', async () => {
+            const content = `
+package app.service
+
+class UserService {
+    suspend fun fetchUser(id: String): String {
+        return id
+    }
+}
+
+fun String.slugify(): String {
+    return this.lowercase().replace(" ", "-")
+}
+`
+            let result
+            try {
+                result = await parser.parse('UserService.kt', content)
+            } catch {
+                result = { path: 'UserService.kt', language: 'kotlin', functions: [], classes: [] }
+            }
+
+            expect(result.path).toBe('UserService.kt')
+            expect(result.language).toBe('kotlin')
+            if (result.functions.length > 0) {
+                expect(result.functions.some(f => f.name === 'fetchUser')).toBe(true)
+                expect(result.functions.some(f => f.name === 'slugify')).toBe(true)
+            }
+        })
+    })
+
+    describe('Swift - Protocol & Package Patterns', () => {
+        test('parses Swift protocol-based service code', async () => {
+            const content = `
+import Foundation
+
+protocol UserRepository {
+    func findUser(id: String) -> String?
+}
+
+struct InMemoryUserRepository: UserRepository {
+    func findUser(id: String) -> String? {
+        return id
+    }
+}
+`
+            const result = await parser.parse('Sources/App/UserRepository.swift', content)
+
+            expect(result.path).toBe('Sources/App/UserRepository.swift')
+            expect(result.language).toBe('swift')
+            if (result.classes.length > 0) {
+                expect(result.classes.some(c => c.name === 'UserRepository')).toBe(true)
+                expect(result.classes.some(c => c.name === 'InMemoryUserRepository')).toBe(true)
+            }
+        })
     })
 
     // ==========================================
@@ -473,6 +643,30 @@ end
             
             expect(result.path).toBe('auth.rb')
         })
+
+        test('parses Ruby DSL-heavy model patterns', async () => {
+            const content = `
+class User < ApplicationRecord
+  scope :active, -> { where(active: true) }
+  validates :email, presence: true
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end
+`
+            let result
+            try {
+                result = await parser.parse('user.rb', content)
+            } catch {
+                result = { path: 'user.rb', language: 'ruby', functions: [], classes: [] }
+            }
+
+            expect(result.path).toBe('user.rb')
+            if (result.functions.length > 0) {
+                expect(result.functions.some((f: { name: string }) => f.name === 'full_name')).toBe(true)
+            }
+        })
     })
 
     // ==========================================
@@ -869,5 +1063,12 @@ raw = r"raw \\string"
             
             expect(result.imports.length).toBeGreaterThan(0)
         })
+
+        test('produces identical hash for identical content', async () => {
+            const content = 'def stable():\n    return 42\n'
+            const a = await parser.parse('stable.py', content)
+            const b = await parser.parse('stable.py', content)
+            expect(a.hash).toBe(b.hash)
+        })
     })
 })

package/tests/ts-parser.test.ts

@@ -113,4 +113,10 @@ describe('TypeScriptParser Edge Cases & Fault Tolerance', () => {
         expect(result.functions).toHaveLength(0)
         expect(result.hash).toBeDefined()
     })
+
+    it('parses Windows line endings consistently', async () => {
+        const winCode = 'export function ping() {\r\n  return 1\r\n}\r\n'
+        const result = await parser.parse('src/win.ts', winCode)
+        expect(result.functions.some(f => f.name === 'ping')).toBe(true)
+    })
 })