@getmikk/core 2.0.14 → 2.0.15

package/src/utils/errors.ts

@@ -2,12 +2,25 @@ export class MikkError extends Error {
     constructor(message: string, public code: string) {
         super(message)
         this.name = 'MikkError'
+        Error.captureStackTrace?.(this, this.constructor)
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            stack: this.stack,
+        }
     }
 }
 
 export class ParseError extends MikkError {
-    constructor(file: string, cause: string) {
-        super(`Failed to parse ${file}: ${cause}`, 'PARSE_ERROR')
+    constructor(file: string, cause: string | Error) {
+        const message = cause instanceof Error 
+            ? `Failed to parse ${file}: ${cause.message}` 
+            : `Failed to parse ${file}: ${cause}`
+        super(message, 'PARSE_ERROR')
     }
 }
 
@@ -18,8 +31,11 @@ export class ContractNotFoundError extends MikkError {
 }
 
 export class LockNotFoundError extends MikkError {
-    constructor() {
-        super(`No mikk.lock.json found. Run 'mikk analyze' first.`, 'LOCK_NOT_FOUND')
+    constructor(path?: string) {
+        const msg = path 
+            ? `No mikk.lock.json found at ${path}. Run 'mikk analyze' first.` 
+            : `No mikk.lock.json found. Run 'mikk analyze' first.`
+        super(msg, 'LOCK_NOT_FOUND')
     }
 }
 
@@ -40,3 +56,72 @@ export class SyncStateError extends MikkError {
         super(`Mikk is in ${status} state. Run 'mikk analyze' to sync.`, 'SYNC_STATE_ERROR')
     }
 }
+
+export class EmbeddingError extends MikkError {
+    constructor(message: string, cause?: Error) {
+        const fullMessage = cause 
+            ? `${message}: ${cause.message}` 
+            : message
+        super(fullMessage, 'EMBEDDING_ERROR')
+    }
+}
+
+export class SearchError extends MikkError {
+    constructor(message: string, cause?: Error) {
+        const fullMessage = cause 
+            ? `${message}: ${cause.message}` 
+            : message
+        super(fullMessage, 'SEARCH_ERROR')
+    }
+}
+
+export class ValidationError extends MikkError {
+    constructor(message: string) {
+        super(message, 'VALIDATION_ERROR')
+    }
+}
+
+export class ConfigurationError extends MikkError {
+    constructor(message: string) {
+        super(message, 'CONFIGURATION_ERROR')
+    }
+}
+
+export class TimeoutError extends MikkError {
+    constructor(operation: string, timeoutMs: number) {
+        super(`Operation '${operation}' timed out after ${timeoutMs}ms`, 'TIMEOUT')
+    }
+}
+
+export class CacheError extends MikkError {
+    constructor(message: string, cause?: Error) {
+        const fullMessage = cause 
+            ? `Cache error: ${message}: ${cause.message}` 
+            : `Cache error: ${message}`
+        super(fullMessage, 'CACHE_ERROR')
+    }
+}
+
+export function isMikkError(error: unknown): error is MikkError {
+    return error instanceof MikkError
+}
+
+export function getErrorCode(error: unknown): string {
+    if (error instanceof MikkError) {
+        return error.code
+    }
+    if (error instanceof Error) {
+        return error.name.toUpperCase().replace(/\s+/g, '_')
+    }
+    return 'UNKNOWN'
+}
+
+export function formatError(error: unknown): string {
+    if (isMikkError(error)) {
+        return `[${error.code}] ${error.message}`
+    }
+    if (error instanceof Error) {
+        return `${error.name}: ${error.message}`
+    }
+    return String(error)
+}

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')
@@ -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'
 }
 
@@ -320,12 +386,12 @@ export function getDiscoveryPatterns(language: ProjectLanguage): { patterns: str
     switch (language) {
         case 'typescript':
             return {
-                patterns: toPatterns(language),
+                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),
+                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':
@@ -345,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':
@@ -448,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 --------------------------------------------

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,15 +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[]> = {
@@ -32,22 +55,41 @@ 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',
+        '.py', '.vue', '.svelte',
         '.go',
         '.rs',
         '.java', '.kt', '.kts',
@@ -56,6 +98,10 @@ const LANGUAGE_EXTENSIONS: Record<RegistryLanguage, readonly string[]> = {
         '.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'],
 }
@@ -82,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/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 = {