@lang-tag/cli 0.16.0 → 0.17.0

package/index.js

@@ -1,21 +1,73 @@
 #!/usr/bin/env node
 import { program } from "commander";
+import * as process$1 from "node:process";
+import process__default from "node:process";
 import fs, { readFileSync, existsSync } from "fs";
-import { writeFile, readFile } from "fs/promises";
-import JSON5 from "json5";
-import * as path from "path";
-import path__default, { sep, join, dirname } from "path";
 import { globby } from "globby";
-import path$1, { resolve } from "pathe";
+import * as path from "path";
+import path__default, { dirname, resolve, join, sep } from "path";
+import JSON5 from "json5";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import path$1, { resolve as resolve$1 } from "pathe";
 import { pathToFileURL, fileURLToPath } from "url";
 import "case";
-import * as process$1 from "node:process";
-import process__default from "node:process";
-import { f as flexibleImportAlgorithm, N as NamespaceCollector, $ as $LT_ReadFileContent, a as $LT_ReadJSON, b as $LT_WriteJSON, c as $LT_EnsureDirectoryExists, d as $LT_WriteFileWithDirs } from "./flexible-import-algorithm-C-S1c742.js";
-import * as acorn from "acorn";
+import { N as NamespaceCollector } from "./chunks/namespace-collector.js";
 import micromatch from "micromatch";
-import chokidar from "chokidar";
+import * as acorn from "acorn";
 import mustache from "mustache";
