@getmikk/core 1.8.3 → 2.0.0

package/src/graph/types.ts

@@ -1,83 +1,107 @@
-/**
- * Graph types — nodes, edges, and the dependency graph itself.
- */
+export type NodeType =
+  | "file"
+  | "class"
+  | "function"
+  | "variable"
+  | "generic";
 
-export type NodeType = 'function' | 'file' | 'module' | 'class' | 'generic'
-export type EdgeType = 'calls' | 'imports' | 'exports' | 'contains'
+export type EdgeType =
+  | "imports"
+  | "calls"
+  | "extends"
+  | "implements"
+  | "accesses"
+  | "contains"; // Keeping for containment edges
 
-/** A single node in the dependency graph */
 export interface GraphNode {
-    id: string              // "fn:src/auth/verify.ts:verifyToken"
-    type: NodeType
-    label: string           // "verifyToken"
-    file: string            // "src/auth/verify.ts"
-    moduleId?: string       // "auth" — which declared module this belongs to
-    metadata: {
-        startLine?: number
-        endLine?: number
-        isExported?: boolean
-        isAsync?: boolean
-        hash?: string
-        purpose?: string
-        genericKind?: string
-        params?: { name: string; type: string; optional?: boolean }[]
-        returnType?: string
-        edgeCasesHandled?: string[]
-        errorHandling?: { line: number; type: 'try-catch' | 'throw'; detail: string }[]
-        detailedLines?: { startLine: number; endLine: number; blockType: string }[]
-    }
+  id: string;              // unique (normalized file::name)
+  type: NodeType;
+  name: string;
+  file: string;
+  moduleId?: string;       // Original cluster feature
+
+  metadata?: {
+    isExported?: boolean;
+    inheritsFrom?: string[];
+    implements?: string[];
+    className?: string; // for methods
+    startLine?: number;
+    endLine?: number;
+    isAsync?: boolean;
+    hash?: string;
+    purpose?: string;
+    genericKind?: string;
+    params?: { name: string; type: string; optional?: boolean }[];
+    returnType?: string;
+    edgeCasesHandled?: string[];
+    errorHandling?: { line: number; type: 'try-catch' | 'throw'; detail: string }[];
+    detailedLines?: { startLine: number; endLine: number; blockType: string }[];
+  };
 }
 
-/** A single edge in the dependency graph */
 export interface GraphEdge {
-    source: string          // "fn:src/auth/verify.ts:verifyToken"
-    target: string          // "fn:src/utils/jwt.ts:jwtDecode"
-    type: EdgeType
-    weight?: number         // How often this call happens (for coupling metrics)
-    confidence?: number     // 0.0–1.0: 1.0 = direct AST call, 0.8 = via interface, 0.5 = fuzzy/inferred
+  from: string;
+  to: string;
+  type: EdgeType;
+  confidence: number; // 0–1
+  weight?: number;    // Weight from EDGE_WEIGHT constants
 }
 
-/** The full dependency graph */
 export interface DependencyGraph {
-    nodes: Map<string, GraphNode>
-    edges: GraphEdge[]
-    outEdges: Map<string, GraphEdge[]>   // node → [edges going out]
-    inEdges: Map<string, GraphEdge[]>    // node → [edges coming in]
+  nodes: Map<string, GraphNode>;
+  edges: GraphEdge[];
+  outEdges: Map<string, GraphEdge[]>;   // node → [edges going out]
+  inEdges: Map<string, GraphEdge[]>;    // node → [edges coming in]
 }
 
