@localheroai/cli 0.0.3 → 0.0.6

package/src/utils/prompt-service.js

@@ -1,67 +0,0 @@
-export function createPromptService(deps = {}) {
-  const { inquirer = null } = deps;
-
-  return {
-    async getApiKey() {
-      if (!inquirer) return '';
-      return inquirer.password({
-        message: 'API Key:',
-        mask: '*'
-      });
-    },
-
-    async getProjectSetup() {
-      if (!inquirer) return {};
-
-      return {
-        projectName: '',
-        sourceLocale: '',
-        outputLocales: [],
-        translationPath: '',
-        ignorePaths: []
-      };
-    },
-
-    async select(options) {
-      if (!inquirer) return 'new';
-      return inquirer.select(options);
-    },
-
-    async input(options) {
-      if (!inquirer) return '';
-      return inquirer.input(options);
-    },
-
-    async confirm(options) {
-      if (!inquirer) return false;
-      return inquirer.confirm(options);
-    },
-
-    async selectProject(projectService) {
-      const projects = await projectService.listProjects();
-
-      if (!projects || projects.length === 0) {
-        return { choice: 'new' };
-      }
-
-      const choices = [
-        { name: '✨ Create new project', value: 'new' },
-        { name: '─────────────', value: 'separator', disabled: true },
-        ...projects.map(p => ({
-          name: p.name,
-          value: p.id
-        }))
-      ];
-
-      const projectChoice = await this.select({
-        message: 'Would you like to use an existing project or create a new one?',
-        choices
-      });
-
-      return {
-        choice: projectChoice,
-        project: projects.find(p => p.id === projectChoice)
-      };
-    }
-  };
-}

package/src/utils/sync-service.js

@@ -1,147 +0,0 @@
-import chalk from 'chalk';
-import { configService } from './config.js';
-import { getUpdates } from '../api/translations.js';
-import { updateTranslationFile, deleteKeysFromTranslationFile } from './translation-updater/index.js';
-import { findTranslationFiles } from './files.js';
-
-const MAX_PAGES = 20;
-
-export const syncService = {
-  async checkForUpdates({ verbose = false } = {}) {
-    const config = await configService.getValidProjectConfig();
-
-    if (!config.projectId) {
-      throw new Error('Project not initialized. Please run `localhero init` first.');
-    }
-
-    const since = config.lastSyncedAt || new Date(0).toISOString();
-
-    if (verbose) {
-      console.log(chalk.blue(`Checking for updates since ${since}`));
-    }
-
-    let allFiles = [];
-    let deletedKeys = [];
-    let currentPage = 1;
-    let hasMorePages = true;
-
-    while (hasMorePages && currentPage <= MAX_PAGES) {
-      const response = await getUpdates(config.projectId, { since, page: currentPage });
-
-      if (response.updates?.updated_keys?.length) {
-        allFiles = allFiles.concat(response.updates.updated_keys);
-      }
-
-      if (response.updates?.deleted_keys?.length) {
-        deletedKeys = deletedKeys.concat(response.updates.deleted_keys);
-      }
-
-      if (response.pagination) {
-        const { current_page, total_pages } = response.pagination;
-        hasMorePages = current_page < total_pages;
-        currentPage++;
-
-        if (verbose && hasMorePages) {
-          if (total_pages > MAX_PAGES) {
-            console.log(chalk.yellow(`  ⚠️  Limiting to ${MAX_PAGES} pages out of ${total_pages} total`));
-          } else {
-            console.log(chalk.gray(`  Fetching page ${currentPage} of ${total_pages}`));
-          }
-        }
-      } else {
-        hasMorePages = false;
-      }
-    }
-
-    if (!allFiles.length && !deletedKeys.length) {
-      if (verbose) {
-        console.log(chalk.green('✓ All translations are up to date'));
-      }
-      return { hasUpdates: false };
-    }
-
-    return {
-      hasUpdates: true,
-      updates: {
-        updates: {
-          files: allFiles,
-          deleted_keys: deletedKeys
-        }
-      }
-    };
-  },
-
-  async applyUpdates(updates, { verbose = false } = {}) {
-    let totalUpdates = 0;
-    let totalDeleted = 0;
-    for (const file of updates.updates.files || []) {
-      for (const lang of file.languages) {
-        if (verbose) {
-          console.log(chalk.blue(`Updating ${lang.code} translations in ${file.path}`));
-        }
-
-        const translations = {};
-        for (const translation of lang.translations) {
-          translations[translation.key] = translation.value;
-          if (verbose) {
-            const displayValue = translation.value.length > 100 ? `${translation.value.slice(0, 100)}…` : translation.value;
-            console.log(chalk.gray(` ${translation.key} = ${displayValue}`));
-          }
-        }
-
-        try {
-          await updateTranslationFile(file.path, translations, lang.code);
-          totalUpdates += Object.keys(translations).length;
-        } catch (error) {
-          console.error(chalk.yellow(`⚠️  Failed to update ${file.path}: ${error.message}`));
-        }
-      }
-    }
-    const deletedKeys = updates.updates.deleted_keys || [];
-    if (deletedKeys.length > 0) {
-      if (verbose) {
-        console.log(chalk.blue(`\nProcessing ${deletedKeys.length} deleted keys`));
-      }
-      const config = await configService.getValidProjectConfig();
-      const translationFiles = await findTranslationFiles(config, {
-        parseContent: false,
-        includeContent: false,
-        extractKeys: false,
-        verbose
-      });
-
-      if (verbose) {
-        console.log(chalk.blue(`Found ${translationFiles.length} translation files to check for deleted keys`));
-      }
-      const keysToDelete = deletedKeys.map(key => key.name);
-      for (const file of translationFiles) {
-        try {
-          if (verbose) {
-            console.log(chalk.blue(`Checking for deleted keys in ${file.path} (${file.locale})`));
-          }
-
-          const deletedFromFile = await deleteKeysFromTranslationFile(file.path, keysToDelete, file.locale);
-
-          if (deletedFromFile.length > 0) {
-            totalDeleted += deletedFromFile.length;
-
-            if (verbose) {
-              console.log(chalk.green(`✓ Deleted ${deletedFromFile.length} keys from ${file.path}`));
-              for (const key of deletedFromFile) {
-                console.log(chalk.gray(` - ${key}`));
-              }
-            }
-          } else if (verbose) {
-            console.log(chalk.gray(`  No keys to delete in ${file.path}`));
-          }
-        } catch (error) {
-          console.error(chalk.yellow(`⚠️  Failed to delete keys from ${file.path}: ${error.message}`));
-        }
-      }
-    }
-
-    await configService.updateLastSyncedAt();
-
-    return { totalUpdates, totalDeleted };
-  }
-};

