@arcreflex/agent-transcripts 0.1.8 → 0.1.9

package/src/render.ts

@@ -3,6 +3,12 @@
  */
 
 import type { Transcript, Message, ToolCall } from "./types.ts";
+import {
+  buildTree,
+  findLatestLeaf,
+  tracePath,
+  getFirstLine,
+} from "./utils/tree.ts";
 
 /**
  * Format a single tool call.
@@ -65,116 +71,6 @@ ${msg.thinking}
   }
 }
 
-/**
- * Get first line of message content for branch reference.
- */
-function getFirstLine(msg: Message): string {
-  let text: string;
-  switch (msg.type) {
-    case "user":
-    case "assistant":
-    case "system":
-    case "error":
-      text = msg.content;
-      break;
-    case "tool_calls":
-      text = msg.calls.map((c) => c.name).join(", ");
-      break;
-    default:
-      text = "";
-  }
-  const firstLine = text.split("\n")[0].trim();
-  const maxLen = 60;
-  return firstLine.length > maxLen
-    ? firstLine.slice(0, maxLen) + "..."
-    : firstLine;
-}
-
-/**
- * Build tree structure from messages.
- * Returns maps for navigation and the messages grouped by sourceRef.
- */
-function buildTree(messages: Message[]): {
-  bySourceRef: Map<string, Message[]>;
-  children: Map<string, Set<string>>;
-  parents: Map<string, string>;
-  roots: string[];
-} {
-  // Group messages by sourceRef
-  const bySourceRef = new Map<string, Message[]>();
-  for (const msg of messages) {
-    const existing = bySourceRef.get(msg.sourceRef) || [];
-    existing.push(msg);
-    bySourceRef.set(msg.sourceRef, existing);
-  }
-
-  // Build parent → children map (at sourceRef level)
-  const children = new Map<string, Set<string>>();
-  const parents = new Map<string, string>();
-
-  for (const msg of messages) {
-    if (msg.parentMessageRef && bySourceRef.has(msg.parentMessageRef)) {
-      parents.set(msg.sourceRef, msg.parentMessageRef);
-      const existing = children.get(msg.parentMessageRef) || new Set();
-      existing.add(msg.sourceRef);
-      children.set(msg.parentMessageRef, existing);
-    }
-  }
-
-  // Find roots (no parent in our set)
-  const roots: string[] = [];
-  for (const sourceRef of bySourceRef.keys()) {
-    if (!parents.has(sourceRef)) {
-      roots.push(sourceRef);
-    }
-  }
-
-  return { bySourceRef, children, parents, roots };
-}
-
-/**
- * Find the latest leaf in the tree (for primary branch).
- */
-function findLatestLeaf(
-  bySourceRef: Map<string, Message[]>,
-  children: Map<string, Set<string>>,
-): string | undefined {
-  let latestLeaf: string | undefined;
-  let latestTime = 0;
-
-  for (const sourceRef of bySourceRef.keys()) {
-    const childSet = children.get(sourceRef);
-    if (!childSet || childSet.size === 0) {
-      // It's a leaf
-      const msgs = bySourceRef.get(sourceRef);
-      if (msgs && msgs.length > 0) {
-        const time = new Date(msgs[0].timestamp).getTime();
-        if (time > latestTime) {
-          latestTime = time;
-          latestLeaf = sourceRef;
-        }
-      }
-    }
-  }
-
-  return latestLeaf;
-}
-
-/**
- * Trace path from root to target.
- */
-function tracePath(target: string, parents: Map<string, string>): string[] {
-  const path: string[] = [];
-  let current: string | undefined = target;
-
-  while (current) {
-    path.unshift(current);
-    current = parents.get(current);
-  }
-
-  return path;
-}
-
 export interface RenderTranscriptOptions {
   head?: string; // render branch ending at this message ID
   sourcePath?: string; // absolute source path for front matter provenance

package/src/serve.ts

@@ -0,0 +1,308 @@
+/**
+ * Serve command: dynamic HTTP server for transcripts.
+ *
+ * Serves transcripts directly from source files, using the cache
+ * for rendered HTML and titles. No output directory needed.
+ */
+
+import { getAdapters } from "./adapters/index.ts";
+import type { Adapter, DiscoveredSession, Transcript } from "./types.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";
+
+export interface ServeOptions {
+  source: 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
+}
+
+/**
+ * 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);
+      }
+    }
+  }
+
+  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;
+  }
+  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 };
+    }
+  }
+
+  // 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({});
+    }
+    newCache.segments[segmentIndex].html = html;
+    if (title) {
+      newCache.segments[segmentIndex].title = title;
+    }
+    await saveCache(session.source.path, newCache);
+  }
+
+  return { html, transcript, contentHash };
+}
+
+/**
+ * Build session entries for index page.
+ */
+async function buildIndexEntries(
+  sessions: Map<string, SessionInfo[]>,
+): Promise<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
+      }
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Start the HTTP server.
+ */
+export async function serve(options: ServeOptions): Promise<void> {
+  const { source, port = 3000, quiet = false, noCache = false } = options;
+
+  if (!quiet) {
+    console.error(`Discovering sessions in ${source}...`);
+  }
+
+  // Discover sessions on startup
+  const sessions = await discoverSessions(source);
+
+  if (!quiet) {
+    console.error(`Found ${sessions.size} session(s)`);
+    console.error(`Starting server at http://localhost:${port}`);
+  }
+
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      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, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+
+      // Session page
+      if (path.endsWith(".html")) {
+        const baseName = path.slice(1, -5); // Remove leading "/" and ".html"
+
+        // First try exact match
+        const exactInfos = sessions.get(baseName);
+        if (exactInfos && exactInfos.length > 0) {
+          try {
+            const info = exactInfos[0];
+            const result = await getSessionHtml(
+              info,
+              info.segmentIndex,
+              noCache,
+            );
+            if (!result) {
+              return new Response("Not Found", { status: 404 });
+            }
+            return new Response(result.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 });
+          }
+        }
+
+        // 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 });
+      }
+
+      return new Response("Not Found", { status: 404 });
+    },
+  });
+
+  // Keep server running
+  if (!quiet) {
+    console.error(`\nPress Ctrl+C to stop`);
+  }
+
+  // Handle shutdown gracefully
+  process.on("SIGINT", () => {
+    if (!quiet) {
+      console.error("\nShutting down...");
+    }
+    server.stop();
+    process.exit(0);
+  });
+}

