reread-cli 0.2.0 → 0.2.1

package/README.md

@@ -41,7 +41,7 @@ Every tool with sessions on your machine is read; `--tool claude`, `--tool codex
 - **By context size**: how much of your usage came from replies with a large context (over 150k is where it adds up).
 - **Why the cache was lost**: a break longer than its life (5 minutes or 1 hour), a model switch mid-session, or a
   change near the start of the context (tools, MCP servers, settings).
-- **By project and by model**, and by tool when you use both.
+- **By project and by model**, and by tool when you use more than one.
 - **Sessions**: the 10 costliest, sortable and searchable across all of them, with their git branch. Open one to see
   its context grow reply by reply, with each rebuild and compaction marked.
 - **Share**: copy a line of text, or save an image card with no project names on it. Hide names in the whole report
@@ -76,6 +76,14 @@ Then add it to `~/.claude/settings.json`:
 
 More in [docs/statusline.md](docs/statusline.md).
 
+## In VS Code
+
+The [ReRead extension](vscode/README.md) shows the same countdown in the editor's status bar, for the latest Claude Code
+session in your workspace, whether Claude Code runs in the terminal or in the editor. Click it for the report of that
+workspace, in an editor tab. Install it from the
+[VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=hamperpick.reread), or from
+[Open VSX](https://open-vsx.org/extension/hamperpick/reread) for Cursor, Antigravity and other editors that use it.
+
 ## Options
 
 ```
@@ -132,8 +140,8 @@ A reply counts once, in the session that made it, even when a resumed session co
 toward the session that started it. "Writing history again" is estimated from token counts: a reply whose cache read
 fell below half of the previous reply's context while the context did not shrink.
 
