@getmikk/core 2.0.13 → 2.0.15

package/src/utils/fs.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import fg from 'fast-glob'
@@ -184,7 +185,22 @@ export function parseMikkIgnore(content: string): string[] {
  * This is technology-agnostic: it works for Prisma, Drizzle, GraphQL, SQL,
  * Protobuf, Docker, OpenAPI, and more -- anything with a well-known file pattern.
  */
-export async function discoverContextFiles(projectRoot: string): Promise<ContextFile[]> {
+
+export interface DiscoverContextFilesOptions {
+    /** Maximum number of context files to return (default 20) */
+    maxFiles?: number
+    /** Callback for progress updates */
+    onProgress?: (current: number, total: number, file: string) => void
+    /** Skip reading file content - just get file list with stats */
+    metadataOnly?: boolean
+}
+
+export async function discoverContextFiles(
+    projectRoot: string,
+    options: DiscoverContextFilesOptions = {}
+): Promise<ContextFile[]> {
+    const { maxFiles = 20, onProgress, metadataOnly = false } = options
+
     const mikkIgnore = await readMikkIgnore(projectRoot)
     const files = await fg(CONTEXT_FILE_PATTERNS, {
         cwd: projectRoot,
@@ -194,29 +210,49 @@ export async function discoverContextFiles(projectRoot: string): Promise<Context
     })
 
     const normalised = files.map(f => f.replace(/\\/g, '/'))
-
-    // Deduplicate -- some patterns overlap (e.g. models/*.ts also matched by source discovery)
     const unique = [...new Set(normalised)]
 
     const results: ContextFile[] = []
-
-    for (const relPath of unique) {
-        const absPath = path.join(projectRoot, relPath)
-        try {
-            const stat = await fs.stat(absPath)
-            if (stat.size > MAX_CONTEXT_FILE_SIZE) continue // skip huge files
-            if (stat.size === 0) continue
-
-            const content = await fs.readFile(absPath, 'utf-8')
-            const type = inferContextFileType(relPath)
-
-            results.push({ path: relPath, content, type, size: stat.size })
-        } catch {
-            // File unreadable -- skip
+    const batchSize = 10
+
+    for (let i = 0; i < unique.length; i += batchSize) {
+        const batch = unique.slice(i, i + batchSize)
+
+        const batchResults = await Promise.all(
+            batch.map(async (relPath) => {
+                const absPath = path.join(projectRoot, relPath)
+                try {
+                    const stat = await fs.stat(absPath)
+                    if (stat.size > MAX_CONTEXT_FILE_SIZE) return null
+                    if (stat.size === 0) return null
+
+                    const type = inferContextFileType(relPath)
+
+                    if (onProgress) {
+                        onProgress(results.length + 1, Math.min(unique.length, maxFiles), relPath)
+                    }
+
+                    if (metadataOnly) {
+                        return { path: relPath, content: '', type, size: stat.size }
+                    }
+
+                    const content = await fs.readFile(absPath, 'utf-8')
+                    return { path: relPath, content, type, size: stat.size }
+                } catch {
+                    return null
+                }
+            })
+        )
+
+        for (const result of batchResults) {
+            if (result && results.length < maxFiles) {
+                results.push(result)
+            }
         }
+
+        if (results.length >= maxFiles) break
     }
 
-    // Sort: schemas/models first, then types, routes, config
     const priority: Record<ContextFileType, number> = {
         schema: 0,
         model: 1,
@@ -229,9 +265,6 @@ export async function discoverContextFiles(projectRoot: string): Promise<Context
     }
     results.sort((a, b) => priority[a.type] - priority[b.type])
 
-    // If we have a schema file (e.g. prisma/schema.prisma), the migrations
-    // are redundant -- they represent historical deltas, not the current state.
-    // Including them wastes AI tokens and can be actively misleading.
     const hasSchema = results.some(f => f.type === 'schema')
     if (hasSchema) {
         return results.filter(f => f.type !== 'migration')
@@ -276,7 +309,7 @@ function inferContextFileType(filePath: string): ContextFileType {
 }
 
 /** Recognised project language */
-export type ProjectLanguage = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java' | 'swift' | 'ruby' | 'php' | 'csharp' | 'c' | 'cpp' | 'unknown'
+export type ProjectLanguage = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java' | 'swift' | 'ruby' | 'php' | 'csharp' | 'c' | 'cpp' | 'unknown' | 'polyglot'
 
 /** Auto-detect the project's primary language from manifest files */
 export async function detectProjectLanguage(projectRoot: string): Promise<ProjectLanguage> {
@@ -287,19 +320,52 @@ export async function detectProjectLanguage(projectRoot: string): Promise<Projec
         const matches = await fg(pattern, { cwd: projectRoot, onlyFiles: true, deep: 1 })
         return matches.length > 0
     }
+    
+    const hasTsConfig = await exists('tsconfig.json') || await hasGlob('tsconfig.*.json')
+    const hasPackageJson = await exists('package.json')
+    const hasRust = await exists('Cargo.toml')
+    const hasGo = await exists('go.mod')
+    const hasPython = await exists('pyproject.toml') || await exists('setup.py') || await exists('requirements.txt')
+    const hasRuby = await exists('Gemfile')
+    const hasJava = await exists('pom.xml') || await exists('build.gradle') || await exists('build.gradle.kts')
+    const hasSwift = await exists('Package.swift')
+    const hasPhp = await exists('composer.json')
+    const hasCSharp = await hasGlob('*.csproj') || await hasGlob('*.sln')
+    const hasCpp = await hasGlob('CMakeLists.txt') || await hasGlob('**/*.cmake')
+    const hasC = await hasGlob('*.c') || await hasGlob('*.h')
+    
+    // Count non-JS family manifests (TypeScript and JavaScript share package.json, so count them together)
+    let languageFamilyCount = 0
+    if (hasTsConfig || hasPackageJson) languageFamilyCount++ // JS family (TS or JS)
+    if (hasRust) languageFamilyCount++
+    if (hasGo) languageFamilyCount++
+    if (hasPython) languageFamilyCount++
+    if (hasRuby) languageFamilyCount++
+    if (hasJava) languageFamilyCount++
+    if (hasSwift) languageFamilyCount++
+    if (hasPhp) languageFamilyCount++
+    if (hasCSharp) languageFamilyCount++
+    if (hasCpp) languageFamilyCount++
+    if (hasC) languageFamilyCount++
+    
+    // If multiple language families detected, it's polyglot
+    if (languageFamilyCount > 1) {
+        return 'polyglot'
+    }
+    
     // Check in priority order -- most specific first
-    if (await exists('tsconfig.json') || await hasGlob('tsconfig.*.json')) return 'typescript'
-    if (await exists('Cargo.toml')) return 'rust'
-    if (await exists('go.mod')) return 'go'
-    if (await exists('pyproject.toml') || await exists('setup.py') || await exists('requirements.txt')) return 'python'
-    if (await exists('Gemfile')) return 'ruby'
-    if (await exists('pom.xml') || await exists('build.gradle') || await exists('build.gradle.kts')) return 'java'
-    if (await exists('Package.swift')) return 'swift'
-    if (await exists('composer.json')) return 'php'
-    if (await hasGlob('*.csproj') || await hasGlob('*.sln')) return 'csharp'
-    if (await hasGlob('CMakeLists.txt') || await hasGlob('**/*.cmake') || await hasGlob('*.cpp')) return 'cpp'
-    if (await hasGlob('*.c') || await hasGlob('*.h')) return 'c'
-    if (await exists('package.json')) return 'javascript'
+    if (hasTsConfig) return 'typescript'
+    if (hasRust) return 'rust'
+    if (hasGo) return 'go'
+    if (hasPython) return 'python'
+    if (hasRuby) return 'ruby'
+    if (hasJava) return 'java'
+    if (hasSwift) return 'swift'
+    if (hasPhp) return 'php'
+    if (hasCSharp) return 'csharp'
+    if (hasCpp) return 'cpp'
+    if (hasC) return 'c'
+    if (hasPackageJson) return 'javascript'
     return 'unknown'
 }
 
@@ -310,24 +376,28 @@ export function getDiscoveryPatterns(language: ProjectLanguage): { patterns: str
     ]
 
     const toPatterns = (lang: ProjectLanguage): string[] => {
-        return getDiscoveryExtensions(lang).map(ext => `**/*${ext}`)
+        if (lang === 'polyglot') {
+            // For polyglot, use LANGUAGE_EXTENSIONS.polyglot directly
+            return getDiscoveryExtensions('polyglot' as any).map(ext => `**/*${ext}`)
+        }
+        return getDiscoveryExtensions(lang as any).map(ext => `**/*${ext}`)
     }
 
     switch (language) {
         case 'typescript':
             return {
-                patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}'],
+                patterns: [...toPatterns(language), '**/*.js', '**/*.jsx'],
+                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}', '**/venv/**', '**/.venv/**'],
             }
         case 'javascript':
             return {
-                patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}'],
+                patterns: [...toPatterns(language), '**/*.ts', '**/*.tsx'],
+                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}', '**/venv/**', '**/.venv/**'],
             }
         case 'python':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/__pycache__/**', '**/venv/**', '**/.venv/**', '**/.tox/**', '**/test_*.py', '**/*_test.py'],
+                ignore: [...commonIgnore, '**/__pycache__/**', '**/venv/**', '**/.venv/**', '**/.tox/**', '**/test_*.py', '**/*_test.py', '**/lib/site-packages/**'],
             }
         case 'go':
             return {
@@ -341,7 +411,7 @@ export function getDiscoveryPatterns(language: ProjectLanguage): { patterns: str
             }
         case 'java':
             return {
-                patterns: toPatterns(language),
+                patterns: [...toPatterns(language), '**/*.kt', '**/*.kts'],
                 ignore: [...commonIgnore, '**/target/**', '**/.gradle/**', '**/Test*.java', '**/*Test.java'],
             }
         case 'swift':
@@ -352,34 +422,47 @@ export function getDiscoveryPatterns(language: ProjectLanguage): { patterns: str
         case 'ruby':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/vendor/**', '**/*_spec.rb', '**/spec/**'],
+                ignore: [...commonIgnore, '**/vendor/**', '**/*.gemspec'],
             }
         case 'php':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/vendor/**', '**/*Test.php'],
+                ignore: [...commonIgnore, '**/vendor/**', '**/tests/**', '**/Test*.php'],
             }
         case 'csharp':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/bin/**', '**/obj/**'],
+                ignore: [...commonIgnore, '**/bin/**', '**/obj/**', '**/*Test.cs'],
             }
-        case 'cpp':
+        case 'c':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/build/**', '**/cmake-build-*/**'],
+                ignore: [...commonIgnore, '**/*.h'],
             }
-        case 'c':
+        case 'cpp':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/build/**'],
+                ignore: [...commonIgnore, '**/build/**', '**/*.hpp'],
             }
