opencode-translate 0.0.12 → 0.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-translate",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "OpenCode plugin that lets the user chat in a configured source language while the main chat loop only sees English.",
   "type": "module",
   "main": "src/index.ts",

package/src/activation.ts

@@ -134,34 +134,28 @@ function mergeTranslatedMetadata(state: TranslateState, part: TextPartLike, engl
   }
 }
 
-// OpenCode's flag semantics, observed from packages/opencode and packages/ui:
+// OpenCode's flag semantics are not uniform across every UI path:
 //   synthetic: true  -> hidden from the user UI, still sent to the LLM
-//   ignored: true    -> hidden from the LLM, still shown in the user UI
-// The translation preview, activation banner, and failure notices are
-// user-facing status/diagnostic parts that must not leak into the LLM
-// prompt, so they use synthetic:false + ignored:true.
-function createSyntheticTextPart(
-  sessionID: string,
-  messageID: string,
-  text: string,
-  metadata: Record<string, unknown>,
-): TextPartLike {
-  return {
-    id: createSyntheticPartID(),
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-    synthetic: false,
-    ignored: true,
-    metadata,
-  }
-}
+//   ignored: true    -> hidden from the LLM, still shown in the main message UI
+//   both true        -> hidden from both (used for metadata-only marker
+//                       parts like the activation banner that exist purely
+//                       to carry state across reloads)
+// Some secondary UIs, including the web `/fork` dialog, only consider text
+// parts that are neither synthetic nor ignored. Persist translated user display
+// parts as non-ignored so those flows can find them; before model serialization,
+// `experimental.chat.messages.transform` marks those display parts ignored and
+// lets the synthetic English twins carry the actual prompt text.
+// The plugin's user-facing status text (translation preview, activation
+// banner, failure notice) lives inline on the source-language user part
+// itself rather than as sibling parts, because OpenCode's
+// `UserMessageDisplay` renders only the first non-synthetic text part
+// per user message.
 
 // LLM-only text part: hidden from the TUI but the only LLM-visible
 // representation of the user's source-language text. The original
-// user-authored part is marked `ignored:true` so the LLM never sees it,
-// and this synthetic English twin carries the actual prompt content.
+// user-authored part is marked `ignored:true` in the model-bound transform so
+// the LLM never sees it, and this synthetic English twin carries the actual
+// prompt content.
 function createLlmOnlyTextPart(
   sessionID: string,
   messageID: string,
@@ -180,6 +174,11 @@ function createLlmOnlyTextPart(
   }
 }
 
+function isTranslatedUserDisplayPart(part: TextPartLike): boolean {
+  if (!isTextPart(part) || part.synthetic === true) return false
+  return extractStateFromMetadata(asMetadata(part)) !== undefined
+}
+
 function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
 }
@@ -337,11 +336,21 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
         const nextParts: TextPartLike[] = []
         let eligibleIndex = 0
         const translationErrors: { part: TextPartLike; error: unknown }[] = []
+        // Track the first user-authored text part so the activation
+        // banner can be inlined onto it. OpenCode's `UserMessageDisplay`
+        // renders only the first non-synthetic text part per user
+        // message, so any standalone banner part is never visible in
+        // the TUI.
+        let firstUserTextPart: (TextPartLike & { text: string }) | undefined
 
         for (const part of output.parts as TextPartLike[]) {
           nextParts.push(part)
           if (!isUserAuthoredTextPart(part)) continue
 
+          if (firstUserTextPart === undefined) {
+            firstUserTextPart = part
+          }
+
           const currentEligibleIndex = eligibleIndex
           eligibleIndex += 1
           if (part.text.trim().length === 0) continue
@@ -369,15 +378,14 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
             // ONE text part per user message — the first non-synthetic —
             // so a sibling `synthetic:false + ignored:true` preview part
             // would never reach the screen. Combining them here keeps
-            // the original visible alongside the English twin while
-            // `ignored:true` still hides the whole thing from the LLM
-            // serializer (`message-v2.ts:773`); the LLM-only synthetic
-            // twin below carries the clean English prompt.
+            // the original visible alongside the English twin while still
+            // satisfying secondary UI filters like `/fork`, which require
+            // non-synthetic, non-ignored text. The transform hook marks this
+            // display part ignored in the model-bound copy.
             part.text = `${part.text}\n\n_→ EN: ${english}_`
-            part.ignored = true
 
             // LLM-only English twin. This is the actual prompt the model
-            // sees in place of the now-`ignored` source-language part.
+            // sees in place of the source-language display part.
             nextParts.push(
               createLlmOnlyTextPart(part.sessionID, part.messageID, english, {
                 translate_role: "llm_only_translation",
@@ -421,13 +429,36 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
         }
 
         if (activatedThisTurn) {
-          nextParts.push(
-            createSyntheticTextPart(input.sessionID, output.message.id, createActivationBannerText(options), {
+          const bannerText = createActivationBannerText(options)
+          // Inline the activation banner into the first user-authored
+          // text part so it actually reaches the TUI (see comment above
+          // for the single-text-part rendering constraint). The banner
+          // sits underneath the inline `→ EN: ...` preview that was
+          // appended during translation, giving the user a one-time
+          // confirmation that translation mode just turned on.
+          if (firstUserTextPart !== undefined) {
+            firstUserTextPart.text = `${firstUserTextPart.text}\n\n_${bannerText}_`
+          }
+          // Also emit the banner as a metadata-only synthetic part so
+          // `extractStoredState`'s canonical `translate_role ===
+          // "activation_banner"` marker is preserved across reloads.
+          // `synthetic:true + ignored:true` keeps it hidden from both
+          // the TUI and the LLM serializer; it exists purely as a
+          // database row carrying state metadata.
+          nextParts.push({
+            id: createSyntheticPartID(),
+            sessionID: input.sessionID,
+            messageID: output.message.id,
+            type: "text",
+            text: bannerText,
+            synthetic: true,
+            ignored: true,
+            metadata: {
               ...activeState,
               translate_role: "activation_banner",
               translate_spec_version: SPEC_VERSION,
-            }),
-          )
+            },
+          })
         }
 
         output.parts.splice(0, output.parts.length, ...(nextParts as typeof output.parts))
@@ -444,12 +475,15 @@ export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, de
         const activeState = resolved.state
         if (!activeState) return
 
-        // User parts need no in-place rewriting: the source-language text
-        // part is `ignored:true` so the LLM serializer skips it, and a
-        // synthetic English twin (created in `chat.message`) carries the
-        // actual prompt content. Only assistant parts still need their
-        // localized trailer stripped before re-entering the model.
         for (const message of output.messages as MessageWithPartsLike[]) {
+          if (message.info.role === "user") {
+            for (const part of message.parts) {
+              if (!isTranslatedUserDisplayPart(part)) continue
+              part.ignored = true
+            }
+            continue
+          }
+
           if (message.info.role !== "assistant") continue
           for (const part of message.parts) {
             if (!isTextPart(part)) continue