transduck 0.5.2 → 0.6.0

package/dist/shared-store.js

@@ -0,0 +1,126 @@
+import { createHash } from 'crypto';
+const TABLE_NAME = 'transduck_translations';
+const CREATE_TABLE = `
+CREATE TABLE IF NOT EXISTS ${TABLE_NAME} (
+    source_lang TEXT NOT NULL,
+    target_lang TEXT NOT NULL,
+    content_hash TEXT NOT NULL,
+    plural_category TEXT NOT NULL DEFAULT '',
+    source_text TEXT NOT NULL,
+    translated_text TEXT NOT NULL,
+    model TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    project_context_hash TEXT NOT NULL,
+    string_context_hash TEXT NOT NULL,
+    string_context TEXT NOT NULL DEFAULT '',
+    PRIMARY KEY (source_lang, target_lang, content_hash, plural_category)
+)`;
+function contentHash(sourceText, projectContextHash, stringContextHash) {
+    return createHash('sha256')
+        .update(sourceText + '\x00' + projectContextHash + '\x00' + stringContextHash)
+        .digest('hex');
+}
+export class SharedStore {
+    pool;
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    async initialize() {
+        if (!this.pool) {
+            let pg;
+            try {
+                pg = await import('pg');
+            }
+            catch {
+                throw new Error('pg is required for shared Postgres storage. Install it with: npm install pg');
+            }
+            const Pool = pg.default?.Pool ?? pg.Pool;
+            this.pool = new Pool({ connectionString: this.url });
+        }
+        await this.getPool().query(CREATE_TABLE);
+    }
+    getPool() {
+        if (!this.pool)
+            throw new Error('SharedStore not initialized. Call initialize() first.');
+        return this.pool;
+    }
+    async lookup(params) {
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const result = await this.getPool().query(`SELECT translated_text FROM ${TABLE_NAME}
+       WHERE source_lang = $1 AND target_lang = $2 AND content_hash = $3
+       AND plural_category = '' AND status = 'translated'`, [params.sourceLang, params.targetLang, chash]);
+        if (result.rows.length > 0) {
+            return result.rows[0].translated_text;
+        }
+        const altResult = await this.getPool().query(`SELECT 1 FROM ${TABLE_NAME}
+       WHERE source_text = $1 AND source_lang = $2 AND target_lang = $3
+       AND status = 'translated' LIMIT 1`, [params.sourceText, params.sourceLang, params.targetLang]);
+        if (altResult.rows.length > 0) {
+            console.debug(`Translation exists in shared store for '${params.sourceText}' (${params.sourceLang}→${params.targetLang}) but with a different project context hash. Check project.context in transduck.yaml.`);
+        }
+        return null;
+    }
+    async insert(params) {
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        await this.getPool().query(`INSERT INTO ${TABLE_NAME}
+       (source_lang, target_lang, content_hash, plural_category, source_text,
+        translated_text, model, status, created_at, project_context_hash,
+        string_context_hash, string_context)
+       VALUES ($1, $2, $3, '', $4, $5, $6, $7, $8, $9, $10, $11)
+       ON CONFLICT DO NOTHING`, [
+            params.sourceLang, params.targetLang, chash,
+            params.sourceText, params.translatedText, params.model, params.status,
+            new Date().toISOString(),
+            params.projectContextHash, params.stringContextHash, params.stringContext ?? '',
+        ]);
+    }
+    async lookupPlural(params) {
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        const result = await this.getPool().query(`SELECT plural_category, translated_text FROM ${TABLE_NAME}
+       WHERE source_lang = $1 AND target_lang = $2 AND content_hash = $3
+       AND plural_category != '' AND status = 'translated'`, [params.sourceLang, params.targetLang, chash]);
+        const forms = {};
+        for (const row of result.rows) {
+            forms[row.plural_category] = row.translated_text;
+        }
+        return forms;
+    }
+    async insertPlural(params) {
+        const chash = contentHash(params.sourceText, params.projectContextHash, params.stringContextHash);
+        await this.getPool().query(`INSERT INTO ${TABLE_NAME}
+       (source_lang, target_lang, content_hash, plural_category, source_text,
+        translated_text, model, status, created_at, project_context_hash,
+        string_context_hash, string_context)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       ON CONFLICT DO NOTHING`, [
+            params.sourceLang, params.targetLang, chash, params.pluralCategory,
+            params.sourceText, params.translatedText, params.model, params.status,
+            new Date().toISOString(),
+            params.projectContextHash, params.stringContextHash, params.stringContext ?? '',
+        ]);
+    }
+    async stats() {
+        const pool = this.getPool();
+        const result = await pool.query(`SELECT target_lang, status, COUNT(*) as count FROM ${TABLE_NAME} GROUP BY target_lang, status`);
+        let totalTranslations = 0;
+        let totalFailed = 0;
+        const byLanguage = {};
+        for (const row of result.rows) {
+            const count = parseInt(row.count, 10);
+            if (row.status === 'translated') {
+                totalTranslations += count;
+                byLanguage[row.target_lang] = (byLanguage[row.target_lang] ?? 0) + count;
+            }
+            else if (row.status === 'failed') {
+                totalFailed += count;
+            }
+        }
+        return { totalTranslations, totalFailed, byLanguage };
+    }
+    async close() {
+        if (this.pool)
+            await this.pool.end();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "transduck",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "AI-native translation tool using source text as keys",
   "type": "module",
   "main": "./dist/index.js",
@@ -44,6 +44,7 @@
   "peerDependencies": {
     "@anthropic-ai/claude-agent-sdk": ">=0.1.0",
     "@anthropic-ai/sdk": ">=0.30.0",
+    "pg": ">=8.0.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },
@@ -59,6 +60,9 @@
     },
     "@anthropic-ai/claude-agent-sdk": {
       "optional": true
+    },
+    "pg": {
+      "optional": true
     }
   }
 }

