opencode-translate 1.0.5 → 1.0.7

package/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+export declare const OpencodeTranslate: Plugin
+
+export default OpencodeTranslate

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "opencode-translate",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "OpenCode plugin that lets the user chat in a configured language while the main chat loop only sees English.",
   "type": "module",
-  "main": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "index.d.ts",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,7 +22,8 @@
     "i18n"
   ],
   "files": [
-    "src",
+    "dist",
+    "index.d.ts",
     "LICENSE",
     "README.md"
   ],
@@ -29,6 +31,7 @@
     "access": "public"
   },
   "scripts": {
+    "build": "bun build src/index.ts --outfile dist/index.js --target node --format esm --packages external",
     "typecheck": "tsgo --noEmit",
     "format": "biome format --write .",
     "format:check": "biome format .",
@@ -38,7 +41,10 @@
     "check": "biome check --write .",
     "check:ci": "biome check .",
     "test": "bun test",
-    "test:coverage": "bun test --coverage"
+    "test:coverage": "bun test --coverage",
+    "test:package": "node scripts/package-smoke.mjs",
+    "prepare": "bun run build",
+    "prepack": "bun run build"
   },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.14.0"

package/src/activation/chat-message.ts

@@ -1,164 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import {
-  buildInboundTranslationError,
-  isUserAuthoredTextPart,
-  LLM_LANGUAGE,
-  NONCE_PATTERN,
-  normalizeReason,
-  type TextPartLike,
-  type TranslateState,
-} from "../constants"
-import { hashText } from "../translator"
-import { logError } from "./logging"
-import { mergeTranslatedMetadata } from "./metadata"
-import { createActivationBannerPart, createActivationBannerText, createLlmOnlyTextPart } from "./parts"
-import { cacheSessionState, createState, resolveSessionState } from "./state"
-import { findTriggerMatch, stripTriggerKeyword } from "./trigger"
-import { type HookContext, INACTIVE_ROOT_SESSION, type ResolvedSessionState } from "./types"
-
-type ChatMessageHook = NonNullable<Hooks["chat.message"]>
-type ChatMessageInput = Parameters<ChatMessageHook>[0]
-type ChatMessageOutput = Parameters<ChatMessageHook>[1]
-
-interface ActivationResult {
-  state?: TranslateState
-  activatedThisTurn: boolean
-  aborted: boolean
-}
-
-interface PartProcessingResult {
-  nextParts: TextPartLike[]
-  eligibleIndex: number
-  errors: { part: TextPartLike; error: unknown }[]
-  firstUserTextPart?: TextPartLike & { text: string }
-}
-
-async function activateFromTrigger(
-  ctx: HookContext,
-  input: ChatMessageInput,
-  output: ChatMessageOutput,
-  resolved: ResolvedSessionState,
-): Promise<ActivationResult> {
-  if (resolved.state || !resolved.canActivate)
-    return { state: resolved.state, activatedThisTurn: false, aborted: false }
-
-  const match = findTriggerMatch(output.parts as TextPartLike[], ctx.options.trigger)
-  if (!match) return { activatedThisTurn: false, aborted: false }
-
-  const part = output.parts[match.partArrayIndex] as TextPartLike & { text: string }
-  const originalText = part.text
-  part.text = stripTriggerKeyword(part.text, match.keyword, match.offset)
-  const state = createState(ctx.options)
-  if (!NONCE_PATTERN.test(state.translate_nonce)) {
-    part.text = originalText
-    await logError(ctx.client, new Error("Generated invalid translation nonce"))
-    return { activatedThisTurn: false, aborted: true }
-  }
-
-  cacheSessionState(input.sessionID, state)
-  return { state, activatedThisTurn: true, aborted: false }
-}
-
-async function translateUserPart(
-  ctx: HookContext,
-  state: TranslateState,
-  part: TextPartLike & { text: string },
-  eligibleIndex: number,
-  nextParts: TextPartLike[],
-  errors: { part: TextPartLike; error: unknown }[],
-) {
-  try {
-    const english = await ctx.translator.translateText({
-      text: part.text,
-      sourceLanguage: state.translate_user_lang,
-      targetLanguage: LLM_LANGUAGE,
-      direction: "inbound",
-    })
-    const sourceHash = hashText(part.text)
-    part.metadata = { ...(part.metadata ?? {}), ...mergeTranslatedMetadata(state, part, english) }
-    part.text = `${part.text}\n\n→ EN: ${english}`
-    nextParts.push(
-      createLlmOnlyTextPart(part.sessionID, part.messageID, english, {
-        translate_role: "llm_only_translation",
-        translate_nonce: state.translate_nonce,
-        translate_source_hash: sourceHash,
-        translate_part_index: eligibleIndex,
-      }),
-    )
-  } catch (error) {
-    errors.push({ part, error })
-    const reason = normalizeReason(error)
-    await logError(ctx.client, buildInboundTranslationError(state.translate_user_lang, reason))
-    const originalText = part.text
-    part.text = `${originalText}\n\n⚠️ Translation failed: ${reason}. Original text was sent to the model.`
-    part.ignored = true
-    nextParts.push(
-      createLlmOnlyTextPart(part.sessionID, part.messageID, originalText, {
-        translate_role: "llm_only_fallback",
-        translate_nonce: state.translate_nonce,
-        translate_part_index: eligibleIndex,
-      }),
-    )
-  }
-}
-
-async function processParts(
-  ctx: HookContext,
-  output: ChatMessageOutput,
-  state: TranslateState,
-): Promise<PartProcessingResult> {
-  const result: PartProcessingResult = { nextParts: [], eligibleIndex: 0, errors: [] }
-  for (const part of output.parts as TextPartLike[]) {
-    result.nextParts.push(part)
-    if (!isUserAuthoredTextPart(part)) continue
-    result.firstUserTextPart ??= part
-    const currentEligibleIndex = result.eligibleIndex
-    result.eligibleIndex += 1
-    if (part.text.trim().length === 0) continue
-    await translateUserPart(ctx, state, part, currentEligibleIndex, result.nextParts, result.errors)
-  }
-  return result
-}
-
-function appendActivationBanner(
-  ctx: HookContext,
-  input: ChatMessageInput,
-  output: ChatMessageOutput,
-  state: TranslateState,
-  processed: PartProcessingResult,
-) {
-  const bannerText = createActivationBannerText(ctx.options)
-  if (processed.firstUserTextPart !== undefined) {
-    processed.firstUserTextPart.text = `${processed.firstUserTextPart.text}\n\n${bannerText}`
-  }
-  processed.nextParts.push(createActivationBannerPart(input.sessionID, output.message.id, state, bannerText))
-}
-
-async function handleChatMessage(ctx: HookContext, input: ChatMessageInput, output: ChatMessageOutput) {
-  const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
-  const activation = await activateFromTrigger(ctx, input, output, resolved)
-  if (activation.aborted || !activation.state) return
-
-  const processed = await processParts(ctx, output, activation.state)
-  if (
-    activation.activatedThisTurn &&
-    processed.errors.length > 0 &&
-    processed.eligibleIndex === processed.errors.length
-  ) {
-    cacheSessionState(input.sessionID, INACTIVE_ROOT_SESSION)
-    return
-  }
-
-  if (activation.activatedThisTurn) appendActivationBanner(ctx, input, output, activation.state, processed)
-  output.parts.splice(0, output.parts.length, ...(processed.nextParts as typeof output.parts))
-}
-
-export function createChatMessageHook(ctx: HookContext): ChatMessageHook {
-  return async (input, output) => {
-    try {
-      await handleChatMessage(ctx, input, output)
-    } catch (error) {
-      await logError(ctx.client, error)
-    }
-  }
-}

