@getmikk/core 1.5.1 → 1.7.0

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

@@ -0,0 +1,41 @@
+import { BaseParser } from '../base-parser.js'
+import { GoExtractor } from './go-extractor.js'
+import { GoResolver } from './go-resolver.js'
+import { hashContent } from '../../hash/file-hasher.js'
+import type { ParsedFile } from '../types.js'
+
+/**
+ * GoParser — implements BaseParser for .go files.
+ * Uses GoExtractor (regex-based) to pull structured data from Go source
+ * without requiring the Go toolchain.
+ */
+export class GoParser extends BaseParser {
+    parse(filePath: string, content: string): ParsedFile {
+        const extractor = new GoExtractor(filePath, content)
+
+        return {
+            path: filePath,
+            language: 'go',
+            functions: extractor.extractFunctions(),
+            classes: extractor.extractClasses(),
+            generics: [], // Go type aliases handled as classes/exports
+            imports: extractor.extractImports(),
+            exports: extractor.extractExports(),
+            routes: extractor.extractRoutes(),
+            hash: hashContent(content),
+            parsedAt: Date.now(),
+        }
+    }
+
+    resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+        const resolver = new GoResolver(projectRoot)
+        return files.map(file => ({
+            ...file,
+            imports: resolver.resolveAll(file.imports),
+        }))
+    }
+
+    getSupportedExtensions(): string[] {
+        return ['.go']
+    }
+}

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

