@arcreflex/agent-transcripts 0.1.10 → 0.1.12

package/src/cli.ts

@@ -15,20 +15,12 @@ import {
 } from "cmd-ts";
 import { parseToTranscripts } from "./parse.ts";
 import { renderTranscript } from "./render.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;
-  },
-};
+import { archiveAll, DEFAULT_ARCHIVE_DIR } from "./archive.ts";
+import { getAdapters } from "./adapters/index.ts";
+import { ArchiveWatcher } from "./watch.ts";
 
 // Shared options
 const inputArg = positional({
@@ -57,57 +49,47 @@ const headOpt = option({
   description: "Render branch ending at this message ID (default: latest)",
 });
 
-// Sync subcommand
-const syncCmd = command({
-  name: "sync",
-  description: "Sync session files to transcripts (markdown or HTML)",
+const archiveDirOpt = option({
+  type: optional(string),
+  long: "archive-dir",
+  description: `Archive directory (default: ${DEFAULT_ARCHIVE_DIR})`,
+});
+
+// Archive subcommand
+const archiveCmd = command({
+  name: "archive",
+  description: "Archive session files from source directory",
   args: {
     source: positional({
       type: string,
       displayName: "source",
       description: "Source directory to scan for session files",
     }),
-    output: option({
-      type: string,
-      long: "output",
-      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",
-      description: "Re-render all sessions, ignoring mtime",
-    }),
+    archiveDir: archiveDirOpt,
     quiet: flag({
       long: "quiet",
       short: "q",
       description: "Suppress progress output",
     }),
   },
-  async handler({ source, output, format, noTitle, force, quiet }) {
-    await sync({ source, output, format, noTitle, force, quiet });
+  async handler({ source, archiveDir, quiet }) {
+    const dir = archiveDir ?? DEFAULT_ARCHIVE_DIR;
+    const result = await archiveAll(dir, source, getAdapters(), { quiet });
+
+    if (!quiet) {
+      console.error(
+        `\nArchive complete: ${result.updated.length} updated, ${result.current.length} current, ${result.errors.length} errors`,
+      );
+    }
   },
 });
 
 // Title subcommand
 const titleCmd = command({
   name: "title",
-  description: "Generate LLM titles for transcripts.json entries",
+  description: "Generate LLM titles for archive entries",
   args: {
-    output: positional({
-      type: string,
-      displayName: "output",
-      description: "Output directory containing transcripts.json",
-    }),
+    archiveDir: archiveDirOpt,
     force: flag({
       long: "force",
       short: "f",
@@ -119,21 +101,21 @@ const titleCmd = command({
       description: "Suppress progress output",
     }),
   },
-  async handler({ output, force, quiet }) {
-    await generateTitles({ outputDir: output, force, quiet });
+  async handler({ archiveDir, force, quiet }) {
+    await generateTitles({
+      archiveDir: archiveDir ?? undefined,
+      force,
+      quiet,
+    });
   },
 });
 
 // Serve subcommand
 const serveCmd = command({
   name: "serve",
-  description: "Serve transcripts via HTTP (dynamic rendering with caching)",
+  description: "Serve transcripts from archive via HTTP",
   args: {
-    source: positional({
-      type: string,
-      displayName: "source",
-      description: "Source directory to scan for session files",
-    }),
+    archiveDir: archiveDirOpt,
     port: option({
       type: optional(number),
       long: "port",
@@ -145,13 +127,66 @@ const serveCmd = command({
       short: "q",
       description: "Suppress request logging",
     }),
-    noCache: flag({
-      long: "no-cache",
-      description: "Bypass HTML cache (for development)",
+  },
+  async handler({ archiveDir, port, quiet }) {
+    await serve({
+      archiveDir: archiveDir ?? undefined,
+      port: port ?? 3000,
+      quiet,
+    });
+  },
+});
+
+// Watch subcommand
+const watchCmd = command({
+  name: "watch",
+  description: "Watch source directories and keep archive updated",
+  args: {
+    source: positional({
+      type: string,
+      displayName: "source",
+      description: "Source directory to watch for session files",
+    }),
+    archiveDir: archiveDirOpt,
+    pollInterval: option({
+      type: optional(number),
+      long: "poll-interval",
+      description: "Poll interval in milliseconds (default: 30000)",
+    }),
+    quiet: flag({
+      long: "quiet",
+      short: "q",
+      description: "Suppress progress output",
     }),
   },
-  async handler({ source, port, quiet, noCache }) {
-    await serve({ source, port: port ?? 3000, quiet, noCache });
+  async handler({ source, archiveDir, pollInterval, quiet }) {
+    const watcher = new ArchiveWatcher([source], {
+      archiveDir: archiveDir ?? undefined,
+      pollIntervalMs: pollInterval ?? undefined,
+      quiet,
+      onUpdate(result) {
+        if (!quiet && result.updated.length > 0) {
+          console.error(`Updated: ${result.updated.join(", ")}`);
+        }
+      },
+      onError(error) {
+        console.error(`Watch error: ${error.message}`);
+      },
+    });
+
+    if (!quiet) {
+      console.error(`Watching ${source}...`);
+    }
+
+    await watcher.start();
+
+    process.on("SIGINT", () => {
+      if (!quiet) {
+        console.error("\nStopping watcher...");
+      }
+      watcher.stop();
+      process.exit(0);
+    });
   },
 });
 
@@ -174,7 +209,6 @@ const convertCmd = command({
   },
   async handler({ input, output, adapter, head }) {
     if (output && isDirectoryOutput(output)) {
-      // Directory output: use provenance tracking
       await convertToDirectory({
         input,
         outputDir: output,
@@ -182,23 +216,21 @@ const convertCmd = command({
         head,
       });
     } else if (output) {
-      // Explicit file output: not supported anymore (use directory)
       console.error(
         "Error: Explicit file output not supported. Use a directory path instead.",
       );
       process.exit(1);
     } else {
-      // No output: stream to stdout
       const { transcripts } = await parseToTranscripts({ input, adapter });
       for (let i = 0; i < transcripts.length; i++) {
-        if (i > 0) console.log(); // blank line between transcripts
-        console.log(renderTranscript(transcripts[i], head));
+        if (i > 0) console.log();
+        console.log(renderTranscript(transcripts[i], { head }));
       }
     }
   },
 });
 
-const SUBCOMMANDS = ["convert", "sync", "title", "serve"] as const;
+const SUBCOMMANDS = ["convert", "archive", "title", "serve", "watch"] as const;
 
 // Main CLI with subcommands
 const cli = subcommands({
@@ -206,9 +238,10 @@ const cli = subcommands({
   description: "Transform agent session files to readable transcripts",
   cmds: {
     convert: convertCmd,
-    sync: syncCmd,
+    archive: archiveCmd,
     title: titleCmd,
     serve: serveCmd,
+    watch: watchCmd,
   },
 });
 

package/src/convert.ts

@@ -1,25 +1,15 @@
 /**
- * Convert command: full pipeline with provenance tracking.
+ * Convert command: parse source and render to markdown.
  *
- * When output is a directory, uses provenance tracking via transcripts.json
- * index to manage output files.
+ * Standalone pipeline with no archive dependency. Directory output
+ * writes markdown files with deterministic names.
  */
 
-import { join } from "path";
+import { join, resolve } from "path";
 import { mkdir } from "fs/promises";
 import { parseToTranscripts } from "./parse.ts";
 import { renderTranscript } from "./render.ts";
-import { generateOutputName, extractSessionId } from "./utils/naming.ts";
-import {
-  loadIndex,
-  saveIndex,
-  removeEntriesForSource,
-  restoreEntries,
-  deleteOutputFiles,
-  setEntry,
-  normalizeSourcePath,
-  extractFirstUserMessage,
-} from "./utils/provenance.ts";
+import { generateOutputName } from "./utils/naming.ts";
 
 export interface ConvertToDirectoryOptions {
   input: string;
@@ -28,91 +18,34 @@ export interface ConvertToDirectoryOptions {
   head?: string;
 }
 
-/**
- * Convert source file to markdown in output directory.
- * Uses provenance tracking to replace existing outputs.
- */
 export async function convertToDirectory(
   options: ConvertToDirectoryOptions,
 ): Promise<void> {
   const { input, outputDir, adapter, head } = options;
 
-  // Ensure output directory exists
   await mkdir(outputDir, { recursive: true });
 
-  // Parse input to transcripts
   const { transcripts, inputPath } = await parseToTranscripts({
     input,
     adapter,
   });
 
-  // Normalize source path for consistent index keys
-  const sourcePath = normalizeSourcePath(inputPath);
-
-  // Load index and handle existing outputs
-  const index = await loadIndex(outputDir);
-
-  // Remove old entries (save for restoration on error)
-  const removedEntries =
-    sourcePath !== "<stdin>" ? removeEntriesForSource(index, sourcePath) : [];
-
-  const sessionId = extractSessionId(inputPath);
-  const newOutputs: string[] = [];
+  const sourcePath = inputPath === "<stdin>" ? undefined : resolve(inputPath);
 
-  try {
-    // Generate fresh outputs
-    for (let i = 0; i < transcripts.length; i++) {
-      const transcript = transcripts[i];
-      const segmentIndex = transcripts.length > 1 ? i + 1 : undefined;
+  for (let i = 0; i < transcripts.length; i++) {
+    const transcript = transcripts[i];
+    const segmentIndex = transcripts.length > 1 ? i + 1 : undefined;
 
-      // Generate deterministic name
-      const baseName = generateOutputName(transcript, inputPath);
-      const suffix = segmentIndex ? `_${segmentIndex}` : "";
-      const relativePath = `${baseName}${suffix}.md`;
-      const outputPath = join(outputDir, relativePath);
+    const baseName = generateOutputName(transcript, inputPath);
+    const suffix = segmentIndex ? `_${segmentIndex}` : "";
+    const relativePath = `${baseName}${suffix}.md`;
+    const outputPath = join(outputDir, relativePath);
 
-      // Render with provenance front matter
-      const markdown = renderTranscript(transcript, {
-        head,
-        sourcePath: sourcePath !== "<stdin>" ? sourcePath : undefined,
-      });
-      await Bun.write(outputPath, markdown);
-      newOutputs.push(relativePath);
-
-      // Update index (only for non-stdin sources)
-      if (sourcePath !== "<stdin>") {
-        setEntry(index, relativePath, {
-          source: sourcePath,
-          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,
-        });
-      }
-
-      console.error(`Wrote: ${outputPath}`);
-    }
-
-    // Success: delete old output files (after new ones are written)
-    const oldFilenames = removedEntries.map((e) => e.filename);
-    const toDelete = oldFilenames.filter((f) => !newOutputs.includes(f));
-    if (toDelete.length > 0) {
-      await deleteOutputFiles(outputDir, toDelete);
-    }
-  } catch (error) {
-    // Clean up any newly written files before restoring old entries
-    if (newOutputs.length > 0) {
-      await deleteOutputFiles(outputDir, newOutputs);
-    }
-    // Restore old entries on error to preserve provenance
-    restoreEntries(index, removedEntries);
-    throw error;
+    const markdown = renderTranscript(transcript, {
+      head,
+      sourcePath,
+    });
+    await Bun.write(outputPath, markdown);
+    console.error(`Wrote: ${outputPath}`);
   }
-
-  // Save index
-  await saveIndex(outputDir, index);
 }

package/src/parse.ts

@@ -15,9 +15,6 @@ export interface ParseResult {
   inputPath: string;
 }
 
-/**
- * Read input content from file or stdin.
- */
 async function readInput(
   input: string,
 ): Promise<{ content: string; path: string }> {