@getmikk/core 2.0.13 → 2.0.15

package/src/parser/oxc-parser.ts

@@ -1,5 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import path from 'node:path';
-import { BaseParser } from './base-parser.js';
+import { BaseExtractor } from './base-extractor.js';
 import { OxcResolver } from './oxc-resolver.js';
 import { hashContent } from '../hash/file-hasher.js';
 import type {
@@ -12,8 +13,10 @@ import type {
     ParsedParam,
     CallExpression,
     ParsedGeneric,
-    ParsedRoute
+    ParsedRoute,
+    ReExport
 } from './types.js';
+import { LanguageRegistry } from './language-registry.js';
 
 // ---------------------------------------------------------------------------
 // LineIndex — O(log n) byte-offset → 1-based line number
@@ -55,13 +58,13 @@ class LineIndex {
 // ---------------------------------------------------------------------------
 function makeAllocator(filePath: string): (prefix: string, name: string) => string {
     const counter = new Map<string, number>();
-    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
     return (prefix: string, name: string): string => {
         const key = `${prefix}:${name}`;
         const count = (counter.get(key) ?? 0) + 1;
         counter.set(key, count);
         const suffix = count === 1 ? '' : `#${count}`;
-        return `${prefix}:${normalizedPath}:${name}${suffix}`.toLowerCase();
+        return `${prefix}:${normalizedPath}:${name}${suffix}`;
     };
 }
 
@@ -102,6 +105,23 @@ function resolvePropertyName(node: any): string | null {
     return null;
 }
 
+function extractDecorators(node: any): string[] {
+    if (!node?.decorators?.length) return [];
+    return node.decorators.map((dec: any) => {
+        if (dec.expression?.type === 'Identifier') return dec.expression.name;
+        if (dec.expression?.type === 'CallExpression') {
+            const callee = dec.expression.callee;
+            if (callee?.type === 'Identifier') return callee.name;
+            if (callee?.type === 'MemberExpression') {
+                const obj = callee.object?.name ?? '';
+                const prop = callee.property?.name ?? '';
+                return obj ? `${obj}.${prop}` : prop;
+            }
+        }
+        return dec.expression?.name ?? dec.name ?? 'decorator';
+    });
+}
+
 function resolveObjectName(node: any): string | null {
     if (!node) return null;
     if (node.type === 'Identifier') return node.name;
@@ -249,6 +269,52 @@ function extractCalls(node: any, lineIndex: LineIndex): CallExpression[] {
 // ---------------------------------------------------------------------------
 // Parameter extraction
 // ---------------------------------------------------------------------------
+function extractTypeAnnotation(typeNode: any): string {
+    if (!typeNode) return 'any';
+    switch (typeNode.type) {
+        case 'TSStringKeyword': return 'string';
+        case 'TSNumberKeyword': return 'number';
+        case 'TSBooleanKeyword': return 'boolean';
+        case 'TSVoidKeyword': return 'void';
+        case 'TSNullKeyword': return 'null';
+        case 'TSUndefinedKeyword': return 'undefined';
+        case 'TSNeverKeyword': return 'never';
+        case 'TSAnyKeyword': return 'any';
+        case 'TSUnknownKeyword': return 'unknown';
+        case 'TSObjectKeyword': return 'object';
+        case 'TSSymbolKeyword': return 'symbol';
+        case 'TSBigIntKeyword': return 'bigint';
+        case 'TSTypeReference':
+            return typeNode.typeName?.name ?? 'unknown';
+        case 'TSArrayType':
+            return `${extractTypeAnnotation(typeNode.elementType)}[]`;
+        case 'TSTupleType':
+            return 'tuple';
+        case 'TSUnionType':
+            return (typeNode.types ?? []).map((t: any) => extractTypeAnnotation(t)).join(' | ');
+        case 'TSIntersectionType':
+            return (typeNode.types ?? []).map((t: any) => extractTypeAnnotation(t)).join(' & ');
+        case 'TSFunctionType':
+            return 'Function';
+        case 'TSConstructorType':
+            return 'new (...args: any[]) => any';
+        case 'TSParenthesizedType':
+            return extractTypeAnnotation(typeNode.typeAnnotation);
+        case 'TSConditionalType':
+            return 'conditional';
+        case 'TSMappedType':
+            return 'mapped';
+        case 'TSIndexedAccessType':
+            return 'indexed';
+        case 'TSLiteralType':
+            return String(typeNode.literal?.value ?? typeNode.literal?.raw ?? 'literal');
+        case 'Identifier':
+            return typeNode.name ?? 'any';
+        default:
+            return 'any';
+    }
+}
+
 function extractParams(params: any[]): ParsedParam[] {
     return params.map(p => {
         const normalized = normalizeParamNode(p);
@@ -256,15 +322,24 @@ function extractParams(params: any[]): ParsedParam[] {
         const name = describeParamPattern(pattern);
         const optional = !!normalized?.optional || pattern?.type === 'AssignmentPattern' || pattern?.type === 'RestElement';
         const hasDefault = pattern?.type === 'AssignmentPattern' || normalized?.defaultValue != null || normalized?.initializer != null;
+        const typeAnnotation = normalized?.typeAnnotation ?? pattern?.typeAnnotation;
         return {
             name,
-            type: 'any',
+            type: extractTypeAnnotation(typeAnnotation),
             optional,
             defaultValue: hasDefault ? 'default' : undefined,
         };
     });
 }
 
+function extractReturnType(returnType: any): string {
+    if (!returnType) return 'void';
+    if (returnType.typeAnnotation) {
+        return extractTypeAnnotation(returnType.typeAnnotation);
+    }
+    return extractTypeAnnotation(returnType);
+}
+
 // ---------------------------------------------------------------------------
 // Span helper
 // ---------------------------------------------------------------------------
@@ -274,25 +349,28 @@ function getSpan(node: any): { start: number; end: number } {
 }
 
 // ---------------------------------------------------------------------------
-// OxcParser
+// TypescriptExtractor (OXC-based)
 // ---------------------------------------------------------------------------
-export class OxcParser extends BaseParser {
-    public async parse(filePath: string, content: string): Promise<ParsedFile> {
+export class TypescriptExtractor extends BaseExtractor {
+    public async extract(filePath: string, content: string): Promise<ParsedFile> {
         const ext = path.extname(filePath).toLowerCase();
         const isTS = ['.ts', '.tsx', '.mts', '.cts'].includes(ext);
 
-        let ast: any;
-        try {
-            const { parseSync } = await import('oxc-parser');
-            const result = parseSync(filePath, content, {
-                sourceType: 'module',
-                lang: isTS ? 'ts' : 'js',
-            });
-            ast = result.program;
-        } catch {
-            // Return empty file on parse error — never crash the pipeline
-            return this.emptyFile(filePath, content, isTS);
-        }
+         let ast: any;
+         try {
+             const { parseSync } = await import('oxc-parser');
+             const lang = ext === '.jsx' ? 'jsx' : ext === '.tsx' ? 'tsx' : isTS ? 'ts' : 'js';
+              const result = parseSync(filePath, content, {
+                  sourceType: 'module',
+                  lang: lang,
+              });
+             ast = result.program;
+         } catch (err) {
+             const error = err instanceof Error ? err.message : String(err);
+             const preview = content.substring(0, 100).replace(/\n/g, ' ');
+             console.warn(`[mikk] Parse error in ${filePath}: ${error} (content: "${preview}...")`);
+             return this.emptyFile(filePath, content, isTS);
+         }
 
         const lineIndex = new LineIndex(content);
         const allocateId = makeAllocator(filePath);
@@ -304,6 +382,7 @@ export class OxcParser extends BaseParser {
         const generics: ParsedGeneric[] = [];
         const imports: ParsedImport[] = [];
         const exports: ParsedExport[] = [];
+        const reexports: ReExport[] = [];
         const moduleCalls: CallExpression[] = [];
         const routes: ParsedRoute[] = [];
 
@@ -316,18 +395,31 @@ export class OxcParser extends BaseParser {
                 case 'ImportDeclaration': {
                     if (node.importKind === 'type') break;
                     const names: string[] = [];
+                    const specifiers: Array<{ imported: string; local: string }> = [];
                     let isDefault = false;
                     for (const spec of node.specifiers ?? []) {
                         if (spec.importKind === 'type') continue;
                         if (spec.type === 'ImportDefaultSpecifier') {
                             isDefault = true;
+                            if (spec.local?.name) names.push(spec.local.name);
+                        } else if (spec.type === 'ImportSpecifier' || spec.type === 'ImportNamedSpecifier') {
+                            const imported = spec.imported?.name ?? spec.local?.name ?? '';
+                            const local = spec.local?.name ?? '';
+                            if (local) {
+                                names.push(local);
+                                if (imported !== local) {
+                                    specifiers.push({ imported, local });
+                                }
+                            }
+                        } else if (spec.type === 'ImportNamespaceSpecifier') {
+                            if (spec.local?.name) names.push(spec.local.name);
                         }
-                        if (spec.local?.name) names.push(spec.local.name);
                     }
                     imports.push({
                         source: node.source.value,
                         resolvedPath: '',
                         names,
+                        specifiers: specifiers.length > 0 ? specifiers : undefined,
                         isDefault,
                         isDynamic: false,
                     });
@@ -355,6 +447,7 @@ export class OxcParser extends BaseParser {
                     const name = node.id.name;
                     const span = getSpan(node);
                     const exported = isDirectlyExported(parent);
+                    const decorators = extractDecorators(node);
                     functions.push({
                         id: allocateId('fn', name),
                         name,
@@ -362,7 +455,7 @@ export class OxcParser extends BaseParser {
                         startLine: lineIndex.getLine(span.start),
                         endLine: lineIndex.getLine(span.end),
                         params: extractParams(node.params?.items ?? node.params ?? []),
-                        returnType: 'void',
+                        returnType: extractReturnType(node.returnType ?? node.signature?.returnType),
                         isExported: exported,
                         isAsync: !!node.async,
                         calls: extractCalls(node.body ?? node, lineIndex),
@@ -371,6 +464,7 @@ export class OxcParser extends BaseParser {
                         edgeCasesHandled: [],
                         errorHandling: [],
                         detailedLines: [],
+                        decorators: decorators.length > 0 ? decorators : undefined,
                     });
                     if (exported) exports.push({ name, type: 'function', file: normalizedFilePath });
                     break;
@@ -382,6 +476,7 @@ export class OxcParser extends BaseParser {
                     const name = node.id.name;
                     const span = getSpan(node);
                     const exported = isDirectlyExported(parent);
+                    const decorators = extractDecorators(node);
                     const methods: ParsedFunction[] = [];
                     const properties: ParsedVariable[] = [];
 
@@ -394,7 +489,9 @@ export class OxcParser extends BaseParser {
                                     null;
                             if (!mName) continue;
 
-                            if (member.type === 'MethodDefinition') {
+                            const memberDecorators = extractDecorators(member);
+                            const isMethod = member.type === 'MethodDefinition';
+                            if (isMethod) {
                                 const value = member.value;
                                 const mSpan = getSpan(member);
                                 methods.push({
@@ -404,7 +501,7 @@ export class OxcParser extends BaseParser {
                                     startLine: lineIndex.getLine(mSpan.start),
                                     endLine: lineIndex.getLine(mSpan.end),
                                     params: extractParams(value?.params?.items ?? value?.params ?? []),
-                                    returnType: 'any',
+                                    returnType: extractReturnType(value?.returnType ?? value?.signature?.returnType),
                                     isExported: exported,
                                     isAsync: !!value?.async,
                                     calls: extractCalls(value?.body ?? value ?? {}, lineIndex),
@@ -413,6 +510,7 @@ export class OxcParser extends BaseParser {
                                     edgeCasesHandled: [],
                                     errorHandling: [],
                                     detailedLines: [],
+                                    decorators: memberDecorators.length > 0 ? memberDecorators : undefined,
                                 });
                             } else {
                                 // PropertyDefinition
@@ -425,6 +523,7 @@ export class OxcParser extends BaseParser {
                                     line: lineIndex.getLine(pSpan.start),
                                     isExported: false,
                                     isStatic: !!member.static,
+                                    decorators: memberDecorators.length > 0 ? memberDecorators : undefined,
                                 };
                                 properties.push(propertyNode);
                                 variables.push(propertyNode);
@@ -444,6 +543,7 @@ export class OxcParser extends BaseParser {
                         isExported: exported,
                         hash: hashContent(JSON.stringify(node.body ?? {})),
                         purpose: '',
+                        decorators: decorators.length > 0 ? decorators : undefined,
                     });
                     if (exported) exports.push({ name, type: 'class', file: normalizedFilePath });
                     break;
@@ -598,13 +698,21 @@ export class OxcParser extends BaseParser {
 
                 // ── Named Exports ──────────────────────────────────────────
                 case 'ExportNamedDeclaration': {
-                    // Re-export specifiers: export { foo, bar }
+                    const source = node.source?.value;
+                    
                     for (const spec of node.specifiers ?? []) {
-                        if (spec.exported?.name) {
-                            exports.push({ name: spec.exported.name, type: 'variable', file: normalizedFilePath });
+                        const exportedName = spec.exported?.name ?? spec.local?.name;
+                        if (!exportedName) continue;
+                        
+                        if (source) {
+                            reexports.push({
+                                name: exportedName,
+                                source: source,
+                            });
+                        } else {
+                            exports.push({ name: exportedName, type: 'variable', file: normalizedFilePath });
                         }
                     }
-                    // Declaration is handled by the declaration's own case with parent context
                     break;
                 }
 
@@ -674,6 +782,7 @@ export class OxcParser extends BaseParser {
             generics,
             imports,
             exports,
+            reexports,
             routes,
             calls: moduleCalls,
             hash: hashContent(content),
@@ -707,3 +816,32 @@ export class OxcParser extends BaseParser {
         };
     }
 }
+
+// Register in the global registry
+LanguageRegistry.getInstance().register({
+    name: 'typescript',
+    extensions: ['.ts', '.tsx', '.mts', '.cts'],
+    treeSitterGrammar: '',
+    extractor: new TypescriptExtractor(),
+    semanticFeatures: {
+        hasTypeSystem: true,
+        hasGenerics: true,
+        hasMacros: false,
+        hasAnnotations: false,
+        hasPatternMatching: false
+    }
+});
+
+LanguageRegistry.getInstance().register({
+    name: 'javascript',
+    extensions: ['.js', '.jsx', '.mjs', '.cjs'],
+    treeSitterGrammar: '',
+    extractor: new TypescriptExtractor(), // OXC handles both
+    semanticFeatures: {
+        hasTypeSystem: false,
+        hasGenerics: false,
+        hasMacros: false,
+        hasAnnotations: false,
+        hasPatternMatching: false
+    }
+});

package/src/parser/oxc-resolver.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
 import path from 'node:path';
 import fs from 'node:fs';
@@ -9,9 +10,10 @@ import type { ParsedFile } from './types.js';
  *
  * 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 ''
+ *  2. If the resolved path is in a monorepo workspace → return full path
+ *  3. If the resolved path is outside projectRoot (node_modules) → return ''
  *     (external deps produce no graph edges; they're not in our file set)
- *  3. On any error → return '' (unresolved, no false edges)
+ *  4. 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
@@ -21,12 +23,140 @@ import type { ParsedFile } from './types.js';
 export class OxcResolver {
     private resolver: any;
     private readonly normalizedRoot: string;
+    private workspaceRoots: string[] | null = null;
 
 
     constructor(private readonly projectRoot: string) {
         this.normalizedRoot = path.resolve(projectRoot).replace(/\\/g, '/');
     }
 
+    /**
+     * Detect all workspace roots in a monorepo setup.
+     * Supports: npm workspaces, pnpm workspaces, Turborepo
+     */
+    private detectWorkspaceRoots(): string[] {
+        if (this.workspaceRoots !== null) {
+            return this.workspaceRoots;
+        }
+
+        const roots: Set<string> = new Set([this.normalizedRoot]);
+        const projectDir = path.dirname(this.normalizedRoot);
+
+        // Check for pnpm-workspace.yaml (pnpm workspaces)
+        const pnpmWorkspace = path.join(projectDir, 'pnpm-workspace.yaml');
+        if (fs.existsSync(pnpmWorkspace)) {
+            try {
+                const content = fs.readFileSync(pnpmWorkspace, 'utf-8');
+                const packageMatch = content.match(/packages:\s*\n([\s\S]*?)(?:\n\n|\n[^ ]|$)/);
+                if (packageMatch) {
+                    const packagesPattern = packageMatch[1];
+                    for (const line of packagesPattern.split('\n')) {
+                        const trimmed = line.trim().replace(/^-\s*/, '').replace(/^'\s*/, '').replace(/^\s*/, '');
+                        if (trimmed && !trimmed.startsWith('#')) {
+                            const wsPath = path.resolve(projectDir, trimmed.replace(/\/\*$/, '')).replace(/\\/g, '/');
+                            roots.add(wsPath);
+                        }
+                    }
+                }
+            } catch { /* ignore */ }
+        }
+
+        // Check for package.json with workspaces field (npm/yarn workspaces)
+        const pkgJson = path.join(projectDir, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const content = fs.readFileSync(pkgJson, 'utf-8');
+                const pkg = JSON.parse(content);
+                const workspaces = pkg.workspaces;
+                if (workspaces) {
+                    const patterns = Array.isArray(workspaces) ? workspaces : (workspaces.packages || []);
+                    for (const pattern of patterns) {
+                        if (typeof pattern === 'string' && !pattern.includes('*')) {
+                            const wsPath = path.resolve(projectDir, pattern).replace(/\\/g, '/');
+                            roots.add(wsPath);
+                        } else if (typeof pattern === 'string') {
+                            // Glob pattern - find matching directories
+                            const basePattern = pattern.replace(/\/\*$/, '');
+                            const basePath = path.resolve(projectDir, basePattern);
+                            if (fs.existsSync(basePath)) {
+                                try {
+                                    const entries = fs.readdirSync(basePath);
+                                    for (const entry of entries) {
+                                        const entryPath = path.join(basePath, entry);
+                                        const stat = fs.statSync(entryPath);
+                                        if (stat.isDirectory()) {
+                                            const pkgJsonPath = path.join(entryPath, 'package.json');
+                                            if (fs.existsSync(pkgJsonPath)) {
+                                                roots.add(entryPath.replace(/\\/g, '/'));
+                                            }
+                                        }
+                                    }
+                                } catch { /* ignore */ }
+                            }
+                        }
+                    }
+                }
+            } catch { /* ignore */ }
+        }
+
+        // Check for turbo.json (Turborepo)
+        const turboJson = path.join(projectDir, 'turbo.json');
+        if (fs.existsSync(turboJson)) {
+            try {
+                const content = fs.readFileSync(turboJson, 'utf-8');
+                const turbo = JSON.parse(content);
+                if (turbo.pipeline) {
+                    for (const task of Object.keys(turbo.pipeline)) {
+                        const pipeline = turbo.pipeline[task];
+                        if (pipeline?.dependsOn) {
+                            for (const dep of pipeline.dependsOn) {
+                                if (typeof dep === 'string' && dep.startsWith('^')) {
+                                    // Workspace dependency
+                                    const wsName = dep.slice(1).replace(/^.*:/, '');
+                                    roots.add(path.resolve(projectDir, 'apps', wsName).replace(/\\/g, '/'));
+                                    roots.add(path.resolve(projectDir, 'packages', wsName).replace(/\\/g, '/'));
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch { /* ignore */ }
+        }
+
+        this.workspaceRoots = [...roots];
+        return this.workspaceRoots;
+    }
+
+    /**
+     * Check if a resolved path is within an accepted workspace root.
+     */
+    private isInAcceptedWorkspace(resolvedPath: string): boolean {
+        if (resolvedPath.startsWith(this.normalizedRoot + '/') || resolvedPath === this.normalizedRoot) {
+            return true;
+        }
+
+        // Check workspace roots for monorepo packages
+        const workspaces = this.detectWorkspaceRoots();
+        for (const wsRoot of workspaces) {
+            if (resolvedPath.startsWith(wsRoot + '/')) {
+                return true;
+            }
+        }
+
+        // Accept node_modules within workspace packages (but not external)
+        const nodeModulesIdx = resolvedPath.indexOf('/node_modules/');
+        if (nodeModulesIdx > 0) {
+            const prefix = resolvedPath.slice(0, nodeModulesIdx);
+            for (const wsRoot of workspaces) {
+                if (prefix.startsWith(wsRoot)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private async ensureResolver() {
         if (this.resolver) return;
         const { ResolverFactory } = await import('oxc-resolver');
@@ -68,7 +198,7 @@ export class OxcResolver {
 
             const resolved = result.path.replace(/\\/g, '/');
 
-            if (!resolved.startsWith(this.normalizedRoot + '/') && resolved !== this.normalizedRoot) {
+            if (!this.isInAcceptedWorkspace(resolved)) {
                 return '';
             }
 
@@ -97,7 +227,7 @@ export class OxcResolver {
             const resolved = path.resolve(baseDir, candidate).replace(/\\/g, '/');
             
             if (fs.existsSync(resolved)) {
-                if (resolved.startsWith(this.normalizedRoot + '/') || resolved === this.normalizedRoot) {
+                if (this.isInAcceptedWorkspace(resolved)) {
                     return resolved;
                 }
             }
@@ -109,13 +239,51 @@ export class OxcResolver {
 
     /** Resolve all imports for a batch of files in one pass */
     public async resolveBatch(files: ParsedFile[]): Promise<ParsedFile[]> {
-        return Promise.all(files.map(async file => ({
-            ...file,
-            imports: await Promise.all(file.imports.map(async imp => ({
-                ...imp,
-                resolvedPath: await this.resolve(imp.source, file.path),
-            }))),
-        })));
+        const fileByPath = new Map<string, ParsedFile>();
+        for (const file of files) {
+            fileByPath.set(file.path, file);
+        }
+
+        const resolveWithReexports = async (source: string, fromFile: string, visited: Set<string> = new Set()): Promise<string> => {
+            if (visited.has(fromFile)) return '';
+            visited.add(fromFile);
+
+            const resolved = await this.resolve(source, fromFile);
+            if (!resolved) return '';
+
+            const targetFile = fileByPath.get(resolved);
+            if (!targetFile) return resolved;
+
+            for (const re of targetFile.reexports ?? []) {
+                if (re.sourceResolved) {
+                    const chain = await resolveWithReexports(re.source, resolved, visited);
+                    if (chain) return chain;
+                }
+            }
+
+            return resolved;
+        };
+
+        const resolvedFiles: ParsedFile[] = [];
+        for (const file of files) {
+            const resolvedImports = await Promise.all(file.imports.map(async imp => {
+                const resolvedPath = await resolveWithReexports(imp.source, file.path);
+                return { ...imp, resolvedPath };
+            }));
+
+            const resolvedReexports = await Promise.all((file.reexports ?? []).map(async re => {
+                const sourceResolved = await this.resolve(re.source, file.path);
+                return { ...re, sourceResolved };
+            }));
+
+            resolvedFiles.push({
+                ...file,
+                imports: resolvedImports,
+                reexports: resolvedReexports,
+            });
+        }
+
+        return resolvedFiles;
     }
 }
 

package/src/parser/parser-constants.ts

@@ -72,6 +72,7 @@ export function stripJsonComments(raw: string): string {
  * Parse JSON config files while tolerating JSON5 comments.
  * Falls back to the raw content if comment stripping breaks URLs.
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function parseJsonWithComments<T = any>(raw: string): T {
     const stripped = stripJsonComments(raw)
     try {