make-folder-txt 2.2.0 → 2.2.1

package/bin/make-folder-txt.js

@@ -449,18 +449,271 @@ function splitBySize(treeLines, filePaths, rootName, splitSize, effectiveMaxSize
   return results;
 }
 
-// ── main ──────────────────────────────────────────────────────────────────────
+// ── configuration ────────────────────────────────────────────────────────────────
+
+function createInteractiveConfig() {
+  const readline = require('readline');
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
 
-const args = process.argv.slice(2);
+  console.log('\n🔧 make-folder-txt Configuration Setup');
+  console.log('=====================================\n');
+
+  return new Promise((resolve) => {
+    const config = {
+      maxFileSize: '500KB',
+      splitMethod: 'none',
+      splitSize: '5MB',
+      copyToClipboard: false,
+      ignoreFolders: [],
+      ignoreFiles: []
+    };
+
+    let currentStep = 0;
+    const questions = [
+      {
+        key: 'maxFileSize',
+        question: 'Maximum file size to include (e.g., 500KB, 2MB, 1GB): ',
+        default: '500KB',
+        validate: (value) => {
+          if (!value.trim()) return true;
+          const validUnits = ['B', 'KB', 'MB', 'GB', 'TB'];
+          const match = value.match(/^(\d+(?:\.\d+)?)\s*([A-Z]+)$/i);
+          if (!match) return 'Please enter a valid size (e.g., 500KB, 2MB, 1GB)';
+          if (!validUnits.includes(match[2].toUpperCase())) return `Invalid unit. Use: ${validUnits.join(', ')}`;
+          return true;
+        }
+      },
+      {
+        key: 'splitMethod',
+        question: 'Split output method (none, folder, file, size): ',
+        default: 'none',
+        validate: (value) => {
+          const validMethods = ['none', 'folder', 'file', 'size'];
+          if (!validMethods.includes(value.toLowerCase())) return `Please choose: ${validMethods.join(', ')}`;
+          return true;
+        }
+      },
+      {
+        key: 'splitSize',
+        question: 'Split size when using size method (e.g., 5MB, 10MB): ',
+        default: '5MB',
+        ask: () => config.splitMethod === 'size',
+        validate: (value) => {
+          if (!value.trim()) return true;
+          const validUnits = ['B', 'KB', 'MB', 'GB', 'TB'];
+          const match = value.match(/^(\d+(?:\.\d+)?)\s*([A-Z]+)$/i);
+          if (!match) return 'Please enter a valid size (e.g., 5MB, 10MB)';
+          if (!validUnits.includes(match[2].toUpperCase())) return `Invalid unit. Use: ${validUnits.join(', ')}`;
+          return true;
+        }
+      },
+      {
+        key: 'copyToClipboard',
+        question: 'Copy to clipboard automatically? (y/n): ',
+        default: 'n',
+        validate: (value) => {
+          const answer = value.toLowerCase();
+          if (!['y', 'n', 'yes', 'no'].includes(answer)) return 'Please enter y/n or yes/no';
+          return true;
+        },
+        transform: (value) => ['y', 'yes'].includes(value.toLowerCase())
+      },
+      {
+        key: 'ignoreFolders',
+        question: 'Ignore folders (comma-separated, or press Enter to skip): ',
+        default: '',
+        transform: (value) => value ? value.split(',').map(f => f.trim()).filter(f => f) : []
+      },
+      {
+        key: 'ignoreFiles',
+        question: 'Ignore files (comma-separated, or press Enter to skip): ',
+        default: '',
+        transform: (value) => value ? value.split(',').map(f => f.trim()).filter(f => f) : []
+      }
+    ];
+
+    function askQuestion() {
+      if (currentStep >= questions.length) {
+        // Save configuration
+        saveConfig();
+        return;
+      }
+
+      const q = questions[currentStep];
+      
+      // Skip if conditional ask returns false
+      if (q.ask && !q.ask()) {
+        currentStep++;
+        askQuestion();
+        return;
+      }
+
+      const defaultValue = typeof q.default === 'function' ? q.default() : q.default;
+      rl.question(q.question + (defaultValue ? `(${defaultValue}) ` : ''), (answer) => {
+        const value = answer.trim() || defaultValue;
+        
+        // Validate input
+        if (q.validate) {
+          const validation = q.validate(value);
+          if (validation !== true) {
+            console.log(`❌ ${validation}`);
+            askQuestion();
+            return;
+          }
+        }
+
+        // Transform value if needed
+        if (q.transform) {
+          config[q.key] = q.transform(value);
+        } else {
+          config[q.key] = value;
+        }
+
+        currentStep++;
+        askQuestion();
+      });
+    }
+
+    function saveConfig() {
+      try {
+        // Create .txtconfig file
+        const configPath = path.join(process.cwd(), '.txtconfig');
+        const configContent = `{
+  "maxFileSize": "${config.maxFileSize}",
+  "splitMethod": "${config.splitMethod}",
+  "splitSize": "${config.splitSize}",
+  "copyToClipboard": ${config.copyToClipboard},
+  "ignoreFolders": ${JSON.stringify(config.ignoreFolders)},
+  "ignoreFiles": ${JSON.stringify(config.ignoreFiles)}
+}`;
+
+        fs.writeFileSync(configPath, configContent);
+
+        // Update .txtignore if there are ignore patterns
+        if (config.ignoreFolders.length > 0 || config.ignoreFiles.length > 0) {
+          const ignorePath = path.join(process.cwd(), '.txtignore');
+          let ignoreContent = '';
+          
+          // Read existing content if file exists
+          if (fs.existsSync(ignorePath)) {
+            ignoreContent = fs.readFileSync(ignorePath, 'utf8');
+            if (!ignoreContent.endsWith('\n')) ignoreContent += '\n';
+          }
+
+          // Add new ignore patterns
+          const newPatterns = [
+            ...config.ignoreFolders.map(f => f.endsWith('/') ? f : `${f}/`),
+            ...config.ignoreFiles
+          ];
+
+          if (newPatterns.length > 0) {
+            ignoreContent += '\n# Added by make-folder-txt config\n';
+            ignoreContent += newPatterns.join('\n') + '\n';
+            fs.writeFileSync(ignorePath, ignoreContent);
+          }
+        }
+
+        console.log('\n✅ Configuration saved successfully!');
+        console.log(`📄 Config file: ${configPath}`);
+        if (config.ignoreFolders.length > 0 || config.ignoreFiles.length > 0) {
+          console.log(`📝 Ignore patterns added to .txtignore`);
+        }
+        console.log('\n💡 You can now run: make-folder-txt --use-config');
 
-if (args.includes("-v") || args.includes("--version")) {
-  console.log(`v${version}`);
-  console.log("Built by Muhammad Saad Amin");
-  process.exit(0);
+      } catch (err) {
+        console.error('❌ Error saving configuration:', err.message);
+      } finally {
+        rl.close();
+        resolve();
+      }
+    }
+
+    askQuestion();
+  });
+}
+
+function loadConfig() {
+  const fs = require('fs');
+  const path = require('path');
+  
+  try {
+    const configPath = path.join(process.cwd(), '.txtconfig');
+    if (!fs.existsSync(configPath)) {
+      console.error('❌ .txtconfig file not found. Run --make-config first.');
+      process.exit(1);
+    }
+    
+    const configContent = fs.readFileSync(configPath, 'utf8');
+    return JSON.parse(configContent);
+  } catch (err) {
+    console.error('❌ Error loading configuration:', err.message);
+    process.exit(1);
+  }
 }
 
-if (args.includes("--help") || args.includes("-h")) {
-  console.log(` 
+// ── main ──────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes("-v") || args.includes("--version")) {
+    console.log(`v${version}`);
+    console.log("Built by Muhammad Saad Amin");
+    process.exit(0);
+  }
+
+  if (args.includes("--make-config")) {
+    await createInteractiveConfig();
+    process.exit(0);
+  }
+
+  if (args.includes("--use-config")) {
+    const config = loadConfig();
+    
+    // Apply config to command line arguments
+    const newArgs = [];
+    
+    // Add max file size if not default
+    if (config.maxFileSize !== '500KB') {
+      newArgs.push('--skip-large', config.maxFileSize);
+    }
+    
+    // Add split method if not none
+    if (config.splitMethod !== 'none') {
+      newArgs.push('--split-method', config.splitMethod);
+      if (config.splitMethod === 'size') {
+        newArgs.push('--split-size', config.splitSize);
+      }
+    }
+    
+    // Add copy to clipboard if true
+    if (config.copyToClipboard) {
+      newArgs.push('--copy');
+    }
+    
+    // Add ignore folders
+    if (config.ignoreFolders.length > 0) {
+      newArgs.push('--ignore-folder', ...config.ignoreFolders);
+    }
+    
+    // Add ignore files
+    if (config.ignoreFiles.length > 0) {
+      newArgs.push('--ignore-file', ...config.ignoreFiles);
+    }
+    
+    // Replace args with config-based args
+    args.splice(0, args.length, ...newArgs);
+  }
+
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(` 
 \x1b[33mmake-folder-txt\x1b[0m
 Dump an entire project folder into a single readable .txt file.
 
@@ -478,6 +731,8 @@ Dump an entire project folder into a single readable .txt file.
   --split-size <size>                 Split output when size exceeds limit (requires --split-method size)
   --copy                              Copy output to clipboard
   --force                             Include everything (overrides all ignore patterns)
+  --make-config                       Create interactive configuration
+  --use-config                        Use configuration from .txtconfig file
   --help, -h                          Show this help message
   --version, -v                       Show version information
 
@@ -499,6 +754,8 @@ Dump an entire project folder into a single readable .txt file.
   make-folder-txt -ofo src docs
   make-folder-txt --only-file package.json README.md
   make-folder-txt -ofi package.json README.md
+  make-folder-txt --make-config
+  make-folder-txt --use-config
 
 \x1b[33m.TXTIGNORE FILE\x1b[0m
   Create a .txtignore file in your project root to specify files/folders to ignore.
@@ -511,373 +768,372 @@ Dump an entire project folder into a single readable .txt file.
     coverage/
     LICENSE
 `);
-  process.exit(0);
-}
+      process.exit(0);
+    }
 
-const ignoreDirs = new Set(IGNORE_DIRS);
-const ignoreFiles = new Set(IGNORE_FILES);
-const onlyFolders = new Set();
-const onlyFiles = new Set();
-let outputArg = null;
-let copyToClipboardFlag = false;
-let forceFlag = false;
-let maxFileSize = 500 * 1024; // Default 500KB
-let noSkipFlag = false;
-let splitMethod = null; // 'folder', 'file', 'size'
-let splitSize = null; // size in bytes
-
-for (let i = 0; i < args.length; i += 1) {
-  const arg = args[i];
-
-  if (arg === "--copy") {
-    copyToClipboardFlag = true;
-    continue;
-  }
+    const ignoreDirs = new Set(IGNORE_DIRS);
+    const ignoreFiles = new Set(IGNORE_FILES);
+    const onlyFolders = new Set();
+    const onlyFiles = new Set();
+    let outputArg = null;
+    let copyToClipboardFlag = false;
+    let forceFlag = false;
+    let maxFileSize = 500 * 1024; // Default 500KB
+    let noSkipFlag = false;
+    let splitMethod = null; // 'folder', 'file', 'size'
+    let splitSize = null; // size in bytes
+
+    for (let i = 0; i < args.length; i += 1) {
+      const arg = args[i];
+
+      if (arg === "--copy") {
+        copyToClipboardFlag = true;
+        continue;
+      }
 
-  if (arg === "--force") {
-    forceFlag = true;
-    continue;
-  }
+      if (arg === "--force") {
+        forceFlag = true;
+        continue;
+      }
 
-  if (arg === "--no-skip") {
-    noSkipFlag = true;
-    continue;
-  }
+      if (arg === "--no-skip") {
+        noSkipFlag = true;
+        continue;
+      }
 
-  if (arg === "--skip-large") {
-    if (i + 1 >= args.length || args[i + 1].startsWith("-")) {
-      console.error("Error: --skip-large requires a size value (e.g., 400KB, 5GB).");
-      process.exit(1);
-    }
-    maxFileSize = parseFileSize(args[i + 1]);
-    i += 1;
-    continue;
-  }
+      if (arg === "--skip-large") {
+        if (i + 1 >= args.length || args[i + 1].startsWith("-")) {
+          console.error("Error: --skip-large requires a size value (e.g., 400KB, 5GB).");
+          process.exit(1);
+        }
+        maxFileSize = parseFileSize(args[i + 1]);
+        i += 1;
+        continue;
+      }
 
-  if (arg.startsWith("--skip-large=")) {
-    const value = arg.slice("--skip-large=".length);
-    if (!value) {
-      console.error("Error: --skip-large requires a size value (e.g., 400KB, 5GB).");
-      process.exit(1);
-    }
-    maxFileSize = parseFileSize(value);
-    continue;
-  }
+      if (arg.startsWith("--skip-large=")) {
+        const value = arg.slice("--skip-large=".length);
+        if (!value) {
+          console.error("Error: --skip-large requires a size value (e.g., 400KB, 5GB).");
+          process.exit(1);
+        }
+        maxFileSize = parseFileSize(value);
+        continue;
+      }
 
-  if (arg === "--split-method") {
-    if (i + 1 >= args.length || args[i + 1].startsWith("-")) {
-      console.error("Error: --split-method requires a method (folder, file, or size).");
-      process.exit(1);
-    }
-    const method = args[i + 1].toLowerCase();
-    if (!['folder', 'file', 'size'].includes(method)) {
-      console.error("Error: --split-method must be one of: folder, file, size");
-      process.exit(1);
-    }
-    splitMethod = method;
-    i += 1;
-    continue;
-  }
+      if (arg === "--split-method") {
+        if (i + 1 >= args.length || args[i + 1].startsWith("-")) {
+          console.error("Error: --split-method requires a method (folder, file, or size).");
+          process.exit(1);
+        }
+        const method = args[i + 1].toLowerCase();
+        if (!['folder', 'file', 'size'].includes(method)) {
+          console.error("Error: --split-method must be one of: folder, file, size");
+          process.exit(1);
+        }
+        splitMethod = method;
+        i += 1;
+        continue;
+      }
 
-  if (arg.startsWith("--split-method=")) {
-    const value = arg.slice("--split-method=".length);
-    if (!value) {
-      console.error("Error: --split-method requires a method (folder, file, or size).");
-      process.exit(1);
-    }
-    const method = value.toLowerCase();
-    if (!['folder', 'file', 'size'].includes(method)) {
-      console.error("Error: --split-method must be one of: folder, file, size");
-      process.exit(1);
-    }
-    splitMethod = method;
-    continue;
-  }
+      if (arg.startsWith("--split-method=")) {
+        const value = arg.slice("--split-method=".length);
+        if (!value) {
+          console.error("Error: --split-method requires a method (folder, file, or size).");
+          process.exit(1);
+        }
+        const method = value.toLowerCase();
+        if (!['folder', 'file', 'size'].includes(method)) {
+          console.error("Error: --split-method must be one of: folder, file, size");
+          process.exit(1);
+        }
+        splitMethod = method;
+        continue;
+      }
 
-  if (arg === "--split-size") {
-    if (i + 1 >= args.length || args[i + 1].startsWith("-")) {
-      console.error("Error: --split-size requires a size value (e.g., 5MB, 10MB).");
-      process.exit(1);
-    }
-    splitSize = parseFileSize(args[i + 1]);
-    i += 1;
-    continue;
-  }
+      if (arg === "--split-size") {
+        if (i + 1 >= args.length || args[i + 1].startsWith("-")) {
+          console.error("Error: --split-size requires a size value (e.g., 5MB, 10MB).");
+          process.exit(1);
+        }
+        splitSize = parseFileSize(args[i + 1]);
+        i += 1;
+        continue;
+      }
 
-  if (arg.startsWith("--split-size=")) {
-    const value = arg.slice("--split-size=".length);
-    if (!value) {
-      console.error("Error: --split-size requires a size value (e.g., 5MB, 10MB).");
-      process.exit(1);
-    }
-    splitSize = parseFileSize(value);
-    continue;
-  }
+      if (arg.startsWith("--split-size=")) {
+        const value = arg.slice("--split-size=".length);
+        if (!value) {
+          console.error("Error: --split-size requires a size value (e.g., 5MB, 10MB).");
+          process.exit(1);
+        }
+        splitSize = parseFileSize(value);
+        continue;
+      }
 
-  if (arg === "--ignore-folder" || arg === "-ifo") {
-    let consumed = 0;
-    while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-      // Normalize the folder name: remove backslashes, trailing slashes, and leading ./
-      let folderName = args[i + 1];
-      folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
-      folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
-      folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
-      ignoreDirs.add(folderName);
-      i += 1;
-      consumed += 1;
-    }
-    if (consumed === 0) {
-      console.error("Error: --ignore-folder requires at least one folder name.");
-      process.exit(1);
-    }
-    continue;
-  }
+      if (arg === "--ignore-folder" || arg === "-ifo") {
+        let consumed = 0;
+        while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          // Normalize the folder name: remove backslashes, trailing slashes, and leading ./
+          let folderName = args[i + 1];
+          folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
+          folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
+          folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
+          ignoreDirs.add(folderName);
+          i += 1;
+          consumed += 1;
+        }
+        if (consumed === 0) {
+          console.error("Error: --ignore-folder requires at least one folder name.");
+          process.exit(1);
+        }
+        continue;
+      }
 
-  if (arg.startsWith("--ignore-folder=") || arg.startsWith("-ifo=")) {
-    const value = arg.startsWith("--ignore-folder=") 
-      ? arg.slice("--ignore-folder=".length)
-      : arg.slice("-ifo=".length);
-    if (!value) {
-      console.error("Error: --ignore-folder requires a folder name.");
-      process.exit(1);
-    }
-    // Normalize the folder name
-    let folderName = value;
-    folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
-    folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
-    folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
-    ignoreDirs.add(folderName);
-    continue;
-  }
+      if (arg.startsWith("--ignore-folder=") || arg.startsWith("-ifo=")) {
+        const value = arg.startsWith("--ignore-folder=") 
+          ? arg.slice("--ignore-folder=".length)
+          : arg.slice("-ifo=".length);
+        if (!value) {
+          console.error("Error: --ignore-folder requires a folder name.");
+          process.exit(1);
+        }
+        // Normalize the folder name
+        let folderName = value;
+        folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
+        folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
+        folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
+        ignoreDirs.add(folderName);
+        continue;
+      }
 
-  if (arg === "--ignore-file" || arg === "-ifi") {
-    let consumed = 0;
-    while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-      ignoreFiles.add(args[i + 1]);
-      i += 1;
-      consumed += 1;
-    }
-    if (consumed === 0) {
-      console.error("Error: --ignore-file requires at least one file name.");
-      process.exit(1);
-    }
-    continue;
-  }
+      if (arg === "--ignore-file" || arg === "-ifi") {
+        let consumed = 0;
+        while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          ignoreFiles.add(args[i + 1]);
+          i += 1;
+          consumed += 1;
+        }
+        if (consumed === 0) {
+          console.error("Error: --ignore-file requires at least one file name.");
+          process.exit(1);
+        }
+        continue;
+      }
 
-  if (arg.startsWith("--ignore-file=") || arg.startsWith("-ifi=")) {
-    const value = arg.startsWith("--ignore-file=") 
-      ? arg.slice("--ignore-file=".length)
-      : arg.slice("-ifi=".length);
-    if (!value) {
-      console.error("Error: --ignore-file requires a file name.");
-      process.exit(1);
-    }
-    ignoreFiles.add(value);
-    continue;
-  }
+      if (arg.startsWith("--ignore-file=") || arg.startsWith("-ifi=")) {
+        const value = arg.startsWith("--ignore-file=") 
+          ? arg.slice("--ignore-file=".length)
+          : arg.slice("-ifi=".length);
+        if (!value) {
+          console.error("Error: --ignore-file requires a file name.");
+          process.exit(1);
+        }
+        ignoreFiles.add(value);
+        continue;
+      }
 
-  if (arg === "--only-folder" || arg === "-ofo") {
-    let consumed = 0;
-    while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-      // Normalize the folder name
-      let folderName = args[i + 1];
-      folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
-      folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
-      folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
-      onlyFolders.add(folderName);
-      i += 1;
-      consumed += 1;
-    }
-    if (consumed === 0) {
-      console.error("Error: --only-folder requires at least one folder name.");
-      process.exit(1);
-    }
-    continue;
-  }
+      if (arg === "--only-folder" || arg === "-ofo") {
+        let consumed = 0;
+        while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          // Normalize the folder name
+          let folderName = args[i + 1];
+          folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
+          folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
+          folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
+          onlyFolders.add(folderName);
+          i += 1;
+          consumed += 1;
+        }
+        if (consumed === 0) {
+          console.error("Error: --only-folder requires at least one folder name.");
+          process.exit(1);
+        }
+        continue;
+      }
+
+      if (arg.startsWith("--only-folder=") || arg.startsWith("-ofo=")) {
+        const value = arg.startsWith("--only-folder=") 
+          ? arg.slice("--only-folder=".length)
+          : arg.slice("-ofo=".length);
+        if (!value) {
+          console.error("Error: --only-folder requires a folder name.");
+          process.exit(1);
+        }
+        // Normalize the folder name
+        let folderName = value;
+        folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
+        folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
+        folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
+        onlyFolders.add(folderName);
+        continue;
+      }
+
+      if (arg === "--only-file" || arg === "-ofi") {
+        let consumed = 0;
+        while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          onlyFiles.add(args[i + 1]);
+          i += 1;
+          consumed += 1;
+        }
+        if (consumed === 0) {
+          console.error("Error: --only-file requires at least one file name.");
+          process.exit(1);
+        }
+        continue;
+      }
+
+      if (arg.startsWith("--only-file=") || arg.startsWith("-ofi=")) {
+        const value = arg.startsWith("--only-file=") 
+          ? arg.slice("--only-file=".length)
+          : arg.slice("-ofi=".length);
+        if (!value) {
+          console.error("Error: --only-file requires a file name.");
+          process.exit(1);
+        }
+        onlyFiles.add(value);
+        continue;
+      }
 
-  if (arg.startsWith("--only-folder=") || arg.startsWith("-ofo=")) {
-    const value = arg.startsWith("--only-folder=") 
-      ? arg.slice("--only-folder=".length)
-      : arg.slice("-ofo=".length);
-    if (!value) {
-      console.error("Error: --only-folder requires a folder name.");
+      // Unknown argument
+      console.error(`Error: Unknown option "${arg}"`);
+      console.error("Use --help for available options.");
       process.exit(1);
     }
-    // Normalize the folder name
-    let folderName = value;
-    folderName = folderName.replace(/\\/g, '/'); // Convert backslashes to forward slashes
-    folderName = folderName.replace(/^\.?\//, ''); // Remove leading ./ or /
-    folderName = folderName.replace(/\/+$/, ''); // Remove trailing slashes
-    onlyFolders.add(folderName);
-    continue;
-  }
 
-  if (arg === "--only-file" || arg === "-ofi") {
-    let consumed = 0;
-    while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
-      onlyFiles.add(args[i + 1]);
-      i += 1;
-      consumed += 1;
-    }
-    if (consumed === 0) {
-      console.error("Error: --only-file requires at least one file name.");
+    // Validate split options
+    if (splitMethod === 'size' && !splitSize) {
+      console.error("Error: --split-method size requires --split-size to be specified");
       process.exit(1);
     }
-    continue;
-  }
 
-  if (arg.startsWith("--only-file=") || arg.startsWith("-ofi=")) {
-    const value = arg.startsWith("--only-file=") 
-      ? arg.slice("--only-file=".length)
-      : arg.slice("-ofi=".length);
-    if (!value) {
-      console.error("Error: --only-file requires a file name.");
+    if (splitSize && splitMethod !== 'size') {
+      console.error("Error: --split-size can only be used with --split-method size");
       process.exit(1);
     }
-    onlyFiles.add(value);
-    continue;
-  }
 
-  if (arg.startsWith("-")) {
-    console.error(`Error: Unknown option "${arg}".`);
-    process.exit(1);
-  }
+    // ── config ────────────────────────────────────────────────────────────────────────
 
-  if (!outputArg) {
-    outputArg = arg;
-    continue;
-  }
+    const folderPath = process.cwd();
+    const rootName = path.basename(folderPath);
+    const txtIgnore = readTxtIgnore(folderPath);
 
-  console.error(`Error: Unexpected argument "${arg}".`);
-  process.exit(1);
-}
+    // ── build tree & collect file paths ───────────────────────────────────────────────
 
-// Validate split options
-if (splitMethod === 'size' && !splitSize) {
-  console.error("Error: --split-method size requires --split-size to be specified.");
-  process.exit(1);
-}
+    const { lines: treeLines, filePaths } = collectFiles(
+      folderPath,
+      folderPath,
+      ignoreDirs,
+      ignoreFiles,
+      onlyFolders,
+      onlyFiles,
+      { rootName, txtIgnore, force: forceFlag }
+    );
 
-if (splitSize && splitMethod !== 'size') {
-  console.error("Error: --split-size can only be used with --split-method size.");
-  process.exit(1);
-}
+    // ── build output filename ───────────────────────────────────────────────────────────
+
+    let outputFile = outputArg || path.join(folderPath, `${rootName}.txt`);
+
+    // ── handle output splitting ─────────────────────────────────────────────────────────
 
-const folderPath = process.cwd();
-const rootName = path.basename(folderPath);
+    const effectiveMaxSize = noSkipFlag ? Infinity : maxFileSize;
+
+    if (splitMethod) {
+      console.log(`🔧 Splitting output by: ${splitMethod}`);
+      
+      let results;
+      
+      if (splitMethod === 'folder') {
+        results = splitByFolders(treeLines, filePaths, rootName, effectiveMaxSize, forceFlag);
+      } else if (splitMethod === 'file') {
+        results = splitByFiles(filePaths, rootName, effectiveMaxSize, forceFlag);
+      } else if (splitMethod === 'size') {
+        results = splitBySize(treeLines, filePaths, rootName, splitSize, effectiveMaxSize, forceFlag);
+      }
+      
+      console.log(`✅  Done! Created ${results.length} split files:`);
+      console.log('');
+      
+      results.forEach((result, index) => {
+        if (splitMethod === 'folder') {
+          console.log(`📁  Folder: ${result.folder}`);
+        } else if (splitMethod === 'file') {
+          console.log(`📄  File: ${result.fileName}`);
+        } else if (splitMethod === 'size') {
+          console.log(`📦  Part ${result.part}`);
+        }
+        console.log(`📄  Output : ${result.file}`);
+        console.log(`📊  Size   : ${result.size} KB`);
+        console.log(`🗂️   Files  : ${result.files}`);
+        console.log('');
+      });
+      
+      if (copyToClipboardFlag) {
+        console.log('⚠️  --copy flag is not compatible with splitting - clipboard copy skipped');
+      }
+      
+      process.exit(0);
+    }
 
-// Read .txtignore file if it exists
-const txtIgnore = readTxtIgnore(folderPath);
+    // ── build output (no splitting) ───────────────────────────────────────────────────
+    const out = [];
+    const divider    = "=".repeat(80);
+    const subDivider = "-".repeat(80);
 
-const outputFile = outputArg
-  ? path.resolve(outputArg)
-  : path.join(process.cwd(), `${rootName}.txt`);
+    out.push(divider);
+    out.push(`START OF FOLDER: ${rootName}`);
+    out.push(divider);
+    out.push("");
 
-console.log(`\n📂  Scanning: ${folderPath}`);
+    out.push(divider);
+    out.push("PROJECT STRUCTURE");
+    out.push(divider);
+    out.push(`Root: ${folderPath}\n`);
 
-const hasOnlyFilters = onlyFolders.size > 0 || onlyFiles.size > 0;
-const { lines: treeLines, filePaths } = collectFiles(
-  folderPath,
-  folderPath,
-  ignoreDirs,
-  ignoreFiles,
-  onlyFolders,
-  onlyFiles,
-  { hasOnlyFilters, rootName, txtIgnore, force: forceFlag },
-);
+    out.push(`${rootName}/`);
+    treeLines.forEach(l => out.push(l));
+    out.push("");
+    out.push(`Total files: ${filePaths.length}`);
+    out.push("");
 
-// ── handle splitting ──────────────────────────────────────────────────────────────
-const effectiveMaxSize = noSkipFlag ? Infinity : maxFileSize;
+    out.push(divider);
+    out.push("FILE CONTENTS");
+    out.push(divider);
 
-if (splitMethod) {
-  console.log(`🔧 Splitting output by: ${splitMethod}`);
-  
-  let results;
-  
-  if (splitMethod === 'folder') {
-    results = splitByFolders(treeLines, filePaths, rootName, effectiveMaxSize, forceFlag);
-  } else if (splitMethod === 'file') {
-    results = splitByFiles(filePaths, rootName, effectiveMaxSize, forceFlag);
-  } else if (splitMethod === 'size') {
-    results = splitBySize(treeLines, filePaths, rootName, splitSize, effectiveMaxSize, forceFlag);
-  }
-  
-  console.log(`✅  Done! Created ${results.length} split files:`);
-  console.log('');
-  
-  results.forEach((result, index) => {
-    if (splitMethod === 'folder') {
-      console.log(`📁  Folder: ${result.folder}`);
-    } else if (splitMethod === 'file') {
-      console.log(`📄  File: ${result.fileName}`);
-    } else if (splitMethod === 'size') {
-      console.log(`📦  Part ${result.part}`);
-    }
-    console.log(`📄  Output : ${result.file}`);
-    console.log(`📊  Size   : ${result.size} KB`);
-    console.log(`🗂️   Files  : ${result.files}`);
-    console.log('');
-  });
-  
-  if (copyToClipboardFlag) {
-    console.log('⚠️  --copy flag is not compatible with splitting - clipboard copy skipped');
-  }
-  
-  process.exit(0);
-}
+    filePaths.forEach(({ abs, rel }) => {
+      out.push("");
+      out.push(subDivider);
+      out.push(`FILE: ${rel}`);
+      out.push(subDivider);
+      out.push(readContent(abs, forceFlag, effectiveMaxSize));
+    });
 
-// ── build output (no splitting) ───────────────────────────────────────────────────
-const out = [];
-const divider    = "=".repeat(80);
-const subDivider = "-".repeat(80);
-
-out.push(divider);
-out.push(`START OF FOLDER: ${rootName}`);
-out.push(divider);
-out.push("");
-
-out.push(divider);
-out.push("PROJECT STRUCTURE");
-out.push(divider);
-out.push(`Root: ${folderPath}\n`);
-out.push(`${rootName}/`);
-treeLines.forEach(l => out.push(l));
-out.push("");
-out.push(`Total files: ${filePaths.length}`);
-out.push("");
-
-out.push(divider);
-out.push("FILE CONTENTS");
-out.push(divider);
-
-filePaths.forEach(({ abs, rel }) => {
-out.push("");
-out.push(subDivider);
-out.push(`FILE: ${rel}`);
-out.push(subDivider);
-const effectiveMaxSize = noSkipFlag ? Infinity : maxFileSize;
-out.push(readContent(abs, forceFlag, effectiveMaxSize));
-});
+    out.push("");
+    out.push(divider);
+    out.push(`END OF FOLDER: ${rootName}`);
+    out.push(divider);
 
-out.push("");
-out.push(divider);
-out.push(`END OF FOLDER: ${rootName}`);
-out.push(divider);
+    fs.writeFileSync(outputFile, out.join("\n"), "utf8");
 
-fs.writeFileSync(outputFile, out.join("\n"), "utf8");
+    const sizeKB = (fs.statSync(outputFile).size / 1024).toFixed(1);
+    console.log(`✅  Done!`);
+    console.log(`📄  Output : ${outputFile}`);
+    console.log(`📊  Size   : ${sizeKB} KB`);
+    console.log(`🗂️   Files  : ${filePaths.length}`);
 
-const sizeKB = (fs.statSync(outputFile).size / 1024).toFixed(1);
-console.log(`✅  Done!`);
-console.log(`📄  Output : ${outputFile}`);
-console.log(`📊  Size   : ${sizeKB} KB`);
-console.log(`🗂️   Files  : ${filePaths.length}`);
+    if (copyToClipboardFlag) {
+      const content = fs.readFileSync(outputFile, 'utf8');
+      const success = copyToClipboard(content);
+      if (success) {
+        console.log(`📋  Copied to clipboard!`);
+      }
+    }
 
-if (copyToClipboardFlag) {
-  const content = fs.readFileSync(outputFile, 'utf8');
-  const success = copyToClipboard(content);
-  if (success) {
-    console.log(`📋  Copied to clipboard!`);
-  }
+    console.log('');
 }
 
-console.log('');
+// Run the main function
+main().catch(err => {
+  console.error('❌ Error:', err.message);
+  process.exit(1);
+});