transduck 0.1.5 → 0.2.1

package/dist/backend.d.ts

@@ -1,40 +1,7 @@
-interface BuildMessagesParams {
-    sourceText: string;
-    sourceLang: string;
-    targetLang: string;
-    projectContext: string;
-    stringContext: string | null;
-}
-interface TranslateParams extends BuildMessagesParams {
-    apiKey: string;
-    model: string;
-    timeout: number;
-    maxRetries: number;
-    _clientOverride?: any;
-}
-interface BuildPluralMessagesParams {
-    one: string;
-    other: string;
-    sourceLang: string;
-    targetLang: string;
-    projectContext: string;
-    stringContext: string | null;
-}
-interface TranslatePluralParams extends BuildPluralMessagesParams {
-    apiKey: string;
-    model: string;
-    timeout: number;
-    maxRetries: number;
-    _clientOverride?: any;
-}
-export declare function buildMessages(params: BuildMessagesParams): Array<{
-    role: string;
-    content: string;
-}>;
-export declare function translate(params: TranslateParams): Promise<string>;
-export declare function buildPluralMessages(params: BuildPluralMessagesParams): Array<{
-    role: string;
-    content: string;
-}>;
-export declare function translatePlural(params: TranslatePluralParams): Promise<Record<string, string>>;
-export {};
+/**
+ * Translation backend router -- delegates to the configured provider.
+ */
+import type { TransduckConfig } from './config.js';
+export { buildMessages, buildPluralMessages } from './providers/prompts.js';
+export declare function translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<string>;
+export declare function translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<Record<string, string>>;

package/dist/backend.js

@@ -1,89 +1,14 @@
-import OpenAI from 'openai';
-/* eslint-disable no-template-curly-in-string */
-const SYSTEM_TEMPLATE = 'You are a professional translator. Translate the given text from {source_lang} ' +
-    'to {target_lang}. Return ONLY the translated text, nothing else. Preserve any ' +
-    'placeholders like {name}, {{count}}, %s, ${value} exactly as they appear. ' +
-    'Preserve brand names. Match the tone and formality of the original.\n\n' +
-    'Project context: {project_context}';
-const USER_TEMPLATE = `Translate: "{source_text}"\nString context: {string_context}`;
-const PLURAL_SYSTEM_TEMPLATE = 'You are a professional translator. You will be given two plural forms ' +
-    '(one and other) in {source_lang}. Generate ALL plural forms needed in ' +
-    '{target_lang} according to CLDR plural rules. Return ONLY a JSON object ' +
-    'mapping plural categories to translated strings. Do not include explanation.\n\n' +
-    'CRITICAL: Placeholders like {count}, {name}, %s, ${value} are SOFTWARE VARIABLES ' +
-    'that will be replaced by code at runtime. You MUST include them exactly as written ' +
-    'in EVERY plural form, even for zero, one, and two categories where the language ' +
-    'would not normally use a numeral. For example, for Arabic zero: use "{count} ..." ' +
-    'not "لا توجد ...". For Arabic one: use "{count} ..." not "واحدة ...".\n\n' +
-    'Preserve brand names. Match the tone and formality of the original.\n\n' +
-    'CLDR plural categories are: zero, one, two, few, many, other.\n' +
-    'Only include categories that {target_lang} actually uses.\n\n' +
-    'Project context: {project_context}';
-const PLURAL_USER_TEMPLATE = 'Source one form: "{one}"\n' +
-    'Source other form: "{other}"\n' +
-    'String context: {string_context}';
-function safeRender(template, vars) {
-    let result = template;
-    for (const [key, value] of Object.entries(vars)) {
-        result = result.replaceAll(`{${key}}`, value);
-    }
-    return result;
-}
-export function buildMessages(params) {
-    const systemMsg = SYSTEM_TEMPLATE
-        .replace('{source_lang}', params.sourceLang)
-        .replace('{target_lang}', params.targetLang)
-        .replace('{project_context}', params.projectContext);
-    const userMsg = USER_TEMPLATE
-        .replace('{source_text}', params.sourceText)
-        .replace('{string_context}', params.stringContext || 'none');
-    return [
-        { role: 'system', content: systemMsg },
-        { role: 'user', content: userMsg },
-    ];
-}
-export async function translate(params) {
-    const client = params._clientOverride ?? new OpenAI({
-        apiKey: params.apiKey,
-        timeout: params.timeout * 1000,
-        maxRetries: params.maxRetries,
-    });
-    const messages = buildMessages(params);
-    const response = await client.chat.completions.create({
-        model: params.model,
-        messages,
-        temperature: 0.3,
-    });
-    return response.choices[0].message.content.trim();
-}
-export function buildPluralMessages(params) {
-    const systemMsg = safeRender(PLURAL_SYSTEM_TEMPLATE, {
-        source_lang: params.sourceLang,
-        target_lang: params.targetLang,
-        project_context: params.projectContext,
-    });
-    const userMsg = safeRender(PLURAL_USER_TEMPLATE, {
-        one: params.one,
-        other: params.other,
-        string_context: params.stringContext || 'none',
-    });
-    return [
-        { role: 'system', content: systemMsg },
-        { role: 'user', content: userMsg },
-    ];
-}
-export async function translatePlural(params) {
-    const client = params._clientOverride ?? new OpenAI({
-        apiKey: params.apiKey,
-        timeout: params.timeout * 1000,
-        maxRetries: params.maxRetries,
-    });
-    const messages = buildPluralMessages(params);
-    const response = await client.chat.completions.create({
-        model: params.model,
-        messages,
-        temperature: 0.3,
-    });
-    const raw = response.choices[0].message.content.trim();
-    return JSON.parse(raw);
+/**
+ * Translation backend router -- delegates to the configured provider.
+ */
+import { getProvider } from './providers/index.js';
+// Re-export prompts for backward compat (tests import buildMessages from backend)
+export { buildMessages, buildPluralMessages } from './providers/prompts.js';
+export async function translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride) {
+    const provider = await getProvider(config);
+    return provider.translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride);
+}
+export async function translatePlural(one, other, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride) {
+    const provider = await getProvider(config);
+    return provider.translatePlural(one, other, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride);
 }

