@getmikk/core 2.0.13 → 2.0.15

package/src/graph/symbol-table.ts

@@ -0,0 +1,252 @@
+import type { ParsedFile, ParsedImport } from '../parser/types.js'
+import { normalizePathQuiet } from '../utils/path.js'
+
+export interface SymbolDefinition {
+    id: string
+    name: string
+    type: 'function' | 'class' | 'variable' | 'interface' | 'type' | 'enum'
+    file: string
+    isExported: boolean
+}
+
+export interface ImportAlias {
+    localName: string
+    exportedName: string
+    sourcePath: string
+}
+
+/**
+ * GlobalSymbolTable — The brain of Mikk's semantic reasoning.
+ * Indexes all exported symbols and provides resolution logic for calls.
+ * Supports: named imports, default imports, aliased imports, local symbols, and fuzzy matching.
+ * 
+ * Case sensitivity: Symbol names are case-sensitive for accurate resolution.
+ * Fallback to case-insensitive matching only when no exact match exists.
+ */
+export class GlobalSymbolTable {
+    private exportsByFile = new Map<string, Map<string, SymbolDefinition>>()
+    private symbolsByName = new Map<string, SymbolDefinition[]>()
+    private importAliases: ImportAlias[] = []
+    private reexportsByFile = new Map<string, Map<string, string>>()
+    private resolveCache = new Map<string, string | null>()
+    private resolveCacheOrder: string[] = []
+    private importsByFile = new Map<string, ParsedImport[]>()
+
+    private static readonly MAX_RESOLVE_CACHE_SIZE = 10000
+
+    private cacheResolve(key: string, value: string | null): void {
+        if (this.resolveCache.size >= GlobalSymbolTable.MAX_RESOLVE_CACHE_SIZE) {
+            const oldestKey = this.resolveCacheOrder.shift()
+            if (oldestKey) this.resolveCache.delete(oldestKey)
+        }
+        this.resolveCache.set(key, value)
+        this.resolveCacheOrder.push(key)
+    }
+
+    register(file: ParsedFile): void {
+        const fileExports = new Map<string, SymbolDefinition>()
+        const filePath = normalizePathQuiet(file.path)
+        const fileReexports = new Map<string, string>()
+
+        const registerSymbol = (name: string, type: SymbolDefinition['type'], id: string, isExported: boolean) => {
+            const def: SymbolDefinition = { id, name, type, file: filePath, isExported }
+            
+            if (isExported) {
+                fileExports.set(name, def)
+            }
+
+            const byName = this.symbolsByName.get(name) ?? []
+            byName.push(def)
+            this.symbolsByName.set(name, byName)
+        }
+
+        for (const fn of file.functions) registerSymbol(fn.name, 'function', fn.id, fn.isExported)
+        for (const cls of file.classes ?? []) {
+            registerSymbol(cls.name, 'class', cls.id, cls.isExported)
+            for (const m of cls.methods) {
+                const fullName = `${cls.name}.${m.name}`
+                registerSymbol(fullName, 'function', m.id, false)
+                const byName = this.symbolsByName.get(m.name) ?? []
+                byName.push({ id: m.id, name: m.name, type: 'function', file: filePath, isExported: false })
+                this.symbolsByName.set(m.name, byName)
+            }
+        }
+        for (const gen of file.generics ?? []) {
+            const validType = gen.type === 'interface' || gen.type === 'type' ? gen.type : 'type'
+            registerSymbol(gen.name, validType, gen.id, gen.isExported)
+        }
+        for (const v of file.variables ?? []) registerSymbol(v.name, 'variable', v.id, v.isExported)
+
+        for (const imp of file.imports) {
+            if (!imp.resolvedPath || imp.isDynamic) continue
+            const resolvedPath = normalizePathQuiet(imp.resolvedPath)
+            for (const spec of imp.specifiers ?? []) {
+                if (spec.imported && spec.local && spec.imported !== spec.local) {
+                    this.importAliases.push({
+                        localName: spec.local,
+                        exportedName: spec.imported,
+                        sourcePath: resolvedPath,
+                    })
+                }
+            }
+        }
+
+        for (const re of file.reexports ?? []) {
+            if (re.sourceResolved) {
+                fileReexports.set(re.name, normalizePathQuiet(re.sourceResolved))
+            }
+        }
+
+        this.exportsByFile.set(filePath, fileExports)
+        if (fileReexports.size > 0) {
+            this.reexportsByFile.set(filePath, fileReexports)
+        }
+        const fileImports = file.imports.filter(i => i.resolvedPath && !i.isDynamic)
+        this.importsByFile.set(filePath, fileImports)
+    }
+
+    resolve(callName: string, contextFile: string, imports: ParsedImport[]): string | null {
+        const hasDot = callName.includes('.')
+        const receiver = hasDot ? callName.split('.')[0] : null
+        const simpleName = hasDot ? callName.split('.').pop()! : callName
+        const normalizedContextFile = normalizePathQuiet(contextFile)
+
+        const cacheKey = `${normalizedContextFile}:${callName}`
+        if (this.resolveCache.has(cacheKey)) {
+            return this.resolveCache.get(cacheKey)!
+        }
+
+        const importsToUse = this.importsByFile.get(normalizedContextFile) ?? imports.filter(i => i.resolvedPath && !i.isDynamic)
+        let result: string | null = null
+
+        for (const imp of importsToUse) {
+            if (!imp.resolvedPath) continue
+            const resolvedPath = normalizePathQuiet(imp.resolvedPath)
+
+            if (imp.isDynamic) continue
+
+            if (hasDot && receiver) {
+                if (imp.isDefault && imp.names.some(n => n === receiver || n.toLowerCase() === receiver.toLowerCase())) {
+                    const target = this.getExport(resolvedPath, simpleName)
+                    if (target) { result = target.id; break }
+                    const methodTarget = this.getMethodByClassCaseInsensitive(resolvedPath, receiver, simpleName)
+                    if (methodTarget) { result = methodTarget; break }
+                }
+
+                const alias = this.importAliases.find(
+                    a => a.localName === receiver && a.sourcePath === resolvedPath
+                )
+                if (alias) {
+                    const target = this.getExport(resolvedPath, alias.exportedName)
+                    if (target) { result = target.id; break }
+                }
+
+                const receiverLower = receiver.toLowerCase()
+                const aliasLower = this.importAliases.find(
+                    a => a.localName.toLowerCase() === receiverLower && a.sourcePath === resolvedPath
+                )
+                if (aliasLower) {
+                    const target = this.getExport(resolvedPath, aliasLower.exportedName)
+                    if (target) { result = target.id; break }
+                }
+
+                const methodTarget = this.getMethodByClassCaseInsensitive(resolvedPath, receiver, simpleName)
+                if (methodTarget) { result = methodTarget; break }
+            }
+
+            const matchedLocal = imp.names.find(n => 
+                n === callName || 
+                n === simpleName ||
+                n.toLowerCase() === callName.toLowerCase() ||
+                n.toLowerCase() === simpleName.toLowerCase() ||
+                this.importAliases.some(a => a.localName === n && (a.exportedName === callName || a.exportedName === simpleName)) ||
+                this.importAliases.some(a => a.localName.toLowerCase() === n.toLowerCase() && (a.exportedName.toLowerCase() === callName.toLowerCase() || a.exportedName.toLowerCase() === simpleName.toLowerCase()))
+            )
+            if (matchedLocal) {
+                const alias = this.importAliases.find(a => a.localName === matchedLocal)
+                const exportedName = alias ? alias.exportedName : simpleName
+                const target = this.getExport(resolvedPath, exportedName)
+                if (target) { result = target.id; break }
+            }
+        }
+
+        if (!result) {
+            const localTarget = this.getExport(normalizedContextFile, callName)
+            if (localTarget) { result = localTarget.id }
+        }
+
+        if (!result) {
+            const globalMatches = this.symbolsByName.get(callName) ?? this.symbolsByName.get(simpleName)
+            if (globalMatches?.length === 1) {
+                result = globalMatches[0].id
+            }
+        }
+
+        if (!result) {
+            const lowerCallName = callName.toLowerCase()
+            const lowerSimpleName = simpleName.toLowerCase()
+            const lowerGlobalMatches = this.symbolsByName.get(lowerCallName) ?? this.symbolsByName.get(lowerSimpleName)
+            if (lowerGlobalMatches?.length === 1) {
+                result = lowerGlobalMatches[0].id
+            }
+        }
+
+        if (!result && hasDot && receiver) {
+            const methodTarget = this.getMethodGlobally(receiver, simpleName)
+            if (methodTarget) { result = methodTarget }
+        }
+
+        this.cacheResolve(cacheKey, result)
+        return result
+    }
+
+    private getExport(filePath: string, name: string, visited: Set<string> = new Set()): SymbolDefinition | undefined {
+        if (visited.has(filePath + ':' + name)) return undefined
+        visited.add(filePath + ':' + name)
+
+        const exports = this.exportsByFile.get(filePath)
+        if (exports) {
+            const def = exports.get(name) ?? exports.get(name.toLowerCase())
+            if (def) return def
+        }
+
+        const reexports = this.reexportsByFile.get(filePath)
+        if (reexports) {
+            const reexportPath = reexports.get(name) ?? reexports.get(name.toLowerCase())
+            if (reexportPath) {
+                return this.getExport(reexportPath, name, visited)
+            }
+        }
+
+        return undefined
+    }
+
+    private getMethodByClassCaseInsensitive(filePath: string, className: string, methodName: string): string | null {
+        const exports = this.exportsByFile.get(filePath)
+        if (!exports) return null
+        
+        for (const [name, def] of exports) {
+            if (def.type === 'class' && name.toLowerCase() === className.toLowerCase()) {
+                const methodFullName = `${name}.${methodName}`
+                const method = this.symbolsByName.get(methodFullName)
+                if (method?.length === 1) return method[0].id
+                
+                const methodLowerName = `${name.toLowerCase()}.${methodName.toLowerCase()}`
+                const methodLower = this.symbolsByName.get(methodLowerName)
+                if (methodLower?.length === 1) return methodLower[0].id
+            }
+        }
+        return null
+    }
+
+    private getMethodGlobally(className: string, methodName: string): string | null {
+        for (const [name, defs] of this.symbolsByName) {
+            if (defs[0]?.type === 'class' && name.toLowerCase() === className.toLowerCase()) {
+                const methodFullName = `${name}.${methodName}`
+                const method = this.symbolsByName.get(methodFullName)
+                if (method?.length === 1) return method[0].id
+            }
+        }
+        return null
+    }
+}

