transduck 0.1.5 → 0.2.2

package/src/cli.ts

@@ -22,16 +22,41 @@ export interface InitOptions {
   context: string;
   sourceLang: string;
   targetLangs: string[];
+  provider?: number;
 }
 
 export async function runInit(opts: InitOptions): Promise<string> {
-  const config = {
+  const providerChoice = opts.provider ?? 1;
+
+  const config: Record<string, any> = {
     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));
 
@@ -40,7 +65,23 @@ export async function runInit(opts: InitOptions): Promise<string> {
   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 interface TranslateOptions {
@@ -71,13 +112,10 @@ export async function runTranslate(opts: TranslateOptions): Promise<string> {
     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({
@@ -141,14 +179,11 @@ export async function runTranslatePlural(opts: TranslatePluralOptions): Promise<
 
   // 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([
@@ -233,7 +268,6 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
     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;
 
@@ -255,13 +289,11 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
         }
 
         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),
@@ -304,12 +336,10 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
         if (cached !== null) { skipped++; 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({
@@ -348,6 +378,7 @@ export interface ScanOptions {
 export async function runScan(opts: ScanOptions): Promise<string> {
   const cfg = loadConfig(opts.configPath);
   const scanDirs = opts.dirs.length > 0 ? opts.dirs : [process.cwd()];
+  console.log('Scanning...');
   const entries = scanDirectory(scanDirs);
 
   const regular = entries.filter(e => !e.plural);
@@ -391,25 +422,31 @@ export async function runScan(opts: ScanOptions): Promise<string> {
 
   // Warm
   if (opts.warm) {
+    if (entries.length === 0) {
+      lines.push('\nNothing to warm — no translatable strings found.');
+    } else {
     const targetLangs = opts.langs && opts.langs.length > 0
       ? opts.langs.map(l => l.toUpperCase())
       : 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;
     let failed = 0;
+    const total = entries.length * targetLangs.length;
+    let done = 0;
 
     for (const entry of entries) {
       if (entry.plural) {
         const sourceKey = entry.one + '\x00' + entry.other;
         const stringContextHash = hash(entry.context ?? '');
+        const label = (entry.one ?? '').slice(0, 40);
 
         for (const lang of targetLangs) {
+          done++;
           const cachedForms = await store.lookupPlural({
             sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
             projectContextHash, stringContextHash,
@@ -417,17 +454,16 @@ export async function runScan(opts: ScanOptions): Promise<string> {
 
           if (Object.keys(cachedForms).length > 0) {
             skipped++;
+            console.log(`  [${done}/${total}] ${lang} skipped (cached): ${label}`);
             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({
@@ -438,14 +474,18 @@ export async function runScan(opts: ScanOptions): Promise<string> {
               });
             }
             translated++;
+            console.log(`  [${done}/${total}] ${lang} translated: ${label}`);
           } catch {
             failed++;
+            console.log(`  [${done}/${total}] ${lang} failed: ${label}`);
           }
         }
       } else {
         const stringContextHash = hash(entry.context ?? '');
+        const label = (entry.text ?? '').slice(0, 40);
 
         for (const lang of targetLangs) {
+          done++;
           const cached = await store.lookup({
             sourceText: entry.text!, sourceLang: cfg.sourceLang, targetLang: lang,
             projectContextHash, stringContextHash,
@@ -453,16 +493,15 @@ export async function runScan(opts: ScanOptions): Promise<string> {
 
           if (cached !== null) {
             skipped++;
+            console.log(`  [${done}/${total}] ${lang} skipped (cached): ${label}`);
             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({
@@ -471,11 +510,14 @@ export async function runScan(opts: ScanOptions): Promise<string> {
                 translatedText: result, model: cfg.backendModel, status: 'translated',
               });
               translated++;
+              console.log(`  [${done}/${total}] ${lang} translated: ${label}`);
             } else {
               failed++;
+              console.log(`  [${done}/${total}] ${lang} failed: ${label}`);
             }
           } catch {
             failed++;
+            console.log(`  [${done}/${total}] ${lang} failed: ${label}`);
           }
         }
       }
@@ -483,6 +525,7 @@ export async function runScan(opts: ScanOptions): Promise<string> {
 
     store.close();
     lines.push(`\nTranslated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`);
+    } // end if entries.length > 0
   }
 
   if (!opts.warm && !opts.outputPath) {
@@ -533,11 +576,19 @@ 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);
 

package/src/config.ts

@@ -10,7 +10,9 @@ export interface TransduckConfig {
   sourceLang: string;
   targetLangs: string[];
   storagePath: string;
+  provider: string;
   apiKeyEnv: string;
+  tokenEnv: string;
   backendModel: string;
   backendTimeout: number;
   backendMaxRetries: number;
@@ -49,16 +51,31 @@ export function loadConfig(path?: string): TransduckConfig {
   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) => 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/src/handler.ts

@@ -58,7 +58,6 @@ export async function handleTranslationRequest(
   const targetLang = body.language.toUpperCase();
 
   const projectContextHash = hash(cfg.projectContext);
-  const apiKey = process.env[cfg.apiKeyEnv];
 
   const translations: Record<string, string> = {};
   const plurals: Record<string, Record<string, string>> = {};
@@ -84,17 +83,14 @@ export async function handleTranslationRequest(
 
     // Backend call
     try {
-      const translated = await backendTranslate({
-        sourceText: item.text,
-        sourceLang: cfg.sourceLang,
+      const translated = await backendTranslate(
+        item.text,
+        cfg.sourceLang,
         targetLang,
-        projectContext: cfg.projectContext,
-        stringContext: item.context ?? null,
-        apiKey: apiKey!,
-        model: cfg.backendModel,
-        timeout: cfg.backendTimeout,
-        maxRetries: cfg.backendMaxRetries,
-      });
+        cfg.projectContext,
+        item.context ?? null,
+        cfg,
+      );
 
       if (validateTranslation(item.text, translated)) {
         await store.insert({
@@ -138,18 +134,15 @@ export async function handleTranslationRequest(
 
     // Backend call
     try {
-      const forms = await backendTranslatePlural({
-        one: item.one,
-        other: item.other,
-        sourceLang: cfg.sourceLang,
+      const forms = await backendTranslatePlural(
+        item.one,
+        item.other,
+        cfg.sourceLang,
         targetLang,
-        projectContext: cfg.projectContext,
-        stringContext: item.context ?? null,
-        apiKey: apiKey!,
-        model: cfg.backendModel,
-        timeout: cfg.backendTimeout,
-        maxRetries: cfg.backendMaxRetries,
-      });
+        cfg.projectContext,
+        item.context ?? null,
+        cfg,
+      );
 
       for (const [cat, translatedText] of Object.entries(forms)) {
         await store.insertPlural({

package/src/index.ts

@@ -92,14 +92,11 @@ export async function ait(
     });
     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}`);
@@ -192,15 +189,12 @@ export async function aitPlural(
   }
 
   // Cache miss — call backend
-  const apiKey = process.env[cfg.apiKeyEnv];
   try {
-    const forms = await backendTranslatePlural({
+    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,
-    });
+      cfg.sourceLang, state.targetLang,
+      cfg.projectContext, context ?? null, cfg,
+    );
 
     // Validate and store each form
     const validCategories = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);

package/src/providers/claude-api.ts

@@ -0,0 +1,77 @@
+/**
+ * Claude API translation provider.
+ * Uses the @anthropic-ai/sdk package (optional peer dependency, lazy imported).
+ */
+
+import type { TransduckConfig } from '../config.js';
+import { buildMessages, buildPluralMessages } from './prompts.js';
+
+async function getClient(config: TransduckConfig) {
+  let Anthropic: any;
+  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: string,
+  sourceLang: string,
+  targetLang: string,
+  projectContext: string,
+  stringContext: string | null,
+  config: TransduckConfig,
+): Promise<string> {
+  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: string,
+  other: string,
+  sourceLang: string,
+  targetLang: string,
+  projectContext: string,
+  stringContext: string | null,
+  config: TransduckConfig,
+): Promise<Record<string, string>> {
+  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/src/providers/claude-code.ts

@@ -0,0 +1,72 @@
+/**
+ * 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';
+import { buildSinglePrompt, buildPluralSinglePrompt } from './prompts.js';
+
+function ensureToken(config: TransduckConfig): void {
+  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: string): Promise<string> {
+  let query: any;
+  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 as any).result.trim();
+    }
+  }
+  throw new Error('No result from Claude Agent SDK');
+}
+
+export async function translate(
+  sourceText: string,
+  sourceLang: string,
+  targetLang: string,
+  projectContext: string,
+  stringContext: string | null,
+  config: TransduckConfig,
+): Promise<string> {
+  ensureToken(config);
+  const prompt = buildSinglePrompt({
+    sourceText, sourceLang, targetLang, projectContext, stringContext,
+  });
+  return translateWithSdk(prompt);
+}
+
+export async function translatePlural(
+  one: string,
+  other: string,
+  sourceLang: string,
+  targetLang: string,
+  projectContext: string,
+  stringContext: string | null,
+  config: TransduckConfig,
+): Promise<Record<string, string>> {
+  ensureToken(config);
+  const prompt = buildPluralSinglePrompt({
+    one, other, sourceLang, targetLang, projectContext, stringContext,
+  });
+  const raw = await translateWithSdk(prompt);
+  return JSON.parse(raw);
+}

package/src/providers/index.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 async function getProvider(config: TransduckConfig): Promise<TranslationProvider> {
+  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`
+    );
+  }
+}