package/dist/cli.d.ts

@@ -6,6 +6,7 @@ export interface InitOptions {
     context: string;
     sourceLang: string;
     targetLangs: string[];
+    provider?: number;
 }
 export declare function runInit(opts: InitOptions): Promise<string>;
 export interface TranslateOptions {

package/dist/cli.js

@@ -14,19 +14,53 @@ function hash(text) {
     return createHash('sha256').update(text).digest('hex');
 }
 export async function runInit(opts) {
+    const providerChoice = opts.provider ?? 1;
     const config = {
         project: { name: opts.name, context: opts.context },
         languages: { source: opts.sourceLang.toUpperCase(), targets: opts.targetLangs.map(l => l.toUpperCase()) },
         storage: { path: './translations.duckdb' },
-        backend: { api_key_env: 'OPENAI_API_KEY', model: 'gpt-4.1-mini', timeout_seconds: 10, max_retries: 2 },
     };
+    if (providerChoice === 2) {
+        config.backend = {
+            provider: 'claude_api',
+            api_key_env: 'ANTHROPIC_API_KEY',
+            model: 'claude-haiku-4-5-20251001',
+            timeout_seconds: 10,
+            max_retries: 2,
+        };
+    }
+    else if (providerChoice === 3) {
+        config.backend = {
+            provider: 'claude_code',
+            token_env: 'CLAUDE_CODE_OAUTH_TOKEN',
+        };
+    }
+    else {
+        config.backend = {
+            provider: 'openai',
+            api_key_env: 'OPENAI_API_KEY',
+            model: 'gpt-4.1-mini',
+            timeout_seconds: 10,
+            max_retries: 2,
+        };
+    }
     const configPath = join(opts.dir, 'transduck.yaml');
     writeFileSync(configPath, yamlStringify(config));
     const dbPath = join(opts.dir, 'translations.duckdb');
     const store = new TranslationStore(dbPath);
     await store.initialize();
     store.close();
-    return `Created ${configPath}\nCreated ${dbPath}`;
+    const lines = [`Created ${configPath}`, `Created ${dbPath}`];
+    if (providerChoice === 2) {
+        lines.push('', 'Add to your .env file: ANTHROPIC_API_KEY=your-key-here');
+    }
+    else if (providerChoice === 3) {
+        lines.push('', "Run 'claude setup-token' to get your OAuth token, then add to your .env file:", '  CLAUDE_CODE_OAUTH_TOKEN=your-token-here', '', 'Note: claude_code works for CLI warming only. Your app will run in read-only mode.');
+    }
+    else {
+        lines.push('', 'Add to your .env file: OPENAI_API_KEY=your-key-here');
+    }
+    return lines.join('\n');
 }
 export async function runTranslate(opts) {
     const cfg = loadConfig(opts.configPath);
@@ -43,13 +77,7 @@ export async function runTranslate(opts) {
         store.close();
         return `[cached] ${interpolateVars(cached, opts.vars)}`;
     }
-    const apiKey = process.env[cfg.apiKeyEnv];
-    const translated = await backendTranslate({
-        sourceText: opts.text, sourceLang: cfg.sourceLang, targetLang,
-        projectContext: cfg.projectContext, stringContext: opts.stringContext ?? null,
-        apiKey: apiKey, model: cfg.backendModel,
-        timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-    });
+    const translated = await backendTranslate(opts.text, cfg.sourceLang, targetLang, cfg.projectContext, opts.stringContext ?? null, cfg);
     if (!validateTranslation(opts.text, translated)) {
         await store.insert({
             sourceText: opts.text, sourceLang: cfg.sourceLang, targetLang,
@@ -93,14 +121,7 @@ export async function runTranslatePlural(opts) {
     }
     // Cache miss — call backend
     try {
-        const apiKey = process.env[cfg.apiKeyEnv];
-        const forms = await backendTranslatePlural({
-            one: opts.one, other: opts.other,
-            sourceLang: cfg.sourceLang, targetLang,
-            projectContext: cfg.projectContext, stringContext: opts.stringContext ?? null,
-            apiKey: apiKey, model: cfg.backendModel,
-            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-        });
+        const forms = await backendTranslatePlural(opts.one, opts.other, cfg.sourceLang, targetLang, cfg.projectContext, opts.stringContext ?? null, cfg);
         // Validate each form
         const sourcePlaceholders = new Set([
             ...extractPlaceholders(opts.one),
@@ -181,7 +202,6 @@ export async function runWarm(opts) {
     else {
         entries = content.split('\n').filter(l => l.trim()).map(text => ({ text: text.trim() }));
     }
-    const apiKey = process.env[cfg.apiKeyEnv];
     const projectContextHash = hash(cfg.projectContext);
     let translated = 0, skipped = 0, failed = 0;
     for (const entry of entries) {
@@ -199,13 +219,7 @@ export async function runWarm(opts) {
                     continue;
                 }
                 try {
-                    const forms = await backendTranslatePlural({
-                        one: entry.one, other: entry.other,
-                        sourceLang: cfg.sourceLang, targetLang: lang,
-                        projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                        apiKey: apiKey, model: cfg.backendModel,
-                        timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-                    });
+                    const forms = await backendTranslatePlural(entry.one, entry.other, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                     const sourcePlaceholders = new Set([
                         ...extractPlaceholders(entry.one),
                         ...extractPlaceholders(entry.other),
@@ -254,12 +268,7 @@ export async function runWarm(opts) {
                     continue;
                 }
                 try {
-                    const result = await backendTranslate({
-                        sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
-                        projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                        apiKey: apiKey, model: cfg.backendModel,
-                        timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-                    });
+                    const result = await backendTranslate(entry.text, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                     if (validateTranslation(entry.text, result)) {
                         await store.insert({
                             sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
@@ -333,7 +342,6 @@ export async function runScan(opts) {
             : cfg.targetLangs;
         const store = new TranslationStore(cfg.storagePath);
         await store.initialize();
-        const apiKey = process.env[cfg.apiKeyEnv];
         const projectContextHash = hash(cfg.projectContext);
         let translated = 0;
         let skipped = 0;
@@ -352,13 +360,7 @@ export async function runScan(opts) {
                         continue;
                     }
                     try {
-                        const forms = await backendTranslatePlural({
-                            one: entry.one, other: entry.other,
-                            sourceLang: cfg.sourceLang, targetLang: lang,
-                            projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                            apiKey: apiKey, model: cfg.backendModel,
-                            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-                        });
+                        const forms = await backendTranslatePlural(entry.one, entry.other, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                         for (const [cat, translatedText] of Object.entries(forms)) {
                             await store.insertPlural({
                                 sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
@@ -386,12 +388,7 @@ export async function runScan(opts) {
                         continue;
                     }
                     try {
-                        const result = await backendTranslate({
-                            sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
-                            projectContext: cfg.projectContext, stringContext: entry.context ?? null,
-                            apiKey: apiKey, model: cfg.backendModel,
-                            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-                        });
+                        const result = await backendTranslate(entry.text, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                         if (validateTranslation(entry.text, result)) {
                             await store.insert({
                                 sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
@@ -450,10 +447,17 @@ program.command('init')
     const context = await ask('Project context: ');
     const sourceLang = await ask('Source language (e.g. EN): ');
     const targetsRaw = await ask('Target languages (comma-separated): ');
+    console.log('\nTranslation provider:');
+    console.log('  1. OpenAI (requires API key)');
+    console.log('  2. Claude API (requires API key)');
+    console.log('  3. Claude Code (uses your Claude Code subscription, warming only)');
+    const providerRaw = await ask('Select provider [1]: ');
+    const providerChoice = parseInt(providerRaw, 10) || 1;
     rl.close();
     const output = await runInit({
         dir, name, context, sourceLang,
         targetLangs: targetsRaw.split(',').map(s => s.trim()),
+        provider: providerChoice,
     });
     console.log(output);
     const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });

package/dist/config.d.ts

@@ -4,7 +4,9 @@ export interface TransduckConfig {
     sourceLang: string;
     targetLangs: string[];
     storagePath: string;
+    provider: string;
     apiKeyEnv: string;
+    tokenEnv: string;
     backendModel: string;
     backendTimeout: number;
     backendMaxRetries: number;

package/dist/config.js

@@ -29,16 +29,29 @@ export function loadConfig(path) {
     const raw = parseYaml(readFileSync(configPath, 'utf-8'));
     const configDir = dirname(configPath);
     const storagePath = resolve(configDir, raw.storage.path);
+    const backend = raw.backend ?? {};
+    const provider = backend.provider ?? 'openai';
+    const apiKeyEnv = backend.api_key_env ?? 'OPENAI_API_KEY';
+    const tokenEnv = backend.token_env ?? 'CLAUDE_CODE_OAUTH_TOKEN';
+    const backendModel = backend.model ?? 'gpt-4.1-mini';
+    const backendTimeout = backend.timeout_seconds ?? 10;
+    const backendMaxRetries = backend.max_retries ?? 2;
+    let readOnly = raw.runtime?.read_only ?? false;
+    if (provider === 'claude_code') {
+        readOnly = true;
+    }
     return {
         projectName: raw.project.name,
         projectContext: raw.project.context,
         sourceLang: String(raw.languages.source).toUpperCase(),
         targetLangs: raw.languages.targets.map((l) => String(l).toUpperCase()),
         storagePath,
-        apiKeyEnv: raw.backend.api_key_env,
-        backendModel: raw.backend.model,
-        backendTimeout: raw.backend.timeout_seconds,
-        backendMaxRetries: raw.backend.max_retries,
-        readOnly: raw.runtime?.read_only ?? false,
+        provider,
+        apiKeyEnv,
+        tokenEnv,
+        backendModel,
+        backendTimeout,
+        backendMaxRetries,
+        readOnly,
     };
 }

package/dist/handler.js

@@ -27,7 +27,6 @@ export async function handleTranslationRequest(body, configPath) {
     const store = await getStore(configPath);
     const targetLang = body.language.toUpperCase();
     const projectContextHash = hash(cfg.projectContext);
-    const apiKey = process.env[cfg.apiKeyEnv];
     const translations = {};
     const plurals = {};
     // Translate regular strings
@@ -48,17 +47,7 @@ export async function handleTranslationRequest(body, configPath) {
         }
         // Backend call
         try {
-            const translated = await backendTranslate({
-                sourceText: item.text,
-                sourceLang: cfg.sourceLang,
-                targetLang,
-                projectContext: cfg.projectContext,
-                stringContext: item.context ?? null,
-                apiKey: apiKey,
-                model: cfg.backendModel,
-                timeout: cfg.backendTimeout,
-                maxRetries: cfg.backendMaxRetries,
-            });
+            const translated = await backendTranslate(item.text, cfg.sourceLang, targetLang, cfg.projectContext, item.context ?? null, cfg);
             if (validateTranslation(item.text, translated)) {
                 await store.insert({
                     sourceText: item.text,
@@ -99,18 +88,7 @@ export async function handleTranslationRequest(body, configPath) {
         }
         // Backend call
         try {
-            const forms = await backendTranslatePlural({
-                one: item.one,
-                other: item.other,
-                sourceLang: cfg.sourceLang,
-                targetLang,
-                projectContext: cfg.projectContext,
-                stringContext: item.context ?? null,
-                apiKey: apiKey,
-                model: cfg.backendModel,
-                timeout: cfg.backendTimeout,
-                maxRetries: cfg.backendMaxRetries,
-            });
+            const forms = await backendTranslatePlural(item.one, item.other, cfg.sourceLang, targetLang, cfg.projectContext, item.context ?? null, cfg);
             for (const [cat, translatedText] of Object.entries(forms)) {
                 await store.insertPlural({
                     sourceText: sourceKey,

package/dist/index.js

@@ -67,14 +67,8 @@ export async function ait(sourceText, context, vars) {
         });
         if (rechecked !== null)
             return rechecked;
-        const apiKey = process.env[cfg.apiKeyEnv];
         try {
-            const translated = await backendTranslate({
-                sourceText, sourceLang: cfg.sourceLang, targetLang: state.targetLang,
-                projectContext: cfg.projectContext, stringContext: context ?? null,
-                apiKey: apiKey, model: cfg.backendModel,
-                timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-            });
+            const translated = await backendTranslate(sourceText, cfg.sourceLang, state.targetLang, cfg.projectContext, context ?? null, cfg);
             if (!validateTranslation(sourceText, translated)) {
                 console.warn(`[transduck] Validation failed for: ${sourceText} -> ${translated}`);
                 await state.store.insert({
@@ -153,15 +147,8 @@ export async function aitPlural(one, other, count, opts) {
         return interpolateVars(fallback, vars);
     }
     // Cache miss — call backend
-    const apiKey = process.env[cfg.apiKeyEnv];
     try {
-        const forms = await backendTranslatePlural({
-            one, other,
-            sourceLang: cfg.sourceLang, targetLang: state.targetLang,
-            projectContext: cfg.projectContext, stringContext: context ?? null,
-            apiKey: apiKey, model: cfg.backendModel,
-            timeout: cfg.backendTimeout, maxRetries: cfg.backendMaxRetries,
-        });
+        const forms = await backendTranslatePlural(one, other, cfg.sourceLang, state.targetLang, cfg.projectContext, context ?? null, cfg);
         // Validate and store each form
         const validCategories = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
         const sourcePlaceholders = new Set([

package/dist/providers/claude-api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Claude API translation provider.
+ * Uses the @anthropic-ai/sdk package (optional peer dependency, lazy imported).
+ */
+import type { TransduckConfig } from '../config.js';
+export declare function translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig): Promise<string>;
+export declare function translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig): Promise<Record<string, string>>;

package/dist/providers/claude-api.js

@@ -0,0 +1,50 @@
+/**
+ * Claude API translation provider.
+ * Uses the @anthropic-ai/sdk package (optional peer dependency, lazy imported).
+ */
+import { buildMessages, buildPluralMessages } from './prompts.js';
+async function getClient(config) {
+    let Anthropic;
+    try {
+        // @ts-ignore — optional peer dependency, may not be installed
+        const mod = await import('@anthropic-ai/sdk');
+        Anthropic = mod.default ?? mod.Anthropic;
+    }
+    catch {
+        throw new Error('Install the required package: npm install @anthropic-ai/sdk');
+    }
+    const apiKey = process.env[config.apiKeyEnv];
+    if (!apiKey) {
+        throw new Error(`Set ${config.apiKeyEnv} environment variable`);
+    }
+    return new Anthropic({ apiKey });
+}
+export async function translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config) {
+    const client = await getClient(config);
+    const messages = buildMessages({
+        sourceText, sourceLang, targetLang, projectContext, stringContext,
+    });
+    const response = await client.messages.create({
+        model: config.backendModel,
+        max_tokens: 1024,
+        temperature: 0.3,
+        system: messages[0].content,
+        messages: [{ role: 'user', content: messages[1].content }],
+    });
+    return response.content[0].text.trim();
+}
+export async function translatePlural(one, other, sourceLang, targetLang, projectContext, stringContext, config) {
+    const client = await getClient(config);
+    const messages = buildPluralMessages({
+        one, other, sourceLang, targetLang, projectContext, stringContext,
+    });
+    const response = await client.messages.create({
+        model: config.backendModel,
+        max_tokens: 2048,
+        temperature: 0.3,
+        system: messages[0].content,
+        messages: [{ role: 'user', content: messages[1].content }],
+    });
+    const raw = response.content[0].text.trim();
+    return JSON.parse(raw);
+}

package/dist/providers/claude-code.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Claude Code translation provider (uses Claude Agent SDK with subscription auth).
+ * Uses the @anthropic-ai/claude-agent-sdk package (optional peer dependency, lazy imported).
+ * Already async in JS — no asyncio bridge needed like Python.
+ */
+import type { TransduckConfig } from '../config.js';
+export declare function translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig): Promise<string>;
+export declare function translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig): Promise<Record<string, string>>;

package/dist/providers/claude-code.js

@@ -0,0 +1,47 @@
+/**
+ * Claude Code translation provider (uses Claude Agent SDK with subscription auth).
+ * Uses the @anthropic-ai/claude-agent-sdk package (optional peer dependency, lazy imported).
+ * Already async in JS — no asyncio bridge needed like Python.
+ */
+import { buildSinglePrompt, buildPluralSinglePrompt } from './prompts.js';
+function ensureToken(config) {
+    const token = process.env[config.tokenEnv];
+    if (!token) {
+        throw new Error(`Set ${config.tokenEnv} \u2014 run 'claude setup-token' to get your OAuth token`);
+    }
+}
+async function translateWithSdk(prompt) {
+    let query;
+    try {
+        // @ts-ignore — optional peer dependency, may not be installed
+        const mod = await import('@anthropic-ai/claude-agent-sdk');
+        query = mod.query;
+    }
+    catch {
+        throw new Error('Install the required package: npm install @anthropic-ai/claude-agent-sdk');
+    }
+    for await (const message of query({
+        prompt,
+        options: { allowedTools: [] },
+    })) {
+        if ('result' in message) {
+            return message.result.trim();
+        }
+    }
+    throw new Error('No result from Claude Agent SDK');
+}
+export async function translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config) {
+    ensureToken(config);
+    const prompt = buildSinglePrompt({
+        sourceText, sourceLang, targetLang, projectContext, stringContext,
+    });
+    return translateWithSdk(prompt);
+}
+export async function translatePlural(one, other, sourceLang, targetLang, projectContext, stringContext, config) {
+    ensureToken(config);
+    const prompt = buildPluralSinglePrompt({
+        one, other, sourceLang, targetLang, projectContext, stringContext,
+    });
+    const raw = await translateWithSdk(prompt);
+    return JSON.parse(raw);
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Translation provider abstraction.
+ */
+import type { TransduckConfig } from '../config.js';
+export interface TranslationProvider {
+    translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<string>;
+    translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<Record<string, string>>;
+}
+/**
+ * Return the provider module for the configured provider.
+ */
+export declare function getProvider(config: TransduckConfig): Promise<TranslationProvider>;

package/dist/providers/index.js

@@ -0,0 +1,20 @@
+/**
+ * Translation provider abstraction.
+ */
+/**
+ * Return the provider module for the configured provider.
+ */
+export async function getProvider(config) {
+    if (config.provider === 'openai') {
+        return await import('./openai-provider.js');
+    }
+    else if (config.provider === 'claude_api') {
+        return await import('./claude-api.js');
+    }
+    else if (config.provider === 'claude_code') {
+        return await import('./claude-code.js');
+    }
+    else {
+        throw new Error(`Unknown provider: ${config.provider}. Valid: openai, claude_api, claude_code`);
+    }
+}

package/dist/providers/openai-provider.d.ts

@@ -0,0 +1,6 @@
+/**
+ * OpenAI translation provider.
+ */
+import type { TransduckConfig } from '../config.js';
+export declare function translate(sourceText: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<string>;
+export declare function translatePlural(one: string, other: string, sourceLang: string, targetLang: string, projectContext: string, stringContext: string | null, config: TransduckConfig, _clientOverride?: any): Promise<Record<string, string>>;