reread-cli 0.0.0-stage → 0.2.0

package/src/args.js

@@ -0,0 +1,155 @@
+// @ts-check
+// The command line: parsed strictly, so a typo fails with a message instead of being ignored.
+
+import { DISPLAY_ORDER, TOOL_IDS } from './tools.js'
+
+/** A mistake in the command line. The CLI prints its message and exits with status 1. */
+export class UsageError extends Error {}
+
+/**
+ * @typedef {object} Options
+ * @property {'report' | 'statusline' | 'help' | 'version'} command
+ * @property {number} since      only replies at or after this time (ms since 1970); 0 for all
+ * @property {string} span       the period in words: 'the last 30 days', 'since 2026-10-01', 'all your sessions'
+ * @property {string} project    only sessions whose project folder contains this text
+ * @property {string} dir        the sessions folder given with --dir, or ''
+ * @property {'all' | import('./tools.js').Tool} tool  whose sessions to read
+ * @property {'text' | 'json' | 'csv' | 'md'} format
+ * @property {'' | 'project' | 'model' | 'day' | 'tool'} by
+ * @property {number} top        sessions in the summary
+ * @property {string | null} html  null: decide by the terminal; '': a file in a private temp folder; else this path
+ * @property {boolean} text      --text: the summary only
+ * @property {boolean} open      open the report in the browser
+ * @property {boolean} anon      replace project names and leave branches out
+ */
+
+const WITH_VALUE = new Set(['--days', '--since', '--project', '--dir', '--by', '--top', '--tool'])
+const SWITCHES = new Set(['--text', '--no-open', '--json', '--csv', '--md', '--anon', '--html'])
+
+/**
+ * @param {string[]} argv  the arguments after the script name
+ * @param {number} [now]   the current time, for --days
+ * @returns {Options}
+ */
+export function parseArgs(argv, now = Date.now()) {
+  /** @type {Map<string, string>} */
+  const values = new Map()
+  /** @type {Set<string>} */
+  const switches = new Set()
+  /** @type {string[]} */
+  const positional = []
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg === '-h' || arg === '--help') return { ...defaults(), command: 'help' }
+    if (arg === '-v' || arg === '--version') return { ...defaults(), command: 'version' }
+    if (!arg.startsWith('-') || arg === '-') {
+      positional.push(arg)
+      continue
+    }
+    const eq = arg.indexOf('=')
+    const name = eq > 0 ? arg.slice(0, eq) : arg
+    const inline = eq > 0 ? arg.slice(eq + 1) : undefined
+    if (WITH_VALUE.has(name)) {
+      const value = inline ?? argv[i + 1]
+      if (value === undefined || (inline === undefined && value.startsWith('--'))) {
+        throw new UsageError(`${name} needs a value (see --help)`)
+      }
+      if (inline === undefined) i++
+      values.set(name, value)
+    } else if (name === '--html') {
+      // --html takes an optional file: --html, --html report.html, --html=report.html
+      switches.add(name)
+      if (inline !== undefined) values.set(name, inline)
+      else if (argv[i + 1] !== undefined && !argv[i + 1].startsWith('-')) values.set(name, argv[++i])
+    } else if (SWITCHES.has(name) && inline === undefined) {
+      switches.add(name)
+    } else {
+      throw new UsageError(`unknown option ${name} (see --help)`)
+    }
+  }
+
+  let command = /** @type {Options['command']} */ ('report')
+  if (positional[0] === 'statusline') {
+    command = 'statusline'
+    positional.shift()
+  }
+  if (positional.length) throw new UsageError(`unexpected argument ${positional[0]} (see --help)`)
+
+  const formats = /** @type {const} */ (['json', 'csv', 'md']).filter((f) => switches.has(`--${f}`))
+  if (formats.length > 1) throw new UsageError(`choose one of --json, --csv or --md`)
+
+  const days = values.get('--days')
+  const sinceArg = values.get('--since')
+  if (days !== undefined && sinceArg !== undefined) throw new UsageError('use --days or --since, not both')
+
+  let since = 0
+  let span = 'all your sessions'
+  if (sinceArg !== undefined) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(sinceArg)
+    const date = m ? new Date(+m[1], +m[2] - 1, +m[3]) : null
+    if (!m || !date || date.getMonth() !== +m[2] - 1 || date.getDate() !== +m[3]) {
+      throw new UsageError('--since takes a date like 2026-10-01')
+    }
+    since = date.getTime()
+    span = `since ${sinceArg}`
+  } else {
+    const n = days === undefined ? 30 : Number(days)
+    if (days !== undefined && (days.trim() === '' || !Number.isFinite(n) || n < 0)) {
+      throw new UsageError('--days takes a number of days, such as --days 7')
+    }
+    if (n > 0) {
+      since = now - n * 86400e3
+      span = n === 1 ? 'the last day' : `the last ${n} days`
+    }
+  }
+
+  const topArg = values.get('--top')
+  const top = topArg === undefined ? 10 : Number(topArg)
+  if (!Number.isInteger(top) || top < 0) throw new UsageError('--top takes a whole number, such as --top 20')
+
+  const by = values.get('--by') ?? ''
+  if (by !== '' && by !== 'project' && by !== 'model' && by !== 'day' && by !== 'tool') {
+    throw new UsageError('--by takes project, model, tool or day')
+  }
+
+  const tool = /** @type {Options['tool']} */ (values.get('--tool') ?? 'all')
+  if (tool !== 'all' && !TOOL_IDS.includes(tool)) {
+    throw new UsageError(`--tool takes ${DISPLAY_ORDER.join(', ')} or all`)
+  }
+
+  return {
+    command,
+    since,
+    span,
+    project: values.get('--project') ?? '',
+    dir: values.get('--dir') ?? '',
+    tool,
+    format: formats[0] ?? 'text',
+    by,
+    top,
+    html: switches.has('--html') ? (values.get('--html') ?? '') : null,
+    text: switches.has('--text'),
+    open: !switches.has('--no-open'),
+    anon: switches.has('--anon'),
+  }
+}
+
+/** @returns {Options} */
+function defaults() {
+  return {
+    command: 'report',
+    since: 0,
+    span: '',
+    project: '',
+    dir: '',
+    tool: 'all',
+    format: 'text',
+    by: '',
+    top: 10,
+    html: null,
+    text: false,
+    open: true,
+    anon: false,
+  }
+}

