@arcreflex/agent-transcripts 0.1.9 → 0.1.11

package/test/archive.test.ts

@@ -0,0 +1,264 @@
+import { describe, expect, it, beforeEach, afterEach } from "bun:test";
+import { join } from "path";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import {
+  archiveSession,
+  archiveAll,
+  loadEntry,
+  saveEntry,
+  listEntries,
+  isFresh,
+  computeContentHash,
+  type ArchiveEntry,
+} from "../src/archive.ts";
+import type { Adapter } from "../src/types.ts";
+import { claudeCodeAdapter } from "../src/adapters/claude-code.ts";
+
+const fixturesDir = join(import.meta.dir, "fixtures/claude");
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), "archive-test-"));
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("computeContentHash", () => {
+  it("returns consistent hash", () => {
+    const h1 = computeContentHash("hello");
+    const h2 = computeContentHash("hello");
+    expect(h1).toBe(h2);
+  });
+
+  it("returns different hash for different content", () => {
+    const h1 = computeContentHash("hello");
+    const h2 = computeContentHash("world");
+    expect(h1).not.toBe(h2);
+  });
+});
+
+describe("saveEntry / loadEntry", () => {
+  it("round-trips an entry", async () => {
+    const entry: ArchiveEntry = {
+      sessionId: "test-session",
+      sourcePath: "/tmp/test.jsonl",
+      sourceHash: "abc123",
+      adapterName: "claude-code",
+      adapterVersion: "claude-code:1",
+      schemaVersion: 1,
+      archivedAt: "2025-01-01T00:00:00Z",
+      transcripts: [],
+    };
+
+    await saveEntry(tmpDir, entry);
+    const loaded = await loadEntry(tmpDir, "test-session");
+    expect(loaded).toEqual(entry);
+  });
+
+  it("returns undefined for missing entry", async () => {
+    const loaded = await loadEntry(tmpDir, "nonexistent");
+    expect(loaded).toBeUndefined();
+  });
+});
+
+describe("isFresh", () => {
+  const adapter: Adapter = {
+    name: "test",
+    version: "test:1",
+    discover: async () => [],
+    parse: () => [],
+  };
+
+  const entry: ArchiveEntry = {
+    sessionId: "s",
+    sourcePath: "/tmp/s.jsonl",
+    sourceHash: "hash1",
+    adapterName: "test",
+    adapterVersion: "test:1",
+    schemaVersion: 1,
+    archivedAt: "2025-01-01T00:00:00Z",
+    transcripts: [],
+  };
+
+  it("returns true when all match", () => {
+    expect(isFresh(entry, "hash1", adapter)).toBe(true);
+  });
+
+  it("returns false when sourceHash differs", () => {
+    expect(isFresh(entry, "hash2", adapter)).toBe(false);
+  });
+
+  it("returns false when adapterVersion differs", () => {
+    const v2 = { ...adapter, version: "test:2" };
+    expect(isFresh(entry, "hash1", v2)).toBe(false);
+  });
+
+  it("returns false when schemaVersion differs", () => {
+    const oldSchema = { ...entry, schemaVersion: 0 };
+    expect(isFresh(oldSchema, "hash1", adapter)).toBe(false);
+  });
+});
+
+describe("archiveSession", () => {
+  it("archives a fixture file", async () => {
+    const fixturePath = join(fixturesDir, "basic-conversation.input.jsonl");
+    const session = {
+      path: fixturePath,
+      relativePath: "basic-conversation.input.jsonl",
+      mtime: Date.now(),
+    };
+
+    const { entry, updated } = await archiveSession(
+      tmpDir,
+      session,
+      claudeCodeAdapter,
+    );
+
+    expect(updated).toBe(true);
+    expect(entry.sessionId).toBe("basic-conversation.input");
+    expect(entry.adapterName).toBe("claude-code");
+    expect(entry.adapterVersion).toBe("claude-code:1");
+    expect(entry.schemaVersion).toBe(1);
+    expect(entry.transcripts.length).toBeGreaterThan(0);
+    expect(entry.sourceHash).toBeTruthy();
+
+    // Verify it was persisted
+    const loaded = await loadEntry(tmpDir, entry.sessionId);
+    expect(loaded).toEqual(entry);
+  });
+
+  it("returns updated: false for unchanged source", async () => {
+    const fixturePath = join(fixturesDir, "basic-conversation.input.jsonl");
+    const session = {
+      path: fixturePath,
+      relativePath: "basic-conversation.input.jsonl",
+      mtime: Date.now(),
+    };
+
+    const first = await archiveSession(tmpDir, session, claudeCodeAdapter);
+    expect(first.updated).toBe(true);
+
+    const second = await archiveSession(tmpDir, session, claudeCodeAdapter);
+    expect(second.updated).toBe(false);
+  });
+
+  it("updates title when harness summary changes on fresh entry", async () => {
+    const fixturePath = join(fixturesDir, "basic-conversation.input.jsonl");
+
+    // Archive without summary
+    const first = await archiveSession(
+      tmpDir,
+      { path: fixturePath, relativePath: "x", mtime: Date.now() },
+      claudeCodeAdapter,
+    );
+    expect(first.entry.title).toBeUndefined();
+
+    // Re-archive with a new harness summary (same content hash)
+    const second = await archiveSession(
+      tmpDir,
+      {
+        path: fixturePath,
+        relativePath: "x",
+        mtime: Date.now(),
+        summary: "New harness title",
+      },
+      claudeCodeAdapter,
+    );
+    expect(second.updated).toBe(true);
+    expect(second.entry.title).toBe("New harness title");
+
+    // Verify persisted
+    const loaded = await loadEntry(tmpDir, first.entry.sessionId);
+    expect(loaded?.title).toBe("New harness title");
+  });
+
+  it("preserves existing title when re-archiving", async () => {
+    const fixturePath = join(fixturesDir, "basic-conversation.input.jsonl");
+    const session = {
+      path: fixturePath,
+      relativePath: "basic-conversation.input.jsonl",
+      mtime: Date.now(),
+    };
+
+    // Archive once
+    const { entry } = await archiveSession(tmpDir, session, claudeCodeAdapter);
+
+    // Manually set a title and save
+    entry.title = "My Custom Title";
+    await saveEntry(tmpDir, entry);
+
+    // Force re-archive by bumping adapter version
+    const bumpedAdapter = { ...claudeCodeAdapter, version: "claude-code:2" };
+    const { entry: reArchived, updated } = await archiveSession(
+      tmpDir,
+      session,
+      bumpedAdapter,
+    );
+
+    expect(updated).toBe(true);
+    expect(reArchived.title).toBe("My Custom Title");
+  });
+});
+
+describe("listEntries", () => {
+  it("returns all entries", async () => {
+    const fixtures = [
+      "basic-conversation.input.jsonl",
+      "with-tools.input.jsonl",
+    ];
+
+    for (const f of fixtures) {
+      await archiveSession(
+        tmpDir,
+        {
+          path: join(fixturesDir, f),
+          relativePath: f,
+          mtime: Date.now(),
+        },
+        claudeCodeAdapter,
+      );
+    }
+
+    const entries = await listEntries(tmpDir);
+    expect(entries.length).toBe(2);
+    const ids = entries.map((e) => e.sessionId).sort();
+    expect(ids).toEqual(
+      ["basic-conversation.input", "with-tools.input"].sort(),
+    );
+  });
+
+  it("returns empty array for nonexistent dir", async () => {
+    const entries = await listEntries("/tmp/nonexistent-archive-dir-xyz");
+    expect(entries).toEqual([]);
+  });
+});
+
+describe("archiveAll", () => {
+  it("discovers and archives sessions", async () => {
+    // Create a source dir with a fixture and a sessions-index.json
+    const sourceDir = await mkdtemp(join(tmpdir(), "archive-source-"));
+    const fixturePath = join(fixturesDir, "basic-conversation.input.jsonl");
+    const content = await Bun.file(fixturePath).text();
+    await Bun.write(join(sourceDir, "test-session.jsonl"), content);
+
+    const result = await archiveAll(tmpDir, sourceDir, [claudeCodeAdapter], {
+      quiet: true,
+    });
+
+    expect(result.updated.length).toBe(1);
+    expect(result.errors.length).toBe(0);
+
+    // Second run should be all current
+    const result2 = await archiveAll(tmpDir, sourceDir, [claudeCodeAdapter], {
+      quiet: true,
+    });
+    expect(result2.updated.length).toBe(0);
+    expect(result2.current.length).toBe(1);
+
+    await rm(sourceDir, { recursive: true, force: true });
+  });
+});