-/** Risk level for an impacted node */
-export type RiskLevel = 'critical' | 'high' | 'medium' | 'low'
-
-/** A single node in the classified impact result */
-export interface ClassifiedImpact {
-    nodeId: string
-    label: string
-    file: string
-    moduleId?: string
-    risk: RiskLevel
-    depth: number           // hops from change
+/**
+ * Canonical ID helpers.
+ * Function IDs:  fn:<absolute-posix-path>:<FunctionName>
+ * Class IDs:     class:<absolute-posix-path>:<ClassName>
+ * Type/enum IDs: type:<absolute-posix-path>:<Name> | enum:<absolute-posix-path>:<Name>
+ * File IDs:      <absolute-posix-path>  (no prefix)
+ *
+ * NOTE: The old normalizeId() that used `file::name` (double-colon, lowercase)
+ * was removed — it did not match any current ID format and would produce IDs
+ * that never matched any graph node.
+ */
+export function makeFnId(file: string, name: string): string {
+  return `fn:${file.replace(/\\/g, '/')}:${name}`;
 }
 
-/** Result of impact analysis */
+export type RiskLevel = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+
 export interface ImpactResult {
-    changed: string[]        // The directly changed nodes
-    impacted: string[]       // Everything that depends on changed nodes
-    depth: number            // How many hops from change to furthest impact
-    confidence: 'high' | 'medium' | 'low'
-    /** Risk-classified breakdown of impacted nodes */
-    classified: {
-        critical: ClassifiedImpact[]
-        high: ClassifiedImpact[]
-        medium: ClassifiedImpact[]
-        low: ClassifiedImpact[]
-    }
+  changed: string[];
+  impacted: string[];
+  allImpacted: ClassifiedImpact[]; // New field for Decision Engine
+  depth: number;
+  entryPoints: string[];
+  criticalModules: string[];
+  paths: string[][];
+  confidence: number;
+  riskScore: number;
+  classified: {
+    critical: ClassifiedImpact[];
+    high: ClassifiedImpact[];
+    medium: ClassifiedImpact[];
+    low: ClassifiedImpact[];
+  };
+}
+
+export interface ClassifiedImpact {
+  nodeId: string;
+  label: string;
+  file: string;
+  risk: RiskLevel;
+  riskScore: number; // numeric score for precise policy checks
+  depth: number;
 }
 
-/** A cluster of files that naturally belong together */
 export interface ModuleCluster {
-    id: string
-    files: string[]
-    confidence: number      // 0.0 to 1.0
-    suggestedName: string   // inferred from folder names
-    functions: string[]     // function IDs in this cluster
+  id: string;
+  files: string[];
+  confidence: number;
+  suggestedName: string;
+  functions: string[];
 }

package/src/index.ts

@@ -8,6 +8,8 @@ export * from './hash/index.js'
 export * from './search/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'
+export type { } from './error-handler.js'
 export { discoverFiles, discoverContextFiles, readFileContent, writeFileContent, fileExists, setupMikkDirectory, readMikkIgnore, parseMikkIgnore, detectProjectLanguage, getDiscoveryPatterns, generateMikkIgnore, updateGitIgnore, cleanupGitIgnore } from './utils/fs.js'
 export type { ContextFile, ContextFileType, ProjectLanguage } from './utils/fs.js'
 export { minimatch } from './utils/minimatch.js'

package/src/parser/change-detector.ts

@@ -0,0 +1,99 @@
+import type { ParsedFile } from './types.js'
+
+export interface ChangeSet {
+  added: string[];    // Symbol IDs
+  removed: string[];  // Symbol IDs
+  modified: string[]; // Symbol IDs (hash mismatch)
+}
+
+/**
+ * Mikk 2.0: Change Detector
+ * Compares parsed file versions to identify precisely which symbols 
+ * (functions, classes, etc.) have changed using AST hashes.
+ */
+export class ChangeDetector {
+  /**
+   * Compare two versions of a file and return the changed symbol IDs.
+   */
+  public detectSymbolChanges(oldFile: ParsedFile | undefined, newFile: ParsedFile): ChangeSet {
+    const added: string[] = [];
+    const removed: string[] = [];
+    const modified: string[] = [];
+
+    if (!oldFile) {
+      // Everything is new
+      return {
+        added: [
+          ...newFile.functions.map(f => f.id),
+          ...newFile.classes.map(c => c.id),
+          ...newFile.generics.map(g => g.id),
+          ...newFile.variables.map(v => v.id),
+        ],
+        removed: [],
+        modified: []
+      };
+    }
+
+    if (oldFile.hash === newFile.hash) {
+      return { added: [], removed: [], modified: [] };
+    }
+
+    // --- Compare Functions ---
+    const oldFns = new Map(oldFile.functions.map(f => [f.id, f.hash]));
+    const newFns = new Map(newFile.functions.map(f => [f.id, f.hash]));
+
+    for (const [id, hash] of newFns) {
+      if (!oldFns.has(id)) added.push(id);
+      else if (oldFns.get(id) !== hash) modified.push(id);
+    }
+    for (const id of oldFns.keys()) {
+      if (!newFns.has(id)) removed.push(id);
+    }
+
+    // --- Compare Classes ---
+    const oldClasses = new Map(oldFile.classes.map(c => [c.id, c.hash || 'no-hash'])); // ParsedClass might not have hash yet, using placeholder
+    const newClasses = new Map(newFile.classes.map(c => [c.id, c.hash || 'no-hash']));
+    
+    // Note: If ParsedClass doesn't have a hash, we might need to compare methods/properties hashes
+    // For Mikk 2.0, we'll assume classes have a summary hash eventually or just compare their structure.
+
+    for (const [id, hash] of newClasses) {
+      if (!oldClasses.has(id)) added.push(id);
+      else if (oldClasses.get(id) !== hash) modified.push(id);
+    }
+    for (const id of oldClasses.keys()) {
+      if (!newClasses.has(id)) removed.push(id);
+    }
+
+    // --- Compare Generics ---
+    const oldGenerics = new Map(oldFile.generics.map(g => [g.id, g.id])); // Simplified
+    const newGenerics = new Map(newFile.generics.map(g => [g.id, g.id]));
+
+    for (const id of newGenerics.keys()) {
+      if (!oldGenerics.has(id)) added.push(id);
+    }
+    for (const id of oldGenerics.keys()) {
+      if (!newGenerics.has(id)) removed.push(id);
+    }
+
+    return { added, removed, modified };
+  }
+
+  /**
+   * Compare two sets of files and return all modified symbol IDs across the project.
+   */
+  public detectBatchChanges(oldFiles: Map<string, ParsedFile>, newFiles: ParsedFile[]): string[] {
+    const allChangedIds = new Set<string>();
+
+    for (const file of newFiles) {
+      const old = oldFiles.get(file.path);
+      const diff = this.detectSymbolChanges(old, file);
+      
+      diff.added.forEach(id => allChangedIds.add(id));
+      diff.modified.forEach(id => allChangedIds.add(id));
+      // Removal is handled by graph-builder removing stale nodes, but we might want to track it for impact
+    }
+
+    return Array.from(allChangedIds);
+  }
+}

package/src/parser/go/go-extractor.ts

@@ -1,7 +1,7 @@
 import { hashContent } from '../../hash/file-hasher.js'
 import type {
     ParsedFunction, ParsedClass, ParsedImport, ParsedExport,
-    ParsedParam, ParsedGeneric, ParsedRoute,
+    ParsedParam, ParsedGeneric, ParsedRoute, CallExpression
 } from '../types.js'
 
 // --- Go builtins / keywords to skip when extracting calls -------------------
@@ -97,6 +97,8 @@ export class GoExtractor {
                 isExported: isExported(typeDecl.name),
                 purpose: typeDecl.purpose,
                 methods: methods.map(m => this.buildParsedFunction(m)),
+                properties: [],
+                hash: '',
             })
             byReceiver.delete(typeDecl.name)
         }
