@getmikk/core 1.6.0 → 1.7.1

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

@@ -0,0 +1,83 @@
+import * as path from 'node:path'
+import type { ParsedImport } from '../types.js'
+
+/**
+ * JavaScriptResolver — resolves JS/JSX/CJS import paths to project-relative files.
+ *
+ * Handles:
+ *   - Relative ESM imports:  import './utils'  →  ./utils.js / ./utils/index.js / ...
+ *   - CommonJS require():    require('./db')    →  same resolution order
+ *   - Path aliases from jsconfig.json / tsconfig.json
+ *   - Mixed TS/JS projects: falls back to .ts/.tsx if no JS file matched
+ *
+ * Extension probe order: .js → .jsx → .mjs → .cjs → index.js → index.jsx →
+ *                         .ts → .tsx → index.ts → index.tsx
+ */
+export class JavaScriptResolver {
+    constructor(
+        private readonly projectRoot: string,
+        private readonly aliases: Record<string, string[]> = {},
+    ) {}
+
+    resolve(imp: ParsedImport, fromFile: string, allProjectFiles: string[] = []): ParsedImport {
+        // External packages (no ./  /  alias prefix) — leave unresolved
+        if (
+            !imp.source.startsWith('.') &&
+            !imp.source.startsWith('/') &&
+            !this.matchesAlias(imp.source)
+        ) {
+            return { ...imp, resolvedPath: '' }
+        }
+        return { ...imp, resolvedPath: this.resolvePath(imp.source, fromFile, allProjectFiles) }
+    }
+
+    resolveAll(imports: ParsedImport[], fromFile: string, allProjectFiles: string[] = []): ParsedImport[] {
+        return imports.map(imp => this.resolve(imp, fromFile, allProjectFiles))
+    }
+
+    private resolvePath(source: string, fromFile: string, allProjectFiles: string[]): string {
+        let resolvedSource = source
+
+        // 1. Alias substitution
+        for (const [alias, targets] of Object.entries(this.aliases)) {
+            const prefix = alias.replace('/*', '')
+            if (source.startsWith(prefix)) {
+                resolvedSource = targets[0].replace('/*', '') + source.slice(prefix.length)
+                break
+            }
+        }
+
+        // 2. Build absolute-like posix path
+        let resolved: string
+        if (resolvedSource.startsWith('.')) {
+            resolved = path.posix.normalize(path.posix.join(path.dirname(fromFile), resolvedSource))
+        } else {
+            resolved = resolvedSource
+        }
+        resolved = resolved.replace(/\\/g, '/')
+
+        // 3. Already has a concrete extension — return as-is
+        const knownExts = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx']
+        if (knownExts.some(e => resolved.endsWith(e))) return resolved
+
+        // 4. Probe extensions: prefer JS-family first, fall back to TS for mixed projects
+        const probeOrder = [
+            '.js', '.jsx', '.mjs', '.cjs',
+            '/index.js', '/index.jsx', '/index.mjs',
+            '.ts', '.tsx',
+            '/index.ts', '/index.tsx',
+        ]
+        for (const ext of probeOrder) {
+            const candidate = resolved + ext
+            if (allProjectFiles.length === 0 || allProjectFiles.includes(candidate)) {
+                return candidate
+            }
+        }
+
+        return resolved + '.js'
+    }
+
+    private matchesAlias(source: string): boolean {
+        return Object.keys(this.aliases).some(a => source.startsWith(a.replace('/*', '')))
+    }
+}

package/src/parser/types.ts