package/src/backend.ts

@@ -29,6 +29,16 @@ function checkApiKey(config: TransduckConfig): void {
   }
 }
 
+export async function detectLanguage(
+  text: string,
+  config: TransduckConfig,
+  _clientOverride?: any,
+): Promise<string> {
+  if (!_clientOverride) checkApiKey(config);
+  const provider = await getProvider(config);
+  return provider.detectLanguage(text, config, _clientOverride);
+}
+
 export async function translate(
   sourceText: string,
   sourceLang: string,

package/src/cli.ts

@@ -7,6 +7,7 @@ import { Command } from 'commander';
 import { stringify as yamlStringify } from 'yaml';
 import { loadConfig } from './config.js';
 import { TranslationStore } from './storage.js';
+import { SharedStore } from './shared-store.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural } from './backend.js';
 import { validateTranslation, extractPlaceholders } from './validation.js';
 import { getPluralCategory, interpolateVars } from './plural.js';
@@ -23,15 +24,21 @@ export interface InitOptions {
   sourceLang: string;
   targetLangs: string[];
   provider?: number;
+  sharedUrl?: string;
 }
 
 export async function runInit(opts: InitOptions): Promise<string> {
   const providerChoice = opts.provider ?? 1;
 
+  const storage: Record<string, string> = { path: './translations.db' };
+  if (opts.sharedUrl) {
+    storage.shared_url = opts.sharedUrl;
+  }
+
   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.db' },
+    storage,
   };
 
   if (providerChoice === 2) {
@@ -259,6 +266,17 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
   const store = new TranslationStore(cfg.storagePath);
   await store.initialize();
 
+  let shared: SharedStore | null = null;
+  if (cfg.sharedUrl) {
+    try {
+      shared = new SharedStore(cfg.sharedUrl);
+      await shared.initialize();
+    } catch (err) {
+      console.warn(`[transduck] Could not connect to shared store: ${(err as Error).message}`);
+      shared = null;
+    }
+  }
+
   const content = readFileSync(opts.filePath, 'utf-8');
   let entries: Array<any>;
 
@@ -311,12 +329,14 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
               if (!translatedPhs.has(p)) { allPresent = false; break; }
             }
 
-            await store.insertPlural({
+            const pluralParams = {
               sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
               projectContextHash, stringContextHash, stringContext: entry.context ?? '',
               pluralCategory: cat, translatedText: translatedText as string,
               model: cfg.backendModel, status: allPresent ? 'translated' : 'failed',
-            });
+            };
+            await store.insertPlural(pluralParams);
+            if (shared) await shared.insertPlural(pluralParams);
             anyStored = true;
           }
 