package/src/hash/hash-store.ts

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

package/src/index.ts

@@ -6,6 +6,9 @@ export * from './graph/index.js'
 export * from './contract/index.js'
 export * from './hash/index.js'
 export * from './search/index.js'
+export * from './cache/index.js'
+export * from './security/index.js'
+export * from './analysis/index.js'
 export * from './utils/errors.js'
 export * from './utils/logger.js'
 export { MikkError, ErrorHandler, ErrorBuilder, ErrorCategory, FileSystemError, ModuleLoadError, GraphError, TokenBudgetError, ValidationError, createDefaultErrorListener, createFileNotFoundError, createFileTooLargeError, createPermissionDeniedError, createModuleNotFoundError, createModuleLoadFailedError, createGraphBuildFailedError, createNodeNotFoundError, createTokenBudgetExceededError, createValidationError, isMikkError, getRootCause, toMikkError } from './error-handler.js'
@@ -16,6 +19,7 @@ export { minimatch } from './utils/minimatch.js'
 export { scoreFunctions, findFuzzyMatches, levenshtein, splitCamelCase, extractKeywords } from './utils/fuzzy-match.js'
 export { writeFileAtomic, writeJsonAtomic } from './utils/atomic-write.js'
 export type { AtomicWriteOptions } from './utils/atomic-write.js'
