dialekt 0.1.0 → 0.1.1

package/src/cli/formatters.ts

@@ -16,18 +16,18 @@ import {
   warning,
   info,
   keyValue,
-} from './format.js';
-import type { OutputFormat } from './format.js';
+} 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',
+  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 ──────────────────────────────────────────────────
@@ -43,12 +43,12 @@ export function formatMissingKeys(
   entries: readonly MissingKeyEntry[],
   format: OutputFormat,
 ): string {
-  if (format === 'json') {
-    return JSON.stringify(entries, null, 2) + '\n';
+  if (format === "json") {
+    return JSON.stringify(entries, null, 2) + "\n";
   }
 
   if (entries.length === 0) {
-    return success('All translations are complete. No missing keys.') + '\n';
+    return success("All translations are complete. No missing keys.") + "\n";
   }
 
   const grouped = new Map<string, Map<string, Map<string, string[]>>>();
@@ -78,7 +78,9 @@ export function formatMissingKeys(
     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)}`);
+      lines.push(
+        `    ${color(`${g.arrow} ${locale}`, C.yellow)} ${color(`(${localeTotal})`, C.dim)}`,
+      );
 
       for (const [resource, keys] of byResource) {
         lines.push(`      ${color(resource, C.bold)}`);
@@ -89,7 +91,7 @@ export function formatMissingKeys(
     }
   }
 
-  return lines.join('\n') + '\n';
+  return lines.join("\n") + "\n";
 }
 
 // ─── Unused keys formatter ───────────────────────────────────────────────────
@@ -101,16 +103,13 @@ export interface UnusedKeyEntry {
   readonly key: string;
 }
 
-export function formatUnusedKeys(
-  entries: readonly UnusedKeyEntry[],
-  format: OutputFormat,
-): string {
-  if (format === 'json') {
-    return JSON.stringify(entries, null, 2) + '\n';
+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';
+    return success("All keys are referenced in source files. No unused keys.") + "\n";
   }
 
   const grouped = new Map<string, Map<string, Map<string, string[]>>>();
@@ -140,7 +139,9 @@ export function formatUnusedKeys(
     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)}`);
+      lines.push(
+        `    ${color(`${g.arrow} ${locale}`, C.yellow)} ${color(`(${localeTotal})`, C.dim)}`,
+      );
 
       for (const [resource, keys] of byResource) {
         lines.push(`      ${color(resource, C.bold)}`);
@@ -151,7 +152,7 @@ export function formatUnusedKeys(
     }
   }
 
-  return lines.join('\n') + '\n';
+  return lines.join("\n") + "\n";
 }
 
 // ─── Validate formatter ──────────────────────────────────────────────────────
@@ -168,33 +169,27 @@ export interface ValidateResult {
   readonly entries: readonly ValidateEntry[];
 }
 