package/src/activation/index.ts

@@ -1,38 +0,0 @@
-import type { Hooks, PluginInput, PluginOptions } from "@opencode-ai/plugin"
-import { type PluginClientLike, resolveOptions } from "../constants"
-import { createTranslator } from "../translator"
-import { createChatMessageHook } from "./chat-message"
-import { createMessagesTransformHook } from "./messages-transform"
-import { createToolExecuteAfterHook, createToolExecuteBeforeHook, resetQuestionSnapshots } from "./question-hooks"
-import { resetSessionStateCache } from "./state"
-import { createTextCompleteHook } from "./text-complete"
-import type { HookContext, HookDependencies } from "./types"
-
-export { extractStoredState } from "./state"
-export { findTriggerMatch, stripTriggerKeyword } from "./trigger"
-
-export function __resetActivationCacheForTest() {
-  resetSessionStateCache()
-  resetQuestionSnapshots()
-}
-
-export function createHooks(ctx: PluginInput, rawOptions: PluginOptions = {}, deps: HookDependencies = {}): Hooks {
-  if (process.env.OPENCODE_TRANSLATE_DISABLE === "1") return {}
-
-  const client = ctx.client as PluginClientLike
-  const options = resolveOptions(rawOptions)
-  const hookContext: HookContext = {
-    client,
-    directory: ctx.directory,
-    options,
-    translator: deps.translator ?? createTranslator(client, options),
-  }
-
-  return {
-    "chat.message": createChatMessageHook(hookContext),
-    "experimental.chat.messages.transform": createMessagesTransformHook(hookContext),
-    "experimental.text.complete": createTextCompleteHook(hookContext),
-    "tool.execute.before": createToolExecuteBeforeHook(hookContext),
-    "tool.execute.after": createToolExecuteAfterHook(hookContext),
-  }
-}

