dialekt 0.1.0 → 0.1.1

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

@@ -1,16 +1,16 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Option } from 'effect';
-import { runUnused, unusedCommand } from './unused.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 { runUnused, unusedCommand } from "./unused.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
 
-describe('runUnused', () => {
+describe("runUnused", () => {
   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: [],
@@ -29,8 +29,9 @@ describe('runUnused', () => {
         canCreateResource: true,
         unusedKeyDetection: opts.hasUnusedDetection ?? true,
       },
-      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
-      listResources: () => Effect.succeed(opts.resources ?? [{ key: 'messages', label: 'messages' }]),
+      listLocales: () => Effect.succeed(opts.locales ?? ["en", "de"]),
+      listResources: () =>
+        Effect.succeed(opts.resources ?? [{ key: "messages", label: "messages" }]),
       readResource: () => Effect.succeed({}),
       writeResource: () => Effect.void,
     };
@@ -43,13 +44,13 @@ describe('runUnused', () => {
     return base as TranslationAdapter;
   }
 
-  it('logs unused keys for capable adapters', async () => {
+  it("logs unused keys for capable adapters", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'test', unused: ['old_key', 'another'] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "test", unused: ["old_key", "another"] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      { config: "./config.ts", adapter: Option.none(), baseLanguage: Option.none() },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       () => Effect.void,
@@ -59,19 +60,19 @@ describe('runUnused', () => {
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
     expect(parsed).toEqual([
-      { adapter: 'test', locale: 'en', resource: 'messages', key: 'old_key' },
-      { adapter: 'test', locale: 'en', resource: 'messages', key: 'another' },
+      { adapter: "test", locale: "en", resource: "messages", key: "old_key" },
+      { adapter: "test", locale: "en", resource: "messages", key: "another" },
     ]);
   });
 
-  it('skips adapters without unusedKeyDetection with a warning', async () => {
+  it("skips adapters without unusedKeyDetection with a warning", async () => {
     const logs: string[] = [];
     const errors: string[] = [];
-    const legacy = makeAdapter({ name: 'legacy', hasUnusedDetection: false });
-    const config = { ...baseConfig, adapters: [legacy] as unknown as DialektConfig['adapters'] };
+    const legacy = makeAdapter({ name: "legacy", hasUnusedDetection: false });
+    const config = { ...baseConfig, adapters: [legacy] as unknown as DialektConfig["adapters"] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      { config: "./config.ts", adapter: Option.none(), baseLanguage: Option.none() },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       (msg) => Effect.sync(() => errors.push(msg)),
@@ -86,20 +87,20 @@ describe('runUnused', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('handles multiple resources', async () => {
+  it("handles multiple resources", async () => {
     const logs: string[] = [];
     const adapter = makeAdapter({
-      name: 'multi',
+      name: "multi",
       resources: [
-        { key: 'auth', label: 'auth' },
-        { key: 'validation', label: 'validation' },
+        { key: "auth", label: "auth" },
+        { key: "validation", label: "validation" },
       ],
-      unused: ['unused_auth'],
+      unused: ["unused_auth"],
     });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      { config: "./config.ts", adapter: Option.none(), baseLanguage: Option.none() },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       () => Effect.void,
@@ -108,15 +109,20 @@ describe('runUnused', () => {
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
-    expect(parsed).toContainEqual({ adapter: 'multi', locale: 'en', resource: 'auth', key: 'unused_auth' });
+    expect(parsed).toContainEqual({
+      adapter: "multi",
+      locale: "en",
+      resource: "auth",
+      key: "unused_auth",
+    });
   });
 
-  it('handles empty adapter list', async () => {
+  it("handles empty adapter list", async () => {
     const logs: string[] = [];
     const config = { ...baseConfig, adapters: [] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      { config: "./config.ts", adapter: Option.none(), baseLanguage: Option.none() },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       () => Effect.void,
@@ -127,13 +133,13 @@ describe('runUnused', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('handles adapter with no resources', async () => {
+  it("handles adapter with no resources", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'empty', resources: [] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "empty", resources: [] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      { config: "./config.ts", adapter: Option.none(), baseLanguage: Option.none() },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       () => Effect.void,
@@ -144,13 +150,13 @@ describe('runUnused', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('handles no unused keys gracefully', async () => {
+  it("handles no unused keys gracefully", async () => {
     const logs: string[] = [];
-    const adapter = makeAdapter({ name: 'clean', unused: [] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "clean", unused: [] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      { config: "./config.ts", adapter: Option.none(), baseLanguage: Option.none() },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       () => Effect.void,
@@ -161,24 +167,29 @@ describe('runUnused', () => {
     expect(JSON.parse(logs[0]!)).toEqual([]);
   });
 
-  it('fails when configLoader fails', async () => {
+  it("fails when configLoader fails", async () => {
     const program = runUnused(
-      { config: './missing.ts', adapter: Option.none(), baseLanguage: Option.none() },
-      () => Effect.fail(new Error('Config not found')),
+      { config: "./missing.ts", adapter: Option.none(), baseLanguage: Option.none() },
+      () => Effect.fail(new Error("Config not found")),
       () => Effect.void,
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+    await expect(Effect.runPromise(program)).rejects.toThrow("Config not found");
   });
 
-  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', unused: ['old_key'] });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter({ name: "test", unused: ["old_key"] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runUnused(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), format: Option.some('pretty') },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        format: Option.some("pretty"),
+      },
       () => Effect.succeed(config),
       (msg) => Effect.sync(() => logs.push(msg)),
       () => Effect.void,
@@ -186,7 +197,7 @@ describe('runUnused', () => {
 
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
-    expect(logs[0]).toContain('test');
-    expect(logs[0]).toContain('old_key');
+    expect(logs[0]).toContain("test");
+    expect(logs[0]).toContain("old_key");
   });
 });

package/src/cli/commands/unused.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 { formatUnusedKeys, formatError } from '../formatters.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter, ResourceRef } 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 { formatUnusedKeys, formatError } from "../formatters.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
 
 export interface UnusedFlags {
   readonly config: string;
@@ -79,9 +79,13 @@ export function runUnused(
   }).pipe(Effect.mapError((e) => e as never)) as Effect.Effect<void, never, never>;
 }
 
-export const unusedCommand = Command.make('unused', {
-  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
-  adapter: Options.optional(Options.text('adapter')),
-  baseLanguage: Options.optional(Options.text('base-language')),
-  format: Options.optional(Options.text('format')),
-}, (flags) => runUnused(flags));
+export const unusedCommand = Command.make(
+  "unused",
+  {
+    config: Options.text("config").pipe(Options.withDefault("./dialekt.config.ts")),
+    adapter: Options.optional(Options.text("adapter")),
+    baseLanguage: Options.optional(Options.text("base-language")),
+    format: Options.optional(Options.text("format")),
+  },
+  (flags) => runUnused(flags),
+);

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

@@ -1,16 +1,16 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Option } from 'effect';
-import { runValidate, validateCommand } from './validate.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 { runValidate, validateCommand } from "./validate.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
 
-describe('runValidate', () => {
+describe("runValidate", () => {
   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,20 +24,25 @@ describe('runValidate', () => {
     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('passes when no keys are missing', async () => {
+  it("passes when no keys are 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 = runValidate(
-      { 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)),
@@ -50,20 +55,22 @@ describe('runValidate', () => {
     expect(parsed.entries).toEqual([]);
   });
 
-  it('fails and reports missing keys', async () => {
+  it("fails and reports missing keys", 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 originalExitCode = process.exitCode;
     const program = runValidate(
-      { 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'] },
-        ]),
+      () => Effect.succeed([{ adapter: "test", locale: "de", resource, missing: ["hello"] }]),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
 
@@ -74,23 +81,33 @@ describe('runValidate', () => {
     const parsed = JSON.parse(logs[0]!);
     expect(parsed.passing).toBe(false);
     expect(parsed.entries).toHaveLength(1);
-    expect(parsed.entries[0]).toMatchObject({ adapter: 'test', locale: 'de', resource: 'messages', count: 1 });
+    expect(parsed.entries[0]).toMatchObject({
+      adapter: "test",
+      locale: "de",
+      resource: "messages",
+      count: 1,
+    });
   });
 
-  it('reports missing keys for multiple adapters', async () => {
+  it("reports missing keys for multiple adapters", 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 originalExitCode = process.exitCode;
     const program = runValidate(
-      { 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)),
     );
@@ -104,14 +121,19 @@ describe('runValidate', () => {
     expect(parsed.entries).toHaveLength(2);
   });
 
-  it('filters by --adapter flag', async () => {
+  it("filters 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 = runValidate(
-      { 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(() => {
@@ -122,62 +144,82 @@ describe('runValidate', () => {
     );
 
     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 = runValidate(
-      { 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 = runValidate(
-      { 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('fails when missingKeysComputer fails', async () => {
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+  it("fails when missingKeysComputer fails", async () => {
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runValidate(
-      { 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.fail(new Error('read error')),
+      () => Effect.fail(new Error("read error")),
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('read error');
+    await expect(Effect.runPromise(program)).rejects.toThrow("read error");
   });
 
-  it('filters by --language flag', async () => {
+  it("filters by --language flag", async () => {
     let checkedLocale: string | undefined;
-    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 = runValidate(
-      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.some('de') },
+      {
+        config: "./config.ts",
+        adapter: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.some("de"),
+      },
       () => Effect.succeed(config),
       (_a, _s, targets) =>
         Effect.sync(() => {
@@ -188,16 +230,22 @@ describe('runValidate', () => {
     );
 
     await Effect.runPromise(program);
-    expect(checkedLocale).toBe('de');
+    expect(checkedLocale).toBe("de");
   });
 
-  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 adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runValidate(
-      { 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([]),
       (msg) => Effect.sync(() => logs.push(msg)),
@@ -205,15 +253,20 @@ describe('runValidate', () => {
 
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
-    expect(logs[0]).toContain('up to date');
+    expect(logs[0]).toContain("up to date");
   });
 
-  it('handles empty adapter list', async () => {
+  it("handles empty adapter list", async () => {
     const logs: string[] = [];
     const config = { ...baseConfig, adapters: [] };
 
     const program = runValidate(
-      { 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)),
@@ -225,13 +278,18 @@ describe('runValidate', () => {
     expect(parsed.passing).toBe(true);
   });
 
-  it('handles adapter with only source locale (no targets)', async () => {
+  it("handles adapter with only source locale (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 = runValidate(
-      { 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)),