transduck 0.5.3 → 0.6.1

package/dist/backend.d.ts

@@ -3,5 +3,6 @@
  */
 import type { TransduckConfig } from './config.js';
 export { buildMessages, buildPluralMessages } from './providers/prompts.js';
+export declare function detectLanguage(text: string, config: TransduckConfig, _clientOverride?: any): Promise<string>;
 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

@@ -20,6 +20,12 @@ function checkApiKey(config) {
             `Or add it to your .env file.`);
     }
 }
+export async function detectLanguage(text, config, _clientOverride) {
+    if (!_clientOverride)
+        checkApiKey(config);
+    const provider = await getProvider(config);
+    return provider.detectLanguage(text, config, _clientOverride);
+}
 export async function translate(sourceText, sourceLang, targetLang, projectContext, stringContext, config, _clientOverride) {
     if (!_clientOverride)
         checkApiKey(config);

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import 'dotenv/config';
 import { Command } from 'commander';
 export interface InitOptions {
     dir: string;
@@ -7,6 +8,7 @@ export interface InitOptions {
     sourceLang: string;
     targetLangs: string[];
     provider?: number;
+    sharedUrl?: string;
 }
 export declare function runInit(opts: InitOptions): Promise<string>;
 export interface TranslateOptions {

package/dist/cli.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import 'dotenv/config';
 import { createHash } from 'crypto';
 import { readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, dirname } from 'path';
@@ -6,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';
@@ -15,10 +17,14 @@ function hash(text) {
 }
 export async function runInit(opts) {
     const providerChoice = opts.provider ?? 1;
+    const storage = { path: './translations.db' };
+    if (opts.sharedUrl) {
+        storage.shared_url = opts.sharedUrl;
+    }
     const config = {
         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) {
         config.backend = {
@@ -194,6 +200,17 @@ export async function runWarm(opts) {
     const targetLangs = opts.langs.map(l => l.toUpperCase());
     const store = new TranslationStore(cfg.storagePath);
     await store.initialize();
+    let shared = 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.message}`);
+            shared = null;
+        }
+    }
     const content = readFileSync(opts.filePath, 'utf-8');
     let entries;
     if (opts.filePath.endsWith('.json')) {
@@ -237,12 +254,15 @@ export async function runWarm(opts) {
                                 break;
                             }
                         }
-                        await store.insertPlural({
+                        const pluralParams = {
                             sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
                             projectContextHash, stringContextHash, stringContext: entry.context ?? '',
                             pluralCategory: cat, translatedText: translatedText,
                             model: cfg.backendModel, status: allPresent ? 'translated' : 'failed',
-                        });
+                        };
+                        await store.insertPlural(pluralParams);
+                        if (shared)
+                            await shared.insertPlural(pluralParams);
                         anyStored = true;
                     }
                     if (anyStored)
@@ -270,19 +290,25 @@ export async function runWarm(opts) {
                 try {
                     const result = await backendTranslate(entry.text, cfg.sourceLang, lang, cfg.projectContext, entry.context ?? null, cfg);
                     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++;
                     }
                 }
@@ -293,6 +319,8 @@ export async function runWarm(opts) {
         }
     }
     store.close();
+    if (shared)
+        await shared.close();
     return `Translated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`;
 }
 export async function runScan(opts) {
@@ -479,21 +507,44 @@ export async function runStats(opts) {
     await store.initialize();
     const st = await store.stats();
     const lines = [
-        `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.message})`);
+        }
+    }
     return lines.join('\n');
 }
 // CLI entry point
 const program = new Command();
-program.name('transduck').description('AI-native translation tool').version('0.5.3');
+program.name('transduck').description('AI-native translation tool').version('0.6.1');
 program.command('init')
     .description('Initialize a new transduck project')
     .action(async () => {
@@ -505,6 +556,7 @@ 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): ');
+    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)');
@@ -516,6 +568,7 @@ program.command('init')
         dir, name, context, sourceLang,
         targetLangs: targetsRaw.split(',').map(s => s.trim()),
         provider: providerChoice,
+        sharedUrl: sharedUrl.trim() || undefined,
     });
     console.log(output);
     const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import 'dotenv/config';
 export interface TransduckConfig {
     projectName: string;
     projectContext: string;
@@ -10,6 +11,7 @@ export interface TransduckConfig {
     backendModel: string;
     backendTimeout: number;
     backendMaxRetries: number;
+    sharedUrl: string | null;
     readOnly: boolean;
 }
 export declare function loadConfig(path?: string): TransduckConfig;

package/dist/config.js

@@ -1,3 +1,4 @@
+import 'dotenv/config';
 import { readFileSync, existsSync } from 'fs';
 import { resolve, dirname, join } from 'path';
 import { parse as parseYaml } from 'yaml';
@@ -36,6 +37,7 @@ export function loadConfig(path) {
     const backendModel = backend.model ?? 'gpt-4.1-mini';
     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;
@@ -46,6 +48,7 @@ export function loadConfig(path) {
         sourceLang: String(raw.languages.source).toUpperCase(),
         targetLangs: raw.languages.targets.map((l) => String(l).toUpperCase()),
         storagePath,
+        sharedUrl,
         provider,
         apiKeyEnv,
         tokenEnv,

package/dist/handler.d.ts

@@ -1,11 +1,13 @@
 interface TranslationRequestString {
     text: string;
     context?: string;
+    sourceLang?: string;
 }
 interface TranslationRequestPlural {
     one: string;
     other: string;
     context?: string | null;
+    sourceLang?: string;
 }
 export interface TranslationRequest {
     language: string;

package/dist/handler.js

@@ -1,12 +1,14 @@
 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';
 function hash(text) {
     return createHash('sha256').update(text).digest('hex');
 }
 let _store = null;
+let _sharedStore = null;
 async function getStore(configPath) {
     if (!_store) {
         const cfg = loadConfig(configPath);
@@ -15,51 +17,76 @@ async function getStore(configPath) {
     }
     return _store;
 }
+async function getSharedStore(configPath) {
+    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() {
     if (_store) {
         _store.close();
     }
     _store = null;
+    _sharedStore = null;
 }
 export async function handleTranslationRequest(body, configPath) {
     const cfg = loadConfig(configPath);
     const store = await getStore(configPath);
+    const shared = await getSharedStore(configPath);
     const targetLang = body.language.toUpperCase();
     const projectContextHash = hash(cfg.projectContext);
     const translations = {};
     const plurals = {};
     // 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 ?? ''}`;
-        // Cache lookup
-        const cached = await store.lookup({
-            sourceText: item.text,
-            sourceLang: cfg.sourceLang,
-            targetLang,
-            projectContextHash,
-            stringContextHash,
-        });
+        const lookupParams = {
+            sourceText: item.text, 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);
+            const translated = await backendTranslate(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 {
@@ -72,37 +99,48 @@ export async function handleTranslationRequest(body, configPath) {
     }
     // 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 ?? ''}`;
-        // Cache lookup
-        const cachedForms = await store.lookupPlural({
-            sourceText: sourceKey,
-            sourceLang: cfg.sourceLang,
-            targetLang,
-            projectContextHash,
-            stringContextHash,
-        });
+        const lookupParams = {
+            sourceText: sourceKey, 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);
+            const forms = await backendTranslatePlural(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,
-                    model: cfg.backendModel,
-                    status: 'translated',
-                });
+                const insertParams = {
+                    ...lookupParams, stringContext: item.context ?? '',
+                    pluralCategory: cat, translatedText: translatedText,
+                    model: cfg.backendModel, status: 'translated',
+                };
+                await store.insertPlural(insertParams);
+                if (shared)
+                    await shared.insertPlural(insertParams);
             }
             plurals[responseKey] = forms;
         }

package/dist/index.d.ts

@@ -1,12 +1,27 @@
 import { type TransduckConfig } from './config.js';
 import { TranslationStore } from './storage.js';
+import { SharedStore } from './shared-store.js';
+import { TranslationResult } from './result.js';
 export declare function initialize(config?: TransduckConfig): Promise<void>;
 export declare function setLanguage(lang: string): void;
 export declare function _resetState(): void;
 export declare function _getStore(): TranslationStore | null;
-export declare function ait(sourceText: string, context?: string, vars?: Record<string, string | number>): Promise<string>;
+export declare function _getSharedStore(): SharedStore | null;
+export declare function _setSharedStore(shared: SharedStore | null): void;
+export interface AitOptions {
+    context?: string;
+    vars?: Record<string, string | number>;
+    sourceLang?: string;
+    background?: boolean;
+}
+export declare function ait(sourceText: string, contextOrOpts?: string | AitOptions, vars?: Record<string, string | number>): Promise<TranslationResult>;
 export { createTransDuckHandler } from './handler.js';
+export { TranslationResult } from './result.js';
+export { SharedStore } from './shared-store.js';
+export declare function detectLanguage(text: string): Promise<string>;
 export declare function aitPlural(one: string, other: string, count: number, opts?: {
     context?: string;
     vars?: Record<string, string | number>;
-}): Promise<string>;
+    sourceLang?: string;
+    background?: boolean;
+}): Promise<TranslationResult>;