package/src/utils/translation-utils.js

@@ -1,237 +0,0 @@
-import path from 'path';
-import { flattenTranslations, parseFile } from './files.js';
-
-export function findMissingTranslations(sourceKeys, targetKeys) {
-  const missingKeys = {};
-  const skippedKeys = {};
-
-  for (const [key, details] of Object.entries(sourceKeys)) {
-    if (typeof details === 'string') {
-      if (
-        details.toLowerCase().includes('wip_') ||
-        details.toLowerCase().includes('_wip') ||
-        details.toLowerCase().includes('__skip_translation__')
-      ) {
-        skippedKeys[key] = {
-          value: details,
-          reason: 'wip'
-        };
-        continue;
-      }
-
-      if (!targetKeys[key]) {
-        missingKeys[key] = {
-          value: details,
-          sourceKey: key
-        };
-      }
-      continue;
-    }
-
-    if (typeof details === 'boolean') {
-      if (!targetKeys[key]) {
-        missingKeys[key] = {
-          value: details,
-          sourceKey: key
-        };
-      }
-      continue;
-    }
-
-    if (
-      typeof details === 'object' && details !== null &&
-      typeof details.value === 'string' &&
-      (details.value.toLowerCase().includes('wip_') || details.value.toLowerCase().includes('_wip') ||
-        details.value.toLowerCase().includes('__skip_translation__'))
-    ) {
-      skippedKeys[key] = {
-        ...details,
-        reason: 'wip'
-      };
-      continue;
-    }
-
-    if (!targetKeys[key]) {
-      if (typeof details === 'object' && details !== null && 'value' in details) {
-        missingKeys[key] = {
-          ...details,
-          sourceKey: key
-        };
-      } else {
-        missingKeys[key] = {
-          value: details,
-          sourceKey: key
-        };
-      }
-    }
-  }
-
-  return { missingKeys, skippedKeys };
-}
-
-
-export function batchKeysWithMissing(sourceFiles, missingByLocale, batchSize = 100) {
-  const batches = [];
-  const errors = [];
-  const sourceFileEntries = new Map();
-
-  for (const [locale, localeData] of Object.entries(missingByLocale)) {
-    const sourceFile = sourceFiles.find(f => f.path === localeData.path);
-    if (!sourceFile) {
-      errors.push({
-        type: 'missing_source_file',
-        message: `No source file found for path: ${localeData.path}`,
-        locale,
-        path: localeData.path
-      });
-      continue;
-    }
-
-    if (!sourceFileEntries.has(sourceFile.path)) {
-      sourceFileEntries.set(sourceFile.path, {
-        path: sourceFile.path,
-        format: sourceFile.format || 'json',
-        keys: {},
-        locales: new Set()
-      });
-    }
-
-    const entry = sourceFileEntries.get(sourceFile.path);
-
-    const formattedKeys = {};
-    for (const [key, value] of Object.entries(localeData.keys)) {
-      let extractedValue;
-
-      if (Array.isArray(value)) {
-        extractedValue = value;
-      } else if (typeof value === 'boolean') {
-        extractedValue = value;
-      } else if (typeof value === 'string') {
-        extractedValue = value;
-      } else if (typeof value === 'object' && value !== null) {
-        if ('value' in value) {
-          extractedValue = value.value;
-        } else if (Object.keys(value).some(k => !isNaN(parseInt(k, 10)))) {
-          extractedValue = Object.values(value).join('');
-        } else {
-          extractedValue = JSON.stringify(value);
-        }
-      } else {
-        extractedValue = String(value);
-      }
-
-      formattedKeys[key] = extractedValue;
-    }
-
-    entry.keys = { ...entry.keys, ...formattedKeys };
-    entry.locales.add(locale);
-  }
-
-  for (const entry of sourceFileEntries.values()) {
-    const keyEntries = Object.entries(entry.keys);
-
-    for (let i = 0; i < keyEntries.length; i += batchSize) {
-      const batchKeys = Object.fromEntries(keyEntries.slice(i, i + batchSize));
-
-      const contentObj = { keys: {} };
-      for (const [key, value] of Object.entries(batchKeys)) {
-        contentObj.keys[key] = {
-          value
-        };
-      }
-
-      batches.push({
-        files: [{
-          path: entry.path,
-          format: entry.format,
-          content: Buffer.from(JSON.stringify(contentObj)).toString('base64')
-        }],
-        locales: Array.from(entry.locales)
-      });
-    }
-  }
-
-  return { batches, errors };
-}
-
-export function findTargetFile(targetFiles, targetLocale, sourceFile, sourceLocale) {
-  return targetFiles.find(f =>
-    f.locale === targetLocale &&
-    (path.dirname(f.path) === path.dirname(sourceFile.path) ||
-      path.basename(f.path, path.extname(f.path)) === path.basename(sourceFile.path, path.extname(sourceFile.path)).replace(sourceLocale, targetLocale))
-  );
-}
-
-export function generateTargetPath(sourceFile, targetLocale, sourceLocale) {
-  const sourceExt = path.extname(sourceFile.path);
-  const sourceDir = path.dirname(sourceFile.path);
-  const sourceName = path.basename(sourceFile.path, sourceExt);
-
-  // Case 1: File is named exactly as the source locale (e.g., "en.yml")
-  if (sourceName === sourceLocale) {
-    return path.join(sourceDir, `${targetLocale}${sourceExt}`);
-  }
-
-  // Case 2: File ends with .locale (e.g., "translations.en.yml")
-  if (sourceName.endsWith(`.${sourceLocale}`)) {
-    const baseName = sourceName.slice(0, -(sourceLocale.length + 1));
-    return path.join(sourceDir, `${baseName}.${targetLocale}${sourceExt}`);
-  }
-
-  // Case 3: File uses hyphen-locale format (e.g., "translations-en.yml")
-  if (sourceName.includes(`-${sourceLocale}`)) {
-    const baseName = sourceName.slice(0, -(sourceLocale.length + 1));
-    return path.join(sourceDir, `${baseName}-${targetLocale}${sourceExt}`);
-  }
-
-  // Case 4: Source locale is a directory name
-  const sourceParentDir = path.basename(sourceDir);
-  if (sourceParentDir === sourceLocale) {
-    const grandParentDir = path.dirname(sourceDir);
-    return path.join(grandParentDir, targetLocale, path.basename(sourceFile.path));
-  }
-
-  // Default case: If none of the above patterns match,
-  // construct the target path by replacing the locale in the filename only
-  const dirPath = path.dirname(sourceFile.path);
-  const fileName = path.basename(sourceFile.path);
-  // Use regex to match the exact locale string to avoid partial matches
-  const localeRegex = new RegExp(`\\b${sourceLocale}\\b`, 'g');
-  const newFileName = fileName.replace(localeRegex, targetLocale);
-  return path.join(dirPath, newFileName);
-}
-
-export function processTargetContent(targetContent, targetLocale) {
-  if (targetContent[targetLocale]) {
-    return flattenTranslations(targetContent[targetLocale]);
-  }
-  return flattenTranslations(targetContent);
-}
-
-export function processLocaleTranslations(sourceKeys, targetLocale, targetFiles, sourceFile, sourceLocale) {
-  try {
-    const targetFile = findTargetFile(targetFiles, targetLocale, sourceFile, sourceLocale);
-    let targetKeys = {};
-    let targetPath = '';
-
-    if (targetFile) {
-      const targetContentRaw = Buffer.from(targetFile.content, 'base64').toString();
-      const targetContent = parseFile(targetContentRaw, targetFile.format);
-      targetKeys = processTargetContent(targetContent, targetLocale);
-      targetPath = targetFile.path;
-    } else {
-      targetPath = generateTargetPath(sourceFile, targetLocale, sourceLocale);
-    }
-
-    const { missingKeys, skippedKeys } = findMissingTranslations(sourceKeys, targetKeys);
-
-    return {
-      targetPath,
-      missingKeys,
-      skippedKeys,
-      targetFile
-    };
-  } catch (error) {
-    throw new Error(`Failed to process translations for ${targetLocale}: ${error.message}`);
-  }
-}