dialekt 0.1.0

package/src/cli/formatters.ts

@@ -0,0 +1,350 @@
+/**
+ * Command-specific formatters for the dialekt CLI output.
+ *
+ * Imports the core utilities from `format.ts` and builds structured
+ * pretty / JSON renderers for each dialekt command.
+ */
+
+import {
+  color,
+  glyphs,
+  drawTable,
+  banner,
+  sectionHeader,
+  success,
+  failure,
+  warning,
+  info,
+  keyValue,
+} from './format.js';
+import type { OutputFormat } from './format.js';
+
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+} as const;
+
+// ─── Missing keys formatter ──────────────────────────────────────────────────
+
+export interface MissingKeyEntry {
+  readonly adapter: string;
+  readonly locale: string;
+  readonly resource: string;
+  readonly key: string;
+}
+
+export function formatMissingKeys(
+  entries: readonly MissingKeyEntry[],
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(entries, null, 2) + '\n';
+  }
+
+  if (entries.length === 0) {
+    return success('All translations are complete. No missing keys.') + '\n';
+  }
+
+  const grouped = new Map<string, Map<string, Map<string, string[]>>>();
+  for (const e of entries) {
+    const byAdapter = grouped.get(e.adapter) ?? new Map();
+    const byLocale = byAdapter.get(e.locale) ?? new Map();
+    const keys = byLocale.get(e.resource) ?? [];
+    keys.push(e.key);
+    byLocale.set(e.resource, keys);
+    byAdapter.set(e.locale, byLocale);
+    grouped.set(e.adapter, byAdapter);
+  }
+
+  const lines: string[] = [];
+  const g = glyphs();
+  const total = entries.length;
+
+  lines.push(sectionHeader(`Missing keys (${total})`));
+
+  for (const [adapter, byLocale] of grouped) {
+    let adapterTotal = 0;
+    for (const byResource of byLocale.values()) {
+      for (const keys of byResource.values()) adapterTotal += keys.length;
+    }
+    lines.push(`\n  ${color(adapter, C.bold + C.blue)} ${color(`(${adapterTotal})`, C.dim)}`);
+
+    for (const [locale, byResource] of byLocale) {
+      let localeTotal = 0;
+      for (const keys of byResource.values()) localeTotal += keys.length;
+      lines.push(`    ${color(`${g.arrow} ${locale}`, C.yellow)} ${color(`(${localeTotal})`, C.dim)}`);
+
+      for (const [resource, keys] of byResource) {
+        lines.push(`      ${color(resource, C.bold)}`);
+        for (const key of keys) {
+          lines.push(`        ${color(g.bullet, C.dim)} ${key}`);
+        }
+      }
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+// ─── Unused keys formatter ───────────────────────────────────────────────────
+
+export interface UnusedKeyEntry {
+  readonly adapter: string;
+  readonly locale: string;
+  readonly resource: string;
+  readonly key: string;
+}
+
+export function formatUnusedKeys(
+  entries: readonly UnusedKeyEntry[],
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(entries, null, 2) + '\n';
+  }
+
+  if (entries.length === 0) {
+    return success('All keys are referenced in source files. No unused keys.') + '\n';
+  }
+
+  const grouped = new Map<string, Map<string, Map<string, string[]>>>();
+  for (const e of entries) {
+    const byAdapter = grouped.get(e.adapter) ?? new Map();
+    const byLocale = byAdapter.get(e.locale) ?? new Map();
+    const keys = byLocale.get(e.resource) ?? [];
+    keys.push(e.key);
+    byLocale.set(e.resource, keys);
+    byAdapter.set(e.locale, byLocale);
+    grouped.set(e.adapter, byAdapter);
+  }
+
+  const lines: string[] = [];
+  const g = glyphs();
+  const total = entries.length;
+
+  lines.push(sectionHeader(`Unused keys (${total})`));
+
+  for (const [adapter, byLocale] of grouped) {
+    let adapterTotal = 0;
+    for (const byResource of byLocale.values()) {
+      for (const keys of byResource.values()) adapterTotal += keys.length;
+    }
+    lines.push(`\n  ${color(adapter, C.bold + C.blue)} ${color(`(${adapterTotal})`, C.dim)}`);
+
+    for (const [locale, byResource] of byLocale) {
+      let localeTotal = 0;
+      for (const keys of byResource.values()) localeTotal += keys.length;
+      lines.push(`    ${color(`${g.arrow} ${locale}`, C.yellow)} ${color(`(${localeTotal})`, C.dim)}`);
+
+      for (const [resource, keys] of byResource) {
+        lines.push(`      ${color(resource, C.bold)}`);
+        for (const key of keys) {
+          lines.push(`        ${color(g.bullet, C.dim)} ${key}`);
+        }
+      }
+    }
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+// ─── Validate formatter ──────────────────────────────────────────────────────
+
+export interface ValidateEntry {
+  readonly adapter: string;
+  readonly locale: string;
+  readonly resource: string;
+  readonly count: number;
+}
+
+export interface ValidateResult {
+  readonly passing: boolean;
+  readonly entries: readonly ValidateEntry[];
+}
+
+export function formatValidate(
+  result: ValidateResult,
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(result, null, 2) + '\n';
+  }
+
+  if (result.passing) {
+    return '\n' + success('All translations are up to date.') + '\n';
+  }
+
+  const rows = result.entries.map((e) => [
+    e.adapter,
+    e.locale,
+    e.resource,
+    e.count.toString(),
+  ]);
+
+  const lines: string[] = [];
+  lines.push(failure(`Missing keys found in ${result.entries.length} resource(s)`));
+  lines.push('');
+  lines.push(drawTable(['Adapter', 'Locale', 'Resource', 'Missing'], rows));
+  lines.push('');
+  lines.push(color(`Run ${color('dialekt translate', C.bold + C.cyan)} to fill missing keys.`, C.dim));
+
+  return lines.join('\n') + '\n';
+}
+
+// ─── Languages formatter ─────────────────────────────────────────────────────
+
+export interface LanguageEntry {
+  readonly adapter: string;
+  readonly locales: readonly string[];
+}
+
+export function formatLanguages(
+  entries: readonly LanguageEntry[],
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(entries, null, 2) + '\n';
+  }
+
+  if (entries.length === 0) {
+    return warning('No adapters configured.') + '\n';
+  }
+
+  const lines: string[] = [];
+  const g = glyphs();
+
+  for (const e of entries) {
+    lines.push(`  ${color(e.adapter, C.bold + C.blue)}`);
+    lines.push(`    ${color(`${g.arrow}`, C.dim)} ${e.locales.join(color(', ', C.dim))}`);
+  }
+
+  return lines.join('\n') + '\n';
+}
+
+// ─── Translate formatter ─────────────────────────────────────────────────────
+
+export interface TranslateResult {
+  readonly success: boolean;
+  readonly message: string;
+  readonly stats?: {
+    readonly adaptersProcessed: number;
+    readonly localesTranslated: number;
+    readonly keysTranslated: number;
+  };
+}
+
+export function formatTranslate(
+  result: TranslateResult,
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(result, null, 2) + '\n';
+  }
+
+  if (result.success) {
+    const lines: string[] = [success(result.message)];
+    if (result.stats) {
+      lines.push('');
+      lines.push(keyValue('Adapters:', result.stats.adaptersProcessed.toString()));
+      lines.push(keyValue('Locales:', result.stats.localesTranslated.toString()));
+      lines.push(keyValue('Keys:', result.stats.keysTranslated.toString()));
+    }
+    return lines.join('\n') + '\n';
+  }
+
+  return failure(result.message) + '\n';
+}
+
+// ─── Add formatter ───────────────────────────────────────────────────────────
+
+export interface AddResult {
+  readonly success: boolean;
+  readonly message: string;
+  readonly addedResources?: readonly string[];
+}
+
+export function formatAdd(
+  result: AddResult,
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(result, null, 2) + '\n';
+  }
+
+  if (result.success) {
+    const lines: string[] = [success(result.message)];
+    if (result.addedResources && result.addedResources.length > 0) {
+      lines.push('');
+      lines.push(color('Added to:', C.dim));
+      for (const r of result.addedResources) {
+        lines.push(`  ${color(glyphs().bullet, C.dim)} ${r}`);
+      }
+    }
+    return lines.join('\n') + '\n';
+  }
+
+  return failure(result.message) + '\n';
+}
+
+// ─── Benchmark formatter ─────────────────────────────────────────────────────
+
+export interface BenchmarkEntry {
+  readonly strategyName: string;
+  readonly totalChunks: number;
+  readonly succeededChunks: number;
+  readonly failedChunks: number;
+  readonly totalDurationMs: number;
+  readonly averageDurationMsPerChunk: number;
+  readonly totalAttempts: number;
+}
+
+export function formatBenchmark(
+  entries: readonly BenchmarkEntry[],
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify(entries, null, 2) + '\n';
+  }
+
+  if (entries.length === 0) {
+    return warning('No benchmark data available.') + '\n';
+  }
+
+  const lines: string[] = [];
+
+  lines.push(banner('Benchmark Results'));
+
+  const rows = entries.map((e) => [
+    e.strategyName,
+    `${e.succeededChunks}/${e.totalChunks}`,
+    `${e.totalDurationMs.toFixed(0)}ms`,
+    `${e.averageDurationMsPerChunk.toFixed(1)}ms`,
+    e.totalAttempts.toString(),
+  ]);
+
+  lines.push('');
+  lines.push(drawTable(
+    ['Strategy', 'Chunks', 'Total', 'Avg/Chunk', 'Attempts'],
+    rows,
+  ));
+
+  return lines.join('\n') + '\n';
+}
+
+// ─── Error formatter ─────────────────────────────────────────────────────────
+
+export function formatError(
+  message: string,
+  format: OutputFormat,
+): string {
+  if (format === 'json') {
+    return JSON.stringify({ error: message }, null, 2) + '\n';
+  }
+  return failure(message) + '\n';
+}