package/test/fixtures/claude/branching.input.jsonl

@@ -0,0 +1,6 @@
+{"type": "user", "uuid": "msg-1", "message": {"role": "user", "content": "What language should I use for this project?"}, "timestamp": "2024-01-15T10:00:00Z"}
+{"type": "assistant", "uuid": "msg-2", "parentUuid": "msg-1", "message": {"role": "assistant", "content": [{"type": "text", "text": "It depends on your requirements. What kind of project is it?"}]}, "timestamp": "2024-01-15T10:00:05Z"}
+{"type": "user", "uuid": "msg-3a", "parentUuid": "msg-2", "message": {"role": "user", "content": "A CLI tool."}, "timestamp": "2024-01-15T10:01:00Z"}
+{"type": "assistant", "uuid": "msg-4a", "parentUuid": "msg-3a", "message": {"role": "assistant", "content": [{"type": "text", "text": "For a CLI tool, I'd suggest Go or Rust."}]}, "timestamp": "2024-01-15T10:01:05Z"}
+{"type": "user", "uuid": "msg-3b", "parentUuid": "msg-2", "message": {"role": "user", "content": "A web application."}, "timestamp": "2024-01-15T10:02:00Z"}
+{"type": "assistant", "uuid": "msg-4b", "parentUuid": "msg-3b", "message": {"role": "assistant", "content": [{"type": "text", "text": "For a web app, TypeScript with a framework like Next.js is a great choice."}]}, "timestamp": "2024-01-15T10:02:05Z"}

