@drakulavich/zapara 0.7.1 → 0.7.2

package/CHANGELOG.md

@@ -5,6 +5,19 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.7.2] - 2026-09-26
+
+### Changed
+- Transcripts are read sixteen at a time instead of one by one. On a machine
+  with 1.6 GB of transcripts in a 14-day window, reading took 0.9 s instead
+  of 5.4 s.
+- Transcript lines older than the window's three-hour look-back are skipped
+  before parsing, except assistant replies, whose request ids dedupe output
+  tokens. A long session's file holds its whole history, and on one machine
+  59% of what a 14-day window read was such history. Results are unchanged.
+  Together with parallel reads, `zapara card --json` there went from 5.6 s to
+  about 2 s.
+
 ## [0.7.1] - 2026-09-25
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakulavich/zapara",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Cognitive load index for people driving Claude Code, computed locally from transcripts",
   "license": "MIT",
   "author": "Anton Yakutovich",

package/src/analyze.ts

@@ -1,11 +1,12 @@
-import { compareStrings, derive } from "./derive.ts";
+import { compareStrings, derive, windowBounds } from "./derive.ts";
 import { parseTranscript } from "./parse.ts";
 import type { Day, Transcript, Window } from "./types.ts";
 
 // Sorted by path so file discovery order cannot change a result.
 export function analyze(transcripts: Transcript[], w: Window): Day[] {
+  const { cutoffMs } = windowBounds(w);
   const events = [...transcripts]
     .sort((a, b) => compareStrings(a.path, b.path))
-    .flatMap((t) => parseTranscript(t.text));
+    .flatMap((t) => parseTranscript(t.text, cutoffMs));
   return derive(events, w);
 }

package/src/parse.ts

@@ -28,7 +28,26 @@ const firstText = (content: unknown): string | null => {
   return null;
 };
 
-export function parseTranscript(text: string): Event[] {
+// A record older than the look-back yields only events derive() drops, so it is
+// not parsed at all. Every "timestamp" in the line must be old, since a nested
+// one can differ from the record's own. The skip waits for a first timestamped
+// record, which the mode switches before it attach to; lines naming the two
+// tools whose result the human writes are always parsed, for their ids.
+// One pass over the line: it costs a fifth of JSON.parse.
+const SKIP_SCAN = new RegExp(`"timestamp":"([^"]{20,40})"|${QUESTION_TOOL}|${PLAN_TOOL}`, "g");
+function olderThan(line: string, cutoffMs: number): boolean {
+  // Parsing an assistant record can update seenRequestIds even when its events
+  // are outside the window. Preserve that deduplication state across the skip.
+  if (line.includes('"requestId"')) return false;
+  let any = false;
+  for (const m of line.matchAll(SKIP_SCAN)) {
+    if (m[1] === undefined || !(Date.parse(m[1]) < cutoffMs)) return false;
+    any = true;
+  }
+  return any;
+}
+
+export function parseTranscript(text: string, cutoffMs = -Infinity): Event[] {
   const events: Event[] = [];
   let lastTs: number | null = null;
   let lastMode: string | null = null;
@@ -42,6 +61,7 @@ export function parseTranscript(text: string): Event[] {
 
   for (const line of text.split("\n")) {
     if (line.trim() === "") continue;
+    if (lastTs !== null && lastTs < cutoffMs && olderThan(line, cutoffMs)) continue;
     let rec: unknown;
     try { rec = JSON.parse(line); } catch { continue; }
     if (!isObj(rec)) continue;

package/src/report.ts

@@ -6,12 +6,23 @@ import type { Day, Transcript } from "./types.ts";
 
 export type ReportOptions = { projects: string; to: string; days: number; now?: Date };
 
+// Reading one file at a time left the disk idle between files: 1.6 GB took 5.4 s
+// sequentially and 0.9 s in parallel. The cap keeps open files well under the limit.
+const READERS = 16;
+
 export async function report(o: ReportOptions): Promise<Day[]> {
   const window = { to: o.to, days: o.days, now: o.now };
   const paths = await scan(o.projects, windowBounds(window).cutoffMs);
+  const texts: (string | null)[] = new Array(paths.length).fill(null);
+  let next = 0;
+  const reader = async (): Promise<void> => {
+    while (next < paths.length) {
+      const i = next++;
+      try { texts[i] = await readFile(paths[i]!, "utf8"); } catch { /* vanished or unreadable: skip */ }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(READERS, paths.length) }, reader));
   const transcripts: Transcript[] = [];
-  for (const path of paths) {
-    try { transcripts.push({ path, text: await readFile(path, "utf8") }); } catch { /* vanished or unreadable: skip */ }
-  }
+  paths.forEach((path, i) => { if (texts[i] !== null) transcripts.push({ path, text: texts[i]! }); });
   return analyze(transcripts, window);
 }