package/src/claude.js

@@ -0,0 +1,121 @@
+// @ts-check
+// Reading Claude Code's session files: ~/.claude/projects/<folder>/<session-id>.jsonl, a subagent's in
+// <session-id>/subagents/. Each line is one JSON event; ReRead keeps only the token counts, model, time and id of each
+// reply, plus the folder and git branch of the session. It never keeps or prints what was written in the conversation.
+import { homedir } from 'node:os'
+import path from 'node:path'
+import { eachLine } from './files.js'
+
+/** @typedef {import('./prices.js').Call} Call */
+
+/**
+ * The folders Claude Code may keep sessions in, most specific first.
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {string} [home]
+ */
+export function claudeDirs(env = process.env, home = homedir()) {
+  return [
+    env.CLAUDE_CONFIG_DIR ? path.join(env.CLAUDE_CONFIG_DIR, 'projects') : '',
+    path.join(home, '.claude', 'projects'),
+    path.join(home, '.config', 'claude', 'projects'),
+  ].filter(Boolean)
+}
+
+/**
+ * One line of a session file as a reply, or null when it is not one. Only token counts, the model, the time and
+ * the ids are kept.
+ * @param {string} line
+ * @param {number} since  replies before this time are left out
+ * @returns {Call | null}
+ */
+export function callOf(line, since) {
+  if (!line.includes('"usage"') || !line.includes('"assistant"')) return null
+  let j
+  try {
+    j = JSON.parse(line)
+  } catch {
+    return null
+  }
+  const m = j?.message
+  const u = m?.usage
+  if (j.type !== 'assistant' || !u || typeof u !== 'object' || m.model === '<synthetic>') return null
+  const ts = Date.parse(j.timestamp)
+  if (!(ts >= since)) return null
+  const n = (/** @type {unknown} */ v) => (typeof v === 'number' && v > 0 ? v : 0)
+  // Some replies list 1-hour writes in the breakdown while the total says 0; the breakdown is kept.
+  const cw = n(u.cache_creation_input_tokens)
+  const cw1 = n(u.cache_creation?.ephemeral_1h_input_tokens)
+  return {
+    key: `${m.id}|${j.requestId ?? ''}`,
+    ts,
+    model: typeof m.model === 'string' ? m.model : '',
+    input: n(u.input_tokens),
+    cw5: Math.max(0, cw - cw1),
+    cw1,
+    read: n(u.cache_read_input_tokens),
+    out: n(u.output_tokens),
+  }
+}
+
+/**
+ * Add a reply to a map of replies. Claude Code writes a reply once per content block with the same ids, so each is
+ * kept once, with the largest output count seen.
+ * @param {Map<string, Call>} calls
+ * @param {Call} call
+ */
+export function collect(calls, call) {
+  const old = calls.get(call.key)
+  if (old) old.out = Math.max(old.out, call.out)
+  else calls.set(call.key, call)
+}
+
+const USAGE = Buffer.from('"usage"')
+const CWD = Buffer.from('"cwd"')
+const BRANCH = Buffer.from('"gitBranch"')
+
+/**
+ * Read the replies of one session file. A resumed or forked session copies the replies it carries over into its new
+ * file: those are marked `seen` (walked for the cache, counted once) and every key is added to `seen`.
+ * @param {string} file
+ * @param {number} since
+ * @param {Set<string>} seen  the replies already counted in files read before
+ * @returns {import('./tools.js').Read}
+ */
+export function readClaudeFile(file, since, seen) {
+  /** @type {Map<string, Call>} */
+  const calls = new Map()
+  let cwd = ''
+  let branch = ''
+  /** @param {Buffer} buf */
+  const onLine = (buf) => {
+    if (!cwd && buf.includes(CWD)) {
+      try {
+        const v = JSON.parse(buf.toString('utf8')).cwd
+        if (typeof v === 'string') cwd = v
+      } catch {
+        /* not JSON */
+      }
+    }
+    if (!branch && buf.includes(BRANCH)) {
+      try {
+        const b = JSON.parse(buf.toString('utf8')).gitBranch
+        if (typeof b === 'string' && b && b !== 'HEAD') branch = b
+      } catch {
+        /* not JSON */
+      }
+    }
+    if (!buf.includes(USAGE)) return
+    const call = callOf(buf.toString('utf8'), since)
+    if (call) collect(calls, call)
+  }
+  eachLine(file, onLine)
+  for (const [key, c] of calls) {
+    c.seen = seen.has(key)
+    seen.add(key)
+  }
+  // A subagent's file sits in <session>/subagents/; it counts toward that session.
+  const parts = file.split(path.sep)
+  const sub = parts.length > 2 && parts.at(-2) === 'subagents'
+  const id = sub ? parts[parts.length - 3] : path.basename(file, '.jsonl')
+  return { id, sub, cwd, branch, calls: [...calls.values()].sort((a, b) => a.ts - b.ts) }
+}

