@arcreflex/agent-transcripts 0.1.15 → 0.1.17

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

@@ -0,0 +1,21 @@
+# Transcript
+
+**Source**: `test/fixtures/pi-coding-agent/with-thinking.input.jsonl`
+**Adapter**: pi-coding-agent
+
+---
+
+## User
+
+What's the best sorting algorithm for nearly-sorted data?
+
+## Assistant
+
+
+<details>
+<summary>Thinking...</summary>
+
+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.
+</details>
+
+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.

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

@@ -0,0 +1,5 @@
+{"type":"session","version":3,"id":"def-456","timestamp":"2024-12-03T15:00:00.000Z","cwd":"/home/user/project"}
+{"type":"message","id":"e1000001","parentId":null,"timestamp":"2024-12-03T15:00:01.000Z","message":{"role":"user","content":"Read the package.json file","timestamp":1733238001000}}
+{"type":"message","id":"e2000002","parentId":"e1000001","timestamp":"2024-12-03T15:00:05.000Z","message":{"role":"assistant","content":[{"type":"text","text":"Let me read that file for you."},{"type":"toolCall","id":"call_001","name":"Read","arguments":{"path":"package.json"}}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"toolUse","usage":{"input":100,"output":30,"cacheRead":0,"cacheWrite":0,"totalTokens":130,"cost":{"input":0.001,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.002}},"timestamp":1733238005000}}
+{"type":"message","id":"e3000003","parentId":"e2000002","timestamp":"2024-12-03T15:00:06.000Z","message":{"role":"toolResult","toolCallId":"call_001","toolName":"Read","content":[{"type":"text","text":"{\"name\": \"my-project\", \"version\": \"1.0.0\"}"}],"isError":false,"timestamp":1733238006000}}
+{"type":"message","id":"e4000004","parentId":"e3000003","timestamp":"2024-12-03T15:00:10.000Z","message":{"role":"assistant","content":[{"type":"text","text":"The package.json contains a project named \"my-project\" at version 1.0.0."}],"provider":"anthropic","model":"claude-sonnet-4-5","api":"messages","stopReason":"stop","usage":{"input":200,"output":25,"cacheRead":0,"cacheWrite":0,"totalTokens":225,"cost":{"input":0.002,"output":0.001,"cacheRead":0,"cacheWrite":0,"total":0.003}},"timestamp":1733238010000}}

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

@@ -0,0 +1,20 @@
+# Transcript
+
+**Source**: `test/fixtures/pi-coding-agent/with-tools.input.jsonl`
+**Adapter**: pi-coding-agent
+
+---
+
+## User
+
+Read the package.json file
+
+## Assistant
+
+Let me read that file for you.
+
+**Tool**: Read `package.json` <!-- tool:call_001 -->
+
+## Assistant
+
+The package.json contains a project named "my-project" at version 1.0.0.

package/test/serve.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it, beforeAll, afterAll } from "bun:test";
+import { join } from "path";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { archiveSession } from "../src/archive.ts";
+import { claudeCodeAdapter } from "../src/adapters/claude-code.ts";
+import { serve } from "../src/serve.ts";
+
+const fixturesDir = join(import.meta.dir, "fixtures/claude");
+const fixture = join(fixturesDir, "basic-conversation.input.jsonl");
+
+let archiveDir: string;
+let baseUrl: string;
+let stopServer: () => void;
+
+beforeAll(async () => {
+  archiveDir = await mkdtemp(join(tmpdir(), "serve-test-"));
+
+  // Archive a fixture so the server has something to serve
+  await archiveSession(
+    archiveDir,
+    {
+      path: fixture,
+      relativePath: "basic-conversation.input.jsonl",
+      mtime: Date.now(),
+      summary: "Test conversation",
+    },
+    claudeCodeAdapter,
+  );
+
+  // Start the server on an ephemeral port.
+  // serve() doesn't return the server directly, so we call the internals.
+  // Instead, we'll use a random high port and just call serve().
+  const port = 49152 + Math.floor(Math.random() * 10000);
+  baseUrl = `http://localhost:${port}`;
+
+  // serve() installs a SIGINT handler and never resolves. We just need
+  // the Bun.serve to be running, so we call it and keep a reference.
+  const servePromise = serve({ archiveDir, port, quiet: true });
+  stopServer = () => {
+    // The server will be cleaned up when the process exits.
+    // For test isolation, we rely on Bun.serve stopping when the test ends.
+  };
+
+  // Give the server a moment to start
+  await Bun.sleep(100);
+});
+
+afterAll(async () => {
+  await rm(archiveDir, { recursive: true, force: true });
+});
+
+async function get(path: string): Promise<Response> {
+  return fetch(`${baseUrl}${path}`);
+}
+
+describe("serve", () => {
+  // ========================================================================
+  // Index routes
+  // ========================================================================
+
+  describe("index", () => {
+    it("GET / returns HTML index", async () => {
+      const res = await get("/");
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/html");
+      const body = await res.text();
+      expect(body).toContain("Agent Transcripts");
+      expect(body).toContain("<!DOCTYPE html>");
+    });
+
+    it("GET /index.html returns HTML index", async () => {
+      const res = await get("/index.html");
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/html");
+    });
+
+    it("GET /index.md returns markdown index", async () => {
+      const res = await get("/index.md");
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/markdown");
+      const body = await res.text();
+      expect(body).toContain("# Agent Transcripts");
+      expect(body).toContain(".md)");
+    });
+
+    it("GET /index.json returns JSON index", async () => {
+      const res = await get("/index.json");
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("application/json");
+      const body = await res.json();
+      expect(body.sessions).toBeArray();
+      expect(body.sessions.length).toBeGreaterThan(0);
+      const session = body.sessions[0];
+      expect(session.links.html).toEndWith(".html");
+      expect(session.links.md).toEndWith(".md");
+      expect(session.links.json).toEndWith(".json");
+    });
+  });
+
+  // ========================================================================
+  // Session routes
+  // ========================================================================
+
+  describe("session", () => {
+    // Discover the baseName from the JSON index
+    let baseName: string;
+
+    beforeAll(async () => {
+      const res = await get("/index.json");
+      const body = await res.json();
+      // Extract baseName from an html link like "2024-01-01-0000-sessionId.html"
+      baseName = body.sessions[0].links.html.replace(/\.html$/, "");
+    });
+
+    it("GET /{baseName}.html returns HTML transcript", async () => {
+      const res = await get(`/${baseName}.html`);
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/html");
+      const body = await res.text();
+      expect(body).toContain("<!DOCTYPE html>");
+      expect(body).toContain("Test conversation");
+    });
+
+    it("GET /{baseName}.md returns markdown transcript", async () => {
+      const res = await get(`/${baseName}.md`);
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("text/markdown");
+      const body = await res.text();
+      expect(body).toContain("# Test conversation");
+      expect(body).toContain(`${baseName}.html`);
+      expect(body).toContain(`${baseName}.json`);
+      expect(body).toContain("## User");
+      expect(body).toContain("## Assistant");
+    });
+
+    it("GET /{baseName}.json returns JSON transcript", async () => {
+      const res = await get(`/${baseName}.json`);
+      expect(res.status).toBe(200);
+      expect(res.headers.get("content-type")).toContain("application/json");
+      const body = await res.json();
+      expect(body.source).toBeDefined();
+      expect(body.messages).toBeArray();
+      expect(body.messages.length).toBeGreaterThan(0);
+    });
+  });
+
+  // ========================================================================
+  // 404s
+  // ========================================================================
+
+  describe("not found", () => {
+    it("returns 404 for unknown session", async () => {
+      const res = await get("/nonexistent.html");
+      expect(res.status).toBe(404);
+    });
+
+    it("returns 404 for unknown extension", async () => {
+      const res = await get("/index.xml");
+      expect(res.status).toBe(404);
+    });
+
+    it("returns 404 for bare path with no extension", async () => {
+      const res = await get("/something");
+      expect(res.status).toBe(404);
+    });
+  });
+});

