npm - session-steward - Versions diffs - 0.4.0 → 0.5.1 - Mend

session-steward 0.4.0 → 0.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/CHANGELOG.md +31 -0
package/README.md +13 -0
package/bin/session-steward-cli.mjs +14 -0
package/dist/assets/index-B8U6eLCA.css +2 -0
package/dist/assets/index-JaDHeyls.js +9 -0
package/dist/index.html +2 -2
package/lib/cli.mjs +134 -2
package/lib/providers/claude-code/events.mjs +498 -0
package/lib/providers/claude-code/index.mjs +2 -0
package/lib/providers/claude-code/store.mjs +6 -1
package/lib/providers/codex/database-families.mjs +2 -2
package/lib/providers/codex/events.mjs +779 -0
package/lib/providers/codex/index.mjs +2 -0
package/lib/providers/codex/store.mjs +82 -4
package/lib/server.mjs +62 -1
package/lib/session-event-reader.mjs +126 -0
package/lib/session-events.mjs +307 -0
package/lib/storage/jsonl.mjs +148 -0
package/package.json +6 -2
package/dist/assets/index-BQ6SUqXr.css +0 -2
package/dist/assets/index-QhQbSn0H.js +0 -9

package/dist/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <meta name="viewport" content="width=device-width,initial-scale=1.0"/>
     <link href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='8' fill='%23171717'/%3E%3Cpath d='M16 4 26 8v7c0 6-4 11-10 13C10 26 6 21 6 15V8Z' fill='%23f5f5f5'/%3E%3Cpath d='m9.5 16 2.2-2.2 3 3 6.5-6.5 2.2 2.2-8.7 8.7Z' fill='%23171717'/%3E%3C/svg%3E" rel="icon"/>
     <title>Session Steward</title>
-    <script type="module" crossorigin src="/assets/index-QhQbSn0H.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BQ6SUqXr.css">
+    <script type="module" crossorigin src="/assets/index-JaDHeyls.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-B8U6eLCA.css">
   </head>
   <body>
     <div id="root"></div>

package/lib/cli.mjs CHANGED Viewed

@@ -1,9 +1,18 @@
 import { once } from "node:events";
 import path from "node:path";
 import readline from "node:readline/promises";
-import process, { stdin as input, stdout as output } from "node:process";
+import process, {
+  stderr as errorOutput,
+  stdin as input,
+  stdout as output,
+} from "node:process";
 import { getProvider } from "./providers/index.mjs";
