@localheroai/cli 0.0.2 → 0.0.5

package/src/commands/translate.js

@@ -1,282 +1,267 @@
 import chalk from 'chalk';
 import { configService } from '../utils/config.js';
-import { findTranslationFiles } from '../utils/files.js';
+import { findTranslationFiles, parseFile, flattenTranslations } from '../utils/files.js';
 import { createTranslationJob, checkJobStatus } from '../api/translations.js';
-import { updateTranslationFile } from '../utils/translation-updater.js';
-import path from 'path';
+import { updateTranslationFile } from '../utils/translation-updater/index.js';
 import { checkAuth } from '../utils/auth.js';
+import { findMissingTranslations, batchKeysWithMissing, processLocaleTranslations } from '../utils/translation-utils.js';
+import { syncService } from '../utils/sync-service.js';
 import { autoCommitChanges } from '../utils/github.js';
 
-const DEFAULT_LOCALE_REGEX = '.*?([a-z]{2}(?:-[A-Z]{2})?)\\.(?:yml|yaml|json)$';
-const MAX_RETRY_ATTEMPTS = 3;
-const BATCH_SIZE = 100;
-
-function validateConfig(config) {
-    const required = ['projectId', 'sourceLocale', 'outputLocales', 'translationFiles'];
-    const missing = required.filter(key => !config[key]);
+const BATCH_SIZE = 50;
+
+const defaultDeps = {
+  console,
+  configUtils: configService,
+  authUtils: { checkAuth },
+  fileUtils: { findTranslationFiles },
+  translationUtils: {
+    createTranslationJob,
+    checkJobStatus,
+    updateTranslationFile,
+    findMissingTranslations,
+    batchKeysWithMissing
+  },
+  syncService,
+  gitUtils: { autoCommitChanges }
+};
+
+export async function translate(options = {}, deps = defaultDeps) {
+  const { console, configUtils, authUtils, fileUtils, translationUtils, syncService, gitUtils } = deps;
+  const { verbose } = options;
+
+  const isAuthenticated = await authUtils.checkAuth();
+  if (!isAuthenticated) {
+    console.error(chalk.red('\n✖ Your API key is invalid. Please run `npx @localheroai/cli login` to authenticate.\n'));
+    process.exit(1);
+  }
+
+  const config = await configUtils.getProjectConfig();
+  if (!config) {
+    console.error(chalk.red('\n✖ No configuration found. Please run `npx @localheroai/cli init` first.\n'));
+    process.exit(1);
+    return;
+  }
+
+  if (!config.translationFiles?.paths) {
+    console.error(chalk.red('\n✖ Invalid configuration: missing translationFiles.paths. Please run `npx @localheroai/cli init` to set up your configuration.\n'));
+    process.exit(1);
+    return;
+  }
+
+  const { hasUpdates, updates } = await syncService.checkForUpdates({ verbose });
+  if (hasUpdates) {
+    await syncService.applyUpdates(updates, { verbose });
+  }
+
+  if (verbose) {
+    console.log(chalk.blue('\nℹ Using configuration:'));
+    console.log(chalk.gray(`  Project ID: ${config.projectId}`));
+    console.log(chalk.gray(`  Source locale: ${config.sourceLocale}`));
+    console.log(chalk.gray(`  Output locales: ${config.outputLocales.join(', ')}`));
+    console.log(chalk.gray(`  Translation files: ${config.translationFiles.paths.join(', ')}`));
+  }
+
+  const result = await fileUtils.findTranslationFiles(config, { verbose, returnFullResult: true });
+  const { sourceFiles, targetFilesByLocale, allFiles } = result;
+
+  if (!allFiles || allFiles.length === 0) {
+    console.error(chalk.red('\n✖ No translation files found in the specified paths.\n'));
+    process.exit(1);
+  }
+
+  if (verbose) {
+    console.log(chalk.blue(`\nℹ Found ${allFiles.length} translation files`));
+  }
+
+  if (sourceFiles.length === 0) {
+    console.error(chalk.red(`\n✖ No source files found for locale ${config.sourceLocale}\n`));
+    console.error(chalk.yellow(`This could be due to one of the following issues:`));
+    console.error(chalk.yellow(`  1. No translation files with the source locale "${config.sourceLocale}" exist in the configured paths`));
+    console.error(chalk.yellow(`  2. The locale identifiers in your filenames don't match the expected pattern`));
+    console.error(chalk.yellow(`  3. There was an error parsing one or more files (check for syntax errors in YAML or JSON)\n`));
+    console.error(chalk.yellow(`Try running with the --verbose flag for more detailed information.\n`));
+    process.exit(1);
+  }
+
+  if (verbose) {
+    console.log(chalk.blue(`ℹ Found ${sourceFiles.length} source files for locale ${config.sourceLocale}`));
+  }
+
+  const missingByLocale = {};
+
+  for (const sourceFile of sourceFiles) {
+    const sourceContentRaw = Buffer.from(sourceFile.content, 'base64').toString();
+    const sourceContent = parseFile(sourceContentRaw, sourceFile.format);
+    const sourceKeys = flattenTranslations(sourceContent[config.sourceLocale] || sourceContent);
+
+    for (const targetLocale of config.outputLocales) {
+      const targetFiles = targetFilesByLocale[targetLocale] || [];
+      const result = processLocaleTranslations(sourceKeys, targetLocale, targetFiles, sourceFile, config.sourceLocale);
+
+      if (Object.keys(result.missingKeys).length > 0) {
+        if (!missingByLocale[targetLocale]) {
+          missingByLocale[targetLocale] = {
+            path: sourceFile.path,
+            targetPath: result.targetPath,
+            keys: {},
+            keyCount: 0
+          };
+        }
 
-    if (missing.length) {
-        throw new Error(`Missing required config: ${missing.join(', ')}. Run 'npx localhero init' to set up your project.`);
-    }
+        missingByLocale[targetLocale].keys = {
+          ...missingByLocale[targetLocale].keys,
+          ...result.missingKeys
+        };
+        missingByLocale[targetLocale].keyCount += Object.keys(result.missingKeys).length;
+      }
 
-    if (!Array.isArray(config.outputLocales) || config.outputLocales.length === 0) {
-        throw new Error('outputLocales must be an array with at least one locale');
+      if (verbose && Object.keys(result.skippedKeys).length > 0) {
+        console.log(chalk.yellow(`\nℹ Skipped ${Object.keys(result.skippedKeys).length} keys marked as WIP in ${sourceFile.path}`));
+      }
     }
-
-    if (config.outputLocales.length > 10) {
-        throw new Error('Maximum 10 target languages allowed per request');
+  }
+
+  const missingLocales = Object.keys(missingByLocale);
+  if (missingLocales.length === 0) {
+    console.log(chalk.green('✓ All translations are up to date!'));
+    return;
+  }
+
+  if (verbose) {
+    console.log(chalk.blue('\nℹ Missing translations:'));
+    for (const [locale, data] of Object.entries(missingByLocale)) {
+      console.log(chalk.gray(`  ${locale}: ${data.keyCount} keys`));
     }
+  }
 
-    if (!config.translationFiles.paths || !Array.isArray(config.translationFiles.paths)) {
-        throw new Error('translationFiles.paths must be an array of paths');
-    }
-}
+  const { batches, errors } = translationUtils.batchKeysWithMissing(sourceFiles, missingByLocale, BATCH_SIZE);
 
-function findMissingTranslations(sourceKeys, targetKeys) {
-    const missing = {};
-    for (const [key, value] of Object.entries(sourceKeys)) {
-        if (!targetKeys[key]) {
-            missing[key] = value;
-        }
+  if (errors.length > 0) {
+    console.error(chalk.red('\n✖ Errors occurred while preparing translation jobs:'));
+    for (const error of errors) {
+      console.error(chalk.red(`  ${error.message}`));
     }
-    return missing;
-}
+    process.exit(1);
+  }
+
+  let totalTranslated = 0;
+  let totalLanguages = 0;
+  const processedLocales = new Set();
+  const allJobIds = [];
+  let resultsBaseUrl = null;
+
+  for (const batch of batches) {
+    const targetPaths = Object.entries(missingByLocale).reduce((acc, [locale, data]) => {
+      acc[locale] = data.targetPath;
+      return acc;
+    }, {});
+
+    const jobRequest = {
+      projectId: config.projectId,
+      sourceFiles: batch.files,
+      targetLocales: batch.locales,
+      targetPaths
+    };
 
-async function retryWithBackoff(operation, attempt = 1) {
     try {
-        return await operation();
-    } catch (error) {
-        if (attempt >= MAX_RETRY_ATTEMPTS) throw error;
-
-        const backoffTime = Math.min(1000 * Math.pow(2, attempt), 30000);
-        const jitter = Math.random() * 1000;
-        const waitTime = backoffTime + jitter;
-
-        console.log(chalk.yellow(`⚠️  API error, retrying in ${Math.round(waitTime / 1000)}s (attempt ${attempt}/${MAX_RETRY_ATTEMPTS})`));
-        console.log(error);
-        await new Promise(resolve => setTimeout(resolve, waitTime));
-
-        return retryWithBackoff(operation, attempt + 1);
-    }
-}
-
-function batchKeysWithMissing(sourceFiles, missingByLocale, batchSize = BATCH_SIZE) {
-    const batches = [];
-    const sourceFileEntries = new Map();
-
-    for (const [locale, localeData] of Object.entries(missingByLocale)) {
-        const sourceFile = sourceFiles.find(f => f.path === localeData.path);
-        if (!sourceFile) continue;
-
-        if (!sourceFileEntries.has(sourceFile.path)) {
-            sourceFileEntries.set(sourceFile.path, {
-                path: path.relative(process.cwd(), sourceFile.path),
-                keys: {},
-                locales: new Set()
-            });
-        }
+      const response = await translationUtils.createTranslationJob(jobRequest);
+      const { jobs } = response;
+      const batchJobIds = jobs.map(job => job.id);
 
-        const entry = sourceFileEntries.get(sourceFile.path);
-        entry.keys = { ...entry.keys, ...localeData.keys };
-        entry.locales.add(locale);
-    }
+      allJobIds.push(...batchJobIds);
 
-    for (const entry of sourceFileEntries.values()) {
-        const keys = entry.keys;
-        const keyEntries = Object.entries(keys);
-        for (let i = 0; i < keyEntries.length; i += batchSize) {
-            const batchKeys = Object.fromEntries(keyEntries.slice(i, i + batchSize));
-            batches.push([{
-                path: entry.path,
-                content: Buffer.from(JSON.stringify({ keys: batchKeys })).toString('base64')
-            }]);
-        }
-    }
+      const pendingJobs = new Set(batchJobIds);
 
-    return batches;
-}
+      while (pendingJobs.size > 0) {
+        const jobPromises = Array.from(pendingJobs).map(async jobId => {
+          if (verbose) {
+            console.log(chalk.blue(`\nℹ Checking job ${jobId}`));
+          }
 
-export async function translate(options = {}) {
-    const { verbose = false, commit = false } = options;
-    const log = verbose ? console.log : () => { };
+          let status;
+          let retries = 0;
+          const MAX_WAIT_MINUTES = 10;
+          const startTime = Date.now();
 
-    try {
-        const config = await configService.getValidProjectConfig();
-        const isAuthenticated = await checkAuth();
+          do {
+            status = await translationUtils.checkJobStatus(jobId, true);
 
-        if (!isAuthenticated) {
-            throw new Error('No API key found. Run `npx localhero login` or set LOCALHERO_API_KEY');
-        }
-
-        console.log(chalk.blue('ℹ️  Loading configuration from localhero.json'));
-
-        const { translationFiles } = config;
-        const fileLocaleRegex = DEFAULT_LOCALE_REGEX;
-        let allFiles = [];
-
-        for (const translationPath of translationFiles.paths) {
-            const filesInPath = await findTranslationFiles(translationPath, fileLocaleRegex);
-            allFiles = allFiles.concat(filesInPath);
-        }
-
-        if (!allFiles.length) {
-            console.error(chalk.red('❌ No translation files found'));
-            process.exit(1);
-        }
+            if (status.status === 'failed') {
+              throw new Error(`Translation job failed: ${status.error_details || 'Unknown error'}`);
+            }
 
-        const sourceFiles = allFiles.filter(f => f.locale === config.sourceLocale);
-        const targetFiles = allFiles.filter(f => config.outputLocales.includes(f.locale));
+            if (status.status === 'pending' || status.status === 'processing') {
+              const elapsed = Math.floor((Date.now() - startTime) / 1000);
+              if (elapsed > MAX_WAIT_MINUTES * 60) {
+                throw new Error(`Translation timed out after ${MAX_WAIT_MINUTES} minutes`);
+              }
+
+              const waitSeconds = Math.min(2 ** retries, 30);
+              if (verbose) {
+                console.log(chalk.blue(`  Job ${jobId} is ${status.status}, checking again in ${waitSeconds}s...`));
+              }
+              await new Promise(resolve => setTimeout(resolve, waitSeconds * 1000));
+              retries = Math.min(retries + 1, 5);
+              return { jobId, status: 'pending' };
+            }
 
-        if (!sourceFiles.length) {
-            console.error(chalk.red(`❌ No source files found for locale ${config.sourceLocale}`));
-            process.exit(1);
-        }
+            if (status.status === 'completed' && status.translations?.data && status.language?.code) {
+              if (status.results_url && !resultsBaseUrl) {
+                resultsBaseUrl = status.results_url.split('?')[0];
+              }
 
-        log(chalk.blue(`✓ Found ${allFiles.length} translation files`));
-        log(chalk.blue(`ℹ️  Analyzing target translations...`));
-
-        const missingByLocale = {};
-        for (const sourceFile of sourceFiles) {
-            const sourceContent = JSON.parse(Buffer.from(sourceFile.content, 'base64').toString());
-
-            for (const targetLocale of config.outputLocales) {
-                const targetFile = targetFiles.find(f => f.locale === targetLocale);
-                const targetContent = targetFile ?
-                    JSON.parse(Buffer.from(targetFile.content, 'base64').toString()) :
-                    { keys: {} };
-
-                const missing = findMissingTranslations(sourceContent.keys, targetContent.keys);
-                const missingCount = Object.keys(missing).length;
-
-                if (missingCount > 0) {
-                    if (!missingByLocale[targetLocale]) {
-                        missingByLocale[targetLocale] = {
-                            keys: {},
-                            path: sourceFile.path
-                        };
-                    }
-                    missingByLocale[targetLocale].keys = {
-                        ...missingByLocale[targetLocale].keys,
-                        ...missing
-                    };
-                    console.log(chalk.blue(`  ${targetLocale} (${path.basename(sourceFile.path)}): ${missingCount} missing keys`));
+              const languageCode = status.language.code;
+              if (!processedLocales.has(languageCode)) {
+                const targetPath = missingByLocale[languageCode].targetPath;
+                if (verbose) {
+                  console.log(chalk.blue(`  Updating translations for ${languageCode} in ${targetPath}`));
                 }
+                await translationUtils.updateTranslationFile(targetPath, status.translations.data, languageCode);
+                totalTranslated += missingByLocale[languageCode].keyCount;
+                totalLanguages++;
+                processedLocales.add(languageCode);
+              }
+              return { jobId, status: 'completed' };
             }
-        }
 
-        if (Object.keys(missingByLocale).length === 0) {
-            console.log(chalk.green('✓ All translations are up to date!'));
-            return;
-        }
+            return { jobId, status: status.status };
+          } while (status.status === 'pending' || status.status === 'processing');
+        });
 
-        const updatedFiles = new Set();
-        const batches = batchKeysWithMissing(sourceFiles, missingByLocale);
-        let totalKeysProcessed = 0;
-        let totalErrors = 0;
-        const processedKeys = new Set();
-        let hasShownUpdateMessage = false;
-
-        for (const [batchIndex, batch] of batches.entries()) {
-            log(chalk.blue(`\nProcessing batch ${batchIndex + 1}/${batches.length}...`));
-
-            try {
-                const { jobs } = await retryWithBackoff(() =>
-                    createTranslationJob({
-                        sourceFiles: batch,
-                        targetLocales: config.outputLocales,
-                        projectId: config.projectId
-                    })
-                );
-                const jobStatuses = new Map();
-                let allCompleted = false;
-
-                while (!allCompleted) {
-                    allCompleted = true;
-                    let totalProgress = 0;
-
-                    for (const job of jobs) {
-                        const status = await retryWithBackoff(() => checkJobStatus(job.id, true));
-                        jobStatuses.set(job.id, status);
-
-                        if (status.status === 'processing') {
-                            allCompleted = false;
-                        }
-                        totalProgress += status.progress.percentage;
-                    }
-
-                    const averageProgress = Math.round(totalProgress / jobs.length);
-                    const bar = '='.repeat(averageProgress / 2) + ' '.repeat(50 - averageProgress / 2);
-
-                    process.stdout.write(`\r⧗ Translating... [${bar}] ${averageProgress}%`);
-
-                    await new Promise(resolve => setTimeout(resolve, 2000));
-                }
+        const results = await Promise.all(jobPromises);
+        results.forEach(result => {
+          if (result.status === 'completed') {
+            pendingJobs.delete(result.jobId);
+          }
+        });
 
-                for (const job of jobs) {
-                    const status = jobStatuses.get(job.id);
-                    if (status.status === 'completed' && status.translations) {
-                        if (!hasShownUpdateMessage) {
-                            console.log(chalk.blue('\nℹ️  Updating translation files...'));
-                            hasShownUpdateMessage = true;
-                        }
-
-                        const translations = status.translations.translations;
-                        const targetLocale = status.language.code;
-                        const uniqueKey = `${targetLocale}:${Object.keys(translations).sort().join(',')}`;
-
-                        if (processedKeys.has(uniqueKey)) {
-                            continue;
-                        }
-                        processedKeys.add(uniqueKey);
-
-                        const targetFile = targetFiles.find(f => f.locale === targetLocale)?.path ||
-                            path.join(config.translationPath, `${targetLocale}.yml`);
-
-                        try {
-                            const updatedKeys = await updateTranslationFile(
-                                targetFile,
-                                translations,
-                                targetLocale
-                            );
-
-                            updatedFiles.add(targetFile);
-                            totalKeysProcessed += updatedKeys.length;
-
-                            if (verbose) {
-                                console.log(chalk.blue(`  Updated ${targetFile}`));
-                                updatedKeys.forEach(key => console.log(chalk.gray(`  - Added: ${key}`)));
-                            } else {
-                                console.log(chalk.blue(`  Updated ${path.basename(targetFile)}`));
-                            }
-                        } catch (error) {
-                            console.error(chalk.yellow(`⚠️  Failed to update ${targetFile}: ${error.message}`));
-                            totalErrors++;
-                        }
-                    }
-                }
-            } catch (error) {
-                totalErrors++;
-                console.error(chalk.red(`❌ Batch ${batchIndex + 1} failed: ${error.message}`));
-                console.log(error);
-
-            }
+        if (pendingJobs.size > 0) {
+          await new Promise(resolve => setTimeout(resolve, 2000));
         }
+      }
+    } catch (error) {
+      console.error(chalk.red(`\n✖ Error processing translation jobs: ${error.message}\n`));
+      process.exit(1);
+    }
+  }
 
-        if (totalErrors > 0) {
-            console.error(chalk.red(`\n❌ Translation completed with ${totalErrors} failed batches`));
-            process.exit(1);
-        }
+  await configUtils.updateLastSyncedAt();
 
-        console.log(chalk.green('\n✓ Translations complete!') + ` Updated ${totalKeysProcessed} keys in ${config.outputLocales.length} languages`);
+  console.log(chalk.green('✓ Translations complete!'));
+  console.log(`Updated ${totalTranslated} keys in ${totalLanguages} languages`);
 
-        if (commit || process.env.GITHUB_ACTIONS === 'true') {
-            const translationPaths = Array.from(updatedFiles).join(' ');
-            if (translationPaths) {
-                autoCommitChanges(translationPaths);
-            }
-        }
+  // Auto-commit changes if we're running in GitHub Actions
+  if (totalTranslated > 0) {
+    try {
+      gitUtils.autoCommitChanges(config.translationFiles.paths.join(' '));
     } catch (error) {
-        console.error(chalk.red(`❌ ${error.message}`));
-        process.exit(1);
+      console.warn(chalk.yellow(`\nℹ Could not auto-commit changes: ${error.message}`));
     }
-} 
+  }
+
+  if (resultsBaseUrl && allJobIds.length > 0) {
+    const jobIdsParam = allJobIds.join(',');
+    console.log(`View job results at: ${resultsBaseUrl}?job_ids=${jobIdsParam}`);
+  }
+}

package/src/utils/auth.js

@@ -1,23 +1,23 @@
 import { configService } from './config.js';
 
 export async function getApiKey() {
-    const envKey = process.env.LOCALHERO_API_KEY;
-    if (envKey) {
-        return envKey;
-    }
+  const envKey = process.env.LOCALHERO_API_KEY;
+  if (typeof envKey === 'string' && envKey.trim() !== '') {
+    return envKey;
+  }
 
-    const config = await configService.getAuthConfig();
-    return config?.api_key;
+  const config = await configService.getAuthConfig();
+  return config?.api_key;
 }
 
 export async function checkAuth() {
-    try {
-        const apiKey = await getApiKey();
-        const isValidFormat = typeof apiKey === 'string' &&
-            /^tk_[a-f0-9]+$/.test(apiKey);
+  try {
+    const apiKey = await getApiKey();
+    const isValidFormat = typeof apiKey === 'string' &&
+      /^tk_[a-f0-9]+$/.test(apiKey);
 
-        return isValidFormat;
-    } catch (error) {
-        return false;
-    }
-} 
+    return isValidFormat;
+  } catch {
+    return false;
+  }
+}