@getmikk/core 1.8.2 → 1.9.0

package/src/parser/oxc-resolver.ts

@@ -0,0 +1,83 @@
+import { ResolverFactory } from 'oxc-resolver';
+import path from 'node:path';
+import fs from 'node:fs';
+import type { ParsedFile } from './types.js';
+
+/**
+ * OxcResolver — Rust-backed compiler-grade module resolution.
+ *
+ * Resolution strategy:
+ *  1. If the resolved path is inside projectRoot → return project-relative posix path
+ *  2. If the resolved path is outside projectRoot (node_modules, monorepo peer) → return ''
+ *     (external deps produce no graph edges; they're not in our file set)
+ *  3. On any error → return '' (unresolved, no false edges)
+ *
+ * All returned paths use forward slashes and are ABSOLUTE, matching what
+ * parseFiles passes to parse().  graph-builder only creates import edges when
+ * the target path exists as a file node — so no path format inconsistency can
+ * create false positive edges.
+ */
+export class OxcResolver {
+    private resolver: any;
+    private readonly normalizedRoot: string;
+
+    constructor(private readonly projectRoot: string) {
+        this.normalizedRoot = path.resolve(projectRoot).replace(/\\/g, '/');
+
+        const tsconfigPath = path.resolve(projectRoot, 'tsconfig.json');
+        const hasTsConfig = fs.existsSync(tsconfigPath);
+
+        this.resolver = new ResolverFactory({
+            extensions: ['.ts', '.tsx', '.js', '.jsx', '.json', '.mjs', '.cjs', '.mts', '.cts'],
+            mainFields: ['module', 'main', 'jsnext:main'],
+            mainFiles: ['index', 'main', 'app'],
+            conditionNames: ['import', 'require', 'node', 'default', 'types', 'browser'],
+            symlinks: true,
+            modules: ['node_modules'],
+            tsconfig: hasTsConfig ? {
+                configFile: tsconfigPath,
+                references: 'auto',
+            } : undefined,
+        });
+    }
+
+    /**
+     * Resolve a single import source string relative to fromFile.
+     * fromFile MUST be an absolute path (as produced by parseFiles).
+     * Returns an absolute posix path, or '' if unresolvable/external.
+     */
+    public resolve(source: string, fromFile: string): string {
+        try {
+            const absFrom = path.isAbsolute(fromFile)
+                ? fromFile
+                : path.resolve(this.projectRoot, fromFile);
+            const dir = path.dirname(absFrom);
+
+            const result = this.resolver.sync(dir, source);
+            if (!result?.path) return '';
+
+            const resolved = result.path.replace(/\\/g, '/');
+
+            // Only include files within our project root in the graph.
+            // node_modules, hoisted workspace deps, etc. are external.
+            if (!resolved.startsWith(this.normalizedRoot + '/') && resolved !== this.normalizedRoot) {
+                return '';
+            }
+
+            return resolved;
+        } catch {
+            return '';
+        }
+    }
+
+    /** Resolve all imports for a batch of files in one pass */
+    public resolveBatch(files: ParsedFile[]): ParsedFile[] {
+        return files.map(file => ({
+            ...file,
+            imports: file.imports.map(imp => ({
+                ...imp,
+                resolvedPath: this.resolve(imp.source, file.path),
+            })),
+        }));
+    }
+}

package/src/parser/tree-sitter/parser.ts