+import {
+  SESSION_EVENT_KIND,
+  SESSION_EVENT_REASON,
+  sessionEventCoveragePercent,
+} from "./session-events.mjs";
 function providerOptions(providerId, home) {
   return providerId === "codex" ? { codexHome: home } : { claudeHome: home };
@@ -67,6 +76,8 @@ Options
   --archive-status <status>      Show all, active, or archived sessions
   --sort <updated|created|name|cwd|size>
                                  Choose the session order
+  --events                       Include the distilled session timeline
+  --events-limit <number>        Limit timeline events (default 100)
   --limit <number>               Limit JSON results
   -h, --help                     Show this help
 `.trim();
@@ -331,6 +342,103 @@ function printInspect(record, deletionPlan) {
   output.write(`Delete log rows: ${deletionPlan.logRowCount}\n`);
 }
+function eventTime(atMs) {
+  if (!Number.isFinite(atMs)) return "--:--";
+  return new Date(atMs).toLocaleTimeString([], {
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+  });
+}
+function eventText(value) {
+  return typeof value === "string" ? value.replace(/\s+/gu, " ").trim() : "";
+}
+function planSummary(steps) {
+  const counts = new Map();
+  for (const step of steps) {
+    const status = step.status.replaceAll("_", " ");
+    counts.set(status, (counts.get(status) ?? 0) + 1);
+  }
+  return [...counts]
+    .map(([status, count]) => `${count} ${status}`)
+    .join(" · ") || "No steps recorded";
+}
+function sessionEventDescription(event) {
+  if (event.kind === SESSION_EVENT_KIND.ASK) {
+    return `${event.injected ? "[injected context] " : ""}${eventText(event.text)}`;
+  }
+  if (event.kind === SESSION_EVENT_KIND.SAID || event.kind === SESSION_EVENT_KIND.SUMMARY) {
+    return eventText(event.text);
+  }
+  if (event.kind === SESSION_EVENT_KIND.EDIT) {
+    const files = event.files.length > 0 ? event.files.join(", ") : "File not recorded";
+    const changes = Number.isInteger(event.added) && Number.isInteger(event.removed)
+      ? `  +${event.added}/-${event.removed}`
+      : "";
+    const outcome = event.applied === true
+      ? "  applied"
+      : event.applied === false
+        ? "  NOT APPLIED"
+        : "";
+    return `${files}${changes}${outcome}`;
+  }
+  if (event.kind === SESSION_EVENT_KIND.RAN) {
+    const command = eventText(event.command) || "Command not recorded";
+    const outcome = event.failed === true ? "  FAILED" : "";
+    const error = event.failed === true && event.error ? `  ${eventText(event.error)}` : "";
+    return `${command}${outcome}${error}`;
+  }
+  if (event.kind === SESSION_EVENT_KIND.DECIDED) {
+    const answer = event.answer ? ` → ${eventText(event.answer)}` : "";
+    return `${eventText(event.question)}${answer}`;
+  }
+  if (event.kind === SESSION_EVENT_KIND.PLAN) return planSummary(event.steps);
+  return "Event details unavailable";
+}
+function sessionEventReason(reason) {
+  return {
+    [SESSION_EVENT_REASON.NO_RECOGNIZED_EVENTS]: "No recognized session events were found.",
+    [SESSION_EVENT_REASON.NO_TRANSCRIPT_PATH]: "No transcript path was recorded for this session.",
+    [SESSION_EVENT_REASON.TRANSCRIPT_MISSING]: "The transcript file is missing.",
+  }[reason] ?? null;
+}
+function printSessionEventCoverage(coverage) {
+  const details = [
+    `recognized ${sessionEventCoveragePercent(coverage)}%`,
+    `${coverage.skipped} skipped`,
+  ];
+  if (coverage.unmapped > 0) details.push(`${coverage.unmapped} unmapped`);
+  if (coverage.unparseable > 0) details.push(`${coverage.unparseable} unparseable`);
+  if (coverage.oversized > 0) details.push(`${coverage.oversized} oversized`);
+  errorOutput.write(`${details.join(" · ")}\n`);
+  if (coverage.unmappedTypes.length > 0) {
+    errorOutput.write(`unmapped types: ${coverage.unmappedTypes.map(({ count, type }) => `${type} (${count})`).join(", ")}\n`);
+  }
+}
+function printSessionEvents(result) {
+  output.write("\nSession timeline\n");
+  output.write("----------------\n");
+  const reason = sessionEventReason(result.reason);
+  if (reason) {
+    output.write(`${reason}\n`);
+  } else {
+    const width = output.isTTY && Number.isInteger(output.columns) ? output.columns : 120;
+    for (const event of [...result.events].reverse()) {
+      const kind = event.kind.toUpperCase().padEnd(8, " ");
+      output.write(`${truncate(`${eventTime(event.atMs)}  ${kind} ${sessionEventDescription(event)}`, width)}\n`);
+    }
+  }
+  printSessionEventCoverage(result.coverage);
+}
 function printDeletionPreview(plan, preflight, scope) {
   const fileCount = preflight.transcriptFileCount ?? plan.transcriptFileCount;
   const sessionBytes = preflight.transcriptBytes ?? plan.transcriptBytes;
@@ -537,7 +645,21 @@ async function printJson(options) {
     for (const record of result.records) {
       if (written >= limit) break;
-      await writeChunk(`${first ? "" : ",\n"}${JSON.stringify(options.provider.formatSessionForJson(record), null, 2)}`);
+      let serializedRecord = options.provider.formatSessionForJson(record);
+      if (options.events) {
+        const eventResult = await options.provider.readSessionEvents({
+          ...providerOptions(options.provider.id, options.providerHome),
+          id: record.id,
+          limit: options.eventsLimit,
+        });
+        serializedRecord = {
+          ...serializedRecord,
+          coverage: eventResult.coverage,
+          events: eventResult.events,
+          header: eventResult.header,
+        };
+      }
+      await writeChunk(`${first ? "" : ",\n"}${JSON.stringify(serializedRecord, null, 2)}`);
       first = false;
       written += 1;
     }
@@ -797,6 +919,14 @@ async function runInteractive(state) {
           });
           printInspect(record, deletionPlan);
+          if (state.showEvents) {
+            const eventResult = await state.provider.readSessionEvents({
+              ...providerOptions(state.provider.id, state.providerHome),
+              id: record.id,
+              limit: state.eventsLimit,
+            });
+            printSessionEvents(eventResult);
+          }
         } catch (error) {
           output.write(`\n${error instanceof Error ? error.message : String(error)}\n`);
         }
@@ -970,6 +1100,7 @@ export async function runCli(options) {
   const state = {
     archiveStatus: validateArchiveStatus(options.archiveStatus),
     cleanupMode: validateCleanupMode(options.cleanup),
+    eventsLimit: options.eventsLimit,
     provider,
     providerHome,
     inactiveDays: validateInactiveDays(options.inactiveDays),
@@ -978,6 +1109,7 @@ export async function runCli(options) {
     result: null,
     search: options.search || "",
     showInternals: Boolean(options.includeInternals),
+    showEvents: Boolean(options.events),
     showSupporting: Boolean(options.includeSupporting),
     sort: validateSort(options.sort || "updated"),
     workspace: options.workspace,

package/lib/providers/claude-code/events.mjs ADDED Viewed

@@ -0,0 +1,498 @@
+import {
+  createSessionEvent,
+  createSessionEventCoverage,
+  createSessionEventHeader,
+  createSessionEventsResult,
+  SESSION_EVENT_KIND,
+  SESSION_EVENT_REASON,
+} from "../../session-events.mjs";
+import {
+  createSessionEventReadState,
+  createUnmappedSessionEventTracker,
+  isInjectedSessionAsk,
+} from "../../session-event-reader.mjs";
+import { visitJsonlSnapshotEntries } from "../../storage/jsonl.mjs";
+import { getSessionRecord } from "./store.mjs";
+const MAX_PENDING_DECISIONS = 2_048;
+const PROVIDER_ID = "claude-code";
+const READ_ONLY_TOOLS = new Set(["Glob", "Grep", "Read", "WebFetch", "WebSearch"]);
+const RECORD_CLASSIFICATION = Object.freeze({
+  RECOGNIZED: "recognized",
+  SKIPPED: "skipped",
+  UNMAPPED: "unmapped",
+  UNPARSEABLE: "unparseable",
+});
+const SKIPPED_CONTENT_TYPES = new Set(["attachment", "image", "thinking"]);
+const SKIPPED_RECORD_TYPES = new Set([
+  "attachment",
+  "custom-title",
+  "file-history-snapshot",
+  "frame-link",
+  "last-prompt",
+  "mode",
+  "queue-operation",
+  "summary",
+  "system",
+]);
+function asTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string") return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+function contentText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value
+      .map((part) => contentText(part))
+      .filter((part) => part !== "")
+      .join("\n");
+  }
+  if (!value || typeof value !== "object") return "";
+  if (typeof value.text === "string") return value.text;
+  if (typeof value.content === "string" || Array.isArray(value.content)) {
+    return contentText(value.content);
+  }
+  return "";
+}
+function emptyResult({ cwd = null, origin = null, reason }) {
+  return createSessionEventsResult({
+    coverage: createSessionEventCoverage(),
+    events: [],
+    header: createSessionEventHeader({ cwd, origin, provider: PROVIDER_ID }),
+    reason,
+    window: {
+      complete: true,
+      end: null,
+      outcomesMayBeUnresolved: false,
+    },
+  });
+}
+function messageParts(record) {
+  const content = record.message?.content;
+  if (typeof content === "string") return [{ text: content, type: "text" }];
+  return Array.isArray(content) ? content : [];
+}
+function planSteps(input) {
+  const todos = Array.isArray(input?.todos) ? input.todos : [];
+  return todos
+    .filter((todo) => typeof todo?.status === "string")
+    .map((todo) => ({
+      status: todo.status,
+      text: typeof todo.content === "string"
+        ? todo.content
+        : typeof todo.activeForm === "string"
+          ? todo.activeForm
+          : "Untitled task",
+    }));
+}
+function questionText(input) {
+  if (typeof input?.question === "string") return input.question;
+  if (!Array.isArray(input?.questions)) return "Question";
+  return input.questions
+    .map((question) => question?.question)
+    .filter((question) => typeof question === "string")
+    .join("\n") || "Question";
+}
+export async function readSessionEvents({
+  claudeHome,
+  desktopDataHome,
+  id,
+  limit,
+  maxLineBytes,
+  mode,
+  signal,
+}) {
+  const record = await getSessionRecord({ claudeHome, desktopDataHome, id });
+  if (!record) return null;
+  const origin = record.surface ?? record.recordSource ?? null;
+  if (!record.rolloutPath) {
+    return emptyResult({
+      cwd: record.cwd || null,
+      origin,
+      reason: SESSION_EVENT_REASON.NO_TRANSCRIPT_PATH,
+    });
+  }
+  const coverage = createSessionEventCoverage();
+  const pendingDecisionIds = [];
+  const readState = createSessionEventReadState({ limit, mode });
+  const unmappedTypes = createUnmappedSessionEventTracker();
+  let acceptingInjectedAsks = true;
+  let header = createSessionEventHeader({
+    cwd: record.cwd || null,
+    origin,
+    provider: PROVIDER_ID,
+  });
+  function addEvent(event, pendingId = null) {
+    return readState.add(event, { pendingId });
+  }
+  function rememberDecision(pendingId) {
+    if (!pendingId) return;
+    pendingDecisionIds.push(pendingId);
+    if (pendingDecisionIds.length > MAX_PENDING_DECISIONS) pendingDecisionIds.shift();
+  }
+  function resolveDecision(answer) {
+    while (pendingDecisionIds.length > 0) {
+      const pendingId = pendingDecisionIds.shift();
+      if (readState.resolve(pendingId, (event) => {
+        if (event.kind === SESSION_EVENT_KIND.DECIDED) event.answer = answer;
+      })) return true;
+    }
+    return false;
+  }
+  function toolEvent(part, atMs, sequence) {
+    const input = part.input && typeof part.input === "object" ? part.input : {};
+    const name = typeof part.name === "string" ? part.name : "unknown tool";
+    const pendingId = typeof part.id === "string" ? part.id : null;
+    if (name === "Edit" || name === "Write") {
+      return {
+        event: createSessionEvent({
+          atMs,
+          files: typeof input.file_path === "string" ? [input.file_path] : [],
+          kind: SESSION_EVENT_KIND.EDIT,
+          sequence,
+        }),
+        pendingId,
+      };
+    }
+    if (name === "Bash") {
+      return {
+        event: createSessionEvent({
+          atMs,
+          command: typeof input.command === "string" ? input.command : null,
+          kind: SESSION_EVENT_KIND.RAN,
+          sequence,
+          workdir: typeof input.workdir === "string" ? input.workdir : record.cwd || null,
+        }),
+        pendingId,
+      };
+    }
+    if (name === "AskUserQuestion") {
+      return {
+        decision: true,
+        event: createSessionEvent({
+          atMs,
+          kind: SESSION_EVENT_KIND.DECIDED,
+          question: questionText(input),
+          sequence,
+        }),
+        pendingId,
+      };
+    }
+    if (name === "TodoWrite") {
+      return {
+        event: createSessionEvent({
+          atMs,
+          kind: SESSION_EVENT_KIND.PLAN,
+          sequence,
+          steps: planSteps(input),
+        }),
+        pendingId: null,
+      };
+    }
+    if (!READ_ONLY_TOOLS.has(name) && typeof input.file_path === "string") {
+      return {
+        event: createSessionEvent({
+          atMs,
+          files: [input.file_path],
+          kind: SESSION_EVENT_KIND.EDIT,
+          sequence,
+        }),
+        pendingId,
+      };
+    }
+    if (typeof input.command === "string") {
+      return {
+        event: createSessionEvent({
+          atMs,
+          command: input.command,
+          kind: SESSION_EVENT_KIND.RAN,
+          sequence,
+          workdir: typeof input.workdir === "string" ? input.workdir : record.cwd || null,
+        }),
+        pendingId,
+      };
+    }
+    return {
+      event: createSessionEvent({
+        atMs,
+        command: name,
+        kind: SESSION_EVENT_KIND.RAN,
+        sequence,
+        unclassified: true,
+        workdir: record.cwd || null,
+      }),
+      pendingId,
+    };
+  }
+  function resolveToolResult(part) {
+    const pendingId = part.tool_use_id;
+    const answer = contentText(part.content).trim();
+    const failed = part.is_error === true;
+    return readState.resolve(pendingId, (event) => {
+      if (event.kind === SESSION_EVENT_KIND.DECIDED) {
+        event.answer = answer || null;
+      } else if (event.kind === SESSION_EVENT_KIND.EDIT) {
+        event.applied = !failed;
+      } else if (event.kind === SESSION_EVENT_KIND.RAN) {
+        event.error = failed ? answer || "Tool failed." : null;
+        event.failed = failed;
+      }
+    });
+  }
+  function updateHeader(recordValue) {
+    const branch = recordValue.gitBranch ?? recordValue.git?.branch ?? header.git?.branch ?? null;
+    const commit = recordValue.git?.commit ?? recordValue.git?.commit_hash ?? header.git?.commit ?? null;
+    const repository = recordValue.git?.repository
+      ?? recordValue.git?.repository_url
+      ?? header.git?.repository
+      ?? null;
+    const hasGit = branch !== null || commit !== null || repository !== null;
+    header = createSessionEventHeader({
+      cwd: recordValue.cwd ?? header.cwd,
+      git: hasGit ? { branch, commit, repository } : null,
+      model: recordValue.message?.model ?? recordValue.model ?? header.model,
+      origin: recordValue.entrypoint ?? header.origin,
+      provider: PROVIDER_ID,
+      version: recordValue.version ?? header.version,
+    });
+  }
+  function handleRecord(recordValue, sequence) {
+    updateHeader(recordValue);
+    const atMs = asTimestamp(recordValue.timestamp ?? recordValue.createdAt);
+    const parts = messageParts(recordValue);
+    if (recordValue.type === "user") {
+      if (recordValue.isCompactSummary === true) {
+        acceptingInjectedAsks = false;
+        const text = contentText(recordValue.message?.content);
+        if (!text) {
+          return { classification: RECORD_CLASSIFICATION.UNPARSEABLE, stop: false };
+        }
+        return {
+          classification: RECORD_CLASSIFICATION.RECOGNIZED,
+          stop: addEvent(createSessionEvent({
+            atMs,
+            kind: SESSION_EVENT_KIND.SUMMARY,
+            sequence,
+            text,
+          })),
+        };
+      }
+      let recognized = false;
+      let resolvedDecision = false;
+      let unparseable = parts.length === 0;
+      let unmappedType = null;
+      for (const part of parts) {
+        if (typeof part?.type !== "string") {
+          unparseable = true;
+          continue;
+        }
+        if (part?.type === "text" && typeof part.text === "string") continue;
+        if (part?.type !== "tool_result") {
+          if (!SKIPPED_CONTENT_TYPES.has(part?.type)) {
+            unmappedType = `user:${part?.type ?? "missing content type"}`;
+          }
+          continue;
+        }
+        const resolved = resolveToolResult(part);
+        if (part.is_error === true) recognized = true;
+        if (part.is_error === true && !resolved) unparseable = true;
+      }
+      const text = parts
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+      if (text) {
+        resolvedDecision = resolveDecision(text);
+        recognized = true;
+        if (resolvedDecision) acceptingInjectedAsks = false;
+        if (!resolvedDecision) {
+          const injected = acceptingInjectedAsks && isInjectedSessionAsk(text);
+          if (!injected) acceptingInjectedAsks = false;
+          return {
+            classification: unmappedType
+              ? RECORD_CLASSIFICATION.UNMAPPED
+              : unparseable
+                ? RECORD_CLASSIFICATION.UNPARSEABLE
+                : RECORD_CLASSIFICATION.RECOGNIZED,
+            stop: addEvent(createSessionEvent({
+              atMs,
+              injected,
+              kind: SESSION_EVENT_KIND.ASK,
+              sequence,
+              text,
+            })),
+            unmappedType,
+          };
+        }
+      }
+      return {
+        classification: unmappedType
+          ? RECORD_CLASSIFICATION.UNMAPPED
+          : unparseable
+            ? RECORD_CLASSIFICATION.UNPARSEABLE
+            : recognized
+              ? RECORD_CLASSIFICATION.RECOGNIZED
+              : RECORD_CLASSIFICATION.SKIPPED,
+        stop: false,
+        unmappedType,
+      };
+    }
+    if (recordValue.type === "assistant") {
+      acceptingInjectedAsks = false;
+      let recognized = false;
+      let stop = false;
+      const unparseable = parts.length === 0 || parts.some((part) => (
+        typeof part?.type !== "string"
+          || (part.type === "text" && typeof part.text !== "string")
+      ));
+      const unmappedPart = parts.find((part) => (
+        typeof part?.type === "string"
+          && part.type !== "text"
+          && part?.type !== "tool_use"
+          && !SKIPPED_CONTENT_TYPES.has(part?.type)
+      ));
+      const unmappedType = unmappedPart
+        ? `assistant:${unmappedPart?.type ?? "missing content type"}`
+        : null;
+      const text = parts
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+      if (text) {
+        recognized = true;
+        stop = addEvent(createSessionEvent({
+          atMs,
+          kind: SESSION_EVENT_KIND.SAID,
+          sequence,
+          text,
+        }));
+      }
+      if (!stop) {
+        for (const part of parts) {
+          if (part?.type === "text" && typeof part.text === "string") continue;
+          if (part?.type !== "tool_use") {
+            continue;
+          }
+          const result = toolEvent(part, atMs, sequence);
+          recognized = true;
+          stop = addEvent(result.event, result.pendingId);
+          if (result.decision) rememberDecision(result.pendingId);
+          if (stop) break;
+        }
+      }
+      return {
+        classification: unmappedType
+          ? RECORD_CLASSIFICATION.UNMAPPED
+          : unparseable
+            ? RECORD_CLASSIFICATION.UNPARSEABLE
+            : recognized
+              ? RECORD_CLASSIFICATION.RECOGNIZED
+              : RECORD_CLASSIFICATION.SKIPPED,
+        stop,
+        unmappedType,
+      };
+    }
+    if (typeof recordValue.type !== "string") {
+      return { classification: RECORD_CLASSIFICATION.UNPARSEABLE, stop: false };
+    }
+    return {
+      classification: SKIPPED_RECORD_TYPES.has(recordValue.type)
+        ? RECORD_CLASSIFICATION.SKIPPED
+        : RECORD_CLASSIFICATION.UNMAPPED,
+      stop: false,
+      unmappedType: `claude:${recordValue.type ?? "missing record type"}`,
+    };
+  }
+  let read;
+  try {
+    read = await visitJsonlSnapshotEntries(
+      record.rolloutPath,
+      (entry) => {
+        if (signal?.aborted) return false;
+        coverage.total += 1;
+        if (entry.oversized) {
+          coverage.oversized += 1;
+          return true;
+        }
+        if (!entry.parsed || typeof entry.parsed !== "object") {
+          coverage.unparseable += 1;
+          return true;
+        }
+        const result = handleRecord(entry.parsed, entry.index);
+        coverage[result.classification] += 1;
+        if (result.classification === RECORD_CLASSIFICATION.UNMAPPED) {
+          unmappedTypes.add(result.unmappedType);
+        }
+        return !result.stop;
+      },
+      { maxLineBytes },
+    );
+  } catch (error) {
+    if (error?.code === "ENOENT") {
+      return emptyResult({
+        cwd: record.cwd || null,
+        origin,
+        reason: SESSION_EVENT_REASON.TRANSCRIPT_MISSING,
+      });
+    }
+    throw error;
+  }
+  const events = readState.values();
+  coverage.unmappedTypes = unmappedTypes.values();
+  return createSessionEventsResult({
+    coverage,
+    events,
+    header,
+    reason: events.length === 0 && read.complete
+      ? SESSION_EVENT_REASON.NO_RECOGNIZED_EVENTS
+      : null,
+    window: readState.window(read),
+  });
+}

package/lib/providers/claude-code/index.mjs CHANGED Viewed

@@ -1,7 +1,9 @@
+import { readSessionEvents } from "./events.mjs";
 import * as store from "./store.mjs";
 export const claudeCodeProvider = Object.freeze({
   id: "claude-code",
   displayName: "Claude Code",
   ...store,
+  readSessionEvents,
 });