-The details, with every rule and threshold: [docs/how-it-counts.md](docs/how-it-counts.md). Neither tool documents its
-session format, and either may change it; if ReRead reads yours wrong, please
+The details, with every rule and threshold: [docs/how-it-counts.md](docs/how-it-counts.md). None of the tools documents
+its session format, and any may change it; if ReRead reads yours wrong, please
 [open an issue](https://github.com/tecyfyai/reread/issues).
 
 Want to see what caching saves for a prompt of your own? The

package/bin/reread.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// ReRead: how much of your Claude Code usage was re-reading context.
+// ReRead: how much of your coding agent's usage was re-reading context.
 import { main } from '../src/cli.js'
 
 process.exitCode = await main(process.argv.slice(2))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reread-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Token usage and prompt cache analyzer for Claude Code, Codex and Antigravity: how much of your coding agent's usage was re-reading context, and why. Visual report and a cache-countdown status line. Local only; uploads nothing.",
   "type": "module",
   "bin": {

package/src/analyze.js

@@ -2,6 +2,7 @@
 // Counting: what each reply cost, how much of it was re-reading history, and when the whole history had to be
 // written again.
 import path from 'node:path'
+import { isInside } from './files.js'
 import { findingsOf } from './findings.js'
 import { dayOf, pct, round1, round2 } from './format.js'
 import { contextOf, costOf, priceOf } from './prices.js'
@@ -187,10 +188,11 @@ export function walk(calls, onCall = () => {}) {
 /**
  * Read and count session files.
  * @param {string[]} files  in the order sessionFiles() gives
- * @param {{ since: number, project?: string, onProgress?: (done: number, total: number) => void }} opts
+ * @param {{ since: number, project?: string, folders?: string[], onProgress?: (done: number, total: number) => void }} opts
+ *   folders: only sessions that ran in one of these folders or a folder inside one.
  *   A file that cannot be read (removed meanwhile, no permission, a broken archive) is skipped and listed in `skipped`.
  */
-export function analyze(files, { since, project = '', onProgress }) {
+export function analyze(files, { since, project = '', folders = [], onProgress }) {
   const needle = project.toLowerCase()
   /** @type {Set<string>} */
   const seen = new Set()
@@ -235,9 +237,12 @@ export function analyze(files, { since, project = '', onProgress }) {
     }
     const { id, sub, cwd, branch, calls } = read
     if (!calls.some((c) => !c.seen)) return
-    if (!(/** @type {import('./tools.js').ToolInfo} */ (TOOLS[tool]).projectInPath) && needle) {
+    const info = /** @type {import('./tools.js').ToolInfo} */ (TOOLS[tool])
+    if (!info.projectInPath && needle) {
       if (!cwd.toLowerCase().includes(needle)) return
     }
+    // A file with no folder in it (a subagent's) was already chosen by its path, where the path holds the project.
+    if (folders.length && !(cwd ? folders.some((f) => isInside(cwd, f)) : info.projectInPath)) return
     const cur = sessions.get(id) ?? { id, tool, project: '', branch: '', points: [], ...emptyTotals() }
     const s = walk(calls, (c, x) => {
       tally(daily, dayOf(c.ts), x)

package/src/claude.js

@@ -2,12 +2,17 @@
 // 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 { closeSync, openSync, readdirSync, readSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
-import { eachLine } from './files.js'
+import { eachLine, existingDirs, isInside, splitLines } from './files.js'
 
 /** @typedef {import('./prices.js').Call} Call */
 
+const USAGE = Buffer.from('"usage"')
+const CWD = Buffer.from('"cwd"')
+const BRANCH = Buffer.from('"gitBranch"')
+
 /**
  * The folders Claude Code may keep sessions in, most specific first.
  * @param {NodeJS.ProcessEnv} [env]
@@ -21,6 +26,92 @@ export function claudeDirs(env = process.env, home = homedir()) {
   ].filter(Boolean)
 }
 
+/**
+ * The folder name Claude Code gives a project: its path, with every character that is not a letter or digit as '-'.
+ * Different paths can share a name ('a b' and 'a-b'), so a session's own `cwd` is what decides.
+ * @param {string} cwd
+ */
+export const claudeFolderName = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, '-')
+
+/**
+ * The folder a session ran in, from the first line that names it (near the top of the file), or ''.
+ * @param {string} file
+ */
+export function cwdOf(file) {
+  let fd
+  try {
+    fd = openSync(file, 'r')
+    const buf = Buffer.alloc(256 * 1024)
+    const got = readSync(fd, buf, 0, buf.length, 0)
+    let cwd = ''
+    splitLines(buf.subarray(0, got), (line) => {
+      if (cwd || !line.includes(CWD)) return
+      try {
+        const v = JSON.parse(line.toString('utf8')).cwd
+        if (typeof v === 'string') cwd = v
+      } catch {
+        /* not JSON, or cut off at the end of the buffer */
+      }
+    })
+    return cwd
+  } catch {
+    return ''
+  } finally {
+    if (fd !== undefined) closeSync(fd)
+  }
+}
+
+/**
+ * The session file written to last, of the sessions that ran in one of these folders or a folder inside one. Subagent
+ * files are left out: the status of a session is its main file's.
+ * @param {string[]} folders
+ * @param {{ dirs?: string[], cwdCache?: Map<string, string> }} [opts]  cwdCache: file to cwd, kept between calls
+ * @returns {string | null}
+ */
+export function latestClaudeSession(folders, { dirs = claudeDirs(), cwdCache = new Map() } = {}) {
+  const root = existingDirs(dirs)[0]
+  if (!root || !folders.length) return null
+  const names = folders.map(claudeFolderName)
+  let best = null
+  let bestTime = -1
+  let entries
+  try {
+    entries = readdirSync(root, { withFileTypes: true })
+  } catch {
+    return null
+  }
+  for (const d of entries) {
+    if (!d.isDirectory() || !names.some((n) => d.name === n || d.name.startsWith(`${n}-`))) continue
+    const dir = path.join(root, d.name)
+    let files
+    try {
+      files = readdirSync(dir)
+    } catch {
+      continue
+    }
+    for (const name of files) {
+      if (!name.endsWith('.jsonl')) continue
+      const f = path.join(dir, name)
+      let t
+      try {
+        t = statSync(f).mtimeMs
+      } catch {
+        continue
+      }
+      if (t <= bestTime) continue
+      let cwd = cwdCache.get(f)
+      if (cwd === undefined) {
+        cwd = cwdOf(f)
+        if (cwd) cwdCache.set(f, cwd)
+      }
+      if (!cwd || !folders.some((folder) => isInside(cwd, folder))) continue
+      best = f
+      bestTime = t
+    }
+  }
+  return best
+}
+
 /**
  * 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.
@@ -69,10 +160,6 @@ export function collect(calls, call) {
   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`.

package/src/files.js

@@ -28,6 +28,20 @@ export function filesUnder(dir, keep) {
   return out
 }
 
+/**
+ * Whether a path is a folder or inside it. Paths are compared as written, ignoring case on macOS and Windows, whose
+ * disks usually do.
+ * @param {string} p
+ * @param {string} folder
+ */
+export function isInside(p, folder) {
+  const fold = process.platform === 'darwin' || process.platform === 'win32'
+  const a = path.resolve(p)
+  const b = path.resolve(folder)
+  const [x, y] = fold ? [a.toLowerCase(), b.toLowerCase()] : [a, b]
+  return x === y || x.startsWith(y.endsWith(path.sep) ? y : y + path.sep)
+}
+
 /** The folders that exist. */
 export const existingDirs = (/** @type {string[]} */ dirs) => dirs.filter((d) => existsSync(d))
 

package/src/report.html

@@ -1100,7 +1100,15 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
     ctx.fillStyle = '#f0efec'; ctx.fillText(cmd, W - P - cw - 18, H - 72)
     return c
   }
+  // Inside the VS Code extension the page cannot download; it hands the file to the editor, which asks where to save it.
+  const editor = typeof acquireVsCodeApi === 'function' ? acquireVsCodeApi() : null
   function download(name, blob) {
+    if (editor) {
+      const r = new FileReader()
+      r.onload = () => editor.postMessage({ type: 'save', name, data: r.result })
+      r.readAsDataURL(blob)
+      return
+    }
     const url = URL.createObjectURL(blob)
     const a = el('a', { href: url, download: name, style: 'display:none' })
     document.body.append(a); a.click(); a.remove()
@@ -1126,7 +1134,7 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
     $('copy-text').addEventListener('click', async () => say((await copy(shareText())) ? 'Copied.' : 'Could not copy. Select the text above instead.'))
     $('download-image').addEventListener('click', () => {
       const c = drawCard()
-      if (c.toBlob) c.toBlob((b) => { if (b) { download(`reread-${stamp()}.png`, b); say('Image saved.') } }, 'image/png')
+      if (c.toBlob) c.toBlob((b) => { if (b) { download(`reread-${stamp()}.png`, b); if (!editor) say('Image saved.') } }, 'image/png')
     })
   }
 
@@ -1177,6 +1185,7 @@ footer .links { display: flex; flex-wrap: wrap; gap: 8px 20px; margin-bottom: 12
   renderSessions()
   renderFindings()
   renderShare()
+  if (editor) editor.postMessage({ type: 'ready' })
 })()
 </script>
 </body>

package/src/statusline.js

@@ -20,9 +20,9 @@ import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { walk } from './analyze.js'
 import { pct, tokens } from './format.js'
-import { contextOf, priceOf } from './prices.js'
 import { callOf, collect } from './claude.js'
 import { readLines } from './files.js'
+import { contextOf, priceOf } from './prices.js'
 
 /** @typedef {import('./prices.js').Call} Call */
 
@@ -45,25 +45,48 @@ export function statusline(input, { now = Date.now(), color = false, cacheDir =
   }
   if (!file || !existsSync(file)) return 'reread: no session yet'
 
-  const calls = readCalls(file, cacheDir)
-  const s = walk([...calls.values()].sort((a, b) => a.ts - b.ts))
-  if (!s.lastCall) return 'reread: no replies 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 left = s.ttl - (now - s.lastCall.ts)
   const p = priceOf(s.lastCall.model, ctx)
-  const parts = [`ctx ${tokens(ctx)}`]
-  if (left > 0) {
-    const m = Math.floor(left / 60e3)
-    const sec = Math.floor((left % 60e3) / 1e3)
-    parts.push(paint(left < 60e3 ? 33 : 32)(`cache warm ${m}:${String(sec).padStart(2, '0')}`))
-  } else {
-    const rewrite = (ctx * (s.ttl > 300e3 ? p.write1h : p.write5m)) / 1e6
-    parts.push(paint(31)(`cache cold: next reply rewrites ${tokens(ctx)} (~$${rewrite.toFixed(2)})`))
+  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,
   }
-  parts.push(`re-read ${pct(s.readCost + s.rebuildCost, s.cost).toFixed(0)}%`)
-  return parts.join(' · ')
 }
 
 /**
@@ -107,7 +130,7 @@ function readCalls(file, cacheDir) {
  * A per-user folder for the cache, or null when one cannot be made safely.
  * @returns {string | null}
  */
-function defaultCacheDir() {
+export function defaultCacheDir() {
   const uid = typeof process.getuid === 'function' ? process.getuid() : null
   const dir = path.join(tmpdir(), `reread-${uid ?? 'user'}`)
   try {

package/src/tools.js

@@ -4,7 +4,7 @@
 import { statSync } from 'node:fs'
 import path from 'node:path'
 import { antigravityDirs, isAntigravityFile, isAntigravityOther, readAntigravityFile } from './antigravity.js'
-import { claudeDirs, readClaudeFile } from './claude.js'
+import { claudeDirs, claudeFolderName, readClaudeFile } from './claude.js'
 import { codexDirs, isCodexFile, readCodexFile } from './codex.js'
 import { existingDirs, filesUnder } from './files.js'
 
@@ -28,6 +28,7 @@ import { existingDirs, filesUnder } from './files.js'
  * @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. */
@@ -55,6 +56,7 @@ export const TOOLS = /** @type {const} */ ({
     owns: (/** @type {string} */ f) => f.endsWith('.jsonl'),
     read: readClaudeFile,
     projectInPath: true,
+    folderName: claudeFolderName,
   },
 })
 /** @typedef {keyof typeof TOOLS} Tool */
@@ -101,12 +103,19 @@ export function rootsFor(tool, dir) {
 /**
  * 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`
- * filters paths here; the other tools name the folder inside, so analyze() filters those.
+ * 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 }} filter
+ * @param {{ since: number, project: string, tool: 'all' | Tool, folders?: string[] }} filter
  */
-export function sessionFiles(roots, { since, project, tool }) {
+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) {
@@ -114,6 +123,7 @@ export function sessionFiles(roots, { since, project, tool }) {
       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)