opencode-translate 0.1.2 → 0.2.0

package/src/activation/text-complete.ts

@@ -0,0 +1,51 @@
+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,
+          activeState.translate_nonce,
+        )
+      } catch (error) {
+        output.text = composeTranslationFailureText(output.text, activeState.translate_nonce)
+        await logError(ctx.client, error)
+      }
+    } catch (error) {
+      await logError(ctx.client, error)
+    }
+  }
+}

package/src/activation/trigger.ts

@@ -0,0 +1,57 @@
+import { isUserAuthoredTextPart, type TextPartLike } from "../constants"
+import type { TriggerMatch } from "./types"
+
+function escapeRegex(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+}
+
+export function findTriggerMatch(parts: TextPartLike[], triggerKeywords: string[]): TriggerMatch | undefined {
+  let eligibleIndex = 0
+  for (let partArrayIndex = 0; partArrayIndex < parts.length; partArrayIndex += 1) {
+    const part = parts[partArrayIndex]
+    if (!isUserAuthoredTextPart(part)) continue
+
+    let bestForPart: TriggerMatch | undefined
+    for (const keyword of triggerKeywords) {
+      const pattern = new RegExp(`(^|[ \\t\\r\\n\\f\\v])${escapeRegex(keyword)}(?=$|[ \\t\\r\\n\\f\\v])`)
+      const match = pattern.exec(part.text)
+      if (!match) continue
+      const offset = match.index + match[1].length
+      if (!bestForPart || offset < bestForPart.offset) bestForPart = { partArrayIndex, eligibleIndex, keyword, offset }
+    }
+
+    if (bestForPart) return bestForPart
+    eligibleIndex += 1
+  }
+
+  return undefined
+}
+
+export function stripTriggerKeyword(text: string, keyword: string, offset: number): string {
+  const lineStart = text.lastIndexOf("\n", offset - 1) + 1
+  const nextNewline = text.indexOf("\n", offset)
+  const lineEnd = nextNewline === -1 ? text.length : nextNewline
+  const line = text.slice(lineStart, lineEnd)
+  const localOffset = offset - lineStart
+
+  let rewrittenLine: string
+  if (localOffset === 0 && line.startsWith(`${keyword} `)) {
+    rewrittenLine = line.slice(keyword.length + 1)
+  } else if (
+    localOffset + keyword.length === line.length &&
+    localOffset > 0 &&
+    line.slice(localOffset - 1, localOffset) === " "
+  ) {
+    rewrittenLine = line.slice(0, localOffset - 1)
+  } else if (
+    localOffset > 0 &&
+    line.slice(localOffset - 1, localOffset) === " " &&
+    line.slice(localOffset + keyword.length, localOffset + keyword.length + 1) === " "
+  ) {
+    rewrittenLine = `${line.slice(0, localOffset - 1)} ${line.slice(localOffset + keyword.length + 1)}`
+  } else {
+    rewrittenLine = `${line.slice(0, localOffset)}${line.slice(localOffset + keyword.length)}`
+  }
+
+  return `${text.slice(0, lineStart)}${rewrittenLine}${text.slice(lineEnd)}`
+}

package/src/activation/types.ts

@@ -0,0 +1,41 @@
+import type { PluginClientLike, ResolvedTranslateOptions, TranslateState } from "../constants"
+
+export const INACTIVE_ROOT_SESSION = "inactive-root"
+export const INACTIVE_CHILD_SESSION = "inactive-child"
+export const QUESTION_TOOL_ID = "question"
+
+export type CachedSessionState = TranslateState | typeof INACTIVE_ROOT_SESSION | typeof INACTIVE_CHILD_SESSION
+
+export interface ResolvedSessionState {
+  sessionActive: boolean
+  canActivate: boolean
+  state?: TranslateState
+  storedMessages: import("../constants").MessageWithPartsLike[]
+}
+
+export interface TriggerMatch {
+  partArrayIndex: number
+  eligibleIndex: number
+  keyword: string
+  offset: number
+}
+
+interface TranslatorLike {
+  translateText(input: {
+    text: string
+    sourceLanguage: string
+    targetLanguage: string
+    direction: "inbound" | "outbound"
+  }): Promise<string>
+}
+
+export interface HookDependencies {
+  translator?: TranslatorLike
+}
+
+export interface HookContext {
+  client: PluginClientLike
+  directory?: string
+  options: ResolvedTranslateOptions
+  translator: TranslatorLike
+}