dialekt 0.1.0 → 0.1.1

package/src/translation/orchestrator.test.ts

@@ -1,25 +1,25 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Either } from 'effect';
-import { runTranslation } from './orchestrator.js';
-import type { TranslationAdapter, ResourceRef, AdapterReadError, AdapterWriteError } from '../adapter/types.js';
-import { TranslationFailedError } from './types.js';
-
-describe('runTranslation', () => {
-  it('translates missing keys across adapters and writes merged results', async () => {
+import { describe, expect, it } from "vitest";
+import { Effect, Either } from "effect";
+import { runTranslation } from "./orchestrator.js";
+import type {
+  TranslationAdapter,
+  ResourceRef,
+  AdapterReadError,
+  AdapterWriteError,
+} from "../adapter/types.js";
+import { TranslationFailedError } from "./types.js";
+
+describe("runTranslation", () => {
+  it("translates missing keys across adapters and writes merged results", async () => {
     const writes: Array<{ locale: string; resource: string; entries: Record<string, string> }> = [];
 
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () =>
-        Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en'
-            ? { hello: 'Hello', bye: 'Bye' }
-            : { hello: 'Hallo' },
-        ),
+        Effect.succeed(locale === "en" ? { hello: "Hello", bye: "Bye" } : { hello: "Hallo" }),
       writeResource: (locale: string, resource: ResourceRef, entries: Record<string, string>) =>
         Effect.sync(() => {
           writes.push({ locale, resource: resource.key, entries });
@@ -27,7 +27,7 @@ describe('runTranslation', () => {
     };
 
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: (ctx: { keys: readonly string[]; targetLocale: string }) =>
         Effect.succeed(
           Object.fromEntries(ctx.keys.map((k: string) => [k, `${ctx.targetLocale}:${k}`])),
@@ -37,43 +37,38 @@ describe('runTranslation', () => {
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
     await Effect.runPromise(program);
     expect(writes).toHaveLength(1);
-    expect(writes[0]!.locale).toBe('de');
-    expect(writes[0]!.entries).toEqual({ hello: 'Hallo', bye: 'de:bye' });
+    expect(writes[0]!.locale).toBe("de");
+    expect(writes[0]!.entries).toEqual({ hello: "Hallo", bye: "de:bye" });
   });
 
-  it('respects concurrency limit', async () => {
+  it("respects concurrency limit", async () => {
     let maxConcurrent = 0;
     let current = 0;
 
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () =>
-        Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en'
-            ? { a: 'A', b: 'B', c: 'C', d: 'D' }
-            : {},
-        ),
+        Effect.succeed(locale === "en" ? { a: "A", b: "B", c: "C", d: "D" } : {}),
       writeResource: () => Effect.void,
     };
 
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: (ctx: { keys: readonly string[] }) =>
         Effect.gen(function* () {
           current++;
           maxConcurrent = Math.max(maxConcurrent, current);
-          yield* Effect.sleep('50 millis');
+          yield* Effect.sleep("50 millis");
           current--;
           return Object.fromEntries(ctx.keys.map((k: string) => [k, k]));
         }),
@@ -82,8 +77,8 @@ describe('runTranslation', () => {
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 10, charsPerToken: 3.0, concurrency: 2 },
     });
 
@@ -91,55 +86,51 @@ describe('runTranslation', () => {
     expect(maxConcurrent).toBeLessThanOrEqual(2);
   });
 
-  it('collects failures and reports them at the end', async () => {
+  it("collects failures and reports them at the end", async () => {
     const adapter: TranslationAdapter = {
-      name: 'test',
+      name: "test",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () =>
-        Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en' ? { a: 'A' } : {},
-        ),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: (locale: string) => Effect.succeed(locale === "en" ? { a: "A" } : {}),
       writeResource: () => Effect.void,
     };
 
     const strategy = {
-      name: 'one-shot' as const,
-      translateChunk: () =>
-        Effect.fail(
-          new TranslationFailedError({ keys: ['a'], cause: 'boom' }),
-        ),
+      name: "one-shot" as const,
+      translateChunk: () => Effect.fail(new TranslationFailedError({ keys: ["a"], cause: "boom" })),
     };
 
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
-    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<void, TranslationFailedError>;
-    if (exit._tag === 'Left') {
-      expect((exit.left as TranslationFailedError)._tag).toBe('TranslationFailedError');
+    const exit = (await Effect.runPromise(Effect.either(program))) as Either.Either<
+      void,
+      TranslationFailedError
+    >;
+    if (exit._tag === "Left") {
+      expect((exit.left as TranslationFailedError)._tag).toBe("TranslationFailedError");
     } else {
-      throw new Error('Expected Left');
+      throw new Error("Expected Left");
     }
   });
 
-  it('handles empty adapters list', async () => {
+  it("handles empty adapters list", async () => {
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: () => Effect.succeed({}),
     };
 
     const program = runTranslation({
       adapters: [],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
@@ -147,26 +138,26 @@ describe('runTranslation', () => {
     expect(true).toBe(true); // should not throw
   });
 
-  it('handles single-locale adapter (no targets)', async () => {
+  it("handles single-locale adapter (no targets)", async () => {
     const adapter: TranslationAdapter = {
-      name: 'mono',
+      name: "mono",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: () => Effect.succeed({ hello: 'Hello' }),
+      listLocales: () => Effect.succeed(["en"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: () => Effect.succeed({ hello: "Hello" }),
       writeResource: () => Effect.void,
     };
 
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: () => Effect.succeed({}),
     };
 
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
@@ -174,21 +165,18 @@ describe('runTranslation', () => {
     expect(true).toBe(true); // should not throw
   });
 
-  it('handles multiple resources', async () => {
+  it("handles multiple resources", async () => {
     const writes: Array<{ locale: string; resource: string }> = [];
     const adapter: TranslationAdapter = {
-      name: 'multi',
+      name: "multi",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
+      listLocales: () => Effect.succeed(["en", "de"]),
       listResources: () =>
         Effect.succeed([
-          { key: 'auth', label: 'auth' },
-          { key: 'validation', label: 'validation' },
+          { key: "auth", label: "auth" },
+          { key: "validation", label: "validation" },
         ]),
-      readResource: (locale: string) =>
-        Effect.succeed(
-          locale === 'en' ? { k1: 'V1' } : {},
-        ),
+      readResource: (locale: string) => Effect.succeed(locale === "en" ? { k1: "V1" } : {}),
       writeResource: (locale: string, resource: ResourceRef) =>
         Effect.sync(() => {
           writes.push({ locale, resource: resource.key });
@@ -196,7 +184,7 @@ describe('runTranslation', () => {
     };
 
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: (ctx: { keys: readonly string[] }) =>
         Effect.succeed(Object.fromEntries(ctx.keys.map((k: string) => [k, k]))),
     };
@@ -204,8 +192,8 @@ describe('runTranslation', () => {
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
@@ -213,41 +201,40 @@ describe('runTranslation', () => {
     expect(writes.length).toBeGreaterThanOrEqual(2);
   });
 
-  it('handles adapter readResource failure', async () => {
+  it("handles adapter readResource failure", async () => {
     const adapter: TranslationAdapter = {
-      name: 'broken',
+      name: "broken",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: () => Effect.fail(new Error('read failed') as AdapterReadError),
+      listLocales: () => Effect.succeed(["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: () => Effect.fail(new Error("read failed") as AdapterReadError),
       writeResource: () => Effect.void,
     };
 
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: () => Effect.succeed({}),
     };
 
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de'],
+      sourceLocale: "en",
+      targetLocales: ["de"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('read failed');
+    await expect(Effect.runPromise(program)).rejects.toThrow("read failed");
   });
 
-  it('handles multiple target locales', async () => {
+  it("handles multiple target locales", async () => {
     const writes: Array<{ locale: string }> = [];
     const adapter: TranslationAdapter = {
-      name: 'multi-locale',
+      name: "multi-locale",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(['en', 'de', 'fr']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
-      readResource: (locale: string) =>
-        Effect.succeed(locale === 'en' ? { hello: 'Hello' } : {}),
+      listLocales: () => Effect.succeed(["en", "de", "fr"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
+      readResource: (locale: string) => Effect.succeed(locale === "en" ? { hello: "Hello" } : {}),
       writeResource: (locale: string) =>
         Effect.sync(() => {
           writes.push({ locale });
@@ -255,22 +242,24 @@ describe('runTranslation', () => {
     };
 
     const strategy = {
-      name: 'one-shot' as const,
+      name: "one-shot" as const,
       translateChunk: (ctx: { keys: readonly string[]; targetLocale: string }) =>
-        Effect.succeed(Object.fromEntries(ctx.keys.map((k: string) => [k, `${ctx.targetLocale}:${k}`]))),
+        Effect.succeed(
+          Object.fromEntries(ctx.keys.map((k: string) => [k, `${ctx.targetLocale}:${k}`])),
+        ),
     };
 
     const program = runTranslation({
       adapters: [adapter],
       strategy,
-      sourceLocale: 'en',
-      targetLocales: ['de', 'fr'],
+      sourceLocale: "en",
+      targetLocales: ["de", "fr"],
       chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     });
 
     await Effect.runPromise(program);
     const locales = writes.map((w) => w.locale);
-    expect(locales).toContain('de');
-    expect(locales).toContain('fr');
+    expect(locales).toContain("de");
+    expect(locales).toContain("fr");
   });
 });

package/src/translation/orchestrator.ts

@@ -1,10 +1,10 @@
-import { Effect } from 'effect';
-import { chunkKeys } from './chunking.js';
-import { diffKeys } from '../keys/flatten.js';
-import type { TranslationAdapter } from '../adapter/types.js';
-import type { TranslationStrategy } from './types.js';
-import { TranslationFailedError } from './types.js';
-import type { ChunkingConfig } from '../config/types.js';
+import { Effect } from "effect";
+import { chunkKeys } from "./chunking.js";
+import { diffKeys } from "../keys/flatten.js";
+import type { TranslationAdapter } from "../adapter/types.js";
+import type { TranslationStrategy } from "./types.js";
+import { TranslationFailedError } from "./types.js";
+import type { ChunkingConfig } from "../config/types.js";
 
 export interface TranslationRunConfig {
   readonly adapters: readonly TranslationAdapter[];
@@ -20,9 +20,7 @@ export function runTranslation(config: TranslationRunConfig) {
 
     for (const adapter of config.adapters) {
       const locales =
-        config.targetLocales.length > 0
-          ? config.targetLocales
-          : yield* adapter.listLocales();
+        config.targetLocales.length > 0 ? config.targetLocales : yield* adapter.listLocales();
       const sourceLocale = config.sourceLocale;
       const targetLocales = locales.filter((l: string) => l !== sourceLocale);
 
@@ -41,22 +39,24 @@ export function runTranslation(config: TranslationRunConfig) {
 
           const translatedChunks: Record<string, string>[] = [];
 
-          yield* Effect.forEach(chunks, (chunkKeysArr) =>
-            Effect.gen(function* () {
-              const result = yield* config.strategy.translateChunk({
-                sourceLocale,
-                targetLocale: locale,
-                sourceMap,
-                targetMap,
-                keys: chunkKeysArr,
-              });
-              translatedChunks.push(result);
-            }).pipe(
-              Effect.catchAll((err) => {
-                failures.push(err);
-                return Effect.void;
-              }),
-            ),
+          yield* Effect.forEach(
+            chunks,
+            (chunkKeysArr) =>
+              Effect.gen(function* () {
+                const result = yield* config.strategy.translateChunk({
+                  sourceLocale,
+                  targetLocale: locale,
+                  sourceMap,
+                  targetMap,
+                  keys: chunkKeysArr,
+                });
+                translatedChunks.push(result);
+              }).pipe(
+                Effect.catchAll((err) => {
+                  failures.push(err);
+                  return Effect.void;
+                }),
+              ),
             { concurrency: config.chunking.concurrency, discard: true },
           );
 

package/src/translation/prompt.test.ts

@@ -1,130 +1,130 @@
-import { describe, expect, it } from 'vitest';
-import { buildSystemPrompt, buildUserPrompt } from './prompt.js';
+import { describe, expect, it } from "vitest";
+import { buildSystemPrompt, buildUserPrompt } from "./prompt.js";
 
-describe('buildSystemPrompt', () => {
-  it('contains from and to language', () => {
-    const prompt = buildSystemPrompt('en', 'de');
-    expect(prompt).toContain('en');
-    expect(prompt).toContain('de');
-    expect(prompt).toContain('Do not escape Unicode');
+describe("buildSystemPrompt", () => {
+  it("contains from and to language", () => {
+    const prompt = buildSystemPrompt("en", "de");
+    expect(prompt).toContain("en");
+    expect(prompt).toContain("de");
+    expect(prompt).toContain("Do not escape Unicode");
   });
 
-  it('mentions placeholder preservation', () => {
-    const prompt = buildSystemPrompt('en', 'ja');
-    expect(prompt).toContain(':attribute');
-    expect(prompt).toContain(':min');
-    expect(prompt).toContain(':max');
+  it("mentions placeholder preservation", () => {
+    const prompt = buildSystemPrompt("en", "ja");
+    expect(prompt).toContain(":attribute");
+    expect(prompt).toContain(":min");
+    expect(prompt).toContain(":max");
   });
 
-  it('instructs to not add or remove keys', () => {
-    const prompt = buildSystemPrompt('en', 'fr');
-    expect(prompt).toContain('Do not add or remove keys');
+  it("instructs to not add or remove keys", () => {
+    const prompt = buildSystemPrompt("en", "fr");
+    expect(prompt).toContain("Do not add or remove keys");
   });
 
-  it('mentions double quote escaping', () => {
-    const prompt = buildSystemPrompt('en', 'es');
-    expect(prompt).toContain('double quotes');
+  it("mentions double quote escaping", () => {
+    const prompt = buildSystemPrompt("en", "es");
+    expect(prompt).toContain("double quotes");
   });
 
-  it('handles same-language translation edge case', () => {
-    const prompt = buildSystemPrompt('en', 'en');
-    expect(prompt).toContain('en');
+  it("handles same-language translation edge case", () => {
+    const prompt = buildSystemPrompt("en", "en");
+    expect(prompt).toContain("en");
   });
 
-  it('handles long locale codes', () => {
-    const prompt = buildSystemPrompt('zh-Hans', 'zh-Hant');
-    expect(prompt).toContain('zh-Hans');
-    expect(prompt).toContain('zh-Hant');
+  it("handles long locale codes", () => {
+    const prompt = buildSystemPrompt("zh-Hans", "zh-Hant");
+    expect(prompt).toContain("zh-Hans");
+    expect(prompt).toContain("zh-Hant");
   });
 });
 
-describe('buildUserPrompt', () => {
-  it('contains XML tags and key list', () => {
+describe("buildUserPrompt", () => {
+  it("contains XML tags and key list", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { hello: 'Hello' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { hello: "Hello" },
       targetMap: {},
-      keys: ['hello'],
+      keys: ["hello"],
     };
     const prompt = buildUserPrompt(ctx);
-    expect(prompt).toContain('<source-file>');
-    expect(prompt).toContain('<existing-translations>');
-    expect(prompt).toContain('<keys-to-translate>');
-    expect(prompt).toContain('hello');
-    expect(prompt).toContain('Translate ALL keys');
+    expect(prompt).toContain("<source-file>");
+    expect(prompt).toContain("<existing-translations>");
+    expect(prompt).toContain("<keys-to-translate>");
+    expect(prompt).toContain("hello");
+    expect(prompt).toContain("Translate ALL keys");
   });
 
-  it('includes existing translations for context', () => {
+  it("includes existing translations for context", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { a: 'A', b: 'B' },
-      targetMap: { a: 'already translated' },
-      keys: ['b'],
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { a: "A", b: "B" },
+      targetMap: { a: "already translated" },
+      keys: ["b"],
     };
     const prompt = buildUserPrompt(ctx);
-    expect(prompt).toContain('already translated');
+    expect(prompt).toContain("already translated");
     expect(prompt).toContain('"b"');
   });
 
-  it('handles empty keys list', () => {
+  it("handles empty keys list", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { hello: 'Hello' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { hello: "Hello" },
       targetMap: {},
       keys: [],
     };
     const prompt = buildUserPrompt(ctx);
-    expect(prompt).toContain('<keys-to-translate>');
-    expect(prompt).toContain('{}');
+    expect(prompt).toContain("<keys-to-translate>");
+    expect(prompt).toContain("{}");
   });
 
-  it('handles keys with missing values in sourceMap', () => {
+  it("handles keys with missing values in sourceMap", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { hello: 'Hello' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { hello: "Hello" },
       targetMap: {},
-      keys: ['hello', 'missing'],
+      keys: ["hello", "missing"],
     };
     const prompt = buildUserPrompt(ctx);
     expect(prompt).toContain('"missing"');
     expect(prompt).toContain('""');
   });
 
-  it('handles special characters in values', () => {
+  it("handles special characters in values", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'ja',
-      sourceMap: { greeting: 'Hello \n World \t!' },
+      sourceLocale: "en",
+      targetLocale: "ja",
+      sourceMap: { greeting: "Hello \n World \t!" },
       targetMap: {},
-      keys: ['greeting'],
+      keys: ["greeting"],
     };
     const prompt = buildUserPrompt(ctx);
-    expect(prompt).toContain('Hello');
+    expect(prompt).toContain("Hello");
   });
 
-  it('handles unicode values', () => {
+  it("handles unicode values", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'ja',
-      sourceMap: { emoji: 'Hello 🌍' },
+      sourceLocale: "en",
+      targetLocale: "ja",
+      sourceMap: { emoji: "Hello 🌍" },
       targetMap: {},
-      keys: ['emoji'],
+      keys: ["emoji"],
     };
     const prompt = buildUserPrompt(ctx);
-    expect(prompt).toContain('🌍');
+    expect(prompt).toContain("🌍");
   });
 
-  it('includes multiple keys in keys-to-translate', () => {
+  it("includes multiple keys in keys-to-translate", () => {
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { a: 'A', b: 'B', c: 'C' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { a: "A", b: "B", c: "C" },
       targetMap: {},
-      keys: ['a', 'b', 'c'],
+      keys: ["a", "b", "c"],
     };
     const prompt = buildUserPrompt(ctx);
     expect(prompt).toContain('"a"');
@@ -132,14 +132,14 @@ describe('buildUserPrompt', () => {
     expect(prompt).toContain('"c"');
   });
 
-  it('round-trips JSON sourceMap without corruption', () => {
+  it("round-trips JSON sourceMap without corruption", () => {
     const sourceMap = { key: 'value with "quotes" and \\ backslash' };
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
+      sourceLocale: "en",
+      targetLocale: "de",
       sourceMap,
       targetMap: {},
-      keys: ['key'],
+      keys: ["key"],
     };
     const prompt = buildUserPrompt(ctx);
     const jsonMatch = prompt.match(/<source-file>\n([\s\S]*?)\n<\/source-file>/)?.[1];