package/src/cli/main.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from '@effect/cli';
+import { NodeContext, NodeRuntime } from '@effect/platform-node';
+import { Effect } from 'effect';
+import { translateCommand } from './commands/translate.js';
+import { validateCommand } from './commands/validate.js';
+import { addCommand } from './commands/add.js';
+import { missingCommand } from './commands/missing.js';
+import { unusedCommand } from './commands/unused.js';
+import { languagesCommand } from './commands/languages.js';
+import { benchmarkCommand } from './commands/benchmark.js';
+
+const rootCommand = Command.make('dialekt').pipe(
+  Command.withSubcommands([
+    translateCommand,
+    validateCommand,
+    addCommand,
+    missingCommand,
+    unusedCommand,
+    languagesCommand,
+    benchmarkCommand,
+  ]),
+);
+
+const cli = Command.run(rootCommand, {
+  name: 'dialekt',
+  version: '0.1.0',
+});
+
+const program = Effect.provide(cli(process.argv), NodeContext.layer);
+NodeRuntime.runMain(program);

package/src/config/define-config.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest';
+import { defineConfig } from './define-config.js';
+import type { DialektConfig } from './types.js';
+
+describe('defineConfig', () => {
+  it('returns its input unchanged', () => {
+    const config: 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: [],
+    };
+    expect(defineConfig(config)).toBe(config);
+  });
+
+  it('accepts a config with adapters', () => {
+    const adapter = { name: 'test', capabilities: { canCreateResource: true, unusedKeyDetection: false }, listLocales: () => { throw new Error(); }, listResources: () => { throw new Error(); }, readResource: () => { throw new Error(); }, writeResource: () => { throw new Error(); } } as unknown as DialektConfig['adapters'][number];
+    const config: 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: [adapter],
+    };
+    expect(defineConfig(config)).toBe(config);
+  });
+
+  it('accepts a config with tool-loop-agent strategy', () => {
+    const config: DialektConfig = {
+      sourceLocale: 'en',
+      targetLocales: ['de'],
+      strategy: 'tool-loop-agent',
+      model: { provider: 'anthropic', modelId: 'claude-3-sonnet' },
+      fastModel: { provider: 'anthropic', modelId: 'claude-3-haiku' },
+      chunking: { maxTokens: 4000, charsPerToken: 3.5, concurrency: 5 },
+      retry: { maxAttempts: 5, baseDelayMs: 500 },
+      adapters: [],
+    };
+    expect(defineConfig(config)).toBe(config);
+  });
+
+  it('preserves reference identity for nested objects', () => {
+    const model = { provider: 'openai', modelId: 'gpt-4o' };
+    const chunking = { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 };
+    const config: DialektConfig = {
+      sourceLocale: 'en',
+      targetLocales: ['de'],
+      strategy: 'one-shot',
+      model,
+      fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+      chunking,
+      retry: { maxAttempts: 3, baseDelayMs: 1000 },
+      adapters: [],
+    };
+    const result = defineConfig(config);
+    expect(result.model).toBe(model);
+    expect(result.chunking).toBe(chunking);
+  });
+});

