dialekt 0.1.0 → 0.1.1

package/src/cli/commands/languages.test.ts

@@ -1,16 +1,16 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Option } from 'effect';
-import { runLanguages, languagesCommand } from './languages.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter } from '../../adapter/types.js';
+import { describe, expect, it } from "vitest";
+import { Effect, Option } from "effect";
+import { runLanguages, languagesCommand } from "./languages.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter } from "../../adapter/types.js";
 
-describe('runLanguages', () => {
+describe("runLanguages", () => {
   const baseConfig: DialektConfig = {
-    sourceLocale: 'en',
-    targetLocales: ['de', 'fr'],
-    strategy: 'one-shot',
-    model: { provider: 'openai', modelId: 'gpt-4o' },
-    fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+    sourceLocale: "en",
+    targetLocales: ["de", "fr"],
+    strategy: "one-shot",
+    model: { provider: "openai", modelId: "gpt-4o" },
+    fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
     chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     retry: { maxAttempts: 3, baseDelayMs: 1000 },
     adapters: [],
@@ -20,21 +20,24 @@ describe('runLanguages', () => {
     return {
       name: opts.name,
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
+      listLocales: () => Effect.succeed(opts.locales ?? ["en", "de"]),
       listResources: () => Effect.succeed([]),
       readResource: () => Effect.succeed({}),
       writeResource: () => Effect.void,
     };
   }
 
-  it('logs locales for each adapter', async () => {
+  it("logs locales for each adapter", async () => {
     const logs: string[] = [];
-    const laravel = makeAdapter({ name: 'laravel', locales: ['en', 'de', 'fr'] });
-    const paraglide = makeAdapter({ name: 'paraglide', locales: ['en', 'es'] });
-    const config = { ...baseConfig, adapters: [laravel, paraglide] as unknown as DialektConfig['adapters'] };
+    const laravel = makeAdapter({ name: "laravel", locales: ["en", "de", "fr"] });
+    const paraglide = makeAdapter({ name: "paraglide", locales: ["en", "es"] });
+    const config = {
+      ...baseConfig,
+      adapters: [laravel, paraglide] as unknown as DialektConfig["adapters"],
+    };
 
     const program = runLanguages(
-      { config: './config.ts' },
+      { config: "./config.ts" },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
@@ -43,17 +46,17 @@ describe('runLanguages', () => {
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
     expect(parsed).toHaveLength(2);
-    expect(parsed).toContainEqual({ adapter: 'laravel', locales: ['en', 'de', 'fr'] });
-    expect(parsed).toContainEqual({ adapter: 'paraglide', locales: ['en', 'es'] });
+    expect(parsed).toContainEqual({ adapter: "laravel", locales: ["en", "de", "fr"] });
+    expect(parsed).toContainEqual({ adapter: "paraglide", locales: ["en", "es"] });
   });
 
-  it('handles single adapter with single locale', async () => {
+  it("handles single adapter with single locale", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'mono', locales: ['en'] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "mono", locales: ["en"] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runLanguages(
-      { config: './config.ts' },
+      { config: "./config.ts" },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
@@ -61,15 +64,15 @@ describe('runLanguages', () => {
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
-    expect(parsed).toEqual([{ adapter: 'mono', locales: ['en'] }]);
+    expect(parsed).toEqual([{ adapter: "mono", locales: ["en"] }]);
   });
 
-  it('handles empty adapter list', async () => {
+  it("handles empty adapter list", async () => {
     const logs: string[] = [];
     const config = { ...baseConfig, adapters: [] };
 
     const program = runLanguages(
-      { config: './config.ts' },
+      { config: "./config.ts" },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
@@ -80,23 +83,23 @@ describe('runLanguages', () => {
     expect(parsed).toEqual([]);
   });
 
-  it('fails when configLoader fails', async () => {
+  it("fails when configLoader fails", async () => {
     const program = runLanguages(
-      { config: './missing.ts' },
-      () => Effect.fail(new Error('Config not found')),
+      { config: "./missing.ts" },
+      () => Effect.fail(new Error("Config not found")),
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+    await expect(Effect.runPromise(program)).rejects.toThrow("Config not found");
   });
 
-  it('handles adapter with empty locales', async () => {
+  it("handles adapter with empty locales", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'empty', locales: [] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "empty", locales: [] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runLanguages(
-      { config: './config.ts' },
+      { config: "./config.ts" },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
@@ -104,24 +107,24 @@ describe('runLanguages', () => {
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
-    expect(parsed).toEqual([{ adapter: 'empty', locales: [] }]);
+    expect(parsed).toEqual([{ adapter: "empty", locales: [] }]);
   });
 
-  it('outputs pretty when --format pretty is passed', async () => {
+  it("outputs pretty when --format pretty is passed", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test', locales: ['en', 'de'] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "test", locales: ["en", "de"] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runLanguages(
-      { config: './config.ts', format: Option.some('pretty') },
+      { config: "./config.ts", format: Option.some("pretty") },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
 
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
-    expect(logs[0]).toContain('test');
-    expect(logs[0]).toContain('en');
-    expect(logs[0]).toContain('de');
+    expect(logs[0]).toContain("test");
+    expect(logs[0]).toContain("en");
+    expect(logs[0]).toContain("de");
   });
 });

package/src/cli/commands/languages.ts

@@ -1,11 +1,11 @@
-import { Command, Options } from '@effect/cli';
-import { Effect, Console, Option } from 'effect';
-import { loadConfig } from '../../config/load-config.js';
-import { resolveEffectiveConfig } from '../config-resolution.js';
-import { detectFormat, type OutputFormat } from '../format.js';
-import { formatLanguages } from '../formatters.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter } from '../../adapter/types.js';
+import { Command, Options } from "@effect/cli";
+import { Effect, Console, Option } from "effect";
+import { loadConfig } from "../../config/load-config.js";
+import { resolveEffectiveConfig } from "../config-resolution.js";
+import { detectFormat, type OutputFormat } from "../format.js";
+import { formatLanguages } from "../formatters.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter } from "../../adapter/types.js";
 
 export interface LanguagesFlags {
   readonly config: string;
@@ -36,7 +36,11 @@ export function runLanguages(
   }).pipe(Effect.mapError((e) => e as never)) as Effect.Effect<void, never, never>;
 }
 
-export const languagesCommand = Command.make('languages', {
-  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
-  format: Options.optional(Options.text('format')),
-}, (flags) => runLanguages(flags));
+export const languagesCommand = Command.make(
+  "languages",
+  {
+    config: Options.text("config").pipe(Options.withDefault("./dialekt.config.ts")),
+    format: Options.optional(Options.text("format")),
+  },
+  (flags) => runLanguages(flags),
+);

package/src/cli/commands/missing.test.ts

@@ -1,16 +1,16 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Option } from 'effect';
-import { runMissing, missingCommand } from './missing.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
+import { describe, expect, it } from "vitest";
+import { Effect, Option } from "effect";
+import { runMissing, missingCommand } from "./missing.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
 
-describe('runMissing', () => {
+describe("runMissing", () => {
   const baseConfig: DialektConfig = {
-    sourceLocale: 'en',
-    targetLocales: ['de', 'fr'],
-    strategy: 'one-shot',
-    model: { provider: 'openai', modelId: 'gpt-4o' },
-    fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+    sourceLocale: "en",
+    targetLocales: ["de", "fr"],
+    strategy: "one-shot",
+    model: { provider: "openai", modelId: "gpt-4o" },
+    fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
     chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
     retry: { maxAttempts: 3, baseDelayMs: 1000 },
     adapters: [],
@@ -24,26 +24,29 @@ describe('runMissing', () => {
     return {
       name: opts.name,
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
-      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(opts.locales ?? ["en", "de"]),
+      listResources: () => Effect.succeed([{ key: "messages", label: "messages" }]),
       readResource: () => Effect.succeed({}),
       writeResource: () => Effect.void,
     };
   }
 
-  it('logs missing keys in default format', async () => {
+  it("logs missing keys in default format", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
-    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
+    const resource: ResourceRef = { key: "messages", label: "messages" };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       () =>
-        Effect.succeed([
-          { adapter: 'test', locale: 'de', resource, missing: ['hello', 'bye'] },
-        ]),
+        Effect.succeed([{ adapter: "test", locale: "de", resource, missing: ["hello", "bye"] }]),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
 
@@ -51,66 +54,76 @@ describe('runMissing', () => {
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
     expect(parsed).toEqual([
-      { adapter: 'test', locale: 'de', resource: 'messages', key: 'hello' },
-      { adapter: 'test', locale: 'de', resource: 'messages', key: 'bye' },
+      { adapter: "test", locale: "de", resource: "messages", key: "hello" },
+      { adapter: "test", locale: "de", resource: "messages", key: "bye" },
     ]);
   });
 
-  it('outputs JSON when --format json is passed', async () => {
+  it("outputs JSON when --format json is passed", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
-    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
+    const resource: ResourceRef = { key: "messages", label: "messages" };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none(), format: Option.some('json') },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        format: Option.some("json"),
+      },
       () => Effect.succeed(config),
-      () =>
-        Effect.succeed([
-          { adapter: 'test', locale: 'de', resource, missing: ['hello'] },
-        ]),
+      () => Effect.succeed([{ adapter: "test", locale: "de", resource, missing: ["hello"] }]),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
 
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
-    expect(parsed).toEqual([
-      { adapter: 'test', locale: 'de', resource: 'messages', key: 'hello' },
-    ]);
+    expect(parsed).toEqual([{ adapter: "test", locale: "de", resource: "messages", key: "hello" }]);
   });
 
-  it('outputs pretty when --format pretty is passed', async () => {
+  it("outputs pretty when --format pretty is passed", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
-    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
+    const resource: ResourceRef = { key: "messages", label: "messages" };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none(), format: Option.some('pretty') },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        format: Option.some("pretty"),
+      },
       () => Effect.succeed(config),
       () =>
-        Effect.succeed([
-          { adapter: 'test', locale: 'de', resource, missing: ['hello', 'bye'] },
-        ]),
+        Effect.succeed([{ adapter: "test", locale: "de", resource, missing: ["hello", "bye"] }]),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
 
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
-    expect(logs[0]).toContain('test');
-    expect(logs[0]).toContain('de');
-    expect(logs[0]).toContain('hello');
-    expect(logs[0]).toContain('bye');
+    expect(logs[0]).toContain("test");
+    expect(logs[0]).toContain("de");
+    expect(logs[0]).toContain("hello");
+    expect(logs[0]).toContain("bye");
   });
 
-  it('returns empty JSON array when nothing is missing', async () => {
+  it("returns empty JSON array when nothing is missing", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       () => Effect.succeed([]),
       (msg) => Effect.sync(() => logs.push(msg)),
@@ -121,19 +134,24 @@ describe('runMissing', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('handles multiple adapters and multiple locales', async () => {
+  it("handles multiple adapters and multiple locales", async () => {
     const logs: string[] = [];
-    const a1 = makeAdapter({ name: 'a1' });
-    const a2 = makeAdapter({ name: 'a2', locales: ['en', 'fr'] });
-    const config = { ...baseConfig, adapters: [a1, a2] as unknown as DialektConfig['adapters'] };
-    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+    const a1 = makeAdapter({ name: "a1" });
+    const a2 = makeAdapter({ name: "a2", locales: ["en", "fr"] });
+    const config = { ...baseConfig, adapters: [a1, a2] as unknown as DialektConfig["adapters"] };
+    const resource: ResourceRef = { key: "messages", label: "messages" };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       (a) =>
         Effect.succeed([
-          { adapter: a.name, locale: a.name === 'a1' ? 'de' : 'fr', resource, missing: ['k1'] },
+          { adapter: a.name, locale: a.name === "a1" ? "de" : "fr", resource, missing: ["k1"] },
         ]),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
@@ -142,18 +160,23 @@ describe('runMissing', () => {
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
     expect(parsed).toHaveLength(2);
-    expect(parsed).toContainEqual({ adapter: 'a1', locale: 'de', resource: 'messages', key: 'k1' });
-    expect(parsed).toContainEqual({ adapter: 'a2', locale: 'fr', resource: 'messages', key: 'k1' });
+    expect(parsed).toContainEqual({ adapter: "a1", locale: "de", resource: "messages", key: "k1" });
+    expect(parsed).toContainEqual({ adapter: "a2", locale: "fr", resource: "messages", key: "k1" });
   });
 
-  it('filters adapters by --adapter flag', async () => {
+  it("filters adapters by --adapter flag", async () => {
     let queriedAdapter: string | undefined;
-    const a1 = makeAdapter({ name: 'a1' });
-    const a2 = makeAdapter({ name: 'a2' });
-    const config = { ...baseConfig, adapters: [a1, a2] as unknown as DialektConfig['adapters'] };
+    const a1 = makeAdapter({ name: "a1" });
+    const a2 = makeAdapter({ name: "a2" });
+    const config = { ...baseConfig, adapters: [a1, a2] as unknown as DialektConfig["adapters"] };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.some('a2'), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.some("a2"),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       (a) =>
         Effect.sync(() => {
@@ -164,47 +187,62 @@ describe('runMissing', () => {
     );
 
     await Effect.runPromise(program);
-    expect(queriedAdapter).toBe('a2');
+    expect(queriedAdapter).toBe("a2");
   });
 
-  it('fails when configLoader fails', async () => {
+  it("fails when configLoader fails", async () => {
     const program = runMissing(
-      { config: './missing.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
-      () => Effect.fail(new Error('Config not found')),
+      {
+        config: "./missing.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
+      () => Effect.fail(new Error("Config not found")),
       () => Effect.succeed([]),
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+    await expect(Effect.runPromise(program)).rejects.toThrow("Config not found");
   });
 
-  it('fails when listLocales fails', async () => {
+  it("fails when listLocales fails", async () => {
     const adapter: TranslationAdapter = {
-      name: 'broken',
+      name: "broken",
       capabilities: { canCreateResource: true, unusedKeyDetection: false },
-      listLocales: () => Effect.fail(new Error('disk error') as never),
+      listLocales: () => Effect.fail(new Error("disk error") as never),
       listResources: () => Effect.succeed([]),
       readResource: () => Effect.succeed({}),
       writeResource: () => Effect.void,
     };
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       () => Effect.succeed([]),
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('disk error');
+    await expect(Effect.runPromise(program)).rejects.toThrow("disk error");
   });
 
-  it('handles empty adapter list', async () => {
+  it("handles empty adapter list", async () => {
     const logs: string[] = [];
     const config = { ...baseConfig, adapters: [] };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       () => Effect.succeed([]),
       (msg) => Effect.sync(() => logs.push(msg)),
@@ -215,13 +253,18 @@ describe('runMissing', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('handles single-locale adapter (no targets)', async () => {
+  it("handles single-locale adapter (no targets)", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'mono', locales: ['en'] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "mono", locales: ["en"] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+      },
       () => Effect.succeed(config),
       () => Effect.succeed([]),
       (msg) => Effect.sync(() => logs.push(msg)),
@@ -232,25 +275,33 @@ describe('runMissing', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('produces valid JSON array even with many entries', async () => {
+  it("produces valid JSON array even with many entries", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
-    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
+    const resource: ResourceRef = { key: "messages", label: "messages" };
 
     const program = runMissing(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none(), format: Option.some('json') },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        format: Option.some("json"),
+      },
       () => Effect.succeed(config),
-      () =>
-        Effect.succeed([
-          { adapter: 'test', locale: 'de', resource, missing: ['a', 'b', 'c'] },
-        ]),
+      () => Effect.succeed([{ adapter: "test", locale: "de", resource, missing: ["a", "b", "c"] }]),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
 
     await Effect.runPromise(program);
     const parsed = JSON.parse(logs[0]!);
     expect(parsed).toHaveLength(3);
-    expect(parsed[0]).toMatchObject({ adapter: 'test', locale: 'de', resource: 'messages', key: 'a' });
+    expect(parsed[0]).toMatchObject({
+      adapter: "test",
+      locale: "de",
+      resource: "messages",
+      key: "a",
+    });
   });
 });

package/src/cli/commands/missing.ts

@@ -1,12 +1,12 @@
-import { Command, Options } from '@effect/cli';
-import { Effect, Console, Option } from 'effect';
-import { loadConfig } from '../../config/load-config.js';
-import { resolveEffectiveConfig } from '../config-resolution.js';
-import { computeMissingKeys } from '../../translation/missing-keys.js';
-import { detectFormat, type OutputFormat } from '../format.js';
-import { formatMissingKeys } from '../formatters.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter } from '../../adapter/types.js';
+import { Command, Options } from "@effect/cli";
+import { Effect, Console, Option } from "effect";
+import { loadConfig } from "../../config/load-config.js";
+import { resolveEffectiveConfig } from "../config-resolution.js";
+import { computeMissingKeys } from "../../translation/missing-keys.js";
+import { detectFormat, type OutputFormat } from "../format.js";
+import { formatMissingKeys } from "../formatters.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter } from "../../adapter/types.js";
 
 export interface MissingFlags {
   readonly config: string;
@@ -30,7 +30,10 @@ export function runMissing(
     adapter: TranslationAdapter,
     sourceLocale: string,
     targetLocales: readonly string[],
-  ) => Effect.Effect<readonly MissingKeysEntry[], unknown> = computeMissingKeys as unknown as typeof missingKeysComputer,
+  ) => Effect.Effect<
+    readonly MissingKeysEntry[],
+    unknown
+  > = computeMissingKeys as unknown as typeof missingKeysComputer,
   logger: (msg: string) => Effect.Effect<void> = (msg: string) => Console.log(msg),
 ): Effect.Effect<void, never> {
   return Effect.gen(function* () {
@@ -79,10 +82,14 @@ export function runMissing(
   }).pipe(Effect.mapError((e) => e as never)) as Effect.Effect<void, never, never>;
 }
 
-export const missingCommand = Command.make('missing', {
-  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
-  adapter: Options.optional(Options.text('adapter')),
-  baseLanguage: Options.optional(Options.text('base-language')),
-  language: Options.optional(Options.text('language')),
-  format: Options.optional(Options.text('format')),
-}, (flags) => runMissing(flags));
+export const missingCommand = Command.make(
+  "missing",
+  {
+    config: Options.text("config").pipe(Options.withDefault("./dialekt.config.ts")),
+    adapter: Options.optional(Options.text("adapter")),
+    baseLanguage: Options.optional(Options.text("base-language")),
+    language: Options.optional(Options.text("language")),
+    format: Options.optional(Options.text("format")),
+  },
+  (flags) => runMissing(flags),
+);