@localheroai/cli 0.0.3 → 0.0.5

package/package.json

@@ -1,7 +1,12 @@
 {
   "name": "@localheroai/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "CLI tool for managing translations with LocalHero.ai",
+  "homepage": "https://localhero.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/localheroai/cli"
+  },
   "type": "module",
   "main": "src/index.js",
   "bin": {
@@ -41,7 +46,7 @@
   },
   "files": [
     "src",
-    "README.md",
+    "README",
     "LICENSE"
   ],
   "jest": {
@@ -59,4 +64,4 @@
       ]
     }
   }
-}
+}

package/src/commands/translate.js

@@ -76,6 +76,11 @@ export async function translate(options = {}, deps = defaultDeps) {
 
   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);
   }
 

package/src/utils/files.js

@@ -5,14 +5,22 @@ import path from 'path';
 import yaml from 'yaml';
 import { promises as fs } from 'fs';
 
-export function parseFile(content, format) {
+export function parseFile(content, format, filePath = '') {
   try {
     if (format === 'json') {
-      return JSON.parse(content);
+      try {
+        return JSON.parse(content);
+      } catch (jsonError) {
+        const errorInfo = jsonError.message.match(/at position (\d+)/)
+          ? jsonError.message
+          : `${jsonError.message} (check for missing commas, quotes, or brackets)`;
+        throw new Error(errorInfo);
+      }
     }
     return yaml.parse(content);
   } catch (error) {
-    throw new Error(`Failed to parse ${format} file: ${error.message}`);
+    const location = filePath ? ` in ${filePath}` : '';
+    throw new Error(`Failed to parse ${format} file${location}: ${error.message}`);
   }
 }
 
@@ -270,7 +278,7 @@ export async function findTranslationFiles(config, options = {}) {
 
         if (parseContent) {
           const content = await readFile(filePath, 'utf8');
-          const parsedContent = parseFile(content, format);
+          const parsedContent = parseFile(content, format, filePath);
 
           if (includeContent) {
             result.content = Buffer.from(content).toString('base64');
@@ -291,7 +299,19 @@ export async function findTranslationFiles(config, options = {}) {
 
         processedFiles.push(result);
       } catch (error) {
-        if (verbose) {
+        if (error.message.includes('Failed to parse') ||
+          error.message.includes('JSON') ||
+          error.message.includes('Unexpected token') ||
+          error.message.includes('Missing closing')) {
+          console.warn(chalk.yellow(`\nWarning: ${error.message}`));
+
+          const format = path.extname(file).slice(1);
+          if (format === 'json') {
+            console.warn(chalk.gray('  Tip: Check for missing commas, quotes, or brackets in your JSON file.'));
+          } else if (format === 'yml' || format === 'yaml') {
+            console.warn(chalk.gray('  Tip: Check for proper indentation and quote matching in your YAML file.'));
+          }
+        } else if (verbose) {
           console.warn(chalk.yellow(`Warning: ${error.message}`));
         }
       }

package/src/utils/github.js

@@ -34,7 +34,13 @@ export const githubService = {
 on:
   pull_request:
     paths:
-      ${translationPaths.map(p => `- "${p}"`).join('\n      ')}
+      ${translationPaths.map(p => {
+      // Check if path already contains a file pattern (*, ?, or {})
+      const hasPattern = /[*?{}]/.test(p);
+      // If it has a pattern, use it as is; otherwise, append /**
+      const formattedPath = hasPattern ? p : `${p}${p.endsWith('/') ? '' : '/'}**`;
+      return `- "${formattedPath}"`;
+    }).join('\n      ')}
 
 jobs:
   translate:
@@ -53,7 +59,7 @@ jobs:
     - name: Set up Node.js
       uses: actions/setup-node@v4
       with:
-        node-version: 18
+        node-version: 22
 
     - name: Run LocalHero CLI
       env:

package/src/utils/import-service.js

@@ -95,28 +95,27 @@ export const importService = {
       translations: allTranslations
     });
 
-    if (importResult.status === 'failed') {
+    if (importResult.import?.status === 'failed') {
       return {
-        ...importResult,
+        ...importResult.import,
         files: importedFiles
       };
     }
 
     let finalImportResult = importResult;
-    while (finalImportResult.status === 'processing') {
-      await new Promise(resolve => setTimeout(resolve, finalImportResult.poll_interval * 1000));
-      finalImportResult = await checkImportStatus(config.projectId, finalImportResult.id);
+    while (finalImportResult.import?.status === 'processing') {
+      await new Promise(resolve => setTimeout(resolve, finalImportResult.import.poll_interval * 1000));
+      finalImportResult = await checkImportStatus(config.projectId, finalImportResult.import.id);
 
-      if (finalImportResult.status === 'failed') {
+      if (finalImportResult.import?.status === 'failed') {
         return {
-          ...finalImportResult,
+          ...finalImportResult.import,
           files: importedFiles
         };
       }
     }
 
-    // Ensure we pass through all relevant fields from the API response
-    const { status, statistics, warnings, translations_url, sourceImport } = finalImportResult;
+    const { import: { status, statistics, warnings, translations_url, sourceImport } = {} } = finalImportResult;
     return {
       status,
       statistics,

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

@@ -1,112 +1,111 @@
 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);
-        }
+  try {
+    let existingContent = {};
+    let jsonFormat = 'nested';
+    let hasLanguageWrapper = false;
+    const result = {
+      updatedKeys: Object.keys(translations),
+      created: false
+    };
 
-        let updatedContent;
+    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);
+    }
 
-        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);
-        }
+    let updatedContent;
 
-        await fs.writeFile(filePath, JSON.stringify(updatedContent, null, 2));
-        return result;
-    } catch (error) {
-        throw new Error(`Failed to update JSON file ${filePath}: ${error.message}`);
+    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 = [];
+  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];
+    }
 
-        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;
+    const deletedKeys = [];
 
-            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];
-            }
+    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;
 
