dialekt 0.1.0

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

@@ -0,0 +1,346 @@
+import { describe, expect, it } from 'vitest';
+import { Effect, Option } from 'effect';
+import { runBenchmarkCommand, benchmarkCommand } from './benchmark.js';
+import type { DialektConfig } from '../../config/types.js';
+import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
+import type { TranslationStrategy, TranslationContext } from '../../translation/types.js';
+import type { StrategyBenchmarkSummary } from '../../benchmark/metrics.js';
+
+describe('runBenchmarkCommand', () => {
+  const baseConfig: DialektConfig = {
+    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: [],
+  };
+
+  function makeAdapter(opts: {
+    name: string;
+    locales?: readonly string[];
+    resources?: readonly ResourceRef[];
+    sourceMap?: Record<string, string>;
+    targetMap?: Record<string, string>;
+    missing?: readonly string[];
+  }): TranslationAdapter {
+    return {
+      name: opts.name,
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
+      listResources: () => Effect.succeed(opts.resources ?? [{ key: 'messages', label: 'messages' }]),
+      readResource: (_locale: string) =>
+        Effect.succeed(_locale === 'en' ? (opts.sourceMap ?? {}) : (opts.targetMap ?? {})),
+      writeResource: () => Effect.void,
+    };
+  }
+
+  function makeDeps(
+    overrides?: Partial<Parameters<typeof runBenchmarkCommand>[1]>,
+  ): Parameters<typeof runBenchmarkCommand>[1] {
+    return {
+      configLoader: () => Effect.succeed(baseConfig),
+      modelResolver: () => Effect.succeed({} as unknown),
+      missingKeysComputer: () =>
+        Effect.succeed([{ adapter: 'test', locale: 'de', resource: { key: 'messages', label: 'messages' } as ResourceRef, missing: ['hello'] as readonly string[] }]),
+      benchmarkRunner: () =>
+        Effect.succeed([
+          {
+            strategyName: 'one-shot',
+            totalChunks: 1,
+            succeededChunks: 1,
+            failedChunks: 0,
+            totalDurationMs: 100,
+            averageDurationMsPerChunk: 100,
+            totalAttempts: 1,
+          } as StrategyBenchmarkSummary,
+        ]),
+      logger: () => Effect.void,
+      errorLogger: () => Effect.void,
+      ...overrides,
+    };
+  }
+
+  it('logs a cost warning', async () => {
+    const errors: string[] = [];
+    const deps = makeDeps({
+      errorLogger: (msg) => Effect.sync(() => errors.push(msg)),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(errors.some((e) => e.includes('Warning') && e.includes('cost'))).toBe(true);
+  });
+
+  it('uses default strategies when none specified', async () => {
+    let usedStrategies: readonly string[] | undefined;
+    const deps = makeDeps({
+      benchmarkRunner: (opts) =>
+        Effect.sync(() => {
+          usedStrategies = opts.strategies.map((s) => s.name);
+          return [];
+        }),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedStrategies).toEqual(['one-shot', 'tool-loop-agent']);
+  });
+
+  it('uses custom strategies when --strategies is passed', async () => {
+    let usedStrategies: readonly string[] | undefined;
+    const deps = makeDeps({
+      benchmarkRunner: (opts) =>
+        Effect.sync(() => {
+          usedStrategies = opts.strategies.map((s) => s.name);
+          return [];
+        }),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.some('tool-loop-agent'),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedStrategies).toEqual(['tool-loop-agent']);
+  });
+
+  it('limits sample size with --sample-size', async () => {
+    let usedChunks: readonly TranslationContext[] | undefined;
+    const adapter = makeAdapter({
+      name: 'test',
+      sourceMap: { a: 'A', b: 'B', c: 'C' },
+      targetMap: {},
+    });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const deps = makeDeps({
+      configLoader: () => Effect.succeed(config),
+      benchmarkRunner: (opts) =>
+        Effect.sync(() => {
+          usedChunks = opts.chunks;
+          return [];
+        }),
+      missingKeysComputer: () =>
+        Effect.succeed([
+          { adapter: 'test', locale: 'de', resource: { key: 'messages', label: 'messages' } as ResourceRef, missing: ['a', 'b', 'c'] as readonly string[] },
+        ]),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.some(1),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedChunks).toHaveLength(1);
+  });
+
+  it('outputs JSON report when --format json is passed', async () => {
+    const logs: string[] = [];
+    const deps = makeDeps({
+      logger: (msg) => Effect.sync(() => logs.push(msg)),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+        format: Option.some('json'),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toBeInstanceOf(Array);
+    expect(parsed[0]).toMatchObject({ strategyName: 'one-shot' });
+  });
+
+  it('outputs benchmark data by default', async () => {
+    const logs: string[] = [];
+    const deps = makeDeps({
+      logger: (msg) => Effect.sync(() => logs.push(msg)),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toBeInstanceOf(Array);
+  });
+
+  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 deps = makeDeps({
+      configLoader: () => Effect.succeed(config),
+      missingKeysComputer: (a) =>
+        Effect.sync(() => {
+          queriedAdapter = a.name;
+          return [];
+        }),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.some('a2'),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(queriedAdapter).toBe('a2');
+  });
+
+  it('fails when configLoader fails', async () => {
+    const deps = makeDeps({
+      configLoader: () => Effect.fail(new Error('Config not found')),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './missing.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+  });
+
+  it('fails when modelResolver fails', async () => {
+    const deps = makeDeps({
+      modelResolver: () => Effect.fail(new Error('Model unavailable')),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Model unavailable');
+  });
+
+  it('fails when benchmarkRunner fails', async () => {
+    const deps = makeDeps({
+      benchmarkRunner: () => Effect.fail(new Error('Benchmark crashed')),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Benchmark crashed');
+  });
+
+  it('handles empty adapter list', async () => {
+    const logs: string[] = [];
+    const config = { ...baseConfig, adapters: [] };
+    const deps = makeDeps({
+      configLoader: () => Effect.succeed(config),
+      benchmarkRunner: () => Effect.succeed([]),
+      logger: (msg) => Effect.sync(() => logs.push(msg)),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toEqual([]);
+  });
+
+  it('handles adapter with no missing keys', async () => {
+    let usedChunks: readonly TranslationContext[] | undefined;
+    const deps = makeDeps({
+      missingKeysComputer: () => Effect.succeed([]),
+      benchmarkRunner: (opts) =>
+        Effect.sync(() => {
+          usedChunks = opts.chunks;
+          return [];
+        }),
+    });
+
+    const program = runBenchmarkCommand(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategies: Option.none(),
+        sampleSize: Option.none(),
+      },
+      deps,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedChunks).toHaveLength(0);
+  });
+});

package/src/cli/commands/benchmark.ts

@@ -0,0 +1,148 @@
+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 { chunkKeys } from '../../translation/chunking.js';
+import { computeMissingKeys } from '../../translation/missing-keys.js';
+import { runBenchmark } from '../../benchmark/runner.js';
+import { detectFormat, type OutputFormat } from '../format.js';
+import { formatBenchmark, formatError } from '../formatters.js';
+import type { DialektConfig } from '../../config/types.js';
+import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
+import type { TranslationStrategy, TranslationContext } from '../../translation/types.js';
+import type { StrategyBenchmarkSummary } from '../../benchmark/metrics.js';
+
+export interface BenchmarkFlags {
+  readonly config: string;
+  readonly adapter: Option.Option<string>;
+  readonly strategies: Option.Option<string>;
+  readonly sampleSize: Option.Option<number>;
+  readonly format?: Option.Option<string>;
+}
+
+export interface BenchmarkDeps {
+  readonly configLoader: (path: string) => Effect.Effect<DialektConfig, unknown>;
+  readonly modelResolver: (config: { provider: string; modelId: string }) => Effect.Effect<unknown, unknown>;
+  readonly missingKeysComputer: (
+    adapter: TranslationAdapter,
+    sourceLocale: string,
+    targetLocales: readonly string[],
+  ) => Effect.Effect<readonly { adapter: string; locale: string; resource: ResourceRef; missing: readonly string[] }[], unknown>;
+  readonly benchmarkRunner: (opts: {
+    strategies: readonly TranslationStrategy[];
+    chunks: readonly TranslationContext[];
+    concurrency: number;
+  }) => Effect.Effect<readonly StrategyBenchmarkSummary[], unknown>;
+  readonly reportFormatter?: (summaries: readonly StrategyBenchmarkSummary[], format: 'table' | 'json') => string;
+  readonly logger: (msg: string) => Effect.Effect<void>;
+  readonly errorLogger: (msg: string) => Effect.Effect<void>;
+}
+
+export function runBenchmarkCommand(
+  flags: BenchmarkFlags,
+  deps: BenchmarkDeps,
+): Effect.Effect<void, unknown> {
+  return Effect.gen(function* () {
+    yield* deps.errorLogger(
+      formatError(
+        'Warning: This will make real API calls to the configured model provider(s) and may incur cost.',
+        detectFormat(
+          flags.format !== undefined
+            ? (Option.getOrUndefined(flags.format) as OutputFormat | undefined)
+            : undefined,
+        ),
+      ),
+    );
+
+    const loaded = yield* deps.configLoader(flags.config);
+    const effective = resolveEffectiveConfig(
+      { adapter: Option.getOrUndefined(flags.adapter) },
+      loaded,
+    );
+
+    const strategyNames = Option.getOrElse(flags.strategies, () => 'one-shot,tool-loop-agent')
+      .split(',')
+      .map((s: string) => s.trim()) as Array<'one-shot' | 'tool-loop-agent'>;
+
+    const model = yield* deps.modelResolver(effective.model) as Effect.Effect<import('ai').LanguageModel, unknown>;
+
+    const strategyList = strategyNames.map((name) =>
+      name === 'tool-loop-agent'
+        ? createToolLoopStrategy({ model, retry: effective.retry })
+        : createOneShotStrategy({ model, retry: effective.retry }),
+    );
+
+    const allChunks: TranslationContext[] = [];
+
+    for (const a of effective.adapters) {
+      const locales = yield* a.listLocales();
+      const sourceLocale = effective.sourceLocale;
+      const targets = locales.filter((l) => l !== sourceLocale);
+      const missingEntries = yield* deps.missingKeysComputer(a, sourceLocale, targets);
+
+      for (const entry of missingEntries) {
+        const sourceMap = yield* a.readResource(sourceLocale, entry.resource);
+        const targetMap = yield* a.readResource(entry.locale, entry.resource);
+        const chunks = chunkKeys(entry.missing, sourceMap, targetMap, {
+          maxTokens: effective.chunking.maxTokens,
+          charsPerToken: effective.chunking.charsPerToken,
+        });
+        for (const keys of chunks) {
+          allChunks.push({
+            sourceLocale,
+            targetLocale: entry.locale,
+            sourceMap,
+            targetMap,
+            keys,
+          });
+        }
+      }
+    }
+
+    const sampled = allChunks.slice(0, Option.getOrElse(flags.sampleSize, () => 20));
+
+    const summaries = yield* deps.benchmarkRunner({
+      strategies: strategyList,
+      chunks: sampled,
+      concurrency: effective.chunking.concurrency,
+    });
+
+    const format = detectFormat(
+      flags.format !== undefined
+        ? (Option.getOrUndefined(flags.format) as OutputFormat | undefined)
+        : undefined,
+    );
+
+    const entries = summaries.map((s) => ({
+      strategyName: s.strategyName,
+      totalChunks: s.totalChunks,
+      succeededChunks: s.succeededChunks,
+      failedChunks: s.failedChunks,
+      totalDurationMs: s.totalDurationMs,
+      averageDurationMsPerChunk: s.averageDurationMsPerChunk,
+      totalAttempts: s.totalAttempts,
+    }));
+
+    yield* deps.logger(formatBenchmark(entries, format));
+  });
+}
+
+export const benchmarkCommand = Command.make('benchmark', {
+  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
+  adapter: Options.optional(Options.text('adapter')),
+  strategies: Options.optional(Options.text('strategies')),
+  sampleSize: Options.optional(Options.integer('sample-size')),
+  format: Options.optional(Options.text('format')),
+}, (flags) =>
+  runBenchmarkCommand(flags, {
+    configLoader: loadConfig,
+    modelResolver: resolveModel,
+    missingKeysComputer: computeMissingKeys as unknown as BenchmarkDeps['missingKeysComputer'],
+    benchmarkRunner: runBenchmark,
+    logger: (msg: string) => Console.log(msg),
+    errorLogger: (msg: string) => Console.error(msg),
+  }),
+);

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

@@ -0,0 +1,127 @@
+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', () => {
+  const baseConfig: DialektConfig = {
+    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: [],
+  };
+
+  function makeAdapter(opts: { name: string; locales?: readonly string[] }): TranslationAdapter {
+    return {
+      name: opts.name,
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
+      listResources: () => Effect.succeed([]),
+      readResource: () => Effect.succeed({}),
+      writeResource: () => Effect.void,
+    };
+  }
+
+  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 program = runLanguages(
+      { config: './config.ts' },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    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'] });
+  });
+
+  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 program = runLanguages(
+      { config: './config.ts' },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toEqual([{ adapter: 'mono', locales: ['en'] }]);
+  });
+
+  it('handles empty adapter list', async () => {
+    const logs: string[] = [];
+    const config = { ...baseConfig, adapters: [] };
+
+    const program = runLanguages(
+      { config: './config.ts' },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toEqual([]);
+  });
+
+  it('fails when configLoader fails', async () => {
+    const program = runLanguages(
+      { config: './missing.ts' },
+      () => Effect.fail(new Error('Config not found')),
+      () => Effect.void,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+  });
+
+  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 program = runLanguages(
+      { config: './config.ts' },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toEqual([{ adapter: 'empty', locales: [] }]);
+  });
+
+  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 program = runLanguages(
+      { 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');
+  });
+});

package/src/cli/commands/languages.ts

@@ -0,0 +1,42 @@
+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;
+  readonly format?: Option.Option<string>;
+}
+
+export function runLanguages(
+  flags: LanguagesFlags,
+  configLoader: (path: string) => Effect.Effect<DialektConfig, unknown> = loadConfig,
+  logger: (msg: string) => Effect.Effect<void> = (msg: string) => Console.log(msg),
+): Effect.Effect<void, never> {
+  return Effect.gen(function* () {
+    const loaded = yield* configLoader(flags.config);
+    const effective = resolveEffectiveConfig({}, loaded);
+
+    const entries: Array<{ adapter: string; locales: readonly string[] }> = [];
+    for (const adapter of effective.adapters) {
+      const locales = yield* adapter.listLocales();
+      entries.push({ adapter: adapter.name, locales });
+    }
+
+    const format = detectFormat(
+      flags.format !== undefined
+        ? (Option.getOrUndefined(flags.format) as OutputFormat | undefined)
+        : undefined,
+    );
+    yield* logger(formatLanguages(entries, format));
+  }).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));