@arcreflex/agent-transcripts 0.1.10 → 0.1.12

package/test/tree.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it } from "bun:test";
+import {
+  buildTree,
+  findLatestLeaf,
+  tracePath,
+  getFirstLine,
+} from "../src/utils/tree.ts";
+import type { Message, UserMessage, AssistantMessage } from "../src/types.ts";
+
+function userMsg(
+  sourceRef: string,
+  timestamp: string,
+  content: string,
+  parentMessageRef?: string,
+): UserMessage {
+  return { type: "user", sourceRef, timestamp, content, parentMessageRef };
+}
+
+function assistantMsg(
+  sourceRef: string,
+  timestamp: string,
+  content: string,
+  parentMessageRef?: string,
+): AssistantMessage {
+  return { type: "assistant", sourceRef, timestamp, content, parentMessageRef };
+}
+
+describe("buildTree", () => {
+  it("builds a linear chain", () => {
+    const msgs: Message[] = [
+      userMsg("a", "2024-01-01T00:00:00Z", "hi"),
+      assistantMsg("b", "2024-01-01T00:01:00Z", "hello", "a"),
+      userMsg("c", "2024-01-01T00:02:00Z", "bye", "b"),
+    ];
+
+    const tree = buildTree(msgs);
+
+    expect(tree.roots).toEqual(["a"]);
+    expect(tree.parents.get("b")).toBe("a");
+    expect(tree.parents.get("c")).toBe("b");
+    expect([...(tree.children.get("a") ?? [])]).toEqual(["b"]);
+    expect([...(tree.children.get("b") ?? [])]).toEqual(["c"]);
+    expect(tree.children.has("c")).toBe(false);
+  });
+
+  it("builds a tree with a branch point", () => {
+    const msgs: Message[] = [
+      userMsg("a", "2024-01-01T00:00:00Z", "root"),
+      assistantMsg("b", "2024-01-01T00:01:00Z", "reply", "a"),
+      userMsg("c", "2024-01-01T00:02:00Z", "branch 1", "b"),
+      userMsg("d", "2024-01-01T00:03:00Z", "branch 2", "b"),
+    ];
+
+    const tree = buildTree(msgs);
+
+    expect(tree.roots).toEqual(["a"]);
+    const bChildren = [...(tree.children.get("b") ?? [])];
+    expect(bChildren.sort()).toEqual(["c", "d"]);
+    expect(tree.parents.get("c")).toBe("b");
+    expect(tree.parents.get("d")).toBe("b");
+  });
+
+  it("handles empty messages", () => {
+    const tree = buildTree([]);
+
+    expect(tree.roots).toEqual([]);
+    expect(tree.bySourceRef.size).toBe(0);
+    expect(tree.children.size).toBe(0);
+    expect(tree.parents.size).toBe(0);
+  });
+
+  it("handles a single message", () => {
+    const msgs: Message[] = [userMsg("only", "2024-01-01T00:00:00Z", "alone")];
+
+    const tree = buildTree(msgs);
+
+    expect(tree.roots).toEqual(["only"]);
+    expect(tree.parents.size).toBe(0);
+    expect(tree.children.size).toBe(0);
+    expect(tree.bySourceRef.get("only")).toEqual([msgs[0]]);
+  });
+
+  it("ignores parentMessageRef pointing to nonexistent message", () => {
+    const msgs: Message[] = [
+      userMsg("a", "2024-01-01T00:00:00Z", "hi", "nonexistent"),
+    ];
+
+    const tree = buildTree(msgs);
+
+    // "a" has an invalid parent, so it becomes a root
+    expect(tree.roots).toEqual(["a"]);
+    expect(tree.parents.size).toBe(0);
+  });
+
+  it("groups multiple messages with same sourceRef", () => {
+    const msgs: Message[] = [
+      assistantMsg("x", "2024-01-01T00:00:00Z", "text part"),
+      {
+        type: "tool_calls",
+        sourceRef: "x",
+        timestamp: "2024-01-01T00:00:00Z",
+        calls: [{ name: "Read", summary: "/foo" }],
+      },
+    ];
+
+    const tree = buildTree(msgs);
+
+    expect(tree.bySourceRef.get("x")?.length).toBe(2);
+    expect(tree.roots).toEqual(["x"]);
+  });
+});
+
+describe("findLatestLeaf", () => {
+  it("finds the leaf with the latest timestamp", () => {
+    const msgs: Message[] = [
+      userMsg("a", "2024-01-01T00:00:00Z", "root"),
+      assistantMsg("b", "2024-01-01T00:01:00Z", "reply", "a"),
+      userMsg("c", "2024-01-01T00:02:00Z", "early branch", "b"),
+      userMsg("d", "2024-01-01T00:05:00Z", "late branch", "b"),
+    ];
+
+    const tree = buildTree(msgs);
+    const leaf = findLatestLeaf(tree.bySourceRef, tree.children);
+
+    expect(leaf).toBe("d");
+  });
+
+  it("returns undefined for empty maps", () => {
+    const leaf = findLatestLeaf(new Map(), new Map());
+    expect(leaf).toBeUndefined();
+  });
+
+  it("returns the single node when there is only one", () => {
+    const msgs: Message[] = [userMsg("only", "2024-01-01T00:00:00Z", "alone")];
+
+    const tree = buildTree(msgs);
+    const leaf = findLatestLeaf(tree.bySourceRef, tree.children);
+
+    expect(leaf).toBe("only");
+  });
+
+  it("skips non-leaf nodes", () => {
+    const msgs: Message[] = [
+      userMsg("a", "2024-01-01T10:00:00Z", "root"),
+      // "a" has a later timestamp, but it's not a leaf
+      assistantMsg("b", "2024-01-01T00:01:00Z", "reply", "a"),
+    ];
+
+    const tree = buildTree(msgs);
+    const leaf = findLatestLeaf(tree.bySourceRef, tree.children);
+
+    expect(leaf).toBe("b");
+  });
+});
+
+describe("tracePath", () => {
+  it("traces a path from root to target", () => {
+    const parents = new Map([
+      ["c", "b"],
+      ["b", "a"],
+    ]);
+
+    expect(tracePath("c", parents)).toEqual(["a", "b", "c"]);
+  });
+
+  it("returns single element for a root", () => {
+    expect(tracePath("root", new Map())).toEqual(["root"]);
+  });
+
+  it("handles deep chains", () => {
+    const parents = new Map([
+      ["e", "d"],
+      ["d", "c"],
+      ["c", "b"],
+      ["b", "a"],
+    ]);
+
+    expect(tracePath("e", parents)).toEqual(["a", "b", "c", "d", "e"]);
+  });
+});
+
+describe("getFirstLine", () => {
+  it("returns first line of user message", () => {
+    const msg = userMsg("x", "2024-01-01T00:00:00Z", "first\nsecond\nthird");
+    expect(getFirstLine(msg)).toBe("first");
+  });
+
+  it("truncates long lines", () => {
+    const long = "a".repeat(100);
+    const msg = userMsg("x", "2024-01-01T00:00:00Z", long);
+    expect(getFirstLine(msg).length).toBe(63); // 60 + "..."
+    expect(getFirstLine(msg).endsWith("...")).toBe(true);
+  });
+
+  it("returns tool names for tool_calls", () => {
+    const msg: Message = {
+      type: "tool_calls",
+      sourceRef: "x",
+      timestamp: "2024-01-01T00:00:00Z",
+      calls: [
+        { name: "Read", summary: "/foo" },
+        { name: "Write", summary: "/bar" },
+      ],
+    };
+    expect(getFirstLine(msg)).toBe("Read, Write");
+  });
+
+  it("returns empty string for unknown type content", () => {
+    const msg = assistantMsg("x", "2024-01-01T00:00:00Z", "");
+    expect(getFirstLine(msg)).toBe("");
+  });
+
+  it("trims whitespace from first line", () => {
+    const msg = userMsg("x", "2024-01-01T00:00:00Z", "  padded  \nsecond");
+    expect(getFirstLine(msg)).toBe("padded");
+  });
+});