package/src/cli.js

@@ -0,0 +1,127 @@
+// @ts-check
+// The command: parse the options, read the sessions, print the chosen output, write the report.
+import { existsSync } from 'node:fs'
+import { analyze, summarize, withPoints } from './analyze.js'
+import { parseArgs, UsageError } from './args.js'
+import { VERSION } from './meta.js'
+import { renderCsv, renderMarkdown, renderText } from './render.js'
+import { buildReport, openFile, readTemplate, TEMPLATE, writeReport } from './report.js'
+import { rootsFor, sessionFiles } from './tools.js'
+import { statusline } from './statusline.js'
+
+export const HELP = `reread ${VERSION}: how much of your coding agent's usage was re-reading context (Claude Code, Codex, Antigravity)
+
+Usage
+  npx reread-cli [options]          summary here, full report in your browser
+  reread statusline                 one line for Claude Code's status line (reads its JSON on stdin)
+
+Range
+  --days <n>         look back this many days (default 30; 0 = every session file still kept)
+  --since <date>     start on this day instead (YYYY-MM-DD, local time)
+  --project <text>   only sessions whose project folder contains this text
+  --tool <name>      claude, codex, antigravity or all (default all: every tool with sessions here)
+  --dir <path>       read the sessions in this folder only
+
+Output
+  --text             the summary only; no browser report
+  --html [file]      write the report (default: a new private folder in your temp directory)
+  --no-open          write the report but do not open it
+  --json             all the numbers as JSON
+  --csv              every session as CSV
+  --md               a Markdown summary, to paste into an issue or a pull request
+  --by <what>        add a breakdown to the summary: project, model, tool or day
+  --top <n>          sessions in the summary (default 10)
+  --anon             replace project names with "project 1", "project 2", ... and leave branches out
+
+  -v, --version      print the version
+  -h, --help         this help
+
+Reads only the token counts in your local session files. Nothing is uploaded.`
+
+/**
+ * @param {string[]} argv
+ * @returns {Promise<number>} the exit status
+ */
+export async function main(argv) {
+  // A closed pipe (reread --json | head) is not an error.
+  process.stdout.on('error', (err) => {
+    if (/** @type {NodeJS.ErrnoException} */ (err).code === 'EPIPE') process.exit(0)
+    throw err
+  })
+  try {
+    return await run(argv)
+  } catch (err) {
+    if (err instanceof UsageError) {
+      process.stderr.write(`reread: ${err.message}\n`)
+      return 1
+    }
+    const e = /** @type {Error} */ (err)
+    process.stderr.write(`reread: ${e.message}\n`)
+    if (process.env.REREAD_DEBUG) process.stderr.write(`${e.stack}\n`)
+    return 1
+  }
+}
+
+/** @param {string[]} argv */
+async function run(argv) {
+  const opts = parseArgs(argv)
+  const print = (/** @type {string} */ s) => process.stdout.write(s)
+
+  if (opts.command === 'help') return (print(`${HELP}\n`), 0)
+  if (opts.command === 'version') return (print(`${VERSION}\n`), 0)
+  if (opts.command === 'statusline') {
+    let input = ''
+    for await (const chunk of process.stdin) input += chunk
+    print(`${statusline(input, { color: !process.env.NO_COLOR })}\n`)
+    return 0
+  }
+
+  const { roots, looked } = rootsFor(opts.tool, opts.dir)
+  if (!roots.length) {
+    throw new UsageError(
+      `no Claude Code, Codex or Antigravity sessions found. Looked in:\n  ${looked.join('\n  ')}\nUse --dir to point at the folder.`,
+    )
+  }
+
+  const files = sessionFiles(roots, opts)
+  const progress = process.stderr.isTTY && opts.format === 'text'
+  const a = analyze(files, {
+    since: opts.since,
+    project: opts.project,
+    onProgress: progress ? (n, total) => process.stderr.write(`\rReading ${n} of ${total} session files…`) : undefined,
+  })
+  if (progress) process.stderr.write('\r\x1b[K')
+  if (a.skipped.length) {
+    const [first] = a.skipped
+    const more = a.skipped.length > 1 ? ` and ${a.skipped.length - 1} more` : ''
+    process.stderr.write(`reread: skipped ${first.file} (${first.error})${more}: could not be read\n`)
+  }
+  if (!a.total.calls) {
+    print(`No replies found in ${roots.join(', ')}${opts.since ? ` for ${opts.span}` : ''}.\n`)
+    return 0
+  }
+
+  const data = summarize(a, { span: opts.span, anon: opts.anon, version: VERSION })
+  if (opts.format === 'json') print(`${JSON.stringify(data, null, 2)}\n`)
+  else if (opts.format === 'csv') print(renderCsv(data))
+  else if (opts.format === 'md') print(renderMarkdown(data, opts))
+  else print(renderText(data, { ...opts, color: !!process.stdout.isTTY && !process.env.NO_COLOR }))
+
+  // The browser report: on by default for the summary at a terminal, or asked for with --html.
+  const auto = opts.format === 'text' && !opts.text && !!process.stdout.isTTY
+  if (opts.html === null && !auto) return 0
+  if (!existsSync(TEMPLATE)) {
+    if (opts.html !== null) throw new Error(`the report template is missing: ${TEMPLATE.pathname}`)
+    return 0
+  }
+  const file = writeReport(buildReport(readTemplate(), withPoints(a, data)), opts.html || undefined)
+  // Next to the summary in the terminal; on stderr when stdout is data.
+  const note = (/** @type {string} */ s) => (opts.format === 'text' ? print(s) : process.stderr.write(s))
+  const dim = (/** @type {string} */ t) => (process.stdout.isTTY && !process.env.NO_COLOR ? `\x1b[2m${t}\x1b[0m` : t)
+  const remote = process.env.SSH_CONNECTION || process.env.CI
+  if (opts.open && !remote) {
+    openFile(file)
+    note(`  ${dim('Full report (opened in your browser):')} ${file}\n\n`)
+  } else note(`  ${dim('Full report:')} ${file}\n\n`)
+  return 0
+}