-            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;
+      for (let i = 0; i < lastIndex; i++) {
+        const key = keys[i];
+        if (!current[key] || typeof current[key] !== 'object') {
+          found = false;
+          break;
         }
-        await fs.writeFile(filePath, JSON.stringify(jsonContent, null, 2));
+        parent = current;
+        keyInParent = key;
+        current = current[key];
+      }
 
-        return deletedKeys;
-    } catch (error) {
-        throw new Error(`Failed to delete keys from JSON file ${filePath}: ${error.message}`);
+      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

@@ -2,180 +2,206 @@ 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 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);
-    }
+  const seqMatch = lines.find(line => /^\s*-\s+\S/.test(line));
+  if (seqMatch) {
+    options.indentSeq = /^\s+-\s+/.test(seqMatch);
+  }
 
-    return options;
+  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;
-    });
+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))
+  );
 }
 
-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 } };
-    }
+function shouldForceQuotes(str) {
+  if (typeof str !== 'string') return false;
 
-    const content = await fs.readFile(filePath, 'utf8');
-    const options = detectYamlOptions(content);
-    return {
-        doc: yaml.parseDocument(content),
-        created: false,
-        options
-    };
-}
+  // Special case: strings containing quotes but no interpolation
+  // don't need outer quotes
+  if (str.includes('"') && !str.includes(INTERPOLATION)) {
+    return false;
+  }
 
-async function updateYamlTranslations(yamlDoc, translations, languageCode) {
-    if (!yamlDoc.contents) {
-        yamlDoc.contents = yamlDoc.createNode({});
-    }
+  return needsQuotes(str);
+}
 
-    const rootNode = yamlDoc.contents;
-    if (!rootNode.has(languageCode)) {
-        rootNode.set(languageCode, yamlDoc.createNode({}));
+function processArrayItems(array, yamlDoc) {
+  return array.map(item => {
+    const itemNode = yamlDoc.createNode(item);
+    if (shouldForceQuotes(item)) {
+      itemNode.type = 'QUOTE_DOUBLE';
     }
+    return itemNode;
+  });
+}
 
-    const langNode = rootNode.get(languageCode);
-
-    for (const [keyPath, newValue] of Object.entries(translations)) {
-        const keys = keyPath.split('.');
-        let current = langNode;
+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
+  };
+}
 
-        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);
-        }
+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];
+    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;
-        }
+    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;
-        }
+    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;
-        }
+    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);
+    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);
+  const { doc: yamlDoc, created, options } = await createYamlDocument(filePath);
 
-    await updateYamlTranslations(yamlDoc, translations, languageCode);
+  await updateYamlTranslations(yamlDoc, translations, languageCode);
 
-    yamlDoc.options.indent = options.indent;
-    yamlDoc.options.indentSeq = options.indentSeq;
+  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
-    };
+  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 [];
-        }
+  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);
-                    }
-                }
-            }
+    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;
         }
-
-        await fs.writeFile(filePath, yamlDoc.toString());
-        return deletedKeys;
-    } catch (error) {
-        throw new Error(`Failed to delete keys from YAML file ${filePath}: ${error.message}`);
+        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

@@ -155,11 +155,53 @@ export function batchKeysWithMissing(sourceFiles, missingByLocale, batchSize = 1
 }
 
 export function findTargetFile(targetFiles, targetLocale, sourceFile, sourceLocale) {
-  return targetFiles.find(f =>
+  // First try exact directory matching (existing logic)
+  let found = 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))
+    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)
   );
+
+  if (found) return found;
+
+  // Then try filename-based matching regardless of directory (existing logic)
+  found = targetFiles.find(f =>
+    f.locale === targetLocale &&
+    path.basename(f.path, path.extname(f.path)) === path.basename(sourceFile.path, path.extname(sourceFile.path)).replace(sourceLocale, targetLocale)
+  );
+
+  if (found) return found;
+
+  const sourceDirParts = path.dirname(sourceFile.path).split(path.sep);
+  const sourceFileBaseName = path.basename(sourceFile.path, path.extname(sourceFile.path));
+
+  // Check for corresponding file in subdirectories or parent directories
+  return targetFiles.find(f => {
+    if (f.locale !== targetLocale) return false;
+
+    // Handle cases where files are in different subdirectories
+    const targetDirParts = path.dirname(f.path).split(path.sep);
+    const targetFileBaseName = path.basename(f.path, path.extname(f.path));
+
+    if (
+      sourceFileBaseName === sourceLocale &&
+      targetFileBaseName === targetLocale &&
+      sourceDirParts.length === targetDirParts.length
+    ) {
+      return true;
+    }
+
+    // Nested directory structure
+    if (sourceDirParts.includes(sourceLocale) && targetDirParts.includes(targetLocale)) {
+      const sourceBasePath = sourceDirParts.slice(0, sourceDirParts.indexOf(sourceLocale)).join(path.sep);
+      const targetBasePath = targetDirParts.slice(0, targetDirParts.indexOf(targetLocale)).join(path.sep);
+
+      return sourceBasePath === targetBasePath &&
+        sourceFileBaseName === targetFileBaseName;
+    }
+
+    return false;
+  });
 }
 
 export function generateTargetPath(sourceFile, targetLocale, sourceLocale) {
@@ -195,7 +237,6 @@ export function generateTargetPath(sourceFile, targetLocale, sourceLocale) {
   // 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);