transduck 0.0.4 → 0.1.1

package/dist/cli.d.ts

@@ -31,6 +31,14 @@ export interface WarmOptions {
     configPath?: string;
 }
 export declare function runWarm(opts: WarmOptions): Promise<string>;
+export interface ScanOptions {
+    dirs: string[];
+    warm?: boolean;
+    langs?: string[];
+    outputPath?: string;
+    configPath?: string;
+}
+export declare function runScan(opts: ScanOptions): Promise<string>;
 export interface StatsOptions {
     configPath?: string;
 }

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createHash } from 'crypto';
-import { readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
 import { Command } from 'commander';
 import { stringify as yamlStringify } from 'yaml';
 import { loadConfig } from './config.js';
@@ -9,6 +9,7 @@ import { TranslationStore } from './storage.js';
 import { translate as backendTranslate, translatePlural as backendTranslatePlural } from './backend.js';
 import { validateTranslation, extractPlaceholders } from './validation.js';
 import { getPluralCategory, interpolateVars } from './plural.js';
+import { scanDirectory } from './scanner.js';
 function hash(text) {
     return createHash('sha256').update(text).digest('hex');
 }
@@ -285,6 +286,138 @@ export async function runWarm(opts) {
     store.close();
     return `Translated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`;
 }
+export async function runScan(opts) {
+    const cfg = loadConfig(opts.configPath);
+    const scanDirs = opts.dirs.length > 0 ? opts.dirs : [process.cwd()];
+    const entries = scanDirectory(scanDirs);
+    const regular = entries.filter(e => !e.plural);
+    const plurals = entries.filter(e => e.plural);
+    // Count scanned files
+    const allFiles = new Set();
+    for (const e of entries) {
+        for (const f of (e.files ?? [])) {
+            allFiles.add(f);
+        }
+    }
+    const lines = [];
+    lines.push(`Scanned files with matches: ${allFiles.size}`);
+    lines.push(`Found ${entries.length} strings (${regular.length} regular, ${plurals.length} plural)`);
+    lines.push('');
+    for (const e of entries) {
+        const locations = (e.files ?? []).join(', ');
+        if (e.plural) {
+            lines.push(`  ait_plural("${e.one}", "${e.other}")  ${locations}`);
+        }
+        else {
+            const ctx = e.context ? `, context="${e.context}"` : '';
+            lines.push(`  ait("${e.text}"${ctx})  ${locations}`);
+        }
+    }
+    // Output to JSON
+    if (opts.outputPath) {
+        const outputEntries = entries.map(e => {
+            const out = {};
+            for (const [k, v] of Object.entries(e)) {
+                if (k !== 'files')
+                    out[k] = v;
+            }
+            return out;
+        });
+        writeFileSync(opts.outputPath, JSON.stringify(outputEntries, null, 2));
+        lines.push(`\nWrote ${entries.length} entries to ${opts.outputPath}`);
+    }
+    // Warm
+    if (opts.warm) {
+        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;
+        for (const entry of entries) {
+            if (entry.plural) {
+                const sourceKey = entry.one + '\x00' + entry.other;
+                const stringContextHash = hash(entry.context ?? '');
+                for (const lang of targetLangs) {
+                    const cachedForms = await store.lookupPlural({
+                        sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
+                        projectContextHash, stringContextHash,
+                    });
+                    if (Object.keys(cachedForms).length > 0) {
+                        skipped++;
+                        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,
+                        });
+                        for (const [cat, translatedText] of Object.entries(forms)) {
+                            await store.insertPlural({
+                                sourceText: sourceKey, sourceLang: cfg.sourceLang, targetLang: lang,
+                                projectContextHash, stringContextHash,
+                                pluralCategory: cat, translatedText: translatedText,
+                                model: cfg.backendModel, status: 'translated',
+                            });
+                        }
+                        translated++;
+                    }
+                    catch {
+                        failed++;
+                    }
+                }
+            }
+            else {
+                const stringContextHash = hash(entry.context ?? '');
+                for (const lang of targetLangs) {
+                    const cached = await store.lookup({
+                        sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
+                        projectContextHash, stringContextHash,
+                    });
+                    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,
+                        });
+                        if (validateTranslation(entry.text, result)) {
+                            await store.insert({
+                                sourceText: entry.text, sourceLang: cfg.sourceLang, targetLang: lang,
+                                projectContextHash, stringContextHash,
+                                translatedText: result, model: cfg.backendModel, status: 'translated',
+                            });
+                            translated++;
+                        }
+                        else {
+                            failed++;
+                        }
+                    }
+                    catch {
+                        failed++;
+                    }
+                }
+            }
+        }
+        store.close();
+        lines.push(`\nTranslated: ${translated} | Skipped: ${skipped} | Failed: ${failed}`);
+    }
+    if (!opts.warm && !opts.outputPath) {
+        lines.push(`\nRun 'transduck scan --warm --langs DE,ES' to translate all strings.`);
+    }
+    return lines.join('\n');
+}
 export async function runStats(opts) {
     const cfg = loadConfig(opts.configPath);
     const store = new TranslationStore(cfg.storagePath);
@@ -323,6 +456,21 @@ program.command('init')
         targetLangs: targetsRaw.split(',').map(s => s.trim()),
     });
     console.log(output);
