npm - opencode-replay - Versions diffs - 1.0.2 → 1.1.0 - Mend

opencode-replay 1.0.2 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md +81 -3
package/dist/assets/gist-preview.js +126 -0
package/dist/index.js +1307 -215
package/package.json +3 -3

package/dist/index.js CHANGED Viewed

@@ -164,7 +164,8 @@ function renderBasePage(options) {
     assetsPath = "./assets",
     headExtra = "",
     bodyClass = "",
-    totalPages
+    totalPages,
+    gistMode = false
   } = options;
   const bodyAttrs = [];
   if (bodyClass)
@@ -172,6 +173,8 @@ function renderBasePage(options) {
   if (totalPages !== undefined)
     bodyAttrs.push(`data-total-pages="${totalPages}"`);
   const bodyAttrStr = bodyAttrs.length > 0 ? ` ${bodyAttrs.join(" ")}` : "";
+  const gistScript = gistMode ? `
+  <script src="${assetsPath}/gist-preview.js"></script>` : "";
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -191,7 +194,7 @@ function renderBasePage(options) {
   </div>
   <script src="${assetsPath}/theme.js"></script>
   <script src="${assetsPath}/highlight.js"></script>
-  <script src="${assetsPath}/search.js"></script>
+  <script src="${assetsPath}/search.js"></script>${gistScript}
 </body>
 </html>`;
 }
@@ -411,7 +414,8 @@ function renderIndexPage(data) {
     sessions,
     isAllProjects = false,
     breadcrumbs = [],
-    assetsPath = "./assets"
+    assetsPath = "./assets",
+    gistMode
   } = data;
   const header = renderHeader({
     title,
@@ -432,7 +436,8 @@ ${footer}
     title,
     content,
     assetsPath,
-    bodyClass: "index-page"
+    bodyClass: "index-page",
+    gistMode
   });
 }
 // src/render/templates/session.ts
@@ -539,7 +544,7 @@ function renderPagination(pageCount) {
 </nav>`;
 }
 function renderSessionPage(data) {
-  const { session, projectName, timeline, pageCount, assetsPath = "../../assets" } = data;
+  const { session, projectName, timeline, pageCount, assetsPath = "../../assets", gistMode } = data;
   const breadcrumbs = [
     { label: projectName ?? "Sessions", href: "../../index.html" },
     { label: session.title }
@@ -567,7 +572,8 @@ ${footer}
     content,
     assetsPath,
     bodyClass: "session-page",
-    totalPages: pageCount
+    totalPages: pageCount,
+    gistMode
   });
 }
 // src/render/components/tools/bash.ts
@@ -1619,7 +1625,8 @@ function renderConversationPage(data) {
     messages,
     pageNumber,
     totalPages,
-    assetsPath = "../../assets"
+    assetsPath = "../../assets",
+    gistMode
   } = data;
   const breadcrumbs = [
     { label: projectName ?? "Sessions", href: "../../index.html" },
@@ -1648,7 +1655,8 @@ ${footer}
     content,
     assetsPath,
     bodyClass: "conversation-page",
-    totalPages
+    totalPages,
+    gistMode
   });
 }
 // src/render/git-commits.ts
@@ -1824,33 +1832,8 @@ function detectRepoFromMessages(messages) {
   return null;
 }
-// src/render/html.ts
+// src/render/data.ts
 var PROMPTS_PER_PAGE = 5;
