@lang-tag/cli 0.16.0 → 0.18.0

package/index.js

@@ -1,21 +1,77 @@
 #!/usr/bin/env node
 import { program } from "commander";
-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 * as process$1 from "node:process";
+import process__default from "node:process";
+import fs, { readFileSync, existsSync, readdirSync, statSync } from "fs";
 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 checkbox from "@inquirer/checkbox";
+import confirm from "@inquirer/confirm";
+import input from "@inquirer/input";
+import select from "@inquirer/select";
+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 +82,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 +107,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 +162,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 +180,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 +190,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 +226,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 +261,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 +455,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 +858,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 +907,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 +931,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 +1093,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 +1124,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 +1191,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 +1212,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 +1247,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 +1258,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 +1281,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 +1308,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 +1365,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 +1390,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,573 +1401,141 @@ 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 });
-}
-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}`);
-          }
-        }
-        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];
-  }
-  return current;
-}
-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);
-    }
-  }
-}
-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 (config.isLibrary) {
-    await $LT_WriteAsExportFile({ config, logger, files });
-    return;
-  }
-  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;
-  }
-}
-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 });
-}
-async function detectModuleSystem() {
-  const packageJsonPath = join(process.cwd(), "package.json");
-  if (!existsSync(packageJsonPath)) {
-    return "cjs";
-  }
-  try {
-    const content = await readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(content);
-    if (packageJson.type === "module") {
-      return "esm";
-    }
-    return "cjs";
-  } catch (error) {
-    return "cjs";
-  }
-}
-async function generateDefaultConfig() {
-  const moduleSystem = await detectModuleSystem();
-  const importStatement = moduleSystem === "esm" ? `import { pathBasedConfigGenerator, configKeeper } from '@lang-tag/cli/algorithms';` : `const { pathBasedConfigGenerator, configKeeper } = require('@lang-tag/cli/algorithms');`;
-  const exportStatement = moduleSystem === "esm" ? "export default config;" : "module.exports = config;";
-  return `${importStatement}
-
-const generationAlgorithm = pathBasedConfigGenerator({
-    ignoreIncludesRootDirectories: true,
-    removeBracketedDirectories: true,
-    namespaceCase: 'kebab',
-    pathCase: 'camel',
-    clearOnDefaultNamespace: true,
-    ignoreDirectories: ['core', 'utils', 'helpers'],
-    // Advanced: Use pathRules for hierarchical transformations with ignore and rename
-    // pathRules: {
-    //     app: {
-    //         dashboard: {
-    //             _: false,          // ignore "dashboard" but continue with nested rules
-    //             modules: false     // also ignore "modules"
-    //         },
-    //         admin: {
-    //             '>': 'management', // rename "admin" to "management"
-    //             users: false       // ignore "users",
-    //             ui: {
-    //                 '>>': {        // 'redirect' - ignore everything, jump to 'ui' namespace and prefix all paths with 'admin'
-    //                     namespace: 'ui',
-    //                     pathPrefix: 'admin'
-    //                 }
-    //             }
-    //         }
-    //     }
-    // }
-});
-const keeper = configKeeper({ propertyName: 'keep' });
-
-/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
-const config = {
-    tagName: 'lang',
-    isLibrary: false,
-    includes: ['src/**/*.{js,ts,jsx,tsx}'],
-    excludes: ['node_modules', 'dist', 'build', '**/*.test.ts'],
-    localesDirectory: 'public/locales',
-    baseLanguageCode: 'en',
-    onConfigGeneration: async event => {
-        // We do not modify imported configurations
-        if (event.isImportedLibrary) return;
-
-        if (event.config?.keep === 'both') return;
-        
-        await generationAlgorithm(event);
-        
-        await keeper(event);
-    },
-    collect: {
-        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 });
+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$2(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(
+    const filePath = resolve$1(
       process$1.cwd(),
       config.import.dir,
       importedFile.pathRelativeToImportDir
@@ -1558,10 +1558,12 @@ async function generateImportFiles(config, logger, importManager) {
       tagImportPath: config.import.tagImportPath,
       exports: processedExports
     };
-    const content = renderTemplate$1(templateData);
+    const content = renderTemplate$2(templateData);
     await $LT_EnsureDirectoryExists(dirname(filePath));
     await writeFile(filePath, content, "utf-8");
-    logger.success('Created tag file: "{file}"', { file: importedFile.pathRelativeToImportDir });
+    logger.success('Created tag file: "{file}"', {
+      file: importedFile.pathRelativeToImportDir
+    });
   }
 }
 class ImportManager {
@@ -1571,13 +1573,19 @@ class ImportManager {
   }
   importTag(pathRelativeToImportDir, tag) {
     if (!pathRelativeToImportDir) {
-      throw new Error(`pathRelativeToImportDir required, got: ${pathRelativeToImportDir}`);
+      throw new Error(
+        `pathRelativeToImportDir required, got: ${pathRelativeToImportDir}`
+      );
     }
     if (!tag?.variableName) {
-      throw new Error(`tag.variableName required, got: ${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.`);
+      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`);
@@ -1590,7 +1598,9 @@ class ImportManager {
         (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.`);
+        throw new Error(
+          `Duplicate variable name "${tag.variableName}" in file "${pathRelativeToImportDir}". Variable names must be unique within the same file.`
+        );
       }
     }
     if (!importedFile) {
@@ -1621,7 +1631,12 @@ async function $LT_ImportLibraries(config, logger) {
     const packageJSON = await $LT_ReadJSON(packageJsonPath);
     exports.push({ packageJSON, exportData });
   }
-  config.import.onImport({ exports, importManager, logger, langTagConfig: config });
+  config.import.onImport({
+    exports,
+    importManager,
+    logger,
+    langTagConfig: config
+  });
   if (!importManager.hasImportedFiles()) {
     logger.warn("No tags were imported from any library files");
     return;
@@ -1636,37 +1651,362 @@ async function $LT_ImportTranslations() {
   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 parseGitignore(cwd) {
+  const gitignorePath = join(cwd, ".gitignore");
+  try {
+    const content = readFileSync(gitignorePath, "utf-8");
+    return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter((line) => !line.startsWith("!")).map((line) => {
+      if (line.endsWith("/")) line = line.slice(0, -1);
+      if (line.startsWith("/")) line = line.slice(1);
+      return line;
+    }).filter((line) => {
+      if (line.startsWith("*.")) return false;
+      if (line.includes(".") && line.split(".")[1].length <= 4)
+        return false;
+      return true;
+    });
+  } catch {
+    return [];
+  }
+}
+function isIgnored(entry, ignorePatterns) {
+  if (entry.startsWith(".")) {
+    return true;
+  }
+  if (ignorePatterns.length === 0) {
+    return false;
+  }
+  return micromatch.isMatch(entry, ignorePatterns);
+}
+function detectProjectDirectories() {
+  const cwd = process.cwd();
+  const ignorePatterns = parseGitignore(cwd);
+  const detectedFolders = [];
+  try {
+    const entries = readdirSync(cwd);
+    for (const entry of entries) {
+      if (isIgnored(entry, ignorePatterns)) {
+        continue;
+      }
+      try {
+        const fullPath = join(cwd, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          detectedFolders.push(entry);
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return ["src", "app"];
+  }
+  return detectedFolders.length > 0 ? detectedFolders.sort() : ["src", "app"];
+}
+async function askProjectSetupQuestions() {
+  const projectType = await select({
+    message: "Is this a project or a library?",
+    choices: [
+      {
+        name: "Project (application that consumes translations)",
+        value: "project",
+        description: "For applications that use translations"
+      },
+      {
+        name: "Library (exports translations for other projects)",
+        value: "library",
+        description: "For packages that provide translations"
+      }
+    ]
+  });
+  const tagName = await input({
+    message: "What name would you like for your translation tag function?",
+    default: "lang"
+  });
+  let collectorType = "namespace";
+  let namespaceOptions;
+  let localesDirectory = "locales";
+  const modifyNamespaceOptions = false;
+  if (projectType === "project") {
+    collectorType = await select({
+      message: "How would you like to collect translations?",
+      choices: [
+        {
+          name: "Namespace (organized by modules/features)",
+          value: "namespace",
+          description: "Organized structure with namespaces"
+        },
+        {
+          name: "Dictionary (flat structure, all translations in one file)",
+          value: "dictionary",
+          description: "Simple flat dictionary structure"
+        }
+      ]
+    });
+    localesDirectory = await input({
+      message: "Where should the translation files be stored?",
+      default: "public/locales"
+    });
+  }
+  const defaultNamespace = await input({
+    message: "Default namespace for tags without explicit namespace:",
+    default: "common"
+  });
+  namespaceOptions = {
+    modifyNamespaceOptions,
+    defaultNamespace
+  };
+  const enableConfigGeneration = await confirm({
+    message: "Do you want to script config generation for tags?",
+    default: projectType === "project"
+  });
+  let configGeneration = {
+    enabled: enableConfigGeneration
+  };
+  if (enableConfigGeneration) {
+    const algorithmChoice = await select({
+      message: "Which config generation approach would you like?",
+      choices: [
+        {
+          name: "Path-based (automatic based on file structure)",
+          value: "path-based",
+          description: "Generates namespace and path from file location"
+        },
+        {
+          name: "Custom (write your own algorithm)",
+          value: "custom",
+          description: "Implement custom config generation logic"
+        }
+      ]
+    });
+    const keepVariables = await confirm({
+      message: "Add a keeper mechanism that locks parts of the configuration from being overwritten?",
+      default: true
+    });
+    configGeneration = {
+      enabled: true,
+      useAlgorithm: algorithmChoice,
+      keepVariables
+    };
+  }
+  const importLibraries = await confirm({
+    message: "Do you plan to import translation tags from external libraries?",
+    default: projectType === "project"
+  });
+  const interfereWithCollection = await confirm({
+    message: "Do you want to interfere with collection mechanisms (conflict resolution, collection finish)?",
+    default: false
+  });
+  const detectedDirectories = detectProjectDirectories();
+  const includeDirectories = await checkbox({
+    message: "Select directories where lang tags will be used (you can add more later):",
+    choices: detectedDirectories.map((directory) => ({
+      name: directory,
+      value: directory,
+      checked: directory === "src" || detectedDirectories.length === 1
+    })),
+    required: true
+  });
+  const baseLanguageCode = await input({
+    message: "Base language code:",
+    default: "en",
+    validate: (value) => {
+      if (!value || value.length < 2) {
+        return "Please enter a valid language code (e.g., en, pl, fr, de, es)";
+      }
+      return true;
+    }
+  });
+  const addCommentGuides = await confirm({
+    message: "Would you like guides in comments?",
+    default: true
+  });
+  return {
+    projectType,
+    tagName,
+    collectorType,
+    namespaceOptions,
+    localesDirectory,
+    configGeneration,
+    importLibraries,
+    interfereWithCollection,
+    includeDirectories,
+    baseLanguageCode,
+    addCommentGuides
+  };
+}
+function renderTemplate$1(template2, data, partials) {
+  return mustache.render(template2, data, partials, {
+    escape: (text) => text
+  });
 }
-function loadTemplate(templateName) {
+function loadTemplateFile(filename, required = true) {
   const __filename2 = fileURLToPath(import.meta.url);
   const __dirname2 = dirname(__filename2);
-  const templatePath2 = join(__dirname2, "templates", "tag", `${templateName}.mustache`);
+  let templatePath2 = join(__dirname2, "templates", "config", filename);
   try {
     return readFileSync(templatePath2, "utf-8");
-  } catch (error) {
-    throw new Error(`Failed to load template ${templateName}: ${error}`);
+  } catch {
+    templatePath2 = join(
+      __dirname2,
+      "..",
+      "..",
+      "templates",
+      "config",
+      filename
+    );
+    try {
+      return readFileSync(templatePath2, "utf-8");
+    } catch (error) {
+      if (required) {
+        throw new Error(
+          `Failed to load template "${filename}": ${error}`
+        );
+      }
+      return null;
+    }
   }
 }
-function prepareTemplateData(options) {
+function loadTemplate$1() {
+  return loadTemplateFile("config.mustache", true);
+}
+function loadPartials() {
+  const partials = {};
+  const generationAlgorithm = loadTemplateFile(
+    "generation-algorithm.mustache",
+    false
+  );
+  if (generationAlgorithm) {
+    partials["generation-algorithm"] = generationAlgorithm;
+  }
+  return partials;
+}
+function buildIncludesPattern(directories) {
+  return directories.map((directory) => `'${directory}/**/*.{js,ts,jsx,tsx}'`).join(", ");
+}
+function buildExcludesPattern() {
+  const excludes = [
+    "node_modules",
+    "dist",
+    "build",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ];
+  return excludes.map((e) => `'${e}'`).join(", ");
+}
+function prepareTemplateData$1(options) {
+  const { answers, moduleSystem } = options;
+  const needsPathBasedImport = answers.configGeneration.enabled && answers.configGeneration.useAlgorithm === "path-based";
+  const hasConfigGeneration = answers.configGeneration.enabled;
+  const usePathBased = hasConfigGeneration && answers.configGeneration.useAlgorithm === "path-based";
+  const useCustom = hasConfigGeneration && answers.configGeneration.useAlgorithm === "custom";
+  const needsTagName = answers.tagName !== "lang";
+  const useKeeper = answers.configGeneration.keepVariables || false;
+  const isDictionaryCollector = answers.collectorType === "dictionary";
+  const isModifiedNamespaceCollector = answers.collectorType === "namespace" && !!answers.namespaceOptions?.modifyNamespaceOptions;
+  const importLibraries = answers.importLibraries;
+  const defaultNamespace = answers.namespaceOptions?.defaultNamespace || "common";
+  const isDefaultNamespace = defaultNamespace === "common";
+  const hasCollectContent = isDictionaryCollector || isModifiedNamespaceCollector || answers.interfereWithCollection || !isDefaultNamespace;
+  const needsAlgorithms = needsPathBasedImport || useKeeper || isDictionaryCollector || isModifiedNamespaceCollector || importLibraries;
   return {
-    ...options,
-    tmpVariables: {
-      key: "{{key}}",
-      username: "{{username}}",
-      processRegex: "{{(.*?)}}"
-    }
+    isCJS: moduleSystem === "cjs",
+    addComments: answers.addCommentGuides,
+    needsAlgorithms,
+    needsPathBasedImport,
+    useKeeper,
+    isDictionaryCollector,
+    isModifiedNamespaceCollector,
+    importLibraries,
+    needsTagName,
+    tagName: answers.tagName,
+    isLibrary: answers.projectType === "library",
+    includes: buildIncludesPattern(answers.includeDirectories),
+    excludes: buildExcludesPattern(),
+    localesDirectory: answers.localesDirectory,
+    baseLanguageCode: answers.baseLanguageCode,
+    hasConfigGeneration,
+    usePathBased,
+    useCustom,
+    defaultNamespace,
+    isDefaultNamespace,
+    interfereWithCollection: answers.interfereWithCollection,
+    hasCollectContent
   };
 }
-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;
+function renderConfigTemplate(options) {
+  const template2 = loadTemplate$1();
+  const templateData = prepareTemplateData$1(options);
+  const partials = loadPartials();
+  return renderTemplate$1(template2, templateData, partials);
+}
+async function detectModuleSystem() {
+  const packageJsonPath = join(process.cwd(), "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return "cjs";
+  }
+  try {
+    const content = await readFile(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    if (packageJson.type === "module") {
+      return "esm";
+    }
+    return "cjs";
+  } catch (error) {
+    return "cjs";
+  }
+}
+async function $LT_CMD_InitConfig() {
+  const logger = $LT_CreateDefaultLogger();
+  if (existsSync(CONFIG_FILE_NAME)) {
+    logger.error(
+      "Configuration file already exists. Please remove the existing configuration file before creating a new one"
+    );
+    return;
+  }
+  console.log("");
+  logger.info("Welcome to Lang Tag CLI Setup!");
+  console.log("");
+  try {
+    const answers = await askProjectSetupQuestions();
+    const moduleSystem = await detectModuleSystem();
+    const configContent = renderConfigTemplate({
+      answers,
+      moduleSystem
+    });
+    await writeFile(CONFIG_FILE_NAME, configContent, "utf-8");
+    logger.success("Configuration file created successfully!");
+    logger.success("Created {configFile}", {
+      configFile: CONFIG_FILE_NAME
+    });
+    logger.info("Next steps:");
+    logger.info("  1. Review and customize {configFile}", {
+      configFile: CONFIG_FILE_NAME
+    });
+    logger.info(
+      "  2. Since you have installed all basic libraries (React, TypeScript, etc.)"
+    );
+    logger.info(
+      "     and the initialized basic tag is based on what you use in your project,"
+    );
+    logger.info(
+      '     we recommend using "npx lang-tag init-tag" to generate an initial version of the tag'
+    );
+    logger.info(
+      "  3. Use your tag in the project under the include directories"
+    );
+    logger.info('  4. Run "npx lang-tag collect" to collect translations');
+    if (answers.projectType === "project") {
+      logger.info("  5. Your translations will be in {dir}", {
+        dir: answers.localesDirectory
+      });
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      logger.warn("Setup cancelled");
+      return;
+    }
+    logger.error(error?.message || "An error occurred during setup");
+  }
 }
 async function readPackageJson() {
   const packageJsonPath = join(process.cwd(), "package.json");
@@ -1709,51 +2049,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;