dialekt 0.1.0 → 0.1.1

package/src/cli/commands/validate.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 { formatValidate, 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 { computeMissingKeys } from "../../translation/missing-keys.js";
+import { detectFormat, type OutputFormat } from "../format.js";
+import { formatValidate, formatError } from "../formatters.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
 
 export interface ValidateFlags {
   readonly config: string;
@@ -30,7 +30,10 @@ export function runValidate(
     adapter: TranslationAdapter,
     sourceLocale: string,
     targetLocales: readonly string[],
-  ) => Effect.Effect<readonly MissingEntry[], unknown> = computeMissingKeys as unknown as typeof missingKeysComputer,
+  ) => Effect.Effect<
+    readonly MissingEntry[],
+    unknown
+  > = computeMissingKeys as unknown as typeof missingKeysComputer,
   logger: (msg: string) => Effect.Effect<void> = (msg: string) => Console.log(msg),
 ): Effect.Effect<void, Error> {
   return Effect.gen(function* () {
@@ -75,9 +78,7 @@ export function runValidate(
 
     const passing = entries.length === 0;
 
-    yield* logger(
-      formatValidate({ passing, entries }, format),
-    );
+    yield* logger(formatValidate({ passing, entries }, format));
 
     if (!passing) {
       yield* Effect.sync(() => {
@@ -87,10 +88,14 @@ export function runValidate(
   }).pipe(Effect.mapError((e) => e as Error)) as Effect.Effect<void, Error, never>;
 }
 
-export const validateCommand = Command.make('validate', {
-  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) => runValidate(flags));
+export const validateCommand = Command.make(
+  "validate",
+  {
+    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) => runValidate(flags),
+);

package/src/cli/config-resolution.test.ts

@@ -1,77 +1,122 @@
-import { describe, expect, it } from 'vitest';
-import { resolveEffectiveConfig } from './config-resolution.js';
-import type { DialektConfig } from '../config/types.js';
+import { describe, expect, it } from "vitest";
+import { resolveEffectiveConfig } from "./config-resolution.js";
+import type { DialektConfig } from "../config/types.js";
 
 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: [],
 };
 
-describe('resolveEffectiveConfig', () => {
-  it('uses loaded config when no flags given', () => {
+describe("resolveEffectiveConfig", () => {
+  it("uses loaded config when no flags given", () => {
     const result = resolveEffectiveConfig({}, baseConfig);
-    expect(result.sourceLocale).toBe('en');
-    expect(result.targetLocales).toEqual(['de', 'fr']);
+    expect(result.sourceLocale).toBe("en");
+    expect(result.targetLocales).toEqual(["de", "fr"]);
   });
 
-  it('overrides sourceLocale with flag', () => {
-    const result = resolveEffectiveConfig({ baseLanguage: 'fr' }, baseConfig);
-    expect(result.sourceLocale).toBe('fr');
+  it("overrides sourceLocale with flag", () => {
+    const result = resolveEffectiveConfig({ baseLanguage: "fr" }, baseConfig);
+    expect(result.sourceLocale).toBe("fr");
   });
 
-  it('overrides strategy with flag', () => {
-    const result = resolveEffectiveConfig({ strategy: 'tool-loop-agent' }, baseConfig);
-    expect(result.strategy).toBe('tool-loop-agent');
+  it("overrides strategy with flag", () => {
+    const result = resolveEffectiveConfig({ strategy: "tool-loop-agent" }, baseConfig);
+    expect(result.strategy).toBe("tool-loop-agent");
   });
 
-  it('filters adapters by name flag', () => {
-    const adapterA = { name: 'a', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
-    const adapterB = { name: 'b', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
+  it("filters adapters by name flag", () => {
+    const adapterA = {
+      name: "a",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
+    const adapterB = {
+      name: "b",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
     const config = { ...baseConfig, adapters: [adapterA, adapterB] };
-    const result = resolveEffectiveConfig({ adapter: 'b' }, config);
+    const result = resolveEffectiveConfig({ adapter: "b" }, config);
     expect(result.adapters).toHaveLength(1);
-    expect(result.adapters[0]!.name).toBe('b');
+    expect(result.adapters[0]!.name).toBe("b");
   });
 
-  it('returns all adapters when adapter flag does not match any', () => {
-    const adapterA = { name: 'a', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
+  it("returns all adapters when adapter flag does not match any", () => {
+    const adapterA = {
+      name: "a",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
     const config = { ...baseConfig, adapters: [adapterA] };
-    const result = resolveEffectiveConfig({ adapter: 'nonexistent' }, config);
+    const result = resolveEffectiveConfig({ adapter: "nonexistent" }, config);
     expect(result.adapters).toHaveLength(0);
   });
 
-  it('overrides targetLocales with language flag', () => {
-    const result = resolveEffectiveConfig({ language: ['es'] }, baseConfig);
-    expect(result.targetLocales).toEqual(['es']);
+  it("overrides targetLocales with language flag", () => {
+    const result = resolveEffectiveConfig({ language: ["es"] }, baseConfig);
+    expect(result.targetLocales).toEqual(["es"]);
   });
 
-  it('preserves targetLocales when language flag is empty', () => {
+  it("preserves targetLocales when language flag is empty", () => {
     const result = resolveEffectiveConfig({ language: [] }, baseConfig);
-    expect(result.targetLocales).toEqual(['de', 'fr']);
+    expect(result.targetLocales).toEqual(["de", "fr"]);
   });
 
-  it('preserves targetLocales when language flag is undefined', () => {
+  it("preserves targetLocales when language flag is undefined", () => {
     const result = resolveEffectiveConfig({}, baseConfig);
-    expect(result.targetLocales).toEqual(['de', 'fr']);
+    expect(result.targetLocales).toEqual(["de", "fr"]);
   });
 
-  it('does not override strategy when flag is undefined', () => {
+  it("does not override strategy when flag is undefined", () => {
     const result = resolveEffectiveConfig({}, baseConfig);
-    expect(result.strategy).toBe('one-shot');
+    expect(result.strategy).toBe("one-shot");
   });
 
-  it('does not override sourceLocale when baseLanguage is undefined', () => {
+  it("does not override sourceLocale when baseLanguage is undefined", () => {
     const result = resolveEffectiveConfig({}, baseConfig);
-    expect(result.sourceLocale).toBe('en');
+    expect(result.sourceLocale).toBe("en");
   });
 
-  it('preserves other config fields unchanged', () => {
+  it("preserves other config fields unchanged", () => {
     const result = resolveEffectiveConfig({}, baseConfig);
     expect(result.model).toEqual(baseConfig.model);
     expect(result.fastModel).toEqual(baseConfig.fastModel);
@@ -79,21 +124,96 @@ describe('resolveEffectiveConfig', () => {
     expect(result.retry).toEqual(baseConfig.retry);
   });
 
-  it('handles multiple adapter filters matching one', () => {
-    const a1 = { name: 'laravel', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
-    const a2 = { name: 'paraglide', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
+  it("handles multiple adapter filters matching one", () => {
+    const a1 = {
+      name: "laravel",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
+    const a2 = {
+      name: "paraglide",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
     const config = { ...baseConfig, adapters: [a1, a2] };
-    const result = resolveEffectiveConfig({ adapter: 'laravel' }, config);
+    const result = resolveEffectiveConfig({ adapter: "laravel" }, config);
     expect(result.adapters).toHaveLength(1);
-    expect(result.adapters[0]!.name).toBe('laravel');
+    expect(result.adapters[0]!.name).toBe("laravel");
   });
 
-  it('preserves adapter order after filtering', () => {
-    const a1 = { name: 'first', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
-    const a2 = { name: 'second', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
-    const a3 = { name: 'third', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as import('../config/types.js').DialektConfig['adapters'][number];
+  it("preserves adapter order after filtering", () => {
+    const a1 = {
+      name: "first",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
+    const a2 = {
+      name: "second",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
+    const a3 = {
+      name: "third",
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => {
+        throw new Error();
+      },
+      listResources: () => {
+        throw new Error();
+      },
+      readResource: () => {
+        throw new Error();
+      },
+      writeResource: () => {
+        throw new Error();
+      },
+    } as unknown as import("../config/types.js").DialektConfig["adapters"][number];
     const config = { ...baseConfig, adapters: [a1, a2, a3] };
-    const result = resolveEffectiveConfig({ adapter: 'second' }, config);
-    expect(result.adapters[0]!.name).toBe('second');
+    const result = resolveEffectiveConfig({ adapter: "second" }, config);
+    expect(result.adapters[0]!.name).toBe("second");
   });
 });

package/src/cli/config-resolution.ts

@@ -1,9 +1,9 @@
-import type { DialektConfig } from '../config/types.js';
+import type { DialektConfig } from "../config/types.js";
 
 export interface CliFlags {
   readonly config?: string | undefined;
   readonly adapter?: string | undefined;
-  readonly strategy?: 'one-shot' | 'tool-loop-agent' | undefined;
+  readonly strategy?: "one-shot" | "tool-loop-agent" | undefined;
   readonly baseLanguage?: string | undefined;
   readonly language?: readonly string[] | undefined;
   readonly name?: readonly string[] | undefined;
@@ -13,14 +13,12 @@ export interface CliFlags {
   readonly langDir?: string | undefined;
 }
 
-export function resolveEffectiveConfig(
-  flags: CliFlags,
-  loaded: DialektConfig,
-): DialektConfig {
+export function resolveEffectiveConfig(flags: CliFlags, loaded: DialektConfig): DialektConfig {
   return {
     ...loaded,
     sourceLocale: flags.baseLanguage ?? loaded.sourceLocale,
-    targetLocales: flags.language && flags.language.length > 0 ? flags.language : loaded.targetLocales,
+    targetLocales:
+      flags.language && flags.language.length > 0 ? flags.language : loaded.targetLocales,
     strategy: flags.strategy ?? loaded.strategy,
     adapters: flags.adapter
       ? loaded.adapters.filter((a: { name: string }) => a.name === flags.adapter)

package/src/cli/format.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, afterEach } from 'vitest';
+import { describe, expect, it, afterEach } from "vitest";
 import {
   detectFormat,
   color,
@@ -10,9 +10,9 @@ import {
   warning,
   info,
   keyValue,
-} from './format.js';
+} from "./format.js";
 
-describe('detectFormat', () => {
+describe("detectFormat", () => {
   const originalTty = process.stdout.isTTY;
   const originalEnv = { ...process.env };
 
@@ -24,94 +24,94 @@ describe('detectFormat', () => {
     Object.assign(process.env, originalEnv);
   });
 
-  it('returns explicit format when provided', () => {
-    expect(detectFormat('json')).toBe('json');
-    expect(detectFormat('pretty')).toBe('pretty');
+  it("returns explicit format when provided", () => {
+    expect(detectFormat("json")).toBe("json");
+    expect(detectFormat("pretty")).toBe("pretty");
   });
 
-  it('defaults to json when not a TTY', () => {
+  it("defaults to json when not a TTY", () => {
     Object.assign(process.stdout, { isTTY: false });
-    expect(detectFormat()).toBe('json');
+    expect(detectFormat()).toBe("json");
   });
 
-  it('defaults to pretty when TTY and no agent env', () => {
+  it("defaults to pretty when TTY and no agent env", () => {
     Object.assign(process.stdout, { isTTY: true });
-    expect(detectFormat()).toBe('pretty');
+    expect(detectFormat()).toBe("pretty");
   });
 
-  it('defaults to json when agent env var is set', () => {
+  it("defaults to json when agent env var is set", () => {
     Object.assign(process.stdout, { isTTY: true });
-    process.env.CLAUDE_CODE = '1';
-    expect(detectFormat()).toBe('json');
+    process.env.CLAUDE_CODE = "1";
+    expect(detectFormat()).toBe("json");
   });
 });
 
-describe('color', () => {
-  it('returns bare text when not a TTY', () => {
-    expect(color('hello', '\x1b[31m')).toBe('hello');
+describe("color", () => {
+  it("returns bare text when not a TTY", () => {
+    expect(color("hello", "\x1b[31m")).toBe("hello");
   });
 });
 
-describe('drawTable', () => {
-  it('renders a table with headers and rows', () => {
+describe("drawTable", () => {
+  it("renders a table with headers and rows", () => {
     const table = drawTable(
-      ['Name', 'Score'],
+      ["Name", "Score"],
       [
-        ['Alice', '10'],
-        ['Bob', '8'],
+        ["Alice", "10"],
+        ["Bob", "8"],
       ],
     );
-    expect(table).toContain('Name');
-    expect(table).toContain('Score');
-    expect(table).toContain('Alice');
-    expect(table).toContain('Bob');
+    expect(table).toContain("Name");
+    expect(table).toContain("Score");
+    expect(table).toContain("Alice");
+    expect(table).toContain("Bob");
   });
 
-  it('handles empty rows', () => {
-    const table = drawTable(['A'], []);
-    expect(table).toContain('A');
+  it("handles empty rows", () => {
+    const table = drawTable(["A"], []);
+    expect(table).toContain("A");
   });
 });
 
-describe('banner', () => {
-  it('includes the title', () => {
-    expect(banner('Results')).toContain('Results');
+describe("banner", () => {
+  it("includes the title", () => {
+    expect(banner("Results")).toContain("Results");
   });
 });
 
-describe('sectionHeader', () => {
-  it('includes the label', () => {
-    expect(sectionHeader('Missing keys')).toContain('Missing keys');
+describe("sectionHeader", () => {
+  it("includes the label", () => {
+    expect(sectionHeader("Missing keys")).toContain("Missing keys");
   });
 });
 
-describe('success', () => {
-  it('includes the text', () => {
-    expect(success('Done')).toContain('Done');
+describe("success", () => {
+  it("includes the text", () => {
+    expect(success("Done")).toContain("Done");
   });
 });
 
-describe('failure', () => {
-  it('includes the text', () => {
-    expect(failure('Failed')).toContain('Failed');
+describe("failure", () => {
+  it("includes the text", () => {
+    expect(failure("Failed")).toContain("Failed");
   });
 });
 
-describe('warning', () => {
-  it('includes the text', () => {
-    expect(warning('Warn')).toContain('Warn');
+describe("warning", () => {
+  it("includes the text", () => {
+    expect(warning("Warn")).toContain("Warn");
   });
 });
 
-describe('info', () => {
-  it('returns dimmed text', () => {
-    expect(info('note')).toBe('note');
+describe("info", () => {
+  it("returns dimmed text", () => {
+    expect(info("note")).toBe("note");
   });
 });
 
-describe('keyValue', () => {
-  it('formats key and value', () => {
-    expect(keyValue('Name:', 'test')).toContain('Name:');
-    expect(keyValue('Name:', 'test')).toContain('test');
+describe("keyValue", () => {
+  it("formats key and value", () => {
+    expect(keyValue("Name:", "test")).toContain("Name:");
+    expect(keyValue("Name:", "test")).toContain("test");
   });
 });