package/src/activation/logging.ts

@@ -1,11 +0,0 @@
-import { normalizeReason, PLUGIN_NAME, type PluginClientLike } from "../constants"
-
-export function logError(client: PluginClientLike, error: unknown) {
-  return client.app.log({
-    body: {
-      service: PLUGIN_NAME,
-      level: "error",
-      message: normalizeReason(error),
-    },
-  })
-}

package/src/activation/messages-transform.ts

@@ -1,44 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import { isTextPart, type MessageWithPartsLike } from "../constants"
-import { extractEnglishHistoryText } from "../formatting"
-import { getDisplayLanguageLabel } from "../labels"
-import { logError } from "./logging"
-import { isTranslatedUserDisplayPart } from "./metadata"
-import { resolveSessionState } from "./state"
-import type { HookContext } from "./types"
-
-type MessagesTransformHook = NonNullable<Hooks["experimental.chat.messages.transform"]>
-
-export function createMessagesTransformHook(ctx: HookContext): MessagesTransformHook {
-  return async (_input, output) => {
-    try {
-      const sessionID = output.messages[0]?.info.sessionID
-      if (!sessionID) return
-
-      const resolved = await resolveSessionState(ctx.client, ctx.directory, sessionID)
-      const activeState = resolved.state
-      if (!activeState) return
-
-      const extractContext = {
-        nonce: activeState.translate_nonce,
-        label: getDisplayLanguageLabel(activeState.translate_user_lang),
-      }
-
-      for (const message of output.messages as MessageWithPartsLike[]) {
-        if (message.info.role === "user") {
-          for (const part of message.parts) {
-            if (isTranslatedUserDisplayPart(part)) part.ignored = true
-          }
-          continue
-        }
-
-        if (message.info.role !== "assistant") continue
-        for (const part of message.parts) {
-          if (isTextPart(part)) part.text = extractEnglishHistoryText(part.text, extractContext)
-        }
-      }
-    } catch (error) {
-      await logError(ctx.client, error)
-    }
-  }
-}

package/src/activation/metadata.ts