package/test/fixtures/claude/branching.output.md

@@ -0,0 +1,25 @@
+# Transcript
+
+**Source**: `test/fixtures/claude/branching.input.jsonl`
+**Adapter**: claude-code
+
+---
+
+## User
+
+What language should I use for this project?
+
+## Assistant
+
+It depends on your requirements. What kind of project is it?
+
+> **Other branches**:
+> - `msg-3a` "A CLI tool."
+
+## User
+
+A web application.
+
+## Assistant
+
+For a web app, TypeScript with a framework like Next.js is a great choice.

package/test/naming.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "bun:test";
+import {
+  extractSessionId,
+  formatDateTimePrefix,
+  generateOutputName,
+} from "../src/utils/naming.ts";
+import type { Transcript } from "../src/types.ts";
+
+describe("extractSessionId", () => {
+  it("strips .jsonl extension", () => {
+    expect(extractSessionId("/path/to/abc-123.jsonl")).toBe("abc-123");
+  });
+
+  it("strips .json extension", () => {
+    expect(extractSessionId("/path/to/session.json")).toBe("session");
+  });
+
+  it("returns 'stdin' for <stdin>", () => {
+    expect(extractSessionId("<stdin>")).toBe("stdin");
+  });
+
+  it("handles bare filename", () => {
+    expect(extractSessionId("my-session.jsonl")).toBe("my-session");
+  });
+
+  it("handles filename with no extension", () => {
+    expect(extractSessionId("/path/to/no-extension")).toBe("no-extension");
+  });
+
+  it("handles deeply nested paths", () => {
+    expect(
+      extractSessionId(
+        "/home/user/.claude/projects/foo/sessions/uuid-here.jsonl",
+      ),
+    ).toBe("uuid-here");
+  });
+});
+
+describe("formatDateTimePrefix", () => {
+  it("formats a valid ISO timestamp", () => {
+    // Use a fixed timestamp and check the format pattern
+    const result = formatDateTimePrefix("2024-01-15T14:23:00Z");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}-\d{4}$/);
+  });
+
+  it("falls back to current date for invalid timestamp", () => {
+    const result = formatDateTimePrefix("not-a-date");
+    // Should still produce a valid format
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}-\d{4}$/);
+  });
+
+  it("falls back to current date for empty string", () => {
+    const result = formatDateTimePrefix("");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}-\d{4}$/);
+  });
+});
+
+describe("generateOutputName", () => {
+  it("combines datetime prefix and session id", () => {
+    const transcript: Transcript = {
+      source: { file: "test.jsonl", adapter: "claude-code" },
+      metadata: {
+        warnings: [],
+        messageCount: 1,
+        startTime: "2024-01-15T14:23:00Z",
+        endTime: "2024-01-15T14:30:00Z",
+      },
+      messages: [
+        {
+          type: "user",
+          sourceRef: "msg-1",
+          timestamp: "2024-01-15T14:23:00Z",
+          content: "hello",
+        },
+      ],
+    };
+
+    const result = generateOutputName(transcript, "/path/to/my-session.jsonl");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}-\d{4}-my-session$/);
+  });
+
+  it("handles transcript with no messages", () => {
+    const transcript: Transcript = {
+      source: { file: "test.jsonl", adapter: "claude-code" },
+      metadata: {
+        warnings: [],
+        messageCount: 0,
+        startTime: "2024-01-01T00:00:00Z",
+        endTime: "2024-01-01T00:00:00Z",
+      },
+      messages: [],
+    };
+
+    const result = generateOutputName(transcript, "empty.jsonl");
+    // No messages → empty timestamp → falls back to current date
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}-\d{4}-empty$/);
+  });
+});

