dialekt 0.1.0

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

@@ -0,0 +1,384 @@
+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' },
+    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('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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          translationCalls++;
+          expect(opts.adapters).toHaveLength(1);
+          expect(opts.sourceLocale).toBe('en');
+        }),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(translationCalls).toBe(1);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed.success).toBe(true);
+    expect(parsed.message).toBe('Translation complete.');
+  });
+
+  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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: true,
+      },
+      () => Effect.succeed(config),
+      (modelConfig) =>
+        Effect.sync(() => {
+          usedModel = modelConfig.modelId;
+          return {};
+        }),
+      () => Effect.void,
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedModel).toBe('gpt-4o-mini');
+  });
+
+  it('uses default strategy from config', async () => {
+    let strategy: TranslationStrategy | undefined;
+    const adapter = makeAdapter({ name: 'test' });
+    const config: DialektConfig = {
+      ...baseConfig,
+      strategy: 'tool-loop-agent',
+      adapters: [adapter] as unknown as DialektConfig['adapters'],
+    };
+
+    const program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          strategy = opts.strategy;
+        }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(strategy).toBeDefined();
+    expect(strategy!.name).toBe('tool-loop-agent');
+  });
+
+  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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.some('tool-loop-agent'),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          strategyName = opts.strategy.name;
+        }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(strategyName).toBe('tool-loop-agent');
+  });
+
+  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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.some('a2'),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          usedAdapterName = (opts.adapters as TranslationAdapter[])[0]!.name;
+        }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedAdapterName).toBe('a2');
+  });
+
+  it('fails when configLoader fails', async () => {
+    const program = runTranslate(
+      {
+        config: './missing.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.fail(new Error('Config not found')),
+      () => Effect.succeed({}),
+      () => Effect.void,
+    );
+
+    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'] };
+
+    const program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.fail(new Error('No API key')),
+      () => Effect.void,
+    );
+
+    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'] };
+
+    const program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      () => Effect.fail(new Error('Translation failed')),
+      () => Effect.void,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Translation failed');
+  });
+
+  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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          strategyName = opts.strategy.name;
+        }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(strategyName).toBe('one-shot');
+  });
+
+  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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.some('de'),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          targetLocales = opts.targetLocales;
+        }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(targetLocales).toEqual(['de']);
+  });
+
+  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 program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+        format: Option.some('pretty'),
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      () => Effect.void,
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toContain('Translation complete');
+  });
+
+  it('handles empty adapters list', async () => {
+    const logs: string[] = [];
+    const config = { ...baseConfig, adapters: [] };
+
+    const program = runTranslate(
+      {
+        config: './config.ts',
+        adapter: Option.none(),
+        strategy: Option.none(),
+        baseLanguage: Option.none(),
+        language: Option.none(),
+        name: Option.none(),
+        skipNames: false,
+        skipLanguages: false,
+        fast: false,
+      },
+      () => Effect.succeed(config),
+      () => Effect.succeed({}),
+      (opts) =>
+        Effect.sync(() => {
+          expect(opts.adapters).toHaveLength(0);
+        }),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed.success).toBe(true);
+  });
+});

package/src/cli/commands/translate.ts