@@ -342,18 +362,22 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
           );
 
           if (validateTranslation(entry.text, result)) {
-            await store.insert({
+            const insertParams = {
               sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
               projectContextHash, stringContextHash, stringContext: entry.context ?? '',
               translatedText: result, model: cfg.backendModel, status: 'translated',
-            });
+            };
+            await store.insert(insertParams);
+            if (shared) await shared.insert(insertParams);
             translated++;
           } else {
-            await store.insert({
+            const insertParams = {
               sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
               projectContextHash, stringContextHash, stringContext: entry.context ?? '',
               translatedText: result, model: cfg.backendModel, status: 'failed',
-            });
+            };
+            await store.insert(insertParams);
+            if (shared) await shared.insert(insertParams);
             failed++;
           }
         } catch {
@@ -364,6 +388,7 @@ export async function runWarm(opts: WarmOptions): Promise<string> {
   }
 
   store.close();
+  if (shared) await shared.close();
   return `Translated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`;
 }
 
@@ -595,23 +620,47 @@ export async function runStats(opts: StatsOptions): Promise<string> {
 
   const st = await store.stats();
   const lines: string[] = [
-    `Total translations: ${st.totalTranslations}`,
-    `Failed translations: ${st.totalFailed}`,
+    'Local store:',
+    `  Total translations: ${st.totalTranslations}`,
+    `  Failed translations: ${st.totalFailed}`,
   ];
   if (Object.keys(st.byLanguage).length > 0) {
-    lines.push('By language:');
+    lines.push('  By language:');
     for (const [lang, count] of Object.entries(st.byLanguage).sort()) {
-      lines.push(`  ${lang}: ${count}`);
+      lines.push(`    ${lang}: ${count}`);
     }
   }
   store.close();
+
+  if (cfg.sharedUrl) {
+    try {
+      const shared = new SharedStore(cfg.sharedUrl);
+      await shared.initialize();
+      const sharedSt = await shared.stats();
+      lines.push('');
+      lines.push('Shared store:');
+      lines.push(`  Total translations: ${sharedSt.totalTranslations}`);
+      lines.push(`  Failed translations: ${sharedSt.totalFailed}`);
+      if (Object.keys(sharedSt.byLanguage).length > 0) {
+        lines.push('  By language:');
+        for (const [lang, count] of Object.entries(sharedSt.byLanguage).sort()) {
+          lines.push(`    ${lang}: ${count}`);
+        }
+      }
+      await shared.close();
+    } catch (err) {
+      lines.push('');
+      lines.push(`Shared store: error connecting (${(err as Error).message})`);
+    }
+  }
+
   return lines.join('\n');
 }
 
 // CLI entry point
 const program = new Command();
 
-program.name('transduck').description('AI-native translation tool').version('0.5.2');
+program.name('transduck').description('AI-native translation tool').version('0.6.0');
 
 program.command('init')
   .description('Initialize a new transduck project')
@@ -626,6 +675,8 @@ program.command('init')
     const sourceLang = await ask('Source language (e.g. EN): ');
     const targetsRaw = await ask('Target languages (comma-separated): ');
 
+    const sharedUrl = await ask('Shared Postgres URL (optional, press Enter to skip): ');
+
     console.log('\nTranslation provider:');
     console.log('  1. OpenAI (requires API key)');
     console.log('  2. Claude API (requires API key)');
@@ -638,6 +689,7 @@ program.command('init')
       dir, name, context, sourceLang,
       targetLangs: targetsRaw.split(',').map(s => s.trim()),
       provider: providerChoice,
+      sharedUrl: sharedUrl.trim() || undefined,
     });
     console.log(output);
 

package/src/config.ts

