dialekt 0.1.0

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

@@ -0,0 +1,256 @@
+import { describe, expect, it } from 'vitest';
+import { Effect, Option } from 'effect';
+import { runMissing, missingCommand } from './missing.js';
+import type { DialektConfig } from '../../config/types.js';
+import type { TranslationAdapter, ResourceRef } from '../../adapter/types.js';
+
+describe('runMissing', () => {
+  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[];
+    missing?: readonly { resource: ResourceRef; missing: readonly string[] }[];
+  }): TranslationAdapter {
+    return {
+      name: opts.name,
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => Effect.succeed(opts.locales ?? ['en', 'de']),
+      listResources: () => Effect.succeed([{ key: 'messages', label: 'messages' }]),
+      readResource: () => Effect.succeed({}),
+      writeResource: () => Effect.void,
+    };
+  }
+
+  it('logs missing keys in default format', async () => {
+    const logs: string[] = [];
+    const adapter = makeAdapter({ name: 'test' });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      () =>
+        Effect.succeed([
+          { adapter: 'test', locale: 'de', resource, missing: ['hello', 'bye'] },
+        ]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toEqual([
+      { adapter: 'test', locale: 'de', resource: 'messages', key: 'hello' },
+      { adapter: 'test', locale: 'de', resource: 'messages', key: 'bye' },
+    ]);
+  });
+
+  it('outputs JSON when --format json is passed', async () => {
+    const logs: string[] = [];
+    const adapter = makeAdapter({ name: 'test' });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none(), format: Option.some('json') },
+      () => Effect.succeed(config),
+      () =>
+        Effect.succeed([
+          { adapter: 'test', locale: 'de', resource, missing: ['hello'] },
+        ]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toEqual([
+      { adapter: 'test', locale: 'de', resource: 'messages', key: 'hello' },
+    ]);
+  });
+
+  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 resource: ResourceRef = { key: 'messages', label: 'messages' };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none(), format: Option.some('pretty') },
+      () => Effect.succeed(config),
+      () =>
+        Effect.succeed([
+          { adapter: 'test', locale: 'de', resource, missing: ['hello', 'bye'] },
+        ]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toContain('test');
+    expect(logs[0]).toContain('de');
+    expect(logs[0]).toContain('hello');
+    expect(logs[0]).toContain('bye');
+  });
+
+  it('returns empty JSON array when nothing is missing', async () => {
+    const logs: string[] = [];
+    const adapter = makeAdapter({ name: 'test' });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      () => Effect.succeed([]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  it('handles multiple adapters and multiple locales', async () => {
+    const logs: string[] = [];
+    const a1 = makeAdapter({ name: 'a1' });
+    const a2 = makeAdapter({ name: 'a2', locales: ['en', 'fr'] });
+    const config = { ...baseConfig, adapters: [a1, a2] as unknown as DialektConfig['adapters'] };
+    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      (a) =>
+        Effect.succeed([
+          { adapter: a.name, locale: a.name === 'a1' ? 'de' : 'fr', resource, missing: ['k1'] },
+        ]),
+      (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: 'a1', locale: 'de', resource: 'messages', key: 'k1' });
+    expect(parsed).toContainEqual({ adapter: 'a2', locale: 'fr', resource: 'messages', key: 'k1' });
+  });
+
+  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 program = runMissing(
+      { config: './config.ts', adapter: Option.some('a2'), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      (a) =>
+        Effect.sync(() => {
+          queriedAdapter = a.name;
+          return [];
+        }),
+      () => Effect.void,
+    );
+
+    await Effect.runPromise(program);
+    expect(queriedAdapter).toBe('a2');
+  });
+
+  it('fails when configLoader fails', async () => {
+    const program = runMissing(
+      { config: './missing.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.fail(new Error('Config not found')),
+      () => Effect.succeed([]),
+      () => Effect.void,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('Config not found');
+  });
+
+  it('fails when listLocales fails', async () => {
+    const adapter: TranslationAdapter = {
+      name: 'broken',
+      capabilities: { canCreateResource: true, unusedKeyDetection: false },
+      listLocales: () => Effect.fail(new Error('disk error') as never),
+      listResources: () => Effect.succeed([]),
+      readResource: () => Effect.succeed({}),
+      writeResource: () => Effect.void,
+    };
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      () => Effect.succeed([]),
+      () => Effect.void,
+    );
+
+    await expect(Effect.runPromise(program)).rejects.toThrow('disk error');
+  });
+
+  it('handles empty adapter list', async () => {
+    const logs: string[] = [];
+    const config = { ...baseConfig, adapters: [] };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      () => Effect.succeed([]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  it('handles single-locale adapter (no targets)', async () => {
+    const logs: string[] = [];
+    const adapter = makeAdapter({ name: 'mono', locales: ['en'] });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none() },
+      () => Effect.succeed(config),
+      () => Effect.succeed([]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    expect(logs).toHaveLength(1);
+    expect(JSON.parse(logs[0]!)).toEqual([]);
+  });
+
+  it('produces valid JSON array even with many entries', async () => {
+    const logs: string[] = [];
+    const adapter = makeAdapter({ name: 'test' });
+    const config = { ...baseConfig, adapters: [adapter] as unknown as DialektConfig['adapters'] };
+    const resource: ResourceRef = { key: 'messages', label: 'messages' };
+
+    const program = runMissing(
+      { config: './config.ts', adapter: Option.none(), baseLanguage: Option.none(), language: Option.none(), format: Option.some('json') },
+      () => Effect.succeed(config),
+      () =>
+        Effect.succeed([
+          { adapter: 'test', locale: 'de', resource, missing: ['a', 'b', 'c'] },
+        ]),
+      (msg) => Effect.sync(() => logs.push(msg)),
+    );
+
+    await Effect.runPromise(program);
+    const parsed = JSON.parse(logs[0]!);
+    expect(parsed).toHaveLength(3);
+    expect(parsed[0]).toMatchObject({ adapter: 'test', locale: 'de', resource: 'messages', key: 'a' });
+  });
+});

package/src/cli/commands/missing.ts

@@ -0,0 +1,88 @@
+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 { computeMissingKeys } from '../../translation/missing-keys.js';
+import { detectFormat, type OutputFormat } from '../format.js';
+import { formatMissingKeys } from '../formatters.js';
+import type { DialektConfig } from '../../config/types.js';
+import type { TranslationAdapter } from '../../adapter/types.js';
+
+export interface MissingFlags {
+  readonly config: string;
+  readonly adapter: Option.Option<string>;
+  readonly baseLanguage: Option.Option<string>;
+  readonly language: Option.Option<string>;
+  readonly format?: Option.Option<string>;
+}
+
+export interface MissingKeysEntry {
+  readonly adapter: string;
+  readonly locale: string;
+  readonly resource: { label: string };
+  readonly missing: readonly string[];
+}
+
+export function runMissing(
+  flags: MissingFlags,
+  configLoader: (path: string) => Effect.Effect<DialektConfig, unknown> = loadConfig,
+  missingKeysComputer: (
+    adapter: TranslationAdapter,
+    sourceLocale: string,
+    targetLocales: readonly string[],
+  ) => Effect.Effect<readonly MissingKeysEntry[], unknown> = computeMissingKeys as unknown as typeof missingKeysComputer,
+  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(
+      {
+        baseLanguage: Option.getOrUndefined(flags.baseLanguage),
+        language: Option.isSome(flags.language) ? [flags.language.value] : undefined,
+        adapter: Option.getOrUndefined(flags.adapter),
+      },
+      loaded,
+    );
+
+    const allEntries: Array<{
+      adapter: string;
+      locale: string;
+      resource: string;
+      key: string;
+    }> = [];
+
+    for (const a of effective.adapters) {
+      const locales = yield* a.listLocales();
+      const sourceLocale = effective.sourceLocale;
+      const targets = locales.filter((l) => l !== sourceLocale);
+
+      const entries = yield* missingKeysComputer(a, sourceLocale, targets);
+      for (const entry of entries) {
+        for (const key of entry.missing) {
+          allEntries.push({
+            adapter: entry.adapter,
+            locale: entry.locale,
+            resource: entry.resource.label,
+            key,
+          });
+        }
+      }
+    }
+
+    const format = detectFormat(
+      flags.format !== undefined
+        ? (Option.getOrUndefined(flags.format) as OutputFormat | undefined)
+        : undefined,
+    );
+
+    yield* logger(formatMissingKeys(allEntries, format));
+  }).pipe(Effect.mapError((e) => e as never)) as Effect.Effect<void, never, never>;
+}
+
+export const missingCommand = Command.make('missing', {
+  config: Options.text('config').pipe(Options.withDefault('./dialekt.config.ts')),
+  adapter: Options.optional(Options.text('adapter')),
+  baseLanguage: Options.optional(Options.text('base-language')),
+  language: Options.optional(Options.text('language')),
+  format: Options.optional(Options.text('format')),
+}, (flags) => runMissing(flags));