package/src/codex.js

@@ -0,0 +1,135 @@
+// @ts-check
+// Reading Codex's session files ("rollouts"): ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl, and archived ones in
+// ~/.codex/archived_sessions (zstd-compressed, read where Node.js can decompress zstd). As with Claude Code, only token
+// counts, the model, the time and ids are kept, plus the folder and git branch from the session's header.
+import { readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import path from 'node:path'
+import zlib from 'node:zlib'
+import { eachLine, splitLines } from './files.js'
+
+/** @typedef {import('./prices.js').Call} Call */
+
+/**
+ * The folders Codex keeps sessions in.
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {string} [home]
+ */
+export function codexDirs(env = process.env, home = homedir()) {
+  const base = env.CODEX_HOME || path.join(home, '.codex')
+  return [path.join(base, 'sessions'), path.join(base, 'archived_sessions')]
+}
+
+/** Whether a file is a Codex session file: rollout-<time>-<id>.jsonl, or .jsonl.zst when archived. */
+export function isCodexFile(/** @type {string} */ file) {
+  const name = path.basename(file)
+  return name.startsWith('rollout-') && (name.endsWith('.jsonl') || name.endsWith('.jsonl.zst'))
+}
+
+/** Whether this Node.js can read compressed (archived) Codex sessions. */
+export const canReadZstd = typeof (/** @type {any} */ (zlib).zstdDecompressSync) === 'function'
+
+const MARKS = ['"session_meta"', '"turn_context"', '"token_usage_record"', '"token_count"'].map((m) => Buffer.from(m))
+
+/**
+ * @param {unknown} v
+ * @returns {number}
+ */
+const n = (v) => (typeof v === 'number' && v > 0 ? v : 0)
+
+/**
+ * A usage object into a reply. OpenAI counts cached and cache-written tokens inside input_tokens.
+ * @param {any} u
+ * @param {string} key
+ * @param {number} ts
+ * @param {string} model
+ * @returns {Call}
+ */
+function callFrom(u, key, ts, model) {
+  const read = n(u.cached_input_tokens)
+  const cw = n(u.cache_write_input_tokens)
+  return {
+    key,
+    ts,
+    model,
+    input: Math.max(0, n(u.input_tokens) - read - cw),
+    cw5: cw,
+    cw1: 0,
+    read,
+    out: n(u.output_tokens),
+  }
+}
+
+/**
+ * Read the replies of one Codex session file.
+ *
+ * Newer Codex versions write a `token_usage_record` for each model response, with its id. Older ones write only
+ * `token_count` events, repeated when nothing changed; there each new running total is one response.
+ * @param {string} file
+ * @param {number} since
+ * @param {Set<string>} seen  replies already counted in files read before
+ * @returns {import('./tools.js').Read}
+ */
+export function readCodexFile(file, since, seen) {
+  let id = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i.exec(path.basename(file))?.[1] ?? ''
+  let cwd = ''
+  let branch = ''
+  let model = ''
+  /** @type {Map<string, Call>} */
+  const records = new Map()
+  /** @type {Map<string, Call>} */
+  const counts = new Map()
+  let lastTotal = -1
+
+  /** @param {Buffer} buf */
+  const onLine = (buf) => {
+    if (!MARKS.some((m) => buf.includes(m))) return
+    let j
+    try {
+      j = JSON.parse(buf.toString('utf8'))
+    } catch {
+      return
+    }
+    const p = j?.payload
+    if (!p || typeof p !== 'object') return
+    if (j.type === 'session_meta') {
+      if (typeof p.id === 'string' && p.id) id = p.id
+      if (typeof p.cwd === 'string') cwd = p.cwd
+      if (typeof p.git?.branch === 'string') branch = p.git.branch
+      return
+    }
+    if (j.type === 'turn_context') {
+      if (typeof p.model === 'string' && p.model) model = p.model
+      return
+    }
+    const ts = Date.parse(j.timestamp)
+    if (j.type === 'token_usage_record' && p.usage && typeof p.usage === 'object') {
+      const key = `codex|${p.response_id ?? `${id}|${j.ordinal}`}`
+      if (ts >= since && !records.has(key)) records.set(key, callFrom(p.usage, key, ts, model))
+      return
+    }
+    if (j.type === 'event_msg' && p.type === 'token_count') {
+      const total = p.info?.total_token_usage?.total_tokens
+      const last = p.info?.last_token_usage
+      if (typeof total !== 'number' || total === lastTotal || !last) return
+      lastTotal = total
+      const key = `codex|${id}|${total}`
+      if (ts >= since) counts.set(key, callFrom(last, key, ts, model))
+    }
+  }
+
+  if (file.endsWith('.zst')) {
+    if (!canReadZstd) return { id, sub: false, cwd, branch, calls: [] }
+    const data = /** @type {any} */ (zlib).zstdDecompressSync(readFileSync(file))
+    splitLines(data, onLine)
+  } else {
+    eachLine(file, onLine)
+  }
+
+  const calls = [...(records.size ? records : counts).values()].sort((a, b) => a.ts - b.ts)
+  for (const c of calls) {
+    c.seen = seen.has(c.key)
+    seen.add(c.key)
+  }
+  return { id, sub: false, cwd, branch, calls }
+}

package/src/files.js

@@ -0,0 +1,102 @@
+// @ts-check
+// Walking folders for session files and reading them line by line, for every tool's reader.
+import { closeSync, existsSync, fstatSync, openSync, readdirSync, readSync } from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Every file under a folder that `keep` accepts. Symbolic links are not followed, so a link loop cannot hang the
+ * walk, and a folder that cannot be read is skipped.
+ * @param {string} dir
+ * @param {(file: string) => boolean} keep
+ * @returns {string[]}
+ */
+export function filesUnder(dir, keep) {
+  /** @type {string[]} */
+  const out = []
+  /** @type {import('node:fs').Dirent[]} */
+  let entries
+  try {
+    entries = readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return out
+  }
+  for (const e of entries) {
+    const p = path.join(dir, e.name)
+    if (e.isDirectory()) out.push(...filesUnder(p, keep))
+    else if (e.isFile() && keep(p)) out.push(p)
+  }
+  return out
+}
+
+/** The folders that exist. */
+export const existingDirs = (/** @type {string[]} */ dirs) => dirs.filter((d) => existsSync(d))
+
+const CHUNK = 1 << 20
+const NEWLINE = 10
+
+/**
+ * Read the complete lines of a file from a byte offset, synchronously and in 1 MB chunks. Lines are handed over as
+ * Buffers, so a long line that is not wanted is never turned into a string.
+ * @param {string} file
+ * @param {number} from  the byte offset to start at; must be the start of a line
+ * @param {(line: Buffer) => void} onLine
+ * @returns {{ offset: number, rest: Buffer, size: number }}  offset: where the unfinished last line starts; rest: that line
+ */
+export function readLines(file, from, onLine) {
+  const fd = openSync(file, 'r')
+  try {
+    const size = fstatSync(fd).size
+    /** @type {Buffer[]} */
+    let pieces = []
+    let pending = 0
+    let pos = from
+    while (pos < size) {
+      const chunk = Buffer.allocUnsafe(Math.min(CHUNK, size - pos))
+      const got = readSync(fd, chunk, 0, chunk.length, pos)
+      if (got <= 0) break
+      pos += got
+      const buf = got < chunk.length ? chunk.subarray(0, got) : chunk
+      let start = 0
+      let nl
+      while ((nl = buf.indexOf(NEWLINE, start)) !== -1) {
+        const part = buf.subarray(start, nl)
+        onLine(pieces.length ? Buffer.concat([...pieces, part]) : part)
+        pieces = []
+        pending = 0
+        start = nl + 1
+      }
+      if (start < buf.length) {
+        pieces.push(buf.subarray(start))
+        pending += buf.length - start
+      }
+    }
+    return { offset: pos - pending, rest: Buffer.concat(pieces), size }
+  } finally {
+    closeSync(fd)
+  }
+}
+
+/**
+ * Hand each line of a buffer to onLine, the last one too.
+ * @param {Buffer} buf
+ * @param {(line: Buffer) => void} onLine
+ */
+export function splitLines(buf, onLine) {
+  let start = 0
+  let nl
+  while ((nl = buf.indexOf(NEWLINE, start)) !== -1) {
+    onLine(buf.subarray(start, nl))
+    start = nl + 1
+  }
+  if (start < buf.length) onLine(buf.subarray(start))
+}
+
+/**
+ * Every line of a file, the last one too even with no newline after it.
+ * @param {string} file
+ * @param {(line: Buffer) => void} onLine
+ */
+export function eachLine(file, onLine) {
+  const { rest } = readLines(file, 0, onLine)
+  if (rest.length) onLine(rest)
+}