@@ -16,6 +16,7 @@ export interface TransduckConfig {
   backendModel: string;
   backendTimeout: number;
   backendMaxRetries: number;
+  sharedUrl: string | null;
   readOnly: boolean;
 }
 
@@ -59,6 +60,8 @@ export function loadConfig(path?: string): TransduckConfig {
   const backendTimeout = backend.timeout_seconds ?? 10;
   const backendMaxRetries = backend.max_retries ?? 2;
 
+  const sharedUrl = process.env.TRANSDUCK_SHARED_URL || raw.storage?.shared_url || null;
+
   let readOnly = raw.runtime?.read_only ?? false;
   if (provider === 'claude_code') {
     readOnly = true;
@@ -70,6 +73,7 @@ export function loadConfig(path?: string): TransduckConfig {
     sourceLang: String(raw.languages.source).toUpperCase(),
     targetLangs: raw.languages.targets.map((l: string) => String(l).toUpperCase()),
     storagePath,
+    sharedUrl,
     provider,
     apiKeyEnv,
     tokenEnv,

package/src/handler.ts

@@ -1,6 +1,7 @@
 import { createHash } from 'crypto';
 import { loadConfig } from './config.js';
 import { TranslationStore } from './storage.js';
+import { SharedStore } from './shared-store.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural } from './backend.js';
 import { validateTranslation } from './validation.js';
 
@@ -11,12 +12,14 @@ function hash(text: string): string {
 interface TranslationRequestString {
   text: string;
   context?: string;
+  sourceLang?: string;
 }
 
 interface TranslationRequestPlural {
   one: string;
   other: string;
   context?: string | null;
+  sourceLang?: string;
 }
 
 export interface TranslationRequest {
@@ -31,6 +34,7 @@ export interface TranslationResponse {
 }
 
 let _store: TranslationStore | null = null;
+let _sharedStore: SharedStore | null = null;
 
 async function getStore(configPath?: string) {
   if (!_store) {
@@ -41,12 +45,26 @@ async function getStore(configPath?: string) {
   return _store;
 }
 
+async function getSharedStore(configPath?: string): Promise<SharedStore | null> {
+  if (_sharedStore) return _sharedStore;
+  const cfg = loadConfig(configPath);
+  if (!cfg.sharedUrl) return null;
+  try {
+    _sharedStore = new SharedStore(cfg.sharedUrl);
+    await _sharedStore.initialize();
+    return _sharedStore;
+  } catch {
+    return null;
+  }
+}
+
 /** @internal Reset the singleton store — for testing only. */
 export function _resetHandlerStore(): void {
   if (_store) {
     _store.close();
   }
   _store = null;
+  _sharedStore = null;
 }
 
 export async function handleTranslationRequest(
@@ -55,6 +73,7 @@ export async function handleTranslationRequest(
 ): Promise<TranslationResponse> {
   const cfg = loadConfig(configPath);
   const store = await getStore(configPath);
+  const shared = await getSharedStore(configPath);
   const targetLang = body.language.toUpperCase();
 
   const projectContextHash = hash(cfg.projectContext);
@@ -64,46 +83,49 @@ export async function handleTranslationRequest(
 
   // Translate regular strings
   for (const item of body.strings ?? []) {
+    const sourceLang = item.sourceLang?.toUpperCase() ?? cfg.sourceLang;
     const stringContextHash = hash(item.context ?? '');
     const key = `${item.text}||${item.context ?? ''}`;
+    const lookupParams = {
+      sourceText: item.text, sourceLang, targetLang,
+      projectContextHash, stringContextHash,
+    };
 
-    // Cache lookup
-    const cached = await store.lookup({
-      sourceText: item.text,
-      sourceLang: cfg.sourceLang,
-      targetLang,
-      projectContextHash,
-      stringContextHash,
-    });
-
+    // Tier 1: local cache
+    const cached = await store.lookup(lookupParams);
     if (cached !== null) {
       translations[key] = cached;
       continue;
     }
 
+    // Tier 2: shared store
+    if (shared) {
+      const sharedCached = await shared.lookup(lookupParams);
+      if (sharedCached !== null) {
+        // Propagate to local
+        await store.insert({
+          ...lookupParams, stringContext: item.context ?? '',
+          translatedText: sharedCached, model: cfg.backendModel, status: 'translated',
+        });
+        translations[key] = sharedCached;
+        continue;
+      }
+    }
+
     // Backend call
     try {
       const translated = await backendTranslate(
-        item.text,
-        cfg.sourceLang,
-        targetLang,
-        cfg.projectContext,
-        item.context ?? null,
-        cfg,
+        item.text, sourceLang, targetLang,
+        cfg.projectContext, item.context ?? null, cfg,
       );
 
       if (validateTranslation(item.text, translated)) {
-        await store.insert({
-          sourceText: item.text,
-          sourceLang: cfg.sourceLang,
-          targetLang,
-          projectContextHash,
-          stringContextHash,
-          stringContext: item.context ?? '',
-          translatedText: translated,
-          model: cfg.backendModel,
-          status: 'translated',
-        });
+        const insertParams = {
+          ...lookupParams, stringContext: item.context ?? '',
+          translatedText: translated, model: cfg.backendModel, status: 'translated',
+        };
+        await store.insert(insertParams);
+        if (shared) await shared.insert(insertParams);
         translations[key] = translated;
       } else {
         translations[key] = item.text;
@@ -115,49 +137,54 @@ export async function handleTranslationRequest(
 
   // Translate plurals
   for (const item of body.plurals ?? []) {
+    const sourceLang = item.sourceLang?.toUpperCase() ?? cfg.sourceLang;
     const stringContextHash = hash(item.context ?? '');
     const sourceKey = item.one + '\x00' + item.other;
     const responseKey = `${sourceKey}||${item.context ?? ''}`;
+    const lookupParams = {
+      sourceText: sourceKey, sourceLang, targetLang,
+      projectContextHash, stringContextHash,
+    };
 
-    // Cache lookup
-    const cachedForms = await store.lookupPlural({
-      sourceText: sourceKey,
-      sourceLang: cfg.sourceLang,
-      targetLang,
-      projectContextHash,
-      stringContextHash,
-    });
-
+    // Tier 1: local cache
+    const cachedForms = await store.lookupPlural(lookupParams);
     if (Object.keys(cachedForms).length > 0) {
       plurals[responseKey] = cachedForms;
       continue;
     }
 
+    // Tier 2: shared store
+    if (shared) {
+      const sharedForms = await shared.lookupPlural(lookupParams);
+      if (Object.keys(sharedForms).length > 0) {
+        // Propagate to local
+        for (const [cat, text] of Object.entries(sharedForms)) {
+          await store.insertPlural({
+            ...lookupParams, stringContext: item.context ?? '',
+            pluralCategory: cat, translatedText: text,
+            model: cfg.backendModel, status: 'translated',
+          });
+        }
+        plurals[responseKey] = sharedForms;
+        continue;
+      }
+    }
+
     // Backend call
     try {
       const forms = await backendTranslatePlural(
-        item.one,
-        item.other,
-        cfg.sourceLang,
-        targetLang,
-        cfg.projectContext,
-        item.context ?? null,
-        cfg,
+        item.one, item.other, sourceLang, targetLang,
+        cfg.projectContext, item.context ?? null, cfg,
       );
 
       for (const [cat, translatedText] of Object.entries(forms)) {
-        await store.insertPlural({
-          sourceText: sourceKey,
-          sourceLang: cfg.sourceLang,
-          targetLang,
-          projectContextHash,
-          stringContextHash,
-          stringContext: item.context ?? '',
-          pluralCategory: cat,
-          translatedText: translatedText as string,
-          model: cfg.backendModel,
-          status: 'translated',
-        });
+        const insertParams = {
+          ...lookupParams, stringContext: item.context ?? '',
+          pluralCategory: cat, translatedText: translatedText as string,
+          model: cfg.backendModel, status: 'translated',
+        };
+        await store.insertPlural(insertParams);
+        if (shared) await shared.insertPlural(insertParams);
       }
       plurals[responseKey] = forms;
     } catch {