@arcreflex/agent-transcripts 0.1.5 → 0.1.9

package/src/utils/tree.ts

@@ -0,0 +1,116 @@
+/**
+ * Tree/branch navigation utilities for transcript messages.
+ */
+
+import type { Message } from "../types.ts";
+
+export interface MessageTree {
+  bySourceRef: Map<string, Message[]>;
+  children: Map<string, Set<string>>;
+  parents: Map<string, string>;
+  roots: string[];
+}
+
+/**
+ * Build tree structure from messages.
+ * Returns maps for navigation and the messages grouped by sourceRef.
+ */
+export function buildTree(messages: Message[]): MessageTree {
+  const bySourceRef = new Map<string, Message[]>();
+  for (const msg of messages) {
+    const existing = bySourceRef.get(msg.sourceRef) || [];
+    existing.push(msg);
+    bySourceRef.set(msg.sourceRef, existing);
+  }
+
+  const children = new Map<string, Set<string>>();
+  const parents = new Map<string, string>();
+
+  for (const msg of messages) {
+    if (msg.parentMessageRef && bySourceRef.has(msg.parentMessageRef)) {
+      parents.set(msg.sourceRef, msg.parentMessageRef);
+      const existing = children.get(msg.parentMessageRef) || new Set();
+      existing.add(msg.sourceRef);
+      children.set(msg.parentMessageRef, existing);
+    }
+  }
+
+  const roots: string[] = [];
+  for (const sourceRef of bySourceRef.keys()) {
+    if (!parents.has(sourceRef)) {
+      roots.push(sourceRef);
+    }
+  }
+
+  return { bySourceRef, children, parents, roots };
+}
+
+/**
+ * Find the latest leaf in the tree (for primary branch).
+ */
+export function findLatestLeaf(
+  bySourceRef: Map<string, Message[]>,
+  children: Map<string, Set<string>>,
+): string | undefined {
+  let latestLeaf: string | undefined;
+  let latestTime = 0;
+
+  for (const sourceRef of bySourceRef.keys()) {
+    const childSet = children.get(sourceRef);
+    if (!childSet || childSet.size === 0) {
+      const msgs = bySourceRef.get(sourceRef);
+      if (msgs && msgs.length > 0) {
+        const time = new Date(msgs[0].timestamp).getTime();
+        if (time > latestTime) {
+          latestTime = time;
+          latestLeaf = sourceRef;
+        }
+      }
+    }
+  }
+
+  return latestLeaf;
+}
+
+/**
+ * Trace path from root to target.
+ */
+export function tracePath(
+  target: string,
+  parents: Map<string, string>,
+): string[] {
+  const path: string[] = [];
+  let current: string | undefined = target;
+
+  while (current) {
+    path.unshift(current);
+    current = parents.get(current);
+  }
+
+  return path;
+}
+
+/**
+ * Get first line of message content for branch reference display.
+ */
+export function getFirstLine(msg: Message): string {
+  let text: string;
+  switch (msg.type) {
+    case "user":
+    case "assistant":
+    case "system":
+    case "error":
+      text = msg.content;
+      break;
+    case "tool_calls":
+      text = msg.calls.map((c) => c.name).join(", ");
+      break;
+    default:
+      text = "";
+  }
+  const firstLine = text.split("\n")[0].trim();
+  const maxLen = 60;
+  return firstLine.length > maxLen
+    ? firstLine.slice(0, maxLen) + "..."
+    : firstLine;
+}

package/test/fixtures/claude/non-message-parents.input.jsonl