package/src/sync.ts

@@ -1,31 +1,49 @@
 /**
- * Sync command: batch export sessions to markdown transcripts.
+ * Sync command: batch export sessions to transcripts.
  *
  * Discovers session files in source directory, parses them,
- * and writes rendered markdown to output directory.
+ * 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 } from "./types.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,
-  isStale,
   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;
 }
@@ -40,12 +58,52 @@ 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, force = false, quiet = false } = options;
+  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
@@ -78,16 +136,22 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
     const sourcePath = normalizeSourcePath(session.path);
 
     try {
-      // Read and parse using the adapter that discovered this file
+      // Read source and compute content hash
       const content = await Bun.file(session.path).text();
-      const transcripts = session.adapter.parse(content, session.path);
+      const contentHash = computeContentHash(content);
+
+      // Check cache
+      const cached = await loadCache(sourcePath);
+      const cachedSegments = getCachedSegments(cached, contentHash, format);
 
-      // Check if sync needed (force or stale)
-      const needsUpdate =
-        force ||
-        isStale(index, sourcePath, session.mtime, transcripts.length, output);
+      // 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 (!needsUpdate) {
+      if (!force && cachedSegments && outputsExist) {
+        // Cache hit and outputs exist - skip
         if (!quiet) {
           console.error(`Skip (up to date): ${session.relativePath}`);
         }
@@ -95,6 +159,10 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
         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);
 
@@ -102,39 +170,65 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
       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}.md`
-              : join(relativeDir, `${baseName}${suffix}.md`);
+              ? `${baseName}${suffix}${ext}`
+              : join(relativeDir, `${baseName}${suffix}${ext}`);
           const outputPath = join(output, relativePath);
 
           // Ensure output directory exists
           await mkdir(dirname(outputPath), { recursive: true });
 
-          // Render with provenance front matter and write
-          const markdown = renderTranscript(transcript, {
+          // Preserve title from cache if content unchanged
+          const cachedTitle =
+            cached?.contentHash === contentHash
+              ? cached.segments[i]?.title
+              : undefined;
+
+          // Render and write
+          const rendered = await renderToFormat(transcript, format, {
             sourcePath,
+            title: cachedTitle,
           });
-          await Bun.write(outputPath, markdown);
+          await Bun.write(outputPath, rendered);
           newOutputs.push(relativePath);
 
+          // Build segment cache
+          const segmentCache: SegmentCache = { title: cachedTitle };
+          segmentCache[format] = rendered;
+          newCache.segments.push(segmentCache);
+
           // Update index
           setEntry(index, relativePath, {
             source: sourcePath,
-            sourceMtime: session.mtime,
             sessionId,
             segmentIndex,
             syncedAt: new Date().toISOString(),
+            firstUserMessage,
+            title: cachedTitle,
+            messageCount: transcript.metadata.messageCount,
+            startTime: transcript.metadata.startTime,
+            endTime: transcript.metadata.endTime,
+            cwd: transcript.metadata.cwd,
           });
 
           if (!quiet) {
@@ -142,6 +236,9 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
           }
         }
 
+        // 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
@@ -170,6 +267,22 @@ export async function sync(options: SyncOptions): Promise<SyncResult> {
   // 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(