@@ -0,0 +1,70 @@
+import * as path from 'node:path'
+import * as fs from 'node:fs'
+import type { ParsedImport } from '../types.js'
+
+/**
+ * GoResolver — resolves Go import paths to project-relative file paths.
+ *
+ * Go import paths follow the module path declared in go.mod:
+ *   module github.com/user/project
+ *
+ * An import "github.com/user/project/internal/auth" resolves to
+ * the directory internal/auth/ relative to the project root.
+ *
+ * Third-party imports (not matching the module path) are left unresolved.
+ */
+export class GoResolver {
+    private modulePath: string
+
+    constructor(private readonly projectRoot: string) {
+        this.modulePath = readModulePath(projectRoot)
+    }
+
+    /** Resolve a list of imports for a single file */
+    resolveAll(imports: ParsedImport[]): ParsedImport[] {
+        return imports.map(imp => this.resolve(imp))
+    }
+
+    private resolve(imp: ParsedImport): ParsedImport {
+        const src = imp.source
+
+        // Third-party (doesn't start with our module path) → leave as-is
+        if (this.modulePath && !src.startsWith(this.modulePath)) {
+            return { ...imp, resolvedPath: '' }
+        }
+
+        // Internal import: strip module path prefix, map to relative dir
+        const relPath = this.modulePath
+            ? src.slice(this.modulePath.length).replace(/^\//, '')
+            : src
+
+        // Try to find the entry file in the directory
+        const dirPath = relPath.replace(/\//g, path.sep)
+        const candidates = [
+            path.join(dirPath, path.basename(dirPath) + '.go'),
+            path.join(dirPath, 'index.go'),
+            dirPath + '.go',
+        ]
+
+        for (const candidate of candidates) {
+            if (fs.existsSync(path.join(this.projectRoot, candidate))) {
+                return { ...imp, resolvedPath: candidate.replace(/\\/g, '/') }
+            }
+        }
+
+        // Fallback: point to directory (graph builder handles directories separately)
+        return { ...imp, resolvedPath: relPath.replace(/\\/g, '/') }
+    }
+}
+
+/** Read module path from go.mod (e.g. "module github.com/user/myapp") */
+function readModulePath(projectRoot: string): string {
+    const goModPath = path.join(projectRoot, 'go.mod')
+    try {
+        const content = fs.readFileSync(goModPath, 'utf-8')
+        const m = /^module\s+(\S+)/m.exec(content)
+        return m ? m[1] : ''
+    } catch {
+        return ''
+    }
+}

package/src/parser/index.ts

@@ -1,6 +1,8 @@
 import * as path from 'node:path'
 import { BaseParser } from './base-parser.js'
 import { TypeScriptParser } from './typescript/ts-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'
 
@@ -9,6 +11,12 @@ export { BaseParser } from './base-parser.js'
 export { TypeScriptParser } from './typescript/ts-parser.js'
 export { TypeScriptExtractor } from './typescript/ts-extractor.js'
 export { TypeScriptResolver } from './typescript/ts-resolver.js'
+export { GoParser } from './go/go-parser.js'
+export { GoExtractor } from './go/go-extractor.js'
+export { GoResolver } from './go/go-resolver.js'
+export { JavaScriptParser } from './javascript/js-parser.js'
+export { JavaScriptExtractor } from './javascript/js-extractor.js'
+export { JavaScriptResolver } from './javascript/js-resolver.js'
 export { BoundaryChecker } from './boundary-checker.js'
 
 /** Get the appropriate parser for a file based on its extension */
@@ -18,6 +26,13 @@ export function getParser(filePath: string): BaseParser {
         case '.ts':
         case '.tsx':
             return new TypeScriptParser()
+        case '.js':
+        case '.mjs':
+        case '.cjs':
+        case '.jsx':
+            return new JavaScriptParser()
+        case '.go':
+            return new GoParser()
         default:
             throw new UnsupportedLanguageError(ext)
     }
@@ -30,17 +45,42 @@ export async function parseFiles(
     readFile: (fp: string) => Promise<string>
 ): Promise<ParsedFile[]> {
     const tsParser = new TypeScriptParser()
-    const files: ParsedFile[] = []
+    const jsParser = new JavaScriptParser()
+    const goParser = new GoParser()
+    const tsFiles: ParsedFile[] = []
+    const jsFiles: ParsedFile[] = []
+    const goFiles: ParsedFile[] = []
 
     for (const fp of filePaths) {
         const ext = path.extname(fp)
         if (ext === '.ts' || ext === '.tsx') {
-            const content = await readFile(path.join(projectRoot, fp))
-            const parsed = tsParser.parse(fp, content)
-            files.push(parsed)
+            try {
+                const content = await readFile(path.join(projectRoot, fp))
+                tsFiles.push(tsParser.parse(fp, content))
+            } catch {
+                // Skip unreadable files (permissions, binary, etc.) — don't abort the whole parse
+            }
+        } else if (ext === '.js' || ext === '.mjs' || ext === '.cjs' || ext === '.jsx') {
+            try {
+                const content = await readFile(path.join(projectRoot, fp))
+                jsFiles.push(jsParser.parse(fp, content))
+            } catch {
+                // Skip unreadable files
+            }
+        } else if (ext === '.go') {
+            try {
+                const content = await readFile(path.join(projectRoot, fp))
+                goFiles.push(goParser.parse(fp, content))
+            } catch {
+                // Skip unreadable files
+            }
         }
     }
 
-    // Resolve all imports after all files are parsed
-    return tsParser.resolveImports(files, projectRoot)
+    // Resolve imports per language after all files of that language are parsed
+    const resolvedTs = tsParser.resolveImports(tsFiles, projectRoot)
+    const resolvedJs = jsParser.resolveImports(jsFiles, projectRoot)
+    const resolvedGo = goParser.resolveImports(goFiles, projectRoot)
+
+    return [...resolvedTs, ...resolvedJs, ...resolvedGo]
 }

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

@@ -0,0 +1,262 @@
+import ts from 'typescript'
+import { TypeScriptExtractor } from '../typescript/ts-extractor.js'
+import { hashContent } from '../../hash/file-hasher.js'
+import type { ParsedFunction, ParsedImport, ParsedExport } from '../types.js'
+
+/**
+ * JavaScriptExtractor — extends TypeScriptExtractor to add CommonJS support on top of
+ * the TypeScript Compiler API's native JS/JSX parsing.
+ *
+ * Extra patterns handled:
+ *   - require() imports: const x = require('./m') / const { a } = require('./m')
+ *   - module.exports = { foo, bar }  / module.exports = function() {}
+ *   - exports.foo = function() {}
+ *
+ * All ESM patterns (import/export, arrow functions, classes) are inherited from the
+ * TypeScriptExtractor which already handles ScriptKind.JS and ScriptKind.JSX.
+ */
+export class JavaScriptExtractor extends TypeScriptExtractor {
+
+    // ── Public overrides ───────────────────────────────────────────────────────
+
+    /** ESM functions + module.exports-assigned functions */
+    override extractFunctions(): ParsedFunction[] {
+        const fns = super.extractFunctions()
+        const seen = new Set(fns.map(f => f.name))
+        for (const fn of this.extractCommonJsFunctions()) {
+            if (!seen.has(fn.name)) { fns.push(fn); seen.add(fn.name) }
+        }
+        return fns
+    }
+
+    /** ESM imports + CommonJS require() calls */
+    override extractImports(): ParsedImport[] {
+        const esm = super.extractImports()
+        const seen = new Set(esm.map(i => i.source))
+        for (const imp of this.extractRequireImports()) {
+            if (!seen.has(imp.source)) { esm.push(imp); seen.add(imp.source) }
+        }
+        return esm
+    }
+
+    /** ESM exports + CommonJS module.exports / exports.x */
+    override extractExports(): ParsedExport[] {
+        const esm = super.extractExports()
+        const seen = new Set(esm.map(e => e.name))
+        for (const exp of this.extractCommonJsExports()) {
+            if (!seen.has(exp.name)) { esm.push(exp); seen.add(exp.name) }
+        }
+        return esm
+    }
+
+    // ── CommonJS: require() ────────────────────────────────────────────────────
+
+    private extractRequireImports(): ParsedImport[] {
+        const imports: ParsedImport[] = []
+        const walk = (node: ts.Node) => {
+            if (
+                ts.isCallExpression(node) &&
+                ts.isIdentifier(node.expression) &&
+                node.expression.text === 'require' &&
+                node.arguments.length === 1 &&
+                ts.isStringLiteral(node.arguments[0])
+            ) {
+                // Ignore require.resolve(), require.cache etc. — those are property accesses
+                // on the result, not on `require` itself:  require.resolve() has a
+                // PropertyAccessExpression as node.expression, not an Identifier.
+                const source = (node.arguments[0] as ts.StringLiteral).text
+                const names = this.getRequireBindingNames(node)
+                // isDefault = true when binding is a plain identifier (const x = require(...))
+                // or when there's no binding at all (require(...) used for side effects).
+                // Only destructured object bindings (const { a } = require(...)) are named imports.
+                const parent = node.parent
+                const isDestructured = parent &&
+                    ts.isVariableDeclaration(parent) &&
+                    ts.isObjectBindingPattern(parent.name)
+                imports.push({
+                    source,
+                    resolvedPath: '',
+                    names,
+                    isDefault: !isDestructured,
+                    isDynamic: false,
+                })
+            }
+            ts.forEachChild(node, walk)
+        }
+        ts.forEachChild(this.sourceFile, walk)
+        return imports
+    }
+
+    /** Names extracted from the variable declaration that receives the require() call. */
+    private getRequireBindingNames(call: ts.CallExpression): string[] {
+        const parent = call.parent
+        if (!parent || !ts.isVariableDeclaration(parent)) return []
+        // const { a, b } = require('...') → ['a', 'b']
+        if (ts.isObjectBindingPattern(parent.name)) {
+            return parent.name.elements
+                .filter(e => ts.isIdentifier(e.name))
+                .map(e => (e.name as ts.Identifier).text)
+        }
+        // const x = require('...') → ['x']
+        if (ts.isIdentifier(parent.name)) return [parent.name.text]
+        return []
+    }
+
+    // ── CommonJS: module.exports / exports.x exports ─────────────────────────
+
+    private extractCommonJsExports(): ParsedExport[] {
+        const result: ParsedExport[] = []
+        const fp = this.filePath
+
+        const walk = (node: ts.Node) => {
+            if (
+                ts.isExpressionStatement(node) &&
+                ts.isBinaryExpression(node.expression) &&
+                node.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken
+            ) {
+                const lhs = node.expression.left
+                const rhs = node.expression.right
+
+                // ── module.exports = ... ────────────────────────────────────
+                if (isModuleExports(lhs)) {
+                    if (ts.isObjectLiteralExpression(rhs)) {
+                        // module.exports = { foo, bar }
+                        for (const prop of rhs.properties) {
+                            if (ts.isShorthandPropertyAssignment(prop)) {
+                                result.push({ name: prop.name.text, type: 'const', file: fp })
+                            } else if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                                const isFunc = ts.isFunctionExpression(prop.initializer) || ts.isArrowFunction(prop.initializer)
+                                result.push({ name: prop.name.text, type: isFunc ? 'function' : 'const', file: fp })
+                            }
+                        }
+                    } else if (ts.isFunctionExpression(rhs) || ts.isArrowFunction(rhs)) {
+                        // module.exports = function name() {} → use function name or 'default'
+                        const name = ts.isFunctionExpression(rhs) && rhs.name ? rhs.name.text : 'default'
+                        result.push({ name, type: 'default', file: fp })
+                    } else if (ts.isClassExpression(rhs) && rhs.name) {
+                        result.push({ name: rhs.name.text, type: 'class', file: fp })
+                    } else if (ts.isIdentifier(rhs)) {
+                        result.push({ name: rhs.text, type: 'default', file: fp })
+                    } else {
+                        result.push({ name: 'default', type: 'default', file: fp })
+                    }
+                }
+
+                // ── exports.foo = ... ───────────────────────────────────────
+                if (isExportsDotProp(lhs)) {
+                    const prop = lhs as ts.PropertyAccessExpression
+                    const isFunc = ts.isFunctionExpression(rhs) || ts.isArrowFunction(rhs)
+                    result.push({ name: prop.name.text, type: isFunc ? 'function' : 'const', file: fp })
+                }
+
+                // ── module.exports.foo = ... ────────────────────────────────
+                if (isModuleExportsDotProp(lhs)) {
+                    const prop = lhs as ts.PropertyAccessExpression
+                    const isFunc = ts.isFunctionExpression(rhs) || ts.isArrowFunction(rhs)
+                    result.push({ name: prop.name.text, type: isFunc ? 'function' : 'const', file: fp })
+                }
+            }
+            ts.forEachChild(node, walk)
+        }
+
+        ts.forEachChild(this.sourceFile, walk)
+        return result
+    }
+
+    // ── CommonJS: module.exports / exports.x function bodies ──────────────────
+
+    /**
+     * Detect functions directly assigned via module.exports or exports.x:
+     *   module.exports = function handleLogin(req, res) { ... }
+     *   module.exports = function() { ... }            ← name = 'default'
+     *   exports.createUser = function(data) { ... }
+     *   exports.createUser = (data) => { ... }
+     */
+    private extractCommonJsFunctions(): ParsedFunction[] {
+        const result: ParsedFunction[] = []
+
+        const walk = (node: ts.Node) => {
+            if (
+                ts.isExpressionStatement(node) &&
+                ts.isBinaryExpression(node.expression) &&
+                node.expression.operatorToken.kind === ts.SyntaxKind.EqualsToken
+            ) {
+                const lhs = node.expression.left
+                const rhs = node.expression.right
+
+                if (!ts.isFunctionExpression(rhs) && !ts.isArrowFunction(rhs)) {
+                    ts.forEachChild(node, walk)
+                    return
+                }
+
+                let fnName: string | null = null
+                if (isModuleExports(lhs)) {
+                    // module.exports = function name() {} / function() {}
+                    fnName = ts.isFunctionExpression(rhs) && rhs.name ? rhs.name.text : 'default'
+                } else if (isExportsDotProp(lhs)) {
+                    // exports.foo = function() {}
+                    fnName = (lhs as ts.PropertyAccessExpression).name.text
+                } else if (isModuleExportsDotProp(lhs)) {
+                    // module.exports.foo = function() {}
+                    fnName = (lhs as ts.PropertyAccessExpression).name.text
+                }
+
+                if (fnName !== null) {
+                    const startLine = this.getLineNumber(node.getStart())
+                    const endLine = this.getLineNumber(node.getEnd())
+                    const isAsync = !!(rhs.modifiers?.some((m: ts.Modifier) => m.kind === ts.SyntaxKind.AsyncKeyword))
+                    result.push({
+                        id: `fn:${this.filePath}:${fnName}`,
+                        name: fnName,
+                        file: this.filePath,
+                        startLine,
+                        endLine,
+                        params: this.extractParams(rhs.parameters),
+                        returnType: rhs.type ? rhs.type.getText(this.sourceFile) : 'void',
+                        isExported: true,
+                        isAsync,
+                        calls: this.extractCalls(rhs),
+                        hash: hashContent(rhs.getText(this.sourceFile)),
+                        purpose: this.extractPurpose(node),
+                        edgeCasesHandled: this.extractEdgeCases(rhs),
+                        errorHandling: this.extractErrorHandling(rhs),
+                        detailedLines: this.extractDetailedLines(rhs),
+                    })
+                }
+            }
+            ts.forEachChild(node, walk)
+        }
+
+        ts.forEachChild(this.sourceFile, walk)
+        return result
+    }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** node is `module.exports` */
+function isModuleExports(node: ts.Node): boolean {
+    return (
+        ts.isPropertyAccessExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'module' &&
+        node.name.text === 'exports'
+    )
+}
+
+/** node is `exports.something` */
+function isExportsDotProp(node: ts.Node): boolean {
+    return (
+        ts.isPropertyAccessExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'exports'
+    )
+}
+
+/** node is `module.exports.something` */
+function isModuleExportsDotProp(node: ts.Node): boolean {
+    return (
+        ts.isPropertyAccessExpression(node) &&
+        isModuleExports(node.expression)
+    )
+}

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

@@ -0,0 +1,92 @@
+import * as path from 'node:path'
+import * as fs from 'node:fs'
+import { BaseParser } from '../base-parser.js'
+import { JavaScriptExtractor } from './js-extractor.js'
+import { JavaScriptResolver } from './js-resolver.js'
+import { hashContent } from '../../hash/file-hasher.js'
+import type { ParsedFile } from '../types.js'
+
+/**
+ * JavaScriptParser — implements BaseParser for .js / .mjs / .cjs / .jsx files.
+ *
+ * Uses the TypeScript Compiler API (ScriptKind.JS / ScriptKind.JSX) which correctly
+ * parses JavaScript without type annotations.  JavaScriptExtractor extends
+ * TypeScriptExtractor and adds CommonJS require() / module.exports support.
+ */
+export class JavaScriptParser extends BaseParser {
+    parse(filePath: string, content: string): ParsedFile {
+        const extractor = new JavaScriptExtractor(filePath, content)
+
+        const functions = extractor.extractFunctions()
+        const classes   = extractor.extractClasses()
+        const generics  = extractor.extractGenerics()
+        const imports   = extractor.extractImports()
+        const exports   = extractor.extractExports()
+        const routes    = extractor.extractRoutes()
+
+        // Cross-reference: CJS exports may mark a name exported even when the
+        // declaration itself had no `export` keyword.
+        const exportedNames = new Set(exports.map(e => e.name))
+        for (const fn  of functions) { if (!fn.isExported  && exportedNames.has(fn.name))  fn.isExported  = true }
+        for (const cls of classes)   { if (!cls.isExported && exportedNames.has(cls.name)) cls.isExported = true }
+        for (const gen of generics)  { if (!gen.isExported && exportedNames.has(gen.name)) gen.isExported = true }
+
+        return {
+            path: filePath,
+            language: 'javascript',
+            functions,
+            classes,
+            generics,
+            imports,
+            exports,
+            routes,
+            hash: hashContent(content),
+            parsedAt: Date.now(),
+        }
+    }
+
+    resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+        const aliases = loadAliases(projectRoot)
+        const allFilePaths = files.map(f => f.path)
+        const resolver = new JavaScriptResolver(projectRoot, aliases)
+        return files.map(file => ({
+            ...file,
+            imports: resolver.resolveAll(file.imports, file.path, allFilePaths),
+        }))
+    }
+
+    getSupportedExtensions(): string[] {
+        return ['.js', '.mjs', '.cjs', '.jsx']
+    }
+}
+
+/**
+ * Load path aliases from jsconfig.json → tsconfig.json → tsconfig.base.json.
+ * Strips JS/block comments before parsing (both formats allow them).
+ * Falls back to raw content if comment-stripping breaks a URL.
+ * Returns {} when no config is found.
+ */
+function loadAliases(projectRoot: string): Record<string, string[]> {
+    for (const name of ['jsconfig.json', 'tsconfig.json', 'tsconfig.base.json']) {
+        const configPath = path.join(projectRoot, name)
+        try {
+            const raw = fs.readFileSync(configPath, 'utf-8')
+            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '')
+            let config: any
+            try   { config = JSON.parse(stripped) }
+            catch { config = JSON.parse(raw) }          // URL stripping may have broken JSON
+
+            const options  = config.compilerOptions ?? {}
+            const rawPaths: Record<string, string[]> = options.paths ?? {}
+            if (Object.keys(rawPaths).length === 0) continue
+
+            const baseUrl = options.baseUrl ?? '.'
+            const resolved: Record<string, string[]> = {}
+            for (const [alias, targets] of Object.entries(rawPaths)) {
+                resolved[alias] = (targets as string[]).map((t: string) => path.posix.join(baseUrl, t))
+            }
+            return resolved
+        } catch { /* config absent or unreadable — try next */ }
+    }
+    return {}
+}

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'
+    language: 'typescript' | 'javascript' | 'python' | 'go'
     functions: ParsedFunction[]
     classes: ParsedClass[]
     generics: ParsedGeneric[]