+import chokidar from "chokidar";
+function $LT_FilterInvalidTags(tags, config, logger) {
+  return tags.filter((tag) => {
+    if (tag.validity === "invalid-param-1")
+      logger.debug(
+        'Skipping tag "{fullMatch}". Invalid JSON: "{invalid}"',
+        {
+          fullMatch: tag.fullMatch.trim(),
+          invalid: tag.parameter1Text
+        }
+      );
+    if (tag.validity === "invalid-param-2")
+      logger.debug(
+        'Skipping tag "{fullMatch}". Invalid JSON: "{invalid}"',
+        {
+          fullMatch: tag.fullMatch.trim(),
+          invalid: tag.parameter2Text
+        }
+      );
+    if (tag.validity === "translations-not-found")
+      logger.debug(
+        'Skipping tag "{fullMatch}". Translations not found at parameter position: {pos}',
+        {
+          fullMatch: tag.fullMatch.trim(),
+          pos: config.translationArgPosition
+        }
+      );
+    return tag.validity === "ok";
+  });
+}
+function $LT_FilterEmptyNamespaceTags(tags, logger) {
+  return tags.filter((tag) => {
+    if (!tag.parameterConfig) {
+      logger.warn(
+        'Skipping tag "{fullMatch}". Tag configuration not defined. (Check lang-tag config at collect.onCollectConfigFix)',
+        {
+          fullMatch: tag.fullMatch.trim()
+        }
+      );
+      return false;
+    }
+    if (!tag.parameterConfig.namespace) {
+      logger.warn(
+        'Skipping tag "{fullMatch}". Tag configuration namespace not defined. (Check lang-tag config at collect.onCollectConfigFix)',
+        {
+          fullMatch: tag.fullMatch.trim()
+        }
+      );
+      return false;
+    }
+    return true;
+  });
+}
 class $LT_TagProcessor {
   constructor(config) {
     this.config = config;
@@ -26,7 +78,10 @@ class $LT_TagProcessor {
     const matches = [];
     let currentIndex = 0;
     const skipRanges = this.buildSkipRanges(fileContent);
-    const startPattern = new RegExp(`${optionalVariableAssignment}${tagName}\\(\\s*\\{`, "g");
+    const startPattern = new RegExp(
+      `${optionalVariableAssignment}${tagName}\\(\\s*\\{`,
+      "g"
+    );
     while (true) {
       startPattern.lastIndex = currentIndex;
       const startMatch = startPattern.exec(fileContent);
@@ -48,7 +103,10 @@ class $LT_TagProcessor {
         currentIndex = matchStartIndex + 1;
         continue;
       }
-      let parameter1Text = fileContent.substring(matchStartIndex + startMatch[0].length - 1, i);
+      let parameter1Text = fileContent.substring(
+        matchStartIndex + startMatch[0].length - 1,
+        i
+      );
       let parameter2Text;
       while (i < fileContent.length && (fileContent[i] === " " || fileContent[i] === "\n" || fileContent[i] === "	")) {
         i++;
@@ -100,7 +158,10 @@ class $LT_TagProcessor {
       }
       i++;
       const fullMatch = fileContent.substring(matchStartIndex, i);
-      const { line, column } = getLineAndColumn(fileContent, matchStartIndex);
+      const { line, column } = getLineAndColumn(
+        fileContent,
+        matchStartIndex
+      );
       let validity = "ok";
       let parameter1 = void 0;
       let parameter2 = void 0;
@@ -115,7 +176,9 @@ class $LT_TagProcessor {
             parameter2 = JSON5.parse(parameter2Text);
           } catch (error) {
             try {
-              parameter2 = JSON5.parse(this.escapeNewlinesInStrings(parameter2Text));
+              parameter2 = JSON5.parse(
+                this.escapeNewlinesInStrings(parameter2Text)
+              );
             } catch {
               validity = "invalid-param-2";
             }
@@ -123,7 +186,9 @@ class $LT_TagProcessor {
         }
       } catch (error) {
         try {
-          parameter1 = JSON5.parse(this.escapeNewlinesInStrings(parameter1Text));
+          parameter1 = JSON5.parse(
+            this.escapeNewlinesInStrings(parameter1Text)
+          );
         } catch {
           validity = "invalid-param-1";
         }
@@ -157,22 +222,31 @@ class $LT_TagProcessor {
       }
       const tag = R.tag;
       let newTranslationsString = R.translations;
-      if (!newTranslationsString) newTranslationsString = this.config.translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text || "{}";
-      else if (typeof newTranslationsString !== "string") newTranslationsString = JSON5.stringify(newTranslationsString);
-      if (!newTranslationsString) throw new Error("Tag must have translations provided!");
+      if (!newTranslationsString)
+        newTranslationsString = this.config.translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text || "{}";
+      else if (typeof newTranslationsString !== "string")
+        newTranslationsString = JSON5.stringify(newTranslationsString);
+      if (!newTranslationsString)
+        throw new Error("Tag must have translations provided!");
       try {
         JSON5.parse(newTranslationsString);
       } catch (error) {
-        throw new Error(`Tag translations are invalid object! Translations: ${newTranslationsString}`);
+        throw new Error(
+          `Tag translations are invalid object! Translations: ${newTranslationsString}`
+        );
       }
       let newConfigString = R.config;
-      if (!newConfigString && newConfigString !== null) newConfigString = tag.parameterConfig;
+      if (!newConfigString && newConfigString !== null)
+        newConfigString = tag.parameterConfig;
       if (newConfigString) {
         try {
-          if (typeof newConfigString === "string") JSON5.parse(newConfigString);
+          if (typeof newConfigString === "string")
+            JSON5.parse(newConfigString);
           else newConfigString = JSON5.stringify(newConfigString);
         } catch (error) {
-          throw new Error(`Tag config is invalid object! Config: ${newConfigString}`);
+          throw new Error(
+            `Tag config is invalid object! Config: ${newConfigString}`
+          );
         }
       }
       if (newConfigString === null && this.config.translationArgPosition === 2) {
@@ -183,7 +257,8 @@ class $LT_TagProcessor {
       let tagFunction = `${this.config.tagName}(${arg1}`;
       if (arg2) tagFunction += `, ${arg2}`;
       tagFunction += ")";
-      if (tag.variableName) replaceMap.set(tag, ` ${tag.variableName} = ${tagFunction}`);
+      if (tag.variableName)
+        replaceMap.set(tag, ` ${tag.variableName} = ${tagFunction}`);
       else replaceMap.set(tag, tagFunction);
     });
     let offset = 0;
@@ -376,127 +451,397 @@ function getLineAndColumn(text, matchIndex) {
   const column = lines[lines.length - 1].length + 1;
   return { line, column };
 }
-function $LT_FilterInvalidTags(tags, config, logger) {
-  return tags.filter((tag) => {
-    if (tag.validity === "invalid-param-1")
-      logger.debug('Skipping tag "{fullMatch}". Invalid JSON: "{invalid}"', {
-        fullMatch: tag.fullMatch.trim(),
-        invalid: tag.parameter1Text
-      });
-    if (tag.validity === "invalid-param-2")
-      logger.debug('Skipping tag "{fullMatch}". Invalid JSON: "{invalid}"', {
-        fullMatch: tag.fullMatch.trim(),
-        invalid: tag.parameter2Text
-      });
-    if (tag.validity === "translations-not-found")
-      logger.debug('Skipping tag "{fullMatch}". Translations not found at parameter position: {pos}', {
-        fullMatch: tag.fullMatch.trim(),
-        pos: config.translationArgPosition
-      });
-    return tag.validity === "ok";
-  });
-}
-function $LT_FilterEmptyNamespaceTags(tags, logger) {
-  return tags.filter((tag) => {
-    if (!tag.parameterConfig) {
-      logger.warn('Skipping tag "{fullMatch}". Tag configuration not defined. (Check lang-tag config at collect.onCollectConfigFix)', {
-        fullMatch: tag.fullMatch.trim()
-      });
-      return false;
+async function $LT_CollectCandidateFilesWithTags(props) {
+  const { config, logger } = props;
+  const processor = new $LT_TagProcessor(config);
+  const cwd = process__default.cwd();
+  let filesToScan = props.filesToScan;
+  if (!filesToScan) {
+    filesToScan = await globby(config.includes, {
+      cwd,
+      ignore: config.excludes,
+      absolute: true
+    });
+  }
+  const candidates = [];
+  for (const filePath of filesToScan) {
+    const fileContent = readFileSync(filePath, "utf-8");
+    let tags = processor.extractTags(fileContent);
+    if (!tags.length) {
+      continue;
     }
-    if (!tag.parameterConfig.namespace) {
-      logger.warn('Skipping tag "{fullMatch}". Tag configuration namespace not defined. (Check lang-tag config at collect.onCollectConfigFix)', {
-        fullMatch: tag.fullMatch.trim()
-      });
-      return false;
+    tags = $LT_FilterInvalidTags(tags, config, logger);
+    if (!tags.length) {
+      continue;
     }
-    return true;
-  });
-}
-function deepFreezeObject(obj) {
-  const propNames = Object.getOwnPropertyNames(obj);
-  for (const name of propNames) {
-    const value = obj[name];
-    if (value && typeof value === "object") {
-      deepFreezeObject(value);
+    for (let tag of tags) {
+      tag.parameterConfig = config.collect.onCollectConfigFix({
+        config: tag.parameterConfig,
+        langTagConfig: config
+      });
     }
+    tags = $LT_FilterEmptyNamespaceTags(tags, logger);
+    const relativeFilePath = path__default.relative(cwd, filePath);
+    candidates.push({ relativeFilePath, tags });
   }
-  return Object.freeze(obj);
+  return candidates;
 }
-async function checkAndRegenerateFileLangTags(config, logger, file, path2) {
-  let libraryImportsDir = config.import.dir;
-  if (!libraryImportsDir.endsWith(sep)) libraryImportsDir += sep;
-  const fileContent = readFileSync(file, "utf-8");
-  const processor = new $LT_TagProcessor(config);
-  let tags = processor.extractTags(fileContent);
-  tags = $LT_FilterInvalidTags(tags, config, logger);
-  if (!tags.length) {
-    return false;
+async function $LT_GroupTagsToCollections({
+  logger,
+  files,
+  config
+}) {
+  let totalTags = 0;
+  const collections = {};
+  function getTranslationsCollection(namespace) {
+    const collectionName = config.collect.collector.aggregateCollection(namespace);
+    const collection = collections[collectionName] || {};
+    if (!(collectionName in collections)) {
+      collections[collectionName] = collection;
+    }
+    return collection;
   }
-  const replacements = [];
-  let lastUpdatedLine = 0;
-  for (let tag of tags) {
-    let newConfig = void 0;
-    let shouldUpdate = false;
-    const frozenConfig = tag.parameterConfig ? deepFreezeObject(tag.parameterConfig) : tag.parameterConfig;
-    const event = {
-      langTagConfig: config,
-      config: frozenConfig,
-      absolutePath: file,
-      relativePath: path2,
-      isImportedLibrary: path2.startsWith(libraryImportsDir),
-      isSaved: false,
-      savedConfig: void 0,
-      save: (updatedConfig, triggerName) => {
-        if (!updatedConfig && updatedConfig !== null) throw new Error("Wrong config data");
-        newConfig = updatedConfig;
-        shouldUpdate = true;
-        event.isSaved = true;
-        event.savedConfig = updatedConfig;
-        logger.debug('Called save for "{path}" with config "{config}" triggered by: ("{trigger}")', { path: path2, config: JSON.stringify(updatedConfig), trigger: triggerName || "-" });
+  const allConflicts = [];
+  const existingValuesByNamespace = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    totalTags += file.tags.length;
+    for (const _tag of file.tags) {
+      const tag = config.collect.collector.transformTag(_tag);
+      const tagConfig = tag.parameterConfig;
+      const collection = getTranslationsCollection(tagConfig.namespace);
+      let existingValues = existingValuesByNamespace.get(
+        tagConfig.namespace
+      );
+      if (!existingValues) {
+        existingValues = /* @__PURE__ */ new Map();
+        existingValuesByNamespace.set(
+          tagConfig.namespace,
+          existingValues
+        );
       }
-    };
-    await config.onConfigGeneration(event);
-    if (!shouldUpdate) {
-      continue;
-    }
-    lastUpdatedLine = tag.line;
-    if (!isConfigSame(tag.parameterConfig, newConfig)) {
-      replacements.push({ tag, config: newConfig });
+      const valueTracker = {
+        get: (path2) => existingValues.get(path2),
+        trackValue: (path2, value) => {
+          existingValues.set(path2, {
+            tag,
+            relativeFilePath: file.relativeFilePath,
+            value
+          });
+        }
+      };
+      const addConflict = async (path2, tagA, tagBValue, conflictType) => {
+        if (conflictType === "path_overwrite" && config.collect?.ignoreConflictsWithMatchingValues !== false && tagA.value === tagBValue) {
+          return;
+        }
+        const conflict = {
+          path: path2,
+          tagA,
+          tagB: {
+            tag,
+            relativeFilePath: file.relativeFilePath,
+            value: tagBValue
+          },
+          conflictType
+        };
+        if (config.collect?.onConflictResolution) {
+          let shouldContinue = true;
+          await config.collect.onConflictResolution({
+            conflict,
+            logger,
+            exit() {
+              shouldContinue = false;
+            }
+          });
+          if (!shouldContinue) {
+            throw new Error(
+              `LangTagConflictResolution:Processing stopped due to conflict resolution: ${conflict.tagA.tag.parameterConfig.namespace}|${conflict.path}`
+            );
+          }
+        }
+        allConflicts.push(conflict);
+      };
+      const target = await ensureNestedObject(
+        tagConfig.path,
+        collection,
+        valueTracker,
+        addConflict
+      );
+      await mergeWithConflictDetection(
+        target,
+        tag.parameterTranslations,
+        tagConfig.path || "",
+        valueTracker,
+        addConflict
+      );
     }
   }
-  if (replacements.length) {
-    const newContent = processor.replaceTags(fileContent, replacements);
-    await writeFile(file, newContent, "utf-8");
-    const encodedFile = encodeURI(file);
-    logger.info('Lang tag configurations written for file "{path}" (file://{file}:{line})', { path: path2, file: encodedFile, line: lastUpdatedLine });
-    return true;
+  if (allConflicts.length > 0) {
+    logger.warn(`Found ${allConflicts.length} conflicts.`);
   }
-  return false;
+  if (config.collect?.onCollectFinish) {
+    let shouldContinue = true;
+    config.collect.onCollectFinish({
+      totalTags,
+      namespaces: collections,
+      conflicts: allConflicts,
+      logger,
+      exit() {
+        shouldContinue = false;
+      }
+    });
+    if (!shouldContinue) {
+      throw new Error(
+        `LangTagConflictResolution:Processing stopped due to collect finish handler`
+      );
+    }
+  }
+  return collections;
 }
-function isConfigSame(c1, c2) {
-  if (!c1 && !c2) return true;
-  if (c1 && typeof c1 === "object" && c2 && typeof c2 === "object" && JSON5.stringify(c1) === JSON5.stringify(c2)) return true;
-  return false;
+async function ensureNestedObject(path2, rootCollection, valueTracker, addConflict) {
+  if (!path2 || !path2.trim()) return rootCollection;
+  let current = rootCollection;
+  let currentPath = "";
+  for (const key of path2.split(".")) {
+    currentPath = currentPath ? `${currentPath}.${key}` : key;
+    if (current[key] !== void 0 && typeof current[key] !== "object") {
+      const existingInfo = valueTracker.get(currentPath);
+      if (existingInfo) {
+        await addConflict(
+          currentPath,
+          existingInfo,
+          {},
+          "type_mismatch"
+        );
+      }
+      return current;
+    }
+    current[key] = current[key] || {};
+    current = current[key];
+  }
+  return current;
 }
-const CONFIG_FILE_NAME = ".lang-tag.config.js";
-const EXPORTS_FILE_NAME = "lang-tags.json";
-const LANG_TAG_DEFAULT_CONFIG = {
-  tagName: "lang",
-  isLibrary: false,
-  includes: ["src/**/*.{js,ts,jsx,tsx}"],
-  excludes: ["node_modules", "dist", "build"],
-  localesDirectory: "locales",
-  baseLanguageCode: "en",
-  collect: {
-    collector: new NamespaceCollector(),
-    defaultNamespace: "common",
+async function mergeWithConflictDetection(target, source, basePath = "", valueTracker, addConflict) {
+  if (typeof target !== "object" || typeof source !== "object") {
+    return;
+  }
+  for (const key in source) {
+    if (!source.hasOwnProperty(key)) {
+      continue;
+    }
+    const currentPath = basePath ? `${basePath}.${key}` : key;
+    let targetValue = target[key];
+    const sourceValue = source[key];
+    if (Array.isArray(sourceValue)) {
+      continue;
+    }
+    if (targetValue !== void 0) {
+      const targetType = typeof targetValue;
+      const sourceType = typeof sourceValue;
+      let existingInfo = valueTracker.get(currentPath);
+      if (!existingInfo && targetType === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+        const findNestedInfo = (obj, prefix) => {
+          for (const key2 in obj) {
+            const path2 = prefix ? `${prefix}.${key2}` : key2;
+            const info = valueTracker.get(path2);
+            if (info) {
+              return info;
+            }
+            if (typeof obj[key2] === "object" && obj[key2] !== null && !Array.isArray(obj[key2])) {
+              const nestedInfo = findNestedInfo(obj[key2], path2);
+              if (nestedInfo) {
+                return nestedInfo;
+              }
+            }
+          }
+          return void 0;
+        };
+        existingInfo = findNestedInfo(targetValue, currentPath);
+      }
+      if (targetType !== sourceType) {
+        if (existingInfo) {
+          await addConflict(
+            currentPath,
+            existingInfo,
+            sourceValue,
+            "type_mismatch"
+          );
+        }
+        continue;
+      }
+      if (targetType !== "object") {
+        if (existingInfo) {
+          await addConflict(
+            currentPath,
+            existingInfo,
+            sourceValue,
+            "path_overwrite"
+          );
+        }
+        if (targetValue !== sourceValue) {
+          continue;
+        }
+      }
+    }
+    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue)) {
+      if (!targetValue) {
+        targetValue = {};
+        target[key] = targetValue;
+      }
+      await mergeWithConflictDetection(
+        targetValue,
+        sourceValue,
+        currentPath,
+        valueTracker,
+        addConflict
+      );
+    } else {
+      target[key] = sourceValue;
+      valueTracker.trackValue(currentPath, sourceValue);
+    }
+  }
+}
+const CONFIG_FILE_NAME = "lang-tag.config.js";
+const EXPORTS_FILE_NAME = "lang-tags.json";
+async function $LT_EnsureDirectoryExists(filePath) {
+  await mkdir(filePath, { recursive: true });
+}
+async function $LT_WriteJSON(filePath, data) {
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+async function $LT_ReadJSON(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function $LT_WriteFileWithDirs(filePath, content) {
+  const dir = dirname(filePath);
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (error) {
+  }
+  await writeFile(filePath, content, "utf-8");
+}
+async function $LT_ReadFileContent(relativeFilePath) {
+  const cwd = process.cwd();
+  const absolutePath = resolve(cwd, relativeFilePath);
+  return await readFile(absolutePath, "utf-8");
+}
+async function $LT_WriteAsExportFile({
+  config,
+  logger,
+  files
+}) {
+  const packageJson = await $LT_ReadJSON(
+    path__default.resolve(process.cwd(), "package.json")
+  );
+  if (!packageJson) {
+    throw new Error("package.json not found");
+  }
+  const exportData = {
+    baseLanguageCode: config.baseLanguageCode,
+    files: files.map(({ relativeFilePath, tags }) => ({
+      relativeFilePath,
+      tags: tags.map((tag) => ({
+        variableName: tag.variableName,
+        config: tag.parameterConfig,
+        translations: tag.parameterTranslations
+      }))
+    }))
+  };
+  await writeFile(EXPORTS_FILE_NAME, JSON.stringify(exportData), "utf-8");
+  logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
+}
+function deepMergeTranslations(target, source) {
+  if (typeof target !== "object") {
+    throw new Error("Target must be an object");
+  }
+  if (typeof source !== "object") {
+    throw new Error("Source must be an object");
+  }
+  let changed = false;
+  for (const key in source) {
+    if (!source.hasOwnProperty(key)) {
+      continue;
+    }
+    let targetValue = target[key];
+    const sourceValue = source[key];
+    if (typeof targetValue === "string" && typeof sourceValue === "object") {
+      throw new Error(
+        `Trying to write object into target key "${key}" which is translation already`
+      );
+    }
+    if (Array.isArray(sourceValue)) {
+      throw new Error(
+        `Trying to write array into target key "${key}", we do not allow arrays inside translations`
+      );
+    }
+    if (typeof sourceValue === "object") {
+      if (!targetValue) {
+        targetValue = {};
+        target[key] = targetValue;
+      }
+      if (deepMergeTranslations(targetValue, sourceValue)) {
+        changed = true;
+      }
+    } else {
+      if (target[key] !== sourceValue) {
+        changed = true;
+      }
+      target[key] = sourceValue;
+    }
+  }
+  return changed;
+}
+async function $LT_WriteToCollections({
+  config,
+  collections,
+  logger,
+  clean
+}) {
+  await config.collect.collector.preWrite(clean);
+  const changedCollections = [];
+  for (let collectionName of Object.keys(collections)) {
+    if (!collectionName) {
+      continue;
+    }
+    const filePath = await config.collect.collector.resolveCollectionFilePath(
+      collectionName
+    );
+    let originalJSON = {};
+    try {
+      originalJSON = await $LT_ReadJSON(filePath);
+    } catch (e) {
+      await config.collect.collector.onMissingCollection(
+        collectionName
+      );
+    }
+    if (deepMergeTranslations(originalJSON, collections[collectionName])) {
+      changedCollections.push(collectionName);
+      await $LT_WriteJSON(filePath, originalJSON);
+    }
+  }
+  await config.collect.collector.postWrite(changedCollections);
+}
+const LANG_TAG_DEFAULT_CONFIG = {
+  tagName: "lang",
+  isLibrary: false,
+  includes: ["src/**/*.{js,ts,jsx,tsx}"],
+  excludes: ["node_modules", "dist", "build"],
+  localesDirectory: "locales",
+  baseLanguageCode: "en",
+  collect: {
+    collector: new NamespaceCollector(),
+    defaultNamespace: "common",
     ignoreConflictsWithMatchingValues: true,
     onCollectConfigFix: ({ config, langTagConfig }) => {
       if (langTagConfig.isLibrary) return config;
-      if (!config) return { path: "", namespace: langTagConfig.collect.defaultNamespace };
+      if (!config)
+        return {
+          path: "",
+          namespace: langTagConfig.collect.defaultNamespace
+        };
       if (!config.path) config.path = "";
-      if (!config.namespace) config.namespace = langTagConfig.collect.defaultNamespace;
+      if (!config.namespace)
+        config.namespace = langTagConfig.collect.defaultNamespace;
       return config;
     },
     onConflictResolution: async (event) => {
@@ -509,25 +854,44 @@ const LANG_TAG_DEFAULT_CONFIG = {
   import: {
     dir: "src/lang-libraries",
     tagImportPath: 'import { lang } from "@/my-lang-tag-path"',
-    onImport: flexibleImportAlgorithm({
-      filePath: {
-        includePackageInPath: true
+    onImport: (event) => {
+      for (let e of event.exports) {
+        event.logger.info(
+          "Detected lang tag exports at package {packageName}",
+          { packageName: e.packageJSON.name }
+        );
       }
-    })
-    // onImport: ({importedRelativePath, fileGenerationData}: LangTagCLIOnImportParams, actions)=> {
-    //     const exportIndex = (fileGenerationData.index || 0) + 1;
-    //     fileGenerationData.index = exportIndex;
-    //
-    //     actions.setFile(path.basename(importedRelativePath));
-    //     actions.setExportName(`translations${exportIndex}`);
-    // }
+      event.logger.warn(
+        `
+Import Algorithm Not Configured
+
+To import external language tags, you need to configure an import algorithm.
+
+Setup Instructions:
+1. Add this import at the top of your configuration file:
+   {importStr}
+
+2. Replace import.onImport function with:
+   {onImport}
+
+This will enable import of language tags from external packages.
+            `.trim(),
+        {
+          importStr: "const { flexibleImportAlgorithm } = require('@lang-tag/cli/algorithms');",
+          onImport: "onImport: flexibleImportAlgorithm({ filePath: { includePackageInPath: true } })"
+        }
+      );
+    }
   },
   translationArgPosition: 1,
   onConfigGeneration: async (event) => {
+    event.logger.info(
+      "Config generation event is not configured. Add onConfigGeneration handler to customize config generation."
+    );
   }
 };
 async function $LT_ReadConfig(projectPath) {
-  const configPath = resolve(projectPath, CONFIG_FILE_NAME);
+  const configPath = resolve$1(projectPath, CONFIG_FILE_NAME);
   if (!existsSync(configPath)) {
     throw new Error(`No "${CONFIG_FILE_NAME}" detected`);
   }
@@ -539,7 +903,9 @@ async function $LT_ReadConfig(projectPath) {
     const userConfig = configModule.default || {};
     const tn = (userConfig.tagName || "").toLowerCase().replace(/[-_\s]/g, "");
     if (tn === "langtag" || tn === "lang-tag") {
-      throw new Error('Custom tagName cannot be "lang-tag" or "langtag"! (It is not recommended for use with libraries)\n');
+      throw new Error(
+        'Custom tagName cannot be "lang-tag" or "langtag"! (It is not recommended for use with libraries)\n'
+      );
     }
     const config = {
       ...LANG_TAG_DEFAULT_CONFIG,
@@ -561,6 +927,75 @@ async function $LT_ReadConfig(projectPath) {
     throw error;
   }
 }
+const ANSI$1 = {
+  reset: "\x1B[0m",
+  white: "\x1B[97m",
+  brightCyan: "\x1B[96m",
+  green: "\x1B[92m",
+  gray: "\x1B[90m",
+  redBg: "\x1B[41m\x1B[97m",
+  bold: "\x1B[1m"
+};
+function colorizeFromAST(code, nodes) {
+  const ranges = [];
+  for (const node of nodes) {
+    const color = getColorForNodeType(node.type);
+    const priority = getPriorityForNodeType(node.type);
+    ranges.push({
+      start: node.start,
+      end: node.end,
+      color,
+      priority
+    });
+  }
+  ranges.sort((a, b) => {
+    if (b.start !== a.start) return b.start - a.start;
+    return b.priority - a.priority;
+  });
+  let colorized = code;
+  for (const range of ranges) {
+    const before = colorized.substring(0, range.start);
+    const text = colorized.substring(range.start, range.end);
+    const after = colorized.substring(range.end);
+    colorized = before + range.color + text + ANSI$1.reset + after;
+  }
+  return colorized;
+}
+function getColorForNodeType(type) {
+  switch (type) {
+    case "key":
+      return ANSI$1.brightCyan;
+    case "bracket":
+    case "colon":
+      return ANSI$1.gray;
+    case "value":
+      return ANSI$1.green;
+    case "comment":
+      return ANSI$1.gray;
+    case "error":
+      return ANSI$1.bold + ANSI$1.redBg;
+    default:
+      return ANSI$1.white;
+  }
+}
+function getPriorityForNodeType(type) {
+  switch (type) {
+    case "error":
+      return 3;
+    // Highest priority
+    case "key":
+      return 2;
+    case "value":
+      return 1;
+    case "bracket":
+    case "colon":
+    case "comment":
+      return 0;
+    // Lowest priority
+    default:
+      return 0;
+  }
+}
 function parseObjectAST(code) {
   const nodes = [];
   try {
@@ -654,81 +1089,12 @@ function markConflictNodes(nodes, conflictPath) {
     return node;
   });
 }
-const ANSI$1 = {
+const ANSI = {
   reset: "\x1B[0m",
   white: "\x1B[97m",
-  brightCyan: "\x1B[96m",
-  green: "\x1B[92m",
-  gray: "\x1B[90m",
-  redBg: "\x1B[41m\x1B[97m",
-  bold: "\x1B[1m"
-};
-function colorizeFromAST(code, nodes) {
-  const ranges = [];
-  for (const node of nodes) {
-    const color = getColorForNodeType(node.type);
-    const priority = getPriorityForNodeType(node.type);
-    ranges.push({
-      start: node.start,
-      end: node.end,
-      color,
-      priority
-    });
-  }
-  ranges.sort((a, b) => {
-    if (b.start !== a.start) return b.start - a.start;
-    return b.priority - a.priority;
-  });
-  let colorized = code;
-  for (const range of ranges) {
-    const before = colorized.substring(0, range.start);
-    const text = colorized.substring(range.start, range.end);
-    const after = colorized.substring(range.end);
-    colorized = before + range.color + text + ANSI$1.reset + after;
-  }
-  return colorized;
-}
-function getColorForNodeType(type) {
-  switch (type) {
-    case "key":
-      return ANSI$1.brightCyan;
-    case "bracket":
-    case "colon":
-      return ANSI$1.gray;
-    case "value":
-      return ANSI$1.green;
-    case "comment":
-      return ANSI$1.gray;
-    case "error":
-      return ANSI$1.bold + ANSI$1.redBg;
-    default:
-      return ANSI$1.white;
-  }
-}
-function getPriorityForNodeType(type) {
-  switch (type) {
-    case "error":
-      return 3;
-    // Highest priority
-    case "key":
-      return 2;
-    case "value":
-      return 1;
-    case "bracket":
-    case "colon":
-    case "comment":
-      return 0;
-    // Lowest priority
-    default:
-      return 0;
-  }
-}
-const ANSI = {
-  reset: "\x1B[0m",
-  white: "\x1B[97m",
-  cyan: "\x1B[96m",
-  gray: "\x1B[37m",
-  darkGray: "\x1B[90m",
+  cyan: "\x1B[96m",
+  gray: "\x1B[37m",
+  darkGray: "\x1B[90m",
   bold: "\x1B[1m"
 };
 function getVisibleLines(totalLines, errorLines, threshold = 10) {
@@ -754,18 +1120,24 @@ function printLines(lines, startLineNumber, errorLines = /* @__PURE__ */ new Set
     lines.forEach((line, i) => {
       const lineNumber = startLineNumber + i;
       const lineNumStr = String(lineNumber).padStart(3, " ");
-      console.log(`${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`);
+      console.log(
+        `${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`
+      );
     });
   } else {
     let lastPrinted = -2;
     lines.forEach((line, i) => {
       if (visibleLines.has(i)) {
         if (i > lastPrinted + 1 && lastPrinted >= 0) {
-          console.log(`${ANSI.gray}  -${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${ANSI.gray}...${ANSI.reset}`);
+          console.log(
+            `${ANSI.gray}  -${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${ANSI.gray}...${ANSI.reset}`
+          );
         }
         const lineNumber = startLineNumber + i;
         const lineNumStr = String(lineNumber).padStart(3, " ");
-        console.log(`${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`);
+        console.log(
+          `${ANSI.gray}${lineNumStr}${ANSI.reset} ${ANSI.darkGray}│${ANSI.reset} ${line}`
+        );
         lastPrinted = i;
       }
     });
@@ -815,14 +1187,20 @@ async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgP
     const wholeTagCode = await getLangTagCodeSection(tagInfo);
     const translationTagCode = translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text;
     const configTagCode = translationArgPosition === 1 ? tag.parameter2Text : tag.parameter1Text;
-    const translationErrorPath = stripPrefix(conflictPath, tag.parameterConfig?.path);
+    const translationErrorPath = stripPrefix(
+      conflictPath,
+      tag.parameterConfig?.path
+    );
     let colorizedWhole = wholeTagCode;
     let errorLines = /* @__PURE__ */ new Set();
     if (translationTagCode) {
       try {
         const translationNodes = parseObjectAST(translationTagCode);
         const markedTranslationNodes = translationErrorPath ? markConflictNodes(translationNodes, translationErrorPath) : translationNodes;
-        const translationErrorLines = getErrorLineNumbers(translationTagCode, markedTranslationNodes);
+        const translationErrorLines = getErrorLineNumbers(
+          translationTagCode,
+          markedTranslationNodes
+        );
         const translationStartInWhole = wholeTagCode.indexOf(translationTagCode);
         if (translationStartInWhole >= 0) {
           const linesBeforeTranslation = wholeTagCode.substring(0, translationStartInWhole).split("\n").length - 1;
@@ -830,12 +1208,20 @@ async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgP
             errorLines.add(linesBeforeTranslation + lineNum2);
           });
           if (translationErrorLines.size > 0) {
-            const lastTranslationErrorLine = Math.max(...Array.from(translationErrorLines));
+            const lastTranslationErrorLine = Math.max(
+              ...Array.from(translationErrorLines)
+            );
             lineNum = startLine + linesBeforeTranslation + lastTranslationErrorLine;
           }
         }
-        const colorizedTranslation = colorizeFromAST(translationTagCode, markedTranslationNodes);
-        colorizedWhole = colorizedWhole.replace(translationTagCode, colorizedTranslation);
+        const colorizedTranslation = colorizeFromAST(
+          translationTagCode,
+          markedTranslationNodes
+        );
+        colorizedWhole = colorizedWhole.replace(
+          translationTagCode,
+          colorizedTranslation
+        );
       } catch (error) {
         console.error("Failed to colorize translation:", error);
       }
@@ -857,7 +1243,10 @@ async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgP
           }
           return node;
         });
-        const configErrorLines = getErrorLineNumbers(configTagCode, markedConfigNodes);
+        const configErrorLines = getErrorLineNumbers(
+          configTagCode,
+          markedConfigNodes
+        );
         const configStartInWhole = wholeTagCode.indexOf(configTagCode);
         if (configStartInWhole >= 0) {
           const linesBeforeConfig = wholeTagCode.substring(0, configStartInWhole).split("\n").length - 1;
@@ -865,14 +1254,22 @@ async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgP
             errorLines.add(linesBeforeConfig + lineNum2);
           });
         }
-        const colorizedConfig = colorizeFromAST(configTagCode, markedConfigNodes);
-        colorizedWhole = colorizedWhole.replace(configTagCode, colorizedConfig);
+        const colorizedConfig = colorizeFromAST(
+          configTagCode,
+          markedConfigNodes
+        );
+        colorizedWhole = colorizedWhole.replace(
+          configTagCode,
+          colorizedConfig
+        );
       } catch (error) {
         console.error("Failed to colorize config:", error);
       }
     }
     const encodedPath = encodeURI(filePath);
-    console.log(`${ANSI.gray}${prefix}${ANSI.reset} ${ANSI.cyan}file://${encodedPath}${ANSI.reset}${ANSI.gray}:${lineNum}${ANSI.reset}`);
+    console.log(
+      `${ANSI.gray}${prefix}${ANSI.reset} ${ANSI.cyan}file://${encodedPath}${ANSI.reset}${ANSI.gray}:${lineNum}${ANSI.reset}`
+    );
     printLines(colorizedWhole.split("\n"), startLine, errorLines, condense);
   } catch (error) {
     console.error("Error displaying conflict:", error);
@@ -880,8 +1277,20 @@ async function logTagConflictInfo(tagInfo, prefix, conflictPath, translationArgP
 }
 async function $LT_LogConflict(conflict, translationArgPosition, condense) {
   const { path: conflictPath, tagA, tagB } = conflict;
-  await logTagConflictInfo(tagA, "between", conflictPath, translationArgPosition, condense);
-  await logTagConflictInfo(tagB, "and", conflictPath, translationArgPosition, condense);
+  await logTagConflictInfo(
+    tagA,
+    "between",
+    conflictPath,
+    translationArgPosition,
+    condense
+  );
+  await logTagConflictInfo(
+    tagB,
+    "and",
+    conflictPath,
+    translationArgPosition,
+    condense
+  );
 }
 const ANSI_COLORS = {
   reset: "\x1B[0m",
@@ -895,14 +1304,18 @@ const ANSI_COLORS = {
   cyan: "\x1B[36m"
 };
 function validateAndInterpolate(message, params) {
-  const placeholders = Array.from(message.matchAll(/\{(\w+)\}/g)).map((m) => m[1]);
+  const placeholders = Array.from(message.matchAll(/\{(\w+)\}/g)).map(
+    (m) => m[1]
+  );
   const missing = placeholders.filter((p) => !(p in (params || {})));
   if (missing.length) {
     throw new Error(`Missing variables in message: ${missing.join(", ")}`);
   }
   const extra = params ? Object.keys(params).filter((k) => !placeholders.includes(k)) : [];
   if (extra.length) {
-    throw new Error(`Extra variables provided not used in message: ${extra.join(", ")}`);
+    throw new Error(
+      `Extra variables provided not used in message: ${extra.join(", ")}`
+    );
   }
   const parts = [];
   let lastIndex = 0;
@@ -948,12 +1361,24 @@ function $LT_CreateDefaultLogger(debugMode, translationArgPosition = 1) {
     conflict: async (conflict, condense) => {
       const { path: path2, conflictType, tagA } = conflict;
       console.log();
-      console.log(`${ANSI_COLORS.bold}${ANSI_COLORS.red}⚠ Translation Conflict Detected${ANSI_COLORS.reset}`);
-      console.log(`${ANSI_COLORS.gray}${"─".repeat(60)}${ANSI_COLORS.reset}`);
-      console.log(`  ${ANSI_COLORS.cyan}Conflict Type:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${conflictType}${ANSI_COLORS.reset}`);
-      console.log(`  ${ANSI_COLORS.cyan}Translation Key:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${path2}${ANSI_COLORS.reset}`);
-      console.log(`  ${ANSI_COLORS.cyan}Namespace:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${tagA.tag.parameterConfig.namespace}${ANSI_COLORS.reset}`);
-      console.log(`${ANSI_COLORS.gray}${"─".repeat(60)}${ANSI_COLORS.reset}`);
+      console.log(
+        `${ANSI_COLORS.bold}${ANSI_COLORS.red}⚠ Translation Conflict Detected${ANSI_COLORS.reset}`
+      );
+      console.log(
+        `${ANSI_COLORS.gray}${"─".repeat(60)}${ANSI_COLORS.reset}`
+      );
+      console.log(
+        `  ${ANSI_COLORS.cyan}Conflict Type:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${conflictType}${ANSI_COLORS.reset}`
+      );
+      console.log(
+        `  ${ANSI_COLORS.cyan}Translation Key:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${path2}${ANSI_COLORS.reset}`
+      );
+      console.log(
+        `  ${ANSI_COLORS.cyan}Namespace:${ANSI_COLORS.reset} ${ANSI_COLORS.white}${tagA.tag.parameterConfig.namespace}${ANSI_COLORS.reset}`
+      );
+      console.log(
+        `${ANSI_COLORS.gray}${"─".repeat(60)}${ANSI_COLORS.reset}`
+      );
       await $LT_LogConflict(conflict, translationArgPosition, condense);
       console.log();
     }
@@ -961,7 +1386,10 @@ function $LT_CreateDefaultLogger(debugMode, translationArgPosition = 1) {
 }
 async function $LT_GetCommandEssentials() {
   const config = await $LT_ReadConfig(process__default.cwd());
-  const logger = $LT_CreateDefaultLogger(config.debug, config.translationArgPosition);
+  const logger = $LT_CreateDefaultLogger(
+    config.debug,
+    config.translationArgPosition
+  );
   config.collect.collector.config = config;
   config.collect.collector.logger = logger;
   return {
@@ -969,398 +1397,255 @@ async function $LT_GetCommandEssentials() {
     logger
   };
 }
-async function $LT_CMD_RegenerateTags() {
+async function $LT_CMD_Collect(options) {
   const { config, logger } = await $LT_GetCommandEssentials();
-  const files = await globby(config.includes, {
-    cwd: process.cwd(),
-    ignore: config.excludes,
-    absolute: true
-  });
-  const charactersToSkip = process.cwd().length + 1;
-  let dirty = false;
-  for (const file of files) {
-    const path2 = file.substring(charactersToSkip);
-    const localDirty = await checkAndRegenerateFileLangTags(config, logger, file, path2);
-    if (localDirty) {
-      dirty = true;
+  logger.info("Collecting translations from source files...");
+  const files = await $LT_CollectCandidateFilesWithTags({ config, logger });
+  if (config.debug) {
+    for (let file of files) {
+      logger.debug("Found {count} translations tags inside: {file}", {
+        count: file.tags.length,
+        file: file.relativeFilePath
+      });
     }
   }
-  if (!dirty) {
-    logger.info("No changes were made based on the current configuration and files");
+  if (config.isLibrary) {
+    await $LT_WriteAsExportFile({ config, logger, files });
+    return;
   }
-}
-function deepMergeTranslations(target, source) {
-  if (typeof target !== "object") {
-    throw new Error("Target must be an object");
+  try {
+    const collections = await $LT_GroupTagsToCollections({
+      logger,
+      files,
+      config
+    });
+    const totalTags = files.reduce(
+      (sum, file) => sum + file.tags.length,
+      0
+    );
+    logger.debug("Found {totalTags} translation tags", { totalTags });
+    await $LT_WriteToCollections({
+      config,
+      collections,
+      logger,
+      clean: options?.clean
+    });
+  } catch (e) {
+    const prefix = "LangTagConflictResolution:";
+    if (e.message.startsWith(prefix)) {
+      logger.error(e.message.substring(prefix.length));
+      return;
+    }
+    throw e;
   }
-  if (typeof source !== "object") {
-    throw new Error("Source must be an object");
+}
+async function $LT_CollectExportFiles(logger) {
+  const nodeModulesPath = path$1.join(process__default.cwd(), "node_modules");
+  if (!fs.existsSync(nodeModulesPath)) {
+    logger.error('"node_modules" directory not found');
+    return [];
   }
-  let changed = false;
-  for (const key in source) {
-    if (!source.hasOwnProperty(key)) {
-      continue;
-    }
-    let targetValue = target[key];
-    const sourceValue = source[key];
-    if (typeof targetValue === "string" && typeof sourceValue === "object") {
-      throw new Error(`Trying to write object into target key "${key}" which is translation already`);
-    }
-    if (Array.isArray(sourceValue)) {
-      throw new Error(`Trying to write array into target key "${key}", we do not allow arrays inside translations`);
-    }
-    if (typeof sourceValue === "object") {
-      if (!targetValue) {
-        targetValue = {};
-        target[key] = targetValue;
-      }
-      if (deepMergeTranslations(targetValue, sourceValue)) {
-        changed = true;
+  const results = [];
+  try {
+    const exportFiles = await globby(
+      [`node_modules/**/${EXPORTS_FILE_NAME}`],
+      {
+        cwd: process__default.cwd(),
+        onlyFiles: true,
+        ignore: ["**/node_modules/**/node_modules/**"],
+        deep: 4
       }
-    } else {
-      if (target[key] !== sourceValue) {
-        changed = true;
+    );
+    for (const exportFile of exportFiles) {
+      const fullExportPath = path$1.resolve(exportFile);
+      const packageJsonPath = findPackageJsonForExport(
+        fullExportPath,
+        nodeModulesPath
+      );
+      if (packageJsonPath) {
+        results.push({
+          exportPath: fullExportPath,
+          packageJsonPath
+        });
+      } else {
+        logger.warn(
+          "Found export file but could not match package.json: {exportPath}",
+          {
+            exportPath: fullExportPath
+          }
+        );
       }
-      target[key] = sourceValue;
-    }
-  }
-  return changed;
-}
-async function $LT_WriteToCollections({ config, collections, logger, clean }) {
-  await config.collect.collector.preWrite(clean);
-  const changedCollections = [];
-  for (let collectionName of Object.keys(collections)) {
-    if (!collectionName) {
-      continue;
-    }
-    const filePath = await config.collect.collector.resolveCollectionFilePath(collectionName);
-    let originalJSON = {};
-    try {
-      originalJSON = await $LT_ReadJSON(filePath);
-    } catch (e) {
-      await config.collect.collector.onMissingCollection(collectionName);
-    }
-    if (deepMergeTranslations(originalJSON, collections[collectionName])) {
-      changedCollections.push(collectionName);
-      await $LT_WriteJSON(filePath, originalJSON);
     }
+    logger.debug(
+      "Found {count} export files with matching package.json in node_modules",
+      {
+        count: results.length
+      }
+    );
+  } catch (error) {
+    logger.error("Error scanning node_modules with globby: {error}", {
+      error: String(error)
+    });
   }
-  await config.collect.collector.postWrite(changedCollections);
+  return results;
 }
-async function $LT_CollectCandidateFilesWithTags(props) {
-  const { config, logger } = props;
-  const processor = new $LT_TagProcessor(config);
-  const cwd = process__default.cwd();
-  let filesToScan = props.filesToScan;
-  if (!filesToScan) {
-    filesToScan = await globby(config.includes, { cwd, ignore: config.excludes, absolute: true });
+function findPackageJsonForExport(exportPath, nodeModulesPath) {
+  const relativePath = path$1.relative(nodeModulesPath, exportPath);
+  const pathParts = relativePath.split(path$1.sep);
+  if (pathParts.length < 2) {
+    return null;
   }
-  const candidates = [];
-  for (const filePath of filesToScan) {
-    const fileContent = readFileSync(filePath, "utf-8");
-    let tags = processor.extractTags(fileContent);
-    if (!tags.length) {
-      continue;
-    }
-    tags = $LT_FilterInvalidTags(tags, config, logger);
-    if (!tags.length) {
-      continue;
+  if (pathParts[0].startsWith("@")) {
+    if (pathParts.length >= 3) {
+      const packageDir = path$1.join(
+        nodeModulesPath,
+        pathParts[0],
+        pathParts[1]
+      );
+      const packageJsonPath = path$1.join(packageDir, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        return packageJsonPath;
+      }
     }
-    for (let tag of tags) {
-      tag.parameterConfig = config.collect.onCollectConfigFix({ config: tag.parameterConfig, langTagConfig: config });
+  } else {
+    const packageDir = path$1.join(nodeModulesPath, pathParts[0]);
+    const packageJsonPath = path$1.join(packageDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return packageJsonPath;
     }
-    tags = $LT_FilterEmptyNamespaceTags(tags, logger);
-    const relativeFilePath = path__default.relative(cwd, filePath);
-    candidates.push({ relativeFilePath, tags });
   }
-  return candidates;
+  return null;
 }
-async function $LT_WriteAsExportFile({ config, logger, files }) {
-  const packageJson = await $LT_ReadJSON(path__default.resolve(process.cwd(), "package.json"));
-  if (!packageJson) {
-    throw new Error("package.json not found");
-  }
-  const exportData = {
-    baseLanguageCode: config.baseLanguageCode,
-    files: files.map(({ relativeFilePath, tags }) => ({
-      relativeFilePath,
-      tags: tags.map((tag) => ({
-        variableName: tag.variableName,
-        config: tag.parameterConfig,
-        translations: tag.parameterTranslations
-      }))
-    }))
-  };
-  await writeFile(EXPORTS_FILE_NAME, JSON.stringify(exportData), "utf-8");
-  logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const templatePath = join(
+  __dirname,
+  "templates",
+  "import",
+  "imported-tag.mustache"
+);
+const template = readFileSync(templatePath, "utf-8");
+function renderTemplate$1(data) {
+  return mustache.render(template, data, {}, { escape: (text) => text });
 }
-async function $LT_GroupTagsToCollections({ logger, files, config }) {
-  let totalTags = 0;
-  const collections = {};
-  function getTranslationsCollection(namespace) {
-    const collectionName = config.collect.collector.aggregateCollection(namespace);
-    const collection = collections[collectionName] || {};
-    if (!(collectionName in collections)) {
-      collections[collectionName] = collection;
-    }
-    return collection;
-  }
-  const allConflicts = [];
-  const existingValuesByNamespace = /* @__PURE__ */ new Map();
-  for (const file of files) {
-    totalTags += file.tags.length;
-    for (const _tag of file.tags) {
-      const tag = config.collect.collector.transformTag(_tag);
-      const tagConfig = tag.parameterConfig;
-      const collection = getTranslationsCollection(tagConfig.namespace);
-      let existingValues = existingValuesByNamespace.get(tagConfig.namespace);
-      if (!existingValues) {
-        existingValues = /* @__PURE__ */ new Map();
-        existingValuesByNamespace.set(tagConfig.namespace, existingValues);
-      }
-      const valueTracker = {
-        get: (path2) => existingValues.get(path2),
-        trackValue: (path2, value) => {
-          existingValues.set(path2, { tag, relativeFilePath: file.relativeFilePath, value });
-        }
-      };
-      const addConflict = async (path2, tagA, tagBValue, conflictType) => {
-        if (conflictType === "path_overwrite" && config.collect?.ignoreConflictsWithMatchingValues !== false && tagA.value === tagBValue) {
-          return;
-        }
-        const conflict = {
-          path: path2,
-          tagA,
-          tagB: {
-            tag,
-            relativeFilePath: file.relativeFilePath,
-            value: tagBValue
-          },
-          conflictType
-        };
-        if (config.collect?.onConflictResolution) {
-          let shouldContinue = true;
-          await config.collect.onConflictResolution({
-            conflict,
-            logger,
-            exit() {
-              shouldContinue = false;
-            }
-          });
-          if (!shouldContinue) {
-            throw new Error(`LangTagConflictResolution:Processing stopped due to conflict resolution: ${conflict.tagA.tag.parameterConfig.namespace}|${conflict.path}`);
-          }
+async function generateImportFiles(config, logger, importManager) {
+  const importedFiles = importManager.getImportedFiles();
+  for (const importedFile of importedFiles) {
+    const filePath = resolve$1(
+      process$1.cwd(),
+      config.import.dir,
+      importedFile.pathRelativeToImportDir
+    );
+    const processedExports = importedFile.tags.map((tag) => {
+      const parameter1 = config.translationArgPosition === 1 ? tag.translations : tag.config;
+      const parameter2 = config.translationArgPosition === 1 ? tag.config : tag.translations;
+      const hasParameter2 = parameter2 !== null && parameter2 !== void 0 && (typeof parameter2 !== "object" || Object.keys(parameter2).length > 0);
+      return {
+        name: tag.variableName,
+        parameter1: JSON5.stringify(parameter1, void 0, 4),
+        parameter2: hasParameter2 ? JSON5.stringify(parameter2, void 0, 4) : null,
+        hasParameter2,
+        config: {
+          tagName: config.tagName
         }
-        allConflicts.push(conflict);
       };
-      const target = await ensureNestedObject(
-        tagConfig.path,
-        collection,
-        valueTracker,
-        addConflict
-      );
-      await mergeWithConflictDetection(
-        target,
-        tag.parameterTranslations,
-        tagConfig.path || "",
-        valueTracker,
-        addConflict
-      );
-    }
-  }
-  if (allConflicts.length > 0) {
-    logger.warn(`Found ${allConflicts.length} conflicts.`);
-  }
-  if (config.collect?.onCollectFinish) {
-    let shouldContinue = true;
-    config.collect.onCollectFinish({
-      totalTags,
-      namespaces: collections,
-      conflicts: allConflicts,
-      logger,
-      exit() {
-        shouldContinue = false;
-      }
     });
-    if (!shouldContinue) {
-      throw new Error(`LangTagConflictResolution:Processing stopped due to collect finish handler`);
-    }
-  }
-  return collections;
-}
-async function ensureNestedObject(path2, rootCollection, valueTracker, addConflict) {
-  if (!path2 || !path2.trim()) return rootCollection;
-  let current = rootCollection;
-  let currentPath = "";
-  for (const key of path2.split(".")) {
-    currentPath = currentPath ? `${currentPath}.${key}` : key;
-    if (current[key] !== void 0 && typeof current[key] !== "object") {
-      const existingInfo = valueTracker.get(currentPath);
-      if (existingInfo) {
-        await addConflict(currentPath, existingInfo, {}, "type_mismatch");
-      }
-      return current;
-    }
-    current[key] = current[key] || {};
-    current = current[key];
+    const templateData = {
+      tagImportPath: config.import.tagImportPath,
+      exports: processedExports
+    };
+    const content = renderTemplate$1(templateData);
+    await $LT_EnsureDirectoryExists(dirname(filePath));
+    await writeFile(filePath, content, "utf-8");
+    logger.success('Created tag file: "{file}"', {
+      file: importedFile.pathRelativeToImportDir
+    });
   }
-  return current;
 }
-async function mergeWithConflictDetection(target, source, basePath = "", valueTracker, addConflict) {
-  if (typeof target !== "object" || typeof source !== "object") {
-    return;
+class ImportManager {
+  importedFiles = [];
+  constructor() {
+    this.importedFiles = [];
   }
-  for (const key in source) {
-    if (!source.hasOwnProperty(key)) {
-      continue;
+  importTag(pathRelativeToImportDir, tag) {
+    if (!pathRelativeToImportDir) {
+      throw new Error(
+        `pathRelativeToImportDir required, got: ${pathRelativeToImportDir}`
+      );
     }
-    const currentPath = basePath ? `${basePath}.${key}` : key;
-    let targetValue = target[key];
-    const sourceValue = source[key];
-    if (Array.isArray(sourceValue)) {
-      continue;
+    if (!tag?.variableName) {
+      throw new Error(
+        `tag.variableName required, got: ${tag?.variableName}`
+      );
     }
-    if (targetValue !== void 0) {
-      const targetType = typeof targetValue;
-      const sourceType = typeof sourceValue;
-      let existingInfo = valueTracker.get(currentPath);
-      if (!existingInfo && targetType === "object" && targetValue !== null && !Array.isArray(targetValue)) {
-        const findNestedInfo = (obj, prefix) => {
-          for (const key2 in obj) {
-            const path2 = prefix ? `${prefix}.${key2}` : key2;
-            const info = valueTracker.get(path2);
-            if (info) {
-              return info;
-            }
-            if (typeof obj[key2] === "object" && obj[key2] !== null && !Array.isArray(obj[key2])) {
-              const nestedInfo = findNestedInfo(obj[key2], path2);
-              if (nestedInfo) {
-                return nestedInfo;
-              }
-            }
-          }
-          return void 0;
-        };
-        existingInfo = findNestedInfo(targetValue, currentPath);
-      }
-      if (targetType !== sourceType) {
-        if (existingInfo) {
-          await addConflict(currentPath, existingInfo, sourceValue, "type_mismatch");
-        }
-        continue;
-      }
-      if (targetType !== "object") {
-        if (existingInfo) {
-          await addConflict(currentPath, existingInfo, sourceValue, "path_overwrite");
-        }
-        if (targetValue !== sourceValue) {
-          continue;
-        }
-      }
+    if (!this.isValidJavaScriptIdentifier(tag.variableName)) {
+      throw new Error(
+        `Invalid JavaScript identifier: "${tag.variableName}". Variable names must start with a letter, underscore, or dollar sign, and contain only letters, digits, underscores, and dollar signs.`
+      );
     }
-    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue)) {
-      if (!targetValue) {
-        targetValue = {};
-        target[key] = targetValue;
-      }
-      await mergeWithConflictDetection(
-        targetValue,
-        sourceValue,
-        currentPath,
-        valueTracker,
-        addConflict
+    if (tag.translations == null) {
+      throw new Error(`tag.translations required`);
+    }
+    let importedFile = this.importedFiles.find(
+      (file) => file.pathRelativeToImportDir === pathRelativeToImportDir
+    );
+    if (importedFile) {
+      const duplicateTag = importedFile.tags.find(
+        (existingTag) => existingTag.variableName === tag.variableName
       );
-    } else {
-      target[key] = sourceValue;
-      valueTracker.trackValue(currentPath, sourceValue);
+      if (duplicateTag) {
+        throw new Error(
+          `Duplicate variable name "${tag.variableName}" in file "${pathRelativeToImportDir}". Variable names must be unique within the same file.`
+        );
+      }
     }
-  }
-}
-async function $LT_CMD_Collect(options) {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  logger.info("Collecting translations from source files...");
-  const files = await $LT_CollectCandidateFilesWithTags({ config, logger });
-  if (config.debug) {
-    for (let file of files) {
-      logger.debug("Found {count} translations tags inside: {file}", { count: file.tags.length, file: file.relativeFilePath });
+    if (!importedFile) {
+      importedFile = { pathRelativeToImportDir, tags: [] };
+      this.importedFiles.push(importedFile);
     }
+    importedFile.tags.push(tag);
   }
-  if (config.isLibrary) {
-    await $LT_WriteAsExportFile({ config, logger, files });
-    return;
+  getImportedFiles() {
+    return [...this.importedFiles];
   }
-  try {
-    const collections = await $LT_GroupTagsToCollections({ logger, files, config });
-    const totalTags = files.reduce((sum, file) => sum + file.tags.length, 0);
-    logger.debug("Found {totalTags} translation tags", { totalTags });
-    await $LT_WriteToCollections({ config, collections, logger, clean: options?.clean });
-  } catch (e) {
-    const prefix = "LangTagConflictResolution:";
-    if (e.message.startsWith(prefix)) {
-      logger.error(e.message.substring(prefix.length));
-      return;
-    }
-    throw e;
+  getImportedFilesCount() {
+    return this.importedFiles.length;
   }
-}
-function getBasePath(pattern) {
-  const globStartIndex = pattern.indexOf("*");
-  const braceStartIndex = pattern.indexOf("{");
-  let endIndex = -1;
-  if (globStartIndex !== -1 && braceStartIndex !== -1) {
-    endIndex = Math.min(globStartIndex, braceStartIndex);
-  } else if (globStartIndex !== -1) {
-    endIndex = globStartIndex;
-  } else if (braceStartIndex !== -1) {
-    endIndex = braceStartIndex;
+  hasImportedFiles() {
+    return this.importedFiles.length > 0;
   }
-  if (endIndex === -1) {
-    const lastSlashIndex = pattern.lastIndexOf("/");
-    return lastSlashIndex !== -1 ? pattern.substring(0, lastSlashIndex) : ".";
+  isValidJavaScriptIdentifier(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
   }
-  const lastSeparatorIndex = pattern.lastIndexOf("/", endIndex);
-  return lastSeparatorIndex === -1 ? "." : pattern.substring(0, lastSeparatorIndex);
 }
-function $LT_CreateChokidarWatcher(config) {
-  const cwd = process.cwd();
-  const baseDirsToWatch = [
-    ...new Set(config.includes.map((pattern) => getBasePath(pattern)))
-  ];
-  const finalDirsToWatch = baseDirsToWatch.map((dir) => dir === "." ? cwd : dir);
-  const ignored = [...config.excludes, "**/.git/**"];
-  return chokidar.watch(finalDirsToWatch, {
-    // Watch base directories
-    cwd,
-    ignored,
-    persistent: true,
-    ignoreInitial: true,
-    awaitWriteFinish: {
-      stabilityThreshold: 300,
-      pollInterval: 100
-    }
-  });
-}
-async function $LT_WatchTranslations() {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  await $LT_CMD_Collect();
-  const watcher = $LT_CreateChokidarWatcher(config);
-  logger.info("Starting watch mode for translations...");
-  logger.info("Watching for changes...");
-  logger.info("Press Ctrl+C to stop watching");
-  watcher.on("change", async (filePath) => await handleFile(config, logger, filePath)).on("add", async (filePath) => await handleFile(config, logger, filePath)).on("error", (error) => {
-    logger.error("Error in file watcher: {error}", { error });
+async function $LT_ImportLibraries(config, logger) {
+  const exportFiles = await $LT_CollectExportFiles(logger);
+  const importManager = new ImportManager();
+  let exports = [];
+  for (const { exportPath, packageJsonPath } of exportFiles) {
+    const exportData = await $LT_ReadJSON(exportPath);
+    const packageJSON = await $LT_ReadJSON(packageJsonPath);
+    exports.push({ packageJSON, exportData });
+  }
+  config.import.onImport({
+    exports,
+    importManager,
+    logger,
+    langTagConfig: config
   });
-}
-async function handleFile(config, logger, cwdRelativeFilePath, event) {
-  if (!micromatch.isMatch(cwdRelativeFilePath, config.includes)) {
+  if (!importManager.hasImportedFiles()) {
+    logger.warn("No tags were imported from any library files");
     return;
   }
-  const cwd = process.cwd();
-  const absoluteFilePath = path__default.join(cwd, cwdRelativeFilePath);
-  await checkAndRegenerateFileLangTags(config, logger, absoluteFilePath, cwdRelativeFilePath);
-  const files = await $LT_CollectCandidateFilesWithTags({ filesToScan: [cwdRelativeFilePath], config, logger });
-  const namespaces = await $LT_GroupTagsToCollections({ logger, files, config });
-  await $LT_WriteToCollections({ config, collections: namespaces, logger });
+  await generateImportFiles(config, logger, importManager);
+  if (config.import.onImportFinish) config.import.onImportFinish();
+}
+async function $LT_ImportTranslations() {
+  const { config, logger } = await $LT_GetCommandEssentials();
+  await $LT_EnsureDirectoryExists(config.import.dir);
+  logger.info("Importing translations from libraries...");
+  await $LT_ImportLibraries(config, logger);
+  logger.success("Successfully imported translations from libraries.");
 }
 async function detectModuleSystem() {
   const packageJsonPath = join(process.cwd(), "package.json");
@@ -1413,7 +1698,7 @@ const generationAlgorithm = pathBasedConfigGenerator({
 });
 const keeper = configKeeper({ propertyName: 'keep' });
 
-/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
+/** @type {import('@lang-tag/cli/type').LangTagCLIConfig} */
 const config = {
     tagName: 'lang',
     isLibrary: false,
@@ -1435,239 +1720,35 @@ const config = {
         defaultNamespace: 'common',
         onConflictResolution: async event => {
             await event.logger.conflict(event.conflict, true);
-            // By default, continue processing even if conflicts occur
-            // Call event.exit(); to terminate the process upon the first conflict
-        },
-        onCollectFinish: event => {
-            if (event.conflicts.length) event.exit(); // Stop the process to avoid merging on conflict
-        }
-    },
-    translationArgPosition: 1,
-    debug: false,
-};
-
-${exportStatement}`;
-}
-async function $LT_CMD_InitConfig() {
-  const logger = $LT_CreateDefaultLogger();
-  if (existsSync(CONFIG_FILE_NAME)) {
-    logger.success("Configuration file already exists. Please remove the existing configuration file before creating a new default one");
-    return;
-  }
-  try {
-    const configContent = await generateDefaultConfig();
-    await writeFile(CONFIG_FILE_NAME, configContent, "utf-8");
-    logger.success("Configuration file created successfully");
-  } catch (error) {
-    logger.error(error?.message);
-  }
-}
-async function $LT_CollectExportFiles(logger) {
-  const nodeModulesPath = path$1.join(process__default.cwd(), "node_modules");
-  if (!fs.existsSync(nodeModulesPath)) {
-    logger.error('"node_modules" directory not found');
-    return [];
-  }
-  const results = [];
-  try {
-    const exportFiles = await globby([
-      `node_modules/**/${EXPORTS_FILE_NAME}`
-    ], {
-      cwd: process__default.cwd(),
-      onlyFiles: true,
-      ignore: ["**/node_modules/**/node_modules/**"],
-      deep: 4
-    });
-    for (const exportFile of exportFiles) {
-      const fullExportPath = path$1.resolve(exportFile);
-      const packageJsonPath = findPackageJsonForExport(fullExportPath, nodeModulesPath);
-      if (packageJsonPath) {
-        results.push({
-          exportPath: fullExportPath,
-          packageJsonPath
-        });
-      } else {
-        logger.warn("Found export file but could not match package.json: {exportPath}", {
-          exportPath: fullExportPath
-        });
-      }
-    }
-    logger.debug("Found {count} export files with matching package.json in node_modules", {
-      count: results.length
-    });
-  } catch (error) {
-    logger.error("Error scanning node_modules with globby: {error}", {
-      error: String(error)
-    });
-  }
-  return results;
-}
-function findPackageJsonForExport(exportPath, nodeModulesPath) {
-  const relativePath = path$1.relative(nodeModulesPath, exportPath);
-  const pathParts = relativePath.split(path$1.sep);
-  if (pathParts.length < 2) {
-    return null;
-  }
-  if (pathParts[0].startsWith("@")) {
-    if (pathParts.length >= 3) {
-      const packageDir = path$1.join(nodeModulesPath, pathParts[0], pathParts[1]);
-      const packageJsonPath = path$1.join(packageDir, "package.json");
-      if (fs.existsSync(packageJsonPath)) {
-        return packageJsonPath;
-      }
-    }
-  } else {
-    const packageDir = path$1.join(nodeModulesPath, pathParts[0]);
-    const packageJsonPath = path$1.join(packageDir, "package.json");
-    if (fs.existsSync(packageJsonPath)) {
-      return packageJsonPath;
-    }
-  }
-  return null;
-}
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const templatePath = join(__dirname, "templates", "import", "imported-tag.mustache");
-const template = readFileSync(templatePath, "utf-8");
-function renderTemplate$1(data) {
-  return mustache.render(template, data, {}, { escape: (text) => text });
-}
-async function generateImportFiles(config, logger, importManager) {
-  const importedFiles = importManager.getImportedFiles();
-  for (const importedFile of importedFiles) {
-    const filePath = resolve(
-      process$1.cwd(),
-      config.import.dir,
-      importedFile.pathRelativeToImportDir
-    );
-    const processedExports = importedFile.tags.map((tag) => {
-      const parameter1 = config.translationArgPosition === 1 ? tag.translations : tag.config;
-      const parameter2 = config.translationArgPosition === 1 ? tag.config : tag.translations;
-      const hasParameter2 = parameter2 !== null && parameter2 !== void 0 && (typeof parameter2 !== "object" || Object.keys(parameter2).length > 0);
-      return {
-        name: tag.variableName,
-        parameter1: JSON5.stringify(parameter1, void 0, 4),
-        parameter2: hasParameter2 ? JSON5.stringify(parameter2, void 0, 4) : null,
-        hasParameter2,
-        config: {
-          tagName: config.tagName
-        }
-      };
-    });
-    const templateData = {
-      tagImportPath: config.import.tagImportPath,
-      exports: processedExports
-    };
-    const content = renderTemplate$1(templateData);
-    await $LT_EnsureDirectoryExists(dirname(filePath));
-    await writeFile(filePath, content, "utf-8");
-    logger.success('Created tag file: "{file}"', { file: importedFile.pathRelativeToImportDir });
-  }
-}
-class ImportManager {
-  importedFiles = [];
-  constructor() {
-    this.importedFiles = [];
-  }
-  importTag(pathRelativeToImportDir, tag) {
-    if (!pathRelativeToImportDir) {
-      throw new Error(`pathRelativeToImportDir required, got: ${pathRelativeToImportDir}`);
-    }
-    if (!tag?.variableName) {
-      throw new Error(`tag.variableName required, got: ${tag?.variableName}`);
-    }
-    if (!this.isValidJavaScriptIdentifier(tag.variableName)) {
-      throw new Error(`Invalid JavaScript identifier: "${tag.variableName}". Variable names must start with a letter, underscore, or dollar sign, and contain only letters, digits, underscores, and dollar signs.`);
-    }
-    if (tag.translations == null) {
-      throw new Error(`tag.translations required`);
-    }
-    let importedFile = this.importedFiles.find(
-      (file) => file.pathRelativeToImportDir === pathRelativeToImportDir
-    );
-    if (importedFile) {
-      const duplicateTag = importedFile.tags.find(
-        (existingTag) => existingTag.variableName === tag.variableName
-      );
-      if (duplicateTag) {
-        throw new Error(`Duplicate variable name "${tag.variableName}" in file "${pathRelativeToImportDir}". Variable names must be unique within the same file.`);
-      }
-    }
-    if (!importedFile) {
-      importedFile = { pathRelativeToImportDir, tags: [] };
-      this.importedFiles.push(importedFile);
-    }
-    importedFile.tags.push(tag);
-  }
-  getImportedFiles() {
-    return [...this.importedFiles];
-  }
-  getImportedFilesCount() {
-    return this.importedFiles.length;
-  }
-  hasImportedFiles() {
-    return this.importedFiles.length > 0;
-  }
-  isValidJavaScriptIdentifier(name) {
-    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-  }
+            // By default, continue processing even if conflicts occur
+            // Call event.exit(); to terminate the process upon the first conflict
+        },
+        onCollectFinish: event => {
+            if (event.conflicts.length) event.exit(); // Stop the process to avoid merging on conflict
+        }
+    },
+    translationArgPosition: 1,
+    debug: false,
+};
+
+${exportStatement}`;
 }
-async function $LT_ImportLibraries(config, logger) {
-  const exportFiles = await $LT_CollectExportFiles(logger);
-  const importManager = new ImportManager();
-  let exports = [];
-  for (const { exportPath, packageJsonPath } of exportFiles) {
-    const exportData = await $LT_ReadJSON(exportPath);
-    const packageJSON = await $LT_ReadJSON(packageJsonPath);
-    exports.push({ packageJSON, exportData });
-  }
-  config.import.onImport({ exports, importManager, logger, langTagConfig: config });
-  if (!importManager.hasImportedFiles()) {
-    logger.warn("No tags were imported from any library files");
+async function $LT_CMD_InitConfig() {
+  const logger = $LT_CreateDefaultLogger();
+  if (existsSync(CONFIG_FILE_NAME)) {
+    logger.success(
+      "Configuration file already exists. Please remove the existing configuration file before creating a new default one"
+    );
     return;
   }
-  await generateImportFiles(config, logger, importManager);
-  if (config.import.onImportFinish) config.import.onImportFinish();
-}
-async function $LT_ImportTranslations() {
-  const { config, logger } = await $LT_GetCommandEssentials();
-  await $LT_EnsureDirectoryExists(config.import.dir);
-  logger.info("Importing translations from libraries...");
-  await $LT_ImportLibraries(config, logger);
-  logger.success("Successfully imported translations from libraries.");
-}
-function renderTemplate(template2, data) {
-  return mustache.render(template2, data, {}, { escape: (text) => text });
-}
-function loadTemplate(templateName) {
-  const __filename2 = fileURLToPath(import.meta.url);
-  const __dirname2 = dirname(__filename2);
-  const templatePath2 = join(__dirname2, "templates", "tag", `${templateName}.mustache`);
   try {
-    return readFileSync(templatePath2, "utf-8");
+    const configContent = await generateDefaultConfig();
+    await writeFile(CONFIG_FILE_NAME, configContent, "utf-8");
+    logger.success("Configuration file created successfully");
   } catch (error) {
-    throw new Error(`Failed to load template ${templateName}: ${error}`);
+    logger.error(error?.message);
   }
 }
-function prepareTemplateData(options) {
-  return {
-    ...options,
-    tmpVariables: {
-      key: "{{key}}",
-      username: "{{username}}",
-      processRegex: "{{(.*?)}}"
-    }
-  };
-}
-function renderInitTagTemplates(options) {
-  const baseTemplateName = options.isLibrary ? "base-library" : "base-app";
-  const baseTemplate = loadTemplate(baseTemplateName);
-  const placeholderTemplate = loadTemplate("placeholder");
-  const templateData = prepareTemplateData(options);
-  const renderedBase = renderTemplate(baseTemplate, templateData);
-  const renderedPlaceholders = renderTemplate(placeholderTemplate, templateData);
-  return renderedBase + "\n\n" + renderedPlaceholders;
-}
 async function readPackageJson() {
   const packageJsonPath = join(process.cwd(), "package.json");
   if (!existsSync(packageJsonPath)) {
@@ -1709,51 +1790,312 @@ async function detectInitTagOptions(options, config) {
     packageVersion: packageJson?.version || "1.0.0"
   };
 }
+function renderTemplate(template2, data) {
+  return mustache.render(template2, data, {}, { escape: (text) => text });
+}
+function loadTemplate(templateName) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename2);
+  const templatePath2 = join(
+    __dirname2,
+    "templates",
+    "tag",
+    `${templateName}.mustache`
+  );
+  try {
+    return readFileSync(templatePath2, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to load template ${templateName}: ${error}`);
+  }
+}
+function prepareTemplateData(options) {
+  return {
+    ...options,
+    tmpVariables: {
+      key: "{{key}}",
+      username: "{{username}}",
+      processRegex: "{{(.*?)}}"
+    }
+  };
+}
+function renderInitTagTemplates(options) {
+  const baseTemplateName = options.isLibrary ? "base-library" : "base-app";
+  const baseTemplate = loadTemplate(baseTemplateName);
+  const placeholderTemplate = loadTemplate("placeholder");
+  const templateData = prepareTemplateData(options);
+  const renderedBase = renderTemplate(baseTemplate, templateData);
+  const renderedPlaceholders = renderTemplate(
+    placeholderTemplate,
+    templateData
+  );
+  return renderedBase + "\n\n" + renderedPlaceholders;
+}
 async function $LT_CMD_InitTagFile(options = {}) {
   const { config, logger } = await $LT_GetCommandEssentials();
   const renderOptions = await detectInitTagOptions(options, config);
   const outputPath = options.output || `${renderOptions.tagName}.${renderOptions.fileExtension}`;
   logger.info("Initializing lang-tag with the following options:");
   logger.info("  Tag name: {tagName}", { tagName: renderOptions.tagName });
-  logger.info("  Library mode: {isLibrary}", { isLibrary: renderOptions.isLibrary ? "Yes" : "No" });
-  logger.info("  React: {isReact}", { isReact: renderOptions.isReact ? "Yes" : "No" });
-  logger.info("  TypeScript: {isTypeScript}", { isTypeScript: renderOptions.isTypeScript ? "Yes" : "No" });
+  logger.info("  Library mode: {isLibrary}", {
+    isLibrary: renderOptions.isLibrary ? "Yes" : "No"
+  });
+  logger.info("  React: {isReact}", {
+    isReact: renderOptions.isReact ? "Yes" : "No"
+  });
+  logger.info("  TypeScript: {isTypeScript}", {
+    isTypeScript: renderOptions.isTypeScript ? "Yes" : "No"
+  });
   logger.info("  Output path: {outputPath}", { outputPath });
   let renderedContent;
   try {
     renderedContent = renderInitTagTemplates(renderOptions);
   } catch (error) {
-    logger.error("Failed to render templates: {error}", { error: error?.message });
+    logger.error("Failed to render templates: {error}", {
+      error: error?.message
+    });
     return;
   }
   if (existsSync(outputPath)) {
     logger.warn("File already exists: {outputPath}", { outputPath });
-    logger.info("Use --output to specify a different path or remove the existing file");
+    logger.info(
+      "Use --output to specify a different path or remove the existing file"
+    );
     return;
   }
   try {
     await $LT_WriteFileWithDirs(outputPath, renderedContent);
-    logger.success("Lang-tag file created successfully: {outputPath}", { outputPath });
+    logger.success("Lang-tag file created successfully: {outputPath}", {
+      outputPath
+    });
     logger.info("Next steps:");
-    logger.info("1. Import the {tagName} function in your files:", { tagName: renderOptions.tagName });
+    logger.info("1. Import the {tagName} function in your files:", {
+      tagName: renderOptions.tagName
+    });
     logger.info("   import { {tagName} } from './{importPath}';", {
       tagName: renderOptions.tagName,
       importPath: outputPath.replace(/^src\//, "")
     });
-    logger.info("2. Create your translation objects and use the tag function");
+    logger.info(
+      "2. Create your translation objects and use the tag function"
+    );
     logger.info('3. Run "lang-tag collect" to extract translations');
   } catch (error) {
-    logger.error("Failed to write file: {error}", { error: error?.message });
+    logger.error("Failed to write file: {error}", {
+      error: error?.message
+    });
+  }
+}
+function deepFreezeObject(obj) {
+  const propNames = Object.getOwnPropertyNames(obj);
+  for (const name of propNames) {
+    const value = obj[name];
+    if (value && typeof value === "object") {
+      deepFreezeObject(value);
+    }
+  }
+  return Object.freeze(obj);
+}
+async function checkAndRegenerateFileLangTags(config, logger, file, path2) {
+  let libraryImportsDir = config.import.dir;
+  if (!libraryImportsDir.endsWith(sep)) libraryImportsDir += sep;
+  const fileContent = readFileSync(file, "utf-8");
+  const processor = new $LT_TagProcessor(config);
+  let tags = processor.extractTags(fileContent);
+  tags = $LT_FilterInvalidTags(tags, config, logger);
+  if (!tags.length) {
+    return false;
+  }
+  const replacements = [];
+  let lastUpdatedLine = 0;
+  for (let tag of tags) {
+    let newConfig = void 0;
+    let shouldUpdate = false;
+    const frozenConfig = tag.parameterConfig ? deepFreezeObject(tag.parameterConfig) : tag.parameterConfig;
+    const event = {
+      langTagConfig: config,
+      logger,
+      config: frozenConfig,
+      absolutePath: file,
+      relativePath: path2,
+      isImportedLibrary: path2.startsWith(libraryImportsDir),
+      isSaved: false,
+      savedConfig: void 0,
+      save: (updatedConfig, triggerName) => {
+        if (!updatedConfig && updatedConfig !== null)
+          throw new Error("Wrong config data");
+        newConfig = updatedConfig;
+        shouldUpdate = true;
+        event.isSaved = true;
+        event.savedConfig = updatedConfig;
+        logger.debug(
+          'Called save for "{path}" with config "{config}" triggered by: ("{trigger}")',
+          {
+            path: path2,
+            config: JSON.stringify(updatedConfig),
+            trigger: triggerName || "-"
+          }
+        );
+      }
+    };
+    await config.onConfigGeneration(event);
+    if (!shouldUpdate) {
+      continue;
+    }
+    lastUpdatedLine = tag.line;
+    if (!isConfigSame(tag.parameterConfig, newConfig)) {
+      replacements.push({ tag, config: newConfig });
+    }
+  }
+  if (replacements.length) {
+    const newContent = processor.replaceTags(fileContent, replacements);
+    await writeFile(file, newContent, "utf-8");
+    const encodedFile = encodeURI(file);
+    logger.info(
+      'Lang tag configurations written for file "{path}" (file://{file}:{line})',
+      { path: path2, file: encodedFile, line: lastUpdatedLine }
+    );
+    return true;
+  }
+  return false;
+}
+function isConfigSame(c1, c2) {
+  if (!c1 && !c2) return true;
+  if (c1 && typeof c1 === "object" && c2 && typeof c2 === "object" && JSON5.stringify(c1) === JSON5.stringify(c2))
+    return true;
+  return false;
+}
+async function $LT_CMD_RegenerateTags() {
+  const { config, logger } = await $LT_GetCommandEssentials();
+  const files = await globby(config.includes, {
+    cwd: process.cwd(),
+    ignore: config.excludes,
+    absolute: true
+  });
+  const charactersToSkip = process.cwd().length + 1;
+  let dirty = false;
+  for (const file of files) {
+    const path2 = file.substring(charactersToSkip);
+    const localDirty = await checkAndRegenerateFileLangTags(
+      config,
+      logger,
+      file,
+      path2
+    );
+    if (localDirty) {
+      dirty = true;
+    }
   }
+  if (!dirty) {
+    logger.info(
+      "No changes were made based on the current configuration and files"
+    );
+  }
+}
+function getBasePath(pattern) {
+  const globStartIndex = pattern.indexOf("*");
+  const braceStartIndex = pattern.indexOf("{");
+  let endIndex = -1;
+  if (globStartIndex !== -1 && braceStartIndex !== -1) {
+    endIndex = Math.min(globStartIndex, braceStartIndex);
+  } else if (globStartIndex !== -1) {
+    endIndex = globStartIndex;
+  } else if (braceStartIndex !== -1) {
+    endIndex = braceStartIndex;
+  }
+  if (endIndex === -1) {
+    const lastSlashIndex = pattern.lastIndexOf("/");
+    return lastSlashIndex !== -1 ? pattern.substring(0, lastSlashIndex) : ".";
+  }
+  const lastSeparatorIndex = pattern.lastIndexOf("/", endIndex);
+  return lastSeparatorIndex === -1 ? "." : pattern.substring(0, lastSeparatorIndex);
+}
+function $LT_CreateChokidarWatcher(config) {
+  const cwd = process.cwd();
+  const baseDirsToWatch = [
+    ...new Set(config.includes.map((pattern) => getBasePath(pattern)))
+  ];
+  const finalDirsToWatch = baseDirsToWatch.map(
+    (dir) => dir === "." ? cwd : dir
+  );
+  const ignored = [...config.excludes, "**/.git/**"];
+  return chokidar.watch(finalDirsToWatch, {
+    // Watch base directories
+    cwd,
+    ignored,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+}
+async function $LT_WatchTranslations() {
+  const { config, logger } = await $LT_GetCommandEssentials();
+  await $LT_CMD_Collect();
+  const watcher = $LT_CreateChokidarWatcher(config);
+  logger.info("Starting watch mode for translations...");
+  logger.info("Watching for changes...");
+  logger.info("Press Ctrl+C to stop watching");
+  watcher.on(
+    "change",
+    async (filePath) => await handleFile(config, logger, filePath)
+  ).on(
+    "add",
+    async (filePath) => await handleFile(config, logger, filePath)
+  ).on("error", (error) => {
+    logger.error("Error in file watcher: {error}", { error });
+  });
+}
+async function handleFile(config, logger, cwdRelativeFilePath, event) {
+  if (!micromatch.isMatch(cwdRelativeFilePath, config.includes)) {
+    return;
+  }
+  const cwd = process.cwd();
+  const absoluteFilePath = path__default.join(cwd, cwdRelativeFilePath);
+  await checkAndRegenerateFileLangTags(
+    config,
+    logger,
+    absoluteFilePath,
+    cwdRelativeFilePath
+  );
+  const files = await $LT_CollectCandidateFilesWithTags({
+    filesToScan: [cwdRelativeFilePath],
+    config,
+    logger
+  });
+  const namespaces = await $LT_GroupTagsToCollections({
+    logger,
+    files,
+    config
+  });
+  await $LT_WriteToCollections({ config, collections: namespaces, logger });
 }
 function createCli() {
   program.name("lang-tag").description("CLI to manage language translations").version("0.1.0");
   program.command("collect").alias("c").description("Collect translations from source files").option("-c, --clean", "Remove output directory before collecting").action($LT_CMD_Collect);
   program.command("import").alias("i").description("Import translations from libraries in node_modules").action($LT_ImportTranslations);
   program.command("regenerate-tags").alias("rt").description("Regenerate configuration for language tags").action($LT_CMD_RegenerateTags);
-  program.command("watch").alias("w").description("Watch for changes in source files and automatically collect translations").action($LT_WatchTranslations);
+  program.command("watch").alias("w").description(
+    "Watch for changes in source files and automatically collect translations"
+  ).action($LT_WatchTranslations);
   program.command("init").description("Initialize project with default configuration").action($LT_CMD_InitConfig);
-  program.command("init-tag").description("Initialize a new lang-tag function file").option("-n, --name <name>", "Name of the tag function (default: from config)").option("-l, --library", "Generate library-style tag (default: from config)").option("-r, --react", "Include React-specific optimizations (default: auto-detect)").option("-t, --typescript", "Force TypeScript output (default: auto-detect)").option("-o, --output <path>", "Output file path (default: auto-generated)").action(async (options) => {
+  program.command("init-tag").description("Initialize a new lang-tag function file").option(
+    "-n, --name <name>",
+    "Name of the tag function (default: from config)"
+  ).option(
+    "-l, --library",
+    "Generate library-style tag (default: from config)"
+  ).option(
+    "-r, --react",
+    "Include React-specific optimizations (default: auto-detect)"
+  ).option(
+    "-t, --typescript",
+    "Force TypeScript output (default: auto-detect)"
+  ).option(
+    "-o, --output <path>",
+    "Output file path (default: auto-generated)"
+  ).action(async (options) => {
     await $LT_CMD_InitTagFile(options);
   });
   return program;