dialekt 0.1.0 → 0.1.1

package/src/translation/prompt.ts

@@ -12,7 +12,7 @@ Rules:
 - Escape double quotes in translations with a backslash when needed.`;
 }
 
-import type { TranslationContext } from './types.js';
+import type { TranslationContext } from "./types.js";
 
 export function buildUserPrompt(ctx: TranslationContext): string {
   const sourceJson = JSON.stringify(ctx.sourceMap, null, 2);
@@ -20,7 +20,7 @@ export function buildUserPrompt(ctx: TranslationContext): string {
 
   const keysWithValues: Record<string, string> = {};
   for (const key of ctx.keys) {
-    keysWithValues[key] = ctx.sourceMap[key] ?? '';
+    keysWithValues[key] = ctx.sourceMap[key] ?? "";
   }
   const keysJson = JSON.stringify(keysWithValues, null, 2);
 

package/src/translation/tool-loop-strategy.test.ts

@@ -1,29 +1,29 @@
-import { describe, expect, it } from 'vitest';
-import { Effect, Either } from 'effect';
-import { MockLanguageModelV3 } from 'ai/test';
-import { createToolLoopStrategy } from './tool-loop-strategy.js';
-import { TranslationFailedError } from './types.js';
+import { describe, expect, it } from "vitest";
+import { Effect, Either } from "effect";
+import { MockLanguageModelV3 } from "ai/test";
+import { createToolLoopStrategy } from "./tool-loop-strategy.js";
+import { TranslationFailedError } from "./types.js";
 
-describe('createToolLoopStrategy', () => {
-  it('returns translated map when tool is called', async () => {
+describe("createToolLoopStrategy", () => {
+  it("returns translated map when tool is called", async () => {
     const model = new MockLanguageModelV3({
       doGenerate: async () => ({
-        text: '',
+        text: "",
         content: [
           {
-            type: 'tool-call',
-            toolCallId: 'call-1',
-            toolName: 'submitTranslations',
-            input: JSON.stringify({ hello: 'Hallo', bye: 'Tschüss' }),
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "submitTranslations",
+            input: JSON.stringify({ hello: "Hallo", bye: "Tschüss" }),
           },
         ],
-        finishReason: { unified: 'tool-calls' as const, raw: 'tool_calls' },
+        finishReason: { unified: "tool-calls" as const, raw: "tool_calls" },
         usage: {
           inputTokens: { total: 10, noCache: 10, cacheRead: 0, cacheWrite: 0 },
           outputTokens: { total: 4, text: 0, reasoning: 0 },
         },
         response: {
-          modelId: 'mock',
+          modelId: "mock",
           timestamp: new Date(),
         },
         request: { body: {} },
@@ -37,32 +37,32 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { hello: 'Hello', bye: 'Bye' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { hello: "Hello", bye: "Bye" },
       targetMap: {},
-      keys: ['hello', 'bye'],
+      keys: ["hello", "bye"],
     };
 
     const result = await Effect.runPromise(strategy.translateChunk(ctx));
-    expect(result).toEqual({ hello: 'Hallo', bye: 'Tschüss' });
+    expect(result).toEqual({ hello: "Hallo", bye: "Tschüss" });
   });
 
-  it('retries when tool is not called and fails after exhaustion', async () => {
+  it("retries when tool is not called and fails after exhaustion", async () => {
     let calls = 0;
     const model = new MockLanguageModelV3({
       doGenerate: async () => {
         calls++;
         return {
-          text: '',
-          content: [{ type: 'text' as const, text: 'I will translate now' }],
-          finishReason: { unified: 'stop' as const, raw: 'stop' },
+          text: "",
+          content: [{ type: "text" as const, text: "I will translate now" }],
+          finishReason: { unified: "stop" as const, raw: "stop" },
           usage: {
             inputTokens: { total: 10, noCache: 10, cacheRead: 0, cacheWrite: 0 },
             outputTokens: { total: 2, text: 2, reasoning: 0 },
           },
           response: {
-            modelId: 'mock',
+            modelId: "mock",
             timestamp: new Date(),
           },
           request: { body: {} },
@@ -77,35 +77,42 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { hello: 'Hello', bye: 'Bye' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { hello: "Hello", bye: "Bye" },
       targetMap: {},
-      keys: ['hello', 'bye'],
+      keys: ["hello", "bye"],
     };
 
-    const exit = await Effect.runPromise(Effect.either(strategy.translateChunk(ctx))) as Either.Either<unknown, TranslationFailedError>;
+    const exit = (await Effect.runPromise(
+      Effect.either(strategy.translateChunk(ctx)),
+    )) as Either.Either<unknown, TranslationFailedError>;
     expect(calls).toBeGreaterThan(1);
-    if (exit._tag === 'Left') {
-      expect(exit.left._tag).toBe('TranslationFailedError');
+    if (exit._tag === "Left") {
+      expect(exit.left._tag).toBe("TranslationFailedError");
     } else {
-      throw new Error('Expected Left');
+      throw new Error("Expected Left");
     }
   });
 
-  it('handles empty keys', async () => {
+  it("handles empty keys", async () => {
     const model = new MockLanguageModelV3({
       doGenerate: async () => ({
-        text: '',
-        content: [{
-          type: 'tool-call',
-          toolCallId: 'call-1',
-          toolName: 'submitTranslations',
-          input: JSON.stringify({}),
-        }],
-        finishReason: { unified: 'tool-calls' as const, raw: 'tool_calls' },
-        usage: { inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1, text: 0, reasoning: 0 } },
-        response: { modelId: 'mock', timestamp: new Date() },
+        text: "",
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "submitTranslations",
+            input: JSON.stringify({}),
+          },
+        ],
+        finishReason: { unified: "tool-calls" as const, raw: "tool_calls" },
+        usage: {
+          inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 1, text: 0, reasoning: 0 },
+        },
+        response: { modelId: "mock", timestamp: new Date() },
         request: { body: {} },
         warnings: [],
       }),
@@ -117,8 +124,8 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
+      sourceLocale: "en",
+      targetLocale: "de",
       sourceMap: {},
       targetMap: {},
       keys: [],
@@ -128,22 +135,27 @@ describe('createToolLoopStrategy', () => {
     expect(result).toEqual({});
   });
 
-  it('handles wrong tool name by retrying', async () => {
+  it("handles wrong tool name by retrying", async () => {
     let calls = 0;
     const model = new MockLanguageModelV3({
       doGenerate: async () => {
         calls++;
         return {
-          text: '',
-          content: [{
-            type: 'tool-call',
-            toolCallId: 'call-1',
-            toolName: calls < 2 ? 'wrongTool' : 'submitTranslations',
-            input: JSON.stringify({ k: 'v' }),
-          }],
-          finishReason: { unified: 'tool-calls' as const, raw: 'tool_calls' },
-          usage: { inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1, text: 0, reasoning: 0 } },
-          response: { modelId: 'mock', timestamp: new Date() },
+          text: "",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call-1",
+              toolName: calls < 2 ? "wrongTool" : "submitTranslations",
+              input: JSON.stringify({ k: "v" }),
+            },
+          ],
+          finishReason: { unified: "tool-calls" as const, raw: "tool_calls" },
+          usage: {
+            inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+            outputTokens: { total: 1, text: 0, reasoning: 0 },
+          },
+          response: { modelId: "mock", timestamp: new Date() },
           request: { body: {} },
           warnings: [],
         };
@@ -156,34 +168,39 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { k: 'K' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { k: "K" },
       targetMap: {},
-      keys: ['k'],
+      keys: ["k"],
     };
 
     const result = await Effect.runPromise(strategy.translateChunk(ctx));
-    expect(result).toEqual({ k: 'v' });
+    expect(result).toEqual({ k: "v" });
     expect(calls).toBeGreaterThan(1);
   });
 
-  it('handles malformed tool input by retrying', async () => {
+  it("handles malformed tool input by retrying", async () => {
     let calls = 0;
     const model = new MockLanguageModelV3({
       doGenerate: async () => {
         calls++;
         return {
-          text: '',
-          content: [{
-            type: 'tool-call',
-            toolCallId: 'call-1',
-            toolName: 'submitTranslations',
-            input: calls < 2 ? 'not-json' : JSON.stringify({ k: 'v' }),
-          }],
-          finishReason: { unified: 'tool-calls' as const, raw: 'tool_calls' },
-          usage: { inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1, text: 0, reasoning: 0 } },
-          response: { modelId: 'mock', timestamp: new Date() },
+          text: "",
+          content: [
+            {
+              type: "tool-call",
+              toolCallId: "call-1",
+              toolName: "submitTranslations",
+              input: calls < 2 ? "not-json" : JSON.stringify({ k: "v" }),
+            },
+          ],
+          finishReason: { unified: "tool-calls" as const, raw: "tool_calls" },
+          usage: {
+            inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+            outputTokens: { total: 1, text: 0, reasoning: 0 },
+          },
+          response: { modelId: "mock", timestamp: new Date() },
           request: { body: {} },
           warnings: [],
         };
@@ -196,26 +213,29 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { k: 'K' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { k: "K" },
       targetMap: {},
-      keys: ['k'],
+      keys: ["k"],
     };
 
     const result = await Effect.runPromise(strategy.translateChunk(ctx));
-    expect(result).toEqual({ k: 'v' });
+    expect(result).toEqual({ k: "v" });
     expect(calls).toBeGreaterThan(1);
   });
 
-  it('fails after all retries when tool never called', async () => {
+  it("fails after all retries when tool never called", async () => {
     const model = new MockLanguageModelV3({
       doGenerate: async () => ({
-        text: '',
-        content: [{ type: 'text', text: 'I will translate now' }],
-        finishReason: { unified: 'stop' as const, raw: 'stop' },
-        usage: { inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1, text: 1, reasoning: 0 } },
-        response: { modelId: 'mock', timestamp: new Date() },
+        text: "",
+        content: [{ type: "text", text: "I will translate now" }],
+        finishReason: { unified: "stop" as const, raw: "stop" },
+        usage: {
+          inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 1, text: 1, reasoning: 0 },
+        },
+        response: { modelId: "mock", timestamp: new Date() },
         request: { body: {} },
         warnings: [],
       }),
@@ -227,34 +247,41 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { k: 'K' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { k: "K" },
       targetMap: {},
-      keys: ['k'],
+      keys: ["k"],
     };
 
-    const exit = await Effect.runPromise(Effect.either(strategy.translateChunk(ctx))) as Either.Either<unknown, TranslationFailedError>;
-    if (exit._tag === 'Left') {
-      expect(exit.left._tag).toBe('TranslationFailedError');
+    const exit = (await Effect.runPromise(
+      Effect.either(strategy.translateChunk(ctx)),
+    )) as Either.Either<unknown, TranslationFailedError>;
+    if (exit._tag === "Left") {
+      expect(exit.left._tag).toBe("TranslationFailedError");
     } else {
-      throw new Error('Expected Left');
+      throw new Error("Expected Left");
     }
   });
 
-  it('handles single key', async () => {
+  it("handles single key", async () => {
     const model = new MockLanguageModelV3({
       doGenerate: async () => ({
-        text: '',
-        content: [{
-          type: 'tool-call',
-          toolCallId: 'call-1',
-          toolName: 'submitTranslations',
-          input: JSON.stringify({ greeting: 'Hallo' }),
-        }],
-        finishReason: { unified: 'tool-calls' as const, raw: 'tool_calls' },
-        usage: { inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 }, outputTokens: { total: 1, text: 0, reasoning: 0 } },
-        response: { modelId: 'mock', timestamp: new Date() },
+        text: "",
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "call-1",
+            toolName: "submitTranslations",
+            input: JSON.stringify({ greeting: "Hallo" }),
+          },
+        ],
+        finishReason: { unified: "tool-calls" as const, raw: "tool_calls" },
+        usage: {
+          inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
+          outputTokens: { total: 1, text: 0, reasoning: 0 },
+        },
+        response: { modelId: "mock", timestamp: new Date() },
         request: { body: {} },
         warnings: [],
       }),
@@ -266,14 +293,14 @@ describe('createToolLoopStrategy', () => {
     });
 
     const ctx = {
-      sourceLocale: 'en',
-      targetLocale: 'de',
-      sourceMap: { greeting: 'Hello' },
+      sourceLocale: "en",
+      targetLocale: "de",
+      sourceMap: { greeting: "Hello" },
       targetMap: {},
-      keys: ['greeting'],
+      keys: ["greeting"],
     };
 
     const result = await Effect.runPromise(strategy.translateChunk(ctx));
-    expect(result).toEqual({ greeting: 'Hallo' });
+    expect(result).toEqual({ greeting: "Hallo" });
   });
 });

package/src/translation/tool-loop-strategy.ts

@@ -1,24 +1,22 @@
-import { ToolLoopAgent, tool, hasToolCall } from 'ai';
-import { Effect, Schedule } from 'effect';
-import { z } from 'zod';
-import type { LanguageModel } from 'ai';
-import type { TranslationContext, TranslationStrategy } from './types.js';
-import { TranslationFailedError } from './types.js';
-import { buildSystemPrompt, buildUserPrompt } from './prompt.js';
+import { ToolLoopAgent, tool, hasToolCall } from "ai";
+import { Effect, Schedule } from "effect";
+import { z } from "zod";
+import type { LanguageModel } from "ai";
+import type { TranslationContext, TranslationStrategy } from "./types.js";
+import { TranslationFailedError } from "./types.js";
+import { buildSystemPrompt, buildUserPrompt } from "./prompt.js";
 
 async function tryTranslateChunk(
   model: LanguageModel,
   ctx: TranslationContext,
 ): Promise<Record<string, string>> {
-  const schema = z.object(
-    Object.fromEntries(ctx.keys.map((key: string) => [key, z.string()])),
-  );
+  const schema = z.object(Object.fromEntries(ctx.keys.map((key: string) => [key, z.string()])));
 
   let captured: Record<string, string> | null = null;
 
   const submitTranslations = tool({
     description:
-      'Submit the final translations for every requested key. Call this exactly once, with every key filled in.',
+      "Submit the final translations for every requested key. Call this exactly once, with every key filled in.",
     inputSchema: schema,
     execute: async (input) => {
       captured = input as Record<string, string>;
@@ -30,18 +28,16 @@ async function tryTranslateChunk(
     model,
     instructions: buildSystemPrompt(ctx.sourceLocale, ctx.targetLocale),
     tools: { submitTranslations },
-    stopWhen: hasToolCall('submitTranslations'),
+    stopWhen: hasToolCall("submitTranslations"),
   });
 
   await agent.generate({ prompt: buildUserPrompt(ctx) });
   if (captured === null) {
-    throw new Error('Agent finished without calling submitTranslations');
+    throw new Error("Agent finished without calling submitTranslations");
   }
-  const missing = ctx.keys.filter(
-    (key: string) => !(key in (captured as Record<string, string>)),
-  );
+  const missing = ctx.keys.filter((key: string) => !(key in (captured as Record<string, string>)));
   if (missing.length > 0) {
-    throw new Error(`Model omitted keys: ${missing.join(', ')}`);
+    throw new Error(`Model omitted keys: ${missing.join(", ")}`);
   }
   return captured;
 }
@@ -51,7 +47,7 @@ export function createToolLoopStrategy(deps: {
   retry: { maxAttempts: number; baseDelayMs: number };
 }): TranslationStrategy {
   return {
-    name: 'tool-loop-agent',
+    name: "tool-loop-agent",
     translateChunk: (ctx: TranslationContext) =>
       Effect.tryPromise({
         try: () => tryTranslateChunk(deps.model, ctx),

package/src/translation/types.test.ts

@@ -1,37 +1,37 @@
-import { describe, expect, it } from 'vitest';
-import { TranslationFailedError } from './types.js';
+import { describe, expect, it } from "vitest";
+import { TranslationFailedError } from "./types.js";
 
-describe('TranslationFailedError', () => {
-  it('carries keys and cause', () => {
-    const err = new TranslationFailedError({ keys: ['a'], cause: new Error('boom') });
-    expect(err._tag).toBe('TranslationFailedError');
-    expect(err.keys).toEqual(['a']);
+describe("TranslationFailedError", () => {
+  it("carries keys and cause", () => {
+    const err = new TranslationFailedError({ keys: ["a"], cause: new Error("boom") });
+    expect(err._tag).toBe("TranslationFailedError");
+    expect(err.keys).toEqual(["a"]);
   });
 
-  it('carries multiple keys', () => {
-    const err = new TranslationFailedError({ keys: ['a', 'b', 'c'], cause: 'network timeout' });
-    expect(err.keys).toEqual(['a', 'b', 'c']);
+  it("carries multiple keys", () => {
+    const err = new TranslationFailedError({ keys: ["a", "b", "c"], cause: "network timeout" });
+    expect(err.keys).toEqual(["a", "b", "c"]);
   });
 
-  it('accepts string cause', () => {
-    const err = new TranslationFailedError({ keys: ['x'], cause: 'rate limited' });
-    expect(err._tag).toBe('TranslationFailedError');
+  it("accepts string cause", () => {
+    const err = new TranslationFailedError({ keys: ["x"], cause: "rate limited" });
+    expect(err._tag).toBe("TranslationFailedError");
   });
 
-  it('accepts Error cause', () => {
-    const cause = new Error('model rejected');
-    const err = new TranslationFailedError({ keys: ['y'], cause });
-    expect(err._tag).toBe('TranslationFailedError');
+  it("accepts Error cause", () => {
+    const cause = new Error("model rejected");
+    const err = new TranslationFailedError({ keys: ["y"], cause });
+    expect(err._tag).toBe("TranslationFailedError");
   });
 
-  it('accepts empty keys array', () => {
-    const err = new TranslationFailedError({ keys: [], cause: 'unknown' });
+  it("accepts empty keys array", () => {
+    const err = new TranslationFailedError({ keys: [], cause: "unknown" });
     expect(err.keys).toEqual([]);
   });
 
-  it('preserves cause object identity when Error', () => {
-    const cause = new Error('specific');
-    const err = new TranslationFailedError({ keys: ['z'], cause });
+  it("preserves cause object identity when Error", () => {
+    const cause = new Error("specific");
+    const err = new TranslationFailedError({ keys: ["z"], cause });
     expect(err.cause).toBe(cause);
   });
 });

package/src/translation/types.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from 'effect';
+import { Data, Effect } from "effect";
 
 export interface TranslationContext {
   readonly sourceLocale: string;
@@ -8,13 +8,13 @@ export interface TranslationContext {
   readonly keys: readonly string[]; // the specific keys to translate in this call
 }
 
-export class TranslationFailedError extends Data.TaggedError('TranslationFailedError')<{
+export class TranslationFailedError extends Data.TaggedError("TranslationFailedError")<{
   readonly keys: readonly string[];
   readonly cause: unknown;
 }> {}
 
 export interface TranslationStrategy {
-  readonly name: 'one-shot' | 'tool-loop-agent';
+  readonly name: "one-shot" | "tool-loop-agent";
   translateChunk(
     ctx: TranslationContext,
   ): Effect.Effect<Record<string, string>, TranslationFailedError>;

package/tsdown.config.ts

@@ -1,7 +1,7 @@
-import { defineConfig } from 'tsdown';
+import { defineConfig } from "tsdown";
 
 export default defineConfig({
-  entry: ['src/index.ts', 'src/cli/main.ts'],
-  format: 'esm',
+  entry: ["src/index.ts", "src/cli/main.ts"],
+  format: "esm",
   dts: true,
 });

package/vitest.config.ts

@@ -1,8 +1,8 @@
-import { defineConfig } from 'vitest/config';
+import { defineConfig } from "vitest/config";
 
 export default defineConfig({
   test: {
-    include: ['src/**/*.test.ts'],
-    environment: 'node',
+    include: ["src/**/*.test.ts"],
+    environment: "node",
   },
 });