@localheroai/cli 0.0.1 → 0.0.3

package/src/commands/login.js

@@ -1,69 +1,80 @@
-import { promises as fs } from 'fs';
-import path from 'path';
 import chalk from 'chalk';
 import { createPromptService } from '../utils/prompt-service.js';
 import { updateGitignore } from '../utils/git.js';
-import { defaultDependencies } from '../utils/defaults.js';
 import { verifyApiKey as defaultVerifyApiKey } from '../api/auth.js';
 import { configService } from '../utils/config.js';
 
 const API_KEY_PATTERN = /^tk_[a-zA-Z0-9]{48}$/;
 
-export async function login(deps = defaultDependencies) {
-    const {
-        console = global.console,
-        basePath = process.cwd(),
-        promptService = createPromptService({ inquirer: await import('@inquirer/prompts') }),
-        verifyApiKey = defaultVerifyApiKey,
-        gitUtils = { updateGitignore },
-        configUtils = configService
-    } = deps;
+export async function login(deps = {}) {
+  const {
+    console = global.console,
+    basePath = process.cwd(),
+    promptService = createPromptService({ inquirer: await import('@inquirer/prompts') }),
+    verifyApiKey = defaultVerifyApiKey,
+    gitUtils = { updateGitignore },
+    configUtils = configService,
+    isCalledFromInit = false
+  } = deps;
 
-    const existingConfig = await configUtils.getAuthConfig(basePath);
+  const existingConfig = await configUtils.getAuthConfig(basePath);
 
-    if (existingConfig?.api_key) {
-        console.log(chalk.yellow('\n⚠️  Warning: This will replace your existing API key configuration'));
-    }
+  if (existingConfig?.api_key) {
+    console.log(chalk.yellow('\n⚠️  Warning: This will replace your existing API key configuration'));
+  }
 
-    const apiKey = process.env.LOCALHERO_API_KEY || (
-        console.log(chalk.blue('\nℹ️  Please enter your API key from https://localhero.ai/api-keys\n')),
-        await promptService.getApiKey()
-    );
+  const apiKey = process.env.LOCALHERO_API_KEY || (
+    console.log('\n→ Get your API key from: https://localhero.ai/api-keys'),
+    console.log('→ New to LocalHero? Sign up at: https://localhero.ai/signup'),
+    console.log(chalk.gray('The API key will be saved to .localhero_key, and automatically added to your .gitignore file.\n')),
+    await promptService.getApiKey()
+  );
 
-    if (!API_KEY_PATTERN.test(apiKey)) {
-        throw new Error('Invalid API key format');
-    }
+  if (!apiKey) {
+    throw new Error('User cancelled');
+  }
+
+  if (!API_KEY_PATTERN.test(apiKey)) {
+    throw new Error('Invalid API key format');
+  }
 
-    const result = await verifyApiKey(apiKey);
+  const result = await verifyApiKey(apiKey);
 
-    if (result.error) {
-        throw new Error(result.error.message);
+  if (result.error) {
+    if (result.error.code === 'invalid_api_key') {
+      console.log(chalk.red('\n❌ ' + result.error.message));
+      console.log(chalk.blue('\nℹ️  Get a new API key at https://localhero.ai/api-keys'));
+      process.exit(1);
     }
+    throw new Error(result.error.message);
+  }
 
-    const config = {
-        api_key: apiKey,
-        last_verified: new Date().toISOString()
-    };
+  const config = {
+    api_key: apiKey,
+    last_verified: new Date().toISOString()
+  };
 
-    await configUtils.saveAuthConfig(config, basePath);
-    const gitignoreUpdated = await gitUtils.updateGitignore(basePath);
+  await configUtils.saveAuthConfig(config, basePath);
+  const gitignoreUpdated = await gitUtils.updateGitignore(basePath);
 
-    console.log(chalk.green('\n✓ API key verified and saved to .localhero_key'));
-    if (gitignoreUpdated) {
-        console.log(chalk.green('✓ Added .localhero_key to .gitignore'));
-    }
+  console.log(chalk.green('\n✓ API key verified and saved to .localhero_key'));
+  if (gitignoreUpdated) {
+    console.log(chalk.green('✓ Added .localhero_key to .gitignore'));
+  }
 
-    console.log(chalk.blue(`💼️  Organization: ${result.organization.name}`));
-    console.log(chalk.blue(`📚  Projects: ${result.organization.projects.map(p => p.name).join(', ')}`));
+  console.log(chalk.blue(`💼️  Organization: ${result.organization.name}`));
+  if (result.organization.projects.length > 0) {
+    console.log(chalk.blue(`\n📚  Projects: ${result.organization.projects.map(p => p.name).join(', ')}`));
+  }
 
-    const projectConfig = await configUtils.getProjectConfig(basePath);
+  const projectConfig = await configUtils.getProjectConfig(basePath);
 
-    if (!projectConfig) {
-        console.log(chalk.yellow('\n⚠️  Almost there! You need to set up your project configuration.'));
-        console.log(chalk.blue('Run this next:'));
-        console.log(chalk.white('\n  npx localhero init\n'));
-    } else {
-        console.log('\nYou\'re ready to start translating!');
-        console.log('Try running: npx localhero translate');
-    }
-} 
+  if (!projectConfig && !isCalledFromInit) {
+    console.log(chalk.yellow('\n⚠️  Almost there! You need to set up your project configuration.'));
+    console.log(chalk.blue('Run this next:'));
+    console.log(chalk.white('\n  npx @localheroai/cli init\n'));
+  } else if (!isCalledFromInit) {
+    console.log('\nYou\'re ready to start translating!');
+    console.log('Try running: npx @localheroai/cli translate');
+  }
+}

package/src/commands/sync.js

@@ -0,0 +1,28 @@
+import { syncService as defaultSyncService } from '../utils/sync-service.js';
+import chalk from 'chalk';
+
+export async function sync({ verbose = false } = {}, deps = { syncService: defaultSyncService }) {
+  const { syncService } = deps;
+  const { hasUpdates, updates } = await syncService.checkForUpdates({ verbose });
+
+  if (!hasUpdates) {
+    console.log(chalk.green('✓ All translations are up to date'));
+    return;
+  }
+
+  const result = await syncService.applyUpdates(updates, { verbose });
+
+  const { totalUpdates = 0, totalDeleted = 0 } = result;
+
+  if (!verbose) {
+    if (totalUpdates > 0) {
+      console.log(chalk.green(`✓ Updated ${totalUpdates} translations`));
+    }
+
+    if (totalDeleted > 0) {
+      console.log(chalk.green(`✓ Deleted ${totalDeleted} keys`));
+    }
+  }
+
+  return result;
+}

package/src/commands/translate.js

@@ -1,282 +1,262 @@
 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`));
+    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}`);
+  }
+}