reread-cli 0.0.0-stage → 0.2.1

package/src/report.js

@@ -0,0 +1,69 @@
+// @ts-check
+// The browser report: one self-contained HTML file. The page's own script reads the numbers from a JSON block.
+import { spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+export const TEMPLATE = new URL('./report.html', import.meta.url)
+const PLACEHOLDER = '__REREAD_DATA__'
+
+/**
+ * Put the data into the report page.
+ *
+ * The data goes into a `<script type="application/json">` block, with `<`, U+2028 and U+2029 escaped so no string in
+ * it can end that block. The page's security policy allows only its own script, by hash, so even a name that got
+ * past the escaping could not run as code.
+ * @param {string} template  the contents of report.html
+ * @param {unknown} data
+ */
+export function buildReport(template, data) {
+  if (!template.includes(PLACEHOLDER)) throw new Error(`the report template has no ${PLACEHOLDER} placeholder`)
+  const script = /<script>([\s\S]*?)<\/script>/.exec(template)
+  if (!script) throw new Error('the report template has no inline script')
+  const hash = createHash('sha256').update(script[1], 'utf8').digest('base64')
+  const csp = "script-src 'unsafe-inline'"
+  if (!template.includes(csp)) throw new Error(`the report template's security policy has no ${csp}`)
+  const json = JSON.stringify(data).replace(
+    /[<\u2028\u2029]/g,
+    (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, '0')}`,
+  )
+  return template.replace(csp, () => `script-src 'sha256-${hash}'`).replace(PLACEHOLDER, () => json)
+}
+
+/**
+ * Write the report. With no file, it goes in a new folder in the temp directory that only this user can read, so
+ * no other user can read it or put a file in its place.
+ * @param {string} html
+ * @param {string} [file]
+ * @returns {string} the path written
+ */
+export function writeReport(html, file) {
+  const target = file ? path.resolve(file) : path.join(mkdtempSync(path.join(tmpdir(), 'reread-')), 'report.html')
+  writeFileSync(target, html, { mode: 0o600 })
+  return target
+}
+
+/** The report template shipped with ReRead. */
+export const readTemplate = () => readFileSync(TEMPLATE, 'utf8')
+
+/**
+ * Open a file in the default browser. No shell is involved, so no character in the path is read as a command.
+ * @param {string} file
+ */
+export function openFile(file) {
+  const [cmd, args] =
+    process.platform === 'darwin'
+      ? ['open', [file]]
+      : process.platform === 'win32'
+        ? ['explorer.exe', [file]]
+        : ['xdg-open', [file]]
+  try {
+    spawn(cmd, args, { stdio: 'ignore', detached: true, shell: false })
+      .on('error', () => {})
+      .unref()
+  } catch {
+    /* no opener on this system; the path is printed anyway */
+  }
+}

package/src/statusline.js

@@ -0,0 +1,188 @@
+// @ts-check
+// `reread statusline`: one line for Claude Code's status line. Claude Code runs the command on each redraw and
+// pipes it a JSON object with `transcript_path`, the current session's file.
+//
+// A session file can grow to hundreds of megabytes, so the replies read so far are kept in a small cache file
+// (token counts only) and each run reads only the bytes added since the last one.
+import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { walk } from './analyze.js'
+import { pct, tokens } from './format.js'
+import { callOf, collect } from './claude.js'
+import { readLines } from './files.js'
+import { contextOf, priceOf } from './prices.js'
+
+/** @typedef {import('./prices.js').Call} Call */
+
+const CACHE_VERSION = 1
+const CACHE_MAX_AGE = 2 * 86400e3
+const USAGE = Buffer.from('"usage"')
+
+/**
+ * The status line for a session file.
+ * @param {string} input  what Claude Code piped in
+ * @param {{ now?: number, color?: boolean, cacheDir?: string | null }} [opts]  cacheDir null: no cache
+ */
+export function statusline(input, { now = Date.now(), color = false, cacheDir = defaultCacheDir() } = {}) {
+  let file = ''
+  try {
+    const v = JSON.parse(input || '{}').transcript_path
+    if (typeof v === 'string') file = v
+  } catch {
+    /* not JSON */
+  }
+  if (!file || !existsSync(file)) return 'reread: no session yet'
+
+  const s = sessionState(file, { cacheDir })
+  if (!s) return 'reread: no replies yet'
+
+  const paint = (/** @type {number} */ code) => (/** @type {string} */ t) => (color ? `\x1b[${code}m${t}\x1b[0m` : t)
+  const left = s.warmUntil - now
+  const parts = [`ctx ${tokens(s.ctx)}`]
+  if (left > 0) parts.push(paint(left < 60e3 ? 33 : 32)(`cache warm ${clock(left)}`))
+  else parts.push(paint(31)(`cache cold: next reply rewrites ${tokens(s.ctx)} (~$${s.rewriteUsd.toFixed(2)})`))
+  parts.push(`re-read ${s.rereadPct.toFixed(0)}%`)
+  return parts.join(' · ')
+}
+
+/**
+ * Minutes and seconds, as 3:41.
+ * @param {number} ms
+ */
+export const clock = (ms) => `${Math.floor(ms / 60e3)}:${String(Math.floor((ms % 60e3) / 1e3)).padStart(2, '0')}`
+
+/**
+ * Where a session stands: the context its last reply sent, until when the cache stays warm, what writing the context
+ * to the cache again would cost, and how much of the session so far was re-reading. Null before the first reply.
+ * @param {string} file
+ * @param {{ cacheDir?: string | null }} [opts]  cacheDir null: no cache
+ */
+export function sessionState(file, { cacheDir = defaultCacheDir() } = {}) {
+  const calls = readCalls(file, cacheDir)
+  const s = walk([...calls.values()].sort((a, b) => a.ts - b.ts))
+  if (!s.lastCall) return null
+  const ctx = contextOf(s.lastCall)
+  const p = priceOf(s.lastCall.model, ctx)
+  return {
+    model: s.lastCall.model,
+    ctx,
+    lastReply: s.lastCall.ts,
+    /** the cache's life: 5 minutes, or 1 hour once the session has written to the 1-hour cache */
+    ttl: s.ttl,
+    warmUntil: s.lastCall.ts + s.ttl,
+    rewriteUsd: (ctx * (s.ttl > 300e3 ? p.write1h : p.write5m)) / 1e6,
+    rereadPct: pct(s.readCost + s.rebuildCost, s.cost),
+    usd: s.cost,
+    replies: calls.size,
+  }
+}
+
+/**
+ * Every reply in a session file, reading only what was added since the cached state.
+ * @param {string} file
+ * @param {string | null} cacheDir
+ * @returns {Map<string, Call>}
+ */
+function readCalls(file, cacheDir) {
+  const st = statSync(file)
+  const cacheFile = cacheDir
+    ? path.join(cacheDir, `${createHash('sha256').update(file).digest('hex').slice(0, 24)}.json`)
+    : ''
+  /** @type {Map<string, Call>} */
+  const calls = new Map()
+  let from = 0
+
+  const cached = cacheFile ? loadCache(cacheFile) : null
+  if (cached && cached.file === file && cached.ino === st.ino && cached.offset <= st.size) {
+    for (const c of cached.calls) calls.set(c.key, c)
+    from = cached.offset
+  }
+
+  /** @param {Buffer} buf */
+  const onLine = (buf) => {
+    if (!buf.includes(USAGE)) return
+    const c = callOf(buf.toString('utf8'), 0)
+    if (c) collect(calls, c)
+  }
+  const { offset, rest } = readLines(file, from, onLine)
+
+  if (cacheFile && (offset !== from || !cached)) {
+    saveCache(cacheFile, { v: CACHE_VERSION, file, ino: st.ino, offset, calls: [...calls.values()] })
+  }
+  // A last line still being written is counted now but read again next time.
+  if (rest.length) onLine(rest)
+  return calls
+}
+
+/**
+ * A per-user folder for the cache, or null when one cannot be made safely.
+ * @returns {string | null}
+ */
+export function defaultCacheDir() {
+  const uid = typeof process.getuid === 'function' ? process.getuid() : null
+  const dir = path.join(tmpdir(), `reread-${uid ?? 'user'}`)
+  try {
+    mkdirSync(dir, { recursive: true, mode: 0o700 })
+    const st = lstatSync(dir)
+    // Someone else's folder, or a link to one, is never used.
+    if (!st.isDirectory() || st.isSymbolicLink() || (uid !== null && st.uid !== uid)) return null
+    return dir
+  } catch {
+    return null
+  }
+}
+
+/**
+ * @param {string} file
+ * @returns {{ v: number, file: string, ino: number, offset: number, calls: Call[] } | null}
+ */
+function loadCache(file) {
+  try {
+    const c = JSON.parse(readFileSync(file, 'utf8'))
+    return c && c.v === CACHE_VERSION && Array.isArray(c.calls) && Number.isInteger(c.offset) ? c : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Write the cache through a temp file and a rename, so a reader never sees half a file. Old caches are removed now
+ * and then.
+ * @param {string} file
+ * @param {object} value
+ */
+function saveCache(file, value) {
+  try {
+    const tmp = `${file}.${process.pid}.tmp`
+    writeFileSync(tmp, JSON.stringify(value), { mode: 0o600 })
+    renameSync(tmp, file)
+    if (Math.random() < 0.05) prune(path.dirname(file))
+  } catch {
+    /* the cache only saves time; the line is right without it */
+  }
+}
+
+/** @param {string} dir */
+function prune(dir) {
+  const cutoff = Date.now() - CACHE_MAX_AGE
+  for (const name of readdirSync(dir)) {
+    const f = path.join(dir, name)
+    try {
+      if (statSync(f).mtimeMs < cutoff) unlinkSync(f)
+    } catch {
+      /* gone already */
+    }
+  }
+}

package/src/tools.js

@@ -0,0 +1,137 @@
+// @ts-check
+// The coding agents ReRead reads. Each is one entry here plus a reader in its own file; adding a tool is a new entry and
+// a new reader, and every option, folder list, breakdown and piece of advice picks it up from this list.
+import { statSync } from 'node:fs'
+import path from 'node:path'
+import { antigravityDirs, isAntigravityFile, isAntigravityOther, readAntigravityFile } from './antigravity.js'
+import { claudeDirs, claudeFolderName, readClaudeFile } from './claude.js'
+import { codexDirs, isCodexFile, readCodexFile } from './codex.js'
+import { existingDirs, filesUnder } from './files.js'
+
+/**
+ * What a reader gives for one session file.
+ * @typedef {object} Read
+ * @property {string} id      the session it belongs to
+ * @property {boolean} sub    a subagent's file, counted toward its session but not drawn in its chart
+ * @property {string} cwd     the folder it ran in, or ''
+ * @property {string} branch  its git branch, or ''
+ * @property {import('./prices.js').Call[]} calls  its replies, oldest first
+ */
+
+/**
+ * @typedef {object} ToolInfo
+ * @property {string} name   for people
+ * @property {string} fresh  how to start fresh in it, for the compaction advice
+ * @property {() => string[]} dirs  where it keeps sessions
+ * @property {boolean} [firstDirOnly]  the folders are alternatives: read the first that exists
+ * @property {(file: string) => boolean} owns  whether a file is one of its sessions
+ * @property {(file: string) => boolean} [ignores]  a file in its folders that is not a session
+ * @property {(file: string, since: number, seen: Set<string>) => Read} read
+ * @property {boolean} [projectInPath]  its folder names hold the project, so --project filters paths
+ * @property {(cwd: string) => string} [folderName]  the name of the folder it keeps a project's sessions in
+ */
+
+/** In the order a file is matched: the more specific names first, Claude Code's plain .jsonl last. */
+export const TOOLS = /** @type {const} */ ({
+  codex: {
+    name: 'Codex',
+    fresh: '/new in Codex',
+    dirs: () => codexDirs(),
+    owns: isCodexFile,
+    read: readCodexFile,
+  },
+  antigravity: {
+    name: 'Antigravity',
+    fresh: 'a new conversation in Antigravity',
+    dirs: () => antigravityDirs(),
+    owns: isAntigravityFile,
+    ignores: isAntigravityOther,
+    read: readAntigravityFile,
+  },
+  claude: {
+    name: 'Claude Code',
+    fresh: '/clear in Claude Code',
+    dirs: () => claudeDirs(),
+    firstDirOnly: true,
+    owns: (/** @type {string} */ f) => f.endsWith('.jsonl'),
+    read: readClaudeFile,
+    projectInPath: true,
+    folderName: claudeFolderName,
+  },
+})
+/** @typedef {keyof typeof TOOLS} Tool */
+
+/** @type {Tool[]} */
+export const TOOL_IDS = /** @type {Tool[]} */ (Object.keys(TOOLS))
+
+/** @type {Record<Tool, ToolInfo>} */
+const INFO = TOOLS
+
+/** In the order people see them. */
+export const DISPLAY_ORDER = /** @type {Tool[]} */ (['claude', 'codex', 'antigravity'])
+
+/**
+ * Which tool wrote a session file, or null for a file that is not a session.
+ * @param {string} file
+ * @returns {Tool | null}
+ */
+export function toolOf(file) {
+  for (const id of TOOL_IDS) {
+    if (INFO[id].owns(file)) return id
+    if (INFO[id].ignores?.(file)) return null
+  }
+  return null
+}
+
+/**
+ * The session folders to read for the chosen tool, or the one folder given with --dir.
+ * @param {'all' | Tool} tool
+ * @param {string} [dir]
+ * @returns {{ roots: string[], looked: string[] }}
+ */
+export function rootsFor(tool, dir) {
+  if (dir) return { roots: existingDirs([dir]), looked: [dir] }
+  const ids = tool === 'all' ? TOOL_IDS : [tool]
+  const looked = ids.flatMap((id) => INFO[id].dirs())
+  const roots = ids.flatMap((id) => {
+    const found = existingDirs(INFO[id].dirs())
+    return INFO[id].firstDirOnly ? found.slice(0, 1) : found
+  })
+  return { roots, looked }
+}
+
+/**
+ * The session files to read: changed at or after `since`, of the chosen tool, oldest first, so a reply copied into a
+ * resumed session is counted in the session that made it. Where a tool's folder names hold the project, `project`
+ * and `folders` filter paths here; the other tools name the folder inside, so analyze() filters those.
+ * @param {string[]} roots
+ * @param {{ since: number, project: string, tool: 'all' | Tool, folders?: string[] }} filter
+ */
+export function sessionFiles(roots, { since, project, tool, folders = [] }) {
+  const needle = project.toLowerCase()
+  /** @param {Tool} t @param {string} root @param {string} f */
+  const inFolders = (t, root, f) => {
+    const name = INFO[t].folderName
+    if (!folders.length || !name) return true
+    const top = path.relative(root, f).split(path.sep)[0]
+    return folders.some((d) => top === name(d) || top.startsWith(`${name(d)}-`))
+  }
+  /** @type {[string, number, number][]} */
+  const found = []
+  for (const root of roots) {
+    for (const f of filesUnder(root, (p) => toolOf(p) !== null)) {
+      const t = /** @type {Tool} */ (toolOf(f))
+      if (tool !== 'all' && t !== tool) continue
+      if (needle && INFO[t].projectInPath && !path.relative(root, f).toLowerCase().includes(needle)) continue
+      if (!inFolders(t, root, f)) continue
+      let st
+      try {
+        st = statSync(f)
+      } catch {
+        continue // gone since the walk
+      }
+      if (st.mtimeMs >= since) found.push([f, st.birthtimeMs, st.mtimeMs])
+    }
+  }
+  return found.sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0])).map(([f]) => f)
+}