+    const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask2 = (q) => new Promise(r => rl2.question(q, r));
+    const useReact = await ask2('Are you using React/Next.js? (y/n): ');
+    if (useReact.toLowerCase() === 'y') {
+        const routePath = await ask2('API route path (default: app/api/translations/route.ts): ');
+        const finalPath = join(dir, routePath.trim() || 'app/api/translations/route.ts');
+        // Create directory
+        const routeDir = dirname(finalPath);
+        mkdirSync(routeDir, { recursive: true });
+        // Write route file
+        writeFileSync(finalPath, `import { createTransDuckHandler } from 'transduck';\n\nexport const POST = createTransDuckHandler();\n`);
+        console.log(`Created ${finalPath}`);
+        console.log('Add TransDuckProvider to your layout — see docs: transduck/react');
+    }
+    rl2.close();
 });
 program.command('translate')
     .description('Translate a single string')
@@ -375,6 +523,23 @@ program.command('stats')
     const output = await runStats({ configPath: opts.config ?? '' });
     console.log(output);
 });
+program.command('scan')
+    .description('Scan source code for translatable strings')
+    .option('--dir <path...>', 'Directories to scan (repeatable)')
+    .option('--warm', 'Translate all found strings')
+    .option('--langs <langs>', 'Comma-separated target languages (for --warm)')
+    .option('--output <path>', 'Write found strings to JSON')
+    .option('--config <path>', 'Path to transduck.yaml')
+    .action(async (opts) => {
+    const output = await runScan({
+        dirs: opts.dir ?? [],
+        warm: opts.warm ?? false,
+        langs: opts.langs ? opts.langs.split(',').map(s => s.trim()) : undefined,
+        outputPath: opts.output,
+        configPath: opts.config,
+    });
+    console.log(output);
+});
 export { program };
 // Run CLI when executed directly (not when imported by tests or other modules)
 if (typeof process !== 'undefined' && process.argv[1]) {

package/dist/config.d.ts

@@ -8,5 +8,6 @@ export interface TransduckConfig {
     backendModel: string;
     backendTimeout: number;
     backendMaxRetries: number;
+    readOnly: boolean;
 }
 export declare function loadConfig(path?: string): TransduckConfig;

package/dist/config.js

@@ -39,5 +39,6 @@ export function loadConfig(path) {
         backendModel: raw.backend.model,
         backendTimeout: raw.backend.timeout_seconds,
         backendMaxRetries: raw.backend.max_retries,
+        readOnly: raw.runtime?.read_only ?? false,
     };
 }

package/dist/handler.d.ts

@@ -0,0 +1,23 @@
+interface TranslationRequestString {
+    text: string;
+    context?: string;
+}
+interface TranslationRequestPlural {
+    one: string;
+    other: string;
+    context?: string | null;
+}
+export interface TranslationRequest {
+    language: string;
+    strings: TranslationRequestString[];
+    plurals: TranslationRequestPlural[];
+}
+export interface TranslationResponse {
+    translations: Record<string, string>;
+    plurals: Record<string, Record<string, string>>;
+}
+/** @internal Reset the singleton store — for testing only. */
+export declare function _resetHandlerStore(): void;
+export declare function handleTranslationRequest(body: TranslationRequest, configPath?: string): Promise<TranslationResponse>;
+export declare function createTransDuckHandler(configPath?: string): (request: Request) => Promise<Response>;
+export {};

package/dist/handler.js