@@ -1,41 +0,0 @@
-import {
-  isTextPart,
-  isTranslateStateRecord,
-  LLM_LANGUAGE,
-  type StoredTextMetadata,
-  type TextPartLike,
-  type TranslateState,
-} from "../constants"
-import { hashText } from "../translator"
-
-export function asMetadata(part: TextPartLike): StoredTextMetadata {
-  return (part.metadata ?? {}) as StoredTextMetadata
-}
-
-export function extractStateFromMetadata(metadata: StoredTextMetadata | undefined): TranslateState | undefined {
-  if (!isTranslateStateRecord(metadata)) return undefined
-  return {
-    translate_enabled: true,
-    translate_user_lang: metadata.translate_user_lang,
-    translate_llm_lang: LLM_LANGUAGE,
-    translate_nonce: metadata.translate_nonce,
-  }
-}
-
-export function mergeTranslatedMetadata(
-  state: TranslateState,
-  part: TextPartLike,
-  english: string,
-): Record<string, unknown> {
-  return {
-    ...(part.metadata ?? {}),
-    ...state,
-    translate_source_hash: hashText(part.text ?? ""),
-    translate_en: english,
-  }
-}
-
-export function isTranslatedUserDisplayPart(part: TextPartLike): boolean {
-  if (!isTextPart(part) || part.synthetic === true) return false
-  return extractStateFromMetadata(asMetadata(part)) !== undefined
-}

package/src/activation/parts.ts

@@ -1,46 +0,0 @@
-import { type ResolvedTranslateOptions, SPEC_VERSION, type TextPartLike, type TranslateState } from "../constants"
-import { createSyntheticPartID } from "../translator"
-
-export function createActivationBannerText(options: ResolvedTranslateOptions): string {
-  return `✓ Translation mode enabled · model: ${options.model} · language: ${options.lang}`
-}
-
-export function createLlmOnlyTextPart(
-  sessionID: string,
-  messageID: string,
-  text: string,
-  metadata: Record<string, unknown>,
-): TextPartLike {
-  return {
-    id: createSyntheticPartID(),
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-    synthetic: true,
-    ignored: false,
-    metadata,
-  }
-}
-
-export function createActivationBannerPart(
-  sessionID: string,
-  messageID: string,
-  state: TranslateState,
-  text: string,
-): TextPartLike {
-  return {
-    id: createSyntheticPartID(),
-    sessionID,
-    messageID,
-    type: "text",
-    text,
-    synthetic: true,
-    ignored: true,
-    metadata: {
-      ...state,
-      translate_role: "activation_banner",
-      translate_spec_version: SPEC_VERSION,
-    },
-  }
-}

package/src/activation/question-hooks.ts

