@ccmsg/cli 0.2.12 → 0.3.0

package/src/transcript/files.ts

@@ -1,19 +1,59 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import type { Sid } from "@ccmsg/protocol";
+import { type Harness, HARNESS } from "../harness/index.ts";
 import { OpError } from "../dispatch/index.ts";
 
-/** Where the harness keeps transcripts under a config home: one directory per
- * working directory, one `<sid>.jsonl` in it. */
-const PROJECTS = "projects";
 const SUFFIX = ".jsonl";
 
-/** A session id as the harness names files by. Validated before it is joined
+/** Where one harness keeps transcripts under its config home, and how a file
+ * there says which session it belongs to (§3.8).
+ *
+ * Two facts, because the two harnesses file the same thing differently. Claude
+ * Code keeps one directory per working directory and names the file after the
+ * session; Codex keeps one directory per date and names the file after the
+ * thread with the moment it started in front. The `depth` is how many
+ * directories stand between the root and a file, which is what the walk needs
+ * and what the naming does not say.
+ *
+ * A Codex rollout that was reverted carries a second id after the thread's own,
+ * separated by `_`: the thread is the same and the file is a new one, so the
+ * name still answers "which session" and that is what is read out of it. */
+interface TranscriptLayout {
+  readonly depth: number;
+  /** The session a file belongs to, or nothing when the name is not one this
+   * harness writes. */
+  readonly sidOf: (name: string) => Sid | undefined;
+  /** What that session's file is called, where the name follows from the sid.
+   * Absent where it does not, which is what makes the walk the only way in. */
+  readonly nameOf?: (sid: Sid) => string;
+}
+
+/** A session id as Claude Code names files by. Validated before it is joined
  * to a path, so a sid is a name rather than a route: no separator and no dot
  * can appear in it, which makes traversal unrepresentable rather than
  * unlikely. */
 const SID = /^[0-9a-fA-F-]{8,64}$/;
 
+/** A Codex rollout, as its recorder writes the name: the moment it opened, the
+ * thread UUID, and the rollout's own id after it when the thread was reverted.
+ * The thread UUID is what a sid is here (measured against codex-cli 0.153.4). */
+const ROLLOUT =
+  /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12})(?:_[0-9a-fA-F-]{36})?\.jsonl$/;
+
+const LAYOUTS: Record<Harness, TranscriptLayout> = {
+  claude: {
+    depth: 1,
+    sidOf: (name) => {
+      if (!name.endsWith(SUFFIX)) return undefined;
+      const sid = name.slice(0, -SUFFIX.length);
+      return SID.test(sid) ? sid : undefined;
+    },
+    nameOf: (sid) => `${sid}${SUFFIX}`,
+  },
+  codex: { depth: 3, sidOf: (name) => ROLLOUT.exec(name)?.[1] },
+};
+
 /** The agent id and run id shapes the harness writes under a session's own
  * directory, and the name a teammate is addressed by. Each is validated on the
  * same footing as a sid, for the same reason: all three name a file. */
