feat: add session export cli command

opencode session export [sessionID]

export session transcript to file

Positionals:
  sessionID  session id to export

Options:
  -o, --output      output file path
  -f, --format      output format
  [string] [choices: "markdown", "json"] [default: "markdown"]

Signed-off-by: Christian Stewart <[email protected]>

Author: paralin

packages/opencode/src/cli/cmd/session.ts

@@ -6,7 +6,7 @@ import { UI } from "../ui"
 import { Locale } from "../../util/locale"
 import { Flag } from "../../flag/flag"
 import { EOL } from "os"
-import path from "path"
+import * as prompts from "@clack/prompts"
 
 function pagerCmd(): string[] {
   const lessOptions = ["-R", "-S"]
@@ -38,7 +38,7 @@ function pagerCmd(): string[] {
 export const SessionCommand = cmd({
   command: "session",
   describe: "manage sessions",
-  builder: (yargs: Argv) => yargs.command(SessionListCommand).demandCommand(),
+  builder: (yargs: Argv) => yargs.command(SessionListCommand).command(SessionExportCommand).demandCommand(),
   async handler() {},
 })
 
@@ -133,3 +133,119 @@ function formatSessionJSON(sessions: Session.Info[]): string {
   }))
   return JSON.stringify(jsonData, null, 2)
 }
+
+export const SessionExportCommand = cmd({
+  command: "export [sessionID]",
+  describe: "export session transcript to file",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("sessionID", {
+        describe: "session id to export",
+        type: "string",
+      })
+      .option("output", {
+        alias: "o",
+        describe: "output file path",
+        type: "string",
+      })
+      .option("format", {
+        alias: "f",
+        describe: "output format",
+        type: "string",
+        choices: ["markdown", "json"],
+        default: "markdown",
+      })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      let sessionID = args.sessionID
+
+      if (!sessionID) {
+        prompts.intro("Export session", {
+          output: process.stderr,
+        })
+
+        const sessions = []
+        for await (const session of Session.list()) {
+          sessions.push(session)
+        }
+
+        if (sessions.length === 0) {
+          prompts.log.error("No sessions found", {
+            output: process.stderr,
+          })
+          prompts.outro("Done", {
+            output: process.stderr,
+          })
+          return
+        }
+
+        sessions.sort((a, b) => b.time.updated - a.time.updated)
+
+        const selectedSession = await prompts.autocomplete({
+          message: "Select session to export",
+          maxItems: 10,
+          options: sessions.map((session) => ({
+            label: session.title,
+            value: session.id,
+            hint: `${new Date(session.time.updated).toLocaleString()} • ${session.id.slice(-8)}`,
+          })),
+          output: process.stderr,
+        })
+
+        if (prompts.isCancel(selectedSession)) {
+          throw new UI.CancelledError()
+        }
+
+        sessionID = selectedSession as string
+      }
+
+      const sessionInfo = await Session.get(sessionID!)
+
+      let content: string
+      let defaultExtension: string
+
+      if (args.format === "json") {
+        const sessionMessages = await Session.messages({ sessionID: sessionID! })
+        const exportData = {
+          info: sessionInfo,
+          messages: sessionMessages.map((msg) => ({
+            info: msg.info,
+            parts: msg.parts,
+          })),
+        }
+        content = JSON.stringify(exportData, null, 2)
+        defaultExtension = "json"
+      } else {
+        content = await Session.exportMarkdown({
+          sessionID: sessionID!,
+          includeThinking: true,
+          includeToolDetails: true,
+        })
+        defaultExtension = "md"
+      }
+
+      const outputPath = await (async () => {
+        if (args.output) return args.output
+        const defaultFilename = `session-${sessionInfo.id.slice(0, 8)}.${defaultExtension}`
+        const filenameInput = await prompts.text({
+          message: "Export filename",
+          defaultValue: defaultFilename,
+          output: process.stderr,
+        })
+
+        if (prompts.isCancel(filenameInput)) {
+          throw new UI.CancelledError()
+        }
+
+        return filenameInput.trim()
+      })()
+
+      await Bun.write(outputPath, content)
+
+      prompts.outro(`Session exported to ${outputPath}`, {
+        output: process.stderr,
+      })
+    })
+  },
+})

packages/opencode/src/session/index.ts

@@ -286,6 +286,55 @@ export namespace Session {
     },
   )
 
+  export const exportMarkdown = fn(
+    z.object({
+      sessionID: Identifier.schema("session"),
+      includeThinking: z.boolean().optional().default(true),
+      includeToolDetails: z.boolean().optional().default(true),
+    }),
+    async (input) => {
+      const sessionInfo = await get(input.sessionID)
+      const sessionMessages = await messages({ sessionID: input.sessionID })
+
+      let transcript = `# ${sessionInfo.title}\n\n`
+      transcript += `**Session ID:** ${sessionInfo.id}\n`
+      transcript += `**Created:** ${new Date(sessionInfo.time.created).toLocaleString()}\n`
+      transcript += `**Updated:** ${new Date(sessionInfo.time.updated).toLocaleString()}\n\n`
+      transcript += `---\n\n`
+
+      for (const msg of sessionMessages) {
+        const role = msg.info.role === "user" ? "User" : "Assistant"
+        transcript += `## ${role}\n\n`
+
+        for (const part of msg.parts) {
+          if (part.type === "text" && !part.synthetic) {
+            transcript += `${part.text}\n\n`
+          } else if (part.type === "reasoning") {
+            if (input.includeThinking) {
+              transcript += `_Thinking:_\n\n${part.text}\n\n`
+            }
+          } else if (part.type === "tool") {
+            transcript += `\`\`\`\nTool: ${part.tool}\n`
+            if (input.includeToolDetails && part.state.input) {
+              transcript += `\n**Input:**\n\`\`\`json\n${JSON.stringify(part.state.input, null, 2)}\n\`\`\``
+            }
+            if (input.includeToolDetails && part.state.status === "completed" && part.state.output) {
+              transcript += `\n**Output:**\n\`\`\`\n${part.state.output}\n\`\`\``
+            }
+            if (input.includeToolDetails && part.state.status === "error" && part.state.error) {
+              transcript += `\n**Error:**\n\`\`\`\n${part.state.error}\n\`\`\``
+            }
+            transcript += `\n\`\`\`\n\n`
+          }
+        }
+
+        transcript += `---\n\n`
+      }
+
+      return transcript
+    },
+  )
+
   export async function* list() {
     const project = Instance.project
     for (const item of await Storage.list(["session", project.id])) {