@@ -1,126 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import { buildInboundTranslationError, LLM_LANGUAGE, normalizeReason } from "../constants"
-import {
-  isQuestionArgs,
-  type QuestionSnapshot,
-  type QuestionToolOutput,
-  restoreQuestionArgs,
-  restoreQuestionOutput,
-  snapshotQuestions,
-  translateQuestionArgs,
-} from "../question-tool"
-import { logError } from "./logging"
-import { resolveSessionState } from "./state"
-import { type HookContext, QUESTION_TOOL_ID } from "./types"
-
-const QUESTION_SNAPSHOT_LIMIT = 1_000
-
-const questionSnapshots = new Map<string, QuestionSnapshot>()
-
-function pruneQuestionSnapshots() {
-  while (questionSnapshots.size > QUESTION_SNAPSHOT_LIMIT) {
-    for (const callID of questionSnapshots.keys()) {
-      questionSnapshots.delete(callID)
-      break
-    }
-  }
-}
-
-export function resetQuestionSnapshots() {
-  questionSnapshots.clear()
-}
-
-export function createToolExecuteBeforeHook(ctx: HookContext): NonNullable<Hooks["tool.execute.before"]> {
-  return async (input, output) => {
-    try {
-      if (input.tool !== QUESTION_TOOL_ID) return
-      const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
-      const activeState = resolved.state
-      if (!activeState) return
-
-      if (!isQuestionArgs(output.args)) return
-      const args = output.args
-
-      const original = snapshotQuestions(args)
-      if (activeState.translate_user_lang !== LLM_LANGUAGE) {
-        try {
-          await translateQuestionArgs(args, (texts) =>
-            ctx.translator.translateTexts
-              ? ctx.translator.translateTexts({
-                  texts,
-                  sourceLanguage: LLM_LANGUAGE,
-                  targetLanguage: activeState.translate_user_lang,
-                  direction: "outbound",
-                })
-              : Promise.all(
-                  texts.map((text) =>
-                    ctx.translator.translateText({
-                      text,
-                      sourceLanguage: LLM_LANGUAGE,
-                      targetLanguage: activeState.translate_user_lang,
-                      direction: "outbound",
-                    }),
-                  ),
-                ),
-          )
-        } catch (error) {
-          args.questions.splice(0, args.questions.length, ...snapshotQuestions({ questions: original }))
-          await logError(ctx.client, error)
-          return
-        }
-      }
-
-      questionSnapshots.set(input.callID, {
-        original,
-        translated: snapshotQuestions(args),
-        userLanguage: activeState.translate_user_lang,
-      })
-      pruneQuestionSnapshots()
-    } catch (error) {
-      await logError(ctx.client, error)
-    }
-  }
-}
-
-export function createToolExecuteAfterHook(ctx: HookContext): NonNullable<Hooks["tool.execute.after"]> {
-  return async (input, output) => {
-    try {
-      if (input.tool !== QUESTION_TOOL_ID) return
-      const snapshot = questionSnapshots.get(input.callID)
-      if (!snapshot) return
-      questionSnapshots.delete(input.callID)
-      if (isQuestionArgs(input.args)) restoreQuestionArgs(input.args, snapshot.original)
-
-      if (snapshot.userLanguage === LLM_LANGUAGE) {
-        await restoreQuestionOutput(output as QuestionToolOutput, snapshot)
-        return
-      }
-
-      await restoreQuestionOutput(output as QuestionToolOutput, snapshot, {
-        translateCustomAnswers: (texts: readonly string[]) =>
-          ctx.translator.translateTexts
-            ? ctx.translator.translateTexts({
-                texts,
-                sourceLanguage: snapshot.userLanguage,
-                targetLanguage: LLM_LANGUAGE,
-                direction: "inbound",
-              })
-            : Promise.all(
-                texts.map((text) =>
-                  ctx.translator.translateText({
-                    text,
-                    sourceLanguage: snapshot.userLanguage,
-                    targetLanguage: LLM_LANGUAGE,
-                    direction: "inbound",
-                  }),
-                ),
-              ),
-        onTranslationError: async (error) => {
-          await logError(ctx.client, buildInboundTranslationError(snapshot.userLanguage, normalizeReason(error)))
-        },
-      })
-    } catch (error) {
-      await logError(ctx.client, error)
-    }
-  }
-}

package/src/activation/state.ts