-export function formatValidate(
-  result: ValidateResult,
-  format: OutputFormat,
-): string {
-  if (format === 'json') {
-    return JSON.stringify(result, null, 2) + '\n';
+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';
+    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 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';
+  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 ─────────────────────────────────────────────────────
@@ -204,16 +199,13 @@ export interface LanguageEntry {
   readonly locales: readonly string[];
 }
 
-export function formatLanguages(
-  entries: readonly LanguageEntry[],
-  format: OutputFormat,
-): string {
-  if (format === 'json') {
-    return JSON.stringify(entries, null, 2) + '\n';
+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';
+    return warning("No adapters configured.") + "\n";
   }
 
   const lines: string[] = [];
@@ -221,10 +213,10 @@ export function formatLanguages(
 
   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))}`);
+    lines.push(`    ${color(`${g.arrow}`, C.dim)} ${e.locales.join(color(", ", C.dim))}`);
   }
 
-  return lines.join('\n') + '\n';
+  return lines.join("\n") + "\n";
 }
 
 // ─── Translate formatter ─────────────────────────────────────────────────────
@@ -239,26 +231,23 @@ export interface TranslateResult {
   };
 }
 
-export function formatTranslate(
-  result: TranslateResult,
-  format: OutputFormat,
-): string {
-  if (format === 'json') {
-    return JSON.stringify(result, null, 2) + '\n';
+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()));
+      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 lines.join("\n") + "\n";
   }
 
-  return failure(result.message) + '\n';
+  return failure(result.message) + "\n";
 }
 
 // ─── Add formatter ───────────────────────────────────────────────────────────
@@ -269,27 +258,24 @@ export interface AddResult {
   readonly addedResources?: readonly string[];
 }
 
-export function formatAdd(
-  result: AddResult,
-  format: OutputFormat,
-): string {
-  if (format === 'json') {
-    return JSON.stringify(result, null, 2) + '\n';
+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));
+      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 lines.join("\n") + "\n";
   }
 
-  return failure(result.message) + '\n';
+  return failure(result.message) + "\n";
 }
 
 // ─── Benchmark formatter ─────────────────────────────────────────────────────
@@ -304,21 +290,18 @@ export interface BenchmarkEntry {
   readonly totalAttempts: number;
 }
 
-export function formatBenchmark(
-  entries: readonly BenchmarkEntry[],
-  format: OutputFormat,
-): string {
-  if (format === 'json') {
-    return JSON.stringify(entries, null, 2) + '\n';
+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';
+    return warning("No benchmark data available.") + "\n";
   }
 
   const lines: string[] = [];
 
-  lines.push(banner('Benchmark Results'));
+  lines.push(banner("Benchmark Results"));
 
   const rows = entries.map((e) => [
     e.strategyName,
@@ -328,23 +311,17 @@ export function formatBenchmark(
     e.totalAttempts.toString(),
   ]);
 
-  lines.push('');
-  lines.push(drawTable(
-    ['Strategy', 'Chunks', 'Total', 'Avg/Chunk', 'Attempts'],
-    rows,
-  ));
+  lines.push("");
+  lines.push(drawTable(["Strategy", "Chunks", "Total", "Avg/Chunk", "Attempts"], rows));
 
-  return lines.join('\n') + '\n';
+  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';
+export function formatError(message: string, format: OutputFormat): string {
+  if (format === "json") {
+    return JSON.stringify({ error: message }, null, 2) + "\n";
   }
-  return failure(message) + '\n';
+  return failure(message) + "\n";
 }

package/src/cli/main.ts

@@ -1,16 +1,16 @@
 #!/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';
+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(
+const rootCommand = Command.make("dialekt").pipe(
   Command.withSubcommands([
     translateCommand,
     validateCommand,
@@ -23,8 +23,8 @@ const rootCommand = Command.make('dialekt').pipe(
 );
 
 const cli = Command.run(rootCommand, {
-  name: 'dialekt',
-  version: '0.1.0',
+  name: "dialekt",
+  version: "0.1.0",
 });
 
 const program = Effect.provide(cli(process.argv), NodeContext.layer);

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

@@ -1,15 +1,15 @@
-import { describe, expect, it } from 'vitest';
-import { defineConfig } from './define-config.js';
-import type { DialektConfig } from './types.js';
+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', () => {
+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' },
+      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: [],
@@ -17,14 +17,29 @@ describe('defineConfig', () => {
     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];
+  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' },
+      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],
@@ -32,13 +47,13 @@ describe('defineConfig', () => {
     expect(defineConfig(config)).toBe(config);
   });
 
-  it('accepts a config with tool-loop-agent strategy', () => {
+  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' },
+      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: [],
@@ -46,15 +61,15 @@ describe('defineConfig', () => {
     expect(defineConfig(config)).toBe(config);
   });
 
-  it('preserves reference identity for nested objects', () => {
-    const model = { provider: 'openai', modelId: 'gpt-4o' };
+  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',
+      sourceLocale: "en",
+      targetLocales: ["de"],
+      strategy: "one-shot",
       model,
-      fastModel: { provider: 'openai', modelId: 'gpt-4o-mini' },
+      fastModel: { provider: "openai", modelId: "gpt-4o-mini" },
       chunking,
       retry: { maxAttempts: 3, baseDelayMs: 1000 },
       adapters: [],

package/src/config/define-config.ts

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

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

@@ -1,35 +1,38 @@
-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';
+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 () => {
+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');
+    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']);
+    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');
+  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');
+      throw new Error("Expected Left");
     }
   });
 });

package/src/config/load-config.ts

@@ -1,9 +1,9 @@
-import { createJiti } from 'jiti';
-import { Effect, Data } from 'effect';
-import { resolve } from 'node:path';
-import type { DialektConfig } from './types.js';
+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')<{
+export class ConfigLoadError extends Data.TaggedError("ConfigLoadError")<{
   readonly path: string;
   readonly cause: unknown;
 }> {}