@localheroai/cli 0.0.2 → 0.0.5

package/src/utils/sync-service.js

@@ -0,0 +1,147 @@
+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-updater/common.js

@@ -0,0 +1,44 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+export const SPECIAL_CHARS_REGEX = /[:@#,[\]{}?|>&*!\n]/;
+export const INTERPOLATION = '%{';
+export const MAX_ARRAY_LENGTH = 1000;
+
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function ensureDirectoryExists(filePath) {
+    const dir = path.dirname(filePath);
+    if (dir !== '.') {
+        await fs.mkdir(dir, { recursive: true });
+    }
+}
+
+export function tryParseJsonArray(value) {
+    if (typeof value !== 'string' || !value.startsWith('["') || !value.endsWith('"]')) {
+        return null;
+    }
+
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return null;
+        }
+
+        if (parsed.length > MAX_ARRAY_LENGTH) {
+            console.warn(`Array length ${parsed.length} exceeds maximum allowed length of ${MAX_ARRAY_LENGTH}`);
+            return null;
+        }
+
+        return parsed;
+    } catch {
+        return null;
+    }
+}

package/src/utils/translation-updater/index.js

@@ -0,0 +1,36 @@
+import path from 'path';
+import { fileExists, ensureDirectoryExists } from './common.js';
+import { updateYamlFile, deleteKeysFromYamlFile } from './yaml-handler.js';
+import { updateJsonFile, deleteKeysFromJsonFile } from './json-handler.js';
+
+export async function updateTranslationFile(filePath, translations, languageCode = 'en') {
+    const fileExt = path.extname(filePath).slice(1).toLowerCase();
+    const result = {
+        updatedKeys: Object.keys(translations),
+        created: false
+    };
+
+    await ensureDirectoryExists(filePath);
+
+    if (fileExt === 'json') {
+        const jsonResult = await updateJsonFile(filePath, translations, languageCode);
+        return {
+            updatedKeys: result.updatedKeys,
+            created: jsonResult.created
+        };
+    }
+
+    return updateYamlFile(filePath, translations, languageCode);
+}
+
+export async function deleteKeysFromTranslationFile(filePath, keysToDelete, languageCode = 'en') {
+    const exists = await fileExists(filePath);
+    if (!exists) {
+        return [];
+    }
+
+    const fileExt = path.extname(filePath).slice(1).toLowerCase();
+    return fileExt === 'json'
+        ? deleteKeysFromJsonFile(filePath, keysToDelete, languageCode)
+        : deleteKeysFromYamlFile(filePath, keysToDelete, languageCode);
+}

package/src/utils/translation-updater/json-handler.js