@@ -1,97 +0,0 @@
-import { randomBytes } from "node:crypto"
-import {
-  isTextPart,
-  LLM_LANGUAGE,
-  type MessageWithPartsLike,
-  type PluginClientLike,
-  type ResolvedTranslateOptions,
-  type TranslateState,
-  unwrapData,
-} from "../constants"
-import { asMetadata, extractStateFromMetadata } from "./metadata"
-import {
-  type CachedSessionState,
-  INACTIVE_CHILD_SESSION,
-  INACTIVE_ROOT_SESSION,
-  type ResolvedSessionState,
-} from "./types"
-
-const sessionStateCache = new Map<string, CachedSessionState>()
-
-export function resetSessionStateCache() {
-  sessionStateCache.clear()
-}
-
-export function cacheSessionState(sessionID: string, state: CachedSessionState) {
-  sessionStateCache.set(sessionID, state)
-}
-
-export function createState(options: ResolvedTranslateOptions): TranslateState {
-  return {
-    translate_enabled: true,
-    translate_user_lang: options.lang,
-    translate_llm_lang: LLM_LANGUAGE,
-    translate_nonce: randomBytes(16).toString("hex"),
-  }
-}
-
-export function extractStoredState(messages: MessageWithPartsLike[]): TranslateState | undefined {
-  let fallback: TranslateState | undefined
-
-  for (const message of messages) {
-    for (const part of message.parts) {
-      if (!isTextPart(part)) continue
-      const metadata = asMetadata(part)
-      const state = extractStateFromMetadata(metadata)
-      if (!state) continue
-      if (metadata.translate_role === "activation_banner") return state
-      if (message.info.role === "user" && part.synthetic !== true && fallback === undefined) fallback = state
-    }
-  }
-
-  return fallback
-}
-
-function cachedStateResult(cached: CachedSessionState): ResolvedSessionState {
-  if (cached === INACTIVE_ROOT_SESSION) return { sessionActive: false, canActivate: true, storedMessages: [] }
-  if (cached === INACTIVE_CHILD_SESSION) return { sessionActive: false, canActivate: false, storedMessages: [] }
-  return { sessionActive: true, canActivate: false, state: cached, storedMessages: [] }
-}
-
-export async function resolveSessionState(
-  client: PluginClientLike,
-  directory: string | undefined,
-  sessionID: string,
-): Promise<ResolvedSessionState> {
-  const cached = sessionStateCache.get(sessionID)
-  if (cached !== undefined) return cachedStateResult(cached)
-
-  const session = unwrapData(
-    await client.session.get({
-      path: { id: sessionID },
-      query: { ...(directory ? { directory } : {}) },
-      throwOnError: true,
-    }),
-  )
-  if (session.parentID != null) {
-    sessionStateCache.set(sessionID, INACTIVE_CHILD_SESSION)
-    return { sessionActive: false, canActivate: false, storedMessages: [] }
-  }
-
-  const storedMessages = unwrapData(
-    await client.session.messages({
-      path: { id: sessionID },
-      query: { ...(directory ? { directory } : {}) },
-      throwOnError: true,
-    }),
-  )
-  const state = extractStoredState(storedMessages)
-  sessionStateCache.set(sessionID, state ?? INACTIVE_ROOT_SESSION)
-
-  return {
-    sessionActive: Boolean(state),
-    canActivate: !state,
-    state: state ?? undefined,
-    storedMessages,
-  }
-}

package/src/activation/text-complete.ts

@@ -1,50 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-import { LLM_LANGUAGE, type MessageWithPartsLike, unwrapData } from "../constants"
-import { composeTranslatedAssistantText, composeTranslationFailureText } from "../formatting"
-import { getDisplayLanguageLabel } from "../labels"
-import { logError } from "./logging"
-import { resolveSessionState } from "./state"
-import type { HookContext } from "./types"
-
-type TextCompleteHook = NonNullable<Hooks["experimental.text.complete"]>
-
-export function createTextCompleteHook(ctx: HookContext): TextCompleteHook {
-  return async (input, output) => {
-    try {
-      const resolved = await resolveSessionState(ctx.client, ctx.directory, input.sessionID)
-      const activeState = resolved.state
-      if (!activeState) return
-
-      const message = unwrapData(
-        await ctx.client.session.message({
-          path: { id: input.sessionID, messageID: input.messageID },
-          query: { ...(ctx.directory ? { directory: ctx.directory } : {}) },
-          throwOnError: true,
-        }),
-      ) as MessageWithPartsLike & { info: Record<string, unknown> }
-
-      if (message.info.role !== "assistant") return
-      if (message.info.summary === true) return
-      if (activeState.translate_user_lang === LLM_LANGUAGE || output.text.length === 0) return
-
-      try {
-        const translated = await ctx.translator.translateText({
-          text: output.text,
-          sourceLanguage: LLM_LANGUAGE,
-          targetLanguage: activeState.translate_user_lang,
-          direction: "outbound",
-        })
-        output.text = composeTranslatedAssistantText(
-          output.text,
-          getDisplayLanguageLabel(activeState.translate_user_lang),
-          translated,
-        )
-      } catch (error) {
-        output.text = composeTranslationFailureText(output.text)
-        await logError(ctx.client, error)
-      }
-    } catch (error) {
-      await logError(ctx.client, error)
-    }
-  }
-}