dialekt 0.1.0 → 0.1.1

package/src/benchmark/report.test.ts

@@ -1,12 +1,12 @@
-import { describe, expect, it } from 'vitest';
-import { formatBenchmarkReport } from './report.js';
-import type { StrategyBenchmarkSummary } from './metrics.js';
+import { describe, expect, it } from "vitest";
+import { formatBenchmarkReport } from "./report.js";
+import type { StrategyBenchmarkSummary } from "./metrics.js";
 
-describe('formatBenchmarkReport', () => {
-  it('produces valid JSON round-trip', () => {
+describe("formatBenchmarkReport", () => {
+  it("produces valid JSON round-trip", () => {
     const summaries: StrategyBenchmarkSummary[] = [
       {
-        strategyName: 'one-shot',
+        strategyName: "one-shot",
         totalChunks: 3,
         succeededChunks: 3,
         failedChunks: 0,
@@ -15,14 +15,14 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 3,
       },
     ];
-    const json = formatBenchmarkReport(summaries, 'json');
+    const json = formatBenchmarkReport(summaries, "json");
     expect(JSON.parse(json)).toEqual(summaries);
   });
 
-  it('produces human-readable table with key metrics', () => {
+  it("produces human-readable table with key metrics", () => {
     const summaries: StrategyBenchmarkSummary[] = [
       {
-        strategyName: 'one-shot',
+        strategyName: "one-shot",
         totalChunks: 3,
         succeededChunks: 3,
         failedChunks: 0,
@@ -31,17 +31,17 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 3,
       },
     ];
-    const table = formatBenchmarkReport(summaries, 'table');
-    expect(table).toContain('one-shot');
-    expect(table).toContain('300');
-    expect(table).toContain('100.0');
-    expect(table).toContain('3');
+    const table = formatBenchmarkReport(summaries, "table");
+    expect(table).toContain("one-shot");
+    expect(table).toContain("300");
+    expect(table).toContain("100.0");
+    expect(table).toContain("3");
   });
 
-  it('handles multiple strategies in table format', () => {
+  it("handles multiple strategies in table format", () => {
     const summaries: StrategyBenchmarkSummary[] = [
       {
-        strategyName: 'one-shot',
+        strategyName: "one-shot",
         totalChunks: 5,
         succeededChunks: 5,
         failedChunks: 0,
@@ -50,7 +50,7 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 5,
       },
       {
-        strategyName: 'tool-loop-agent',
+        strategyName: "tool-loop-agent",
         totalChunks: 5,
         succeededChunks: 4,
         failedChunks: 1,
@@ -59,26 +59,26 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 6,
       },
     ];
-    const table = formatBenchmarkReport(summaries, 'table');
-    expect(table).toContain('one-shot');
-    expect(table).toContain('tool-loop-agent');
-    expect(table).toContain('4 ok, 1 failed');
+    const table = formatBenchmarkReport(summaries, "table");
+    expect(table).toContain("one-shot");
+    expect(table).toContain("tool-loop-agent");
+    expect(table).toContain("4 ok, 1 failed");
   });
 
-  it('handles empty summaries in JSON format', () => {
-    const json = formatBenchmarkReport([], 'json');
+  it("handles empty summaries in JSON format", () => {
+    const json = formatBenchmarkReport([], "json");
     expect(JSON.parse(json)).toEqual([]);
   });
 
-  it('handles empty summaries in table format', () => {
-    const table = formatBenchmarkReport([], 'table');
-    expect(table).toContain('Benchmark Results');
+  it("handles empty summaries in table format", () => {
+    const table = formatBenchmarkReport([], "table");
+    expect(table).toContain("Benchmark Results");
   });
 
-  it('handles all-failed strategy in table', () => {
+  it("handles all-failed strategy in table", () => {
     const summaries: StrategyBenchmarkSummary[] = [
       {
-        strategyName: 'one-shot',
+        strategyName: "one-shot",
         totalChunks: 3,
         succeededChunks: 0,
         failedChunks: 3,
@@ -87,14 +87,14 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 3,
       },
     ];
-    const table = formatBenchmarkReport(summaries, 'table');
-    expect(table).toContain('0 ok, 3 failed');
+    const table = formatBenchmarkReport(summaries, "table");
+    expect(table).toContain("0 ok, 3 failed");
   });
 
-  it('handles zero-duration strategy', () => {
+  it("handles zero-duration strategy", () => {
     const summaries: StrategyBenchmarkSummary[] = [
       {
-        strategyName: 'one-shot',
+        strategyName: "one-shot",
         totalChunks: 1,
         succeededChunks: 1,
         failedChunks: 0,
@@ -103,15 +103,15 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 1,
       },
     ];
-    const table = formatBenchmarkReport(summaries, 'table');
-    expect(table).toContain('0ms');
-    expect(table).toContain('0.0ms');
+    const table = formatBenchmarkReport(summaries, "table");
+    expect(table).toContain("0ms");
+    expect(table).toContain("0.0ms");
   });
 
-  it('JSON format includes all numeric fields', () => {
+  it("JSON format includes all numeric fields", () => {
     const summaries: StrategyBenchmarkSummary[] = [
       {
-        strategyName: 'tool-loop-agent',
+        strategyName: "tool-loop-agent",
         totalChunks: 2,
         succeededChunks: 1,
         failedChunks: 1,
@@ -120,7 +120,7 @@ describe('formatBenchmarkReport', () => {
         totalAttempts: 4,
       },
     ];
-    const json = formatBenchmarkReport(summaries, 'json');
+    const json = formatBenchmarkReport(summaries, "json");
     const parsed = JSON.parse(json) as StrategyBenchmarkSummary[];
     expect(parsed[0]!.totalChunks).toBe(2);
     expect(parsed[0]!.totalAttempts).toBe(4);

package/src/benchmark/report.ts

@@ -1,21 +1,21 @@
-import type { StrategyBenchmarkSummary } from './metrics.js';
+import type { StrategyBenchmarkSummary } from "./metrics.js";
 
 export function formatBenchmarkReport(
   summaries: readonly StrategyBenchmarkSummary[],
-  format: 'table' | 'json',
+  format: "table" | "json",
 ): string {
-  if (format === 'json') {
+  if (format === "json") {
     return JSON.stringify(summaries, null, 2);
   }
 
-  const lines: string[] = ['Benchmark Results', '================='];
+  const lines: string[] = ["Benchmark Results", "================="];
   for (const s of summaries) {
     lines.push(`Strategy: ${s.strategyName}`);
     lines.push(`  Chunks: ${s.totalChunks} (${s.succeededChunks} ok, ${s.failedChunks} failed)`);
     lines.push(`  Total duration: ${s.totalDurationMs.toFixed(0)}ms`);
     lines.push(`  Avg per chunk: ${s.averageDurationMsPerChunk.toFixed(1)}ms`);
     lines.push(`  Total attempts: ${s.totalAttempts}`);
-    lines.push('');
+    lines.push("");
   }
-  return lines.join('\n');
+  return lines.join("\n");
 }

package/src/benchmark/runner.test.ts

@@ -1,160 +1,158 @@
-import { describe, expect, it } from 'vitest';
-import { Effect } from 'effect';
-import { runBenchmark } from './runner.js';
-import type { StrategyBenchmarkSummary } 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 { runBenchmark } from "./runner.js";
+import type { StrategyBenchmarkSummary } from "./metrics.js";
+import type { TranslationStrategy, TranslationContext } from "../translation/types.js";
+import { TranslationFailedError } from "../translation/types.js";
 
-describe('runBenchmark', () => {
-  it('returns summaries for both strategies', async () => {
+describe("runBenchmark", () => {
+  it("returns summaries for both strategies", async () => {
     const a: TranslationStrategy = {
-      name: 'one-shot',
-      translateChunk: () => Effect.succeed({ k: 'a' }),
+      name: "one-shot",
+      translateChunk: () => Effect.succeed({ k: "a" }),
     };
     const b: TranslationStrategy = {
-      name: 'tool-loop-agent',
-      translateChunk: () => Effect.succeed({ k: 'b' }),
+      name: "tool-loop-agent",
+      translateChunk: () => Effect.succeed({ k: "b" }),
     };
     const chunks: 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(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a, b], chunks, concurrency: 1 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result).toHaveLength(2);
-    expect(result[0]!.strategyName).toBe('one-shot');
-    expect(result[1]!.strategyName).toBe('tool-loop-agent');
+    expect(result[0]!.strategyName).toBe("one-shot");
+    expect(result[1]!.strategyName).toBe("tool-loop-agent");
   });
 
-  it('does not abort when one strategy fails every chunk', async () => {
+  it("does not abort when one strategy fails every chunk", async () => {
     const a: TranslationStrategy = {
-      name: 'one-shot',
-      translateChunk: () => Effect.succeed({ k: 'a' }),
+      name: "one-shot",
+      translateChunk: () => Effect.succeed({ k: "a" }),
     };
     const b: TranslationStrategy = {
-      name: 'tool-loop-agent',
-      translateChunk: () =>
-        Effect.fail(new TranslationFailedError({ keys: ['k'], cause: 'boom' })),
+      name: "tool-loop-agent",
+      translateChunk: () => Effect.fail(new TranslationFailedError({ keys: ["k"], cause: "boom" })),
     };
     const chunks: 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(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a, b], chunks, concurrency: 1 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result[0]!.succeededChunks).toBe(1);
     expect(result[1]!.failedChunks).toBe(1);
   });
 
-  it('handles empty chunks', async () => {
+  it("handles empty chunks", async () => {
     const a: TranslationStrategy = {
-      name: 'one-shot',
+      name: "one-shot",
       translateChunk: () => Effect.succeed({}),
     };
-    const result = await Effect.runPromise(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a], chunks: [], concurrency: 1 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result).toHaveLength(1);
     expect(result[0]!.totalChunks).toBe(0);
     expect(result[0]!.succeededChunks).toBe(0);
   });
 
-  it('handles single strategy', async () => {
+  it("handles single strategy", async () => {
     const a: TranslationStrategy = {
-      name: 'one-shot',
-      translateChunk: () => Effect.succeed({ a: 'A', b: 'B' }),
+      name: "one-shot",
+      translateChunk: () => Effect.succeed({ a: "A", b: "B" }),
     };
     const chunks: TranslationContext[] = [
       {
-        sourceLocale: 'en',
-        targetLocale: 'de',
-        sourceMap: { a: 'A', b: 'B' },
+        sourceLocale: "en",
+        targetLocale: "de",
+        sourceMap: { a: "A", b: "B" },
         targetMap: {},
-        keys: ['a', 'b'],
+        keys: ["a", "b"],
       },
     ];
-    const result = await Effect.runPromise(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a], chunks, concurrency: 1 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result).toHaveLength(1);
     expect(result[0]!.totalChunks).toBe(1);
     expect(result[0]!.succeededChunks).toBe(1);
   });
 
-  it('handles multiple chunks with concurrency', async () => {
+  it("handles multiple chunks with concurrency", async () => {
     const a: TranslationStrategy = {
-      name: 'one-shot',
-      translateChunk: () => Effect.succeed({ k: 'v' }),
+      name: "one-shot",
+      translateChunk: () => Effect.succeed({ k: "v" }),
     };
     const chunks: TranslationContext[] = Array.from({ length: 5 }, (_, i) => ({
-      sourceLocale: 'en',
-      targetLocale: 'de',
+      sourceLocale: "en",
+      targetLocale: "de",
       sourceMap: { [`k${i}`]: `V${i}` },
       targetMap: {},
       keys: [`k${i}`],
     }));
-    const result = await Effect.runPromise(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a], chunks, concurrency: 3 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result[0]!.totalChunks).toBe(5);
     expect(result[0]!.succeededChunks).toBe(5);
   });
 
-  it('handles all strategies failing', async () => {
+  it("handles all strategies failing", async () => {
     const a: TranslationStrategy = {
-      name: 'one-shot',
-      translateChunk: () =>
-        Effect.fail(new TranslationFailedError({ keys: ['k'], cause: 'fail' })),
+      name: "one-shot",
+      translateChunk: () => Effect.fail(new TranslationFailedError({ keys: ["k"], cause: "fail" })),
     };
     const chunks: 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(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a], chunks, concurrency: 1 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result[0]!.failedChunks).toBe(1);
     expect(result[0]!.succeededChunks).toBe(0);
   });
 
-  it('handles mixed success and failure across chunks', async () => {
+  it("handles mixed success and failure across chunks", async () => {
     let callCount = 0;
     const a: TranslationStrategy = {
-      name: 'one-shot',
+      name: "one-shot",
       translateChunk: () => {
         callCount++;
         return callCount % 2 === 1
-          ? Effect.succeed({ k: 'v' })
-          : Effect.fail(new TranslationFailedError({ keys: ['k'], cause: 'odd' }));
+          ? Effect.succeed({ k: "v" })
+          : Effect.fail(new TranslationFailedError({ keys: ["k"], cause: "odd" }));
       },
     };
     const chunks: TranslationContext[] = Array.from({ length: 4 }, () => ({
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { k: 'K' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { k: "K" },
       targetMap: {},
-      keys: ['k'],
+      keys: ["k"],
     }));
-    const result = await Effect.runPromise(
+    const result = (await Effect.runPromise(
       runBenchmark({ strategies: [a], chunks, concurrency: 1 }),
-    ) as StrategyBenchmarkSummary[];
+    )) as StrategyBenchmarkSummary[];
     expect(result[0]!.totalChunks).toBe(4);
     expect(result[0]!.succeededChunks).toBe(2);
     expect(result[0]!.failedChunks).toBe(2);

package/src/benchmark/runner.ts

@@ -1,7 +1,7 @@
-import { Effect } from 'effect';
-import type { TranslationStrategy, TranslationContext } from '../translation/types.js';
-import type { StrategyBenchmarkSummary } from './metrics.js';
-import { runBenchmarkedChunk, summarizeBenchmarkResults } from './metrics.js';
+import { Effect } from "effect";
+import type { TranslationStrategy, TranslationContext } from "../translation/types.js";
+import type { StrategyBenchmarkSummary } from "./metrics.js";
+import { runBenchmarkedChunk, summarizeBenchmarkResults } from "./metrics.js";
 
 export interface BenchmarkConfig {
   readonly strategies: readonly TranslationStrategy[];