opencode-handoff 0.1.0 → 0.2.0

package/README.md

@@ -9,6 +9,7 @@ Inspired by Amp's handoff command - see their [post](https://ampcode.com/news/ha
 - `/handoff <goal>` command that analyzes the conversation and generates a continuation prompt
 - Guides the AI to include relevant `@file` references so the next session starts with context loaded
 - Opens a new session with the prompt as an editable draft
+- `read_session` tool for retrieving full conversation transcripts from previous sessions when the handoff summary isn't sufficient
 
 ## Requirements
 
@@ -53,6 +54,24 @@ ln -sf ~/.config/opencode/opencode-handoff/src/plugin.ts ~/.config/opencode/plug
 
 The AI analyzes the conversation, extracts key decisions and relevant files, generates a focused prompt, and creates a new session with that prompt ready to edit.
 
+### Reading Previous Session Transcripts
+
+When you use `/handoff`, the generated prompt includes a session reference line:
+
+```
+Continuing work from session sess_01jxyz123. When you lack specific information you can use read_session to get it.
+```
+
+This gives the AI in the new session access to the `read_session` tool, which can fetch the full conversation transcript from the source session. If the handoff summary doesn't include something you need, just ask - the AI can look it up.
+
+**Example:**
+
+```
+You: What were the specific error messages we saw earlier?
+```
+
+The AI will use `read_session` to retrieve details from the previous session that weren't included in the handoff summary.
+
 ## Contributing
 
 Contributions are welcome! Here's how to set up for development:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-handoff",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "Create focused handoff prompts for continuing work in new OpenCode sessions",
   "author": "Josh Thomas <josh@joshthomas.dev>",

package/src/plugin.ts

@@ -1,6 +1,46 @@
 import type { Plugin } from "@opencode-ai/plugin"
 import { tool } from "@opencode-ai/plugin"
 
+function formatTranscript(messages: Array<{ info: any; parts: any[] }>, limit?: number): string {
+  const lines: string[] = []
+
+  for (const msg of messages) {
+    if (msg.info.role === "user") {
+      lines.push("## User")
+      for (const part of msg.parts) {
+        if (part.type === "text" && !part.ignored) {
+          lines.push(part.text)
+        }
+        if (part.type === "file") {
+          lines.push(`[Attached: ${part.filename || "file"}]`)
+        }
+      }
+      lines.push("")
+    }
+
+    if (msg.info.role === "assistant") {
+      lines.push("## Assistant")
+      for (const part of msg.parts) {
+        if (part.type === "text") {
+          lines.push(part.text)
+        }
+        if (part.type === "tool" && part.state.status === "completed") {
+          lines.push(`[Tool: ${part.tool}] ${part.state.title}`)
+        }
+      }
+      lines.push("")
+    }
+  }
+
+  const output = lines.join("\n").trim()
+
+  if (messages.length >= (limit ?? 100)) {
+    return output + `\n\n(Showing ${messages.length} most recent messages. Use a higher 'limit' to see more.)`
+  }
+
+  return output + `\n\n(End of session - ${messages.length} messages)`
+}
+
 export const HandoffPlugin: Plugin = async (ctx) => ({
   config: async (config) => {
     config.command = config.command || {}
@@ -16,7 +56,9 @@ A good handoff frontloads everything the next session needs so it can start impl
 
 Analyze this conversation and extract what matters for continuing the work.
 
-1. FILE REFERENCES (Required)
+## OUTPUT FORMAT
+
+1. FILE REFERENCES
 
    Include all relevant @file references on a SINGLE LINE, space-separated.
 
@@ -36,22 +78,33 @@ The user controls what context matters. If they mentioned something to preserve,
 
 ---
 
-After generating the handoff message, IMMEDIATELY call handoff_prepare with the full message as a handoff prompt:
-\`handoff_prepare(prompt="...")\``,
+After generating the handoff message, IMMEDIATELY call handoff_session with the full message as a handoff prompt:
+\`handoff_session(prompt="...")\``,
     }
   },
 
   tool: {
-    handoff_prepare: tool({
-      description: "Prepare handoff by creating new session with generated prompt as draft",
+    handoff_session: tool({
+      description: "Create a new session with the handoff prompt as an editable draft",
       args: {
         prompt: tool.schema.string().describe("The generated handoff prompt"),
       },
       async execute(args, context) {
+        // Capture current session ID before switching to new session
+        const sourceSessionID = context.sessionID
+        const sessionReference = `Continuing work from session ${sourceSessionID}. When you lack specific information you can use read_session to get it.`
+        const fullPrompt = `${sessionReference}\n\n${args.prompt}`
+
+        // Double-append workaround for textarea resize bug:
+        // appendPrompt uses insertText() which bypasses onContentChange, so resize never triggers.
+        // First append sets height in old session, session_new preserves textarea element,
+        // second append populates new session with already-expanded textarea.
         await ctx.client.tui.clearPrompt()
+        await new Promise(r => setTimeout(r, 200))
+        await ctx.client.tui.appendPrompt({ body: { text: fullPrompt } })
         await ctx.client.tui.executeCommand({ body: { command: "session_new" } })
         await new Promise(r => setTimeout(r, 200))
-        await ctx.client.tui.appendPrompt({ body: { text: args.prompt } })
+        await ctx.client.tui.appendPrompt({ body: { text: fullPrompt } })
 
         await ctx.client.tui.showToast({
           body: {
@@ -64,6 +117,33 @@ After generating the handoff message, IMMEDIATELY call handoff_prepare with the
 
         return "Handoff prompt created in new session. Review and edit before sending."
       }
+    }),
+
+    read_session: tool({
+      description: "Read the conversation transcript from a previous session. Use this when you need specific information from the source session that wasn't included in the handoff summary.",
+      args: {
+        sessionID: tool.schema.string().describe("The full session ID (e.g., sess_01jxyz...)"),
+        limit: tool.schema.number().optional().describe("Maximum number of messages to read (defaults to 100, max 500)"),
+      },
+      async execute(args, context) {
+        const limit = Math.min(args.limit ?? 100, 500)
+
+        try {
+          const response = await ctx.client.session.messages({
+            path: { id: args.sessionID },
+            query: { limit }
+          })
+
+          if (!response.data || response.data.length === 0) {
+            return "Session has no messages or does not exist."
+          }
+
+          const formatted = formatTranscript(response.data, limit)
+          return formatted
+        } catch (error) {
+          return `Could not read session ${args.sessionID}: ${error instanceof Error ? error.message : 'Unknown error'}`
+        }
+      }
     })
   }
 })