package/test/snapshots.test.ts

@@ -4,59 +4,60 @@ 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 fixturesRoot = join(dirname(import.meta.path), "fixtures");
 const binPath = join(dirname(import.meta.path), "../bin/agent-transcripts");
 
-// Find all input fixtures
-const inputFiles: string[] = [];
-const glob = new Glob("*.input.jsonl");
-for await (const file of glob.scan(fixturesDir)) {
-  inputFiles.push(file);
-}
-inputFiles.sort();
+/** Map fixture directory name → adapter name */
+const fixtureAdapters: Record<string, string> = {
+  claude: "claude-code",
+  "pi-coding-agent": "pi-coding-agent",
+};
 
-describe("snapshot tests", () => {
-  for (const inputFile of inputFiles) {
-    const name = inputFile.replace(".input.jsonl", "");
+for (const [fixtureDir, adapterName] of Object.entries(fixtureAdapters)) {
+  const fixturesDir = join(fixturesRoot, fixtureDir);
 
-    it(name, async () => {
-      const inputPath = join(fixturesDir, inputFile);
-      const expectedPath = inputPath.replace(".input.jsonl", ".output.md");
-      // Use relative path for consistent Source: field in output
-      const relativeInputPath = `test/fixtures/claude/${inputFile}`;
+  // Find all input fixtures
+  const inputFiles: string[] = [];
+  const glob = new Glob("*.input.jsonl");
+  for await (const file of glob.scan(fixturesDir)) {
+    inputFiles.push(file);
+  }
+  inputFiles.sort();
 
-      const expectedOutput = await Bun.file(expectedPath).text();
+  describe(`snapshot tests (${adapterName})`, () => {
+    for (const inputFile of inputFiles) {
+      const name = inputFile.replace(".input.jsonl", "");
 
-      // 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);
+      it(name, async () => {
+        const inputPath = join(fixturesDir, inputFile);
+        const expectedPath = inputPath.replace(".input.jsonl", ".output.md");
+        const relativeInputPath = `test/fixtures/${fixtureDir}/${inputFile}`;
 
-      expect(transcripts.length).toBeGreaterThan(0);
+        const expectedOutput = await Bun.file(expectedPath).text();
 
-      // Render the first transcript (our fixtures are single-transcript)
-      const actualOutput = renderTranscript(transcripts[0]);
+        const adapter = getAdapter(adapterName)!;
+        const content = await Bun.file(relativeInputPath).text();
+        const transcripts = adapter.parse(content, relativeInputPath);
 
-      expect(actualOutput.trimEnd()).toBe(expectedOutput.trimEnd());
-    });
-  }
-});
+        expect(transcripts.length).toBeGreaterThan(0);
 
-describe("CLI integration", () => {
-  it("convert to stdout works", async () => {
-    const inputFile = inputFiles[0];
-    if (!inputFile) {
-      throw new Error("No input fixtures found");
+        const actualOutput = renderTranscript(transcripts[0]);
+        expect(actualOutput.trimEnd()).toBe(expectedOutput.trimEnd());
+      });
     }
+  });
+}
 
-    const relativeInputPath = `test/fixtures/claude/${inputFile}`;
+describe("CLI integration", () => {
+  it("convert to stdout works (claude-code)", async () => {
+    const relativeInputPath =
+      "test/fixtures/claude/basic-conversation.input.jsonl";
     const expectedPath = join(
-      fixturesDir,
-      inputFile.replace(".input.jsonl", ".output.md"),
+      fixturesRoot,
+      "claude/basic-conversation.output.md",
     );
     const expectedOutput = await Bun.file(expectedPath).text();
 
-    // Run CLI: convert with stdout output
     const result = Bun.spawnSync([
       binPath,
       "convert",
@@ -70,4 +71,27 @@ describe("CLI integration", () => {
     const actualOutput = result.stdout.toString();
     expect(actualOutput.trimEnd()).toBe(expectedOutput.trimEnd());
   });
+
+  it("convert to stdout works (pi-coding-agent)", async () => {
+    const relativeInputPath =
+      "test/fixtures/pi-coding-agent/basic-conversation.input.jsonl";
+    const expectedPath = join(
+      fixturesRoot,
+      "pi-coding-agent/basic-conversation.output.md",
+    );
+    const expectedOutput = await Bun.file(expectedPath).text();
+
+    const result = Bun.spawnSync([
+      binPath,
+      "convert",
+      relativeInputPath,
+      "--adapter",
+      "pi-coding-agent",
+    ]);
+
+    expect(result.exitCode).toBe(0);
+
+    const actualOutput = result.stdout.toString();
+    expect(actualOutput.trimEnd()).toBe(expectedOutput.trimEnd());
+  });
 });

package/test/summary.test.ts

@@ -12,6 +12,12 @@ describe("extractToolSummary", () => {
     it("returns empty for missing file_path", () => {
       expect(extractToolSummary("Read", {})).toBe("");
     });
+
+    it("returns path (pi-coding-agent style)", () => {
+      expect(extractToolSummary("Read", { path: "src/index.ts" })).toBe(
+        "src/index.ts",
+      );
+    });
   });
 
   describe("Write", () => {