@localheroai/cli 0.0.2 → 0.0.3

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,112 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+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,181 @@
+import { promises as fs } from 'fs';
+import yaml from 'yaml';
+import { SPECIAL_CHARS_REGEX, INTERPOLATION, fileExists, tryParseJsonArray } from './common.js';
+
+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 processArrayItems(array, yamlDoc) {
+    return array.map(item => {
+        const itemNode = yamlDoc.createNode(item);
+        if (typeof item === 'string') {
+            const needsQuotes = item.includes(INTERPOLATION) || SPECIAL_CHARS_REGEX.test(item);
+            if (needsQuotes) {
+                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 } };
+    }
+
+    const content = await fs.readFile(filePath, 'utf8');
+    const options = detectYamlOptions(content);
+    return {
+        doc: yaml.parseDocument(content),
+        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 (typeof newValue === 'string' && (newValue.includes(INTERPOLATION) || SPECIAL_CHARS_REGEX.test(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;
+
+    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}`);
+    }
+}

package/src/utils/translation-utils.js

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

package/src/utils/defaults.js

@@ -1,7 +0,0 @@
-import inquirer from 'inquirer';
-
-export const defaultDependencies = {
-    inquirer,
-    console: global.console,
-    basePath: process.cwd(),
-}; 

package/src/utils/helpers.js

@@ -1,3 +0,0 @@
-export function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-} 

package/src/utils/project-service.js

@@ -1,11 +0,0 @@
-import { createProject as apiCreateProject, listProjects as apiListProjects } from '../api/projects.js';
-
-export const defaultProjectService = {
-    async createProject({ name, sourceLocale, targetLocales }) {
-        return apiCreateProject({ name, sourceLocale, targetLocales });
-    },
-
-    async listProjects() {
-        return apiListProjects();
-    }
-};