-async function ensureDir(dir) {
-  await mkdir(dir, { recursive: true });
-}
-async function writeHtml(filePath, content) {
-  await ensureDir(dirname(filePath));
-  await Bun.write(filePath, content);
-}
-function getAssetsSourceDir() {
-  const prodAssetsDir = join2(import.meta.dir, "assets");
-  const devAssetsDir = join2(import.meta.dir, "../assets");
-  if (Bun.file(join2(prodAssetsDir, "styles.css")).size) {
-    return prodAssetsDir;
-  }
-  return devAssetsDir;
-}
-async function copyAssets(outputDir) {
-  const assetsDir = join2(outputDir, "assets");
-  await ensureDir(assetsDir);
-  const sourceDir = getAssetsSourceDir();
-  await copyFile(join2(sourceDir, "styles.css"), join2(assetsDir, "styles.css"));
-  await copyFile(join2(sourceDir, "prism.css"), join2(assetsDir, "prism.css"));
-  await copyFile(join2(sourceDir, "theme.js"), join2(assetsDir, "theme.js"));
-  await copyFile(join2(sourceDir, "highlight.js"), join2(assetsDir, "highlight.js"));
-  await copyFile(join2(sourceDir, "search.js"), join2(assetsDir, "search.js"));
-}
 function getFirstPrompt(messages) {
   for (const msg of messages) {
     if (msg.message.role === "user") {
@@ -1939,17 +1922,12 @@ function paginateMessages(messages) {
   }
   return pages;
 }
-async function generateSessionHtml(storagePath, outputDir, session2, projectName, repo, includeJson) {
-  const sessionDir = join2(outputDir, "sessions", session2.id);
-  await ensureDir(sessionDir);
-  const messages = await getMessagesWithParts(storagePath, session2.id);
-  const messageCount = messages.length;
-  const firstPrompt = getFirstPrompt(messages);
-  const timeline = buildTimeline(messages, repo);
+function calculateSessionStats(messages) {
   let totalTokensInput = 0;
   let totalTokensOutput = 0;
   let totalCost = 0;
   let model;
+  let userMessageCount = 0;
   for (const msg of messages) {
     if (msg.message.role === "assistant") {
       const asst = msg.message;
@@ -1963,20 +1941,69 @@ async function generateSessionHtml(storagePath, outputDir, session2, projectName
       if (!model && asst.modelID) {
         model = asst.modelID;
       }
+    } else if (msg.message.role === "user") {
+      userMessageCount++;
     }
   }
+  const pageCount = userMessageCount > 0 ? Math.ceil(userMessageCount / PROMPTS_PER_PAGE) : 0;
+  return {
+    messageCount: messages.length,
+    pageCount,
+    totalTokensInput,
+    totalTokensOutput,
+    totalCost,
+    model
+  };
+}
+// src/render/html.ts
+async function ensureDir(dir) {
+  await mkdir(dir, { recursive: true });
+}
+async function writeHtml(filePath, content) {
+  await ensureDir(dirname(filePath));
+  await Bun.write(filePath, content);
+}
+function getAssetsSourceDir() {
+  const prodAssetsDir = join2(import.meta.dir, "assets");
+  const devAssetsDir = join2(import.meta.dir, "../assets");
+  if (Bun.file(join2(prodAssetsDir, "styles.css")).size) {
+    return prodAssetsDir;
+  }
+  return devAssetsDir;
+}
+async function copyAssets(outputDir, gistMode) {
+  const assetsDir = join2(outputDir, "assets");
+  await ensureDir(assetsDir);
+  const sourceDir = getAssetsSourceDir();
+  await copyFile(join2(sourceDir, "styles.css"), join2(assetsDir, "styles.css"));
+  await copyFile(join2(sourceDir, "prism.css"), join2(assetsDir, "prism.css"));
+  await copyFile(join2(sourceDir, "theme.js"), join2(assetsDir, "theme.js"));
+  await copyFile(join2(sourceDir, "highlight.js"), join2(assetsDir, "highlight.js"));
+  await copyFile(join2(sourceDir, "search.js"), join2(assetsDir, "search.js"));
+  if (gistMode) {
+    await copyFile(join2(sourceDir, "gist-preview.js"), join2(assetsDir, "gist-preview.js"));
+  }
+}
+async function generateSessionHtml(storagePath, outputDir, session2, projectName, repo, includeJson, gistMode) {
+  const sessionDir = join2(outputDir, "sessions", session2.id);
+  await ensureDir(sessionDir);
+  const messages = await getMessagesWithParts(storagePath, session2.id);
+  const firstPrompt = getFirstPrompt(messages);
+  const timeline = buildTimeline(messages, repo);
+  const stats = calculateSessionStats(messages);
   const pages = paginateMessages(messages);
-  const pageCount = pages.length;
   const sessionOverviewHtml = renderSessionPage({
     session: session2,
     projectName,
     timeline,
-    messageCount,
-    totalTokens: totalTokensInput > 0 || totalTokensOutput > 0 ? { input: totalTokensInput, output: totalTokensOutput } : undefined,
-    totalCost: totalCost > 0 ? totalCost : undefined,
-    pageCount,
-    model,
-    assetsPath: "../../assets"
+    messageCount: stats.messageCount,
+    totalTokens: stats.totalTokensInput > 0 || stats.totalTokensOutput > 0 ? { input: stats.totalTokensInput, output: stats.totalTokensOutput } : undefined,
+    totalCost: stats.totalCost > 0 ? stats.totalCost : undefined,
+    pageCount: stats.pageCount,
+    model: stats.model,
+    assetsPath: "../../assets",
+    gistMode
   });
   await writeHtml(join2(sessionDir, "index.html"), sessionOverviewHtml);
   for (let i = 0;i < pages.length; i++) {
@@ -1987,8 +2014,9 @@ async function generateSessionHtml(storagePath, outputDir, session2, projectName
       projectName,
       messages: pageMessages,
       pageNumber,
-      totalPages: pageCount,
-      assetsPath: "../../assets"
+      totalPages: stats.pageCount,
+      assetsPath: "../../assets",
+      gistMode
     });
     const pageFile = `page-${String(pageNumber).padStart(3, "0")}.html`;
     await writeHtml(join2(sessionDir, pageFile), pageHtml);
@@ -1998,23 +2026,16 @@ async function generateSessionHtml(storagePath, outputDir, session2, projectName
       session: session2,
       messages,
       timeline,
-      stats: {
-        messageCount,
-        pageCount,
-        totalTokensInput,
-        totalTokensOutput,
-        totalCost,
-        model
-      }
+      stats
     };
     await Bun.write(join2(sessionDir, "session.json"), JSON.stringify(jsonData, null, 2));
   }
-  return { messageCount, pageCount, firstPrompt };
+  return { messageCount: stats.messageCount, pageCount: stats.pageCount, firstPrompt };
 }
 async function generateHtml(options) {
-  const { storagePath, outputDir, all = false, sessionId, includeJson = false, onProgress, repo } = options;
+  const { storagePath, outputDir, all = false, sessionId, includeJson = false, onProgress, repo, gistMode = false } = options;
   await ensureDir(outputDir);
-  await copyAssets(outputDir);
+  await copyAssets(outputDir, gistMode);
   const sessionCards = [];
   let title = "OpenCode Sessions";
   let projectName;
@@ -2027,7 +2048,7 @@ async function generateHtml(options) {
       title: session2.title,
       phase: "generating"
     });
-    const result = await generateSessionHtml(storagePath, outputDir, session2, project.name, repo, includeJson);
+    const result = await generateSessionHtml(storagePath, outputDir, session2, project.name, repo, includeJson, gistMode);
     totalPageCount += result.pageCount;
     totalMessageCount += result.messageCount;
     sessionCards.push({
@@ -2086,7 +2107,8 @@ async function generateHtml(options) {
     subtitle: projectName,
     sessions: sessionCards,
     isAllProjects: all,
-    assetsPath: "./assets"
+    assetsPath: "./assets",
+    gistMode
   });
   await writeHtml(join2(outputDir, "index.html"), indexHtml);
   onProgress?.({
@@ -2102,154 +2124,981 @@ async function generateHtml(options) {
     projectName
   };
 }
-// src/server.ts
-import { resolve, join as join3, sep } from "path";
-function isPathSafe(rootDir, targetPath) {
-  const resolvedRoot = resolve(rootDir);
-  const resolvedTarget = resolve(targetPath);
-  return resolvedTarget.startsWith(resolvedRoot + sep) || resolvedTarget === resolvedRoot;
-}
-function createRequestHandler(rootDir) {
-  const ROOT_DIR = resolve(rootDir);
-  return async function handleRequest(req) {
-    const url = new URL(req.url);
-    if (req.method !== "GET" && req.method !== "HEAD") {
-      return new Response("Method Not Allowed", {
-        status: 405,
-        headers: { Allow: "GET, HEAD" }
-      });
-    }
-    let pathname;
-    try {
-      pathname = decodeURIComponent(url.pathname);
-    } catch {
-      return new Response("Bad Request", { status: 400 });
-    }
-    pathname = pathname.replace(/\0/g, "");
-    const targetPath = join3(ROOT_DIR, pathname);
-    if (!isPathSafe(ROOT_DIR, targetPath)) {
-      return new Response("Forbidden", { status: 403 });
-    }
-    let file = Bun.file(targetPath);
-    let fileExists = await file.exists();
-    if (pathname.endsWith("/") || !fileExists) {
-      const indexPath = join3(targetPath, "index.html");
-      const indexFile = Bun.file(indexPath);
-      if (await indexFile.exists()) {
-        file = indexFile;
-        fileExists = true;
-      }
-    }
-    if (!fileExists) {
-      return new Response("Not Found", {
-        status: 404,
-        headers: { "Content-Type": "text/plain" }
-      });
-    }
-    const content = await file.arrayBuffer();
-    const etag = `W/"${Bun.hash(new Uint8Array(content)).toString(16)}"`;
-    const ifNoneMatch = req.headers.get("If-None-Match");
-    if (ifNoneMatch === etag) {
-      return new Response(null, {
-        status: 304,
-        headers: { ETag: etag }
-      });
-    }
-    const isHashed = /\.[a-f0-9]{8,}\.(js|css|png|jpg|jpeg|gif|svg|woff2?)$/i.test(targetPath);
-    const responseHeaders = {
-      "Content-Type": file.type,
-      "Content-Length": String(content.byteLength),
-      ETag: etag,
-      "Cache-Control": isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600"
-    };
-    if (req.method === "HEAD") {
-      return new Response(null, { headers: responseHeaders });
-    }
-    return new Response(content, { headers: responseHeaders });
-  };
-}
-async function serve(options) {
-  const { directory, port, open = true } = options;
-  const handleRequest = createRequestHandler(directory);
-  let server;
-  try {
-    server = Bun.serve({
-      port,
-      fetch: handleRequest,
-      error(error) {
-        console.error("Server error:", error);
-        return new Response("Internal Server Error", { status: 500 });
-      }
-    });
-  } catch (err) {
-    const error = err;
-    if (error.code === "EADDRINUSE") {
-      console.error(`Error: Port ${port} is already in use`);
-      process.exit(1);
+// src/render/markdown/tools/bash.ts
+function renderBashToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const command = input?.command || "";
+  const description = input?.description || state.title || "";
+  const workdir = input?.workdir;
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  const workdirText = workdir ? ` (in \`${workdir}\`)` : "";
+  lines.push(`**Bash:** ${description}${workdirText}`);
+  lines.push("");
+  lines.push("```bash");
+  lines.push(`$ ${command}`);
+  lines.push("```");
+  lines.push("");
+  if (output) {
+    const outputLines = output.split(`
+`).length;
+    if (outputLines > 15) {
+      lines.push("<details>");
+      lines.push("<summary>Output (click to expand)</summary>");
+      lines.push("");
+      lines.push("```");
+      lines.push(output);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("```");
+      lines.push(output);
+      lines.push("```");
     }
-    throw err;
+    lines.push("");
   }
-  const serverUrl = `http://localhost:${port}`;
-  console.log(`
-Server running at ${serverUrl}`);
-  console.log(`Press Ctrl+C to stop
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
 `);
-  if (open) {
-    openBrowser(serverUrl);
+}
+// src/render/markdown/tools/read.ts
+function renderReadToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const filePath = input?.filePath || state.title || "Unknown file";
+  const offset = input?.offset;
+  const limit = input?.limit;
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  let rangeInfo = "";
+  if (offset !== undefined || limit !== undefined) {
+    const parts = [];
+    if (offset !== undefined)
+      parts.push(`from line ${offset}`);
+    if (limit !== undefined)
+      parts.push(`${limit} lines`);
+    rangeInfo = ` (${parts.join(", ")})`;
   }
-  const sigintHandler = () => shutdown("SIGINT");
-  const sigtermHandler = () => shutdown("SIGTERM");
-  function shutdown(signal) {
-    console.log(`
-Received ${signal}, shutting down...`);
-    process.off("SIGINT", sigintHandler);
-    process.off("SIGTERM", sigtermHandler);
-    server.stop();
-    console.log("Server stopped");
-    process.exit(0);
+  lines.push(`**Read:** \`${filePath}\`${rangeInfo}`);
+  lines.push("");
+  if (output) {
+    const contentLines = output.split(`
+`).length;
+    if (contentLines > 30) {
+      lines.push("<details>");
+      lines.push(`<summary>Content (${contentLines} lines)</summary>`);
+      lines.push("");
+      lines.push("```");
+      lines.push(output);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("```");
+      lines.push(output);
+      lines.push("```");
+    }
+    lines.push("");
   }
-  process.on("SIGINT", sigintHandler);
-  process.on("SIGTERM", sigtermHandler);
-  await new Promise(() => {});
-}
-function openBrowser(url) {
-  const platform = process.platform;
-  if (platform === "darwin") {
-    Bun.spawn(["open", url]);
-  } else if (platform === "win32") {
-    Bun.spawn(["cmd", "/c", "start", "", url]);
-  } else {
-    Bun.spawn(["xdg-open", url]);
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
   }
+  return lines.join(`
+`);
 }
-// src/utils/update-notifier.ts
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
-import { mkdir as mkdir2 } from "fs/promises";
-var PACKAGE_NAME = "opencode-replay";
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-function detectPackageManager() {
-  const modulePath = import.meta.dir;
-  if (modulePath.includes(".bun") || modulePath.includes("bun/install")) {
-    return "bun";
-  }
-  if (process.env.BUN_INSTALL) {
-    return "bun";
+// src/render/markdown/tools/write.ts
+function renderWriteToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const filePath = input?.filePath || state.title || "Unknown file";
+  const content = input?.content || "";
+  const error = state.error;
+  const status = state.status;
+  const lines = [];
+  const lineCount = content ? content.split(`
+`).length : 0;
+  const sizeText = formatBytes(content.length);
+  const statusText = status === "completed" ? "Created" : status === "error" ? "Failed" : "Writing...";
+  lines.push(`**Write:** \`${filePath}\` - ${statusText} (${lineCount} lines, ${sizeText})`);
+  lines.push("");
+  if (content) {
+    if (lineCount > 30) {
+      lines.push("<details>");
+      lines.push(`<summary>Content (${lineCount} lines)</summary>`);
+      lines.push("");
+      lines.push("```");
+      lines.push(content);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("```");
+      lines.push(content);
+      lines.push("```");
+    }
+    lines.push("");
   }
-  if (typeof Bun !== "undefined") {
-    const bunInstallPath = join4(homedir2(), ".bun");
-    try {
-      if (Bun.file(bunInstallPath).size) {
-        return "bun";
-      }
-    } catch {}
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
   }
-  return "npm";
+  return lines.join(`
+`);
 }
-function getCachePath() {
-  const cacheDir = process.env.XDG_CACHE_HOME || join4(homedir2(), ".cache");
+// src/render/markdown/tools/edit.ts
+function renderEditToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const filePath = input?.filePath || state.title || "Unknown file";
+  const oldString = input?.oldString || "";
+  const newString = input?.newString || "";
+  const replaceAll = input?.replaceAll || false;
+  const error = state.error;
+  const lines = [];
+  const oldLines = oldString.split(`
+`).length;
+  const newLines = newString.split(`
+`).length;
+  const replaceAllText = replaceAll ? " (replace all)" : "";
+  lines.push(`**Edit:** \`${filePath}\`${replaceAllText} - ${oldLines} lines -> ${newLines} lines`);
+  lines.push("");
+  lines.push("```diff");
+  for (const line of oldString.split(`
+`)) {
+    lines.push(`- ${line}`);
+  }
+  for (const line of newString.split(`
+`)) {
+    lines.push(`+ ${line}`);
+  }
+  lines.push("```");
+  lines.push("");
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+// src/render/markdown/tools/glob.ts
+function renderGlobToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const pattern = input?.pattern || "";
+  const searchPath = input?.path || ".";
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  const files = output.trim() ? output.trim().split(`
+`).filter(Boolean) : [];
+  const fileCount = files.length;
+  lines.push(`**Glob:** \`${pattern}\` in \`${searchPath}\` - ${fileCount} files`);
+  lines.push("");
+  if (files.length > 0) {
+    if (files.length > 20) {
+      lines.push("<details>");
+      lines.push(`<summary>Files (${fileCount})</summary>`);
+      lines.push("");
+      for (const file of files) {
+        lines.push(`- \`${file}\``);
+      }
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      for (const file of files) {
+        lines.push(`- \`${file}\``);
+      }
+    }
+    lines.push("");
+  } else if (!error) {
+    lines.push("*No matching files*");
+    lines.push("");
+  }
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+// src/render/markdown/tools/grep.ts
+function renderGrepToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const pattern = input?.pattern || "";
+  const searchPath = input?.path || ".";
+  const include = input?.include;
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  const matches = parseGrepOutput2(output);
+  const matchCount = matches.length;
+  const includeText = include ? ` (filter: \`${include}\`)` : "";
+  lines.push(`**Grep:** \`${pattern}\` in \`${searchPath}\`${includeText} - ${matchCount} matches`);
+  lines.push("");
+  if (matches.length > 0) {
+    if (matches.length > 20) {
+      lines.push("<details>");
+      lines.push(`<summary>Matches (${matchCount})</summary>`);
+      lines.push("");
+      for (const match of matches) {
+        lines.push(`- \`${match.file}:${match.line}\` ${match.content}`);
+      }
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      for (const match of matches) {
+        lines.push(`- \`${match.file}:${match.line}\` ${match.content}`);
+      }
+    }
+    lines.push("");
+  } else if (!error) {
+    lines.push("*No matches found*");
+    lines.push("");
+  }
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function parseGrepOutput2(output) {
+  if (!output.trim())
+    return [];
+  const lines = output.trim().split(`
+`);
+  const matches = [];
+  for (const line of lines) {
+    const match = line.match(/^(.+?):(\d+):?(.*)$/);
+    if (match && match[1] && match[2]) {
+      matches.push({
+        file: match[1],
+        line: parseInt(match[2], 10),
+        content: match[3] || ""
+      });
+    }
+  }
+  return matches;
+}
+// src/render/markdown/tools/task.ts
+function renderTaskToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const description = input?.description || state.title || "Task";
+  const prompt = input?.prompt || "";
+  const agentType = input?.subagent_type || "general";
+  const command = input?.command;
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  lines.push(`**Task:** ${description} (\`${agentType}\` agent)`);
+  lines.push("");
+  if (command) {
+    lines.push(`Command: \`${command}\``);
+    lines.push("");
+  }
+  if (prompt) {
+    const promptLines = prompt.split(`
+`).length;
+    if (promptLines > 5) {
+      lines.push("<details>");
+      lines.push(`<summary>Prompt (${promptLines} lines)</summary>`);
+      lines.push("");
+      lines.push(prompt);
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("**Prompt:**");
+      lines.push("> " + prompt.split(`
+`).join(`
+> `));
+    }
+    lines.push("");
+  }
+  if (output) {
+    const resultLines = output.split(`
+`).length;
+    if (resultLines > 15) {
+      lines.push("<details>");
+      lines.push(`<summary>Result (${resultLines} lines)</summary>`);
+      lines.push("");
+      lines.push(output);
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("**Result:**");
+      lines.push(output);
+    }
+    lines.push("");
+  }
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+// src/render/markdown/tools/todowrite.ts
+function renderTodoWriteToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const todos = input?.todos || [];
+  const error = state.error;
+  const lines = [];
+  const completed = todos.filter((t) => t.status === "completed").length;
+  const inProgress = todos.filter((t) => t.status === "in_progress").length;
+  const pending = todos.filter((t) => t.status === "pending").length;
+  const cancelled = todos.filter((t) => t.status === "cancelled").length;
+  lines.push(`**Todo List:** ${completed}/${todos.length} done`);
+  if (inProgress > 0 || pending > 0 || cancelled > 0) {
+    const stats = [];
+    if (inProgress > 0)
+      stats.push(`${inProgress} in progress`);
+    if (pending > 0)
+      stats.push(`${pending} pending`);
+    if (cancelled > 0)
+      stats.push(`${cancelled} cancelled`);
+    lines.push(`*(${stats.join(", ")})*`);
+  }
+  lines.push("");
+  if (todos.length > 0) {
+    for (const todo of todos) {
+      const checkbox = getStatusCheckbox(todo.status);
+      const priorityBadge = todo.priority === "high" ? " **[HIGH]**" : todo.priority === "medium" ? " *[MEDIUM]*" : "";
+      lines.push(`- ${checkbox} ${todo.content}${priorityBadge}`);
+    }
+    lines.push("");
+  } else {
+    lines.push("*No todos*");
+    lines.push("");
+  }
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function getStatusCheckbox(status) {
+  switch (status) {
+    case "completed":
+      return "[x]";
+    case "in_progress":
+      return "[-]";
+    case "pending":
+      return "[ ]";
+    case "cancelled":
+      return "[~]";
+    default:
+      return "[ ]";
+  }
+}
+// src/render/markdown/tools/webfetch.ts
+function renderWebFetchToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const url = input?.url || "";
+  const format = input?.format || "markdown";
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  const contentSize = formatBytes(output.length);
+  lines.push(`**WebFetch:** [${truncateUrl2(url)}](${url}) - ${format} (${contentSize})`);
+  lines.push("");
+  if (output) {
+    const contentLines = output.split(`
+`).length;
+    if (contentLines > 30) {
+      lines.push("<details>");
+      lines.push(`<summary>Content (${contentLines} lines)</summary>`);
+      lines.push("");
+      lines.push(output);
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push(output);
+    }
+    lines.push("");
+  }
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function truncateUrl2(url, maxLength = 60) {
+  if (url.length <= maxLength)
+    return url;
+  try {
+    const parsed = new URL(url);
+    const domain = parsed.hostname;
+    const path = parsed.pathname;
+    if (domain.length + path.length <= maxLength) {
+      return domain + path;
+    }
+    const availableForPath = maxLength - domain.length - 3;
+    if (availableForPath > 10) {
+      return domain + path.slice(0, availableForPath) + "...";
+    }
+    return url.slice(0, maxLength - 3) + "...";
+  } catch {
+    return url.slice(0, maxLength - 3) + "...";
+  }
+}
+// src/render/markdown/tools/batch.ts
+function renderBatchToolMd(part) {
+  const { state } = part;
+  const input = state.input;
+  const toolCalls = input?.tool_calls || [];
+  const output = state.output || "";
+  const error = state.error;
+  const lines = [];
+  const toolCounts = new Map;
+  for (const call of toolCalls) {
+    const count = toolCounts.get(call.tool) || 0;
+    toolCounts.set(call.tool, count + 1);
+  }
+  const toolSummary = Array.from(toolCounts.entries()).map(([tool, count]) => `${count} ${tool}`).join(", ");
+  lines.push(`**Batch:** ${toolCalls.length} calls (${toolSummary})`);
+  lines.push("");
+  if (toolCalls.length > 0) {
+    for (let i = 0;i < toolCalls.length; i++) {
+      const call = toolCalls[i];
+      const info = getToolInfo2(call.tool, call.parameters);
+      lines.push(`${i + 1}. **${call.tool}**${info ? `: ${info}` : ""}`);
+    }
+    lines.push("");
+  }
+  if (output) {
+    const outputLines = output.split(`
+`).length;
+    if (outputLines > 30) {
+      lines.push("<details>");
+      lines.push(`<summary>Combined Output (${outputLines} lines)</summary>`);
+      lines.push("");
+      lines.push("```");
+      lines.push(output);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("```");
+      lines.push(output);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  if (error) {
+    lines.push(`> **Error:** ${error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function getToolInfo2(tool, params) {
+  switch (tool) {
+    case "bash":
+      return `\`${String(params.command || params.description || "")}\``;
+    case "read":
+    case "write":
+    case "edit":
+      return `\`${String(params.filePath || "")}\``;
+    case "glob":
+    case "grep":
+      return `\`${String(params.pattern || "")}\``;
+    case "webfetch":
+      return String(params.url || "");
+    case "task":
+      return String(params.description || "");
+    default:
+      return "";
+  }
+}
+// src/render/markdown/part.ts
+function renderTextPartMd(part) {
+  if (part.ignored)
+    return "";
+  return part.text;
+}
+function renderReasoningPartMd(part) {
+  const hasTiming = part.time?.start && part.time?.end;
+  const durationText = hasTiming ? ` (${formatDuration(part.time.start, part.time.end)})` : "";
+  return `<details>
+<summary>Thinking...${durationText}</summary>
+${part.text}
+</details>`;
+}
+function renderToolPartMd(part) {
+  const { tool } = part;
+  switch (tool) {
+    case "bash":
+      return renderBashToolMd(part);
+    case "read":
+      return renderReadToolMd(part);
+    case "write":
+      return renderWriteToolMd(part);
+    case "edit":
+      return renderEditToolMd(part);
+    case "glob":
+      return renderGlobToolMd(part);
+    case "grep":
+      return renderGrepToolMd(part);
+    case "task":
+      return renderTaskToolMd(part);
+    case "todowrite":
+      return renderTodoWriteToolMd(part);
+    case "webfetch":
+      return renderWebFetchToolMd(part);
+    case "batch":
+      return renderBatchToolMd(part);
+    default:
+      return renderGenericToolPartMd(part);
+  }
+}
+function renderGenericToolPartMd(part) {
+  const { tool, state } = part;
+  const title = state.title || tool;
+  const lines = [];
+  lines.push(`**${tool}:** ${title}`);
+  lines.push("");
+  if (state.input) {
+    lines.push("<details>");
+    lines.push("<summary>Input</summary>");
+    lines.push("");
+    lines.push("```json");
+    lines.push(JSON.stringify(state.input, null, 2));
+    lines.push("```");
+    lines.push("");
+    lines.push("</details>");
+    lines.push("");
+  }
+  if (state.output) {
+    const outputLines = state.output.split(`
+`).length;
+    if (outputLines > 15) {
+      lines.push("<details>");
+      lines.push("<summary>Output (click to expand)</summary>");
+      lines.push("");
+      lines.push("```");
+      lines.push(state.output);
+      lines.push("```");
+      lines.push("");
+      lines.push("</details>");
+    } else {
+      lines.push("```");
+      lines.push(state.output);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  if (state.error) {
+    lines.push(`> **Error:** ${state.error}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderFilePartMd(part) {
+  const filename = part.filename || "file";
+  const isImage = part.mime.startsWith("image/");
+  const isDataUrl = part.url.startsWith("data:");
+  const lines = [];
+  let sizeText = "";
+  if (isDataUrl) {
+    const base64Part = part.url.split(",")[1];
+    if (base64Part) {
+      const estimatedBytes = Math.floor(base64Part.length * 0.75);
+      sizeText = ` (${formatBytes(estimatedBytes)})`;
+    }
+  }
+  lines.push(`**File:** \`${filename}\` - ${part.mime}${sizeText}`);
+  lines.push("");
+  if (isImage && isDataUrl) {
+    lines.push(`![${filename}](${part.url})`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderSnapshotPartMd(part) {
+  return `*Snapshot created: \`${part.snapshot}\`*`;
+}
+function renderPatchPartMd(part) {
+  const fileCount = part.files.length;
+  const lines = [];
+  lines.push(`**File changes:** ${fileCount} file${fileCount !== 1 ? "s" : ""} (\`${part.hash.slice(0, 8)}\`)`);
+  lines.push("");
+  if (part.files.length > 0) {
+    for (const file of part.files) {
+      lines.push(`- \`${file}\``);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderAgentPartMd(part) {
+  const sourceText = part.source?.value ? `: ${part.source.value.slice(0, 100)}${part.source.value.length > 100 ? "..." : ""}` : "";
+  return `**Agent:** \`${part.name}\`${sourceText}`;
+}
+function renderCompactionPartMd(part) {
+  const typeLabel = part.auto ? "Auto-compacted" : "Manual compaction";
+  return `*${typeLabel}*`;
+}
+function renderSubtaskPartMd(part) {
+  const lines = [];
+  lines.push(`**Subtask:** ${part.description} (${part.agent})`);
+  lines.push("");
+  if (part.command) {
+    lines.push(`Command: \`${part.command}\``);
+    lines.push("");
+  }
+  const promptLines = part.prompt.split(`
+`).length;
+  if (promptLines > 5) {
+    lines.push("<details>");
+    lines.push("<summary>Prompt</summary>");
+    lines.push("");
+    lines.push(part.prompt);
+    lines.push("");
+    lines.push("</details>");
+  } else {
+    lines.push("> " + part.prompt.split(`
+`).join(`
+> `));
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function renderRetryPartMd(part) {
+  const codeText = part.error.code ? ` (code: ${part.error.code})` : "";
+  return `**Retry #${part.attempt}:** ${part.error.name} - ${part.error.message}${codeText}`;
+}
+function renderGenericPartMd(part) {
+  return `*[${part.type}]*`;
+}
+function renderPartMd(part) {
+  switch (part.type) {
+    case "text":
+      return renderTextPartMd(part);
+    case "reasoning":
+      return renderReasoningPartMd(part);
+    case "tool":
+      return renderToolPartMd(part);
+    case "file":
+      return renderFilePartMd(part);
+    case "snapshot":
+      return renderSnapshotPartMd(part);
+    case "patch":
+      return renderPatchPartMd(part);
+    case "agent":
+      return renderAgentPartMd(part);
+    case "compaction":
+      return renderCompactionPartMd(part);
+    case "subtask":
+      return renderSubtaskPartMd(part);
+    case "retry":
+      return renderRetryPartMd(part);
+    default:
+      return renderGenericPartMd(part);
+  }
+}
+// src/render/markdown/message.ts
+function renderUserMessageMd(message, parts) {
+  const time = formatTime(message.time.created);
+  const model = message.model ? `${message.model.providerID}/${message.model.modelID}` : "";
+  const lines = [];
+  lines.push("### User");
+  lines.push("");
+  lines.push(`*${time}*${model ? ` - ${model}` : ""}`);
+  lines.push("");
+  for (const part of parts) {
+    const partMd = renderPartMd(part);
+    if (partMd) {
+      lines.push(partMd);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderAssistantMessageMd(message, parts) {
+  const time = formatTime(message.time.created);
+  const model = message.modelID || "";
+  const lines = [];
+  lines.push("### Assistant");
+  lines.push("");
+  lines.push(`*${time}*${model ? ` - ${model}` : ""}`);
+  lines.push("");
+  for (const part of parts) {
+    const partMd = renderPartMd(part);
+    if (partMd) {
+      lines.push(partMd);
+      lines.push("");
+    }
+  }
+  const stats = formatStatsMd(message);
+  if (stats) {
+    lines.push(`> ${stats}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function formatStatsMd(message) {
+  const parts = [];
+  if (message.tokens) {
+    parts.push(`Tokens: ${formatTokens(message.tokens.input)} in / ${formatTokens(message.tokens.output)} out`);
+    if (message.tokens.cache?.read) {
+      parts.push(`Cache: ${formatTokens(message.tokens.cache.read)} read`);
+    }
+  }
+  if (message.cost !== undefined && message.cost > 0) {
+    parts.push(`Cost: ${formatCost(message.cost)}`);
+  }
+  if (message.finish) {
+    parts.push(`Finish: ${message.finish}`);
+  }
+  return parts.length > 0 ? parts.join(" | ") : null;
+}
+function renderMessageMd(messageWithParts) {
+  const { message, parts } = messageWithParts;
+  if (message.role === "user") {
+    return renderUserMessageMd(message, parts);
+  } else {
+    return renderAssistantMessageMd(message, parts);
+  }
+}
+// src/render/markdown/index.ts
+function renderFullTranscript(data, _context) {
+  const { session: session2, projectName, messages, stats } = data;
+  const lines = [];
+  lines.push(`# ${session2.title}`);
+  lines.push("");
+  lines.push(`**Session:** \`${session2.id}\``);
+  if (projectName) {
+    lines.push(`**Project:** ${projectName}`);
+  }
+  lines.push(`**Created:** ${formatDateTime(session2.time.created)}`);
+  lines.push(`**Messages:** ${messages.length}`);
+  if (stats.model) {
+    lines.push(`**Model:** ${stats.model}`);
+  }
+  if (stats.totalTokensInput > 0 || stats.totalTokensOutput > 0) {
+    lines.push(`**Tokens:** ${formatTokens(stats.totalTokensInput)} in / ${formatTokens(stats.totalTokensOutput)} out`);
+  }
+  if (stats.totalCost > 0) {
+    lines.push(`**Cost:** ${formatCost(stats.totalCost)}`);
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  for (const msg of messages) {
+    lines.push(renderMessageMd(msg));
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function generateMarkdown(options) {
+  const { session: session2, messages, projectName, stats, includeHeader = true } = options;
+  const data = {
+    session: session2,
+    projectName,
+    messages,
+    timeline: [],
+    stats
+  };
+  const context = {
+    format: "markdown"
+  };
+  if (!includeHeader) {
+    const lines = [];
+    for (const msg of messages) {
+      lines.push(renderMessageMd(msg));
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  return renderFullTranscript(data, context);
+}
+// src/server.ts
+import { resolve, join as join3, sep } from "path";
+function isPathSafe(rootDir, targetPath) {
+  const resolvedRoot = resolve(rootDir);
+  const resolvedTarget = resolve(targetPath);
+  return resolvedTarget.startsWith(resolvedRoot + sep) || resolvedTarget === resolvedRoot;
+}
+function createRequestHandler(rootDir) {
+  const ROOT_DIR = resolve(rootDir);
+  return async function handleRequest(req) {
+    const url = new URL(req.url);
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      return new Response("Method Not Allowed", {
+        status: 405,
+        headers: { Allow: "GET, HEAD" }
+      });
+    }
+    let pathname;
+    try {
+      pathname = decodeURIComponent(url.pathname);
+    } catch {
+      return new Response("Bad Request", { status: 400 });
+    }
+    pathname = pathname.replace(/\0/g, "");
+    const targetPath = join3(ROOT_DIR, pathname);
+    if (!isPathSafe(ROOT_DIR, targetPath)) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    let file = Bun.file(targetPath);
+    let fileExists = await file.exists();
+    if (pathname.endsWith("/") || !fileExists) {
+      const indexPath = join3(targetPath, "index.html");
+      const indexFile = Bun.file(indexPath);
+      if (await indexFile.exists()) {
+        file = indexFile;
+        fileExists = true;
+      }
+    }
+    if (!fileExists) {
+      return new Response("Not Found", {
+        status: 404,
+        headers: { "Content-Type": "text/plain" }
+      });
+    }
+    const content = await file.arrayBuffer();
+    const etag = `W/"${Bun.hash(new Uint8Array(content)).toString(16)}"`;
+    const ifNoneMatch = req.headers.get("If-None-Match");
+    if (ifNoneMatch === etag) {
+      return new Response(null, {
+        status: 304,
+        headers: { ETag: etag }
+      });
+    }
+    const isHashed = /\.[a-f0-9]{8,}\.(js|css|png|jpg|jpeg|gif|svg|woff2?)$/i.test(targetPath);
+    const responseHeaders = {
+      "Content-Type": file.type,
+      "Content-Length": String(content.byteLength),
+      ETag: etag,
+      "Cache-Control": isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600"
+    };
+    if (req.method === "HEAD") {
+      return new Response(null, { headers: responseHeaders });
+    }
+    return new Response(content, { headers: responseHeaders });
+  };
+}
+async function serve(options) {
+  const { directory, port, open = true } = options;
+  const handleRequest = createRequestHandler(directory);
+  let server;
+  try {
+    server = Bun.serve({
+      port,
+      fetch: handleRequest,
+      error(error) {
+        console.error("Server error:", error);
+        return new Response("Internal Server Error", { status: 500 });
+      }
+    });
+  } catch (err) {
+    const error = err;
+    if (error.code === "EADDRINUSE") {
+      console.error(`Error: Port ${port} is already in use`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  const serverUrl = `http://localhost:${port}`;
+  console.log(`
+Server running at ${serverUrl}`);
+  console.log(`Press Ctrl+C to stop
+`);
+  if (open) {
+    openBrowser(serverUrl);
+  }
+  const sigintHandler = () => shutdown("SIGINT");
+  const sigtermHandler = () => shutdown("SIGTERM");
+  function shutdown(signal) {
+    console.log(`
+Received ${signal}, shutting down...`);
+    process.off("SIGINT", sigintHandler);
+    process.off("SIGTERM", sigtermHandler);
+    server.stop();
+    console.log("Server stopped");
+    process.exit(0);
+  }
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  await new Promise(() => {});
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    Bun.spawn(["open", url]);
+  } else if (platform === "win32") {
+    Bun.spawn(["cmd", "/c", "start", "", url]);
+  } else {
+    Bun.spawn(["xdg-open", url]);
+  }
+}
+// src/utils/update-notifier.ts
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+import { mkdir as mkdir2 } from "fs/promises";
+var PACKAGE_NAME = "opencode-replay";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+function detectPackageManager() {
+  const modulePath = import.meta.dir;
+  if (modulePath.includes(".bun") || modulePath.includes("bun/install")) {
+    return "bun";
+  }
+  if (process.env.BUN_INSTALL) {
+    return "bun";
+  }
+  if (typeof Bun !== "undefined") {
+    const bunInstallPath = join4(homedir2(), ".bun");
+    try {
+      if (Bun.file(bunInstallPath).size) {
+        return "bun";
+      }
+    } catch {}
+  }
+  return "npm";
+}
+function getCachePath() {
+  const cacheDir = process.env.XDG_CACHE_HOME || join4(homedir2(), ".cache");
   return join4(cacheDir, "opencode-replay", "update-check.json");
 }
 async function readCache() {
@@ -2262,11 +3111,11 @@ async function readCache() {
   } catch {}
   return null;
 }
-async function writeCache(data) {
+async function writeCache(data2) {
   try {
     const cachePath = getCachePath();
     await mkdir2(join4(cachePath, ".."), { recursive: true });
-    await Bun.write(cachePath, JSON.stringify(data));
+    await Bun.write(cachePath, JSON.stringify(data2));
   } catch {}
 }
 async function fetchLatestVersion() {
@@ -2280,8 +3129,8 @@ async function fetchLatestVersion() {
     if (!response.ok) {
       return null;
     }
-    const data = await response.json();
-    return data.version || null;
+    const data2 = await response.json();
+    return data2.version || null;
   } catch {
     return null;
   }
@@ -2379,6 +3228,74 @@ async function notifyIfUpdateAvailable(currentVersion) {
   }
 }
+// src/gist.ts
+var {spawn } = globalThis.Bun;
+class GistError extends Error {
+  code;
+  constructor(message2, code) {
+    super(message2);
+    this.code = code;
+    this.name = "GistError";
+  }
+}
+async function isGhInstalled() {
+  try {
+    const proc = spawn(["gh", "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function isGhAuthenticated() {
+  try {
+    const proc = spawn(["gh", "auth", "status"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function createGist(files, options = {}) {
+  if (!await isGhInstalled()) {
+    throw new GistError("GitHub CLI (gh) not found. Install it from https://cli.github.com/", "NOT_INSTALLED");
+  }
+  if (!await isGhAuthenticated()) {
+    throw new GistError("Not authenticated with GitHub CLI. Run: gh auth login", "NOT_AUTHENTICATED");
+  }
+  const cmd = ["gh", "gist", "create"];
+  if (options.description) {
+    cmd.push("--desc", options.description);
+  }
+  if (options.public) {
+    cmd.push("--public");
+  }
+  cmd.push(...files);
+  const proc = spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new GistError(`gh gist create failed: ${stderr.trim() || "Unknown error"}`, "CREATE_FAILED");
+  }
+  const gistUrl = stdout.trim();
+  const gistId = gistUrl.split("/").pop() || "";
+  if (!gistId) {
+    throw new GistError(`Failed to parse gist ID from output: ${gistUrl}`, "CREATE_FAILED");
+  }
+  const previewUrl = `https://gisthost.github.io/?${gistId}/index.html`;
+  return { gistId, gistUrl, previewUrl };
+}
 // src/index.ts
 var colors = {
   reset: "\x1B[0m",
@@ -2401,19 +3318,19 @@ function color(text, ...codes) {
 }
 var quietMode = false;
 var verboseMode = false;
-function log(message) {
+function log(message2) {
   if (!quietMode) {
-    console.log(message);
+    console.log(message2);
   }
 }
-function debug(message) {
+function debug(message2) {
   if (verboseMode && !quietMode) {
-    console.log(color("[debug]", colors.gray) + " " + message);
+    console.log(color("[debug]", colors.gray) + " " + message2);
   }
 }
-function writeProgress(message) {
+function writeProgress(message2) {
   if (!quietMode) {
-    process.stdout.write(message);
+    process.stdout.write(message2);
   }
 }
 function formatProgress(progress) {
@@ -2532,6 +3449,27 @@ var { values } = parseArgs({
       type: "string",
       description: "GitHub repo (OWNER/NAME) for commit links"
     },
+    format: {
+      type: "string",
+      short: "f",
+      default: "html",
+      description: "Output format: html (default), md"
+    },
+    stdout: {
+      type: "boolean",
+      default: false,
+      description: "Output to stdout (markdown only)"
+    },
+    gist: {
+      type: "boolean",
+      default: false,
+      description: "Upload to GitHub Gist after generation"
+    },
+    "gist-public": {
+      type: "boolean",
+      default: false,
+      description: "Make gist public (default: secret)"
+    },
     help: {
       type: "boolean",
       short: "h",
@@ -2557,8 +3495,12 @@ Usage:
 Options:
   --all                  Generate for all projects (default: current project only)
   -a, --auto             Auto-name output directory from project/session name
-  -o, --output <dir>     Output directory (default: ./opencode-replay-output)
+  -o, --output <path>    Output directory (HTML) or file (markdown)
   -s, --session <id>     Generate for specific session only
+  -f, --format <type>    Output format: html (default), md
+  --stdout               Output to stdout (markdown only, requires --session)
+  --gist                 Upload HTML to GitHub Gist after generation
+  --gist-public          Make gist public (default: secret)
   --json                 Include raw JSON export alongside HTML
   --open                 Open in browser after generation
   --storage <path>       Custom storage path (default: ~/.local/share/opencode/storage)
@@ -2572,7 +3514,7 @@ Options:
   -v, --version          Show version
 Examples:
-  opencode-replay                     # Current project's sessions
+  opencode-replay                     # Current project's sessions (HTML)
   opencode-replay --all               # All projects
   opencode-replay -a                  # Auto-name output (e.g., ./my-project-replay)
   opencode-replay -o ./my-transcripts # Custom output directory
@@ -2580,7 +3522,19 @@ Examples:
   opencode-replay --serve             # Generate and serve via HTTP
   opencode-replay --serve --port 8080 # Serve on custom port
   opencode-replay --serve --no-generate -o ./existing  # Serve existing output
-  opencode-replay --repo sst/opencode   # Add GitHub links to git commits
+  opencode-replay --repo sst/opencode # Add GitHub links to git commits
+Markdown Output:
+  opencode-replay -f md -s ses_xxx                 # Markdown to stdout
+  opencode-replay -f md -s ses_xxx -o transcript   # Markdown to file
+  opencode-replay -f md -s ses_xxx | gh gist create --filename transcript.md -
+GitHub Gist:
+  opencode-replay --gist              # Upload to secret gist
+  opencode-replay --gist --gist-public  # Upload to public gist
+  opencode-replay -s ses_xxx --gist   # Upload specific session to gist
+  Requires GitHub CLI (https://cli.github.com/) to be installed and authenticated.
 `);
   process.exit(0);
 }
@@ -2601,6 +3555,36 @@ if (isNaN(port) || port < 1 || port > 65535) {
   console.error("Error: Invalid port number");
   process.exit(1);
 }
+var format = (values.format ?? "html").toLowerCase();
+if (format !== "html" && format !== "md" && format !== "markdown") {
+  console.error(color("Error:", colors.red, colors.bold) + ` Invalid format: ${values.format}`);
+  console.error("Valid formats: html, md (or markdown)");
+  process.exit(1);
+}
+var isMarkdownFormat = format === "md" || format === "markdown";
+if (values.stdout) {
+  if (!isMarkdownFormat) {
+    console.error(color("Error:", colors.red, colors.bold) + " --stdout requires --format md");
+    console.error("HTML output to stdout is not supported.");
+    process.exit(1);
+  }
+  if (!values.session) {
+    console.error(color("Error:", colors.red, colors.bold) + " --stdout requires --session");
+    console.error("Specify a session with -s <session_id> for stdout output.");
+    process.exit(1);
+  }
+  quietMode = true;
+}
+if (values.gist) {
+  if (isMarkdownFormat) {
+    console.error(color("Error:", colors.red, colors.bold) + " --gist requires --format html (default)");
+    console.error("Use --format md | gh gist create --filename transcript.md - for markdown gists.");
+    process.exit(1);
+  }
+}
+if (values["gist-public"] && !values.gist) {
+  console.error(color("Warning:", colors.yellow, colors.bold) + " --gist-public has no effect without --gist");
+}
 try {
   await readdir2(storagePath);
   const projectDir = join5(storagePath, "project");
@@ -2651,6 +3635,61 @@ if (values.repo && !repoInfo) {
   console.error("Expected format: OWNER/NAME (e.g., sst/opencode)");
   process.exit(1);
 }
+if (isMarkdownFormat) {
+  if (values.all) {
+    console.error(color("Error:", colors.red, colors.bold) + " --format md does not support --all");
+    console.error("Markdown output is single-session only. Use -s <session_id>");
+    process.exit(1);
+  }
+  if (values.serve) {
+    console.error(color("Error:", colors.red, colors.bold) + " --serve is not supported with --format md");
+    console.error("Use --format html (default) for serving via HTTP.");
+    process.exit(1);
+  }
+  if (!values.session) {
+    console.error(color("Error:", colors.red, colors.bold) + " --format md requires --session");
+    console.error("Specify a session with -s <session_id>");
+    process.exit(1);
+  }
+  try {
+    const projects = await listProjects(storagePath);
+    let foundSession = null;
+    for (const project of projects) {
+      const sessions = await listSessions(storagePath, project.id);
+      const session2 = sessions.find((s) => s.id === values.session);
+      if (session2) {
+        foundSession = { session: session2, projectName: project.name };
+        break;
+      }
+    }
+    if (!foundSession) {
+      console.error(color("Error:", colors.red, colors.bold) + ` Session not found: ${values.session}`);
+      process.exit(1);
+    }
+    const messages = await getMessagesWithParts(storagePath, foundSession.session.id);
+    const stats = calculateSessionStats(messages);
+    const markdown2 = generateMarkdown({
+      session: foundSession.session,
+      messages,
+      projectName: foundSession.projectName,
+      stats,
+      includeHeader: true
+    });
+    if (values.stdout) {
+      process.stdout.write(markdown2);
+    } else if (values.output) {
+      const outputPath = values.output.endsWith(".md") ? values.output : `${values.output}.md`;
+      await Bun.write(outputPath, markdown2);
+      console.log(resolve2(outputPath));
+    } else {
+      process.stdout.write(markdown2);
+    }
+  } catch (error) {
+    console.error(color("Error:", colors.red, colors.bold) + " " + (error instanceof Error ? error.message : error));
+    process.exit(1);
+  }
+  process.exit(0);
+}
 log(color("opencode-replay", colors.bold, colors.cyan));
 log(color("---------------", colors.dim));
 log(color("Storage:", colors.dim) + ` ${storagePath}`);
@@ -2682,6 +3721,7 @@ if (values["no-generate"]) {
       sessionId: values.session,
       includeJson: values.json ?? false,
       repo: repoInfo,
+      gistMode: values.gist ?? false,
       onProgress: (progress) => {
         const msg = formatProgress(progress);
         if (msg) {
@@ -2696,13 +3736,52 @@ if (values["no-generate"]) {
       process.exit(1);
     }
     log(color("Done!", colors.green, colors.bold) + ` Generated ${formatStats(stats)}`);
-    console.log(resolve2(outputDir));
+    if (!values.gist) {
+      console.log(resolve2(outputDir));
+    }
   } catch (error) {
     process.stdout.write("\r\x1B[K");
     console.error(color("Error:", colors.red, colors.bold) + " " + (error instanceof Error ? error.message : error));
     process.exit(1);
   }
 }
+if (values.gist && !values["no-generate"]) {
+  log("");
+  log(color("Uploading to GitHub Gist...", colors.cyan));
+  try {
+    const gistFiles = await collectGistFiles(resolve2(outputDir));
+    if (gistFiles.length === 0) {
+      console.error(color("Error:", colors.red, colors.bold) + " No files found to upload");
+      process.exit(1);
+    }
+    debug(`Found ${gistFiles.length} files to upload`);
+    const description = values.session ? `OpenCode transcript: ${values.session}` : values.all ? "OpenCode transcripts: All projects" : "OpenCode transcripts";
+    const result = await createGist(gistFiles, {
+      public: values["gist-public"] ?? false,
+      description
+    });
+    log("");
+    log(color("Gist created!", colors.green, colors.bold));
+    log(color("Gist URL:", colors.dim) + ` ${result.gistUrl}`);
+    log(color("Preview:", colors.dim) + ` ${result.previewUrl}`);
+    console.log(result.previewUrl);
+    if (values.open) {
+      openInBrowser(result.previewUrl);
+    }
+  } catch (error) {
+    if (error instanceof GistError) {
+      console.error(color("Error:", colors.red, colors.bold) + ` ${error.message}`);
+      if (error.code === "NOT_INSTALLED") {
+        console.error(color("Install GitHub CLI:", colors.dim) + " https://cli.github.com/");
+      } else if (error.code === "NOT_AUTHENTICATED") {
+        console.error(color("Authenticate with:", colors.dim) + " gh auth login");
+      }
+    } else {
+      console.error(color("Error:", colors.red, colors.bold) + " " + (error instanceof Error ? error.message : error));
+    }
+    process.exit(1);
+  }
+}
 if (values.serve) {
   await notifyIfUpdateAvailable(currentVersion);
   await serve({
@@ -2710,7 +3789,7 @@ if (values.serve) {
     port,
     open: values.open ?? true
   });
-} else if (values.open) {
+} else if (values.open && !values.gist) {
   const indexPath = resolve2(outputDir, "index.html");
   openInBrowser(indexPath);
 }
@@ -2727,3 +3806,16 @@ function openInBrowser(target) {
     Bun.spawn(["xdg-open", target]);
   }
 }
+async function collectGistFiles(dir) {
+  const files = [];
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join5(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectGistFiles(fullPath));
+    } else if (entry.name.endsWith(".html") || entry.name.endsWith(".css") || entry.name.endsWith(".js")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}