/**

* scripts/lcov-to-istanbul.ts

*

* Convert Bun's LCOV coverage output (`.coverage/lcov.info`) into the Istanbul

* `coverage-final.json` format that `fallow health --coverage <path>` expects.

*

* Bun emits LCOV via `bun test --coverage --coverage-reporter=lcov`, but

* fallow's CRAP scorer wants Istanbul JSON. Bun's LCOV currently includes

* aggregate `FNF` / `FNH` function totals but omits the per-function `FN` /

* `FNDA` records Istanbul needs. This converter therefore combines the LCOV

* line hits with TypeScript's source AST:

* - `f` / `fnMap` from native `FN` / `FNDA` records when present, otherwise

* from source function ranges with Bun's declaration-line hit count.

* - `s` / `statementMap` from LCOV's `DA` records — used as a fallback

* line-coverage signal.

* - `b` / `branchMap` left empty: LCOV's `BRDA` data uses block IDs that

* don't translate to Istanbul's branch shape without source-map context.

* CRAP is dominated by function coverage in practice, so this is fine.

*

* Run with `bun run scripts/lcov-to-istanbul.ts [in.lcov] [out.json]`.

* Defaults to `.coverage/lcov.info` → `.coverage/coverage-final.json`.

*

* The `wired:coverage` script in package.json composes

* `bun test --coverage` → this converter → `npx fallow health --coverage`.

*/

import { readFile, writeFile, mkdir } from 'node:fs/promises'

import { dirname, isAbsolute, resolve } from 'node:path'

import { fileURLToPath } from 'node:url'

import * as ts from 'typescript'

const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')

interface IstanbulRange {

start: { line: number; column: number }

end: { line: number; column: number }

}

interface IstanbulFunction {

name: string

decl: IstanbulRange

loc: IstanbulRange

line: number

}

interface IstanbulFileCoverage {

path: string

statementMap: Record<string, IstanbulRange>

fnMap: Record<string, IstanbulFunction>

branchMap: Record<string, never>

s: Record<string, number>

f: Record<string, number>

b: Record<string, never>

}

type IstanbulCoverage = Record<string, IstanbulFileCoverage>

interface LcovFunction {

line: number

endLine: number

name: string

hits: number

range?: IstanbulRange

}

interface LcovFileRecord {

path: string

functions: LcovFunction[]

/** line number → hit count */

lineHits: Map<number, number>

}

type ReadSource = (path: string) => Promise<string>

/**

* Parse an LCOV file into a list of per-file records.

*

* LCOV is line-oriented; the records we care about:

* SF:<path> — file path (start of a record)

* FN:<line>,<name> — function declaration at <line>

* FNDA:<hits>,<name> — function hit count

* DA:<line>,<hits> — line hit count

* end_of_record — terminator

*/

export function parseLcov(lcov: string): LcovFileRecord[] {

const records: LcovFileRecord[] = []

let current: LcovFileRecord | null = null

// FN comes before FNDA — buffer FNs by name so FNDA can backfill the hit count.

const fnByName = new Map<string, LcovFunction>()

for (const rawLine of lcov.split('\n')) {

const line = rawLine.trim()

if (!line) continue

if (line.startsWith('SF:')) {

current = { path: line.slice(3), functions: [], lineHits: new Map() }

fnByName.clear()

continue

}

if (!current) continue

if (line.startsWith('FN:')) {

const [lineNumber, ...nameParts] = line.slice(3).split(',')

const name = nameParts.join(',')

const fnLine = Number(lineNumber)

const fn: LcovFunction = {

line: fnLine,

endLine: fnLine,

name,

hits: 0,

}

current.functions.push(fn)

fnByName.set(name, fn)

continue

}

if (line.startsWith('FNDA:')) {

const [hits, ...nameParts] = line.slice(5).split(',')

const name = nameParts.join(',')

const fn = fnByName.get(name)

if (fn) fn.hits = Number(hits)

continue

}

if (line.startsWith('DA:')) {

const [lineNumber, hits] = line.slice(3).split(',')

current.lineHits.set(Number(lineNumber), Number(hits))

continue

}

if (line === 'end_of_record') {

records.push(current)

current = null

fnByName.clear()

}

}

if (current) records.push(current)

return records

}

/** Build a single-line range — fallow only needs the line number for CRAP. */

function lineRange(line: number): IstanbulRange {

return {

start: { line, column: 0 },

end: { line, column: 0 },

}

}

function sourceRange(

sourceFile: ts.SourceFile,

start: number,

end: number,

): IstanbulRange {

const startPosition = sourceFile.getLineAndCharacterOfPosition(start)

const endPosition = sourceFile.getLineAndCharacterOfPosition(end)

return {

start: {

line: startPosition.line + 1,

column: startPosition.character,

},

end: {

line: endPosition.line + 1,

column: endPosition.character,

},

}

}

