opencode-handoff 0.3.1 → 0.4.0

package/README.md

@@ -13,22 +13,29 @@ Inspired by Amp's handoff command - see their [post](https://ampcode.com/news/ha
 
 ## Requirements
 
-- [OpenCode](https://opencode.ai/) v1.0.143 or later
+- [OpenCode](https://opencode.ai/) v1.0.188 or later
 
 ## Installation
 
-Add to your OpenCode config (`~/.config/opencode/config.json`):
+Add to your OpenCode config (`~/.config/opencode/opencode.json`):
 
 ```json
 {
-  "plugin": ["opencode-handoff@0.3.1"]
+  "plugin": ["opencode-handoff"]
 }
 ```
 
 Restart OpenCode and you're ready to go.
 
-Pin to a specific version to ensure updates work correctly - OpenCode's lockfile won't re-resolve unpinned versions. To upgrade, change the version and restart.
+Optionally, pin to a specific version for stability:
 
+```json
+{
+  "plugin": ["opencode-handoff@0.4.0"]
+}
+```
+
+OpenCode fetches unpinned plugins from npm on each startup; pinned versions are cached and require a manual version bump to update.
 ### Local Development
 
 If you want to customize or contribute:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-handoff",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "description": "Create focused handoff prompts for continuing work in new OpenCode sessions",
   "author": "Josh Thomas <josh@joshthomas.dev>",
@@ -21,8 +21,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "^1.0.143",
-    "@opencode-ai/sdk": "^1.0.143",
+    "@opencode-ai/plugin": "^1.0.188",
+    "@opencode-ai/sdk": "^1.0.188",
     "zod": "^4.1.13"
   },
   "devDependencies": {

package/src/files.ts

@@ -2,12 +2,13 @@
  * File reference parsing and building for handoff sessions.
  *
  * Handles extraction of @file references from handoff prompts and
- * building file parts for injection into new sessions.
+ * building synthetic text parts that match OpenCode's Read tool output format.
  */
 
 import * as path from "node:path"
 import * as fs from "node:fs/promises"
-import type { FilePartInput } from "@opencode-ai/sdk"
+import type { TextPartInput } from "@opencode-ai/sdk"
+import { isBinaryFile, formatFileContent } from "./vendor"
 
 /**
  * File reference regex matching OpenCode's internal pattern.
@@ -34,33 +35,53 @@ export function parseFileReferences(text: string): Set<string> {
 }
 
 /**
- * Build file parts for files that exist.
+ * Build synthetic text parts matching OpenCode's Read tool output.
+ *
+ * Creates two synthetic text parts for each file:
+ * 1. Header describing the Read tool call
+ * 2. Formatted file content with line numbers
  *
  * @param directory - Project directory to resolve relative paths against
  * @param refs - Set of file path references to check
- * @returns Array of file parts for existing files (non-existent files are skipped)
+ * @returns Array of synthetic text parts (non-existent and binary files are skipped)
  */
-export async function buildFileParts(
+export async function buildSyntheticFileParts(
   directory: string,
   refs: Set<string>
-): Promise<FilePartInput[]> {
-  const fileParts: FilePartInput[] = []
+): Promise<TextPartInput[]> {
+  const parts: TextPartInput[] = []
 
   for (const ref of refs) {
     const filepath = path.resolve(directory, ref)
 
     try {
-      await fs.stat(filepath)
-      fileParts.push({
-        type: "file",
-        mime: "text/plain",
-        url: `file://${filepath}`,
-        filename: ref,
+      // Check if file exists
+      const stats = await fs.stat(filepath)
+      if (!stats.isFile()) continue
+
+      // Skip binary files
+      if (await isBinaryFile(filepath)) continue
+
+      // Read file content
+      const content = await fs.readFile(filepath, "utf-8")
+
+      // Create header part (matching OpenCode's prompt.ts:820 format)
+      parts.push({
+        type: "text",
+        synthetic: true,
+        text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: filepath })}`
+      })
+
+      // Create content part (matching OpenCode's ReadTool format)
+      parts.push({
+        type: "text",
+        synthetic: true,
+        text: formatFileContent(filepath, content)
       })
     } catch {
-      // Skip silently if file doesn't exist
+      // Skip silently if file can't be read
     }
   }
 
-  return fileParts
+  return parts
 }

package/src/plugin.ts

@@ -1,6 +1,6 @@
 import type { Plugin } from "@opencode-ai/plugin"
 import { HandoffSession, ReadSession } from "./tools"
-import { parseFileReferences, buildFileParts } from "./files"
+import { parseFileReferences, buildSyntheticFileParts } from "./files"
 
 const HANDOFF_COMMAND = `GOAL: You are creating a handoff message to continue work in a new session.
 
@@ -29,7 +29,9 @@ The user controls what context matters. If they mentioned something to preserve,
 </instructions>
 
 <user_input>
-The user's guidance for continuing work. If empty, the handoff should capture a natural continuation of the current conversation's direction.
+This is what the next session should focus on. Use it to shape your handoff's direction—don't investigate or search, just incorporate the intent into your context and goals.
+
+If empty, capture a natural continuation of the current conversation's direction.
 
 USER: $ARGUMENTS
 </user_input>
@@ -76,7 +78,7 @@ export const HandoffPlugin: Plugin = async (ctx) => {
       const fileRefs = parseFileReferences(text)
       if (fileRefs.size === 0) return
 
-      const fileParts = await buildFileParts(ctx.directory, fileRefs)
+      const fileParts = await buildSyntheticFileParts(ctx.directory, fileRefs)
       if (fileParts.length === 0) return
 
       // Inject file parts via noReply

package/src/tools.ts

@@ -32,16 +32,7 @@ export const HandoffSession = (client: OpencodeClient) => {
         ? `${sessionReference}\n\n${fileRefs}\n\n${args.prompt}`
         : `${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 client.tui.clearPrompt()
-      await new Promise(r => setTimeout(r, 50))
-      await client.tui.appendPrompt({ body: { text: fullPrompt } })
       await client.tui.executeCommand({ body: { command: "session_new" } })
-      await client.tui.clearPrompt()
-      await new Promise(r => setTimeout(r, 50))
       await client.tui.appendPrompt({ body: { text: fullPrompt } })
 
       await client.tui.showToast({

package/src/vendor.ts

@@ -0,0 +1,102 @@
+/**
+ * Code extracted from OpenCode for compatibility.
+ *
+ * Source: https://github.com/sst/opencode
+ * File: packages/opencode/src/tool/read.ts
+ *
+ * These functions and constants are copied to ensure our synthetic file parts
+ * match OpenCode's Read tool output exactly.
+ */
+
+import * as path from "node:path"
+import * as fs from "node:fs/promises"
+
+/**
+ * Constants from OpenCode's ReadTool
+ */
+export const DEFAULT_READ_LIMIT = 2000
+export const MAX_LINE_LENGTH = 2000
+
+/**
+ * Binary file extensions (from OpenCode's ReadTool)
+ */
+const BINARY_EXTENSIONS = new Set([
+  ".zip", ".tar", ".gz", ".exe", ".dll", ".so", ".class", ".jar", ".war",
+  ".7z", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".odt", ".ods",
+  ".odp", ".bin", ".dat", ".obj", ".o", ".a", ".lib", ".wasm", ".pyc", ".pyo"
+])
+
+/**
+ * Check if a file is binary (copied from OpenCode's ReadTool)
+ */
+export async function isBinaryFile(filepath: string): Promise<boolean> {
+  const ext = path.extname(filepath).toLowerCase()
+
+  // Check extension first
+  if (BINARY_EXTENSIONS.has(ext)) {
+    return true
+  }
+
+  try {
+    const buffer = await fs.readFile(filepath)
+    if (!buffer) return false
+
+    const fileSize = buffer.length
+    if (fileSize === 0) return false
+
+    const bufferSize = Math.min(4096, fileSize)
+    const bytes = buffer.subarray(0, bufferSize)
+
+    let nonPrintableCount = 0
+    for (let i = 0; i < bytes.length; i++) {
+      const byte = bytes[i]
+      if (byte === undefined) continue
+      if (byte === 0) return true
+      if (byte < 9 || (byte > 13 && byte < 32)) {
+        nonPrintableCount++
+      }
+    }
+
+    // If >30% non-printable characters, consider it binary
+    return nonPrintableCount / bytes.length > 0.3
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Format file content matching OpenCode's Read tool output format.
+ *
+ * @param _filepath - Absolute path to the file (unused in output, kept for signature compatibility)
+ * @param content - File content as string
+ * @returns Formatted output with line numbers in <file> tags
+ */
+export function formatFileContent(_filepath: string, content: string): string {
+  const lines = content.split("\n")
+  const limit = DEFAULT_READ_LIMIT
+  const offset = 0
+
+  const raw = lines.slice(offset, offset + limit).map((line) => {
+    return line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line
+  })
+
+  const formatted = raw.map((line, index) => {
+    return `${(index + offset + 1).toString().padStart(5, "0")}| ${line}`
+  })
+
+  let output = "<file>\n"
+  output += formatted.join("\n")
+
+  const totalLines = lines.length
+  const lastReadLine = offset + formatted.length
+  const hasMoreLines = totalLines > lastReadLine
+
+  if (hasMoreLines) {
+    output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`
+  } else {
+    output += `\n\n(End of file - total ${totalLines} lines)`
+  }
+  output += "\n</file>"
+
+  return output
+}