package/test/summary.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from "bun:test";
+import { extractToolSummary } from "../src/utils/summary.ts";
+
+describe("extractToolSummary", () => {
+  describe("Read", () => {
+    it("returns file_path", () => {
+      expect(extractToolSummary("Read", { file_path: "/foo/bar.ts" })).toBe(
+        "/foo/bar.ts",
+      );
+    });
+
+    it("returns empty for missing file_path", () => {
+      expect(extractToolSummary("Read", {})).toBe("");
+    });
+  });
+
+  describe("Write", () => {
+    it("returns file_path", () => {
+      expect(extractToolSummary("Write", { file_path: "/out.txt" })).toBe(
+        "/out.txt",
+      );
+    });
+  });
+
+  describe("Edit", () => {
+    it("returns file_path", () => {
+      expect(extractToolSummary("Edit", { file_path: "/src/index.ts" })).toBe(
+        "/src/index.ts",
+      );
+    });
+  });
+
+  describe("Bash", () => {
+    it("prefers description over command", () => {
+      expect(
+        extractToolSummary("Bash", {
+          description: "Run tests",
+          command: "bun test",
+        }),
+      ).toBe("Run tests");
+    });
+
+    it("falls back to truncated command", () => {
+      const longCmd = "a".repeat(100);
+      const result = extractToolSummary("Bash", { command: longCmd });
+      expect(result.length).toBe(60);
+      expect(result.endsWith("...")).toBe(true);
+    });
+
+    it("returns empty for no description or command", () => {
+      expect(extractToolSummary("Bash", {})).toBe("");
+    });
+  });
+
+  describe("Grep", () => {
+    it("returns pattern with path", () => {
+      expect(
+        extractToolSummary("Grep", { pattern: "TODO", path: "/src" }),
+      ).toBe("TODO in /src");
+    });
+
+    it("returns pattern alone without path", () => {
+      expect(extractToolSummary("Grep", { pattern: "TODO" })).toBe("TODO");
+    });
+
+    it("truncates long patterns", () => {
+      const long = "x".repeat(100);
+      const result = extractToolSummary("Grep", { pattern: long });
+      expect(result.length).toBe(80);
+      expect(result.endsWith("...")).toBe(true);
+    });
+  });
+
+  describe("Glob", () => {
+    it("returns pattern", () => {
+      expect(extractToolSummary("Glob", { pattern: "**/*.ts" })).toBe(
+        "**/*.ts",
+      );
+    });
+  });
+
+  describe("WebFetch", () => {
+    it("returns url", () => {
+      expect(
+        extractToolSummary("WebFetch", { url: "https://example.com" }),
+      ).toBe("https://example.com");
+    });
+  });
+
+  describe("WebSearch", () => {
+    it("returns query", () => {
+      expect(
+        extractToolSummary("WebSearch", { query: "bun test runner" }),
+      ).toBe("bun test runner");
+    });
+  });
+
+  describe("Task", () => {
+    it("prefers description", () => {
+      expect(
+        extractToolSummary("Task", { description: "Research this topic" }),
+      ).toBe("Research this topic");
+    });
+
+    it("falls back to prompt", () => {
+      expect(extractToolSummary("Task", { prompt: "Do the thing" })).toBe(
+        "Do the thing",
+      );
+    });
+
+    it("truncates long descriptions", () => {
+      const long = "y".repeat(100);
+      const result = extractToolSummary("Task", { description: long });
+      expect(result.length).toBe(60);
+      expect(result.endsWith("...")).toBe(true);
+    });
+  });
+
+  describe("TodoWrite", () => {
+    it("returns fixed string", () => {
+      expect(extractToolSummary("TodoWrite", {})).toBe("update todos");
+    });
+  });
+
+  describe("AskUserQuestion", () => {
+    it("returns fixed string", () => {
+      expect(extractToolSummary("AskUserQuestion", {})).toBe("ask user");
+    });
+  });
+
+  describe("NotebookEdit", () => {
+    it("returns notebook_path", () => {
+      expect(
+        extractToolSummary("NotebookEdit", { notebook_path: "/nb.ipynb" }),
+      ).toBe("/nb.ipynb");
+    });
+  });
+
+  describe("unknown tool", () => {
+    it("returns empty string", () => {
+      expect(extractToolSummary("SomeUnknownTool", { x: 1 })).toBe("");
+    });
+  });
+});