-        default:
-            // Fallback: discover JS/TS (most common)
+        case 'polyglot':
             return {
                 patterns: toPatterns(language),
-                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/*.d.ts'],
+                ignore: [
+                    ...commonIgnore,
+                    '**/node_modules/**', '**/dist/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**',
+                    '**/__pycache__/**', '**/venv/**', '**/.venv/**', '**/.tox/**', '**/lib/site-packages/**',
+                    '**/vendor/**', '**/target/**', '**/.gradle/**', '**/.build/**', '**/bin/**', '**/obj/**',
+                    '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}',
+                    '**/test_*.py', '**/*_test.py', '**/Test*.java', '**/*Test.java', '**/*Test.cs',
+                ],
+            }
+        case 'unknown':
+            return {
+                patterns: ['**/*.{ts,tsx,js,jsx}'],
+                ignore: [...commonIgnore, '**/node_modules/**'],
             }
+        default:
+            return { patterns: [], ignore: commonIgnore }
     }
 }
 
@@ -431,29 +514,17 @@ export async function fileExists(filePath: string): Promise<boolean> {
 
 /**
  * Set up the .mikk directory structure in a project root.
+ * Only creates directories that are actually used.
  */
 export async function setupMikkDirectory(projectRoot: string): Promise<void> {
     const dirs = [
         '.mikk',
-        '.mikk/fragments',
-        '.mikk/diagrams',
-        '.mikk/diagrams/modules',
-        '.mikk/diagrams/capsules',
-        '.mikk/diagrams/flows',
-        '.mikk/diagrams/impact',
-        '.mikk/diagrams/exposure',
-        '.mikk/intent',
         '.mikk/cache',
+        '.mikk/transactions',
     ]
     for (const dir of dirs) {
         await fs.mkdir(path.join(projectRoot, dir), { recursive: true })
     }
-
-    // Create .gitkeep in impact dir
-    const impactKeep = path.join(projectRoot, '.mikk/diagrams/impact/.gitkeep')
-    if (!await fileExists(impactKeep)) {
-        await fs.writeFile(impactKeep, '', 'utf-8')
-    }
 }
 
 // --- .mikkignore auto-generation --------------------------------------------
@@ -625,6 +696,20 @@ const LANGUAGE_IGNORE_TEMPLATES: Record<ProjectLanguage, string[]> = {
         '__tests__/',
         '',
     ],
+    polyglot: [
+        '# Multi-language project',
+        '**/node_modules/**',
+        '**/venv/**',
+        '**/.venv/**',
+        '**/__pycache__/**',
+        '**/site-packages/**',
+        '**/vendor/**',
+        '**/target/**',
+        '**/build/**',
+        '**/dist/**',
+        '**/.next/**',
+        '',
+    ],
 }
 
 /**

package/src/utils/json.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import * as fs from 'node:fs/promises'
 
 /**

package/src/utils/language-registry.ts

@@ -14,14 +14,38 @@ export type RegistryLanguage =
     | 'csharp'
     | 'c'
     | 'cpp'
+    | 'zig'
+    | 'elixir'
+    | 'haskell'
+    | 'scala'
+    | 'dart'
+    | 'lua'
+    | 'julia'
+    | 'clojure'
+    | 'fsharp'
+    | 'ocaml'
+    | 'perl'
+    | 'r'
+    | 'sql'
+    | 'terraform'
+    | 'shell'
+    | 'vue'
+    | 'svelte'
+    | 'jsx'
+    | 'tsx'
+    | 'polyglot'
     | 'unknown'
 
-const OXC_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'] as const
+const OXC_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.vue', '.svelte'] as const
 const GO_EXTENSIONS = ['.go'] as const
 const TREE_SITTER_EXTENSIONS = [
     '.py', '.java', '.kt', '.kts', '.swift',
     '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh',
     '.cs', '.rs', '.php', '.rb',
+    '.zig', '.ex', '.exs', '.hs', '.scala', '.sc',
+    '.dart', '.lua', '.jl', '.clj', '.cljs', '.fs', '.fsx',
+    '.ml', '.mli', '.pl', '.pm', '.r', '.R', '.sql',
+    '.tf', '.sh', '.bash', '.zsh',
 ] as const
 
 const PARSER_EXTENSIONS: Record<Exclude<ParserKind, 'unknown'>, readonly string[]> = {
@@ -31,19 +55,54 @@ const PARSER_EXTENSIONS: Record<Exclude<ParserKind, 'unknown'>, readonly string[
 }
 
 const LANGUAGE_EXTENSIONS: Record<RegistryLanguage, readonly string[]> = {
-    typescript: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
-    javascript: ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx'],
-    python: ['.py'],
+    typescript: ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'],
+    javascript: ['.js', '.jsx', '.mjs', '.cjs'],
+    vue: ['.vue'],
+    svelte: ['.svelte'],
+    jsx: ['.jsx'],
+    tsx: ['.tsx'],
+    python: ['.py', '.pyw'],
     go: ['.go'],
     rust: ['.rs'],
     kotlin: ['.kt', '.kts'],
-    java: ['.java', '.kt', '.kts'],
+    java: ['.java'],
     swift: ['.swift'],
     ruby: ['.rb'],
     php: ['.php'],
     csharp: ['.cs'],
     c: ['.c', '.h'],
     cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh', '.h'],
+    zig: ['.zig'],
+    elixir: ['.ex', '.exs'],
+    haskell: ['.hs'],
+    scala: ['.scala', '.sc'],
+    dart: ['.dart'],
+    lua: ['.lua'],
+    julia: ['.jl'],
+    clojure: ['.clj', '.cljs', '.cljc'],
+    fsharp: ['.fs', '.fsx', '.fsi'],
+    ocaml: ['.ml', '.mli'],
+    perl: ['.pl', '.pm'],
+    r: ['.r', '.R'],
+    sql: ['.sql'],
+    terraform: ['.tf'],
+    shell: ['.sh', '.bash', '.zsh'],
+    polyglot: [
+        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+        '.py', '.vue', '.svelte',
+        '.go',
+        '.rs',
+        '.java', '.kt', '.kts',
+        '.swift',
+        '.rb',
+        '.php',
+        '.cs',
+        '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh',
+        '.zig', '.ex', '.exs', '.hs', '.scala', '.sc',
+        '.dart', '.lua', '.jl', '.clj', '.cljs', '.cljc',
+        '.fs', '.fsx', '.fsi', '.ml', '.mli', '.pl', '.pm',
+        '.r', '.R', '.sql', '.tf', '.sh', '.bash', '.zsh',
+    ],
     unknown: ['.ts', '.tsx', '.js', '.jsx'],
 }
 
@@ -69,6 +128,38 @@ export function languageForExtension(ext: string): RegistryLanguage {
     return EXT_TO_LANGUAGE.get(ext.toLowerCase()) ?? 'unknown'
 }
 
+const VALID_PARSED_FILE_LANGUAGES = new Set([
+    // Mainstream Languages (22)
+    'javascript', 'typescript', 'python', 'java', 'csharp', 'cpp', 'c',
+    'php', 'ruby', 'swift', 'go', 'kotlin', 'rust', 'dart', 'scala',
+    'haskell', 'elixir', 'clojure', 'fsharp', 'ocaml', 'perl', 'r',
+    // Systems Languages
+    'zig',
+    // Scripting Languages
+    'lua', 'julia',
+    // Special Purpose
+    'sql', 'terraform', 'shell',
+    // Web Frameworks
+    'vue', 'svelte',
+    // Fallback
+    'unknown'
+])
+
+export function toParsedFileLanguage(lang: RegistryLanguage): ParsedFileLanguage {
+    return VALID_PARSED_FILE_LANGUAGES.has(lang)
+        ? lang as ParsedFileLanguage
+        : 'unknown'
+}
+
+export type ParsedFileLanguage = 
+    | 'javascript' | 'typescript' | 'python' | 'java' | 'csharp' | 'cpp' | 'c'
+    | 'php' | 'ruby' | 'swift' | 'go' | 'kotlin' | 'rust' | 'dart' | 'scala'
+    | 'haskell' | 'elixir' | 'clojure' | 'fsharp' | 'ocaml' | 'perl' | 'r'
+    | 'zig' | 'lua' | 'julia'
+    | 'sql' | 'terraform' | 'shell'
+    | 'vue' | 'svelte'
+    | 'unknown'
+
 export function getParserExtensions(kind: Exclude<ParserKind, 'unknown'>): readonly string[] {
     return PARSER_EXTENSIONS[kind]
 }

package/src/utils/minimatch.ts

@@ -4,7 +4,7 @@
  * Rules:
  *   - Pattern with no glob chars (*, ?, {, [) → directory prefix match
  *     "src/auth" matches "src/auth/jwt.ts" and "src/auth" itself
- *   - "**" matches any depth
+ *   - "**" matches any depth (zero or more directory segments)
  *   - "*"  matches within a single directory segment
  */
 export function minimatch(filePath: string, pattern: string): boolean {
@@ -17,12 +17,55 @@ export function minimatch(filePath: string, pattern: string): boolean {
     return normalizedPath === bare || normalizedPath.startsWith(bare + '/')
   }
 
-  // Convert glob to regex
-  const regexStr = normalizedPattern
+  // Handle patterns that start with ** - these should match anywhere in the path
+  // e.g., **/venv/** should match if there's a /venv/ segment anywhere
+  if (normalizedPattern.startsWith('**/')) {
+    const rest = normalizedPattern.slice(3) // Remove **/
+    // Check if the rest of the pattern appears as a path segment
+    // For **/venv/**, check if /venv/ is in the path
+    // For **/node_modules/**, check if /node_modules/ is in the path
+    const segments = normalizedPath.split('/')
+    const patternSegments = rest.split('/').filter(Boolean)
+    
+    // Check if pattern segments appear consecutively in path
+    for (let i = 0; i <= segments.length - patternSegments.length; i++) {
+      let match = true
+      for (let j = 0; j < patternSegments.length; j++) {
+        const pseg = patternSegments[j].replace(/\*/g, '[^/]*')
+        if (!new RegExp('^' + pseg + '$', 'i').test(segments[i + j])) {
+          match = false
+          break
+        }
+      }
+      if (match) return true
+    }
+    return false
+  }
+
+  // Convert glob to regex (for patterns not starting with **)
+  let regexStr = normalizedPattern
+    .replace(/\[/g, '\\[')
+    .replace(/\]/g, '\\]')
     .replace(/\./g, '\\.')
-    .replace(/\*\*\//g, '(?:.+/)?')
-    .replace(/\*\*/g, '.*')
-    .replace(/\*/g, '[^/]*')
+  
+  // Replace **/ at end with (?:[^/]+/)* - matches zero or more dir segments ending with /
+  // But we need to handle path/** specifically - matching path/file, path/dir/file, etc.
+  
+  // Handle trailing /** specifically - should match path itself and anything under it
+  if (normalizedPattern.endsWith('/**')) {
+    const base = normalizedPattern.slice(0, -3) // Remove /**
+    // Match either exact base or base + anything
+    return normalizedPath === base || normalizedPath.startsWith(base + '/')
+  }
+  
+  // Replace **/ with (?:[^/]+/)* - matches zero or more directory segments
+  regexStr = regexStr.replace(/\*\*\//g, '(?:[^/]+/)*')
+  // Replace trailing ** with (?:[^/]+/)*[^/]+ - matches zero or more at end  
+  regexStr = regexStr.replace(/\*\*$/g, '(?:[^/]+/)*[^/]+')
+  // Standalone **
+  regexStr = regexStr.replace(/\*\*/g, '(?:[^/]+/)*[^/]+')
+  // Single * matches any characters except slash
+  regexStr = regexStr.replace(/\*/g, '[^/]*')
 
   return new RegExp(`^${regexStr}$`, 'i').test(normalizedPath)
 }

package/src/utils/path.ts

@@ -0,0 +1,26 @@
+export function normalizeSlashes(filePath: string): string {
+    return filePath.replace(/\\/g, '/')
+}
+
+export function normalizePath(filePath: string, lowercase: boolean = true): string {
+    const normalized = normalizeSlashes(filePath)
+    return lowercase ? normalized.toLowerCase() : normalized
+}
+
+export function normalizePathQuiet(filePath: string): string {
+    return normalizeSlashes(filePath).toLowerCase()
+}
+
+export function getPathKey(filePath: string): string {
+    return normalizePath(filePath, true)
+}
+
+export function pathsEqual(a: string, b: string): boolean {
+    return normalizePathQuiet(a) === normalizePathQuiet(b)
+}
+
+export function isSubPath(child: string, parent: string): boolean {
+    const childNorm = normalizePathQuiet(child)
+    const parentNorm = normalizePathQuiet(parent)
+    return childNorm.startsWith(parentNorm + '/') || childNorm === parentNorm
+}

package/tests/dead-code.test.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect } from 'bun:test'
 import { DeadCodeDetector } from '../src/graph/dead-code-detector'
-import { buildTestGraph, mockFunction } from './helpers'
-import { GraphBuilder } from '../src/graph/graph-builder'
+import { buildTestGraph } from './helpers'
 import type { MikkLock } from '../src/contract/schema'
 
+const _GraphBuilder = { addNode: () => {}, addEdge: () => {}, build: () => new Map() }
+
 /** Helper to generate a dummy lock file from graph nodes for the detector */
 function generateDummyLock(graphNodes: Map<string, any>): MikkLock {
     const lock: MikkLock = {