@h-rig/cli 0.0.6-alpha.7 → 0.0.6-alpha.71

package/dist/src/commands/_run-replay.js

@@ -0,0 +1,142 @@
+// @bun
+// packages/cli/src/commands/_run-replay.ts
+import { existsSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  runJournalPath
+} from "@rig/runtime/control-plane/authority-files";
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function snippet(value, max = 120) {
+  const raw = text(value);
+  if (!raw)
+    return null;
+  const flat = raw.replace(/\s+/g, " ");
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function summarizeLifecycleEntry(entry) {
+  const type = text(entry.type) ?? "event";
+  switch (type) {
+    case "status": {
+      const anchor = text(entry.sessionId);
+      return [
+        `status \u2192 ${text(entry.status) ?? "(unknown)"}`,
+        snippet(entry.detail) ? `\u2014 ${snippet(entry.detail)}` : null,
+        anchor ? `[session ${anchor}]` : null
+      ].filter(Boolean).join(" ");
+    }
+    case "timeline-entry": {
+      const payload = asRecord(entry.payload) ?? {};
+      const kind = text(payload.type) ?? "entry";
+      const body = snippet(payload.title) ?? snippet(payload.text) ?? snippet(payload.detail);
+      const state = text(payload.state);
+      return [`timeline ${kind}`, body ? `\u2014 ${body}` : null, state ? `(${state})` : null].filter(Boolean).join(" ");
+    }
+    case "log-entry": {
+      const payload = asRecord(entry.payload) ?? {};
+      const title = snippet(payload.title) ?? "log";
+      const detail = snippet(payload.detail);
+      return [`log ${title}`, detail ? `\u2014 ${detail}` : null].filter(Boolean).join(" ");
+    }
+    case "record-patch": {
+      const patch = asRecord(entry.patch) ?? {};
+      const keys = Object.keys(patch);
+      const shown = keys.slice(0, 8).join(", ");
+      return `record-patch {${shown}${keys.length > 8 ? `, +${keys.length - 8} more` : ""}}`;
+    }
+    case "timeline":
+      return "timeline updated (signal)";
+    case "log":
+      return `log signal${snippet(entry.title) ? ` \u2014 ${snippet(entry.title)}` : ""}`;
+    case "completed":
+      return "run completed";
+    case "failed":
+      return `run failed${snippet(entry.error) ? ` \u2014 ${snippet(entry.error)}` : ""}`;
+    default:
+      return type;
+  }
+}
+function summarizeSessionEntry(entry) {
+  const type = text(entry.type) ?? "entry";
+  const message = asRecord(entry.message);
+  const role = text(message?.role);
+  const content = message?.content;
+  let body = null;
+  if (typeof content === "string") {
+    body = snippet(content);
+  } else if (Array.isArray(content)) {
+    body = snippet(content.map((part) => text(asRecord(part)?.text) ?? "").filter(Boolean).join(" "));
+  }
+  return [
+    `pi ${type}`,
+    role ? `(${role})` : null,
+    body ? `\u2014 ${body}` : null
+  ].filter(Boolean).join(" ");
+}
+function sessionEntryTimestamp(entry) {
+  return text(entry.timestamp) ?? text(entry.at) ?? text(entry.createdAt) ?? null;
+}
+function resolveRunSessionFile(record) {
+  const piSession = record?.piSession ?? null;
+  if (!piSession)
+    return null;
+  const recorded = text(piSession.sessionFile);
+  if (recorded && existsSync(recorded)) {
+    return recorded;
+  }
+  const cwd = text(piSession.cwd);
+  const sessionId = text(piSession.sessionId);
+  if (!cwd || !sessionId)
+    return null;
+  const sessionDir = resolve(cwd, ".rig", "session");
+  try {
+    const match = readdirSync(sessionDir).find((name) => name.endsWith(`_${sessionId}.jsonl`));
+    return match ? join(sessionDir, match) : null;
+  } catch {
+    return null;
+  }
+}
+function buildRunReplay(projectRoot, runId, options = {}) {
+  const logPath = runJournalPath(projectRoot, runId);
+  const record = readAuthorityRun(projectRoot, runId);
+  const lifecycleEntries = readJsonlFile(logPath).map((entry) => asRecord(entry)).filter((entry) => entry !== null);
+  const merged = lifecycleEntries.map((entry) => ({
+    at: text(entry.at),
+    source: "run",
+    summary: summarizeLifecycleEntry(entry)
+  }));
+  let sessionFile = null;
+  let sessionEntryCount = 0;
+  if (options.withSession) {
+    sessionFile = resolveRunSessionFile(record);
+    if (sessionFile) {
+      let lastSeenAt = null;
+      const sessionLines = readJsonlFile(sessionFile).map((entry) => asRecord(entry)).filter((entry) => entry !== null).map((entry) => {
+        lastSeenAt = sessionEntryTimestamp(entry) ?? lastSeenAt;
+        return { at: lastSeenAt, source: "session", summary: summarizeSessionEntry(entry) };
+      });
+      sessionEntryCount = sessionLines.length;
+      merged.push(...sessionLines);
+      merged.sort((left, right) => (left.at ?? "").localeCompare(right.at ?? ""));
+    }
+  }
+  const lines = merged.map((line) => `${line.at ?? "(no timestamp)      "}  ${line.source === "run" ? "run    " : "session"}  ${line.summary}`);
+  return {
+    runId,
+    logPath,
+    sessionFile,
+    entryCount: lifecycleEntries.length,
+    sessionEntryCount,
+    lines
+  };
+}
+export {
+  resolveRunSessionFile,
+  buildRunReplay
+};