function propertyNameText(name: ts.PropertyName | undefined): string | null {

if (!name) return null

if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {

return name.text

}

if (ts.isPrivateIdentifier(name)) return name.text

return null

}

function sourceFunctionName(node: ts.FunctionLikeDeclaration): string {

if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {

return node.name?.text ?? '<function>'

}

if (ts.isConstructorDeclaration(node)) return 'constructor'

if (

ts.isMethodDeclaration(node) ||

ts.isGetAccessorDeclaration(node) ||

ts.isSetAccessorDeclaration(node)

) {

return propertyNameText(node.name) ?? '<function>'

}

return '<arrow>'

}

function isRuntimeFunction(node: ts.Node): node is ts.FunctionLikeDeclaration {

return (

ts.isFunctionDeclaration(node) ||

ts.isFunctionExpression(node) ||

ts.isArrowFunction(node) ||

ts.isMethodDeclaration(node) ||

ts.isGetAccessorDeclaration(node) ||

ts.isSetAccessorDeclaration(node) ||

ts.isConstructorDeclaration(node)

) && node.body !== undefined

}

/**

* Build the function inventory Bun leaves out of LCOV. Declaration lines match

* fallow's source function index; full ranges keep the output valid Istanbul.

*/

export function extractSourceFunctions(

sourceText: string,

path: string,

lineHits: ReadonlyMap<number, number>,

): LcovFunction[] {

const sourceFile = ts.createSourceFile(

path,

sourceText,

ts.ScriptTarget.Latest,

true,

)

const functions: LcovFunction[] = []

function visit(node: ts.Node): void {

if (isRuntimeFunction(node)) {

const range = sourceRange(sourceFile, node.getStart(sourceFile), node.end)

let hits = lineHits.get(range.start.line)

if (hits === undefined) {

for (let line = range.start.line + 1; line <= range.end.line; line++) {

const lineHitCount = lineHits.get(line)

if (lineHitCount !== undefined) {

hits = lineHitCount

break

}

}

}

functions.push({

line: range.start.line,

endLine: range.end.line,

name: sourceFunctionName(node),

hits: hits ?? 0,

range,

})

}

ts.forEachChild(node, visit)

}

visit(sourceFile)

return functions

}

export async function toIstanbul(

records: LcovFileRecord[],

readSource: ReadSource = (path) => readFile(path, 'utf-8'),

): Promise<IstanbulCoverage> {

const out: IstanbulCoverage = {}

for (const record of records) {

const absolutePath = isAbsolute(record.path)

? record.path

: resolve(PROJECT_ROOT, record.path)

let functions = record.functions

if (functions.length === 0) {

try {

const sourceText = await readSource(absolutePath)

functions = extractSourceFunctions(sourceText, absolutePath, record.lineHits)

} catch (err) {

const code = err instanceof Error && 'code' in err ? err.code : undefined

if (code !== 'ENOENT') throw err

}

}

const fnMap: Record<string, IstanbulFunction> = {}

const f: Record<string, number> = {}

functions.forEach((fn, idx) => {

const id = String(idx)

const range = fn.range ?? lineRange(fn.line)

fnMap[id] = {

name: fn.name,

decl: range,

loc: range,

line: fn.line,

}

f[id] = fn.hits

})

const statementMap: Record<string, IstanbulRange> = {}

const s: Record<string, number> = {}

let stmtIdx = 0

for (const [line, hits] of record.lineHits) {

const id = String(stmtIdx++)

statementMap[id] = lineRange(line)

s[id] = hits

}

out[absolutePath] = {

path: absolutePath,

statementMap,

fnMap,

branchMap: {},

s,

f,

b: {},

}

}

return out

}

async function main() {

const [inputArg, outputArg] = process.argv.slice(2)

const inputPath = resolve(PROJECT_ROOT, inputArg ?? '.coverage/lcov.info')

const outputPath = resolve(PROJECT_ROOT, outputArg ?? '.coverage/coverage-final.json')

const lcov = await readFile(inputPath, 'utf-8')

const records = parseLcov(lcov)

const istanbul = await toIstanbul(records)

await mkdir(dirname(outputPath), { recursive: true })

await writeFile(outputPath, JSON.stringify(istanbul), 'utf-8')

const fileCount = Object.keys(istanbul).length

const fnCount = Object.values(istanbul).reduce(

(sum, file) => sum + Object.keys(file.f).length,

0,

)

console.log(

`[lcov-to-istanbul] ${inputPath} → ${outputPath}\n` +

` ${fileCount} files, ${fnCount} functions`,

)

}

if (import.meta.main) {

main().catch((err) => {

console.error('[lcov-to-istanbul]', err)

process.exit(1)

})

}