dialekt 0.1.0

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

@@ -0,0 +1,267 @@
+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 result = await Effect.runPromise(program);
+    expect(result).toEqual({
+      messages: { hello: 'Hello' },
+      validation: { email: 'Email' },
+    });
+    expect(errors).toHaveLength(0);
+  });
+
+  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 () => {
+    const errors: string[] = [];
+    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');
+  });
+
+  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 result = await Effect.runPromise(program);
+    expect(result).toEqual({});
+    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,
+    );
+
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual({
+      messages: { hello: 'Hello', bye: 'Bye' },
+    });
+  });
+
+  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' },
+    });
+  });
+
+  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' },
+    });
+  });
+
+  it('handles empty values', async () => {
+    const program = parseAddTokens(
+      ['messages.empty='],
+      () => Effect.void,
+    );
+
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual({
+      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,
+    );
+
+    const result = await Effect.runPromise(program);
+    expect(result).toEqual({
+      a: { 'b.c.key': 'value' },
+    });
+  });
+});
+
+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' },
+    chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
+    retry: { maxAttempts: 3, baseDelayMs: 1000 },
+    adapters: [],
+  };
+
+  function makeAdapter(name: string): TranslationAdapter {
+    return {
+      name,
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => Effect.succeed([]),
+      listResources: () => Effect.succeed([]),
+      readResource: () => Effect.succeed({}),
+      writeResource: () => Effect.void,
+    };
+  }
+
+  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 program = runAdd(
+      { 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.');
+      }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(translated).toBe(true);
+  });
+
+  it('fails when configLoader fails', async () => {
+    const program = runAdd(
+      { 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');
+  });
+
+  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'],
+      () => Effect.succeed(config),
+      () => Effect.fail(new Error('Model unavailable')),
+      () => Effect.void,
+      () => Effect.void,
+      () => Effect.void,
+    );
+
+    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'] };
+
+    const program = runAdd(
+      { config: './config.ts', create: false },
+      ['messages.hello=Hello'],
+      () => Effect.succeed(config),
+      () => Effect.succeed({} as unknown),
+      () => Effect.fail(new Error('Translation failed')),
+      () => Effect.void,
+      () => Effect.void,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Translation failed');
+  });
+
+  it('handles empty tokens list', async () => {
+    let translated = false;
+    const adapter = makeAdapter('test');
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+
+    const program = runAdd(
+      { config: './config.ts', create: false },
+      [],
+      () => Effect.succeed(config),
+      () => Effect.succeed({} as unknown),
+      () =>
+        Effect.sync(() => {
+          translated = true;
+        }),
+      () => Effect.void,
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(translated).toBe(true);
+  });
+
+  it('filters targetLocales to exclude sourceLocale', async () => {
+    let usedTargets: readonly string[] | undefined;
+    const adapter = makeAdapter('test');
+    const config = {
+      ...baseConfig,
+      sourceLocale: 'en',
+      targetLocales: ['en', 'de', 'fr'],
+      adapters: [adapter] as unknown as DialektConfig['adapters'],
+    };
+
+    const program = runAdd(
+      { config: './config.ts', create: false },
+      ['messages.hello=Hello'],
+      () => Effect.succeed(config),
+      () => Effect.succeed({} as unknown),
+      (opts) =>
+        Effect.sync(() => {
+          usedTargets = opts.targetLocales as readonly string[];
+        }),
+      () => Effect.void,
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(usedTargets).not.toContain('en');
+    expect(usedTargets).toContain('de');
+  });
+});

package/src/cli/commands/add.ts

@@ -0,0 +1,123 @@
+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;
+  readonly create: boolean;
+  readonly format?: Option.Option<string>;
+}
+
+export function parseAddTokens(
+  tokens: readonly string[],
+  errorLogger: (msg: string) => Effect.Effect<void>,
+): Effect.Effect<Record<string, Record<string, string>>, never> {
+  return Effect.gen(function* () {
+    const entriesByResource: Record<string, Record<string, string>> = {};
+
+    for (const token of tokens) {
+      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('.');
+      if (dotIdx === -1) {
+        yield* errorLogger(`Invalid key (no resource segment): ${key}`);
+        continue;
+      }
+      const resource = key.slice(0, dotIdx);
+      const subKey = key.slice(dotIdx + 1);
+      if (!entriesByResource[resource]) entriesByResource[resource] = {};
+      entriesByResource[resource]![subKey] = value;
+    }
+
+    return entriesByResource;
+  });
+}
+
+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,
+  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),
+  errorLogger: (msg: string) => Effect.Effect<void> = (msg: string) => Console.error(msg),
+): Effect.Effect<void, unknown> {
+  return Effect.gen(function* () {
+    const loaded = yield* configLoader(flags.config);
+    const effective = resolveEffectiveConfig({}, loaded);
+
+    const entriesByResource = yield* parseAddTokens(tokens, errorLogger);
+
+    const addedResources: string[] = [];
+    for (const adapter of effective.adapters) {
+      for (const [resourceKey, entries] of Object.entries(entriesByResource)) {
+        const resourceRef = { key: resourceKey, label: resourceKey };
+        yield* adapter.writeResource(effective.sourceLocale, resourceRef, entries);
+        addedResources.push(`${adapter.name}/${effective.sourceLocale}/${resourceKey}`);
+      }
+    }
+
+    const modelConfig = 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 ?? []).filter((l) => l !== effective.sourceLocale),
+      chunking: effective.chunking,
+    });
+
+    const format = detectFormat(
+      flags.format !== undefined
+        ? (Option.getOrUndefined(flags.format) as OutputFormat | undefined)
+        : undefined,
+    );
+
+    yield* logger(
+      formatAdd(
+        {
+          success: true,
+          message: 'Add + translate complete.',
+          addedResources,
+        },
+        format,
+      ),
+    );
+  });
+}
+
+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);
+});