dialekt 0.1.0 → 0.1.1

package/src/adapter/types.test.ts

@@ -1,98 +1,98 @@
-import { describe, expect, it } from 'vitest';
-import { AdapterReadError, AdapterWriteError } from './types.js';
+import { describe, expect, it } from "vitest";
+import { AdapterReadError, AdapterWriteError } from "./types.js";
 
-describe('AdapterReadError', () => {
-  it('carries adapter/locale/resource/cause', () => {
+describe("AdapterReadError", () => {
+  it("carries adapter/locale/resource/cause", () => {
     const err = new AdapterReadError({
-      adapter: 'laravel',
-      locale: 'en',
-      resource: 'validation',
-      cause: new Error('boom'),
+      adapter: "laravel",
+      locale: "en",
+      resource: "validation",
+      cause: new Error("boom"),
     });
-    expect(err._tag).toBe('AdapterReadError');
-    expect(err.adapter).toBe('laravel');
-    expect(err.locale).toBe('en');
-    expect(err.resource).toBe('validation');
+    expect(err._tag).toBe("AdapterReadError");
+    expect(err.adapter).toBe("laravel");
+    expect(err.locale).toBe("en");
+    expect(err.resource).toBe("validation");
   });
 
-  it('carries string cause', () => {
+  it("carries string cause", () => {
     const err = new AdapterReadError({
-      adapter: 'paraglide',
-      locale: 'de',
-      resource: 'messages',
-      cause: 'file not found',
+      adapter: "paraglide",
+      locale: "de",
+      resource: "messages",
+      cause: "file not found",
     });
-    expect(err._tag).toBe('AdapterReadError');
-    expect(err.cause).toBe('file not found');
+    expect(err._tag).toBe("AdapterReadError");
+    expect(err.cause).toBe("file not found");
   });
 
-  it('preserves Error cause identity', () => {
-    const cause = new Error('disk full');
+  it("preserves Error cause identity", () => {
+    const cause = new Error("disk full");
     const err = new AdapterReadError({
-      adapter: 'laravel',
-      locale: 'fr',
-      resource: 'auth',
+      adapter: "laravel",
+      locale: "fr",
+      resource: "auth",
       cause,
     });
     expect(err.cause).toBe(cause);
   });
 
-  it('accepts empty locale and resource', () => {
+  it("accepts empty locale and resource", () => {
     const err = new AdapterReadError({
-      adapter: 'test',
-      locale: '',
-      resource: '',
-      cause: 'unknown',
+      adapter: "test",
+      locale: "",
+      resource: "",
+      cause: "unknown",
     });
-    expect(err.locale).toBe('');
-    expect(err.resource).toBe('');
+    expect(err.locale).toBe("");
+    expect(err.resource).toBe("");
   });
 
-  it('accepts various adapter names', () => {
-    for (const name of ['laravel', 'paraglide', 'symfony', 'custom']) {
+  it("accepts various adapter names", () => {
+    for (const name of ["laravel", "paraglide", "symfony", "custom"]) {
       const err = new AdapterReadError({
         adapter: name,
-        locale: 'en',
-        resource: 'x',
-        cause: 'test',
+        locale: "en",
+        resource: "x",
+        cause: "test",
       });
       expect(err.adapter).toBe(name);
     }
   });
 });
 
-describe('AdapterWriteError', () => {
-  it('carries adapter/locale/resource/cause', () => {
+describe("AdapterWriteError", () => {
+  it("carries adapter/locale/resource/cause", () => {
     const err = new AdapterWriteError({
-      adapter: 'paraglide',
-      locale: 'de',
-      resource: 'messages',
-      cause: 'disk full',
+      adapter: "paraglide",
+      locale: "de",
+      resource: "messages",
+      cause: "disk full",
     });
-    expect(err._tag).toBe('AdapterWriteError');
-    expect(err.adapter).toBe('paraglide');
-    expect(err.locale).toBe('de');
-    expect(err.resource).toBe('messages');
+    expect(err._tag).toBe("AdapterWriteError");
+    expect(err.adapter).toBe("paraglide");
+    expect(err.locale).toBe("de");
+    expect(err.resource).toBe("messages");
   });
 
-  it('carries Error cause', () => {
-    const cause = new Error('permission denied');
+  it("carries Error cause", () => {
+    const cause = new Error("permission denied");
     const err = new AdapterWriteError({
-      adapter: 'laravel',
-      locale: 'en',
-      resource: 'validation',
+      adapter: "laravel",
+      locale: "en",
+      resource: "validation",
       cause,
     });
     expect(err.cause).toBe(cause);
   });
 
-  it('accepts empty strings', () => {
+  it("accepts empty strings", () => {
     const err = new AdapterWriteError({
-      adapter: '',
-      locale: '',
-      resource: '',
-      cause: '',
+      adapter: "",
+      locale: "",
+      resource: "",
+      cause: "",
     });
-    expect(err.adapter).toBe('');
+    expect(err.adapter).toBe("");
   });
 });

package/src/adapter/types.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from 'effect';
+import { Data, Effect } from "effect";
 
 /** Opaque adapter-specific identifier for one resource within a locale. */
 export interface ResourceRef {
@@ -6,14 +6,14 @@ export interface ResourceRef {
   readonly label: string; // human-readable, for CLI output
 }
 
-export class AdapterReadError extends Data.TaggedError('AdapterReadError')<{
+export class AdapterReadError extends Data.TaggedError("AdapterReadError")<{
   readonly adapter: string;
   readonly locale: string;
   readonly resource: string;
   readonly cause: unknown;
 }> {}
 
-export class AdapterWriteError extends Data.TaggedError('AdapterWriteError')<{
+export class AdapterWriteError extends Data.TaggedError("AdapterWriteError")<{
   readonly adapter: string;
   readonly locale: string;
   readonly resource: string;
@@ -34,7 +34,10 @@ export interface TranslationAdapter {
   listResources(locale: string): Effect.Effect<readonly ResourceRef[], AdapterReadError>;
 
   /** Read one resource, flattened to dot-notation key → string value. Returns {} if the resource does not exist. */
-  readResource(locale: string, resource: ResourceRef): Effect.Effect<Record<string, string>, AdapterReadError>;
+  readResource(
+    locale: string,
+    resource: ResourceRef,
+  ): Effect.Effect<Record<string, string>, AdapterReadError>;
 
   /** Write a full flattened key→value map back to a resource, unflattening as needed. Creates the resource if absent and `create` capability allows it. */
   writeResource(

package/src/benchmark/metrics.test.ts

@@ -1,16 +1,35 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { summarizeBenchmarkResults, runBenchmarkedChunk } from './metrics.js';
-import type { ChunkBenchmarkResult } from './metrics.js';
-import type { TranslationStrategy, TranslationContext } from '../translation/types.js';
-import { TranslationFailedError } from '../translation/types.js';
+import { describe, expect, it } from "vitest";
+import { Effect } from "effect";
+import { summarizeBenchmarkResults, runBenchmarkedChunk } from "./metrics.js";
+import type { ChunkBenchmarkResult } from "./metrics.js";
+import type { TranslationStrategy, TranslationContext } from "../translation/types.js";
+import { TranslationFailedError } from "../translation/types.js";
 
-describe('summarizeBenchmarkResults', () => {
-  it('computes totals and averages correctly', () => {
+describe("summarizeBenchmarkResults", () => {
+  it("computes totals and averages correctly", () => {
     const results = [
-      { strategyName: 'one-shot' as const, chunkKeyCount: 2, durationMs: 100, attemptCount: 1, succeeded: true },
-      { strategyName: 'one-shot' as const, chunkKeyCount: 2, durationMs: 200, attemptCount: 1, succeeded: true },
-      { strategyName: 'one-shot' as const, chunkKeyCount: 1, durationMs: 300, attemptCount: 1, succeeded: false, errorMessage: 'oops' },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 2,
+        durationMs: 100,
+        attemptCount: 1,
+        succeeded: true,
+      },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 2,
+        durationMs: 200,
+        attemptCount: 1,
+        succeeded: true,
+      },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 1,
+        durationMs: 300,
+        attemptCount: 1,
+        succeeded: false,
+        errorMessage: "oops",
+      },
     ];
     const summary = summarizeBenchmarkResults(results);
     expect(summary.totalChunks).toBe(3);
@@ -21,7 +40,7 @@ describe('summarizeBenchmarkResults', () => {
     expect(summary.totalAttempts).toBe(3);
   });
 
-  it('handles empty results', () => {
+  it("handles empty results", () => {
     const summary = summarizeBenchmarkResults([]);
     expect(summary.totalChunks).toBe(0);
     expect(summary.succeededChunks).toBe(0);
@@ -29,12 +48,18 @@ describe('summarizeBenchmarkResults', () => {
     expect(summary.totalDurationMs).toBe(0);
     expect(summary.averageDurationMsPerChunk).toBe(0);
     expect(summary.totalAttempts).toBe(0);
-    expect(summary.strategyName).toBe('one-shot');
+    expect(summary.strategyName).toBe("one-shot");
   });
 
-  it('handles single result', () => {
+  it("handles single result", () => {
     const results = [
-      { strategyName: 'tool-loop-agent' as const, chunkKeyCount: 5, durationMs: 150, attemptCount: 2, succeeded: true },
+      {
+        strategyName: "tool-loop-agent" as const,
+        chunkKeyCount: 5,
+        durationMs: 150,
+        attemptCount: 2,
+        succeeded: true,
+      },
     ];
     const summary = summarizeBenchmarkResults(results);
     expect(summary.totalChunks).toBe(1);
@@ -44,10 +69,24 @@ describe('summarizeBenchmarkResults', () => {
     expect(summary.totalAttempts).toBe(2);
   });
 
-  it('handles all failures', () => {
+  it("handles all failures", () => {
     const results = [
-      { strategyName: 'one-shot' as const, chunkKeyCount: 1, durationMs: 50, attemptCount: 1, succeeded: false, errorMessage: 'a' },
-      { strategyName: 'one-shot' as const, chunkKeyCount: 1, durationMs: 60, attemptCount: 1, succeeded: false, errorMessage: 'b' },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 1,
+        durationMs: 50,
+        attemptCount: 1,
+        succeeded: false,
+        errorMessage: "a",
+      },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 1,
+        durationMs: 60,
+        attemptCount: 1,
+        succeeded: false,
+        errorMessage: "b",
+      },
     ];
     const summary = summarizeBenchmarkResults(results);
     expect(summary.succeededChunks).toBe(0);
@@ -55,27 +94,51 @@ describe('summarizeBenchmarkResults', () => {
     expect(summary.totalDurationMs).toBe(110);
   });
 
-  it('handles zero-duration results', () => {
+  it("handles zero-duration results", () => {
     const results = [
-      { strategyName: 'one-shot' as const, chunkKeyCount: 1, durationMs: 0, attemptCount: 1, succeeded: true },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 1,
+        durationMs: 0,
+        attemptCount: 1,
+        succeeded: true,
+      },
     ];
     const summary = summarizeBenchmarkResults(results);
     expect(summary.totalDurationMs).toBe(0);
     expect(summary.averageDurationMsPerChunk).toBe(0);
   });
 
-  it('preserves strategyName from first result', () => {
+  it("preserves strategyName from first result", () => {
     const results = [
-      { strategyName: 'tool-loop-agent' as const, chunkKeyCount: 1, durationMs: 100, attemptCount: 1, succeeded: true },
+      {
+        strategyName: "tool-loop-agent" as const,
+        chunkKeyCount: 1,
+        durationMs: 100,
+        attemptCount: 1,
+        succeeded: true,
+      },
     ];
     const summary = summarizeBenchmarkResults(results);
-    expect(summary.strategyName).toBe('tool-loop-agent');
+    expect(summary.strategyName).toBe("tool-loop-agent");
   });
 
-  it('handles very large durations without overflow', () => {
+  it("handles very large durations without overflow", () => {
     const results = [
-      { strategyName: 'one-shot' as const, chunkKeyCount: 1, durationMs: 1_000_000, attemptCount: 1, succeeded: true },
-      { strategyName: 'one-shot' as const, chunkKeyCount: 1, durationMs: 2_000_000, attemptCount: 1, succeeded: true },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 1,
+        durationMs: 1_000_000,
+        attemptCount: 1,
+        succeeded: true,
+      },
+      {
+        strategyName: "one-shot" as const,
+        chunkKeyCount: 1,
+        durationMs: 2_000_000,
+        attemptCount: 1,
+        succeeded: true,
+      },
     ];
     const summary = summarizeBenchmarkResults(results);
     expect(summary.totalDurationMs).toBe(3_000_000);
@@ -83,98 +146,107 @@ describe('summarizeBenchmarkResults', () => {
   });
 });
 
-describe('runBenchmarkedChunk', () => {
-  it('measures duration and returns success', async () => {
+describe("runBenchmarkedChunk", () => {
+  it("measures duration and returns success", async () => {
     const strategy: TranslationStrategy = {
-      name: 'one-shot',
-      translateChunk: () => Effect.succeed({ hello: 'Hallo' }),
+      name: "one-shot",
+      translateChunk: () => Effect.succeed({ hello: "Hallo" }),
     };
     const ctx: TranslationContext = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { hello: 'Hello' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { hello: "Hello" },
       targetMap: {},
-      keys: ['hello'],
+      keys: ["hello"],
     };
-    const result = await Effect.runPromise(runBenchmarkedChunk(strategy, ctx)) as ChunkBenchmarkResult;
+    const result = (await Effect.runPromise(
+      runBenchmarkedChunk(strategy, ctx),
+    )) as ChunkBenchmarkResult;
     expect(result.succeeded).toBe(true);
     expect(result.chunkKeyCount).toBe(1);
     expect(result.durationMs).toBeGreaterThanOrEqual(0);
-    expect(result.strategyName).toBe('one-shot');
+    expect(result.strategyName).toBe("one-shot");
   });
 
-  it('records failure without propagating', async () => {
+  it("records failure without propagating", async () => {
     const strategy: TranslationStrategy = {
-      name: 'tool-loop-agent',
-      translateChunk: () =>
-        Effect.fail(new TranslationFailedError({ keys: ['a'], cause: 'boom' })),
+      name: "tool-loop-agent",
+      translateChunk: () => Effect.fail(new TranslationFailedError({ keys: ["a"], cause: "boom" })),
     };
     const ctx: TranslationContext = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { a: 'A' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { a: "A" },
       targetMap: {},
-      keys: ['a'],
+      keys: ["a"],
     };
-    const result = await Effect.runPromise(runBenchmarkedChunk(strategy, ctx)) as ChunkBenchmarkResult;
+    const result = (await Effect.runPromise(
+      runBenchmarkedChunk(strategy, ctx),
+    )) as ChunkBenchmarkResult;
     expect(result.succeeded).toBe(false);
-    expect(result.errorMessage).toBe('boom');
+    expect(result.errorMessage).toBe("boom");
     expect(result.chunkKeyCount).toBe(1);
   });
 
-  it('handles empty key list', async () => {
+  it("handles empty key list", async () => {
     const strategy: TranslationStrategy = {
-      name: 'one-shot',
+      name: "one-shot",
       translateChunk: () => Effect.succeed({}),
     };
     const ctx: TranslationContext = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
+      sourceLocale: "en",
+      targetLocale: "de",
       sourceMap: {},
       targetMap: {},
       keys: [],
     };
-    const result = await Effect.runPromise(runBenchmarkedChunk(strategy, ctx)) as ChunkBenchmarkResult;
+    const result = (await Effect.runPromise(
+      runBenchmarkedChunk(strategy, ctx),
+    )) as ChunkBenchmarkResult;
     expect(result.succeeded).toBe(true);
     expect(result.chunkKeyCount).toBe(0);
   });
 
-  it('measures duration for slow strategies', async () => {
+  it("measures duration for slow strategies", async () => {
     const strategy: TranslationStrategy = {
-      name: 'tool-loop-agent',
+      name: "tool-loop-agent",
       translateChunk: () =>
         Effect.gen(function* () {
-          yield* Effect.sleep('50 millis');
-          return { k: 'v' };
+          yield* Effect.sleep("50 millis");
+          return { k: "v" };
         }),
     };
     const ctx: TranslationContext = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { k: 'K' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { k: "K" },
       targetMap: {},
-      keys: ['k'],
+      keys: ["k"],
     };
-    const result = await Effect.runPromise(runBenchmarkedChunk(strategy, ctx)) as ChunkBenchmarkResult;
+    const result = (await Effect.runPromise(
+      runBenchmarkedChunk(strategy, ctx),
+    )) as ChunkBenchmarkResult;
     expect(result.succeeded).toBe(true);
     expect(result.durationMs).toBeGreaterThanOrEqual(30);
   });
 
-  it('captures Error cause in errorMessage', async () => {
+  it("captures Error cause in errorMessage", async () => {
     const strategy: TranslationStrategy = {
-      name: 'one-shot',
+      name: "one-shot",
       translateChunk: () =>
-        Effect.fail(new TranslationFailedError({ keys: ['x'], cause: new Error('deep error') })),
+        Effect.fail(new TranslationFailedError({ keys: ["x"], cause: new Error("deep error") })),
     };
     const ctx: TranslationContext = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { x: 'X' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { x: "X" },
       targetMap: {},
-      keys: ['x'],
+      keys: ["x"],
     };
-    const result = await Effect.runPromise(runBenchmarkedChunk(strategy, ctx)) as ChunkBenchmarkResult;
+    const result = (await Effect.runPromise(
+      runBenchmarkedChunk(strategy, ctx),
+    )) as ChunkBenchmarkResult;
     expect(result.succeeded).toBe(false);
-    expect(result.errorMessage).toContain('deep error');
+    expect(result.errorMessage).toContain("deep error");
   });
 });

package/src/benchmark/metrics.ts

@@ -1,8 +1,8 @@
-import { Effect } from 'effect';
-import type { TranslationStrategy, TranslationContext } from '../translation/types.js';
+import { Effect } from "effect";
+import type { TranslationStrategy, TranslationContext } from "../translation/types.js";
 
 export interface ChunkBenchmarkResult {
-  readonly strategyName: 'one-shot' | 'tool-loop-agent';
+  readonly strategyName: "one-shot" | "tool-loop-agent";
   readonly chunkKeyCount: number;
   readonly durationMs: number;
   readonly attemptCount: number;
@@ -11,7 +11,7 @@ export interface ChunkBenchmarkResult {
 }
 
 export interface StrategyBenchmarkSummary {
-  readonly strategyName: 'one-shot' | 'tool-loop-agent';
+  readonly strategyName: "one-shot" | "tool-loop-agent";
   readonly totalChunks: number;
   readonly succeededChunks: number;
   readonly failedChunks: number;
@@ -29,7 +29,7 @@ export function summarizeBenchmarkResults(
   const totalDurationMs = results.reduce((sum, r) => sum + r.durationMs, 0);
   const totalAttempts = results.reduce((sum, r) => sum + r.attemptCount, 0);
   return {
-    strategyName: results[0]?.strategyName ?? 'one-shot',
+    strategyName: results[0]?.strategyName ?? "one-shot",
     totalChunks,
     succeededChunks,
     failedChunks,
@@ -47,7 +47,7 @@ export function runBenchmarkedChunk(
     const start = Date.now();
     const result = yield* Effect.either(strategy.translateChunk(ctx));
     const durationMs = Date.now() - start;
-    if (result._tag === 'Right') {
+    if (result._tag === "Right") {
       return {
         strategyName: strategy.name,
         chunkKeyCount: ctx.keys.length,