package/tsconfig.json

@@ -11,5 +11,5 @@
     "esModuleInterop": true,
     "resolveJsonModule": true
   },
-  "include": ["src/**/*"]
+  "include": ["src/**/*", "test/**/*"]
 }

package/src/cache.ts

@@ -1,129 +0,0 @@
-/**
- * Cache module for agent-transcripts.
- *
- * Stores derived content (rendered outputs, titles) keyed by source path,
- * invalidated by content hash. Cache lives at ~/.cache/agent-transcripts/.
- */
-
-import { join } from "path";
-import { homedir } from "os";
-import { mkdir, rename, unlink } from "fs/promises";
-
-const CACHE_DIR = join(homedir(), ".cache", "agent-transcripts");
-
-export interface SegmentCache {
-  title?: string;
-  html?: string;
-  md?: string;
-}
-
-export interface CacheEntry {
-  contentHash: string;
-  segments: SegmentCache[];
-}
-
-/**
- * Compute a hash of file content for cache invalidation.
- */
-export function computeContentHash(content: string): string {
-  return Bun.hash(content).toString(16);
-}
-
-/**
- * Get the cache file path for a source file.
- * Uses hash of source path to avoid filesystem issues with special chars.
- */
-function getCachePath(sourcePath: string): string {
-  const pathHash = Bun.hash(sourcePath).toString(16);
-  return join(CACHE_DIR, `${pathHash}.json`);
-}
-
-/**
- * Ensure cache directory exists.
- */
-async function ensureCacheDir(): Promise<void> {
-  await mkdir(CACHE_DIR, { recursive: true, mode: 0o755 });
-}
-
-/**
- * Load cache entry for a source file.
- * Returns undefined if no cache exists or cache is corrupt.
- */
-export async function loadCache(
-  sourcePath: string,
-): Promise<CacheEntry | undefined> {
-  const cachePath = getCachePath(sourcePath);
-  try {
-    const content = await Bun.file(cachePath).text();
-    return JSON.parse(content) as CacheEntry;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Save cache entry for a source file.
- * Uses atomic write (temp file + rename) to prevent corruption.
- */
-export async function saveCache(
-  sourcePath: string,
-  entry: CacheEntry,
-): Promise<void> {
-  await ensureCacheDir();
-
-  const cachePath = getCachePath(sourcePath);
-  const tmpPath = `${cachePath}.${process.pid}.${Date.now()}.tmp`;
-
-  const content = JSON.stringify(entry, null, 2) + "\n";
-  await Bun.write(tmpPath, content);
-
-  try {
-    await rename(tmpPath, cachePath);
-  } catch (err) {
-    try {
-      await unlink(tmpPath);
-    } catch {
-      // Ignore cleanup errors
-    }
-    throw err;
-  }
-}
-
-/**
- * Check if cache is valid for the given content hash and format.
- * Returns the cached segments if valid, undefined otherwise.
- */
-export function getCachedSegments(
-  cached: CacheEntry | undefined,
-  contentHash: string,
-  format: "html" | "md",
-): SegmentCache[] | undefined {
-  if (!cached || cached.contentHash !== contentHash) {
-    return undefined;
-  }
-  // Check that all segments have the requested format
-  if (cached.segments.length === 0) {
-    return undefined;
-  }
-  for (const seg of cached.segments) {
-    if (!seg[format]) {
-      return undefined;
-    }
-  }
-  return cached.segments;
-}
-
-/**
- * Get cached title for a specific segment.
- * Returns undefined if cache is invalid or title not present.
- */
-export function getCachedTitle(
-  cached: CacheEntry | undefined,
-  contentHash: string,
-  segmentIndex: number,
-): string | undefined {
-  if (!cached || cached.contentHash !== contentHash) {
-    return undefined;
-  }
-  return cached.segments[segmentIndex]?.title;
-}

package/src/sync.ts

@@ -1,295 +0,0 @@
-/**
- * Sync command: batch export sessions to transcripts.
- *
- * Discovers session files in source directory, parses them,
- * and writes rendered output (markdown or HTML) to output directory.
- * Tracks provenance via transcripts.json index.
- */
-
-import { dirname, join } from "path";
-import { mkdir } from "fs/promises";
-import { existsSync } from "fs";
-import { getAdapters } from "./adapters/index.ts";
-import type { Adapter, DiscoveredSession, Transcript } from "./types.ts";
-import { renderTranscript } from "./render.ts";
-import { renderTranscriptHtml } from "./render-html.ts";
-import { renderIndex } from "./render-index.ts";
-import { generateOutputName, extractSessionId } from "./utils/naming.ts";
-import {
-  loadIndex,
-  saveIndex,
-  setEntry,
-  removeEntriesForSource,
-  restoreEntries,
-  deleteOutputFiles,
-  normalizeSourcePath,
-  extractFirstUserMessage,
-  getOutputsForSource,
-  type TranscriptsIndex,
-} from "./utils/provenance.ts";
-import { generateTitles } from "./title.ts";
-import {
-  computeContentHash,
-  loadCache,
-  saveCache,
-  getCachedSegments,
-  type CacheEntry,
-  type SegmentCache,
-} from "./cache.ts";
-
-export type OutputFormat = "md" | "html";
-
-export interface SyncOptions {
-  source: string;
-  output: string;
-  format?: OutputFormat;
-  noTitle?: boolean;
-  force?: boolean;
-  quiet?: boolean;
-}
-
-export interface SyncResult {
-  synced: number;
-  skipped: number;
-  errors: number;
-}
-
-interface SessionFile extends DiscoveredSession {
-  adapter: Adapter;
-}
-
-/**
- * Render a transcript to the specified format.
- */
-function renderToFormat(
-  transcript: Transcript,
-  format: OutputFormat,
-  options: { sourcePath?: string; title?: string },
-): Promise<string> {
-  if (format === "html") {
-    return renderTranscriptHtml(transcript, { title: options.title });
-  }
-  return Promise.resolve(
-    renderTranscript(transcript, { sourcePath: options.sourcePath }),
-  );
-}
-
-/**
- * Generate index.html for HTML output.
- */
-async function writeIndexHtml(
-  outputDir: string,
-  index: TranscriptsIndex,
-  quiet: boolean,
-): Promise<void> {
-  const indexHtml = renderIndex(index);
-  const indexPath = join(outputDir, "index.html");
-  await Bun.write(indexPath, indexHtml);
-  if (!quiet) {
-    console.error(`Generated: ${indexPath}`);
-  }
-}
-
-/**
- * Sync session files from source to output directory.
- */
-export async function sync(options: SyncOptions): Promise<SyncResult> {
-  const {
-    source,
-    output,
-    format = "md",
-    noTitle = false,
-    force = false,
-    quiet = false,
-  } = options;
-
-  const ext = format === "html" ? ".html" : ".md";
-  const result: SyncResult = { synced: 0, skipped: 0, errors: 0 };
-
-  // Ensure output directory exists
-  await mkdir(output, { recursive: true });
-
-  // Load index
-  const index = await loadIndex(output);
-  if (!quiet && Object.keys(index.entries).length > 0) {
-    console.error(
-      `Found ${Object.keys(index.entries).length} existing transcript(s) in index`,
-    );
-  }
-
-  // Discover sessions from all adapters
-  const sessions: SessionFile[] = [];
-  for (const adapter of getAdapters()) {
-    const discovered = await adapter.discover(source);
-    for (const session of discovered) {
-      sessions.push({ ...session, adapter });
-    }
-  }
-
-  if (!quiet) {
-    console.error(`Found ${sessions.length} session file(s)`);
-  }
-
-  // Process each session
-  for (const session of sessions) {
-    // Normalize source path for consistent index keys
-    const sourcePath = normalizeSourcePath(session.path);
-
-    try {
-      // Read source and compute content hash
-      const content = await Bun.file(session.path).text();
-      const contentHash = computeContentHash(content);
-
-      // Check cache
-      const cached = await loadCache(sourcePath);
-      const cachedSegments = getCachedSegments(cached, contentHash, format);
-
-      // Check if we can use cached output
-      const existingOutputs = getOutputsForSource(index, sourcePath);
-      const outputsExist =
-        existingOutputs.length > 0 &&
-        existingOutputs.every((f) => existsSync(join(output, f)));
-
-      if (!force && cachedSegments && outputsExist) {
-        // Cache hit and outputs exist - skip
-        if (!quiet) {
-          console.error(`Skip (up to date): ${session.relativePath}`);
-        }
-        result.skipped++;
-        continue;
-      }
-
-      // Need to sync: either cache miss, content changed, or force
-      // Parse the source
-      const transcripts = session.adapter.parse(content, session.path);
-
-      // Remove entries from index (save for potential restoration on error)
-      const removedEntries = removeEntriesForSource(index, sourcePath);
-
-      // Track new outputs for this session
-      const newOutputs: string[] = [];
-      const sessionId = extractSessionId(session.path);
-
-      // Build new cache entry
-      const newCache: CacheEntry = {
-        contentHash,
-        segments: [],
-      };
-
-      try {
-        // Generate fresh outputs for all transcripts
-        for (let i = 0; i < transcripts.length; i++) {
-          const transcript = transcripts[i];
-          const segmentIndex = transcripts.length > 1 ? i + 1 : undefined;
-
-          // Extract first user message
-          const firstUserMessage = extractFirstUserMessage(transcript);
-
-          // Generate deterministic name
-          const baseName = generateOutputName(transcript, session.path);
-          const suffix = segmentIndex ? `_${segmentIndex}` : "";
-          const relativeDir = dirname(session.relativePath);
-          const relativePath =
-            relativeDir === "."
-              ? `${baseName}${suffix}${ext}`
-              : join(relativeDir, `${baseName}${suffix}${ext}`);
-          const outputPath = join(output, relativePath);
-
-          // Ensure output directory exists
-          await mkdir(dirname(outputPath), { recursive: true });
-
-          // Use title from: (1) harness-provided summary, (2) cache, (3) LLM later
-          const title =
-            session.summary ||
-            (cached?.contentHash === contentHash
-              ? cached.segments[i]?.title
-              : undefined);
-
-          // Render and write
-          const rendered = await renderToFormat(transcript, format, {
-            sourcePath,
-            title,
-          });
-          await Bun.write(outputPath, rendered);
-          newOutputs.push(relativePath);
-
-          // Build segment cache
-          const segmentCache: SegmentCache = { title };
-          segmentCache[format] = rendered;
-          newCache.segments.push(segmentCache);
-
-          // Update index
-          setEntry(index, relativePath, {
-            source: sourcePath,
-            sessionId,
-            segmentIndex,
-            syncedAt: new Date().toISOString(),
-            firstUserMessage,
-            title,
-            messageCount: transcript.metadata.messageCount,
-            startTime: transcript.metadata.startTime,
-            endTime: transcript.metadata.endTime,
-            cwd: transcript.metadata.cwd,
-          });
-
-          if (!quiet) {
-            console.error(`Synced: ${outputPath}`);
-          }
-        }
-
-        // Save cache
-        await saveCache(sourcePath, newCache);
-
-        // Success: delete old output files (after new ones are written)
-        const oldFilenames = removedEntries.map((e) => e.filename);
-        // Only delete files that aren't being reused
-        const toDelete = oldFilenames.filter((f) => !newOutputs.includes(f));
-        if (toDelete.length > 0) {
-          await deleteOutputFiles(output, toDelete, quiet);
-        }
-
-        result.synced++;
-      } catch (error) {
-        // Clean up any newly written files before restoring old entries
-        if (newOutputs.length > 0) {
-          await deleteOutputFiles(output, newOutputs, quiet);
-        }
-        // Restore old entries on error to preserve provenance
-        restoreEntries(index, removedEntries);
-        throw error;
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error(`Error: ${session.relativePath}: ${message}`);
-      result.errors++;
-    }
-  }
-
-  // Save index
-  await saveIndex(output, index);
-
-  // Generate titles for HTML format (unless --no-title)
-  if (format === "html" && !noTitle) {
-    if (!quiet) {
-      console.error("\nGenerating titles...");
-    }
-    await generateTitles({ outputDir: output, quiet });
-
-    // Reload index after title generation and regenerate index.html
-    const updatedIndex = await loadIndex(output);
-    await writeIndexHtml(output, updatedIndex, quiet);
-  } else if (format === "html") {
-    // Generate index.html without titles
-    const updatedIndex = await loadIndex(output);
-    await writeIndexHtml(output, updatedIndex, quiet);
-  }
-
-  // Summary
-  if (!quiet) {
-    console.error(
-      `\nSync complete: ${result.synced} synced, ${result.skipped} skipped, ${result.errors} errors`,
-    );
-  }
-
-  return result;
-}