@@ -0,0 +1,111 @@
+import { promises as fs } from 'fs';
+import { detectJsonFormat, preserveJsonStructure } from '../files.js';
+import { ensureDirectoryExists } from './common.js';
+
+export async function updateJsonFile(filePath, translations, languageCode) {
+  try {
+    let existingContent = {};
+    let jsonFormat = 'nested';
+    let hasLanguageWrapper = false;
+    const result = {
+      updatedKeys: Object.keys(translations),
+      created: false
+    };
+
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      existingContent = JSON.parse(content);
+      if (existingContent[languageCode] && typeof existingContent[languageCode] === 'object') {
+        hasLanguageWrapper = true;
+        jsonFormat = detectJsonFormat(existingContent[languageCode]);
+      } else {
+        jsonFormat = detectJsonFormat(existingContent);
+      }
+    } catch {
+      console.warn(`Creating new JSON file: ${filePath}`);
+      result.created = true;
+      await ensureDirectoryExists(filePath);
+    }
+
+    let updatedContent;
+
+    if (result.created) {
+      updatedContent = {
+        [languageCode]: preserveJsonStructure({}, translations, jsonFormat)
+      };
+    } else if (hasLanguageWrapper) {
+      existingContent[languageCode] = existingContent[languageCode] || {};
+      updatedContent = JSON.parse(JSON.stringify(existingContent));
+      const mergedContent = preserveJsonStructure(
+        existingContent[languageCode],
+        translations,
+        jsonFormat
+      );
+      updatedContent[languageCode] = mergedContent;
+    } else {
+      const existingCopy = JSON.parse(JSON.stringify(existingContent));
+      updatedContent = preserveJsonStructure(existingCopy, translations, jsonFormat);
+    }
+
+    await fs.writeFile(filePath, JSON.stringify(updatedContent, null, 2));
+    return result;
+  } catch (error) {
+    throw new Error(`Failed to update JSON file ${filePath}: ${error.message}`);
+  }
+}
+
+export async function deleteKeysFromJsonFile(filePath, keysToDelete, languageCode) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    let jsonContent = JSON.parse(content);
+    let hasLanguageWrapper = false;
+    let rootContent = jsonContent;
+    if (jsonContent[languageCode] && typeof jsonContent[languageCode] === 'object') {
+      hasLanguageWrapper = true;
+      rootContent = jsonContent[languageCode];
+    }
+
+    const deletedKeys = [];
+
+    for (const keyPath of keysToDelete) {
+      const keys = keyPath.split('.');
+      const lastIndex = keys.length - 1;
+      let current = rootContent;
+      let parent = null;
+      let keyInParent = '';
+      let found = true;
+
+      for (let i = 0; i < lastIndex; i++) {
+        const key = keys[i];
+        if (!current[key] || typeof current[key] !== 'object') {
+          found = false;
+          break;
+        }
+        parent = current;
+        keyInParent = key;
+        current = current[key];
+      }
+
+      if (found) {
+        const lastKey = keys[lastIndex];
+        if (current[lastKey] !== undefined) {
+          delete current[lastKey];
+          deletedKeys.push(keyPath);
+          if (parent && Object.keys(current).length === 0) {
+            delete parent[keyInParent];
+          }
+        }
+      }
+    }
+    if (hasLanguageWrapper) {
+      jsonContent[languageCode] = rootContent;
+    } else {
+      jsonContent = rootContent;
+    }
+    await fs.writeFile(filePath, JSON.stringify(jsonContent, null, 2));
+
+    return deletedKeys;
+  } catch (error) {
+    throw new Error(`Failed to delete keys from JSON file ${filePath}: ${error.message}`);
+  }
+}

package/src/utils/translation-updater/yaml-handler.js

