dialekt 0.1.0 → 0.1.1

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

@@ -1,17 +1,17 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Option } from 'effect';
-import { runTranslate, translateCommand } from './translate.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
-import type { TranslationStrategy } from '../../translation/types.js';
-
-describe('runTranslate', () => {
+import { describe, expect, it } from "vitest";
+import { Effect, Option } from "effect";
+import { runTranslate, translateCommand } from "./translate.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationAdapter, ResourceRef } from "../../adapter/types.js";
+import type { TranslationStrategy } from "../../translation/types.js";
+
+describe("runTranslate", () => {
   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: [],
@@ -21,22 +21,22 @@ describe('runTranslate', () => {
     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('loads config and runs translation with default model', async () => {
+  it("loads config and runs translation with default model", async () => {
     const logs: string[] = [];
     let translationCalls = 0;
-    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 = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -52,7 +52,7 @@ describe('runTranslate', () => {
         Effect.sync(() => {
           translationCalls++;
           expect(opts.adapters).toHaveLength(1);
-          expect(opts.sourceLocale).toBe('en');
+          expect(opts.sourceLocale).toBe("en");
         }),
       (msg) => Effect.sync(() => logs.push(msg)),
     );
@@ -62,17 +62,17 @@ describe('runTranslate', () => {
     expect(logs).toHaveLength(1);
     const parsed = JSON.parse(logs[0]!);
     expect(parsed.success).toBe(true);
-    expect(parsed.message).toBe('Translation complete.');
+    expect(parsed.message).toBe("Translation complete.");
   });
 
-  it('uses fastModel when --fast is passed', async () => {
+  it("uses fastModel when --fast is passed", async () => {
     let usedModel: 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 = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -93,21 +93,21 @@ describe('runTranslate', () => {
     );
 
     await Effect.runPromise(program);
-    expect(usedModel).toBe('gpt-4o-mini');
+    expect(usedModel).toBe("gpt-4o-mini");
   });
 
-  it('uses default strategy from config', async () => {
+  it("uses default strategy from config", async () => {
     let strategy: TranslationStrategy | undefined;
-    const adapter = makeAdapter({ name: 'test' });
+    const adapter = makeAdapter({ name: "test" });
     const config: DialektConfig = {
       ...baseConfig,
-      strategy: 'tool-loop-agent',
-      adapters: [adapter] as unknown as DialektConfig['adapters'],
+      strategy: "tool-loop-agent",
+      adapters: [adapter] as unknown as DialektConfig["adapters"],
     };
 
     const program = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -128,19 +128,19 @@ describe('runTranslate', () => {
 
     await Effect.runPromise(program);
     expect(strategy).toBeDefined();
-    expect(strategy!.name).toBe('tool-loop-agent');
+    expect(strategy!.name).toBe("tool-loop-agent");
   });
 
-  it('overrides strategy with --strategy flag', async () => {
+  it("overrides strategy with --strategy flag", async () => {
     let strategyName: 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 = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
-        strategy: Option.some('tool-loop-agent'),
+        strategy: Option.some("tool-loop-agent"),
         baseLanguage: Option.none(),
         language: Option.none(),
         name: Option.none(),
@@ -158,19 +158,19 @@ describe('runTranslate', () => {
     );
 
     await Effect.runPromise(program);
-    expect(strategyName).toBe('tool-loop-agent');
+    expect(strategyName).toBe("tool-loop-agent");
   });
 
-  it('filters adapters by --adapter flag', async () => {
+  it("filters adapters by --adapter flag", async () => {
     let usedAdapterName: 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 = runTranslate(
       {
-        config: './config.ts',
-        adapter: Option.some('a2'),
+        config: "./config.ts",
+        adapter: Option.some("a2"),
         strategy: Option.none(),
         baseLanguage: Option.none(),
         language: Option.none(),
@@ -189,13 +189,13 @@ describe('runTranslate', () => {
     );
 
     await Effect.runPromise(program);
-    expect(usedAdapterName).toBe('a2');
+    expect(usedAdapterName).toBe("a2");
   });
 
-  it('fails when configLoader fails', async () => {
+  it("fails when configLoader fails", async () => {
     const program = runTranslate(
       {
-        config: './missing.ts',
+        config: "./missing.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -205,21 +205,21 @@ describe('runTranslate', () => {
         skipLanguages: false,
         fast: false,
       },
-      () => Effect.fail(new Error('Config not found')),
+      () => 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 modelResolver fails', async () => {
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+  it("fails when modelResolver fails", async () => {
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -230,20 +230,20 @@ describe('runTranslate', () => {
         fast: false,
       },
       () => Effect.succeed(config),
-      () => Effect.fail(new Error('No API key')),
+      () => Effect.fail(new Error("No API key")),
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('No API key');
+    await expect(Effect.runPromise(program)).rejects.toThrow("No API key");
   });
 
-  it('fails when translationRunner fails', async () => {
-    const adapter = makeAdapter({ name: 'test' });
-    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+  it("fails when translationRunner fails", async () => {
+    const adapter = makeAdapter({ name: "test" });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig["adapters"] };
 
     const program = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -255,21 +255,21 @@ describe('runTranslate', () => {
       },
       () => Effect.succeed(config),
       () => Effect.succeed({}),
-      () => Effect.fail(new Error('Translation failed')),
+      () => Effect.fail(new Error("Translation failed")),
       () => Effect.void,
     );
 
-    await expect(Effect.runPromise(program)).rejects.toThrow('Translation failed');
+    await expect(Effect.runPromise(program)).rejects.toThrow("Translation failed");
   });
 
-  it('uses one-shot strategy by default', async () => {
+  it("uses one-shot strategy by default", async () => {
     let strategyName: 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 = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -289,21 +289,21 @@ describe('runTranslate', () => {
     );
 
     await Effect.runPromise(program);
-    expect(strategyName).toBe('one-shot');
+    expect(strategyName).toBe("one-shot");
   });
 
-  it('filters target locales by --language flag', async () => {
+  it("filters target locales by --language flag", async () => {
     let targetLocales: readonly 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 = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
-        language: Option.some('de'),
+        language: Option.some("de"),
         name: Option.none(),
         skipNames: false,
         skipLanguages: false,
@@ -319,17 +319,17 @@ describe('runTranslate', () => {
     );
 
     await Effect.runPromise(program);
-    expect(targetLocales).toEqual(['de']);
+    expect(targetLocales).toEqual(["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 = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),
@@ -338,7 +338,7 @@ describe('runTranslate', () => {
         skipNames: false,
         skipLanguages: false,
         fast: false,
-        format: Option.some('pretty'),
+        format: Option.some("pretty"),
       },
       () => Effect.succeed(config),
       () => Effect.succeed({}),
@@ -348,16 +348,16 @@ describe('runTranslate', () => {
 
     await Effect.runPromise(program);
     expect(logs).toHaveLength(1);
-    expect(logs[0]).toContain('Translation complete');
+    expect(logs[0]).toContain("Translation complete");
   });
 
-  it('handles empty adapters list', async () => {
+  it("handles empty adapters list", async () => {
     const logs: string[] = [];
     const config = { ...baseConfig, adapters: [] };
 
     const program = runTranslate(
       {
-        config: './config.ts',
+        config: "./config.ts",
         adapter: Option.none(),
         strategy: Option.none(),
         baseLanguage: Option.none(),

package/src/cli/commands/translate.ts

@@ -1,15 +1,15 @@
-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 { 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 { detectFormat, type OutputFormat } from '../format.js';
-import { formatTranslate, formatError } from '../formatters.js';
-import type { DialektConfig } from '../../config/types.js';
-import type { TranslationStrategy } from '../../translation/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 { 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 { detectFormat, type OutputFormat } from "../format.js";
+import { formatTranslate, formatError } from "../formatters.js";
+import type { DialektConfig } from "../../config/types.js";
+import type { TranslationStrategy } from "../../translation/types.js";
 
 export interface TranslateFlags {
   readonly config: string;
@@ -27,7 +27,10 @@ export interface TranslateFlags {
 export function runTranslate(
   flags: TranslateFlags,
   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;
@@ -45,19 +48,22 @@ export function runTranslate(
         language: Option.isSome(flags.language) ? [flags.language.value] : undefined,
         adapter: Option.getOrUndefined(flags.adapter),
         strategy:
-          Option.getOrUndefined(flags.strategy) === 'one-shot' ||
-          Option.getOrUndefined(flags.strategy) === 'tool-loop-agent'
-            ? (Option.getOrUndefined(flags.strategy) as 'one-shot' | 'tool-loop-agent')
+          Option.getOrUndefined(flags.strategy) === "one-shot" ||
+          Option.getOrUndefined(flags.strategy) === "tool-loop-agent"
+            ? (Option.getOrUndefined(flags.strategy) as "one-shot" | "tool-loop-agent")
             : undefined,
       },
       loaded,
     );
 
     const modelConfig = flags.fast ? effective.fastModel : 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 });
 
@@ -79,7 +85,7 @@ export function runTranslate(
       formatTranslate(
         {
           success: true,
-          message: 'Translation complete.',
+          message: "Translation complete.",
           stats: {
             adaptersProcessed: effective.adapters.length,
             localesTranslated: (effective.targetLocales ?? []).length,
@@ -92,15 +98,19 @@ export function runTranslate(
   });
 }
 
-export const translateCommand = Command.make('translate', {
-  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
-  adapter: Options.optional(Options.text('adapter')),
-  strategy: Options.optional(Options.text('strategy')),
-  baseLanguage: Options.optional(Options.text('base-language')),
-  language: Options.optional(Options.text('language')),
-  name: Options.optional(Options.text('name')),
-  skipNames: Options.boolean('skip-names'),
-  skipLanguages: Options.boolean('skip-languages'),
-  fast: Options.boolean('fast'),
-  format: Options.optional(Options.text('format')),
-}, (flags) => runTranslate(flags));
+export const translateCommand = Command.make(
+  "translate",
+  {
+    config: Options.text("config").pipe(Options.withDefault("./dialekt.config.ts")),
+    adapter: Options.optional(Options.text("adapter")),
+    strategy: Options.optional(Options.text("strategy")),
+    baseLanguage: Options.optional(Options.text("base-language")),
+    language: Options.optional(Options.text("language")),
+    name: Options.optional(Options.text("name")),
+    skipNames: Options.boolean("skip-names"),
+    skipLanguages: Options.boolean("skip-languages"),
+    fast: Options.boolean("fast"),
+    format: Options.optional(Options.text("format")),
+  },
+  (flags) => runTranslate(flags),
+);