@arcreflex/agent-transcripts 0.1.15 → 0.1.17

package/src/render-html.ts

@@ -304,23 +304,25 @@ main {
   color: var(--fg);
 }
 
-/* Shiki syntax highlighting - dual theme support */
-.content .shiki,
-.thinking .shiki {
+/* Markdown-highlighted content (Shiki renders as <pre>, but this is prose) */
+.markdown-body pre {
+  white-space: pre-wrap;
+  overflow-wrap: break-word;
+}
+
+.markdown-body .shiki {
   background: transparent !important;
   border: none;
   padding: 0;
   margin: 0;
 }
 
-.content .shiki span,
-.thinking .shiki span {
+.markdown-body .shiki span {
   color: var(--shiki-light);
 }
 
 @media (prefers-color-scheme: dark) {
-  .content .shiki span,
-  .thinking .shiki span {
+  .markdown-body .shiki span {
     color: var(--shiki-dark);
   }
 }
@@ -755,7 +757,7 @@ async function renderMessage(
   </div>
   ${msg.rawJson ? renderRawToggle() : ""}
   <div class="rendered-view">
-    <div class="content">${await contentToHtml(msg.content)}</div>
+    <div class="content markdown-body">${await contentToHtml(msg.content)}</div>
   </div>
   ${msg.rawJson ? `<div class="raw-view">${rawJson}</div>` : ""}
 </div>`;
@@ -767,13 +769,13 @@ async function renderMessage(
         rendered += `
   <details>
     <summary>thinking...</summary>
-    <div class="thinking">${await contentToHtml(msg.thinking)}</div>
+    <div class="thinking markdown-body">${await contentToHtml(msg.thinking)}</div>
   </details>`;
       }
 
       if (msg.content.trim()) {
         rendered += `
-  <div class="content">${await contentToHtml(msg.content)}</div>`;
+  <div class="content markdown-body">${await contentToHtml(msg.content)}</div>`;
       }
 
       const header = ctx.showAssistantHeader

package/src/render.ts

@@ -6,10 +6,9 @@ import type { Transcript, Message, ToolCall } from "./types.ts";
 import { walkTranscriptTree } from "./utils/tree.ts";
 
 function formatToolCall(call: ToolCall): string {
-  if (call.summary) {
-    return `${call.name} \`${call.summary}\``;
-  }
-  return call.name;
+  const label = call.summary ? `${call.name} \`${call.summary}\`` : call.name;
+  const ref = call.id ? ` <!-- tool:${call.id} -->` : "";
+  return `${label}${ref}`;
 }
 
 function formatToolCalls(calls: ToolCall[]): string {
@@ -60,13 +59,14 @@ ${msg.thinking}
 export interface RenderTranscriptOptions {
   head?: string; // render branch ending at this message ID
   sourcePath?: string; // absolute source path for front matter provenance
+  title?: string; // override the "# Transcript" heading
 }
 
 export function renderTranscript(
   transcript: Transcript,
   options: RenderTranscriptOptions = {},
 ): string {
-  const { head, sourcePath } = options;
+  const { head, sourcePath, title } = options;
 
   const lines: string[] = [];
 
@@ -79,7 +79,7 @@ export function renderTranscript(
   }
 
   // Header
-  lines.push("# Transcript");
+  lines.push(`# ${title || "Transcript"}`);
   lines.push("");
   lines.push(`**Source**: \`${transcript.source.file}\``);
   lines.push(`**Adapter**: ${transcript.source.adapter}`);

package/src/serve.ts

@@ -1,14 +1,20 @@
 /**
  * Serve command: HTTP server for transcripts from the archive.
  *
- * Reads archive entries, renders HTML on demand with in-memory LRU cache.
+ * Reads archive entries, renders on demand in multiple formats:
+ * - .html — rich HTML rendering (LRU cached, shiki highlighting)
+ * - .md   — markdown (lightweight, agent-friendly)
+ * - .json — raw transcript data
  */
 
 import type { ArchiveEntryHeader, TranscriptSummary } from "./archive.ts";
 import { listEntryHeaders, loadEntry, DEFAULT_ARCHIVE_DIR } from "./archive.ts";
+import type { Transcript } from "./types.ts";
 import { renderTranscriptHtml } from "./render-html.ts";
+import { renderTranscript } from "./render.ts";
 import { renderIndexFromSessions, type SessionEntry } from "./render-index.ts";
 import { formatDateTimePrefix } from "./utils/naming.ts";
+import { truncate } from "./utils/text.ts";
 
 export interface ServeOptions {
   archiveDir?: string;
@@ -25,6 +31,14 @@ interface SessionInfo {
   baseName: string;
 }
 
+type Format = "html" | "md" | "json";
+
+const CONTENT_TYPES: Record<Format, string> = {
+  html: "text/html; charset=utf-8",
+  md: "text/markdown; charset=utf-8",
+  json: "application/json; charset=utf-8",
+};
+
 /** Simple LRU cache for rendered HTML. */
 class HtmlCache {
   private map = new Map<string, string>();
@@ -93,23 +107,24 @@ function buildSessionMap(
   return sessions;
 }
 
+function sessionTitle(info: SessionInfo): string {
+  return (
+    info.title || truncate(info.segment.firstUserMessage, 80) || info.baseName
+  );
+}
+
 function buildIndexEntries(sessions: Map<string, SessionInfo>): SessionEntry[] {
   const entries: SessionEntry[] = [];
 
   for (const [baseName, info] of sessions) {
-    const { segment, title } = info;
+    const { segment } = info;
     if (segment.metadata.messageCount === 0) continue;
 
     const { messageCount, startTime, endTime, cwd } = segment.metadata;
 
     entries.push({
       filename: `${baseName}.html`,
-      title:
-        title ||
-        (segment.firstUserMessage.length > 80
-          ? segment.firstUserMessage.slice(0, 80) + "..."
-          : segment.firstUserMessage) ||
-        baseName,
+      title: sessionTitle(info),
       firstUserMessage: segment.firstUserMessage,
       date: startTime,
       endDate: endTime,
@@ -121,6 +136,128 @@ function buildIndexEntries(sessions: Map<string, SessionInfo>): SessionEntry[] {
   return entries;
 }
 
+// ============================================================================
+// Format-specific renderers
+// ============================================================================
+
+function renderTranscriptMd(
+  transcript: Transcript,
+  baseName: string,
+  title: string,
+): string {
+  const nav = `*→ [html](${baseName}.html) · [json](${baseName}.json)*`;
+  const md = renderTranscript(transcript, { title });
+  // Insert format links after the title line
+  return md.replace(/^(# .+)\n/, `$1\n\n${nav}\n`);
+}
+
+function renderTranscriptJson(transcript: Transcript): string {
+  return JSON.stringify(transcript, null, 2);
+}
+
+function renderIndexMd(sessions: Map<string, SessionInfo>): string {
+  const sorted = [...sessions.entries()]
+    .filter(([, info]) => info.segment.metadata.messageCount > 0)
+    .sort(
+      (a, b) =>
+        new Date(b[1].segment.metadata.startTime).getTime() -
+        new Date(a[1].segment.metadata.startTime).getTime(),
+    );
+
+  const lines: string[] = [
+    "# Agent Transcripts",
+    "",
+    `${sorted.length} session${sorted.length !== 1 ? "s" : ""}`,
+    "",
+    "*→ [html](index.html) · [json](index.json)*",
+    "",
+  ];
+
+  // Group by cwd
+  const groups = new Map<string, [string, SessionInfo][]>();
+  for (const entry of sorted) {
+    const cwd = entry[1].segment.metadata.cwd || "(unknown)";
+    const group = groups.get(cwd) || [];
+    group.push(entry);
+    groups.set(cwd, group);
+  }
+
+  for (const [cwd, entries] of groups) {
+    lines.push(`## ${cwd}`, "");
+    for (const [baseName, info] of entries) {
+      const title = sessionTitle(info);
+      const msgs = info.segment.metadata.messageCount;
+      const preview = truncate(info.segment.firstUserMessage, 100);
+      lines.push(`- [${title}](${baseName}.md) — ${msgs} msgs`);
+      if (preview) {
+        lines.push(`  > ${preview}`);
+      }
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+interface IndexJsonSession {
+  title: string;
+  links: { html: string; md: string; json: string };
+  date: string;
+  endDate: string;
+  messageCount: number;
+  cwd?: string;
+  firstUserMessage: string;
+}
+
+function renderIndexJson(sessions: Map<string, SessionInfo>): string {
+  const sorted = [...sessions.entries()]
+    .filter(([, info]) => info.segment.metadata.messageCount > 0)
+    .sort(
+      (a, b) =>
+        new Date(b[1].segment.metadata.startTime).getTime() -
+        new Date(a[1].segment.metadata.startTime).getTime(),
+    );
+
+  const result: IndexJsonSession[] = sorted.map(([baseName, info]) => ({
+    title: sessionTitle(info),
+    links: {
+      html: `${baseName}.html`,
+      md: `${baseName}.md`,
+      json: `${baseName}.json`,
+    },
+    date: info.segment.metadata.startTime,
+    endDate: info.segment.metadata.endTime,
+    messageCount: info.segment.metadata.messageCount,
+    cwd: info.segment.metadata.cwd,
+    firstUserMessage: info.segment.firstUserMessage,
+  }));
+
+  return JSON.stringify({ sessions: result }, null, 2);
+}
+
+// ============================================================================
+// Server
+// ============================================================================
+
+/** Parse a URL path into baseName + format, or null if unrecognized. */
+function parseRoute(
+  path: string,
+):
+  | { type: "index"; format: Format }
+  | { type: "session"; baseName: string; format: Format }
+  | null {
+  if (path === "/") return { type: "index", format: "html" };
+
+  const match = path.match(/^\/(.+)\.(html|md|json)$/);
+  if (!match) return null;
+
+  const [, name, ext] = match;
+  const format = ext as Format;
+
+  if (name === "index") return { type: "index", format };
+  return { type: "session", baseName: name, format };
+}
+
 export async function serve(options: ServeOptions): Promise<void> {
   const {
     archiveDir = DEFAULT_ARCHIVE_DIR,
@@ -136,8 +273,10 @@ export async function serve(options: ServeOptions): Promise<void> {
   const sessions = buildSessionMap(headers);
   const htmlCache = new HtmlCache(200);
 
-  // Index is static (session map doesn't change), so build once
+  // Index HTML is static (session map doesn't change), so build once
   const indexHtml = renderIndexFromSessions(buildIndexEntries(sessions));
+  const indexMd = renderIndexMd(sessions);
+  const indexJson = renderIndexJson(sessions);
 
   if (!quiet) {
     console.error(`Found ${sessions.size} transcript(s)`);
@@ -148,58 +287,76 @@ export async function serve(options: ServeOptions): Promise<void> {
     port,
     async fetch(req) {
       const url = new URL(req.url);
-      const path = url.pathname;
+      const route = parseRoute(url.pathname);
 
       if (!quiet) {
-        console.error(`${req.method} ${path}`);
+        console.error(`${req.method} ${url.pathname}`);
       }
 
-      // Index page
-      if (path === "/" || path === "/index.html") {
-        return new Response(indexHtml, {
-          headers: { "Content-Type": "text/html; charset=utf-8" },
+      if (!route) {
+        return new Response("Not Found", { status: 404 });
+      }
+
+      // Index
+      if (route.type === "index") {
+        const body =
+          route.format === "html"
+            ? indexHtml
+            : route.format === "md"
+              ? indexMd
+              : indexJson;
+        return new Response(body, {
+          headers: { "Content-Type": CONTENT_TYPES[route.format] },
         });
       }
 
-      // Session page
-      if (path.endsWith(".html")) {
-        const baseName = path.slice(1, -5);
-        const info = sessions.get(baseName);
-
-        if (info) {
-          try {
-            const { sessionId, segmentIndex, sourceHash, title } = info;
-
-            const cached = htmlCache.get(sessionId, segmentIndex, sourceHash);
-            if (cached) {
-              return new Response(cached, {
-                headers: { "Content-Type": "text/html; charset=utf-8" },
-              });
-            }
-
-            // Load full entry from disk on demand
-            const entry = await loadEntry(archiveDir, sessionId);
-            const transcript = entry?.transcripts[segmentIndex];
-            if (!transcript) {
-              return new Response("Not Found", { status: 404 });
-            }
-
-            const html = await renderTranscriptHtml(transcript, { title });
-            htmlCache.set(sessionId, segmentIndex, sourceHash, html);
-            return new Response(html, {
-              headers: { "Content-Type": "text/html; charset=utf-8" },
+      // Session
+      const info = sessions.get(route.baseName);
+      if (!info) {
+        return new Response("Not Found", { status: 404 });
+      }
+
+      try {
+        const { sessionId, segmentIndex, sourceHash } = info;
+        const title = sessionTitle(info);
+
+        // HTML — use LRU cache (shiki rendering is expensive)
+        if (route.format === "html") {
+          const cached = htmlCache.get(sessionId, segmentIndex, sourceHash);
+          if (cached) {
+            return new Response(cached, {
+              headers: { "Content-Type": CONTENT_TYPES.html },
             });
-          } catch (error) {
-            const message =
-              error instanceof Error ? error.message : String(error);
-            return new Response(`Error: ${message}`, { status: 500 });
           }
+
+          const entry = await loadEntry(archiveDir, sessionId);
+          const transcript = entry?.transcripts[segmentIndex];
+          if (!transcript) return new Response("Not Found", { status: 404 });
+
+          const html = await renderTranscriptHtml(transcript, { title });
+          htmlCache.set(sessionId, segmentIndex, sourceHash, html);
+          return new Response(html, {
+            headers: { "Content-Type": CONTENT_TYPES.html },
+          });
         }
 
-        return new Response("Not Found", { status: 404 });
-      }
+        // Markdown and JSON — render on demand (cheap)
+        const entry = await loadEntry(archiveDir, sessionId);
+        const transcript = entry?.transcripts[segmentIndex];
+        if (!transcript) return new Response("Not Found", { status: 404 });
+
+        const body =
+          route.format === "md"
+            ? renderTranscriptMd(transcript, route.baseName, title)
+            : renderTranscriptJson(transcript);
 
-      return new Response("Not Found", { status: 404 });
+        return new Response(body, {
+          headers: { "Content-Type": CONTENT_TYPES[route.format] },
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return new Response(`Error: ${message}`, { status: 500 });
+      }
     },
   });
 

package/src/types.ts

@@ -60,6 +60,7 @@ export interface ToolCallGroup extends BaseMessage {
 }
 
 export interface ToolCall {
+  id?: string;
   name: string;
   summary: string;
   input?: Record<string, unknown>;

package/src/utils/summary.ts

@@ -7,9 +7,9 @@ import { truncate } from "./text.ts";
 type ToolInput = Record<string, unknown>;
 
 const extractors: Record<string, (input: ToolInput) => string> = {
-  Read: (i) => String(i.file_path || ""),
-  Write: (i) => String(i.file_path || ""),
-  Edit: (i) => String(i.file_path || ""),
+  Read: (i) => String(i.file_path || i.path || ""),
+  Write: (i) => String(i.file_path || i.path || ""),
+  Edit: (i) => String(i.file_path || i.path || ""),
   Bash: (i) => {
     if (i.description) return String(i.description);
     if (i.command) return truncate(String(i.command), 60);

package/test/adapters.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, it } from "bun:test";
-import { getDefaultSources, getAdapter } from "../src/adapters/index.ts";
+import {
+  getDefaultSources,
+  getAdapter,
+  detectAdapter,
+} from "../src/adapters/index.ts";
 import { claudeCodeAdapter } from "../src/adapters/claude-code.ts";
+import { piCodingAgentAdapter } from "../src/adapters/pi-coding-agent.ts";
 
 describe("getDefaultSources", () => {
   it("returns claude-code with its defaultSource", () => {
@@ -14,6 +19,14 @@ describe("getDefaultSources", () => {
     expect(cc?.source.length).toBeGreaterThan(0);
   });
 
+  it("returns pi-coding-agent with its defaultSource", () => {
+    const specs = getDefaultSources();
+    const pi = specs.find((s) => s.adapter.name === "pi-coding-agent");
+    expect(pi).toBeDefined();
+    expect(pi?.adapter).toBe(piCodingAgentAdapter);
+    expect(pi?.source).toMatch(/\.pi[/\\]agent[/\\]sessions$/);
+  });
+
   it("only includes adapters with defaultSource set", () => {
     for (const spec of getDefaultSources()) {
       expect(spec.source).toBeTruthy();
@@ -24,9 +37,30 @@ describe("getDefaultSources", () => {
 describe("getAdapter", () => {
   it("returns adapter by name", () => {
     expect(getAdapter("claude-code")).toBe(claudeCodeAdapter);
+    expect(getAdapter("pi-coding-agent")).toBe(piCodingAgentAdapter);
   });
 
   it("returns undefined for unknown adapter", () => {
     expect(getAdapter("nonexistent")).toBeUndefined();
   });
 });
+
+describe("detectAdapter", () => {
+  it("detects claude-code from .claude/ paths", () => {
+    expect(detectAdapter("/home/user/.claude/projects/foo/session.jsonl")).toBe(
+      "claude-code",
+    );
+  });
+
+  it("detects pi-coding-agent from .pi/agent/sessions/ paths", () => {
+    expect(
+      detectAdapter(
+        "/home/user/.pi/agent/sessions/--project--/12345_abc.jsonl",
+      ),
+    ).toBe("pi-coding-agent");
+  });
+
+  it("returns undefined for unrecognized paths", () => {
+    expect(detectAdapter("/tmp/random/file.jsonl")).toBeUndefined();
+  });
+});

package/test/fixtures/claude/multiple-tools.output.md

@@ -10,6 +10,6 @@
 Check the files
 
 **Tools**:
-- Read `/src/main.ts`
-- Glob `**/*.test.ts`
-- Bash `List files`
+- Read `/src/main.ts` <!-- tool:tool-1 -->
+- Glob `**/*.test.ts` <!-- tool:tool-2 -->
+- Bash `List files` <!-- tool:tool-3 -->

package/test/fixtures/claude/skipped-message-chain.output.md

@@ -13,7 +13,7 @@ Read the config file
 
 I'll read the config file for you.
 
-**Tool**: Read `/project/config.json`
+**Tool**: Read `/project/config.json` <!-- tool:tool-1 -->
 
 ## Assistant
 

package/test/fixtures/claude/with-tools.output.md

@@ -13,4 +13,4 @@ Read the config file
 
 I'll read the config file for you.
 
-**Tool**: Read `/project/config.json`
+**Tool**: Read `/project/config.json` <!-- tool:tool-1 -->

package/test/fixtures/pi-coding-agent/basic-conversation.input.jsonl

@@ -0,0 +1,5 @@
+{"type":"session","version":3,"id":"abc-123","timestamp":"2024-12-03T14:00:00.000Z","cwd":"/home/user/project"}
+{"type":"message","id":"a1b2c3d4","parentId":null,"timestamp":"2024-12-03T14:00:01.000Z","message":{"role":"user","content":"Hello, can you help me with TypeScript?","timestamp":1733234401000}}
+{"type":"message","id":"b2c3d4e5","parentId":"a1b2c3d4","timestamp":"2024-12-03T14:00:05.000Z","message":{"role":"assistant","content":[{"type":"text","text":"Of course! I'd be happy to help with TypeScript. What do you need?"}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":100,"output":20,"cacheRead":0,"cacheWrite":0,"totalTokens":120,"cost":{"input":0.001,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.002}},"timestamp":1733234405000}}
+{"type":"message","id":"c3d4e5f6","parentId":"b2c3d4e5","timestamp":"2024-12-03T14:00:30.000Z","message":{"role":"user","content":"How do I define a generic type?","timestamp":1733234430000}}
+{"type":"message","id":"d4e5f6g7","parentId":"c3d4e5f6","timestamp":"2024-12-03T14:00:35.000Z","message":{"role":"assistant","content":[{"type":"text","text":"You can define a generic type using angle brackets:\n\n```typescript\ntype Result<T> = { ok: true; value: T } | { ok: false; error: string };\n```\n\nThe `T` is a type parameter that gets filled in when you use the type."}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":150,"output":50,"cacheRead":0,"cacheWrite":0,"totalTokens":200,"cost":{"input":0.002,"output":0.002,"cacheRead":0,"cacheWrite":0,"total":0.004}},"timestamp":1733234435000}}

package/test/fixtures/pi-coding-agent/basic-conversation.output.md

@@ -0,0 +1,28 @@
+# Transcript
+
+**Source**: `test/fixtures/pi-coding-agent/basic-conversation.input.jsonl`
+**Adapter**: pi-coding-agent
+
+---
+
+## User
+
+Hello, can you help me with TypeScript?
+
+## Assistant
+
+Of course! I'd be happy to help with TypeScript. What do you need?
+
+## User
+
+How do I define a generic type?
+
+## Assistant
+
+You can define a generic type using angle brackets:
+
+```typescript
+type Result<T> = { ok: true; value: T } | { ok: false; error: string };
+```
+
+The `T` is a type parameter that gets filled in when you use the type.

package/test/fixtures/pi-coding-agent/branching.input.jsonl

@@ -0,0 +1,7 @@
+{"type":"session","version":3,"id":"branch-001","timestamp":"2024-12-03T17:00:00.000Z","cwd":"/home/user/project"}
+{"type":"message","id":"g1000001","parentId":null,"timestamp":"2024-12-03T17:00:01.000Z","message":{"role":"user","content":"Help me pick a web framework","timestamp":1733245201000}}
+{"type":"message","id":"g2000002","parentId":"g1000001","timestamp":"2024-12-03T17:00:05.000Z","message":{"role":"assistant","content":[{"type":"text","text":"I'd recommend considering a few options. What are your priorities?"}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":100,"output":20,"cacheRead":0,"cacheWrite":0,"totalTokens":120,"cost":{"input":0.001,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.002}},"timestamp":1733245205000}}
+{"type":"message","id":"g3000003","parentId":"g2000002","timestamp":"2024-12-03T17:00:30.000Z","message":{"role":"user","content":"I want something with great TypeScript support","timestamp":1733245230000}}
+{"type":"message","id":"g4000004","parentId":"g3000003","timestamp":"2024-12-03T17:00:35.000Z","message":{"role":"assistant","content":[{"type":"text","text":"For great TypeScript support, I'd suggest Next.js or SvelteKit."}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":150,"output":20,"cacheRead":0,"cacheWrite":0,"totalTokens":170,"cost":{"input":0.002,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.003}},"timestamp":1733245235000}}
+{"type":"message","id":"g5000005","parentId":"g2000002","timestamp":"2024-12-03T17:01:00.000Z","message":{"role":"user","content":"I want something minimal and fast","timestamp":1733245260000}}
+{"type":"message","id":"g6000006","parentId":"g5000005","timestamp":"2024-12-03T17:01:05.000Z","message":{"role":"assistant","content":[{"type":"text","text":"For minimal and fast, check out Hono or Elysia — both are lightweight and performant."}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":150,"output":25,"cacheRead":0,"cacheWrite":0,"totalTokens":175,"cost":{"input":0.002,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.003}},"timestamp":1733245265000}}

package/test/fixtures/pi-coding-agent/branching.output.md

@@ -0,0 +1,25 @@
+# Transcript
+
+**Source**: `test/fixtures/pi-coding-agent/branching.input.jsonl`
+**Adapter**: pi-coding-agent
+
+---
+
+## User
+
+Help me pick a web framework
+
+## Assistant
+
+I'd recommend considering a few options. What are your priorities?
+
+> **Other branches**:
+> - `g3000003` "I want something with great TypeScript support"
+
+## User
+
+I want something minimal and fast
+
+## Assistant
+
+For minimal and fast, check out Hono or Elysia — both are lightweight and performant.

package/test/fixtures/pi-coding-agent/with-compaction.input.jsonl

@@ -0,0 +1,7 @@
+{"type":"session","version":3,"id":"compact-001","timestamp":"2024-12-03T18:00:00.000Z","cwd":"/home/user/project"}
+{"type":"message","id":"h1000001","parentId":null,"timestamp":"2024-12-03T18:00:01.000Z","message":{"role":"user","content":"Start a new project","timestamp":1733248801000}}
+{"type":"message","id":"h2000002","parentId":"h1000001","timestamp":"2024-12-03T18:00:05.000Z","message":{"role":"assistant","content":[{"type":"text","text":"Sure, I'll set up a new project for you."}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":100,"output":15,"cacheRead":0,"cacheWrite":0,"totalTokens":115,"cost":{"input":0.001,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.002}},"timestamp":1733248805000}}
+{"type":"compaction","id":"h3000003","parentId":"h2000002","timestamp":"2024-12-03T18:05:00.000Z","summary":"User asked to start a new project. Assistant agreed and began setup.","firstKeptEntryId":"h2000002","tokensBefore":5000}
+{"type":"model_change","id":"h4000004","parentId":"h3000003","timestamp":"2024-12-03T18:05:01.000Z","provider":"openai","modelId":"gpt-4o"}
+{"type":"message","id":"h5000005","parentId":"h4000004","timestamp":"2024-12-03T18:05:30.000Z","message":{"role":"user","content":"Now add a test framework","timestamp":1733249130000}}
+{"type":"message","id":"h6000006","parentId":"h5000005","timestamp":"2024-12-03T18:05:35.000Z","message":{"role":"assistant","content":[{"type":"text","text":"I'll add vitest as the test framework."}],"provider":"openai","model":"gpt-4o","api":"chat","stopReason":"stop","usage":{"input":200,"output":15,"cacheRead":0,"cacheWrite":0,"totalTokens":215,"cost":{"input":0.002,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.003}},"timestamp":1733249135000}}

package/test/fixtures/pi-coding-agent/with-compaction.output.md

@@ -0,0 +1,28 @@
+# Transcript
+
+**Source**: `test/fixtures/pi-coding-agent/with-compaction.input.jsonl`
+**Adapter**: pi-coding-agent
+
+---
+
+## User
+
+Start a new project
+
+## Assistant
+
+Sure, I'll set up a new project for you.
+
+## System
+
+```
+[Compaction] User asked to start a new project. Assistant agreed and began setup.
+```
+
+## User
+
+Now add a test framework
+
+## Assistant
+
+I'll add vitest as the test framework.

package/test/fixtures/pi-coding-agent/with-thinking.input.jsonl

@@ -0,0 +1,3 @@
+{"type":"session","version":3,"id":"ghi-789","timestamp":"2024-12-03T16:00:00.000Z","cwd":"/home/user/project"}
+{"type":"message","id":"f1000001","parentId":null,"timestamp":"2024-12-03T16:00:01.000Z","message":{"role":"user","content":"What's the best sorting algorithm for nearly-sorted data?","timestamp":1733241601000}}
+{"type":"message","id":"f2000002","parentId":"f1000001","timestamp":"2024-12-03T16:00:05.000Z","message":{"role":"assistant","content":[{"type":"thinking","thinking":"The user is asking about sorting algorithms for nearly-sorted data. Insertion sort is O(n) for nearly sorted data, which makes it ideal. Timsort also handles this well since it detects runs."},{"type":"text","text":"For nearly-sorted data, **insertion sort** is excellent — it runs in O(n) time when the data is almost sorted. Python's built-in Timsort also handles this case well since it detects existing sorted runs."}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":100,"output":80,"cacheRead":0,"cacheWrite":0,"totalTokens":180,"cost":{"input":0.001,"output":0.003,"cacheRead":0,"cacheWrite":0,"total":0.004}},"timestamp":1733241605000}}