@@ -89,7 +89,7 @@ export interface ParsedGeneric {
 /** Everything extracted from a single file */
 export interface ParsedFile {
     path: string            // "src/auth/verify.ts"
-    language: 'typescript' | 'python' | 'go'
+    language: 'typescript' | 'javascript' | 'python' | 'go'
     functions: ParsedFunction[]
     classes: ParsedClass[]
     generics: ParsedGeneric[]

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

@@ -7,11 +7,11 @@ import { hashContent } from '../../hash/file-hasher.js'
  * and extracts functions, classes, imports, exports and call relationships.
  */
 export class TypeScriptExtractor {
-    private sourceFile: ts.SourceFile
+    protected readonly sourceFile: ts.SourceFile
 
     constructor(
-        private filePath: string,
-        private content: string
+        protected readonly filePath: string,
+        protected readonly content: string
     ) {
         this.sourceFile = ts.createSourceFile(
             filePath,
@@ -118,7 +118,7 @@ export class TypeScriptExtractor {
         return generics
     }
 
-    private isVariableFunction(node: ts.VariableStatement): boolean {
+    protected isVariableFunction(node: ts.VariableStatement): boolean {
         for (const decl of node.declarationList.declarations) {
             if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
                 return true
@@ -309,14 +309,14 @@ export class TypeScriptExtractor {
         return routes
     }
 
-    // ─── Private Helpers ──────────────────────────────────────
+    // ─── Protected Helpers ─────────────────────────────────────
 
-    private parseFunctionDeclaration(node: ts.FunctionDeclaration): ParsedFunction {
+    protected parseFunctionDeclaration(node: ts.FunctionDeclaration): ParsedFunction {
         const name = node.name!.text
         const startLine = this.getLineNumber(node.getStart())
         const endLine = this.getLineNumber(node.getEnd())
         const params = this.extractParams(node.parameters)
-        const returnType = node.type ? node.type.getText(this.sourceFile) : 'void'
+        const returnType = normalizeTypeAnnotation(node.type ? node.type.getText(this.sourceFile) : 'void')
         const isAsync = !!node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
         const isGenerator = !!node.asteriskToken
         const typeParameters = this.extractTypeParameters(node.typeParameters)
@@ -344,7 +344,7 @@ export class TypeScriptExtractor {
         }
     }
 
-    private parseVariableFunction(
+    protected parseVariableFunction(
         stmt: ts.VariableStatement,
         decl: ts.VariableDeclaration,
         fn: ts.ArrowFunction | ts.FunctionExpression
@@ -353,7 +353,7 @@ export class TypeScriptExtractor {
         const startLine = this.getLineNumber(stmt.getStart())
         const endLine = this.getLineNumber(stmt.getEnd())
         const params = this.extractParams(fn.parameters)
-        const returnType = fn.type ? fn.type.getText(this.sourceFile) : 'void'
+        const returnType = normalizeTypeAnnotation(fn.type ? fn.type.getText(this.sourceFile) : 'void')
         const isAsync = !!fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
         const isGenerator = ts.isFunctionExpression(fn) && !!fn.asteriskToken
         const typeParameters = this.extractTypeParameters(fn.typeParameters)
@@ -381,7 +381,7 @@ export class TypeScriptExtractor {
         }
     }
 
-    private parseClass(node: ts.ClassDeclaration): ParsedClass {
+    protected parseClass(node: ts.ClassDeclaration): ParsedClass {
         const name = node.name!.text
         const startLine = this.getLineNumber(node.getStart())
         const endLine = this.getLineNumber(node.getEnd())
@@ -420,7 +420,7 @@ export class TypeScriptExtractor {
                 const mStartLine = this.getLineNumber(member.getStart())
                 const mEndLine = this.getLineNumber(member.getEnd())
                 const params = this.extractParams(member.parameters)
-                const returnType = member.type ? member.type.getText(this.sourceFile) : 'void'
+                const returnType = normalizeTypeAnnotation(member.type ? member.type.getText(this.sourceFile) : 'void')
                 const isAsync = !!member.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword)
                 const isGenerator = !!member.asteriskToken
                 const methodTypeParams = this.extractTypeParameters(member.typeParameters)
@@ -465,7 +465,7 @@ export class TypeScriptExtractor {
         }
     }
 
-    private parseImport(node: ts.ImportDeclaration): ParsedImport | null {
+    protected parseImport(node: ts.ImportDeclaration): ParsedImport | null {
         const source = (node.moduleSpecifier as ts.StringLiteral).text
         const names: string[] = []
         let isDefault = false
@@ -503,7 +503,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract function/method call expressions from a node (including new Foo()) */
-    private extractCalls(node: ts.Node): string[] {
+    protected extractCalls(node: ts.Node): string[] {
         const calls: string[] = []
         const walkCalls = (n: ts.Node) => {
             if (ts.isCallExpression(n)) {
@@ -532,7 +532,7 @@ export class TypeScriptExtractor {
 
     /** Extract the purpose from JSDoc comments or preceding single-line comments.
      *  Falls back to deriving a human-readable sentence from the function name. */
-    private extractPurpose(node: ts.Node): string {
+    protected extractPurpose(node: ts.Node): string {
         const fullText = this.sourceFile.getFullText()
         const commentRanges = ts.getLeadingCommentRanges(fullText, node.getFullStart())
         if (commentRanges && commentRanges.length > 0) {
@@ -563,7 +563,7 @@ export class TypeScriptExtractor {
     }
 
     /** Get the identifier name from common declaration node types */
-    private getNodeName(node: ts.Node): string {
+    protected getNodeName(node: ts.Node): string {
         if (ts.isFunctionDeclaration(node) && node.name) return node.name.text
         if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
             const parent = node.parent
@@ -580,7 +580,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract edge cases handled (if statements returning early) */
-    private extractEdgeCases(node: ts.Node): string[] {
+    protected extractEdgeCases(node: ts.Node): string[] {
         const edgeCases: string[] = []
         const walkEdgeCases = (n: ts.Node) => {
             if (ts.isIfStatement(n)) {
@@ -601,7 +601,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract try-catch blocks or explicit throw statements */
-    private extractErrorHandling(node: ts.Node): { line: number, type: 'try-catch' | 'throw', detail: string }[] {
+    protected extractErrorHandling(node: ts.Node): { line: number, type: 'try-catch' | 'throw', detail: string }[] {
         const errors: { line: number, type: 'try-catch' | 'throw', detail: string }[] = []
         const walkErrors = (n: ts.Node) => {
             if (ts.isTryStatement(n)) {
@@ -625,7 +625,7 @@ export class TypeScriptExtractor {
     }
 
     /** Extract detailed line block breakdowns */
-    private extractDetailedLines(node: ts.Node): { startLine: number, endLine: number, blockType: string }[] {
+    protected extractDetailedLines(node: ts.Node): { startLine: number, endLine: number, blockType: string }[] {
         const blocks: { startLine: number, endLine: number, blockType: string }[] = []
         const walkBlocks = (n: ts.Node) => {
             if (ts.isIfStatement(n) || ts.isSwitchStatement(n)) {
@@ -650,13 +650,13 @@ export class TypeScriptExtractor {
     }
 
     /** Extract type parameter names from a generic declaration */
-    private extractTypeParameters(typeParams: ts.NodeArray<ts.TypeParameterDeclaration> | undefined): string[] {
+    protected extractTypeParameters(typeParams: ts.NodeArray<ts.TypeParameterDeclaration> | undefined): string[] {
         if (!typeParams || typeParams.length === 0) return []
         return typeParams.map(tp => tp.name.text)
     }
 
     /** Extract decorator names from a class declaration */
-    private extractDecorators(node: ts.ClassDeclaration): string[] {
+    protected extractDecorators(node: ts.ClassDeclaration): string[] {
         const decorators: string[] = []
         const modifiers = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined
         if (modifiers) {
@@ -674,28 +674,28 @@ export class TypeScriptExtractor {
     }
 
     /** Extract parameters from a function's parameter list */
-    private extractParams(params: ts.NodeArray<ts.ParameterDeclaration>): ParsedParam[] {
+    protected extractParams(params: ts.NodeArray<ts.ParameterDeclaration>): ParsedParam[] {
         return params.map((p) => ({
             name: p.name.getText(this.sourceFile),
-            type: p.type ? p.type.getText(this.sourceFile) : 'any',
+            type: normalizeTypeAnnotation(p.type ? p.type.getText(this.sourceFile) : 'any'),
             optional: !!p.questionToken || !!p.initializer,
             defaultValue: p.initializer ? p.initializer.getText(this.sourceFile) : undefined,
         }))
     }
 
     /** Check if a node has the 'export' modifier */
-    private hasExportModifier(node: ts.Node): boolean {
+    protected hasExportModifier(node: ts.Node): boolean {
         const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined
         return !!modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword)
     }
 
     /** Get 1-indexed line number from a character position */
-    private getLineNumber(pos: number): number {
+    protected getLineNumber(pos: number): number {
         return this.sourceFile.getLineAndCharacterOfPosition(pos).line + 1
     }
 
     /** Walk the top-level children of a node (non-recursive — callbacks decide depth) */
-    private walkNode(node: ts.Node, callback: (node: ts.Node) => void): void {
+    protected walkNode(node: ts.Node, callback: (node: ts.Node) => void): void {
         ts.forEachChild(node, (child) => {
             callback(child)
         })
@@ -712,6 +712,10 @@ export class TypeScriptExtractor {
  *   UserRepository     → "User repository"
  *   parseFiles         → "Parse files"
  */
+function normalizeTypeAnnotation(type: string): string {
+    return type.replace(/\s*\n\s*/g, ' ').replace(/\s{2,}/g, ' ').trim()
+}
+
 function derivePurposeFromName(name: string): string {
     if (!name || name === 'constructor') return ''
     // Split on camelCase/PascalCase boundaries and underscores

package/src/parser/typescript/ts-parser.ts

@@ -71,30 +71,27 @@ export class TypeScriptParser extends BaseParser {
 }
 
 /**
- * Read compilerOptions.paths from the nearest tsconfig.json in projectRoot.
- * Handles baseUrl prefix so aliases like "@/*" → ["src/*"] resolve correctly.
+ * Read compilerOptions.paths from tsconfig.json in projectRoot.
+ * Recursively follows "extends" chains (e.g. extends ./tsconfig.base.json,
+ * extends @tsconfig/node-lts/tsconfig.json) and merges paths.
+ * 
+ * Handles:
+ *  - extends with relative paths (./tsconfig.base.json)
+ *  - extends with node_modules packages (@tsconfig/node-lts)
+ *  - baseUrl prefix so aliases like "@/*" → ["src/*"] resolve correctly
+ *  - JSON5-style comments (line and block comments)
  */
 function loadTsConfigPaths(projectRoot: string): Record<string, string[]> {
     const candidates = ['tsconfig.json', 'tsconfig.base.json']
     for (const name of candidates) {
         const tsConfigPath = path.join(projectRoot, name)
         try {
-            const raw = fs.readFileSync(tsConfigPath, 'utf-8')
-            // Strip line comments before JSON.parse (tsconfig allows them)
-            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')
-            let tsConfig: any
-            try {
-                tsConfig = JSON.parse(stripped)
-            } catch {
-                // Stripping may have broken a URL (e.g. "https://...") — fall back to raw
-                tsConfig = JSON.parse(raw)
-            }
-            const options = tsConfig.compilerOptions ?? {}
+            const merged = loadTsConfigWithExtends(tsConfigPath, new Set())
+            const options = merged.compilerOptions ?? {}
             const rawPaths: Record<string, string[]> = options.paths ?? {}
             if (Object.keys(rawPaths).length === 0) continue
 
             const baseUrl: string = options.baseUrl ?? '.'
-            // Prefix each target with baseUrl so relative resolution works
             const resolved: Record<string, string[]> = {}
             for (const [alias, targets] of Object.entries(rawPaths)) {
                 resolved[alias] = (targets as string[]).map(t =>
@@ -106,3 +103,85 @@ function loadTsConfigPaths(projectRoot: string): Record<string, string[]> {
     }
     return {}
 }
+
+/**
+ * Recursively load a tsconfig, following the "extends" chain.
+ * Merges compilerOptions from parent → child (child wins on conflict).
+ * Prevents infinite loops via a visited set.
+ */
+function loadTsConfigWithExtends(configPath: string, visited: Set<string>): any {
+    const resolved = path.resolve(configPath)
+    if (visited.has(resolved)) return {}
+    visited.add(resolved)
+
+    let raw: string
+    try {
+        raw = fs.readFileSync(resolved, 'utf-8')
+    } catch {
+        return {}
+    }
+
+    // Strip JSON5 comments
+    const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')
+    let config: any
+    try {
+        config = JSON.parse(stripped)
+    } catch {
+        try { config = JSON.parse(raw) } catch { return {} }
+    }
+
+    if (!config.extends) return config
+
+    // Resolve the parent config path
+    const extendsValue = config.extends
+    let parentPath: string
+
+    if (extendsValue.startsWith('.')) {
+        // Relative path: ./tsconfig.base.json or ../tsconfig.json
+        parentPath = path.resolve(path.dirname(resolved), extendsValue)
+        // Add .json if missing
+        if (!parentPath.endsWith('.json')) parentPath += '.json'
+    } else {
+        // Node module: @tsconfig/node-lts or @tsconfig/node-lts/tsconfig.json
+        try {
+            // Try resolving as a node module from projectRoot
+            const projectRoot = path.dirname(resolved)
+            const modulePath = path.join(projectRoot, 'node_modules', extendsValue)
+            if (fs.existsSync(modulePath + '.json')) {
+                parentPath = modulePath + '.json'
+            } else if (fs.existsSync(path.join(modulePath, 'tsconfig.json'))) {
+                parentPath = path.join(modulePath, 'tsconfig.json')
+            } else if (fs.existsSync(modulePath)) {
+                parentPath = modulePath
+            } else {
+                // Can't resolve — skip extends
+                delete config.extends
+                return config
+            }
+        } catch {
+            delete config.extends
+            return config
+        }
+    }
+
+    // Load parent recursively
+    const parent = loadTsConfigWithExtends(parentPath, visited)
+
+    // Merge: parent compilerOptions → child compilerOptions (child wins)
+    const merged = { ...config }
+    delete merged.extends
+    merged.compilerOptions = {
+        ...(parent.compilerOptions ?? {}),
+        ...(config.compilerOptions ?? {}),
+    }
+
+    // Merge paths specifically (child paths override parent paths for same alias)
+    if (parent.compilerOptions?.paths || config.compilerOptions?.paths) {
+        merged.compilerOptions.paths = {
+            ...(parent.compilerOptions?.paths ?? {}),
+            ...(config.compilerOptions?.paths ?? {}),
+        }
+    }
+
+    return merged
+}

package/tests/contract.test.ts

@@ -76,7 +76,7 @@ describe('LockCompiler', () => {
         const graph = new GraphBuilder().build(files)
         const lock = compiler.compile(graph, contract, files)
 
-        expect(lock.version).toBe('1.0.0')
+        expect(lock.version).toBe('1.7.0')
         expect(lock.syncState.status).toBe('clean')
         expect(Object.keys(lock.functions).length).toBeGreaterThan(0)
         expect(Object.keys(lock.modules).length).toBeGreaterThanOrEqual(1)

package/tests/helpers.ts

@@ -45,7 +45,6 @@ export function mockFunction(
         purpose: '',
         edgeCasesHandled: [],
         errorHandling: [],
-        detailedLines: [],
     }
 }