+export { normalizeSlashes, normalizePath, normalizePathQuiet, getPathKey, pathsEqual, isSubPath } from './utils/path.js'
 export {
 	runArtifactWriteTransaction,
 	recoverArtifactWriteTransactions,

package/src/parser/base-extractor.ts

@@ -0,0 +1,19 @@
+import type { ParsedFile } from './types.js';
+
+/**
+ * Abstract base class for language-specific metadata extraction.
+ * Extractors can use different engines (Tree-Sitter, OXC, etc.) internally.
+ */
+export abstract class BaseExtractor {
+  /**
+   * Main entry point to parse and extract metadata from a file
+   */
+  abstract extract(filePath: string, content: string): Promise<ParsedFile>;
+
+  /**
+   * Resolve imports for a list of files (optional, default to simple pass-through)
+   */
+  async resolveImports(files: ParsedFile[], _projectRoot: string): Promise<ParsedFile[]> {
+    return files;
+  }
+}

package/src/parser/boundary-checker.ts

@@ -53,21 +53,40 @@ function parseConstraint(constraint: string): ParsedRule | null {
 export class BoundaryChecker {
     private rules: ParsedRule[]
     private moduleNames: Map<string, string>
+    private fileModuleMap: Map<string, string>
 
     constructor(private contract: MikkContract, private lock: MikkLock) {
         this.rules = contract.declared.constraints.map(parseConstraint).filter((r): r is ParsedRule => r !== null)
         this.moduleNames = new Map(contract.declared.modules.map(m => [m.id, m.name]))
+        
+        this.fileModuleMap = new Map()
+        for (const [filePath, fileData] of Object.entries(this.lock.files)) {
+            if (fileData.moduleId && fileData.moduleId !== 'unknown') {
+                this.fileModuleMap.set(filePath.toLowerCase(), fileData.moduleId)
+            }
+        }
+    }
+
+    private getModuleId(fn: any): string {
+        if (fn.moduleId && fn.moduleId !== 'unknown') return fn.moduleId
+        const normalized = (fn.file ?? '').replace(/\\/g, '/').toLowerCase()
+        return this.fileModuleMap.get(normalized) ?? 'unknown'
     }
 
     check(): BoundaryCheckResult {
         const violations: BoundaryViolation[] = []
+        const fnIndex = (this.lock as any).fnIndex ?? []
 
         for (const fn of Object.values(this.lock.functions)) {
-            if (fn.moduleId === 'unknown') continue
-            for (const calleeId of fn.calls) {
+            const fnModuleId = this.getModuleId(fn)
+            if (fnModuleId === 'unknown') continue
+            const calls = (fn.calls ?? []).map((c: any) => typeof c === 'number' ? fnIndex[c] : c).filter(Boolean)
+            for (const calleeId of calls) {
                 const callee = this.lock.functions[calleeId]
-                if (!callee || callee.moduleId === 'unknown' || fn.moduleId === callee.moduleId) continue
-                const v = this.checkCall(fn, callee)
+                if (!callee) continue
+                const calleeModuleId = this.getModuleId(callee)
+                if (calleeModuleId === 'unknown' || fnModuleId === calleeModuleId) continue
+                const v = this.checkCall(fn, callee, fnModuleId, calleeModuleId)
                 if (v) violations.push(v)
             }
         }
@@ -97,21 +116,21 @@ export class BoundaryChecker {
         const errorCount = unique.filter(v => v.severity === 'error').length
         const warnCount = unique.filter(v => v.severity === 'warning').length
         const summary = unique.length === 0
-            ? `All module boundaries respected (${fnCount} functions, ${fileCount} files checked)`
-            : `${errorCount} boundary error(s), ${warnCount} warning(s) found`
+            ? `All module boundaries respected (${fnCount} fns, ${fileCount} files checked)`
+            : `${errorCount} error(s), ${warnCount} warning(s) found`
 
         return { pass: errorCount === 0, violations: unique, summary }
     }
 
-    private checkCall(caller: MikkLockFunction, callee: MikkLockFunction): BoundaryViolation | null {
+    private checkCall(caller: any, callee: any, callerModuleId: string, calleeModuleId: string): BoundaryViolation | null {
         for (const rule of this.rules) {
-            if (rule.fromModuleId !== caller.moduleId) continue
+            if (rule.fromModuleId !== callerModuleId) continue
             const forbidden = rule.type === 'isolated' ? true
-                : rule.type === 'deny' ? rule.toModuleIds.includes(callee.moduleId)
-                : !rule.toModuleIds.includes(callee.moduleId)
+                : rule.type === 'deny' ? rule.toModuleIds.includes(calleeModuleId)
+                : !rule.toModuleIds.includes(calleeModuleId)
             if (forbidden) return {
-                from: { functionId: caller.id, functionName: caller.name, file: caller.file, moduleId: caller.moduleId, moduleName: this.moduleNames.get(caller.moduleId) ?? caller.moduleId },
-                to: { functionId: callee.id, functionName: callee.name, file: callee.file, moduleId: callee.moduleId, moduleName: this.moduleNames.get(callee.moduleId) ?? callee.moduleId },
+                from: { functionId: caller.id, functionName: caller.name, file: caller.file, moduleId: callerModuleId, moduleName: this.moduleNames.get(callerModuleId) ?? callerModuleId },
+                to: { functionId: callee.id, functionName: callee.name, file: callee.file, moduleId: calleeModuleId, moduleName: this.moduleNames.get(calleeModuleId) ?? calleeModuleId },
                 rule: rule.raw, severity: 'error'
             }
         }