@djangocfg/i18n 2.1.216 → 2.1.218

package/src/cli/commands/translate.ts

@@ -1,208 +0,0 @@
-/**
- * Translate text or JSON using LLM
- */
-
-import { defineCommand } from 'citty';
-import { consola } from 'consola';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-import {
-  detectLocaleConfig,
-  getDefaultLocalesDir,
-  loadLocale,
-  readLocaleFile,
-  writeLocaleFile,
-  getExportName,
-  translateText,
-  translateJson,
-  getTranslatorStats,
-} from '../utils';
-
-export const translateCommand = defineCommand({
-  meta: {
-    name: 'translate',
-    description: 'Translate text or locale file using LLM',
-  },
-  args: {
-    text: {
-      type: 'positional',
-      description: 'Text to translate or locale code (e.g., "Hello" or "ru")',
-      required: false,
-    },
-    dir: {
-      type: 'string',
-      alias: 'd',
-      description: 'Locales directory',
-    },
-    from: {
-      type: 'string',
-      alias: 'f',
-      description: 'Source locale (default: en)',
-      default: 'en',
-    },
-    to: {
-      type: 'string',
-      alias: 't',
-      description: 'Target locales (comma-separated, e.g., "ru,ko,ja")',
-    },
-    json: {
-      type: 'boolean',
-      alias: 'j',
-      description: 'Output as JSON',
-      default: false,
-    },
-    file: {
-      type: 'boolean',
-      description: 'Translate entire locale file',
-      default: false,
-    },
-    stats: {
-      type: 'boolean',
-      alias: 's',
-      description: 'Show translation cache stats',
-      default: false,
-    },
-  },
-  async run({ args }) {
-    // Show stats
-    if (args.stats) {
-      const stats = getTranslatorStats();
-      if (stats) {
-        consola.info('Translation Cache Stats:');
-        consola.log(`  Memory size: ${stats.memorySize}`);
-        consola.log(`  Hits: ${stats.hits}`);
-        consola.log(`  Misses: ${stats.misses}`);
-        if (stats.languagePairs.length > 0) {
-          consola.log('  Language pairs:');
-          for (const { pair, translations } of stats.languagePairs) {
-            consola.log(`    ${pair}: ${translations} translations`);
-          }
-        }
-      } else {
-        consola.info('No translations performed yet.');
-      }
-      return;
-    }
-
-    const localesDir = args.dir
-      ? path.resolve(process.cwd(), args.dir)
-      : getDefaultLocalesDir();
-
-    try {
-      const config = detectLocaleConfig(localesDir);
-      const sourceLocale = args.from || 'en';
-
-      // Determine target locales
-      let targetLocales: string[];
-      if (args.to) {
-        targetLocales = args.to.split(',').map((l) => l.trim());
-      } else {
-        // All locales except source
-        targetLocales = config.locales.filter((l) => l !== sourceLocale);
-      }
-
-      // Translate entire file
-      if (args.file || (args.text && config.locales.includes(args.text))) {
-        const targetLocale = args.text || targetLocales[0];
-        if (!targetLocale) {
-          consola.error('Please specify target locale');
-          return;
-        }
-
-        consola.info(`Translating ${sourceLocale} -> ${targetLocale}`);
-        consola.info(`Directory: ${localesDir}`);
-
-        const sourceData = await loadLocale(config, sourceLocale);
-        const startTime = Date.now();
-
-        // Translate section-by-section to avoid LLM output truncation on large files
-        const topLevelKeys = Object.keys(sourceData);
-        const translated: Record<string, unknown> = {};
-
-        for (const section of topLevelKeys) {
-          const sectionData = sourceData[section];
-          consola.info(`  [${section}] translating...`);
-          const sectionTranslated = await translateJson(
-            sectionData as Record<string, unknown>,
-            targetLocale,
-            sourceLocale,
-          );
-          translated[section] = sectionTranslated;
-          consola.success(`  [${section}] done`);
-        }
-
-        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-        consola.success(`Translated in ${elapsed}s`);
-
-        // Write to file
-        if (config.fileExtension === '.ts') {
-          const exportName = getExportName(targetLocale);
-          const { content } = readLocaleFile(config, targetLocale);
-          const jsonStr = JSON.stringify(translated, null, 2);
-          // Replace the exported object (from `export const X... = {` to end of file)
-          const newContent = content.replace(
-            /(export const \w+[^=]*=\s*)\{[\s\S]*$/,
-            `$1${jsonStr};\n`
-          );
-          const finalContent = newContent !== content
-            ? newContent
-            : `import type { DocsTranslations } from './en';\n\nexport const ${exportName}: DocsTranslations = ${jsonStr};\n`;
-          writeLocaleFile(config, targetLocale, finalContent);
-          consola.success(`Written to ${targetLocale}.ts`);
-        } else {
-          writeLocaleFile(config, targetLocale, JSON.stringify(translated, null, 2));
-          consola.success(`Written to ${targetLocale}.json`);
-        }
-
-        if (args.json) {
-          console.log(JSON.stringify(translated, null, 2));
-        } else {
-          // Show sample
-          const sample = JSON.stringify(translated, null, 2).slice(0, 300);
-          consola.log(sample + (sample.length >= 300 ? '\n...' : ''));
-        }
-
-        return;
-      }
-
-      // Translate text
-      const text = args.text;
-      if (!text) {
-        consola.error('Please provide text to translate or use --file flag');
-        consola.log('');
-        consola.log('Examples:');
-        consola.log('  pnpm i18n translate "Hello World" --to ru,ko');
-        consola.log('  pnpm i18n translate --file --to ru');
-        consola.log('  pnpm i18n translate ru  # Translate en.ts to ru');
-        return;
-      }
-
-      consola.info(`Translating: "${text}"`);
-      consola.log('');
-
-      const translations: Record<string, string> = {
-        [sourceLocale]: text,
-      };
-
-      for (const locale of targetLocales) {
-        try {
-          const translated = await translateText(text, locale, sourceLocale);
-          translations[locale] = translated;
-          consola.log(`  ${locale}: ${translated}`);
-        } catch (error) {
-          consola.warn(`  ${locale}: [FAILED] ${error instanceof Error ? error.message : error}`);
-        }
-      }
-
-      consola.log('');
-      if (args.json) {
-        console.log(JSON.stringify(translations, null, 2));
-      } else {
-        consola.log('Copy-paste JSON:');
-        console.log(JSON.stringify(translations));
-      }
-    } catch (error) {
-      consola.error(error);
-    }
-  },
-});

package/src/cli/utils/translator.ts

@@ -1,97 +0,0 @@
-/**
- * LLM Translator utility for i18n CLI
- *
- * Uses @djangocfg/llm for translations
- */
-
-import { createLLMClient, createTranslator, type JsonTranslator } from '@djangocfg/llm';
-
-/** Default API key for testing */
-const DEFAULT_API_KEY = 'test-api-key';
-
-let translator: JsonTranslator | null = null;
-
-/**
- * Get or create translator instance
- */
-export function getTranslator(): JsonTranslator {
-  if (!translator) {
-    // Use env key or default test key
-    const apiKey = process.env.SDKROUTER_API_KEY ||
-                   process.env.OPENAI_API_KEY ||
-                   process.env.ANTHROPIC_API_KEY ||
-                   DEFAULT_API_KEY;
-
-    const llm = createLLMClient({
-      provider: 'sdkrouter',
-      apiKey
-    });
-    translator = createTranslator(llm);
-  }
-  return translator;
-}
-
-/**
- * Translate text to target language
- */
-export async function translateText(
-  text: string,
-  targetLocale: string,
-  sourceLocale: string = 'en'
-): Promise<string> {
-  const t = getTranslator();
-  return t.translateText(text, targetLocale, { sourceLanguage: sourceLocale });
-}
-
-/**
- * Translate JSON object to target language
- */
-export async function translateJson<T extends Record<string, unknown>>(
-  data: T,
-  targetLocale: string,
-  sourceLocale: string = 'en'
-): Promise<T> {
-  const t = getTranslator();
-  const result = await t.translate(data, targetLocale, { sourceLanguage: sourceLocale });
-  return result.data;
-}
-
-/**
- * Translate to multiple languages in parallel
- */
-export async function translateToMany<T extends Record<string, unknown>>(
-  data: T,
-  targetLocales: string[],
-  sourceLocale: string = 'en'
-): Promise<Map<string, T>> {
-  const t = getTranslator();
-  const results = await t.translateToMany(data, targetLocales, { sourceLanguage: sourceLocale });
-
-  const output = new Map<string, T>();
-  for (const [locale, result] of results) {
-    output.set(locale, result.data);
-  }
-  return output;
-}
-
-/**
- * Get translator stats
- */
-export function getTranslatorStats(): {
-  memorySize: number;
-  hits: number;
-  misses: number;
-  languagePairs: Array<{ pair: string; translations: number }>;
-} | null {
-  if (!translator) return null;
-  return translator.getStats();
-}
-
-/**
- * Clear translator cache
- */
-export function clearTranslatorCache() {
-  if (translator) {
-    translator.clearCache();
-  }
-}