package/src/config/define-config.ts

@@ -0,0 +1,5 @@
+import type { DialektConfig } from './types.js';
+
+export function defineConfig(config: DialektConfig): DialektConfig {
+  return config;
+}

package/src/config/load-config.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { Effect, Either } from 'effect';
+import { loadConfig, ConfigLoadError } from './load-config.js';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('loadConfig', () => {
+  it('loads a valid dialekt.config.ts', async () => {
+    const dir = join(tmpdir(), `dialekt-load-config-test-${Date.now()}`);
+    mkdirSync(dir, { recursive: true });
+    const configPath = join(dir, 'dialekt.config.ts');
+    writeFileSync(
+      configPath,
+      `export default { 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: [] };`,
+    );
+
+    const result = await Effect.runPromise(loadConfig(configPath));
+    expect(result.sourceLocale).toBe('en');
+    expect(result.targetLocales).toEqual(['de']);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('returns ConfigLoadError for a nonexistent path', async () => {
+    const program = loadConfig('/nonexistent/path/config.ts');
+    const exit = await Effect.runPromise(Effect.either(program)) as Either.Either<unknown, ConfigLoadError>;
+    if (exit._tag === 'Left') {
+      expect(exit.left._tag).toBe('ConfigLoadError');
+      expect(exit.left.path).toBe('/nonexistent/path/config.ts');
+    } else {
+      throw new Error('Expected Left');
+    }
+  });
+});

package/src/config/load-config.ts

@@ -0,0 +1,21 @@
+import { createJiti } from 'jiti';
+import { Effect, Data } from 'effect';
+import { resolve } from 'node:path';
+import type { DialektConfig } from './types.js';
+
+export class ConfigLoadError extends Data.TaggedError('ConfigLoadError')<{
+  readonly path: string;
+  readonly cause: unknown;
+}> {}
+
+export function loadConfig(configPath: string): Effect.Effect<DialektConfig, ConfigLoadError> {
+  return Effect.tryPromise({
+    try: async () => {
+      const jiti = createJiti(process.cwd());
+      const absolutePath = resolve(configPath);
+      const mod = await jiti.import(absolutePath, { default: true });
+      return mod as DialektConfig;
+    },
+    catch: (cause) => new ConfigLoadError({ path: configPath, cause }),
+  });
+}

package/src/config/types.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest';
+import type { DialektConfig, ModelConfig, ChunkingConfig, RetryConfig } from './types.js';
+
+describe('config type conformance', () => {
+  it('accepts all known model providers', () => {
+    const providers: ModelConfig['provider'][] = ['openai', 'anthropic', 'google', 'mistral', 'cohere'];
+    for (const provider of providers) {
+      const m: ModelConfig = { provider, modelId: 'test-model' };
+      expect(m.provider).toBe(provider);
+    }
+  });
+
+  it('accepts any string provider at compile time', () => {
+    // provider is typed as string, not a literal union
+    const valid: ModelConfig = { provider: 'unknown-provider', modelId: 'x' };
+    expect(valid.provider).toBe('unknown-provider');
+  });
+
+  it('ChunkingConfig enforces positive maxTokens', () => {
+    const c: ChunkingConfig = { maxTokens: 1, charsPerToken: 1.0, concurrency: 1 };
+    expect(c.maxTokens).toBe(1);
+    expect(c.concurrency).toBe(1);
+  });
+
+  it('RetryConfig enforces positive maxAttempts', () => {
+    const r: RetryConfig = { maxAttempts: 1, baseDelayMs: 0 };
+    expect(r.maxAttempts).toBe(1);
+    expect(r.baseDelayMs).toBe(0);
+  });
+
+  it('DialektConfig requires sourceLocale and targetLocales', () => {
+    const minimal: 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: [],
+    };
+    expect(minimal.sourceLocale).toBe('en');
+    expect(minimal.targetLocales).toEqual(['de']);
+  });
+
+  it('DialektConfig accepts tool-loop-agent strategy', () => {
+    const config: DialektConfig = {
+      sourceLocale: 'en',
+      targetLocales: ['de'],
+      strategy: 'tool-loop-agent',
+      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: [],
+    };
+    expect(config.strategy).toBe('tool-loop-agent');
+  });
+
+  it('targetLocales can be empty', () => {
+    const config: DialektConfig = {
+      sourceLocale: 'en',
+      targetLocales: [],
+      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: [],
+    };
+    expect(config.targetLocales).toEqual([]);
+  });
+
+  it('accepts multiple target locales', () => {
+    const config: DialektConfig = {
+      sourceLocale: 'en',
+      targetLocales: ['de', 'fr', 'es', 'ja'],
+      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: [],
+    };
+    expect(config.targetLocales).toHaveLength(4);
+  });
+
+  it('fastModel can be different provider from model', () => {
+    const config: DialektConfig = {
+      sourceLocale: 'en',
+      targetLocales: ['de'],
+      strategy: 'one-shot',
+      model: { provider: 'openai', modelId: 'gpt-4o' },
+      fastModel: { provider: 'anthropic', modelId: 'claude-3-haiku' },
+      chunking: { maxTokens: 3000, charsPerToken: 3.0, concurrency: 3 },
+      retry: { maxAttempts: 3, baseDelayMs: 1000 },
+      adapters: [],
+    };
+    expect(config.fastModel.provider).toBe('anthropic');
+  });
+});

package/src/config/types.ts

@@ -0,0 +1,28 @@
+import type { TranslationAdapter } from '../adapter/types.js';
+
+export interface ModelConfig {
+  readonly provider: string;
+  readonly modelId: string;
+}
+
+export interface ChunkingConfig {
+  readonly maxTokens: number;
+  readonly charsPerToken: number;
+  readonly concurrency: number;
+}
+
+export interface RetryConfig {
+  readonly maxAttempts: number;
+  readonly baseDelayMs: number;
+}
+
+export interface DialektConfig {
+  readonly sourceLocale: string;
+  readonly targetLocales: readonly string[] | null;
+  readonly strategy: 'one-shot' | 'tool-loop-agent';
+  readonly model: ModelConfig;
+  readonly fastModel: ModelConfig;
+  readonly chunking: ChunkingConfig;
+  readonly retry: RetryConfig;
+  readonly adapters: readonly TranslationAdapter[];
+}