@@ -0,0 +1,207 @@
+import { promises as fs } from 'fs';
+import yaml from 'yaml';
+import { SPECIAL_CHARS_REGEX, INTERPOLATION, fileExists, tryParseJsonArray } from './common.js';
+
+const NEEDS_QUOTES_REGEX = /[:,%{}[\]|><!&*?-]/;
+const LINE_WIDTH = 80;
+
+function detectYamlOptions(content) {
+  const lines = content
+    .split('\n')
+    .filter(line => line.trim())
+    .slice(0, 10);
+
+  const options = {
+    indent: 2,
+    indentSeq: true
+  };
+
+  const indentMatch = lines.find(line => /^\s+\S/.test(line))?.match(/^(\s+)\S/);
+  if (indentMatch) {
+    options.indent = indentMatch[1].length;
+    if (indentMatch[1].includes('\t')) {
+      options.indent = 2;
+    }
+  }
+
+  const seqMatch = lines.find(line => /^\s*-\s+\S/.test(line));
+  if (seqMatch) {
+    options.indentSeq = /^\s+-\s+/.test(seqMatch);
+  }
+
+  return options;
+}
+
+function needsQuotes(str) {
+  if (typeof str !== 'string') return false;
+
+  return (
+    SPECIAL_CHARS_REGEX.test(str) ||
+    str.includes(INTERPOLATION) ||
+    NEEDS_QUOTES_REGEX.test(str) ||
+    (str.includes(' ') && /[:"']/g.test(str))
+  );
+}
+
+function shouldForceQuotes(str) {
+  if (typeof str !== 'string') return false;
+
+  // Special case: strings containing quotes but no interpolation
+  // don't need outer quotes
+  if (str.includes('"') && !str.includes(INTERPOLATION)) {
+    return false;
+  }
+
+  return needsQuotes(str);
+}
+
+function processArrayItems(array, yamlDoc) {
+  return array.map(item => {
+    const itemNode = yamlDoc.createNode(item);
+    if (shouldForceQuotes(item)) {
+      itemNode.type = 'QUOTE_DOUBLE';
+    }
+    return itemNode;
+  });
+}
+
+async function createYamlDocument(filePath) {
+  const exists = await fileExists(filePath);
+  if (!exists) {
+    console.warn(`Creating new file: ${filePath}`);
+    const doc = new yaml.Document();
+    doc.contents = doc.createNode({});
+    return { doc, created: true, options: { indent: 2, indentSeq: true, lineWidth: LINE_WIDTH } };
+  }
+
+  const content = await fs.readFile(filePath, 'utf8');
+  const options = detectYamlOptions(content);
+  const doc = yaml.parseDocument(content);
+  doc.options.lineWidth = LINE_WIDTH;
+  return {
+    doc,
+    created: false,
+    options
+  };
+}
+
+async function updateYamlTranslations(yamlDoc, translations, languageCode) {
+  if (!yamlDoc.contents) {
+    yamlDoc.contents = yamlDoc.createNode({});
+  }
+
+  const rootNode = yamlDoc.contents;
+  if (!rootNode.has(languageCode)) {
+    rootNode.set(languageCode, yamlDoc.createNode({}));
+  }
+
+  const langNode = rootNode.get(languageCode);
+
+  for (const [keyPath, newValue] of Object.entries(translations)) {
+    const keys = keyPath.split('.');
+    let current = langNode;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!current.has(key)) {
+        current.set(key, yamlDoc.createNode({}));
+      }
+      current = current.get(key);
+    }
+
+    const lastKey = keys[keys.length - 1];
+
+    if (Array.isArray(newValue)) {
+      const arrayNode = new yaml.YAMLSeq();
+      processArrayItems(newValue, yamlDoc).forEach(item => arrayNode.add(item));
+      current.set(lastKey, arrayNode);
+      continue;
+    }
+
+    const array = tryParseJsonArray(newValue);
+    if (array) {
+      const arrayNode = new yaml.YAMLSeq();
+      processArrayItems(array, yamlDoc).forEach(item => arrayNode.add(item));
+      current.set(lastKey, arrayNode);
+      continue;
+    }
+
+    if (typeof newValue === 'string' && newValue.includes('\n')) {
+      const scalar = new yaml.Scalar(newValue);
+      scalar.type = 'BLOCK_LITERAL';
+      current.set(lastKey, scalar);
+      continue;
+    }
+
+    const node = yamlDoc.createNode(newValue);
+    if (needsQuotes(newValue)) {
+      node.type = 'QUOTE_DOUBLE';
+    }
+    current.set(lastKey, node);
+  }
+}
+
+export async function updateYamlFile(filePath, translations, languageCode) {
+  const { doc: yamlDoc, created, options } = await createYamlDocument(filePath);
+
+  await updateYamlTranslations(yamlDoc, translations, languageCode);
+
+  yamlDoc.options.indent = options.indent;
+  yamlDoc.options.indentSeq = options.indentSeq;
+  yamlDoc.options.lineWidth = LINE_WIDTH;
+
+  await fs.writeFile(filePath, yamlDoc.toString());
+  return {
+    updatedKeys: Object.keys(translations),
+    created
+  };
+}
+
+export async function deleteKeysFromYamlFile(filePath, keysToDelete, languageCode) {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    const yamlDoc = yaml.parseDocument(content);
+    if (!yamlDoc.contents || !yamlDoc.contents.has(languageCode)) {
+      return [];
+    }
+
+    const langNode = yamlDoc.contents.get(languageCode);
+    const deletedKeys = [];
+
+    for (const keyPath of keysToDelete) {
+      const keys = keyPath.split('.');
+      const lastIndex = keys.length - 1;
+      let current = langNode;
+      let parent = null;
+      let keyInParent = '';
+      let found = true;
+
+      for (let i = 0; i < lastIndex; i++) {
+        const key = keys[i];
+        if (!current.has(key)) {
+          found = false;
+          break;
+        }
+        parent = current;
+        keyInParent = key;
+        current = current.get(key);
+      }
+
+      if (found) {
+        const lastKey = keys[lastIndex];
+        if (current.has(lastKey)) {
+          current.delete(lastKey);
+          deletedKeys.push(keyPath);
+          if (parent && current.items.length === 0) {
+            parent.delete(keyInParent);
+          }
+        }
+      }
+    }
+
+    await fs.writeFile(filePath, yamlDoc.toString());
+    return deletedKeys;
+  } catch (error) {
+    throw new Error(`Failed to delete keys from YAML file ${filePath}: ${error.message}`);
+  }
+}