@getmikk/core 1.8.3 → 1.9.1

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

@@ -1,191 +1,36 @@
-import * as path from 'node:path'
-import * as fs from 'node:fs'
 import { BaseParser } from '../base-parser.js'
+import type { ParsedFile } from '../types.js'
 import { TypeScriptExtractor } from './ts-extractor.js'
 import { TypeScriptResolver } from './ts-resolver.js'
 import { hashContent } from '../../hash/file-hasher.js'
-import type { ParsedFile } from '../types.js'
-import { MIN_FILES_FOR_COMPLETE_SCAN, parseJsonWithComments } from '../parser-constants.js'
 
-/**
- * TypeScript parser — uses TS Compiler API to parse .ts/.tsx files
- * and extract structured data (functions, classes, imports, exports).
- */
 export class TypeScriptParser extends BaseParser {
-    /** Parse a single TypeScript file */
-    async parse(filePath: string, content: string): Promise<ParsedFile> {
+    public async parse(filePath: string, content: string): Promise<ParsedFile> {
         const extractor = new TypeScriptExtractor(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: re-export declarations (`export { Name }` or
-        // `export { X as Y } from './m'`) may refer to symbols whose declaration
-        // doesn't carry an export keyword. Mark them as exported here.
-        // Exclude `type: 'default'` to avoid marking an unrelated local called 'default'.
-        const exportedNonDefault = new Set(
-            exports.filter(e => e.type !== 'default').map(e => e.name)
-        )
-        for (const fn of functions) {
-            if (!fn.isExported && exportedNonDefault.has(fn.name)) fn.isExported = true
-        }
-        for (const cls of classes) {
-            if (!cls.isExported && exportedNonDefault.has(cls.name)) cls.isExported = true
-        }
-        for (const gen of generics) {
-            if (!gen.isExported && exportedNonDefault.has(gen.name)) gen.isExported = true
-        }
-
+        
         return {
             path: filePath,
             language: 'typescript',
-            functions,
-            classes,
-            generics,
-            imports,
-            exports,
-            routes,
+            functions: extractor.extractFunctions(),
+            classes: extractor.extractClasses(),
+            variables: extractor.extractVariables(),
+            generics: extractor.extractGenerics(),
+            imports: extractor.extractImports(),
+            exports: extractor.extractExports(),
+            routes: extractor.extractRoutes(),
+            calls: extractor.extractModuleCalls(),
             hash: hashContent(content),
-            parsedAt: Date.now(),
+            parsedAt: Date.now()
         }
     }
 
-    /** Resolve all import paths in parsed files to absolute project paths */
-    resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
-        const tsConfigPaths = loadTsConfigPaths(projectRoot)
-        const resolver = new TypeScriptResolver(projectRoot, tsConfigPaths)
-
-        // Only pass the project file list when it is large enough to be a meaningful
-        // scan. Sparse lists (< MIN_FILES_FOR_COMPLETE_SCAN files) cause alias
-        // resolution lookups to fail with '', so we only trust the list once it is
-        // sufficiently large. With an empty list the resolver falls back to extension
-        // probing, which is safe for alias-defined paths.
-        const allFilePaths = files.length >= MIN_FILES_FOR_COMPLETE_SCAN ? files.map(f => f.path) : []
-
-        return files.map(file => ({
-            ...file,
-            imports: file.imports.map(imp => resolver.resolve(imp, file.path, allFilePaths)),
-        }))
+    public resolveImports(files: ParsedFile[], projectRoot: string): ParsedFile[] {
+        const resolver = new TypeScriptResolver(projectRoot)
+        return resolver.resolveBatch(files)
     }
 
-    getSupportedExtensions(): string[] {
+    public getSupportedExtensions(): string[] {
         return ['.ts', '.tsx']
     }
 }
 
-/**
- * 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) via the shared helper
- */
-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 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 ?? '.'
-            const resolved: Record<string, string[]> = {}
-            for (const [alias, targets] of Object.entries(rawPaths)) {
-                resolved[alias] = (targets as string[]).map(t =>
-                    t.startsWith('.') ? path.posix.join(baseUrl, t) : t
-                )
-            }
-            return resolved
-        } catch { /* tsconfig not found or invalid — continue */ }
-    }
-    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 {}
-    }
-
-    let config: any
-    try {
-        config = parseJsonWithComments(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/src/parser/typescript/ts-resolver.ts

@@ -1,5 +1,5 @@
 import * as path from 'node:path'
-import type { ParsedImport } from '../types.js'
+import type { ParsedImport, ParsedFile } from '../types.js'
 
 interface TSConfigPaths {
     [alias: string]: string[]
@@ -26,6 +26,16 @@ export class TypeScriptResolver {
         this.aliases = tsConfigPaths ?? {}
     }
 
+    /** Resolve all imports for a batch of files */
+    public resolveBatch(files: ParsedFile[]): ParsedFile[] {
+        const allFilePaths = files.map(f => f.path)
+        return files.map(file => ({
+            ...file,
+            imports: this.resolveAll(file.imports, file.path, allFilePaths)
+        }))
+    }
+
+
     /** Resolve a single import relative to the importing file */
     resolve(imp: ParsedImport, fromFile: string, allProjectFiles: string[] = []): ParsedImport {
         if (

package/src/search/bm25.ts

@@ -43,12 +43,14 @@ export class BM25Index {
     private documents: BM25Document[] = []
     private documentFrequency = new Map<string, number>()  // term → how many docs contain it
     private avgDocLength = 0
+    private totalDocLength = 0  // running total — avoids O(n²) recompute on every addDocument
 
     /** Clear the index */
     clear(): void {
         this.documents = []
         this.documentFrequency.clear()
         this.avgDocLength = 0
+        this.totalDocLength = 0
     }
 
     /** Add a document with pre-tokenized terms */
@@ -62,8 +64,9 @@ export class BM25Index {
             this.documentFrequency.set(term, (this.documentFrequency.get(term) ?? 0) + 1)
         }
 
-        // Recompute average document length
-        this.avgDocLength = this.documents.reduce((sum, d) => sum + d.length, 0) / this.documents.length
+        // O(1) running average — was O(n) reduce over all documents on every insert
+        this.totalDocLength += normalizedTokens.length
+        this.avgDocLength = this.totalDocLength / this.documents.length
     }
 
     /** Search the index and return ranked results */
@@ -92,7 +95,14 @@ export class BM25Index {
 
                 // BM25 score component
                 const tfNorm = (tf * (K1 + 1)) / (tf + K1 * (1 - B + B * (doc.length / this.avgDocLength)))
-                score += idf * tfNorm
+                let termScore = idf * tfNorm
+
+                // Bonus for direct name match in the ID
+                if (doc.id.toLowerCase().includes(term.toLowerCase())) {
+                    termScore += 0.5
+                }
+
+                score += termScore
             }
 
             if (score > 0) {
@@ -178,7 +188,9 @@ export function buildFunctionTokens(fn: {
 
     // Function name tokens (highest signal)
     parts.push(...tokenize(fn.name))
-    parts.push(...tokenize(fn.name)) // Double-weight the name
+    parts.push(...tokenize(fn.name))
+    parts.push(...tokenize(fn.name)) // Triple-weight the name
+    parts.push(`name_exact:${fn.name.toLowerCase()}`)
 
     // File path tokens
     const filename = fn.file.split('/').pop() ?? fn.file

package/src/utils/minimatch.ts

@@ -24,5 +24,5 @@ export function minimatch(filePath: string, pattern: string): boolean {
     .replace(/\*\*/g, '.*')
     .replace(/\*/g, '[^/]*')
 
-  return new RegExp(`^${regexStr}$`).test(normalizedPath)
+  return new RegExp(`^${regexStr}$`, 'i').test(normalizedPath)
 }

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.7.0')
+        expect(lock.version).toBe('2.0.0')
         expect(lock.syncState.status).toBe('clean')
         expect(Object.keys(lock.functions).length).toBeGreaterThan(0)
         expect(Object.keys(lock.modules).length).toBeGreaterThanOrEqual(1)
@@ -89,7 +89,7 @@ describe('LockCompiler', () => {
         ]
         const graph = new GraphBuilder().build(files)
         const lock = compiler.compile(graph, contract, files)
-        expect(lock.functions['fn:src/auth/verify.ts:verifyToken']?.moduleId).toBe('auth')
+        expect(lock.functions['fn:src/auth/verify.ts:verifytoken']?.moduleId).toBe('auth')
     })
 
     it('computes stable module hash', () => {

package/tests/dead-code.test.ts

@@ -31,7 +31,7 @@ function generateDummyLock(graphNodes: Map<string, any>): MikkLock {
 
     for (const [id, node] of graphNodes.entries()) {
         if (node.type === 'function') {
-            const name = node.label
+            const name = node.name
             const file = node.file
             // We need to populate `calledBy` for transitive liveness checks
 
@@ -68,7 +68,7 @@ describe('DeadCodeDetector', () => {
         // lookups for the lock structure (it only does it for the graph)
         Object.values(lock.functions).forEach(fn => {
             const inEdges = graph.inEdges.get(fn.id) ?? []
-            fn.calledBy = inEdges.filter(e => e.type === 'calls').map(e => e.source)
+            fn.calledBy = inEdges.filter(e => e.type === 'calls').map(e => e.from)
         })
 
         const detector = new DeadCodeDetector(graph, lock)
@@ -83,7 +83,7 @@ describe('DeadCodeDetector', () => {
         const graph = buildTestGraph([
             ['D', 'nothing']
         ])
-        graph.nodes.get('fn:src/D.ts:D')!.metadata!.isExported = true
+        graph.nodes.get('fn:src/d.ts:d')!.metadata!.isExported = true
 
         const lock = generateDummyLock(graph.nodes)
 
@@ -115,16 +115,16 @@ describe('DeadCodeDetector', () => {
         ])
 
         // Both in same file by default from buildTestGraph
-        graph.nodes.get('fn:src/ExportedFn.ts:ExportedFn')!.metadata!.isExported = true
+        graph.nodes.get('fn:src/exportedfn.ts:exportedfn')!.metadata!.isExported = true
 
         // In the lock, we must place them in the SAME file manually because buildTestGraph 
         // puts them in separate files based on name
         const lock = generateDummyLock(graph.nodes)
-        lock.functions['fn:src/ExportedFn.ts:ExportedFn'].file = 'src/shared.ts'
-        lock.functions['fn:src/InternalHelper.ts:InternalHelper'].file = 'src/shared.ts'
+        lock.functions['fn:src/exportedfn.ts:exportedfn'].file = 'src/shared.ts'
+        lock.functions['fn:src/internalhelper.ts:internalhelper'].file = 'src/shared.ts'
 
         // Set up the calledBy relation
-        lock.functions['fn:src/InternalHelper.ts:InternalHelper'].calledBy = ['fn:src/ExportedFn.ts:ExportedFn']
+        lock.functions['fn:src/internalhelper.ts:internalhelper'].calledBy = ['fn:src/exportedfn.ts:exportedfn']
 
         const detector = new DeadCodeDetector(graph, lock)
         const result = detector.detect()

package/tests/esm-resolver.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeAll, afterAll } from 'bun:test'
+import * as path from 'node:path'
+import * as fs from 'node:fs/promises'
+import { OxcResolver } from '../src/parser/oxc-resolver'
+
+describe('OxcResolver - ESM and CJS Resolution', () => {
+    const FIXTURE_DIR = path.join(process.cwd(), '.test-fixture-esm')
+
+    beforeAll(async () => {
+        await fs.mkdir(FIXTURE_DIR, { recursive: true })
+        
+        // 1. Create a "dependency" package with 'exports'
+        const depDir = path.join(FIXTURE_DIR, 'node_modules', 'some-pkg')
+        await fs.mkdir(depDir, { recursive: true })
+        
+        await fs.writeFile(
+            path.join(depDir, 'package.json'),
+            JSON.stringify({
+                name: 'some-pkg',
+                type: 'module',
+                exports: {
+                    '.': {
+                        import: './dist/esm/index.js',
+                        require: './dist/cjs/index.cjs',
+                        types: './dist/index.d.ts'
+                    },
+                    './subpath': './dist/sub.js'
+                }
+            })
+        )
+        
+        await fs.mkdir(path.join(depDir, 'dist', 'esm'), { recursive: true })
+        await fs.mkdir(path.join(depDir, 'dist', 'cjs'), { recursive: true })
+        await fs.writeFile(path.join(depDir, 'dist', 'esm', 'index.js'), 'export const a = 1')
+        await fs.writeFile(path.join(depDir, 'dist', 'cjs', 'index.cjs'), 'exports.a = 1')
+        await fs.writeFile(path.join(depDir, 'dist', 'sub.js'), 'export const sub = 1')
+
+        // 2. Create a main package.json
+        await fs.writeFile(
+            path.join(FIXTURE_DIR, 'package.json'),
+            JSON.stringify({
+                name: 'main-pkg',
+                type: 'module'
+            })
+        )
+    })
+
+    afterAll(async () => {
+        await fs.rm(FIXTURE_DIR, { recursive: true, force: true })
+    })
+
+    it('resolves ESM exports correctly', () => {
+        const resolver = new OxcResolver(FIXTURE_DIR)
+        
+        // Resolve 'some-pkg' (should hit exports['.'].import)
+        const res = resolver.resolve('some-pkg', path.join(FIXTURE_DIR, 'index.ts'))
+        expect(res).toContain('node_modules/some-pkg/dist/esm/index.js')
+    })
+
+    it('resolves subpath exports correctly', () => {
+        const resolver = new OxcResolver(FIXTURE_DIR)
+        
+        // Resolve 'some-pkg/subpath'
+        const res = resolver.resolve('some-pkg/subpath', path.join(FIXTURE_DIR, 'index.ts'))
+        expect(res).toContain('node_modules/some-pkg/dist/sub.js')
+    })
+
+    it('resolves relative imports with extension probing', async () => {
+        const resolver = new OxcResolver(FIXTURE_DIR)
+        await fs.writeFile(path.join(FIXTURE_DIR, 'local.ts'), 'export const x = 1')
+        
+        const res = resolver.resolve('./local', path.join(FIXTURE_DIR, 'index.ts'))
+        expect(res).toContain('.test-fixture-esm/local.ts')
+    })
+})

package/tests/graph.test.ts

@@ -19,8 +19,8 @@ describe('GraphBuilder', () => {
             mockParsedFile('src/auth.ts', [mockFunction('verifyToken', [], 'src/auth.ts')]),
         ]
         const graph = builder.build(files)
-        expect(graph.nodes.has('fn:src/auth.ts:verifyToken')).toBe(true)
-        expect(graph.nodes.get('fn:src/auth.ts:verifyToken')!.type).toBe('function')
+        expect(graph.nodes.has('fn:src/auth.ts:verifytoken')).toBe(true)
+        expect(graph.nodes.get('fn:src/auth.ts:verifytoken')!.type).toBe('function')
     })
 
     it('creates edges for imports', () => {
@@ -35,8 +35,8 @@ describe('GraphBuilder', () => {
         const graph = builder.build(files)
         const importEdges = graph.edges.filter(e => e.type === 'imports')
         expect(importEdges.length).toBeGreaterThanOrEqual(1)
-        expect(importEdges[0].source).toBe('src/auth.ts')
-        expect(importEdges[0].target).toBe('src/utils/jwt.ts')
+        expect(importEdges[0].from).toBe('src/auth.ts')
+        expect(importEdges[0].to).toBe('src/utils/jwt.ts')
     })
 
     it('creates edges for function calls via imports', () => {
@@ -51,8 +51,8 @@ describe('GraphBuilder', () => {
         const graph = builder.build(files)
         const callEdges = graph.edges.filter(e => e.type === 'calls')
         expect(callEdges.length).toBeGreaterThanOrEqual(1)
-        expect(callEdges[0].source).toBe('fn:src/auth.ts:verifyToken')
-        expect(callEdges[0].target).toBe('fn:src/utils/jwt.ts:jwtDecode')
+        expect(callEdges[0].from).toBe('fn:src/auth.ts:verifytoken')
+        expect(callEdges[0].to).toBe('fn:src/utils/jwt.ts:jwtdecode')
     })
 
     it('creates containment edges', () => {
@@ -62,8 +62,8 @@ describe('GraphBuilder', () => {
         const graph = builder.build(files)
         const containEdges = graph.edges.filter(e => e.type === 'contains')
         expect(containEdges.length).toBeGreaterThanOrEqual(1)
-        expect(containEdges[0].source).toBe('src/auth.ts')
-        expect(containEdges[0].target).toBe('fn:src/auth.ts:verifyToken')
+        expect(containEdges[0].from).toBe('src/auth.ts')
+        expect(containEdges[0].to).toBe('fn:src/auth.ts:verifytoken')
     })
 
     it('builds adjacency maps', () => {
@@ -72,7 +72,7 @@ describe('GraphBuilder', () => {
         ]
         const graph = builder.build(files)
         expect(graph.outEdges.has('src/auth.ts')).toBe(true)
-        expect(graph.inEdges.has('fn:src/auth.ts:verifyToken')).toBe(true)
+        expect(graph.inEdges.has('fn:src/auth.ts:verifytoken')).toBe(true)
     })
 })
 
@@ -83,8 +83,8 @@ describe('ImpactAnalyzer', () => {
             ['B', 'nothing'],
         ])
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/B.ts:B'])
-        expect(result.impacted).toContain('fn:src/A.ts:A')
+        const result = analyzer.analyze(['fn:src/b.ts:b'])
+        expect(result.impacted).toContain('fn:src/a.ts:a')
     })
 
     it('finds transitive dependents', () => {
@@ -94,9 +94,9 @@ describe('ImpactAnalyzer', () => {
             ['C', 'nothing'],
         ])
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/C.ts:C'])
-        expect(result.impacted).toContain('fn:src/B.ts:B')
-        expect(result.impacted).toContain('fn:src/A.ts:A')
+        const result = analyzer.analyze(['fn:src/c.ts:c'])
+        expect(result.impacted).toContain('fn:src/b.ts:b')
+        expect(result.impacted).toContain('fn:src/a.ts:a')
     })
 
     it('reports correct depth', () => {
@@ -107,7 +107,7 @@ describe('ImpactAnalyzer', () => {
             ['D', 'nothing'],
         ])
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/D.ts:D'])
+        const result = analyzer.analyze(['fn:src/d.ts:d'])
         expect(result.depth).toBeGreaterThanOrEqual(3)
     })
 
@@ -117,8 +117,8 @@ describe('ImpactAnalyzer', () => {
             ['B', 'nothing'],
         ])
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/B.ts:B'])
-        expect(result.confidence).toBe('high')
+        const result = analyzer.analyze(['fn:src/b.ts:b'])
+        expect(result.confidence).toBeGreaterThanOrEqual(0.8)
     })
 
     it('does not include changed nodes in impacted', () => {
@@ -127,9 +127,9 @@ describe('ImpactAnalyzer', () => {
             ['B', 'nothing'],
         ])
         const analyzer = new ImpactAnalyzer(graph)
-        const result = analyzer.analyze(['fn:src/B.ts:B'])
-        expect(result.impacted).not.toContain('fn:src/B.ts:B')
-        expect(result.changed).toContain('fn:src/B.ts:B')
+        const result = analyzer.analyze(['fn:src/b.ts:b'])
+        expect(result.impacted).not.toContain('fn:src/b.ts:b')
+        expect(result.changed).toContain('fn:src/b.ts:b')
     })
 })
 

package/tests/helpers.ts

@@ -1,5 +1,5 @@
 import { hashContent } from '../src/hash/file-hasher'
-import type { ParsedFile, ParsedFunction, ParsedImport } from '../src/parser/types'
+import type { ParsedFile, ParsedFunction, ParsedImport, CallExpression } from '../src/parser/types'
 import { GraphBuilder } from '../src/graph/graph-builder'
 import type { DependencyGraph } from '../src/graph/types'
 
@@ -10,7 +10,7 @@ export function mockParsedFile(
     imports: ParsedImport[] = []
 ): ParsedFile {
     return {
-        path: filePath,
+        path: filePath.replace(/\\/g, '/'),
         language: 'typescript',
         functions,
         classes: [],
@@ -26,25 +26,30 @@ export function mockParsedFile(
 /** Build a minimal ParsedFunction */
 export function mockFunction(
     name: string,
-    calls: string[] = [],
+    calls: (string | CallExpression)[] = [],
     file: string = 'src/test.ts',
     isExported: boolean = false
 ): ParsedFunction {
+    const mappedCalls: CallExpression[] = calls.map(c => 
+        typeof c === 'string' ? { name: c, line: 1, type: 'function' } : c
+    )
+    const normalizedPath = file.replace(/\\/g, '/')
     return {
-        id: `fn:${file}:${name}`,
+        id: `fn:${normalizedPath}:${name}`.toLowerCase(),
         name,
-        file,
+        file: normalizedPath,
         startLine: 1,
         endLine: 10,
         params: [],
         returnType: 'void',
         isExported,
         isAsync: false,
-        calls,
+        calls: mappedCalls,
         hash: hashContent(name),
         purpose: '',
         edgeCasesHandled: [],
         errorHandling: [],
+        detailedLines: [],
     }
 }