@lang-tag/cli 0.17.0 → 0.18.0

package/index.cjs

@@ -15,6 +15,10 @@ const namespaceCollector = require("./chunks/namespace-collector.cjs");
 const micromatch = require("micromatch");
 const acorn = require("acorn");
 const mustache = require("mustache");
+const checkbox = require("@inquirer/checkbox");
+const confirm = require("@inquirer/confirm");
+const input = require("@inquirer/input");
+const select = require("@inquirer/select");
 const chokidar = require("chokidar");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
@@ -1545,7 +1549,7 @@ const templatePath = path.join(
   "imported-tag.mustache"
 );
 const template = fs.readFileSync(templatePath, "utf-8");
-function renderTemplate$1(data) {
+function renderTemplate$2(data) {
   return mustache.render(template, data, {}, { escape: (text) => text });
 }
 async function generateImportFiles(config, logger, importManager) {
@@ -1574,7 +1578,7 @@ 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(path.dirname(filePath));
     await promises.writeFile(filePath, content, "utf-8");
     logger.success('Created tag file: "{file}"', {
@@ -1667,6 +1671,294 @@ async function $LT_ImportTranslations() {
   await $LT_ImportLibraries(config, logger);
   logger.success("Successfully imported translations from libraries.");
 }
+function parseGitignore(cwd) {
+  const gitignorePath = path.join(cwd, ".gitignore");
+  try {
+    const content = fs.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 = fs.readdirSync(cwd);
+    for (const entry of entries) {
+      if (isIgnored(entry, ignorePatterns)) {
+        continue;
+      }
+      try {
+        const fullPath = path.join(cwd, entry);
+        const stat = fs.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 loadTemplateFile(filename, required = true) {
+  const __filename2 = url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename2).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("index.cjs", document.baseURI).href);
+  const __dirname = path.dirname(__filename2);
+  let templatePath2 = path.join(__dirname, "templates", "config", filename);
+  try {
+    return fs.readFileSync(templatePath2, "utf-8");
+  } catch {
+    templatePath2 = path.join(
+      __dirname,
+      "..",
+      "..",
+      "templates",
+      "config",
+      filename
+    );
+    try {
+      return fs.readFileSync(templatePath2, "utf-8");
+    } catch (error) {
+      if (required) {
+        throw new Error(
+          `Failed to load template "${filename}": ${error}`
+        );
+      }
+      return null;
+    }
+  }
+}
+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 {
+    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 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 = path.join(process.cwd(), "package.json");
   if (!fs.existsSync(packageJsonPath)) {
@@ -1683,90 +1975,57 @@ async function detectModuleSystem() {
     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/type').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 (fs.existsSync(CONFIG_FILE_NAME)) {
-    logger.success(
-      "Configuration file already exists. Please remove the existing configuration file before creating a new default one"
+    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 configContent = await generateDefaultConfig();
+    const answers = await askProjectSetupQuestions();
+    const moduleSystem = await detectModuleSystem();
+    const configContent = renderConfigTemplate({
+      answers,
+      moduleSystem
+    });
     await promises.writeFile(CONFIG_FILE_NAME, configContent, "utf-8");
-    logger.success("Configuration file created successfully");
+    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) {
-    logger.error(error?.message);
+    if (error.name === "ExitPromptError") {
+      logger.warn("Setup cancelled");
+      return;
+    }
+    logger.error(error?.message || "An error occurred during setup");
   }
 }
 async function readPackageJson() {

package/index.js

@@ -2,7 +2,7 @@
 import { program } from "commander";
 import * as process$1 from "node:process";
 import process__default from "node:process";
-import fs, { readFileSync, existsSync } from "fs";
+import fs, { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { globby } from "globby";
 import * as path from "path";
 import path__default, { dirname, resolve, join, sep } from "path";
@@ -15,6 +15,10 @@ import { N as NamespaceCollector } from "./chunks/namespace-collector.js";
 import micromatch from "micromatch";
 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) => {
@@ -1525,7 +1529,7 @@ const templatePath = join(
   "imported-tag.mustache"
 );
 const template = readFileSync(templatePath, "utf-8");
-function renderTemplate$1(data) {
+function renderTemplate$2(data) {
   return mustache.render(template, data, {}, { escape: (text) => text });
 }
 async function generateImportFiles(config, logger, importManager) {
@@ -1554,7 +1558,7 @@ 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}"', {
@@ -1647,6 +1651,294 @@ async function $LT_ImportTranslations() {
   await $LT_ImportLibraries(config, logger);
   logger.success("Successfully imported translations from libraries.");
 }
+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 loadTemplateFile(filename, required = true) {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename2);
+  let templatePath2 = join(__dirname2, "templates", "config", filename);
+  try {
+    return readFileSync(templatePath2, "utf-8");
+  } 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 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 {
+    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 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)) {
@@ -1663,90 +1955,57 @@ async function detectModuleSystem() {
     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/type').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"
+    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 configContent = await generateDefaultConfig();
+    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("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) {
-    logger.error(error?.message);
+    if (error.name === "ExitPromptError") {
+      logger.warn("Setup cancelled");
+      return;
+    }
+    logger.error(error?.message || "An error occurred during setup");
   }
 }
 async function readPackageJson() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lang-tag/cli",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -33,6 +33,10 @@
     "lang-tag": "*"
   },
   "dependencies": {
+    "@inquirer/checkbox": "^4.3.0",
+    "@inquirer/confirm": "^5.1.19",
+    "@inquirer/prompts": "^7.9.0",
+    "@inquirer/select": "^4.4.0",
     "acorn": "^8.15.0",
     "case": "^1.6.3",
     "chokidar": "^4.0.3",

package/templates/config/config.mustache

@@ -0,0 +1,180 @@
+/**
+ * Lang Tag CLI Configuration
+ * 
+ * This file was generated. You can modify it to customize your translation workflow.
+ * Documentation: https://github.com/TheTonsOfCode/lang-tag-cli
+ */
+
+{{#needsAlgorithms}}
+{{#isCJS}}const{{/isCJS}}{{^isCJS}}import{{/isCJS}} {
+{{#needsPathBasedImport}}
+    pathBasedConfigGenerator,
+{{/needsPathBasedImport}}
+{{#useKeeper}}
+    configKeeper,
+{{/useKeeper}}
+{{#isDictionaryCollector}}
+    DictionaryCollector,
+{{/isDictionaryCollector}}
+{{#isModifiedNamespaceCollector}}
+    NamespaceCollector,
+{{/isModifiedNamespaceCollector}}
+{{#importLibraries}}
+    flexibleImportAlgorithm,
+{{/importLibraries}}
+} {{#isCJS}}= require('@lang-tag/cli/algorithms');{{/isCJS}}{{^isCJS}}from '@lang-tag/cli/algorithms';{{/isCJS}}
+{{/needsAlgorithms}}
+
+{{#needsPathBasedImport}}
+{{>generation-algorithm}}
+{{/needsPathBasedImport}}
+{{#useKeeper}}
+{{#addComments}}
+// Preserves tags marked with keep property. Example: {{tagName}}({ text: 'text'}, { namespace: 'custom', keep: 'namespace' })
+{{/addComments}}
+    const keeper = configKeeper({ propertyName: 'keep' });
+
+{{/useKeeper}}
+/** @type {import('@lang-tag/cli/type').LangTagCLIConfig} */
+const config = {
+{{#needsTagName}}
+    tagName: '{{tagName}}',
+{{/needsTagName}}
+{{#isLibrary}}
+    isLibrary: true,
+{{/isLibrary}}
+{{#addComments}}
+    // Directories where we’re going to look for language tags
+{{/addComments}}
+    includes: [{{includes}}],
+    excludes: [{{excludes}}],
+{{^isLibrary}}
+    localesDirectory: '{{localesDirectory}}',
+{{/isLibrary}}
+{{#addComments}}
+    // The source translations language used in your code (e.g., 'en', 'pl')
+{{/addComments}}
+    baseLanguageCode: '{{baseLanguageCode}}',
+{{#hasConfigGeneration}}
+{{#usePathBased}}
+{{#addComments}}
+    /**
+     * Automatically generates namespace/path from file location.
+     * Example: src/features/auth/LoginForm.tsx → { namespace: 'auth', path: 'loginForm' }
+     * 
+     * To customize, modify generationAlgorithm options above or add custom logic:
+     * - Change case formatting (namespaceCase, pathCase)
+     * - Ignore specific directories (ignoreDirectories)
+     * - Add path transformation rules (pathRules)
+     */
+{{/addComments}}
+    onConfigGeneration: async event => {
+        // We do not modify imported configurations
+        if (event.isImportedLibrary) return;
+{{#useKeeper}}
+        if (event.config?.keep === 'both') return;
+{{/useKeeper}}
+        
+        await generationAlgorithm(event);
+{{#useKeeper}}
+        await keeper(event);
+{{/useKeeper}}
+    },
+{{/usePathBased}}
+{{#useCustom}}
+{{#addComments}}
+    /**
+     * Custom hook to generate namespace/path for each tag based on file location.
+     * 
+     * Sample properties:
+     * - event.relativePath: File path relative to project root (e.g., 'src/auth/Login.tsx')
+     * - event.config: Current tag config (may be undefined or contain user-provided values)
+     * - event.save(newConfig): Save new config. Example: event.save({ namespace: 'auth', path: 'login' })
+     * 
+     * Example - generate from directory structure:
+     *   const segments = event.relativePath.split('/').slice(1, -1);
+     *   event.save({ namespace: segments[0], path: segments.slice(1).join('.') });
+     */
+{{/addComments}}
+    onConfigGeneration: async event => {
+        // We do not modify imported configurations
+        if (event.isImportedLibrary) return;
+
+{{#useKeeper}}
+        if (event.config?.keep === 'both') return;
+{{/useKeeper}}
+        // TODO: Implement your custom config generation logic here
+        // event.save({
+        //     namespace: 'your-namespace',
+        //     path: 'your.path'
+        // });
+{{#useKeeper}}
+    await keeper(event);
+{{/useKeeper}}
+    },
+{{/useCustom}}
+{{/hasConfigGeneration}}
+{{#hasCollectContent}}
+    collect: {
+{{#isDictionaryCollector}}
+{{#addComments}}
+        // All translations in one file per language. Change to NamespaceCollector() for separate files per namespace.
+{{/addComments}}
+        collector: new DictionaryCollector(),
+{{/isDictionaryCollector}}
+{{#isModifiedNamespaceCollector}}
+{{#addComments}}
+        // Separate file per namespace (e.g., locales/en/auth.json, locales/en/dashboard.json)
+{{/addComments}}
+        collector: new NamespaceCollector(),
+{{/isModifiedNamespaceCollector}}
+{{^isDictionary}}
+{{^isDefaultNamespace}}
+{{#addComments}}
+        // Tags without config or namespace in config will use this
+{{/addComments}}
+        defaultNamespace: '{{defaultNamespace}}',
+{{/isDefaultNamespace}}
+{{/isDictionary}}
+{{#interfereWithCollection}}
+{{#addComments}}
+        /**
+         * Called for each duplicate key conflict (same namespace + path, different values).
+         * To stop on first conflict, call event.exit() here instead of in onCollectFinish.
+         */
+{{/addComments}}
+        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
+        },
+{{#addComments}}
+        /**
+         * Called after collection completes. Check event.conflicts array to handle all conflicts.
+         * Remove this hook to allow merging despite conflicts.
+         */
+{{/addComments}}
+        onCollectFinish: event => {
+            if (event.conflicts.length) event.exit(); // Stop the process to avoid merging on conflict
+        }
+{{/interfereWithCollection}}
+    },
+{{/hasCollectContent}}
+{{#importLibraries}}
+{{#addComments}}
+    /**
+     * Imports translations from external libraries (node modules packages containing exported 'lang-tags.json').
+     * - dir: Where to generate import files
+     * - tagImportPath: Update path to your tag function
+     * - onImport: Controls file naming/structure (see flexibleImportAlgorithm options)
+     */
+{{/addComments}}
+    import: {
+        dir: 'src/lang-libraries',
+        tagImportPath: 'import { {{tagName}} } from "@/my-lang-tag-path"',
+        onImport: flexibleImportAlgorithm({ filePath: { includePackageInPath: true } })
+    },
+{{/importLibraries}}
+};
+
+{{#isCJS}}module.exports = config;{{/isCJS}}{{^isCJS}}export default config;{{/isCJS}}

package/templates/config/generation-algorithm.mustache

@@ -0,0 +1,73 @@
+{{#addComments}}
+/**
+ * Generates namespace/path from directory structure (filename is excluded).
+ * 
+ * Example with current settings (assuming includes: ['src/**']):
+ *   File: src/(admin)/features/auth/utils/LoginForm.tsx
+ *   1. Remove filename → src/(admin)/features/auth/utils
+ *   2. Remove root 'src' → (admin)/features/auth/utils
+ *   3. Remove bracketed '(admin)' → features/auth/utils
+ *   4. Remove 'utils' (in ignoreDirectories) → features/auth
+ *   5. First segment = namespace, rest = path → namespace: 'features', path: 'auth'
+ */
+{{/addComments}}
+const generationAlgorithm = pathBasedConfigGenerator({
+{{#addComments}}
+    // Removes root directory from includes patterns (e.g., 'src' if includes: ['src/**'])
+{{/addComments}}
+    ignoreIncludesRootDirectories: true,
+{{#addComments}}
+    // Directories with () or [] are NOT used for namespace/path generation
+    // true: app/(admin)/[id]/page.tsx → app/page (completely removed)
+    // false: app/(admin)/[id]/page.tsx → app/admin/id/page (brackets removed, names kept)
+{{/addComments}}
+    removeBracketedDirectories: true,
+{{#addComments}}
+    // Case for namespace. Options: 'kebab', 'camel', 'pascal', 'snake'
+{{/addComments}}
+    namespaceCase: 'kebab',
+{{#addComments}}
+    // Case for path. Options: 'kebab', 'camel', 'pascal', 'snake'
+{{/addComments}}
+    pathCase: 'camel',
+{{#addComments}}
+    // If namespace equals defaultNamespace, omit it from config (namespace becomes undefined)
+{{/addComments}}
+    clearOnDefaultNamespace: true,
+{{#addComments}}
+    // Skip these directory names globally when building namespace/path
+{{/addComments}}
+    ignoreDirectories: ['core', 'utils', 'helpers'],{{#addComments}}
+    /**
+     * Advanced: pathRules for hierarchical transformations
+     * 
+     * Special operators:
+     * - _: false → ignore current directory, continue with nested rules
+     * - '>': 'newName' → rename directory in namespace
+     * - '>>': redirect → jump to different namespace
+     *   - '>>': 'namespace' → use specified namespace, remaining segments become path
+     *   - '>>': { namespace: 'ui', pathPrefix: 'admin' } → jump to 'ui' namespace with 'admin.' prefix
+     *   - '>>': '' or null → use current directory as namespace
+     * 
+     * Example usage:
+     */
+    // 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"
+    //         },
+    //         components: {
+    //             '>>': {            // jump to 'ui' namespace, prefix all paths with 'components'
+    //                 namespace: 'ui',
+    //                 pathPrefix: 'components'
+    //             }
+    //         }
+    //     }
+    // }{{/addComments}}
+});
+

package/templates/config/init-config.mustache

@@ -1 +0,0 @@
--