@@ -0,0 +1,153 @@
+import { createHash } from 'crypto';
+import { loadConfig } from './config.js';
+import { TranslationStore } from './storage.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;
+async function getStore(configPath) {
+    if (!_store) {
+        const cfg = loadConfig(configPath);
+        _store = new TranslationStore(cfg.storagePath);
+        await _store.initialize();
+    }
+    return _store;
+}
+/** @internal Reset the singleton store — for testing only. */
+export function _resetHandlerStore() {
+    if (_store) {
+        _store.close();
+    }
+    _store = null;
+}
+export async function handleTranslationRequest(body, configPath) {
+    const cfg = loadConfig(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
+    for (const item of body.strings) {
+        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,
+        });
+        if (cached !== null) {
+            translations[key] = cached;
+            continue;
+        }
+        // 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,
+            });
+            if (validateTranslation(item.text, translated)) {
+                await store.insert({
+                    sourceText: item.text,
+                    sourceLang: cfg.sourceLang,
+                    targetLang,
+                    projectContextHash,
+                    stringContextHash,
+                    translatedText: translated,
+                    model: cfg.backendModel,
+                    status: 'translated',
+                });
+                translations[key] = translated;
+            }
+            else {
+                translations[key] = item.text;
+            }
+        }
+        catch {
+            translations[key] = item.text;
+        }
+    }
+    // Translate plurals
+    for (const item of body.plurals) {
+        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,
+        });
+        if (Object.keys(cachedForms).length > 0) {
+            plurals[responseKey] = cachedForms;
+            continue;
+        }
+        // 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,
+            });
+            for (const [cat, translatedText] of Object.entries(forms)) {
+                await store.insertPlural({
+                    sourceText: sourceKey,
+                    sourceLang: cfg.sourceLang,
+                    targetLang,
+                    projectContextHash,
+                    stringContextHash,
+                    pluralCategory: cat,
+                    translatedText: translatedText,
+                    model: cfg.backendModel,
+                    status: 'translated',
+                });
+            }
+            plurals[responseKey] = forms;
+        }
+        catch {
+            plurals[responseKey] = { one: item.one, other: item.other };
+        }
+    }
+    return { translations, plurals };
+}
+export function createTransDuckHandler(configPath) {
+    return async function POST(request) {
+        try {
+            const body = await request.json();
+            const result = await handleTranslationRequest(body, configPath);
+            return new Response(JSON.stringify(result), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+        catch (err) {
+            console.error('[transduck] Handler error:', err);
+            return new Response(JSON.stringify({ error: 'Translation failed' }), {
+                status: 500,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+    };
+}

package/dist/index.d.ts

@@ -5,6 +5,7 @@ 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 { createTransDuckHandler } from './handler.js';
 export declare function aitPlural(one: string, other: string, count: number, opts?: {
     context?: string;
     vars?: Record<string, string | number>;

package/dist/index.js

@@ -49,6 +49,10 @@ export async function ait(sourceText, context, vars) {
     });
     if (cached !== null)
         return interpolateVars(cached, vars);
+    // Read-only mode: skip backend, return source text
+    if (cfg.readOnly) {
+        return interpolateVars(sourceText, vars);
+    }
     // In-process dedup
     const lockKey = `${sourceText}|${cfg.sourceLang}|${state.targetLang}|${projectContextHash}|${stringContextHash}`;
     if (state.pendingTranslations.has(lockKey)) {
@@ -99,6 +103,7 @@ export async function ait(sourceText, context, vars) {
     const result = await translationPromise;
     return interpolateVars(result, vars);
 }
+export { createTransDuckHandler } from './handler.js';
 export async function aitPlural(one, other, count, opts) {
     if (!state.config || !state.store) {
         throw new Error('transduck not initialized. Call initialize() first.');
@@ -141,6 +146,12 @@ export async function aitPlural(one, other, count, opts) {
     if (category in cached) {
         return interpolateVars(cached[category], vars);
     }
+    // Read-only mode: skip backend, fall back to source forms
+    if (cfg.readOnly) {
+        const fallbackCategory = getPluralCategory(cfg.sourceLang, count);
+        const fallback = fallbackCategory === 'one' ? one : other;
+        return interpolateVars(fallback, vars);
+    }
     // Cache miss — call backend
     const apiKey = process.env[cfg.apiKeyEnv];
     try {

package/dist/react/index.d.ts

@@ -0,0 +1 @@
+export { TransDuckProvider, t, ait, tPlural, aitPlural, useTransDuck, _resetReactState } from './provider.js';

package/dist/react/index.js

@@ -0,0 +1 @@
+export { TransDuckProvider, t, ait, tPlural, aitPlural, useTransDuck, _resetReactState } from './provider.js';

package/dist/react/provider.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from 'react';
+/**
+ * Hook that subscribes to translation updates. Call this in any component
+ * that uses t()/ait() to ensure it re-renders when translations are loaded.
+ */
+export declare function useTransDuck(): void;
+export declare function _resetReactState(): void;
+export declare function t(sourceText: string, context?: string, vars?: Record<string, string | number>): string;
+export declare function tPlural(one: string, other: string, count: number, opts?: {
+    context?: string;
+    vars?: Record<string, string | number>;
+}): string;
+export declare const ait: typeof t;
+export declare const aitPlural: typeof tPlural;
+interface TransDuckProviderProps {
+    language: string;
+    sourceLang?: string;
+    endpoint?: string;
+    projectName?: string;
+    children: ReactNode;
+}
+export declare function TransDuckProvider({ language, sourceLang, endpoint, projectName, children, }: TransDuckProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};