@@ -30,6 +70,8 @@ const TEAMMATE = /^[A-Za-z0-9_-]{1,64}$/;
  * (M6) — nothing searches for another one. */
 export interface TranscriptFilesDeps {
   readonly configHome: string;
+  /** Which harness's tree is under it (§3.8). */
+  readonly harness: Harness;
   /** Where a connected session said its transcript is (§5.1). A session that
    * never greeted has none, and the walk below answers for it. */
   readonly announced: (sid: Sid) => string | undefined;
@@ -42,10 +84,10 @@ export class TranscriptFiles {
    *
    * Two ways to the one file, in the order of what each is good for: what the
    * session announced is exact and costs no search, and the walk finds the
-   * file by the identity it carries in its name (`<sid>.jsonl`) for a session
-   * that never greeted or is no longer running. Both stay inside this
-   * instance's `projects/` — the announced path because it was taken only if
-   * it was inside it, the walk because that tree is what it walks (M6). */
+   * file by the identity it carries in its name for a session that never
+   * greeted or is no longer running. Both stay inside this harness's own
+   * transcript tree — the announced path because it was taken only if it was
+   * inside it, the walk because that tree is what it walks (M6). */
   path(sid: Sid): string | undefined {
     const announced = this.deps.announced(sid);
     if (announced !== undefined && isFile(announced)) return announced;
@@ -117,21 +159,23 @@ export class TranscriptFiles {
    * the file and what a `stat` already said about it, so neither has to stat
    * again to decide whether to open it. */
   all(): TranscriptFile[] {
+    const layout = LAYOUTS[this.deps.harness];
     const found: TranscriptFile[] = [];
-    const projects = join(this.deps.configHome, PROJECTS);
-    for (const project of names(projects)) {
-      const dir = join(projects, project);
+    for (const dir of directories(this.#root(), layout.depth)) {
       for (const entry of names(dir)) {
-        if (!entry.endsWith(SUFFIX)) continue;
-        const sid = entry.slice(0, -SUFFIX.length);
-        if (!SID.test(sid)) continue;
+        const sid = layout.sidOf(entry);
+        if (sid === undefined) continue;
         const file = join(dir, entry);
         const stat = statOf(file);
         if (stat === undefined) continue;
         found.push({
           sid,
           file,
-          project,
+          // Only a layout that files by working directory has one to state,
+          // and the field is a prefilter: a tree that says nothing about where
+          // a session ran narrows nothing, and the transcript's own `cwd`
+          // decides as it already does.
+          ...(this.deps.harness === "claude" ? { project: basename(dir) } : {}),
           size: stat.size,
           created_at: Math.round(stat.birthtimeMs || stat.ctimeMs),
           updated_at: Math.round(stat.mtimeMs),
@@ -142,17 +186,52 @@ export class TranscriptFiles {
     return found;
   }
 
+  /** The root of this harness's transcript tree, which is the boundary every
+   * path below is inside of (M6). */
+  #root(): string {
+    return join(this.deps.configHome, HARNESS[this.deps.harness].transcripts);
+  }
+
+  /** The session's file, found by the identity its name carries.
+   *
+   * A layout whose name follows from the sid is joined rather than searched,
+   * which is one `stat` per directory instead of a listing; one whose name
+   * carries more than the sid is walked, because the rest of the name is
+   * exactly what this does not know. */
   private find(sid: Sid): string | undefined {
-    if (!SID.test(sid)) return undefined;
-    const projects = join(this.deps.configHome, PROJECTS);
-    for (const project of names(projects)) {
-      const file = join(projects, project, `${sid}${SUFFIX}`);
-      if (isFile(file)) return file;
+    const layout = LAYOUTS[this.deps.harness];
+    const dirs = directories(this.#root(), layout.depth);
+    const nameOf = layout.nameOf;
+    if (nameOf !== undefined) {
+      if (!SID.test(sid)) return undefined;
+      for (const dir of dirs) {
+        const file = join(dir, nameOf(sid));
+        if (isFile(file)) return file;
+      }
+      return undefined;
+    }
+    for (const dir of dirs) {
+      for (const entry of names(dir)) {
+        if (layout.sidOf(entry) === sid && isFile(join(dir, entry))) return join(dir, entry);
+      }
     }
     return undefined;
   }
 }
 
+/** Every directory transcripts sit in, at the depth the layout files them at.
+ *
+ * Names are read rather than dates computed: what is there is what the harness
+ * wrote, and a tree with a directory nobody expected is one whose files are
+ * still found. */
+function directories(root: string, depth: number): string[] {
+  let level = [root];
+  for (let step = 0; step < depth; step += 1) {
+    level = level.flatMap((dir) => names(dir).map((entry) => join(dir, entry)));
+  }
+  return level;
+}
+
 export interface AgentNames {
   readonly agent_id?: string;
   readonly run_id?: string;
@@ -165,8 +244,10 @@ export interface TranscriptFile {
   readonly file: string;
   /** The project directory's name, which is the working directory flattened.
    * A lossy spelling — separators and dots all become dashes — so it prefilters
-   * a search and never decides it. */
-  readonly project: string;
+   * a search and never decides it. Absent where the harness files transcripts
+   * by something other than the working directory, which leaves nothing to
+   * prefilter on. */
+  readonly project?: string;
   readonly size: number;
   readonly created_at: number;
   readonly updated_at: number;

package/src/transcript/fold.ts

@@ -133,6 +133,11 @@ export class TranscriptFold {
       return false;
     }
     if (!isRecord(row)) return false;
+    // A Codex rollout line settles one of these facts and none of the others,
+    // so it is folded on its own rather than run past readers of records it
+    // does not have (§3.8).
+    const rollout = rolloutRecord(row, str(row["type"]));
+    if (rollout !== undefined) return this.#foldRollout(rollout);
     // Every value this fold derives, derived from the one parse (M5).
     let changed = this.#foldApiError(row);
     if (this.#foldAnswered(row)) changed = true;
@@ -223,6 +228,20 @@ export class TranscriptFold {
    *
    * A sidechain user row is a subagent being prompted by its parent, which is
    * a session speaking to itself rather than a person speaking to it. */
+  /** What a Codex rollout says: when a person last spoke.
+   *
+   * The rest of what this fold holds — the api error, the model of the latest
+   * turn, todos, teammates, background work — are records Claude Code writes
+   * and a rollout does not, so they stay as they are for a Codex session
+   * rather than being guessed at from something that resembles them. */
+  #foldRollout(record: TranscriptRecord): boolean {
+    if (record.said_by !== "user" || record.said_at === undefined) return false;
+    if (record.text === undefined || !isHuman(record.text)) return false;
+    if ((this.#lastUserInputAt ?? 0) >= record.said_at) return false;
+    this.#lastUserInputAt = record.said_at;
+    return true;
+  }
+
   #foldUserInput(row: Record<string, unknown>): boolean {
     if (row["type"] !== "user" || row["isSidechain"] === true) return false;
     if (row["isMeta"] === true || row["promptSource"] === "system") return false;
@@ -744,6 +763,8 @@ export function readRecord(line: string): TranscriptRecord | undefined {
   }
   if (!isRecord(row)) return undefined;
   const type = str(row["type"]);
+  const rollout = rolloutRecord(row, type);
+  if (rollout !== undefined) return rollout;
   const message = isRecord(row["message"]) ? row["message"] : undefined;
   const model = message === undefined ? undefined : str(message["model"]);
   return {
@@ -760,6 +781,52 @@ export function readRecord(line: string): TranscriptRecord | undefined {
   };
 }
 
+/** One line of a Codex rollout, or nothing where the line is not one.
+ *
+ * A rollout says what kind of line it is in its own `type`, and the words it
+ * uses appear in no Claude Code transcript — so the two formats are told apart
+ * by the line rather than by anything the reader was told beforehand.
+ *
+ * What is read is what §5 asks a transcript for and a rollout answers: when a
+ * person last spoke, and where the session runs. The rest of the fold's facts —
+ * a session's todos, its teammates, the files it named — are Claude Code's own
+ * records, and a Codex session simply declares none of them.
+ *
+ * `developer` is not a person: Codex writes the instructions a turn runs under
+ * as messages of that role, so only `user` and `assistant` are read as somebody
+ * speaking. One of the `user` rows is not a person either — Codex opens a
+ * thread by stating the environment as `<environment_context>` — and it is the
+ * fold that turns that away, by the same rule that turns away every injected
+ * opening a Claude Code transcript carries: a row that opens with a tag is the
+ * harness talking. So the role decides who is read here, and what is read
+ * decides whether a person said it. */
+function rolloutRecord(
+  row: Record<string, unknown>,
+  type: string | undefined,
+): TranscriptRecord | undefined {
+  if (type === "session_meta") {
+    const payload = isRecord(row["payload"]) ? row["payload"] : undefined;
+    return {
+      sidechain: false,
+      ...optional("said_at", instant(row["timestamp"])),
+      ...optional("cwd", payload === undefined ? undefined : str(payload["cwd"])),
+    };
+  }
+  if (type !== "response_item") return undefined;
+  const payload = isRecord(row["payload"]) ? row["payload"] : undefined;
+  if (payload === undefined || str(payload["type"]) !== "message") return { sidechain: false };
+  const role = str(payload["role"]);
+  return {
+    sidechain: false,
+    ...optional("said_at", instant(row["timestamp"])),
+    ...optional<"said_by", "user" | "agent">(
+      "said_by",
+      role === "user" ? "user" : role === "assistant" ? "agent" : undefined,
+    ),
+    ...optional("text", blockText(payload["content"])),
+  };
+}
+
 /** The harness's record types, in the contract's two words. Its `assistant` is
  * the contract's `agent`; every other type is a record neither side spoke. */
 function saidBy(type: string | undefined): "user" | "agent" | undefined {
@@ -771,6 +838,8 @@ function optional<K extends string, V>(key: K, value: V | undefined): Record<K,
   return value === undefined ? {} : { [key]: value };
 }
 
+const TEXT_BLOCK = new Set(["text", "input_text", "output_text"]);
+
 /** The text a message states, whoever wrote it. A plain prompt is a string; a
  * prompt with an attachment, and every row the harness writes, is a block
  * array whose text blocks carry the words. An array holding only tool results
@@ -781,7 +850,9 @@ function blockText(content: unknown): string | undefined {
   if (!Array.isArray(content)) return undefined;
   const parts: string[] = [];
   for (const block of content) {
-    if (!isRecord(block) || block["type"] !== "text") continue;
+    // `text` is what Claude Code writes; `input_text` and `output_text` are
+    // what a Codex rollout writes for the same thing, one per direction.
+    if (!isRecord(block) || !TEXT_BLOCK.has(block["type"] as string)) continue;
     const text = str(block["text"]);
     if (text !== undefined) parts.push(text);
   }