dialekt 0.1.0 → 0.1.1

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

@@ -1,128 +1,103 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { runAdd, addCommand, parseAddTokens } from './add.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
-
-describe('parseAddTokens', () => {
-  it('parses resource.key=value pairs', async () => {
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { runAdd, addCommand, parseAddTokens } from "./add.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
+
+describe("parseAddTokens", () => {
+  it("parses resource.key=value pairs", async () => {
     const errors: string[] = [];
-    const program = parseAddTokens(
-      ['messages.hello=Hello', 'validation.email=Email'],
-      (msg) => Effect.sync(() => errors.push(msg)),
+    const program = parseAddTokens(["messages.hello=Hello", "validation.email=Email"], (msg) =>
+      Effect.sync(() => errors.push(msg)),
     );
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      messages: { hello: 'Hello' },
-      validation: { email: 'Email' },
+      messages: { hello: "Hello" },
+      validation: { email: "Email" },
     });
     expect(errors).toHaveLength(0);
   });
 
-  it('handles empty tokens', async () => {
-    const program = parseAddTokens(
-      [],
-      () => Effect.void,
-    );
+  it("handles empty tokens", async () => {
+    const program = parseAddTokens([], () => Effect.void);
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({});
   });
 
-  it('logs error for tokens without =', async () => {
+  it("logs error for tokens without =", async () => {
     const errors: string[] = [];
-    const program = parseAddTokens(
-      ['invalid-token'],
-      (msg) => Effect.sync(() => errors.push(msg)),
-    );
+    const program = parseAddTokens(["invalid-token"], (msg) => Effect.sync(() => errors.push(msg)));
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({});
     expect(errors[0]).toContain("Invalid token (missing '=')");
-    expect(errors[0]).toContain('invalid-token');
+    expect(errors[0]).toContain("invalid-token");
   });
 
-  it('logs error for keys without resource segment', async () => {
+  it("logs error for keys without resource segment", async () => {
     const errors: string[] = [];
-    const program = parseAddTokens(
-      ['no_dot=value'],
-      (msg) => Effect.sync(() => errors.push(msg)),
-    );
+    const program = parseAddTokens(["no_dot=value"], (msg) => Effect.sync(() => errors.push(msg)));
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({});
-    expect(errors[0]).toContain('Invalid key (no resource segment)');
+    expect(errors[0]).toContain("Invalid key (no resource segment)");
   });
 
-  it('handles multiple keys in the same resource', async () => {
-    const program = parseAddTokens(
-      ['messages.hello=Hello', 'messages.bye=Bye'],
-      () => Effect.void,
-    );
+  it("handles multiple keys in the same resource", async () => {
+    const program = parseAddTokens(["messages.hello=Hello", "messages.bye=Bye"], () => Effect.void);
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      messages: { hello: 'Hello', bye: 'Bye' },
+      messages: { hello: "Hello", bye: "Bye" },
     });
   });
 
-  it('handles values containing =', async () => {
-    const program = parseAddTokens(
-      ['messages.greeting=Hello=World'],
-      () => Effect.void,
-    );
+  it("handles values containing =", async () => {
+    const program = parseAddTokens(["messages.greeting=Hello=World"], () => Effect.void);
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      messages: { greeting: 'Hello=World' },
+      messages: { greeting: "Hello=World" },
     });
   });
 
-  it('ignores tokens after first = in key portion', async () => {
-    const program = parseAddTokens(
-      ['messages.key=val=ue'],
-      () => Effect.void,
-    );
+  it("ignores tokens after first = in key portion", async () => {
+    const program = parseAddTokens(["messages.key=val=ue"], () => Effect.void);
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      messages: { key: 'val=ue' },
+      messages: { key: "val=ue" },
     });
   });
 
-  it('handles empty values', async () => {
-    const program = parseAddTokens(
-      ['messages.empty='],
-      () => Effect.void,
-    );
+  it("handles empty values", async () => {
+    const program = parseAddTokens(["messages.empty="], () => Effect.void);
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      messages: { empty: '' },
+      messages: { empty: "" },
     });
   });
 
-  it('handles deeply nested resource names by splitting on first dot only', async () => {
-    const program = parseAddTokens(
-      ['a.b.c.key=value'],
-      () => Effect.void,
-    );
+  it("handles deeply nested resource names by splitting on first dot only", async () => {
+    const program = parseAddTokens(["a.b.c.key=value"], () => Effect.void);
 
     const result = await Effect.runPromise(program);
     expect(result).toEqual({
-      a: { 'b.c.key': 'value' },
+      a: { "b.c.key": "value" },
     });
   });
 });
 
-describe('runAdd', () => {
+describe("runAdd", () => {
   const baseConfig: DialektConfig = {
-    sourceLocale: 'en',
-    targetLocales: ['de'],
-    strategy: 'one-shot',
-    model: { provider: 'openai', modelId: 'gpt-4o' },
-    fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+    sourceLocale: "en",
+    targetLocales: ["de"],
+    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: [],
@@ -139,27 +114,33 @@ describe('runAdd', () => {
     };
   }
 
-  it('writes entries to all adapters and triggers translation', async () => {
-    const writes: Array<{ adapter: string; locale: string; resource: string; entries: Record<string, string> }> = [];
+  it("writes entries to all adapters and triggers translation", async () => {
+    const writes: Array<{
+      adapter: string;
+      locale: string;
+      resource: string;
+      entries: Record<string, string>;
+    }> = [];
     let translated = false;
 
-    const adapter = makeAdapter('test');
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter("test");
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runAdd(
-      { config: './config.ts', create: false },
-      ['messages.hello=Hello'],
+      { config: "./config.ts", create: false },
+      ["messages.hello=Hello"],
       () => Effect.succeed(config),
       () => Effect.succeed({} as unknown),
       () =>
         Effect.sync(() => {
           translated = true;
         }),
-      (msg) => Effect.sync(() => {
-        const parsed = JSON.parse(msg);
-        expect(parsed.success).toBe(true);
-        expect(parsed.message).toBe('Add + translate complete.');
-      }),
+      (msg) =>
+        Effect.sync(() => {
+          const parsed = JSON.parse(msg);
+          expect(parsed.success).toBe(true);
+          expect(parsed.message).toBe("Add + translate complete.");
+        }),
       () => Effect.void,
     );
 
@@ -167,61 +148,61 @@ describe('runAdd', () => {
     expect(translated).toBe(true);
   });
 
-  it('fails when configLoader fails', async () => {
+  it("fails when configLoader fails", async () => {
     const program = runAdd(
-      { config: './missing.ts', create: false },
-      ['messages.hello=Hello'],
-      () => Effect.fail(new Error('Config not found')),
+      { config: "./missing.ts", create: false },
+      ["messages.hello=Hello"],
+      () => Effect.fail(new Error("Config not found")),
       () => Effect.succeed({} as unknown),
       () => Effect.void,
       () => 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('fails when modelResolver fails', async () => {
-    const adapter = makeAdapter('test');
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+  it("fails when modelResolver fails", async () => {
+    const adapter = makeAdapter("test");
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runAdd(
-      { config: './config.ts', create: false },
-      ['messages.hello=Hello'],
+      { config: "./config.ts", create: false },
+      ["messages.hello=Hello"],
       () => Effect.succeed(config),
-      () => Effect.fail(new Error('Model unavailable')),
+      () => Effect.fail(new Error("Model unavailable")),
       () => Effect.void,
       () => Effect.void,
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('Model unavailable');
+    await expect(Effect.runPromise(program)).rejects.toThrow("Model unavailable");
   });
 
-  it('fails when translationRunner fails', async () => {
-    const adapter = makeAdapter('test');
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+  it("fails when translationRunner fails", async () => {
+    const adapter = makeAdapter("test");
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runAdd(
-      { config: './config.ts', create: false },
-      ['messages.hello=Hello'],
+      { config: "./config.ts", create: false },
+      ["messages.hello=Hello"],
       () => Effect.succeed(config),
       () => Effect.succeed({} as unknown),
-      () => Effect.fail(new Error('Translation failed')),
+      () => Effect.fail(new Error("Translation failed")),
       () => Effect.void,
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('Translation failed');
+    await expect(Effect.runPromise(program)).rejects.toThrow("Translation failed");
   });
 
-  it('handles empty tokens list', async () => {
+  it("handles empty tokens list", async () => {
     let translated = false;
-    const adapter = makeAdapter('test');
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const adapter = makeAdapter("test");
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runAdd(
-      { config: './config.ts', create: false },
+      { config: "./config.ts", create: false },
       [],
       () => Effect.succeed(config),
       () => Effect.succeed({} as unknown),
@@ -237,19 +218,19 @@ describe('runAdd', () => {
     expect(translated).toBe(true);
   });
 
-  it('filters targetLocales to exclude sourceLocale', async () => {
+  it("filters targetLocales to exclude sourceLocale", async () => {
     let usedTargets: readonly string[] | undefined;
-    const adapter = makeAdapter('test');
+    const adapter = makeAdapter("test");
     const config = {
       ...baseConfig,
-      sourceLocale: 'en',
-      targetLocales: ['en', 'de', 'fr'],
-      adapters: [adapter] as unknown as DialektConfig['adapters'],
+      sourceLocale: "en",
+      targetLocales: ["en", "de", "fr"],
+      adapters: [adapter] as unknown as DialektConfig["adapters"],
     };
 
     const program = runAdd(
-      { config: './config.ts', create: false },
-      ['messages.hello=Hello'],
+      { config: "./config.ts", create: false },
+      ["messages.hello=Hello"],
       () => Effect.succeed(config),
       () => Effect.succeed({} as unknown),
       (opts) =>
@@ -261,7 +242,7 @@ describe('runAdd', () => {
     );
 
     await Effect.runPromise(program);
-    expect(usedTargets).not.toContain('en');
-    expect(usedTargets).toContain('de');
+    expect(usedTargets).not.toContain("en");
+    expect(usedTargets).toContain("de");
   });
 });

package/src/cli/commands/add.ts

@@ -1,17 +1,17 @@
-import { Command, Options, Args } from '@effect/cli';
-import { Effect, Console, Option } from 'effect';
-import { loadConfig } from '../../config/load-config.js';
-import { resolveEffectiveConfig } from '../config-resolution.js';
-import { resolveModel } from '../../translation/model-registry.js';
-import { createOneShotStrategy } from '../../translation/one-shot-strategy.js';
-import { createToolLoopStrategy } from '../../translation/tool-loop-strategy.js';
-import { runTranslation } from '../../translation/orchestrator.js';
-import { flattenObject } from '../../keys/flatten.js';
-import { detectFormat, type OutputFormat } from '../format.js';
-import { formatAdd, formatError } from '../formatters.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
-import type { TranslationStrategy } from '../../translation/types.js';
+import { Command, Options, Args } from "@effect/cli";
+import { Effect, Console, Option } from "effect";
+import { loadConfig } from "../../config/load-config.js";
+import { resolveEffectiveConfig } from "../config-resolution.js";
+import { resolveModel } from "../../translation/model-registry.js";
+import { createOneShotStrategy } from "../../translation/one-shot-strategy.js";
+import { createToolLoopStrategy } from "../../translation/tool-loop-strategy.js";
+import { runTranslation } from "../../translation/orchestrator.js";
+import { flattenObject } from "../../keys/flatten.js";
+import { detectFormat, type OutputFormat } from "../format.js";
+import { formatAdd, formatError } from "../formatters.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
+import type { TranslationStrategy } from "../../translation/types.js";
 
 export interface AddFlags {
   readonly config: string;
@@ -27,14 +27,14 @@ export function parseAddTokens(
     const entriesByResource: Record<string, Record<string, string>> = {};
 
     for (const token of tokens) {
-      const eqIdx = token.indexOf('=');
+      const eqIdx = token.indexOf("=");
       if (eqIdx === -1) {
         yield* errorLogger(`Invalid token (missing '='): ${token}`);
         continue;
       }
       const key = token.slice(0, eqIdx);
       const value = token.slice(eqIdx + 1);
-      const dotIdx = key.indexOf('.');
+      const dotIdx = key.indexOf(".");
       if (dotIdx === -1) {
         yield* errorLogger(`Invalid key (no resource segment): ${key}`);
         continue;
@@ -53,7 +53,10 @@ export function runAdd(
   flags: AddFlags,
   tokens: readonly string[],
   configLoader: (path: string) => Effect.Effect<DialektConfig, unknown> = loadConfig,
-  modelResolver: (config: { provider: string; modelId: string }) => Effect.Effect<unknown, unknown> = resolveModel,
+  modelResolver: (config: {
+    provider: string;
+    modelId: string;
+  }) => Effect.Effect<unknown, unknown> = resolveModel,
   translationRunner: (opts: {
     adapters: readonly unknown[];
     strategy: TranslationStrategy;
@@ -80,9 +83,12 @@ export function runAdd(
     }
 
     const modelConfig = effective.model;
-    const model = yield* modelResolver(modelConfig) as Effect.Effect<import('ai').LanguageModel, unknown>;
+    const model = yield* modelResolver(modelConfig) as Effect.Effect<
+      import("ai").LanguageModel,
+      unknown
+    >;
     const translationStrategy =
-      effective.strategy === 'tool-loop-agent'
+      effective.strategy === "tool-loop-agent"
         ? createToolLoopStrategy({ model, retry: effective.retry })
         : createOneShotStrategy({ model, retry: effective.retry });
 
@@ -104,7 +110,7 @@ export function runAdd(
       formatAdd(
         {
           success: true,
-          message: 'Add + translate complete.',
+          message: "Add + translate complete.",
           addedResources,
         },
         format,
@@ -113,11 +119,17 @@ export function runAdd(
   });
 }
 
-export const addCommand = Command.make('add', {
-  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
-  create: Options.boolean('create'),
-  format: Options.optional(Options.text('format')),
-}, ({ config, create, format }) => {
-  const rawTokens = process.argv.slice(3).filter((t: string) => !t.startsWith('--') && !t.startsWith('-'));
-  return runAdd({ config, create, format }, rawTokens);
-});
+export const addCommand = Command.make(
+  "add",
+  {
+    config: Options.text("config").pipe(Options.withDefault("./dialekt.config.ts")),
+    create: Options.boolean("create"),
+    format: Options.optional(Options.text("format")),
+  },
+  ({ config, create, format }) => {
+    const rawTokens = process.argv
+      .slice(3)
+      .filter((t: string) => !t.startsWith("--") && !t.startsWith("-"));
+    return runAdd({ config, create, format }, rawTokens);
+  },
+);