@arcreflex/agent-transcripts 0.1.8 → 0.1.9

package/src/cache.ts

@@ -0,0 +1,129 @@
+/**
+ * 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/cli.ts

@@ -7,6 +7,7 @@ import {
   subcommands,
   run,
   string,
+  number,
   option,
   optional,
   positional,
@@ -14,8 +15,20 @@ import {
 } from "cmd-ts";
 import { parseToTranscripts } from "./parse.ts";
 import { renderTranscript } from "./render.ts";
-import { sync } from "./sync.ts";
+import { sync, type OutputFormat } from "./sync.ts";
 import { convertToDirectory } from "./convert.ts";
+import { generateTitles } from "./title.ts";
+import { serve } from "./serve.ts";
+
+// Custom type for format option
+const formatType = {
+  async from(value: string): Promise<OutputFormat> {
+    if (value !== "md" && value !== "html") {
+      throw new Error(`Invalid format: ${value}. Must be "md" or "html".`);
+    }
+    return value;
+  },
+};
 
 // Shared options
 const inputArg = positional({
@@ -47,7 +60,7 @@ const headOpt = option({
 // Sync subcommand
 const syncCmd = command({
   name: "sync",
-  description: "Sync session files to markdown transcripts",
+  description: "Sync session files to transcripts (markdown or HTML)",
   args: {
     source: positional({
       type: string,
@@ -60,6 +73,15 @@ const syncCmd = command({
       short: "o",
       description: "Output directory for transcripts",
     }),
+    format: option({
+      type: optional(formatType),
+      long: "format",
+      description: "Output format: md (default) or html",
+    }),
+    noTitle: flag({
+      long: "no-title",
+      description: "Skip LLM title generation (for HTML format)",
+    }),
     force: flag({
       long: "force",
       short: "f",
@@ -71,8 +93,65 @@ const syncCmd = command({
       description: "Suppress progress output",
     }),
   },
-  async handler({ source, output, force, quiet }) {
-    await sync({ source, output, force, quiet });
+  async handler({ source, output, format, noTitle, force, quiet }) {
+    await sync({ source, output, format, noTitle, force, quiet });
+  },
+});
+
+// Title subcommand
+const titleCmd = command({
+  name: "title",
+  description: "Generate LLM titles for transcripts.json entries",
+  args: {
+    output: positional({
+      type: string,
+      displayName: "output",
+      description: "Output directory containing transcripts.json",
+    }),
+    force: flag({
+      long: "force",
+      short: "f",
+      description: "Regenerate all titles, not just missing ones",
+    }),
+    quiet: flag({
+      long: "quiet",
+      short: "q",
+      description: "Suppress progress output",
+    }),
+  },
+  async handler({ output, force, quiet }) {
+    await generateTitles({ outputDir: output, force, quiet });
+  },
+});
+
+// Serve subcommand
+const serveCmd = command({
+  name: "serve",
+  description: "Serve transcripts via HTTP (dynamic rendering with caching)",
+  args: {
+    source: positional({
+      type: string,
+      displayName: "source",
+      description: "Source directory to scan for session files",
+    }),
+    port: option({
+      type: optional(number),
+      long: "port",
+      short: "p",
+      description: "Port to listen on (default: 3000)",
+    }),
+    quiet: flag({
+      long: "quiet",
+      short: "q",
+      description: "Suppress request logging",
+    }),
+    noCache: flag({
+      long: "no-cache",
+      description: "Bypass HTML cache (for development)",
+    }),
+  },
+  async handler({ source, port, quiet, noCache }) {
+    await serve({ source, port: port ?? 3000, quiet, noCache });
   },
 });
 
@@ -119,7 +198,7 @@ const convertCmd = command({
   },
 });
 
-const SUBCOMMANDS = ["convert", "sync"] as const;
+const SUBCOMMANDS = ["convert", "sync", "title", "serve"] as const;
 
 // Main CLI with subcommands
 const cli = subcommands({
@@ -128,6 +207,8 @@ const cli = subcommands({
   cmds: {
     convert: convertCmd,
     sync: syncCmd,
+    title: titleCmd,
+    serve: serveCmd,
   },
 });
 

package/src/convert.ts

@@ -18,6 +18,7 @@ import {
   deleteOutputFiles,
   setEntry,
   normalizeSourcePath,
+  extractFirstUserMessage,
 } from "./utils/provenance.ts";
 
 export interface ConvertToDirectoryOptions {
@@ -55,19 +56,6 @@ export async function convertToDirectory(
   const removedEntries =
     sourcePath !== "<stdin>" ? removeEntriesForSource(index, sourcePath) : [];
 
-  // Get source mtime for index entry
-  let sourceMtime = Date.now();
-  if (sourcePath !== "<stdin>") {
-    try {
-      const stat = await Bun.file(sourcePath).stat();
-      if (stat) {
-        sourceMtime = stat.mtime.getTime();
-      }
-    } catch {
-      // Use current time as fallback
-    }
-  }
-
   const sessionId = extractSessionId(inputPath);
   const newOutputs: string[] = [];
 
@@ -95,10 +83,14 @@ export async function convertToDirectory(
       if (sourcePath !== "<stdin>") {
         setEntry(index, relativePath, {
           source: sourcePath,
-          sourceMtime,
           sessionId,
           segmentIndex,
           syncedAt: new Date().toISOString(),
+          firstUserMessage: extractFirstUserMessage(transcript),
+          messageCount: transcript.metadata.messageCount,
+          startTime: transcript.metadata.startTime,
+          endTime: transcript.metadata.endTime,
+          cwd: transcript.metadata.cwd,
         });
       }