openAgent

1#!/usr/bin/env bun
2 
3import path from "path"
4import { parseArgs } from "util"
5import { pathToFileURL } from "url"
6import {
7  DESKTOP_NATIVE_LOCALES,
8  desktopNativePluralCategories,
9  type DesktopNativeLocale,
10} from "../packages/app/src/i18n/desktop-native"
11 
12type Locale = Exclude<DesktopNativeLocale, "en">
13const locales = DESKTOP_NATIVE_LOCALES.filter((locale): locale is Locale => locale !== "en")
14 
15const languages = {
16  ar: "Arabic",
17  br: "Brazilian Portuguese",
18  bs: "Bosnian",
19  da: "Danish",
20  de: "German",
21  es: "Spanish",
22  fr: "French",
23  ja: "Japanese",
24  ko: "Korean",
25  no: "Norwegian Bokmal",
26  pl: "Polish",
27  ru: "Russian",
28  uk: "Ukrainian",
29  th: "Thai",
30  tr: "Turkish",
31  hi: "Hindi",
32  nl: "Dutch",
33  id: "Indonesian",
34  vi: "Vietnamese",
35  it: "Italian",
36  ur: "Urdu",
37  pa: "Punjabi (Shahmukhi)",
38  az: "Azerbaijani (Latin)",
39  fi: "Finnish",
40  sv: "Swedish",
41  am: "Amharic",
42  bg: "Bulgarian",
43  bn: "Bengali",
44  ca: "Catalan",
45  cs: "Czech",
46  dv: "Dhivehi",
47  dz: "Dzongkha",
48  el: "Greek",
49  et: "Estonian",
50  fa: "Persian",
51  fo: "Faroese",
52  hr: "Croatian",
53  hu: "Hungarian",
54  hy: "Armenian",
55  is: "Icelandic",
56  ka: "Georgian",
57  km: "Khmer",
58  lo: "Lao",
59  lt: "Lithuanian",
60  lv: "Latvian",
61  mk: "Macedonian",
62  mn: "Mongolian (Cyrillic)",
63  ms: "Malay",
64  my: "Burmese",
65  ne: "Nepali",
66  ro: "Romanian",
67  si: "Sinhala",
68  sk: "Slovak",
69  sl: "Slovenian",
70  sq: "Albanian",
71  sr: "Serbian (Cyrillic)",
72  tg: "Tajik",
73  tk: "Turkmen",
74  uz: "Uzbek (Latin)",
75  zh: "Simplified Chinese",
76  zht: "Traditional Chinese",
77} as const satisfies Record<Locale, string>
78 
79type Dictionary = Record<string, string>
80type Drift = ReturnType<typeof findDrift>
81type Domain = { name: string; source: string; target: string; drift: Drift }
82 
83const desktopLocales = new Set<Locale>(locales)
84const root = path.resolve(import.meta.dir, "..")
85 
86export function parseTranslationArgs(args: string[]) {
87  const parsed = parseArgs({
88    args,
89    options: {
90      concurrency: { type: "string", short: "c", default: "4" },
91      model: { type: "string", default: "opencode/gpt-5.5" },
92      variant: { type: "string", default: "xhigh" },
93      "dry-run": { type: "boolean", default: false },
94      check: { type: "boolean", default: false },
95      help: { type: "boolean", short: "h", default: false },
96    },
97    allowPositionals: true,
98  })
99  const target = parsed.positionals[0] ?? "all"
100  const concurrency = Number(parsed.values.concurrency)
101 
102  if (!parsed.values.help && parsed.positionals.length !== 1) throw new Error("Pass one locale or 'all'.")
103  if (target !== "all" && !isLocale(target)) throw new Error(`Unknown locale '${target}'.`)
104  if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error("Concurrency must be a positive integer.")
105 
106  return {
107    target,
108    concurrency: target === "all" ? concurrency : 1,
109    model: parsed.values.model,
110    variant: parsed.values.variant,
111    dryRun: parsed.values["dry-run"],
112    check: parsed.values.check,
113    help: parsed.values.help,
114  }
115}
116 
117export function targetFiles(locale: Locale) {
118  return [
119    `packages/app/src/i18n/${locale}.ts`,
120    `packages/ui/src/i18n/${locale}.ts`,
121    ...(desktopLocales.has(locale) ? [`packages/desktop/src/renderer/i18n/${locale}.ts`] : []),
122  ]
123}
124 
125export function glossaryFile(locale: Locale) {
126  if (locale === "zh") return ".opencode/glossary/zh-cn.md"
127  if (locale === "zht") return ".opencode/glossary/zh-tw.md"
128  return `.opencode/glossary/${locale}.md`
129}
130 
131export function findDrift(source: Dictionary, target: Dictionary, locale?: Locale) {
132  const pluralVariants = new Map(
133    (locale
134      ? pluralFamilies(source).flatMap((key) =>
135          desktopNativePluralCategories(locale)
136            .filter((category) => category !== "one" && category !== "other")
137            .map((category) => [`${key}.${category}`, `${key}.other`] as const),
138        )
139      : []) as ReadonlyArray<readonly [string, string]>,
140  )
141  return {
142    missing: [
143      ...Object.keys(source).filter((key) => !Object.hasOwn(target, key)),
144      ...Array.from(pluralVariants.keys()).filter((key) => !Object.hasOwn(target, key)),
145    ],
146    extra: Object.keys(target).filter((key) => !Object.hasOwn(source, key) && !pluralVariants.has(key)),
147    placeholders: [
148      ...Object.keys(source).filter(
149        (key) => Object.hasOwn(target, key) && tokens(source[key]).join() !== tokens(target[key]).join(),
150      ),
151      ...Array.from(pluralVariants.entries())
152        .filter(
153          ([key, sourceKey]) =>
154            Object.hasOwn(target, key) && tokens(source[sourceKey]).join() !== tokens(target[key]).join(),
155        )
156        .map(([key]) => key),
157    ],
158  }
159}
160 
161export function sessionIDFromEvents(output: string) {
162  const match = output.match(/"sessionID"\s*:\s*"([^"]+)"/)
163  if (!match?.[1]) throw new Error("OpenCode did not report a session ID.")
164  return match[1]
165}
166 
167export function sessionModels(value: unknown) {
168  if (!isRecord(value) || !Array.isArray(value.messages))
169    throw new Error("OpenCode returned an invalid session export.")
170  return value.messages.flatMap((message) => {
171    if (!isRecord(message) || !isRecord(message.info) || message.info.role !== "assistant") return []
172    if (typeof message.info.providerID !== "string" || typeof message.info.modelID !== "string") {
173      throw new Error("OpenCode session export omitted the assistant model.")
174    }
175    return [
176      {
177        model: `${message.info.providerID}/${message.info.modelID}`,
178        variant: typeof message.info.variant === "string" ? message.info.variant : undefined,
179      },
180    ]
181  })
182}
183 
184export function modelVariants(output: string, model: string) {
185  const normalized = output.replaceAll("\r\n", "\n")
186  const marker = `${model}\n`
187  const start = normalized.indexOf(marker)
188  if (start < 0) throw new Error(`Model not found: ${model}`)
189  const provider = model.split("/")[0]
190  const rest = normalized.slice(start + marker.length)
191  const next = rest.search(new RegExp(`^${escapeRegExp(provider)}/`, "m"))
192  const metadata: unknown = JSON.parse((next < 0 ? rest : rest.slice(0, next)).trim())
193  if (!isRecord(metadata) || !isRecord(metadata.variants)) throw new Error(`Model variants not found: ${model}`)
194  return metadata.variants
195}
196 
197export function translationConfig(agent: string, model: string, targets: string[]) {
198  return {
199    $schema: "https://opencode.ai/config.json",
200    model,
201    default_agent: agent,
202    share: "disabled" as const,
203    formatter: false,
204    lsp: false,
205    snapshot: false,
206    agent: {
207      [agent]: {
208        mode: "primary" as const,
209        model,
210        permission: {
211          "*": "deny" as const,
212          read: "allow" as const,
213          glob: "allow" as const,
214          grep: "allow" as const,
215          webfetch: "allow" as const,
216          websearch: "allow" as const,
217          edit: Object.fromEntries([["*", "deny"], ...targets.map((target) => [target, "allow"])]),
218        },
219      },
220    },
221  }
222}
223 
224export function unexpectedChanges(before: Record<string, string>, after: Record<string, string>, allowed: string[]) {
225  const targets = new Set(allowed)
226  return [...new Set([...Object.keys(before), ...Object.keys(after)])]
227    .filter((file) => !targets.has(file) && before[file] !== after[file])
228    .sort()
229}
230 
231export async function runPool<T, R>(items: readonly T[], concurrency: number, task: (item: T) => Promise<R>) {
232  const results = new Map<number, R>()
233  const entries = items.entries()
234  const worker = async (): Promise<void> => {
235    const next = entries.next()
236    if (next.done) return
237    results.set(next.value[0], await task(next.value[1]))
238    await worker()
239  }
240 
241  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker))
242  return Array.from(results.entries())
243    .sort((a, b) => a[0] - b[0])
244    .map((entry) => entry[1])
245}
246 
247async function main() {
248  const options = parseTranslationArgs(Bun.argv.slice(2))
249  if (options.help) {
250    console.log(`
251Usage: bun run translate:app -- <locale|all> [options]
252 
253Synchronizes product app translations with the English app, UI, and desktop dictionaries.
254 
255Options:
256  -c, --concurrency <count>  Maximum parallel OpenCode runs for 'all' (default: 4)
257      --model <provider/id>  OpenCode model (default: opencode/gpt-5.5)
258      --variant <name>       Model variant (default: xhigh)
259      --dry-run              Report drift without running OpenCode
260      --check                Exit nonzero when translation drift exists
261  -h, --help                 Show this help message
262 
263Examples:
264  bun run translate:app -- fr
265  bun run translate:app -- all --concurrency 4
266`)
267    return
268  }
269 
270  const selected = options.target === "all" ? locales : [options.target]
271  const plans = await Promise.all(selected.map((locale) => inspect(locale)))
272  plans.forEach(report)
273  const pending = plans.filter((plan) => plan.domains.some((domain) => changed(domain.drift)))
274  if (options.check) {
275    if (pending.length) process.exitCode = 1
276    return
277  }
278  if (options.dryRun || pending.length === 0) return
279 
280  const targets = pending.flatMap((plan) => plan.domains.map((domain) => domain.target))
281  const baseline = await worktreeSnapshot()
282  const variant = await resolveModelVariant(options.model, options.variant)
283  console.log(`Resolved ${options.model} (${options.variant}): ${JSON.stringify(variant)}`)
284  const template = await commandTemplate()
285  const results = await runPool(pending, options.concurrency, (plan) =>
286    translate(plan, template, options.model, options.variant).catch((error) => ({
287      locale: plan.locale,
288      code: 1,
289      stdout: "",
290      stderr: error instanceof Error ? error.message : String(error),
291    })),
292  )
293 
294  results.forEach((result) => {
295    if (result.stdout) process.stdout.write(`\n[${result.locale}]\n${result.stdout}`)
296    if (result.stderr) process.stderr.write(`\n[${result.locale}]\n${result.stderr}`)
297  })
298 
299  const failed = results.filter((result) => result.code !== 0)
300  const checks = await runPool(pending, options.concurrency, (plan) => check(plan.locale))
301  const incomplete = checks.filter((result) => result.code !== 0)
302  const escaped = unexpectedChanges(baseline, await worktreeSnapshot(), targets)
303  incomplete.forEach((result) => {
304    if (result.stdout) process.stderr.write(`\n[${result.locale} verification]\n${result.stdout}`)
305    if (result.stderr) process.stderr.write(`\n[${result.locale} verification]\n${result.stderr}`)
306  })
307 
308  if (failed.length === 0 && incomplete.length === 0 && escaped.length === 0) {
309    console.log(`\nTranslated ${pending.map((plan) => plan.locale).join(", ")}.`)
310    return
311  }
312 
313  if (failed.length) console.error(`\nOpenCode failed for: ${failed.map((result) => result.locale).join(", ")}`)
314  if (incomplete.length)
315    console.error(`Translation remains incomplete for: ${incomplete.map((plan) => plan.locale).join(", ")}`)
316  if (escaped.length) console.error(`Translation changed files outside its locale targets: ${escaped.join(", ")}`)
317  process.exitCode = 1
318}
319 
320async function worktreeSnapshot() {
321  const groups = await Promise.all([
322    gitPaths(["diff", "--name-only", "-z", "HEAD"]),
323    gitPaths(["ls-files", "--others", "--exclude-standard", "-z"]),
324  ])
325  const files = [...new Set(groups.flat())]
326  return Object.fromEntries(
327    await Promise.all(
328      files.map(async (file) => {
329        const target = Bun.file(path.join(root, file))
330        if (!(await target.exists())) return [file, "<missing>"] as const
331        const hash = new Bun.CryptoHasher("sha256")
332        hash.update(await target.arrayBuffer())
333        return [file, hash.digest("hex")] as const
334      }),
335    ),
336  )
337}
338 
339async function gitPaths(args: string[]) {
340  const proc = Bun.spawn(["git", ...args], {
341    cwd: root,
342    stdin: "ignore",
343    stdout: "pipe",
344    stderr: "pipe",
345  })
346  const result = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited])
347  if (result[2] !== 0) throw new Error(result[1] || `git ${args.join(" ")} failed`)
348  return result[0].split("\0").filter(Boolean)
349}
350 
351async function check(locale: Locale) {
352  const proc = Bun.spawn([process.execPath, import.meta.path, locale, "--check"], {
353    cwd: root,
354    stdin: "ignore",
355    stdout: "pipe",
356    stderr: "pipe",
357  })
358  const result = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited])
359  return { locale, stdout: result[0], stderr: result[1], code: result[2] }
360}
361 
362async function inspect(locale: Locale) {
363  const domains = await Promise.all(
364    targetFiles(locale).map(async (target) => {
365      const source = target.replace(`/${locale}.ts`, "/en.ts")
366      const dictionaries = await Promise.all([dictionary(source), dictionary(target)])
367      return {
368        name: target.includes("packages/app/") ? "app" : target.includes("packages/ui/") ? "ui" : "desktop",
369        source,
370        target,
371        drift: findDrift(dictionaries[0], dictionaries[1], locale),
372      }
373    }),
374  )
375  return { locale, language: languages[locale], domains }
376}
377 
378async function dictionary(file: string) {
379  const module: unknown = await import(pathToFileURL(path.join(root, file)).href)
380  if (typeof module !== "object" || module === null || !("dict" in module) || !isDictionary(module.dict)) {
381    throw new Error(`Invalid translation dictionary: ${file}`)
382  }
383  return module.dict
384}
385 
386async function commandTemplate() {
387  return (await Bun.file(path.join(root, "script/translate-app.md")).text()).trim()
388}
389 
390async function translate(
391  plan: { locale: Locale; language: string; domains: Domain[] },
392  template: string,
393  model: string,
394  variant: string,
395) {
396  const glossary = glossaryFile(plan.locale)
397  const glossaryContent = (await Bun.file(path.join(root, glossary)).exists())
398    ? await Bun.file(path.join(root, glossary)).text()
399    : undefined
400  const prompt = template.replaceAll("$1", plan.locale).replaceAll(
401    "$ARGUMENTS",
402    JSON.stringify(
403      {
404        locale: plan.locale,
405        language: plan.language,
406        glossary: glossaryContent ? { file: glossary, content: glossaryContent } : undefined,
407        domains: plan.domains.map((domain) => ({
408          source: domain.source,
409          target: domain.target,
410          ...domain.drift,
411        })),
412      },
413      null,
414      2,
415    ),
416  )
417  const agent = `translate-app-${plan.locale}-${process.pid}`
418  const env = isolatedEnvironment()
419  env.OPENCODE_DISABLE_PROJECT_CONFIG = "1"
420  env.OPENCODE_CONFIG_CONTENT = JSON.stringify(
421    translationConfig(
422      agent,
423      model,
424      plan.domains.map((domain) => domain.target),
425    ),
426  )
427 
428  const proc = Bun.spawn(
429    [
430      "opencode",
431      "--pure",
432      "run",
433      "--dir",
434      root,
435      "--agent",
436      agent,
437      "--model",
438      model,
439      "--variant",
440      variant,
441      "--title",
442      `Translate app ${plan.locale}`,
443      "--format",
444      "json",
445    ],
446    {
447      cwd: root,
448      env,
449      stdin: "pipe",
450      stdout: "pipe",
451      stderr: "pipe",
452    },
453  )
454  const stdout = new Response(proc.stdout).text()
455  const stderr = new Response(proc.stderr).text()
456  await proc.stdin.write(prompt)
457  await proc.stdin.end()
458  const result = await Promise.all([stdout, stderr, proc.exited])
459  if (result[2] !== 0) return { locale: plan.locale, stdout: result[0], stderr: result[1], code: result[2] }
460 
461  const sessionID = sessionIDFromEvents(result[0])
462  const exported = Bun.spawn(["opencode", "--pure", "export", sessionID, "--sanitize"], {
463    cwd: root,
464    env,
465    stdout: "pipe",
466    stderr: "pipe",
467  })
468  const exportResult = await Promise.all([
469    new Response(exported.stdout).text(),
470    new Response(exported.stderr).text(),
471    exported.exited,
472  ])
473  if (exportResult[2] !== 0) {
474    return { locale: plan.locale, stdout: textFromEvents(result[0]), stderr: exportResult[1], code: exportResult[2] }
475  }
476 
477  const session: unknown = JSON.parse(exportResult[0])
478  const observed = sessionModels(session)
479  const mismatch = observed.length === 0 || observed.some((item) => item.model !== model || item.variant !== variant)
480  const actual = Array.from(new Set(observed.map((item) => `${item.model} (${item.variant ?? "default"})`))).join(", ")
481  return {
482    locale: plan.locale,
483    stdout: `${textFromEvents(result[0])}\nVerified session model: ${actual}\n`,
484    stderr: mismatch
485      ? `Requested ${model} (${variant}), but session used ${actual || "no assistant model"}.\n`
486      : result[1],
487    code: mismatch ? 1 : 0,
488  }
489}
490 
491function report(plan: { locale: Locale; domains: Domain[] }) {
492  const details = plan.domains
493    .map(
494      (domain) =>
495        `${domain.name}: ${domain.drift.missing.length} missing, ${domain.drift.extra.length} extra, ${domain.drift.placeholders.length} placeholder mismatches`,
496    )
497    .join("; ")
498  console.log(`[${plan.locale}] ${details}`)
499}
500 
501function changed(drift: Drift) {
502  return drift.missing.length > 0 || drift.extra.length > 0 || drift.placeholders.length > 0
503}
504 
505function isLocale(value: string): value is Locale {
506  return Object.hasOwn(languages, value)
507}
508 
509function isDictionary(value: unknown): value is Dictionary {
510  if (typeof value !== "object" || value === null || Array.isArray(value)) return false
511  return Object.values(value).every((item) => typeof item === "string")
512}
513 
514function pluralFamilies(dictionary: Dictionary) {
515  return Object.keys(dictionary)
516    .filter(
517      (key) =>
518        key.endsWith(".one") &&
519        dictionary[key].includes("{{count}}") &&
520        dictionary[`${key.slice(0, -4)}.other`]?.includes("{{count}}"),
521    )
522    .map((key) => key.slice(0, -4))
523}
524 
525function isRecord(value: unknown): value is Record<string, unknown> {
526  return typeof value === "object" && value !== null && !Array.isArray(value)
527}
528 
529async function resolveModelVariant(model: string, variant: string) {
530  const provider = model.split("/")[0]
531  if (!provider || !model.includes("/")) throw new Error(`Model must use provider/model syntax: ${model}`)
532  const env = isolatedEnvironment()
533  env.OPENCODE_DISABLE_PROJECT_CONFIG = "1"
534  const proc = Bun.spawn(["opencode", "--pure", "models", provider, "--verbose"], {
535    cwd: root,
536    env,
537    stdin: "ignore",
538    stdout: "pipe",
539    stderr: "pipe",
540  })
541  const result = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text(), proc.exited])
542  if (result[2] !== 0) throw new Error(result[1] || `Unable to resolve model: ${model}`)
543  const variants = modelVariants(result[0], model)
544  if (!Object.hasOwn(variants, variant)) throw new Error(`Variant '${variant}' is not configured for ${model}.`)
545  return variants[variant]
546}
547 
548function isolatedEnvironment() {
549  const env = { ...process.env }
550  delete env.OPENCODE_CONFIG
551  delete env.OPENCODE_CONFIG_DIR
552  delete env.OPENCODE_CONFIG_CONTENT
553  delete env.OPENCODE_PERMISSION
554  delete env.OPENCODE_AUTO_SHARE
555  return env
556}
557 
558function escapeRegExp(value: string) {
559  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
560}
561 
562export function textFromEvents(output: string) {
563  return output
564    .split(/\r?\n/)
565    .map((line) => line.trim())
566    .filter((line) => line.startsWith("{") && line.endsWith("}"))
567    .flatMap((line) => {
568      const event: unknown = JSON.parse(line)
569      if (!isRecord(event) || event.type !== "text" || !isRecord(event.part) || typeof event.part.text !== "string") {
570        return []
571      }
572      return [event.part.text.trim()]
573    })
574    .filter(Boolean)
575    .join("\n")
576}
577 
578function tokens(value: string) {
579  return Array.from(value.matchAll(/{{\s*([^}]+?)\s*}}/g), (match) => match[1] ?? "").sort()
580}
581 
582if (import.meta.main) {
583  main().catch((error) => {
584    console.error(error instanceof Error ? error.message : error)
585    process.exitCode = 1
586  })
587}
588