@@ -0,0 +1,106 @@
+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;
+  readonly adapter: Option.Option<string>;
+  readonly strategy: Option.Option<string>;
+  readonly baseLanguage: Option.Option<string>;
+  readonly language: Option.Option<string>;
+  readonly name: Option.Option<string>;
+  readonly skipNames: boolean;
+  readonly skipLanguages: boolean;
+  readonly fast: boolean;
+  readonly format?: Option.Option<string>;
+}
+
+export function runTranslate(
+  flags: TranslateFlags,
+  configLoader: (path: string) => Effect.Effect<DialektConfig, unknown> = loadConfig,
+  modelResolver: (config: { provider: string; modelId: string }) => Effect.Effect<unknown, unknown> = resolveModel,
+  translationRunner: (opts: {
+    adapters: readonly unknown[];
+    strategy: TranslationStrategy;
+    sourceLocale: string;
+    targetLocales: readonly string[];
+    chunking: unknown;
+  }) => Effect.Effect<void, unknown> = runTranslation as unknown as typeof translationRunner,
+  logger: (msg: string) => Effect.Effect<void> = (msg: string) => Console.log(msg),
+): Effect.Effect<void, unknown> {
+  return Effect.gen(function* () {
+    const loaded = yield* configLoader(flags.config);
+    const effective = resolveEffectiveConfig(
+      {
+        baseLanguage: Option.getOrUndefined(flags.baseLanguage),
+        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')
+            : undefined,
+      },
+      loaded,
+    );
+
+    const modelConfig = flags.fast ? effective.fastModel : effective.model;
+    const model = yield* modelResolver(modelConfig) as Effect.Effect<import('ai').LanguageModel, unknown>;
+
+    const translationStrategy =
+      effective.strategy === 'tool-loop-agent'
+        ? createToolLoopStrategy({ model, retry: effective.retry })
+        : createOneShotStrategy({ model, retry: effective.retry });
+
+    yield* translationRunner({
+      adapters: effective.adapters,
+      strategy: translationStrategy,
+      sourceLocale: effective.sourceLocale,
+      targetLocales: effective.targetLocales ?? [],
+      chunking: effective.chunking,
+    });
+
+    const format = detectFormat(
+      flags.format !== undefined
+        ? (Option.getOrUndefined(flags.format) as OutputFormat | undefined)
+        : undefined,
+    );
+
+    yield* logger(
+      formatTranslate(
+        {
+          success: true,
+          message: 'Translation complete.',
+          stats: {
+            adaptersProcessed: effective.adapters.length,
+            localesTranslated: (effective.targetLocales ?? []).length,
+            keysTranslated: 0, // TODO: track from orchestrator
+          },
+        },
+        format,
+      ),
+    );
+  });
+}
+
+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));

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

@@ -0,0 +1,192 @@
+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', () => {
+  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[];
+    resources?: readonly ResourceRef[];
+    unused?: readonly string[];
+    hasUnusedDetection?: boolean;
+  }): TranslationAdapter {
+    const base = {
+      name: opts.name,
+      capabilities: {
+        canCreateResource: true,
+        unusedKeyDetection: opts.hasUnusedDetection ?? true,
+      },
+      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
+      listResources: () => Effect.succeed(opts.resources ?? [{ key: 'messages', label: 'messages' }]),
+      readResource: () => Effect.succeed({}),
+      writeResource: () => Effect.void,
+    };
+    if (opts.unused !== undefined) {
+      return {
+        ...base,
+        findUnusedKeys: () => Effect.succeed(opts.unused!),
+      } as TranslationAdapter;
+    }
+    return base as TranslationAdapter;
+  }
+
+  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 program = runUnused(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    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' },
+    ]);
+  });
+
+  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 program = runUnused(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      (msg) => Effect.sync(() => errors.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(errors).toHaveLength(1);
+    expect(JSON.parse(errors[0]!)).toMatchObject({
+      error: "Adapter 'legacy' does not support unused-key detection.",
+    });
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  it('handles multiple resources', async () => {
+    const logs: string[] = [];
+    const adapter = makeAdapter({
+      name: 'multi',
+      resources: [
+        { key: 'auth', label: 'auth' },
+        { key: 'validation', label: 'validation' },
+      ],
+      unused: ['unused_auth'],
+    });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+
+    const program = runUnused(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      () => Effect.void,
+    );
+
+    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' });
+  });
+
+  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() },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  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 program = runUnused(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  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 program = runUnused(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none() },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  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')),
+      () => Effect.void,
+      () => Effect.void,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+  });
+
+  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 program = runUnused(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), format: Option.some('pretty') },
+      () => Effect.succeed(config),
+      (msg) => Effect.sync(() => logs.push(msg)),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toContain('test');
+    expect(logs[0]).toContain('old_key');
+  });
+});