@@ -0,0 +1,9 @@
+{"type": "user", "uuid": "msg-1", "message": {"role": "user", "content": "First message"}, "timestamp": "2024-01-15T10:00:00Z"}
+{"type": "assistant", "uuid": "msg-2", "parentUuid": "msg-1", "message": {"role": "assistant", "content": [{"type": "text", "text": "First response"}]}, "timestamp": "2024-01-15T10:00:05Z"}
+{"type": "progress", "uuid": "progress-1", "parentUuid": "msg-2", "content": "Processing...", "timestamp": "2024-01-15T10:00:10Z"}
+{"type": "user", "uuid": "msg-3", "parentUuid": "progress-1", "message": {"role": "user", "content": "Second message (parent is progress record)"}, "timestamp": "2024-01-15T10:00:15Z"}
+{"type": "assistant", "uuid": "msg-4", "parentUuid": "msg-3", "message": {"role": "assistant", "content": [{"type": "text", "text": "Second response"}]}, "timestamp": "2024-01-15T10:00:20Z"}
+{"type": "progress", "uuid": "progress-2", "parentUuid": "msg-4", "content": "More processing...", "timestamp": "2024-01-15T10:00:25Z"}
+{"type": "progress", "uuid": "progress-3", "parentUuid": "progress-2", "content": "Nested progress...", "timestamp": "2024-01-15T10:00:26Z"}
+{"type": "user", "uuid": "msg-5", "parentUuid": "progress-3", "message": {"role": "user", "content": "Third message (parent is nested progress)"}, "timestamp": "2024-01-15T10:00:30Z"}
+{"type": "assistant", "uuid": "msg-6", "parentUuid": "msg-5", "message": {"role": "assistant", "content": [{"type": "text", "text": "Third response"}]}, "timestamp": "2024-01-15T10:00:35Z"}

package/test/fixtures/claude/non-message-parents.output.md

@@ -0,0 +1,30 @@
+# Transcript
+
+**Source**: `test/fixtures/claude/non-message-parents.input.jsonl`
+**Adapter**: claude-code
+
+---
+
+## User
+
+First message
+
+## Assistant
+
+First response
+
+## User
+
+Second message (parent is progress record)
+
+## Assistant
+
+Second response
+
+## User
+
+Third message (parent is nested progress)
+
+## Assistant
+
+Third response

package/test/snapshots.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it } from "bun:test";
 import { join, dirname } from "path";
 import { Glob } from "bun";
+import { getAdapter } from "../src/adapters/index.ts";
+import { renderTranscript } from "../src/render.ts";
 
 const fixturesDir = join(dirname(import.meta.path), "fixtures/claude");
 const binPath = join(dirname(import.meta.path), "../bin/agent-transcripts");
@@ -25,43 +27,47 @@ describe("snapshot tests", () => {
 
       const expectedOutput = await Bun.file(expectedPath).text();
 
-      // Run the CLI: parse to temp JSON, then render to temp MD
-      const tempJson = `/tmp/test-${name}-${Date.now()}.json`;
-      const tempMd = `/tmp/test-${name}-${Date.now()}.md`;
+      // Direct function call: parse with adapter, then render
+      const adapter = getAdapter("claude-code")!;
+      const content = await Bun.file(relativeInputPath).text();
+      const transcripts = adapter.parse(content, relativeInputPath);
 
-      // Parse
-      const parseResult = Bun.spawnSync([
-        binPath,
-        "parse",
-        relativeInputPath,
-        "--adapter",
-        "claude-code",
-        "-o",
-        tempJson,
-      ]);
-      expect(parseResult.exitCode).toBe(0);
+      expect(transcripts.length).toBeGreaterThan(0);
 
-      // Render
-      const renderResult = Bun.spawnSync([
-        binPath,
-        "render",
-        tempJson,
-        "-o",
-        tempMd,
-      ]);
-      expect(renderResult.exitCode).toBe(0);
+      // Render the first transcript (our fixtures are single-transcript)
+      const actualOutput = renderTranscript(transcripts[0]);
 
-      // Compare output
-      const actualOutput = await Bun.file(tempMd).text();
       expect(actualOutput.trimEnd()).toBe(expectedOutput.trimEnd());
-
-      // Cleanup
-      await Bun.file(tempJson)
-        .delete()
-        .catch(() => {});
-      await Bun.file(tempMd)
-        .delete()
-        .catch(() => {});
     });
   }
 });
+
+describe("CLI integration", () => {
+  it("convert to stdout works", async () => {
+    const inputFile = inputFiles[0];
+    if (!inputFile) {
+      throw new Error("No input fixtures found");
+    }
+
+    const relativeInputPath = `test/fixtures/claude/${inputFile}`;
+    const expectedPath = join(
+      fixturesDir,
+      inputFile.replace(".input.jsonl", ".output.md"),
+    );
+    const expectedOutput = await Bun.file(expectedPath).text();
+
+    // Run CLI: convert with stdout output
+    const result = Bun.spawnSync([
+      binPath,
+      "convert",
+      relativeInputPath,
+      "--adapter",
+      "claude-code",
+    ]);
+
+    expect(result.exitCode).toBe(0);
+
+    const actualOutput = result.stdout.toString();
+    expect(actualOutput.trimEnd()).toBe(expectedOutput.trimEnd());
+  });
+});