@@ -111,6 +113,9 @@ export class GoExtractor {
                 endLine: methods[methods.length - 1]?.endLine ?? 0,
                 isExported: isExported(receiverType),
                 methods: methods.map(m => this.buildParsedFunction(m)),
+                properties: [],
+                hash: '',
+                purpose: '',
             })
         }
 
@@ -250,7 +255,7 @@ export class GoExtractor {
 
         const bodyLines = this.lines.slice(raw.bodyStart - 1, raw.endLine)
         const hash = hashContent(bodyLines.join('\n'))
-        const calls = extractCallsFromBody(bodyLines)
+        const calls = extractCallsFromBody(bodyLines, raw.bodyStart)
         const edgeCases = extractEdgeCases(bodyLines)
         const errorHandling = extractErrorHandling(bodyLines, raw.bodyStart)
 
@@ -620,25 +625,30 @@ function stripStringsAndComments(code: string): string {
     return out
 }
 
-function extractCallsFromBody(bodyLines: string[]): string[] {
-    const stripped = stripStringsAndComments(bodyLines.join('\n'))
-    const calls = new Set<string>()
+function extractCallsFromBody(bodyLines: string[], baseLine: number = 1): CallExpression[] {
+    const code = bodyLines.join('\n')
+    const stripped = stripStringsAndComments(code)
+    const calls: CallExpression[] = []
 
     // Direct calls: identifier(
     const callRe = /\b([A-Za-z_]\w*)\s*\(/g
     let m: RegExpExecArray | null
     while ((m = callRe.exec(stripped)) !== null) {
         const name = m[1]
-        if (!GO_BUILTINS.has(name)) calls.add(name)
+        if (!GO_BUILTINS.has(name)) {
+            // Heuristic for line number: find the line in bodyLines
+            // This is a rough estimation but good enough for static analysis
+            calls.push({ name, line: baseLine, type: 'function' })
+        }
     }
 
     // Method calls: receiver.Method(
     const methodRe = /\b([A-Za-z_]\w+\.[A-Za-z_]\w*)\s*\(/g
     while ((m = methodRe.exec(stripped)) !== null) {
-        calls.add(m[1])
+        calls.push({ name: m[1], line: baseLine, type: 'method' })
     }
 
-    return [...calls]
+    return calls
 }
 
 function extractEdgeCases(bodyLines: string[]): string[] {

package/src/parser/go/go-parser.ts

@@ -22,6 +22,8 @@ export class GoParser extends BaseParser {
             imports: extractor.extractImports(),
             exports: extractor.extractExports(),
             routes: extractor.extractRoutes(),
+            variables: [],
+            calls: [],
             hash: hashContent(content),
             parsedAt: Date.now(),
         }

package/src/parser/index.ts

@@ -1,12 +1,22 @@
-import * as path from 'node:path'
+import * as nodePath from 'node:path'
 import { BaseParser } from './base-parser.js'
-import { TypeScriptParser } from './typescript/ts-parser.js'
+import { OxcParser } from './oxc-parser.js'
 import { GoParser } from './go/go-parser.js'
-import { JavaScriptParser } from './javascript/js-parser.js'
 import { UnsupportedLanguageError } from '../utils/errors.js'
 import type { ParsedFile } from './types.js'
 
-export type { ParsedFile, ParsedFunction, ParsedImport, ParsedExport, ParsedClass, ParsedParam } from './types.js'
+export type {
+    ParsedFile,
+    ParsedFunction,
+    ParsedImport,
+    ParsedExport,
+    ParsedClass,
+    ParsedParam,
+    ParsedVariable,
+    CallExpression,
+    ParsedGeneric,
+    ParsedRoute
+} from './types.js'
 export { BaseParser } from './base-parser.js'
 export { TypeScriptParser } from './typescript/ts-parser.js'
 export { TypeScriptExtractor } from './typescript/ts-extractor.js'
@@ -19,22 +29,20 @@ export { JavaScriptExtractor } from './javascript/js-extractor.js'
 export { JavaScriptResolver } from './javascript/js-resolver.js'
 export { BoundaryChecker } from './boundary-checker.js'
 export { TreeSitterParser } from './tree-sitter/parser.js'
-import { TreeSitterParser } from './tree-sitter/parser.js'
 
 /** Get the appropriate parser for a file based on its extension */
 export function getParser(filePath: string): BaseParser {
-    const ext = path.extname(filePath)
+    const ext = nodePath.extname(filePath).toLowerCase()
     switch (ext) {
         case '.ts':
         case '.tsx':
-            return new TypeScriptParser()
         case '.js':
         case '.mjs':
         case '.cjs':
         case '.jsx':
-            return new JavaScriptParser()
+            return new OxcParser()
         case '.go':
-            return new GoParser() // Mikk's custom Regex Go parser
+            return new GoParser()
         case '.py':
         case '.java':
         case '.c':
@@ -46,55 +54,97 @@ export function getParser(filePath: string): BaseParser {
         case '.rs':
         case '.php':
         case '.rb':
-            return new TreeSitterParser()
+            throw new UnsupportedLanguageError(ext)
         default:
             throw new UnsupportedLanguageError(ext)
     }
 }
 
-/** Parse multiple files and resolve imports across them */
+/**
+ * Parse multiple files, resolve their imports, and return ParsedFile[].
+ *
+ * Path contract (critical for graph correctness):
+ *   - filePaths come from discoverFiles() as project-root-relative strings
+ *   - We resolve them to ABSOLUTE posix paths before passing to parse()
+ *   - ParsedFile.path is therefore always absolute + forward-slash
+ *   - OxcResolver also returns absolute paths → import edges always consistent
+ */
 export async function parseFiles(
     filePaths: string[],
     projectRoot: string,
     readFile: (fp: string) => Promise<string>
 ): Promise<ParsedFile[]> {
-    const parsersMap = new Map<BaseParser, ParsedFile[]>()
-    // Re-use parser instances so they can share cache/bindings
-    const tsParser = new TypeScriptParser()
-    const jsParser = new JavaScriptParser()
+    // Shared parser instances — avoid re-initialisation overhead per file
+    const oxcParser = new OxcParser()
     const goParser = new GoParser()
-    const treeSitterParser = new TreeSitterParser()
 
-    const getCachedParser = (ext: string): BaseParser | null => {
-        switch (ext) {
-            case '.ts': case '.tsx': return tsParser
-            case '.js': case '.mjs': case '.cjs': case '.jsx': return jsParser
-            case '.go': return goParser
-            case '.py': case '.java': case '.c': case '.h': case '.cpp': case '.cc': case '.hpp': case '.cs': case '.rs': case '.php': case '.rb': return treeSitterParser
-            default: return null
+    // Lazily loaded to avoid mandatory dep on tree-sitter
+    let treeSitterParser: BaseParser | null = null
+    const getTreeSitter = async (): Promise<BaseParser> => {
+        if (!treeSitterParser) {
+            const { TreeSitterParser } = await import('./tree-sitter/parser.js')
+            treeSitterParser = new TreeSitterParser()
         }
+        return treeSitterParser!
     }
 
+    const tsExtensions = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'])
+    const goExtensions = new Set(['.go'])
+    const treeSitterExtensions = new Set(['.py', '.java', '.c', '.h', '.cpp', '.cc', '.hpp', '.cs', '.rs', '.php', '.rb'])
+
+    // Normalised project root for absolute path construction
+    const normalizedRoot = nodePath.resolve(projectRoot).replace(/\\/g, '/')
+
+    // Group by parser to enable batch resolveImports
+    const oxcFiles: ParsedFile[] = []
+    const goFiles: ParsedFile[] = []
+    const treeFiles: ParsedFile[] = []
+
+    // Parse sequentially to avoid races in parser implementations that keep
+    // mutable per-instance state (e.g. language switching/counters).
     for (const fp of filePaths) {
-        const ext = path.extname(fp).toLowerCase()
-        const parser = getCachedParser(ext)
-        if (!parser) continue
+        const ext = nodePath.extname(fp).toLowerCase()
+
+        // Build absolute posix path — this is the single source of truth for all IDs
+        const absoluteFp = nodePath.resolve(normalizedRoot, fp).replace(/\\/g, '/')
 
+        let content: string
         try {
-            const content = await readFile(path.join(projectRoot, fp))
-            const parsed = await parser.parse(fp, content)
-            
-            if (!parsersMap.has(parser)) parsersMap.set(parser, [])
-            parsersMap.get(parser)!.push(parsed)
+            content = await readFile(absoluteFp)
         } catch {
-            // Skip unreadable files (permissions, binary, etc.) — don't abort the whole parse
+            // File unreadable — skip silently (deleted, permission error, binary)
+            continue
+        }
+
+        try {
+            if (tsExtensions.has(ext)) {
+                const parsed = await oxcParser.parse(absoluteFp, content)
+                oxcFiles.push(parsed)
+            } else if (goExtensions.has(ext)) {
+                const parsed = await goParser.parse(absoluteFp, content)
+                goFiles.push(parsed)
+            } else if (treeSitterExtensions.has(ext)) {
+                const ts = await getTreeSitter()
+                const parsed = await ts.parse(absoluteFp, content)
+                treeFiles.push(parsed)
+            }
+        } catch {
+            // Parser error — skip this file, don't abort the whole run
         }
     }
 
-    const allResolvedFiles: ParsedFile[] = []
-    for (const [parser, files] of parsersMap.entries()) {
-        allResolvedFiles.push(...parser.resolveImports(files, projectRoot))
+    // Resolve imports batch-wise per parser (each has its own resolver)
+    let resolvedTreeFiles: ParsedFile[] = treeFiles
+    if (treeFiles.length > 0) {
+        const treeParser = treeSitterParser ?? await getTreeSitter()
+        resolvedTreeFiles = treeParser.resolveImports(treeFiles, normalizedRoot)
     }
 
-    return allResolvedFiles
+    const resolved: ParsedFile[] = [
+        ...oxcParser.resolveImports(oxcFiles, normalizedRoot),
+        ...goParser.resolveImports(goFiles, normalizedRoot),
+        ...resolvedTreeFiles,
+    ]
+
+    return resolved
 }

package/src/parser/javascript/js-extractor.ts

@@ -231,7 +231,7 @@ export class JavaScriptExtractor extends TypeScriptExtractor {
                         returnType: rhs.type ? rhs.type.getText(this.sourceFile) : 'void',
                         isExported: true,
                         isAsync,
-                        calls: this.extractCalls(rhs),
+                        calls: this.extractCallsFromNode(rhs),
                         hash: hashContent(rhs.getText(this.sourceFile)),
                         purpose: this.extractPurpose(node),
                         edgeCasesHandled: this.extractEdgeCases(rhs),

package/src/parser/javascript/js-parser.ts

@@ -48,6 +48,8 @@ export class JavaScriptParser extends BaseParser {
             imports,
             exports,
             routes,
+            variables: [],
+            calls: [],
             hash: hashContent(content),
             parsedAt: Date.now(),
         }