@@ -109,8 +109,8 @@ function findFirstChild(node: any, predicate: (n: any) => boolean): any {
 function assignCallsToFunctions(
     functions: ParsedFunction[],
     callEntries: Array<{ name: string; line: number }>
-): string[] {
-    const unassigned: string[] = []
+): Array<{ name: string; line: number }> {
+    const unassigned: Array<{ name: string; line: number }> = []
     for (const { name, line } of callEntries) {
         // Find the innermost (smallest range) function that contains this line
         let best: ParsedFunction | null = null
@@ -125,11 +125,11 @@ function assignCallsToFunctions(
             }
         }
         if (best) {
-            if (!best.calls.includes(name)) {
-                best.calls.push(name)
+            if (!best.calls.some(c => c.name === name && c.line === line)) {
+                best.calls.push({ name, line, type: 'function' })
             }
         } else {
-            unassigned.push(name)
+            unassigned.push({ name, line })
         }
     }
     return unassigned
@@ -142,6 +142,7 @@ function assignCallsToFunctions(
 export class TreeSitterParser extends BaseParser {
     private parser: any = null
     private languages = new Map<string, any>()
+    private nameCounter = new Map<string, number>()
 
     getSupportedExtensions(): string[] {
         return ['.py', '.java', '.c', '.cpp', '.cc', '.h', '.hpp', '.cs', '.go', '.rs', '.php', '.rb']
@@ -155,6 +156,7 @@ export class TreeSitterParser extends BaseParser {
     }
 
     async parse(filePath: string, content: string): Promise<ParsedFile> {
+        this.nameCounter.clear()
         await this.init()
         const ext = path.extname(filePath).toLowerCase()
         const config = await this.getLanguageConfig(ext)
@@ -185,10 +187,13 @@ export class TreeSitterParser extends BaseParser {
             // --- Calls: record name and line position ---
             if (captures['call.name']) {
                 const callNode = captures['call.name']
-                callEntries.push({
-                    name: callNode.text,
-                    line: (callNode.startPosition?.row ?? 0) + 1,
-                })
+                const name = callNode.text
+                if (name) {
+                    callEntries.push({
+                        name,
+                        line: (callNode.startPosition?.row ?? 0) + 1,
+                    })
+                }
                 continue
             }
 
@@ -215,11 +220,12 @@ export class TreeSitterParser extends BaseParser {
                     const startLine = defNode.startPosition.row + 1
                     const endLine = defNode.endPosition.row + 1
                     const nodeText = defNode.text ?? ''
+                    const count = (this.nameCounter.get(fnName) ?? 0) + 1
+                    this.nameCounter.set(fnName, count)
 
-                    // Unique ID: include start line to handle overloads and same-name scoped functions
-                    let fnId = `fn:${filePath}:${fnName}:${startLine}`
+                    // Unique ID: use stable format with counter for collisions
+                    let fnId = count === 1 ? `fn:${filePath}:${fnName}` : `fn:${filePath}:${fnName}#${count}`
                     if (seenFnIds.has(fnId)) {
-                        // Extremely rare duplicate — skip rather than corrupt
                         continue
                     }
                     seenFnIds.add(fnId)
@@ -269,7 +275,7 @@ export class TreeSitterParser extends BaseParser {
                     const startLine = defNode.startPosition.row + 1
                     const endLine = defNode.endPosition.row + 1
                     const nodeText = defNode.text ?? ''
-                    const clsId = `cls:${filePath}:${clsName}:${startLine}`
+                    const clsId = `class:${filePath}:${clsName}` // consistent with ts-extractor
 
                     if (!classesMap.has(clsId)) {
                         classesMap.set(clsId, {
@@ -279,7 +285,9 @@ export class TreeSitterParser extends BaseParser {
                             startLine,
                             endLine,
                             methods: [],
+                            properties: [],
                             isExported: isExportedByLanguage(ext, clsName, nodeText),
+                            hash: hashContent(nodeText),
                         })
                     }
                 }
@@ -300,9 +308,9 @@ export class TreeSitterParser extends BaseParser {
                 endLine: lineCount || 1,
                 params: [],
                 returnType: 'void',
-                isExported: true,
+                isExported: false, // Don't export the synthetic module function
                 isAsync: false,
-                calls: Array.from(new Set(unassignedCalls)),
+                calls: unassignedCalls.map(c => ({ name: c.name, line: c.line, type: 'function' })),
                 hash: '',
                 purpose: 'Module-level initialization code',
                 edgeCasesHandled: [],
@@ -330,6 +338,8 @@ export class TreeSitterParser extends BaseParser {
                 file: filePath,
             })),
             routes: [],
+            variables: [],
+            calls: [],
             hash: hashContent(content),
             parsedAt: Date.now(),
         }
@@ -352,6 +362,8 @@ export class TreeSitterParser extends BaseParser {
             imports: [],
             exports: [],
             routes: [],
+            variables: [],
+            calls: [],
             hash: hashContent(content),
             parsedAt: Date.now(),
         }

package/src/parser/types.ts

@@ -1,103 +1,130 @@
 /**
  * Parser types — data shapes that flow through the entire Mikk system.
- * Parser produces them, graph consumes them, contract stores them.
  */
 
 /** A single parameter in a function signature */
 export interface ParsedParam {
-    name: string
-    type: string
-    optional: boolean
-    defaultValue?: string
+  name: string;
+  type: string;
+  optional: boolean;
+  defaultValue?: string;
 }
 
+/** A single call expression found in code (Mikk 2.0) */
+export interface CallExpression {
+  name: string;
+  line: number;
+  type: 'function' | 'method' | 'property';
+  arguments?: string[];
+}
+
+/** A detailed function declaration */
 export interface ParsedFunction {
-    id: string              // "fn:auth/verify.ts:verifyToken"
-    name: string            // "verifyToken"
-    file: string            // "src/auth/verify.ts"
-    moduleId?: string
-    startLine: number       // 14
-    endLine: number         // 28
-    params: ParsedParam[]   // [{name: "token", type: "string"}]
-    returnType: string      // "boolean"
-    isExported: boolean     // true
-    isAsync: boolean        // false
-    isGenerator?: boolean   // true for function* / async function*
-    typeParameters?: string[] // ["T", "U"] for generic functions
-    calls: string[]         // ["jwtDecode", "findUser"]
-    hash: string            // SHA-256 of the function body
-    purpose: string         // Extracted from JSDoc or comments
-    edgeCasesHandled: string[] // Found conditions like 'if (!x) return'
-    errorHandling: { line: number, type: 'try-catch' | 'throw', detail: string }[]
-    detailedLines: { startLine: number, endLine: number, blockType: string }[]
+  id: string;              // unique normalized ID (file::name)
+  name: string;
+  file: string;
+  moduleId?: string;
+  startLine: number;
+  endLine: number;
+  params: ParsedParam[];
+  returnType: string;
+  isExported: boolean;
+  isAsync: boolean;
+  isGenerator?: boolean;
+  typeParameters?: string[];
+  calls: CallExpression[]; // Behavioral tracking (Upgraded from string[])
+  hash: string;
+  purpose: string;
+  edgeCasesHandled: string[];
+  errorHandling: { line: number; type: 'try-catch' | 'throw'; detail: string }[];
+  detailedLines: { startLine: number; endLine: number; blockType: string }[];
 }
 
 /** A single import statement */
 export interface ParsedImport {
-    source: string          // "../../utils/jwt"
-    resolvedPath: string    // "src/utils/jwt.ts" (absolute within project)
-    names: string[]         // ["jwtDecode", "jwtSign"]
-    isDefault: boolean      // false
-    isDynamic: boolean      // false
+  source: string;
+  resolvedPath: string;
+  names: string[];
+  isDefault: boolean;
+  isDynamic: boolean;
 }
 
 /** A single exported symbol */
 export interface ParsedExport {
-    name: string            // "verifyToken"
-    type: 'function' | 'class' | 'const' | 'type' | 'default' | 'interface'
-    file: string
+  name: string;
+  type: 'function' | 'class' | 'const' | 'type' | 'default' | 'interface' | 'variable';
+  file: string;
+}
+
+/** A single variable or property */
+export interface ParsedVariable {
+  id: string;
+  name: string;
+  type: string;
+  file: string;
+  line: number;
+  isExported: boolean;
+  isStatic?: boolean;
+  purpose?: string;
 }
 
 /** A parsed class */
 export interface ParsedClass {
-    id: string
-    name: string
-    file: string
-    moduleId?: string
-    startLine: number
-    endLine: number
-    methods: ParsedFunction[]
-    isExported: boolean
-    decorators?: string[]   // ["Injectable", "Controller"]
-    typeParameters?: string[] // ["T"] for generic classes
-    purpose?: string
-    edgeCasesHandled?: string[]
-    errorHandling?: { line: number, type: 'try-catch' | 'throw', detail: string }[]
+  id: string;
+  name: string;
+  file: string;
+  moduleId?: string;
+  startLine: number;
+  endLine: number;
+  methods: ParsedFunction[];
+  properties: ParsedVariable[];
+  extends?: string;
+  implements?: string[];
+  isExported: boolean;
+  decorators?: string[];
+  typeParameters?: string[];
+  hash: string;
+  purpose?: string;
+  edgeCasesHandled?: string[];
+  errorHandling?: { line: number; type: 'try-catch' | 'throw'; detail: string }[];
 }
 
-/** A detected HTTP route registration (Express/Koa/Hono style) */
-export interface ParsedRoute {
-    method: string            // "GET", "POST", "PUT", "DELETE", "USE", etc.
-    path: string              // "/upload", "/:shortId", "/api"
-    handler: string           // "createZap" or "anonymous"
-    middlewares: string[]     // ["uploadLimiter", "upload.single"]
-    file: string              // "src/Routes/zap.routes.ts"
-    line: number              // 15
+/** A generic declaration (interface, type aliase, etc.) */
+export interface ParsedGeneric {
+  id: string;
+  name: string;
+  type: string; // "interface" | "type"
+  file: string;
+  startLine: number;
+  endLine: number;
+  isExported: boolean;
+  typeParameters?: string[];
+  hash: string;
+  purpose?: string;
 }
 
-/** A generic declaration like interface, type, or constant with metadata */
-export interface ParsedGeneric {
-    id: string
-    name: string
-    type: string // "interface" | "type" | "const"
-    file: string
-    startLine: number
-    endLine: number
-    isExported: boolean
-    typeParameters?: string[] // ["T", "K"] for generic interfaces/types
-    purpose?: string
+/** A detected HTTP route registration */
+export interface ParsedRoute {
+  method: string;
+  path: string;
+  handler: string;
+  middlewares: string[];
+  file: string;
+  line: number;
 }
 
 /** Everything extracted from a single file */
 export interface ParsedFile {
-    path: string            // "src/auth/verify.ts"
-    language: 'python' | 'go' | 'typescript' | 'javascript' | 'java' | 'c' | 'cpp' | 'csharp' | 'rust' | 'php' | 'ruby' | 'unknown'
-    functions: ParsedFunction[]
-    classes: ParsedClass[]
-    generics: ParsedGeneric[]
-    imports: ParsedImport[]
-    exports: ParsedExport[]
-    routes: ParsedRoute[]    // Detected HTTP route registrations
-    hash: string            // SHA-256 of the entire file content
-    parsedAt: number        // Date.now()
+  path: string;            // normalized absolute path
+  language: 'python' | 'go' | 'typescript' | 'javascript' | 'java' | 'c' | 'cpp' | 'csharp' | 'rust' | 'php' | 'ruby' | 'unknown';
+  functions: ParsedFunction[];
+  classes: ParsedClass[];
+  variables: ParsedVariable[];
+  generics: ParsedGeneric[];
+  imports: ParsedImport[];
+  exports: ParsedExport[];
+  routes: ParsedRoute[];
+  calls: CallExpression[]; // module-level calls
+  hash: string;
+  parsedAt: number;
 }