@arcreflex/agent-transcripts 0.1.10 → 0.1.12

package/src/render.ts

@@ -3,16 +3,8 @@
  */
 
 import type { Transcript, Message, ToolCall } from "./types.ts";
-import {
-  buildTree,
-  findLatestLeaf,
-  tracePath,
-  getFirstLine,
-} from "./utils/tree.ts";
+import { walkTranscriptTree } from "./utils/tree.ts";
 
-/**
- * Format a single tool call.
- */
 function formatToolCall(call: ToolCall): string {
   if (call.summary) {
     return `${call.name} \`${call.summary}\``;
@@ -20,9 +12,6 @@ function formatToolCall(call: ToolCall): string {
   return call.name;
 }
 
-/**
- * Format tool calls group.
- */
 function formatToolCalls(calls: ToolCall[]): string {
   if (calls.length === 1) {
     return `**Tool**: ${formatToolCall(calls[0])}`;
@@ -30,9 +19,6 @@ function formatToolCalls(calls: ToolCall[]): string {
   return `**Tools**:\n${calls.map((c) => `- ${formatToolCall(c)}`).join("\n")}`;
 }
 
-/**
- * Render a message to markdown.
- */
 function renderMessage(msg: Message): string {
   switch (msg.type) {
     case "user":
@@ -76,17 +62,11 @@ export interface RenderTranscriptOptions {
   sourcePath?: string; // absolute source path for front matter provenance
 }
 
-/**
- * Render transcript to markdown with branch awareness.
- */
 export function renderTranscript(
   transcript: Transcript,
-  options: RenderTranscriptOptions | string = {},
+  options: RenderTranscriptOptions = {},
 ): string {
-  // Support legacy signature: renderTranscript(transcript, head?: string)
-  const opts: RenderTranscriptOptions =
-    typeof options === "string" ? { head: options } : options;
-  const { head, sourcePath } = opts;
+  const { head, sourcePath } = options;
 
   const lines: string[] = [];
 
@@ -116,76 +96,33 @@ export function renderTranscript(
   lines.push("");
   lines.push("---");
 
-  // Handle empty transcripts
-  if (transcript.messages.length === 0) {
-    return lines.join("\n");
-  }
-
-  // Build tree
-  const { bySourceRef, children, parents, roots } = buildTree(
-    transcript.messages,
-  );
-
-  // Determine target (head or latest leaf)
-  let target: string | undefined;
-  if (head) {
-    if (!bySourceRef.has(head)) {
-      lines.push("");
-      lines.push(`**Error**: Message ID \`${head}\` not found`);
-      return lines.join("\n");
-    }
-    target = head;
-  } else {
-    target = findLatestLeaf(bySourceRef, children);
-  }
+  for (const event of walkTranscriptTree(transcript, { head })) {
+    switch (event.type) {
+      case "empty":
+        break;
 
-  if (!target) {
-    // Fallback: just render all messages in order (shouldn't happen normally)
-    for (const msg of transcript.messages) {
-      const rendered = renderMessage(msg);
-      if (rendered) {
+      case "head_not_found":
         lines.push("");
-        lines.push(rendered);
-      }
-    }
-    return lines.join("\n");
-  }
-
-  // Trace path from root to target
-  const path = tracePath(target, parents);
-  const pathSet = new Set(path);
-
-  // Render messages along the path
-  for (const sourceRef of path) {
-    const msgs = bySourceRef.get(sourceRef);
-    if (!msgs) continue;
+        lines.push(`**Error**: Message ID \`${event.head}\` not found`);
+        break;
+
+      case "messages":
+        for (const msg of event.messages) {
+          const rendered = renderMessage(msg);
+          if (rendered) {
+            lines.push("");
+            lines.push(rendered);
+          }
+        }
+        break;
 
-    // Render all messages from this source
-    for (const msg of msgs) {
-      const rendered = renderMessage(msg);
-      if (rendered) {
+      case "branch_note":
         lines.push("");
-        lines.push(rendered);
-      }
-    }
-
-    // Check for other branches at this point (only if not using explicit --head)
-    if (!head) {
-      const childSet = children.get(sourceRef);
-      if (childSet && childSet.size > 1) {
-        const otherBranches = [...childSet].filter((c) => !pathSet.has(c));
-        if (otherBranches.length > 0) {
-          lines.push("");
-          lines.push("> **Other branches**:");
-          for (const branchRef of otherBranches) {
-            const branchMsgs = bySourceRef.get(branchRef);
-            if (branchMsgs && branchMsgs.length > 0) {
-              const firstLine = getFirstLine(branchMsgs[0]);
-              lines.push(`> - \`${branchRef}\` "${firstLine}"`);
-            }
-          }
+        lines.push("> **Other branches**:");
+        for (const branch of event.branches) {
+          lines.push(`> - \`${branch.sourceRef}\` "${branch.firstLine}"`);
         }
-      }
+        break;
     }
   }
 

package/src/serve.ts

@@ -1,211 +1,146 @@
 /**
- * Serve command: dynamic HTTP server for transcripts.
+ * Serve command: HTTP server for transcripts from the archive.
  *
- * Serves transcripts directly from source files, using the cache
- * for rendered HTML and titles. No output directory needed.
+ * Reads archive entries, renders HTML on demand with in-memory LRU cache.
  */
 
-import { getAdapters } from "./adapters/index.ts";
-import type { Adapter, DiscoveredSession, Transcript } from "./types.ts";
+import type { ArchiveEntryHeader, TranscriptSummary } from "./archive.ts";
+import { listEntryHeaders, loadEntry, DEFAULT_ARCHIVE_DIR } from "./archive.ts";
 import { renderTranscriptHtml } from "./render-html.ts";
 import { renderIndexFromSessions, type SessionEntry } from "./render-index.ts";
-import { generateOutputName } from "./utils/naming.ts";
-import { extractFirstUserMessage } from "./utils/provenance.ts";
-import {
-  computeContentHash,
-  loadCache,
-  saveCache,
-  getCachedSegments,
-  type CacheEntry,
-} from "./cache.ts";
+import { formatDateTimePrefix } from "./utils/naming.ts";
 
 export interface ServeOptions {
-  source: string;
+  archiveDir?: string;
   port?: number;
   quiet?: boolean;
-  noCache?: boolean;
 }
 
 interface SessionInfo {
-  source: DiscoveredSession;
-  adapter: Adapter;
-  baseName: string; // e.g., "2024-01-15-1423-sessionid"
-  segmentIndex: number; // 0-indexed segment within multi-transcript source
+  sessionId: string;
+  sourceHash: string;
+  title?: string;
+  segment: TranscriptSummary;
+  segmentIndex: number;
+  baseName: string;
 }
 
-/**
- * Discover sessions and build URL mapping.
- * Returns map of baseName → session info.
- */
-async function discoverSessions(
-  sourceDir: string,
-): Promise<Map<string, SessionInfo[]>> {
-  const sessions = new Map<string, SessionInfo[]>();
-
-  for (const adapter of getAdapters()) {
-    const discovered = await adapter.discover(sourceDir);
-    for (const source of discovered) {
-      // Parse to get transcript info for naming
-      // We need to parse once to determine the output name
-      const content = await Bun.file(source.path).text();
-      const transcripts = adapter.parse(content, source.path);
-
-      for (let i = 0; i < transcripts.length; i++) {
-        const transcript = transcripts[i];
-        const baseName = generateOutputName(transcript, source.path);
-        const suffix = transcripts.length > 1 ? `_${i + 1}` : "";
-        const fullName = `${baseName}${suffix}`;
-
-        const info: SessionInfo = {
-          source,
-          adapter,
-          baseName: fullName,
-          segmentIndex: i,
-        };
-
-        // Store by baseName for lookup
-        const existing = sessions.get(fullName) || [];
-        existing.push(info);
-        sessions.set(fullName, existing);
-      }
-    }
-  }
+/** Simple LRU cache for rendered HTML. */
+class HtmlCache {
+  private map = new Map<string, string>();
+  constructor(private maxSize: number) {}
 
-  return sessions;
-}
-
-/**
- * Get or render HTML for a session.
- * Uses cache if available and content unchanged (unless noCache is true).
- */
-async function getSessionHtml(
-  session: SessionInfo,
-  segmentIndex: number,
-  noCache = false,
-): Promise<{
-  html: string;
-  transcript: Transcript;
-  contentHash: string;
-} | null> {
-  const content = await Bun.file(session.source.path).text();
-  const contentHash = computeContentHash(content);
-
-  // Parse first to validate segment index
-  const transcripts = session.adapter.parse(content, session.source.path);
-  if (segmentIndex < 0 || segmentIndex >= transcripts.length) {
-    return null;
+  private key(sessionId: string, segmentIndex: number, sourceHash: string) {
+    return `${sessionId}:${segmentIndex}:${sourceHash}`;
   }
-  const transcript = transcripts[segmentIndex];
-
-  // Check cache (unless bypassing for dev)
-  const cached = await loadCache(session.source.path);
-  if (!noCache) {
-    const cachedSegments = getCachedSegments(cached, contentHash, "html");
-    const cachedHtml = cachedSegments?.[segmentIndex]?.html;
-    if (cachedHtml) {
-      return { html: cachedHtml, transcript, contentHash };
+
+  get(
+    sessionId: string,
+    segmentIndex: number,
+    sourceHash: string,
+  ): string | undefined {
+    const k = this.key(sessionId, segmentIndex, sourceHash);
+    const val = this.map.get(k);
+    if (val !== undefined) {
+      // Move to end (most recently used)
+      this.map.delete(k);
+      this.map.set(k, val);
     }
+    return val;
   }
 
-  // Still use cached title if available
-  const title =
-    cached?.contentHash === contentHash
-      ? cached.segments[segmentIndex]?.title
-      : undefined;
-
-  const html = await renderTranscriptHtml(transcript, { title });
-
-  // Update cache (even in noCache mode, for titles)
-  if (!noCache) {
-    // Deep copy segments to avoid mutating cached objects
-    const newCache: CacheEntry = {
-      contentHash,
-      segments:
-        cached?.contentHash === contentHash
-          ? cached.segments.map((s) => ({ ...s }))
-          : [],
-    };
-    while (newCache.segments.length <= segmentIndex) {
-      newCache.segments.push({});
+  set(
+    sessionId: string,
+    segmentIndex: number,
+    sourceHash: string,
+    html: string,
+  ) {
+    const k = this.key(sessionId, segmentIndex, sourceHash);
+    this.map.delete(k);
+    this.map.set(k, html);
+    if (this.map.size > this.maxSize) {
+      // Evict oldest
+      const oldest = this.map.keys().next().value!;
+      this.map.delete(oldest);
     }
-    newCache.segments[segmentIndex].html = html;
-    if (title) {
-      newCache.segments[segmentIndex].title = title;
+  }
+}
+
+function buildSessionMap(
+  headers: ArchiveEntryHeader[],
+): Map<string, SessionInfo> {
+  const sessions = new Map<string, SessionInfo>();
+
+  for (const header of headers) {
+    for (let i = 0; i < header.segments.length; i++) {
+      const segment = header.segments[i];
+      const dateTime = formatDateTimePrefix(segment.firstMessageTimestamp);
+      const baseName = `${dateTime}-${header.sessionId}`;
+      const suffix = header.segments.length > 1 ? `_${i + 1}` : "";
+      const fullName = `${baseName}${suffix}`;
+
+      sessions.set(fullName, {
+        sessionId: header.sessionId,
+        sourceHash: header.sourceHash,
+        title: header.title,
+        segment,
+        segmentIndex: i,
+        baseName: fullName,
+      });
     }
-    await saveCache(session.source.path, newCache);
   }
 
-  return { html, transcript, contentHash };
+  return sessions;
 }
 
-/**
- * Build session entries for index page.
- */
-async function buildIndexEntries(
-  sessions: Map<string, SessionInfo[]>,
-): Promise<SessionEntry[]> {
+function buildIndexEntries(sessions: Map<string, SessionInfo>): SessionEntry[] {
   const entries: SessionEntry[] = [];
 
-  for (const [baseName, infos] of sessions) {
-    for (const info of infos) {
-      const { segmentIndex } = info;
-
-      try {
-        const content = await Bun.file(info.source.path).text();
-        const contentHash = computeContentHash(content);
-        const transcripts = info.adapter.parse(content, info.source.path);
-        const transcript = transcripts[segmentIndex];
-
-        if (!transcript) continue;
-
-        // Get cached title
-        const cached = await loadCache(info.source.path);
-        const title =
-          cached?.contentHash === contentHash
-            ? cached.segments[segmentIndex]?.title
-            : undefined;
-
-        const firstUserMessage = extractFirstUserMessage(transcript);
-        const { messageCount, startTime, endTime, cwd } = transcript.metadata;
-
-        entries.push({
-          filename: `${baseName}.html`,
-          title:
-            title ||
-            (firstUserMessage.length > 80
-              ? firstUserMessage.slice(0, 80) + "..."
-              : firstUserMessage) ||
-            baseName,
-          firstUserMessage,
-          date: startTime,
-          endDate: endTime,
-          messageCount,
-          cwd,
-        });
-      } catch {
-        // Skip sessions that fail to parse
-      }
-    }
+  for (const [baseName, info] of sessions) {
+    const { segment, title } = 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,
+      firstUserMessage: segment.firstUserMessage,
+      date: startTime,
+      endDate: endTime,
+      messageCount,
+      cwd,
+    });
   }
 
   return entries;
 }
 
-/**
- * Start the HTTP server.
- */
 export async function serve(options: ServeOptions): Promise<void> {
-  const { source, port = 3000, quiet = false, noCache = false } = options;
+  const {
+    archiveDir = DEFAULT_ARCHIVE_DIR,
+    port = 3000,
+    quiet = false,
+  } = options;
 
   if (!quiet) {
-    console.error(`Discovering sessions in ${source}...`);
+    console.error(`Loading archive from ${archiveDir}...`);
   }
 
-  // Discover sessions on startup
-  const sessions = await discoverSessions(source);
+  const headers = await listEntryHeaders(archiveDir);
+  const sessions = buildSessionMap(headers);
+  const htmlCache = new HtmlCache(200);
+
+  // Index is static (session map doesn't change), so build once
+  const indexHtml = renderIndexFromSessions(buildIndexEntries(sessions));
 
   if (!quiet) {
-    console.error(`Found ${sessions.size} session(s)`);
+    console.error(`Found ${sessions.size} transcript(s)`);
     console.error(`Starting server at http://localhost:${port}`);
   }
 
@@ -215,38 +150,43 @@ export async function serve(options: ServeOptions): Promise<void> {
       const url = new URL(req.url);
       const path = url.pathname;
 
-      // Log request
       if (!quiet) {
         console.error(`${req.method} ${path}`);
       }
 
       // Index page
       if (path === "/" || path === "/index.html") {
-        const entries = await buildIndexEntries(sessions);
-        const html = renderIndexFromSessions(entries);
-        return new Response(html, {
+        return new Response(indexHtml, {
           headers: { "Content-Type": "text/html; charset=utf-8" },
         });
       }
 
       // Session page
       if (path.endsWith(".html")) {
-        const baseName = path.slice(1, -5); // Remove leading "/" and ".html"
+        const baseName = path.slice(1, -5);
+        const info = sessions.get(baseName);
 
-        // First try exact match
-        const exactInfos = sessions.get(baseName);
-        if (exactInfos && exactInfos.length > 0) {
+        if (info) {
           try {
-            const info = exactInfos[0];
-            const result = await getSessionHtml(
-              info,
-              info.segmentIndex,
-              noCache,
-            );
-            if (!result) {
+            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 });
             }
-            return new Response(result.html, {
+
+            const html = await renderTranscriptHtml(transcript, { title });
+            htmlCache.set(sessionId, segmentIndex, sourceHash, html);
+            return new Response(html, {
               headers: { "Content-Type": "text/html; charset=utf-8" },
             });
           } catch (error) {
@@ -256,35 +196,6 @@ export async function serve(options: ServeOptions): Promise<void> {
           }
         }
 
-        // Fallback: parse segment suffix (e.g., "name_2" → base "name" + segment 1)
-        // Handles case where URL has suffix but session was stored without it
-        const segmentMatch = baseName.match(/^(.+)_(\d+)$/);
-        if (segmentMatch) {
-          const lookupName = segmentMatch[1];
-          const segmentIndex = parseInt(segmentMatch[2], 10) - 1;
-          const infos = sessions.get(lookupName);
-          if (infos && infos.length > 0 && segmentIndex >= 0) {
-            try {
-              const result = await getSessionHtml(
-                infos[0],
-                segmentIndex,
-                noCache,
-              );
-              if (!result) {
-                return new Response("Not Found", { status: 404 });
-              }
-              const { html } = result;
-              return new Response(html, {
-                headers: { "Content-Type": "text/html; charset=utf-8" },
-              });
-            } catch (error) {
-              const message =
-                error instanceof Error ? error.message : String(error);
-              return new Response(`Error: ${message}`, { status: 500 });
-            }
-          }
-        }
-
         return new Response("Not Found", { status: 404 });
       }
 
@@ -292,12 +203,10 @@ export async function serve(options: ServeOptions): Promise<void> {
     },
   });
 
-  // Keep server running
   if (!quiet) {
     console.error(`\nPress Ctrl+C to stop`);
   }
 
-  // Handle shutdown gracefully
   process.on("SIGINT", () => {
     if (!quiet) {
       console.error("\nShutting down...");