openAgent

1import { describe, expect, test } from "bun:test"
2import {
3  findDrift,
4  glossaryFile,
5  modelVariants,
6  parseTranslationArgs,
7  runPool,
8  sessionIDFromEvents,
9  sessionModels,
10  targetFiles,
11  textFromEvents,
12  translationConfig,
13  unexpectedChanges,
14} from "./translate-app"
15 
16describe("translate app", () => {
17  test("parses one locale with the public model defaults", () => {
18    expect(parseTranslationArgs(["fr"])).toEqual({
19      target: "fr",
20      concurrency: 1,
21      model: "opencode/gpt-5.5",
22      variant: "xhigh",
23      dryRun: false,
24      check: false,
25      help: false,
26    })
27  })
28 
29  test("parses all locales with bounded concurrency overrides", () => {
30    expect(
31      parseTranslationArgs([
32        "all",
33        "--concurrency",
34        "7",
35        "--model",
36        "opencode/gpt-5.4",
37        "--variant",
38        "high",
39        "--dry-run",
40      ]),
41    ).toEqual({
42      target: "all",
43      concurrency: 7,
44      model: "opencode/gpt-5.4",
45      variant: "high",
46      dryRun: true,
47      check: false,
48      help: false,
49    })
50  })
51 
52  test("rejects unsupported targets and invalid concurrency", () => {
53    expect(() => parseTranslationArgs(["en"])).toThrow("Unknown locale")
54    expect(() => parseTranslationArgs(["fr", "de"])).toThrow("one locale")
55    expect(() => parseTranslationArgs(["all", "--concurrency", "0"])).toThrow("positive integer")
56  })
57 
58  test("parses fresh-process parity checks without requesting translation", () => {
59    expect(parseTranslationArgs(["fr", "--check"]).check).toBe(true)
60  })
61 
62  test("limits each locale to its app surfaces", () => {
63    expect(targetFiles("fr")).toEqual([
64      "packages/app/src/i18n/fr.ts",
65      "packages/ui/src/i18n/fr.ts",
66      "packages/desktop/src/renderer/i18n/fr.ts",
67    ])
68    expect(targetFiles("tr")).toEqual([
69      "packages/app/src/i18n/tr.ts",
70      "packages/ui/src/i18n/tr.ts",
71      "packages/desktop/src/renderer/i18n/tr.ts",
72    ])
73    expect(targetFiles("dv")).toEqual([
74      "packages/app/src/i18n/dv.ts",
75      "packages/ui/src/i18n/dv.ts",
76      "packages/desktop/src/renderer/i18n/dv.ts",
77    ])
78  })
79 
80  test("maps product locale codes to their glossaries", () => {
81    expect(glossaryFile("fr")).toBe(".opencode/glossary/fr.md")
82    expect(glossaryFile("zh")).toBe(".opencode/glossary/zh-cn.md")
83    expect(glossaryFile("zht")).toBe(".opencode/glossary/zh-tw.md")
84  })
85 
86  test("finds key and placeholder drift", () => {
87    expect(
88      findDrift(
89        { keep: "Hello {{name}}", missing: "Missing", changed: "{{one}} {{two}}" },
90        { keep: "Bonjour {{name}}", extra: "Extra", changed: "{{one}}" },
91      ),
92    ).toEqual({ missing: ["missing"], extra: ["extra"], placeholders: ["changed"] })
93  })
94 
95  test("accepts locale-specific CLDR plural variants", () => {
96    expect(
97      findDrift(
98        { "files.one": "{{count}} file", "files.other": "{{count}} files" },
99        {
100          "files.one": "{{count}} ملف",
101          "files.two": "ملفان: {{count}}",
102          "files.few": "{{count}} ملفات",
103          "files.many": "{{count}} ملفًا",
104          "files.zero": "{{count}} ملف",
105          "files.other": "{{count}} ملف",
106        },
107        "ar",
108      ),
109    ).toEqual({ missing: [], extra: [], placeholders: [] })
110  })
111 
112  test("reports missing locale-specific CLDR plural variants", () => {
113    const drift = findDrift(
114      { "files.one": "{{count}} file", "files.other": "{{count}} files" },
115      { "files.one": "{{count}} ملف", "files.other": "{{count}} ملف" },
116      "ar",
117    )
118    expect(drift.missing).toContain("files.few")
119  })
120 
121  test("reports placeholder drift in locale-specific CLDR plural variants", () => {
122    const drift = findDrift(
123      { "files.one": "{{count}} file", "files.other": "{{count}} files" },
124      {
125        "files.one": "{{count}} ملف",
126        "files.two": "ملفان: {{count}}",
127        "files.few": "{{count}} ملفات",
128        "files.many": "ملفات كثيرة",
129        "files.zero": "{{count}} ملف",
130        "files.other": "{{count}} ملف",
131      },
132      "ar",
133    )
134    expect(drift.placeholders).toContain("files.many")
135  })
136 
137  test("runs work with the requested maximum concurrency", async () => {
138    const active = new Set<number>()
139    const peaks: number[] = []
140    const result = await runPool([1, 2, 3, 4, 5], 2, async (item) => {
141      active.add(item)
142      peaks.push(active.size)
143      await Bun.sleep(5)
144      active.delete(item)
145      return item * 2
146    })
147 
148    expect(result).toEqual([2, 4, 6, 8, 10])
149    expect(Math.max(...peaks)).toBe(2)
150  })
151 
152  test("reads the actual model and variant from the completed session", () => {
153    expect(sessionIDFromEvents('shared: https://example.test\n{"type":"step_start","sessionID":"ses_test"}\n')).toBe(
154      "ses_test",
155    )
156    expect(
157      sessionModels({
158        messages: [
159          { info: { role: "user" } },
160          {
161            info: {
162              role: "assistant",
163              providerID: "opencode",
164              modelID: "gpt-5.5",
165              variant: "xhigh",
166            },
167          },
168        ],
169      }),
170    ).toEqual([{ model: "opencode/gpt-5.5", variant: "xhigh" }])
171    expect(
172      textFromEvents(
173        'shared: https://example.test\n{"type":"text","sessionID":"ses_test","part":{"text":"finished"}}\n',
174      ),
175    ).toBe("finished")
176  })
177 
178  test("resolves variants from verbose model output", () => {
179    const output = `opencode/other
180{"variants":{}}
181opencode/gpt-5.5
182{"variants":{"high":{"reasoningEffort":"high"},"xhigh":{"reasoningEffort":"xhigh"}}}
183opencode/next
184{"variants":{}}
185`
186    expect(modelVariants(output, "opencode/gpt-5.5")).toEqual({
187      high: { reasoningEffort: "high" },
188      xhigh: { reasoningEffort: "xhigh" },
189    })
190  })
191 
192  test("disables side effects and scopes edits for the translation agent", () => {
193    const config = translationConfig("translate-app-fr", "opencode/gpt-5.5", ["packages/app/src/i18n/fr.ts"])
194    expect(config.share).toBe("disabled")
195    expect(config.formatter).toBe(false)
196    expect(config.lsp).toBe(false)
197    expect(config.agent["translate-app-fr"].permission.webfetch).toBe("allow")
198    expect(config.agent["translate-app-fr"].permission.websearch).toBe("allow")
199    expect(config.agent["translate-app-fr"].permission.edit).toEqual({
200      "*": "deny",
201      "packages/app/src/i18n/fr.ts": "allow",
202    })
203  })
204 
205  test("detects edits outside the locale targets", () => {
206    expect(
207      unexpectedChanges(
208        { "script/translate-app.ts": "before" },
209        {
210          "script/translate-app.ts": "before",
211          "packages/app/src/i18n/fr.ts": "translated",
212          "packages/app/src/app.tsx": "unexpected",
213        },
214        ["packages/app/src/i18n/fr.ts"],
215      ),
216    ).toEqual(["packages/app/src/app.tsx"])
217    expect(unexpectedChanges({ "already-dirty.ts": "before" }, { "already-dirty.ts": "after" }, [])).toEqual([
218      "already-dirty.ts",
219    ])
220  })
221})
222