make-folder-txt 1.4.4 → 2.0.1

package/README.md

@@ -11,7 +11,7 @@
 
 Perfect for sharing your codebase with **AI tools**, **teammates**, or **code reviewers** — without zipping files or giving repo access.
 
-[Installation](#-installation) · [Usage](#-usage) · [Help](#-get-help) · [Output Format](#-output-format) · [What Gets Skipped](#-what-gets-skipped) · [Contributing](#-contributing)
+[Installation](#-installation) · [Usage](#-usage) · [Help](#-get-help) · [Copy to Clipboard](#-copy-to-clipboard) · [Force Include Everything](#-force-include-everything) · [Shell Autocompletion](#-shell-autocompletion) · [Output Format](#-output-format) · [What Gets Skipped](#-what-gets-skipped) · [Contributing](#-contributing)
 
 </div>
 
@@ -23,6 +23,9 @@ Ever needed to share your entire project with ChatGPT, Claude, or a teammate —
 
 - ✅ Run it from any project directory — no arguments needed
 - ✅ Built-in help system with `--help` flag
+- ✅ **Built-in shell autocompletion** (installs automatically)
+- ✅ Copy to clipboard with `--copy` flag
+- ✅ Force include everything with `--force` flag
 - ✅ Generates a clean folder tree + every file's content
 - ✅ `.txtignore` support (works like `.gitignore`)
 - ✅ Automatically skips `node_modules`, binaries, and junk files
@@ -61,13 +64,84 @@ make-folder-txt --version   # Show version info
 make-folder-txt -v          # Short version of version
 ```
 
+### 📋 Copy to Clipboard
+
+```bash
+make-folder-txt --copy      # Generate output and copy to clipboard
+make-folder-txt --copy --ignore-folder node_modules  # Copy filtered output
+```
+
+The `--copy` flag automatically copies the generated output to your system clipboard, making it easy to paste directly into AI tools, emails, or documents. Works on Windows, macOS, and Linux (requires `xclip` or `xsel` on Linux).
+
+### 🔥 Force Include Everything
+
+```bash
+make-folder-txt --force      # Include everything (overrides all ignore patterns)
+make-folder-txt --force --copy  # Include everything and copy to clipboard
+```
+
+The `--force` flag overrides all ignore patterns and includes:
+- `node_modules` and other ignored folders
+- Binary files (images, executables, etc.)
+- Large files (no 500 KB limit)
+- Files in `.txtignore`
+- System files and other normally skipped content
+
+Use this when you need a complete, unfiltered dump of your entire project.
+
+### ⚡ Shell Autocompletion (Built-in)
+
+```bash
+make-folder-txt  # Autocompletion installs automatically on first run
+```
+
+**🎉 No installation required!** The tool automatically installs shell autocompletion the first time you run it.
+
+**What gets installed automatically:**
+- **Flag completion**: `make-folder-txt --<TAB>` shows all available flags
+- **Folder completion**: `make-folder-txt --ignore-folder <TAB>` shows folders
+- **File completion**: `make-folder-txt --ignore-file <TAB>` shows files
+
+**Supported Shells:**
+- **Bash** - Linux/macOS/Windows (WSL)
+- **Zsh** - macOS/Linux
+- **PowerShell** - Windows (7+)
+
+**Example usage:**
+```bash
+$ make-folder-txt --ignore-folder b<TAB>
+# → completes to "bin/" if bin folder exists
+
+$ make-folder-txt --ignore-file p<TAB>
+# → completes to "package.json" if package.json exists
+```
+
+**Manual Installation (if needed):**
+```bash
+make-folder-txt --install-completion  # Force reinstall completion
+```
+
+**PowerShell Manual Setup:**
+```powershell
+# If auto-installation doesn't work, load manually:
+. .\completion\make-folder-txt-completion.ps1
+
+# Or add to your PowerShell profile for persistence:
+notepad $PROFILE
+# Add: . "C:\path\to\make-folder-txt\completion\make-folder-txt-completion.ps1"
+```
+
+The completion works out of the box - just run the tool once and restart your terminal!
+
 Ignore specific folders/files by name:
 
 ```bash
 make-folder-txt --ignore-folder examples extensions docs
+make-folder-txt -ifo examples extensions docs  # shorthand
 make-folder-txt --ignore-folder examples extensions "docs and explaination"
 make-folder-txt --ignore-folder examples extensions docs --ignore-file LICENSE
 make-folder-txt --ignore-file .env .env.local secrets.txt
+make-folder-txt -ifi .env .env.local secrets.txt  # shorthand
 ```
 
 Use a `.txtignore` file (works like `.gitignore`):
@@ -93,7 +167,9 @@ Include only specific folders/files by name (everything else is ignored):
 
 ```bash
 make-folder-txt --only-folder src docs
+make-folder-txt -ofo src docs  # shorthand
 make-folder-txt --only-file package.json README.md
+make-folder-txt -ofi package.json README.md  # shorthand
 make-folder-txt --only-folder src --only-file package.json
 ```
 

package/bin/make-folder-txt.js

@@ -3,6 +3,7 @@
 const fs = require("fs");
 const path = require("path");
 const { version } = require("../package.json");
+const { execSync } = require("child_process");
 
 // ── config ────────────────────────────────────────────────────────────────────
 const IGNORE_DIRS = new Set(["node_modules", ".git", ".next", "dist", "build", ".cache"]);
@@ -37,6 +38,34 @@ function readTxtIgnore(rootDir) {
   return ignorePatterns;
 }
 
+function copyToClipboard(text) {
+  try {
+    if (process.platform === 'win32') {
+      // Windows
+      execSync(`echo ${JSON.stringify(text).replace(/"/g, '""')} | clip`, { stdio: 'ignore' });
+    } else if (process.platform === 'darwin') {
+      // macOS
+      execSync(`echo ${JSON.stringify(text)} | pbcopy`, { stdio: 'ignore' });
+    } else {
+      // Linux (requires xclip or xsel)
+      try {
+        execSync(`echo ${JSON.stringify(text)} | xclip -selection clipboard`, { stdio: 'ignore' });
+      } catch {
+        try {
+          execSync(`echo ${JSON.stringify(text)} | xsel --clipboard --input`, { stdio: 'ignore' });
+        } catch {
+          console.warn('⚠️  Could not copy to clipboard. Install xclip or xsel on Linux.');
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch (err) {
+    console.warn('⚠️  Could not copy to clipboard:', err.message);
+    return false;
+  }
+}
+
 function collectFiles(
   dir,
   rootDir,
@@ -54,6 +83,7 @@ function collectFiles(
     hasOnlyFilters = false,
     rootName = "",
     txtIgnore = new Set(),
+    force = false,
   } = options;
 
   let entries;
@@ -74,7 +104,7 @@ function collectFiles(
     const childIndent = indent + (isLast ? "    " : "│   ");
 
     if (entry.isDirectory()) {
-      if (ignoreDirs.has(entry.name)) {
+      if (!force && ignoreDirs.has(entry.name)) {
         if (!hasOnlyFilters) {
           lines.push(`${indent}${connector}${entry.name}/  [skipped]`);
         }
@@ -84,8 +114,8 @@ function collectFiles(
       // Get relative path for .txtignore pattern matching
       const relPathForIgnore = path.relative(rootDir, path.join(dir, entry.name)).split(path.sep).join("/");
       
-      // Check against .txtignore patterns (both dirname and relative path)
-      if (txtIgnore.has(entry.name) || txtIgnore.has(`${entry.name}/`) || txtIgnore.has(relPathForIgnore) || txtIgnore.has(`${relPathForIgnore}/`) || txtIgnore.has(`/${relPathForIgnore}/`)) {
+      // Check against .txtignore patterns (both dirname and relative path) unless force is enabled
+      if (!force && (txtIgnore.has(entry.name) || txtIgnore.has(`${entry.name}/`) || txtIgnore.has(relPathForIgnore) || txtIgnore.has(`${relPathForIgnore}/`) || txtIgnore.has(`/${relPathForIgnore}/`))) {
         if (!hasOnlyFilters) {
           lines.push(`${indent}${connector}${entry.name}/  [skipped]`);
         }
@@ -111,6 +141,7 @@ function collectFiles(
           hasOnlyFilters,
           rootName,
           txtIgnore,
+          force,
         },
       );
 
@@ -123,18 +154,18 @@ function collectFiles(
         filePaths.push(...child.filePaths);
       }
     } else {
-      if (ignoreFiles.has(entry.name)) return;
+      if (!force && ignoreFiles.has(entry.name)) return;
 
       // Get relative path for .txtignore pattern matching
       const relPathForIgnore = path.relative(rootDir, path.join(dir, entry.name)).split(path.sep).join("/");
       
-      // Check against .txtignore patterns (both filename and relative path)
-      if (txtIgnore.has(entry.name) || txtIgnore.has(relPathForIgnore) || txtIgnore.has(`/${relPathForIgnore}`)) {
+      // Check against .txtignore patterns (both filename and relative path) unless force is enabled
+      if (!force && (txtIgnore.has(entry.name) || txtIgnore.has(relPathForIgnore) || txtIgnore.has(`/${relPathForIgnore}`))) {
         return;
       }
 
-      // Ignore .txt files that match the folder name (e.g., foldername.txt)
-      if (entry.name.endsWith('.txt') && entry.name === `${rootName}.txt`) return;
+      // Ignore .txt files that match the folder name (e.g., foldername.txt) unless force is enabled
+      if (!force && entry.name.endsWith('.txt') && entry.name === `${rootName}.txt`) return;
 
       const shouldIncludeFile = !hasOnlyFilters || inSelectedFolder || onlyFiles.has(entry.name);
       if (!shouldIncludeFile) return;
@@ -148,12 +179,12 @@ function collectFiles(
   return { lines, filePaths, hasIncluded: filePaths.length > 0 || lines.length > 0 };
 }
 
-function readContent(absPath) {
+function readContent(absPath, force = false) {
   const ext = path.extname(absPath).toLowerCase();
-  if (BINARY_EXTS.has(ext)) return "[binary / skipped]";
+  if (!force && BINARY_EXTS.has(ext)) return "[binary / skipped]";
   try {
     const stat = fs.statSync(absPath);
-    if (stat.size > 500 * 1024) {
+    if (!force && stat.size > 500 * 1024) {
       return `[file too large: ${(stat.size / 1024).toFixed(1)} KB – skipped]`;
     }
     return fs.readFileSync(absPath, "utf8");
@@ -166,6 +197,205 @@ function readContent(absPath) {
 
 const args = process.argv.slice(2);
 
+// Check if completion is already installed, install if not
+function checkAndInstallCompletion() {
+  const { execSync } = require('child_process');
+  const path = require('path');
+  const os = require('os');
+  const fs = require('fs');
+  
+  try {
+    const homeDir = os.homedir();
+    const shell = process.env.SHELL || '';
+    const platform = process.platform;
+    let completionInstalled = false;
+    
+    if (platform === 'win32') {
+      // Check PowerShell completion - try multiple profile locations
+      const profilePaths = [
+        path.join(homeDir, 'Documents', 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1'),
+        path.join(homeDir, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1'),
+        path.join(homeDir, '.config', 'powershell', 'Microsoft.PowerShell_profile.ps1')
+      ];
+      
+      for (const profilePath of profilePaths) {
+        if (fs.existsSync(profilePath)) {
+          const profileContent = fs.readFileSync(profilePath, 'utf8');
+          if (profileContent.includes('make-folder-txt-completion')) {
+            completionInstalled = true;
+            break;
+          }
+        }
+      }
+    } else if (shell.includes('zsh')) {
+      // Check zsh completion
+      const zshrc = path.join(homeDir, '.zshrc');
+      if (fs.existsSync(zshrc)) {
+        const zshrcContent = fs.readFileSync(zshrc, 'utf8');
+        if (zshrcContent.includes('make-folder-txt')) {
+          completionInstalled = true;
+        }
+      }
+    } else {
+      // Check bash completion
+      const bashrc = path.join(homeDir, '.bashrc');
+      if (fs.existsSync(bashrc)) {
+        const bashrcContent = fs.readFileSync(bashrc, 'utf8');
+        if (bashrcContent.includes('make-folder-txt-completion')) {
+          completionInstalled = true;
+        }
+      }
+    }
+    
+    // If completion is not installed, install it automatically
+    if (!completionInstalled) {
+      console.log('🔧 Installing shell autocompletion for make-folder-txt...');
+      
+      if (platform === 'win32') {
+        // Windows PowerShell
+        try {
+          execSync('powershell -Command "Get-Host"', { stdio: 'ignore' });
+          const installScript = path.join(__dirname, '..', 'completion', 'install-powershell-completion.ps1');
+          execSync(`powershell -ExecutionPolicy Bypass -File "${installScript}"`, { stdio: 'ignore' });
+          console.log('✅ PowerShell completion installed!');
+        } catch (err) {
+          // Silent fail for PowerShell
+        }
+      } else if (shell.includes('zsh')) {
+        // zsh
+        try {
+          const zshrc = path.join(homeDir, '.zshrc');
+          const completionDir = path.join(homeDir, '.zsh', 'completions');
+          execSync(`mkdir -p "${completionDir}"`, { stdio: 'ignore' });
+          const completionPath = path.join(__dirname, '..', 'completion', 'make-folder-txt-completion.zsh');
+          execSync(`cp "${completionPath}" "${completionDir}/_make-folder-txt"`, { stdio: 'ignore' });
+          
+          try {
+            const zshrcContent = fs.readFileSync(zshrc, 'utf8');
+            if (!zshrcContent.includes('fpath+=~/.zsh/completions')) {
+              fs.appendFileSync(zshrc, '\n# make-folder-txt completion\nfpath+=~/.zsh/completions\nautoload -U compinit && compinit\n');
+            }
+          } catch (e) {
+            fs.writeFileSync(zshrc, '# make-folder-txt completion\nfpath+=~/.zsh/completions\nautoload -U compinit && compinit\n');
+          }
+          console.log('✅ Zsh completion installed!');
+        } catch (err) {
+          // Silent fail for zsh
+        }
+      } else {
+        // bash
+        try {
+          const bashrc = path.join(homeDir, '.bashrc');
+          const completionPath = path.join(__dirname, '..', 'completion', 'make-folder-txt-completion.bash');
+          try {
+            const bashrcContent = fs.readFileSync(bashrc, 'utf8');
+            if (!bashrcContent.includes('make-folder-txt-completion.bash')) {
+              fs.appendFileSync(bashrc, `\n# make-folder-txt completion\nsource "${completionPath}"\n`);
+            }
+          } catch (e) {
+            fs.writeFileSync(bashrc, `# make-folder-txt completion\nsource "${completionPath}"\n`);
+          }
+          console.log('✅ Bash completion installed!');
+        } catch (err) {
+          // Silent fail for bash
+        }
+      }
+      
+      console.log('💡 Restart your terminal to enable autocompletion');
+      console.log('');
+    }
+  } catch (err) {
+    // Silent fail - don't interrupt the main functionality
+  }
+}
+
+// Run completion check on first run (but not for help/version commands)
+if (!args.includes("--help") && !args.includes("-h") && 
+    !args.includes("--version") && !args.includes("-v") && 
+    !args.includes("--install-completion")) {
+  checkAndInstallCompletion();
+}
+
+if (args.includes("--install-completion")) {
+  const { execSync } = require('child_process');
+  const path = require('path');
+  const os = require('os');
+  
+  try {
+    const homeDir = os.homedir();
+    const shell = process.env.SHELL || '';
+    const platform = process.platform;
+    
+    if (platform === 'win32') {
+      // Windows - Check if PowerShell is available
+      try {
+        execSync('powershell -Command "Get-Host"', { stdio: 'ignore' });
+        
+        // Install PowerShell completion
+        const completionScript = path.join(__dirname, '..', 'completion', 'make-folder-txt-completion.ps1');
+        const installScript = path.join(__dirname, '..', 'completion', 'install-powershell-completion.ps1');
+        
+        // Run the PowerShell installation script
+        execSync(`powershell -ExecutionPolicy Bypass -File "${installScript}"`, { stdio: 'inherit' });
+        
+      } catch (err) {
+        console.error('❌ Failed to install PowerShell completion:', err.message);
+        process.exit(1);
+      }
+      
+    } else if (shell.includes('zsh')) {
+      // Install for zsh
+      const zshrc = path.join(homeDir, '.zshrc');
+      const completionDir = path.join(homeDir, '.zsh', 'completions');
+      
+      // Create completions directory if it doesn't exist
+      try {
+        execSync(`mkdir -p "${completionDir}"`, { stdio: 'ignore' });
+      } catch (e) {}
+      
+      // Copy completion file
+      const completionPath = path.join(__dirname, '..', 'completion', 'make-folder-txt-completion.zsh');
+      execSync(`cp "${completionPath}" "${completionDir}/_make-folder-txt"`, { stdio: 'ignore' });
+      
+      // Add to .zshrc if not already there
+      try {
+        const zshrcContent = fs.readFileSync(zshrc, 'utf8');
+        if (!zshrcContent.includes('fpath+=~/.zsh/completions')) {
+          fs.appendFileSync(zshrc, '\n# make-folder-txt completion\nfpath+=~/.zsh/completions\nautoload -U compinit && compinit\n');
+        }
+      } catch (e) {
+        // .zshrc doesn't exist, create it
+        fs.writeFileSync(zshrc, '# make-folder-txt completion\nfpath+=~/.zsh/completions\nautoload -U compinit && compinit\n');
+      }
+      
+      console.log('✅ Zsh completion installed! Restart your terminal or run: source ~/.zshrc');
+      
+    } else {
+      // Install for bash
+      const bashrc = path.join(homeDir, '.bashrc');
+      const completionPath = path.join(__dirname, '..', 'completion', 'make-folder-txt-completion.bash');
+      
+      // Add to .bashrc if not already there
+      try {
+        const bashrcContent = fs.readFileSync(bashrc, 'utf8');
+        if (!bashrcContent.includes('make-folder-txt-completion.bash')) {
+          fs.appendFileSync(bashrc, `\n# make-folder-txt completion\nsource "${completionPath}"\n`);
+        }
+      } catch (e) {
+        // .bashrc doesn't exist, create it
+        fs.writeFileSync(bashrc, `# make-folder-txt completion\nsource "${completionPath}"\n`);
+      }
+      
+      console.log('✅ Bash completion installed! Restart your terminal or run: source ~/.bashrc');
+    }
+  } catch (err) {
+    console.error('❌ Failed to install completion:', err.message);
+    process.exit(1);
+  }
+  
+  process.exit(0);
+}
+
 if (args.includes("-v") || args.includes("--version")) {
   console.log(`v${version}`);
   console.log("Built by Muhammad Saad Amin");
@@ -181,19 +411,29 @@ Dump an entire project folder into a single readable .txt file.
   make-folder-txt [options]
 
 \x1b[33mOPTIONS\x1b[0m
-  --ignore-folder <names...>    Ignore specific folders by name
-  --ignore-file <names...>      Ignore specific files by name
-  --only-folder <names...>      Include only specific folders
-  --only-file <names...>        Include only specific files
-  --help, -h                    Show this help message
-  --version, -v                 Show version information
+  --ignore-folder, -ifo <names...>    Ignore specific folders by name
+  --ignore-file, -ifi <names...>      Ignore specific files by name
+  --only-folder, -ofo <names...>      Include only specific folders
+  --only-file, -ofi <names...>        Include only specific files
+  --copy                              Copy output to clipboard
+  --force                             Include everything (overrides all ignore patterns)
+  --install-completion         Install shell autocompletion (bash/zsh/PowerShell) - usually automatic
+  --help, -h                          Show this help message
+  --version, -v                       Show version information
 
 \x1b[33mEXAMPLES\x1b[0m
   make-folder-txt
+  make-folder-txt --copy
+  make-folder-txt --force
+  make-folder-txt --install-completion
   make-folder-txt --ignore-folder node_modules dist
+  make-folder-txt -ifo node_modules dist
   make-folder-txt --ignore-file .env .env.local
+  make-folder-txt -ifi .env .env.local
   make-folder-txt --only-folder src docs
+  make-folder-txt -ofo src docs
   make-folder-txt --only-file package.json README.md
+  make-folder-txt -ofi package.json README.md
 
 \x1b[33m.TXTIGNORE FILE\x1b[0m
   Create a .txtignore file in your project root to specify files/folders to ignore.
@@ -214,11 +454,23 @@ const ignoreFiles = new Set(IGNORE_FILES);
 const onlyFolders = new Set();
 const onlyFiles = new Set();
 let outputArg = null;
+let copyToClipboardFlag = false;
+let forceFlag = false;
 
 for (let i = 0; i < args.length; i += 1) {
   const arg = args[i];
 
-  if (arg === "--ignore-folder") {
+  if (arg === "--copy") {
+    copyToClipboardFlag = true;
+    continue;
+  }
+
+  if (arg === "--force") {
+    forceFlag = true;
+    continue;
+  }
+
+  if (arg === "--ignore-folder" || arg === "-ifo") {
     let consumed = 0;
     while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
       ignoreDirs.add(args[i + 1]);
@@ -232,8 +484,10 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg.startsWith("--ignore-folder=")) {
-    const value = arg.slice("--ignore-folder=".length);
+  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);
@@ -242,7 +496,7 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg === "--ignore-file") {
+  if (arg === "--ignore-file" || arg === "-ifi") {
     let consumed = 0;
     while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
       ignoreFiles.add(args[i + 1]);
@@ -256,8 +510,10 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg.startsWith("--ignore-file=")) {
-    const value = arg.slice("--ignore-file=".length);
+  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);
@@ -266,7 +522,7 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg === "--only-folder") {
+  if (arg === "--only-folder" || arg === "-ofo") {
     let consumed = 0;
     while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
       onlyFolders.add(args[i + 1]);
@@ -280,8 +536,10 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg.startsWith("--only-folder=")) {
-    const value = arg.slice("--only-folder=".length);
+  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);
@@ -290,7 +548,7 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg === "--only-file") {
+  if (arg === "--only-file" || arg === "-ofi") {
     let consumed = 0;
     while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
       onlyFiles.add(args[i + 1]);
@@ -304,8 +562,10 @@ for (let i = 0; i < args.length; i += 1) {
     continue;
   }
 
-  if (arg.startsWith("--only-file=")) {
-    const value = arg.slice("--only-file=".length);
+  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);
@@ -348,7 +608,7 @@ const { lines: treeLines, filePaths } = collectFiles(
   ignoreFiles,
   onlyFolders,
   onlyFiles,
-  { hasOnlyFilters, rootName, txtIgnore },
+  { hasOnlyFilters, rootName, txtIgnore, force: forceFlag },
 );
 
 // ── build output ──────────────────────────────────────────────────────────────
@@ -380,7 +640,7 @@ filePaths.forEach(({ abs, rel }) => {
   out.push(subDivider);
   out.push(`FILE: ${rel}`);
   out.push(subDivider);
-  out.push(readContent(abs));
+  out.push(readContent(abs, forceFlag));
 });
 
 out.push("");
@@ -394,4 +654,14 @@ 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}\n`);
+console.log(`🗂️   Files  : ${filePaths.length}`);
+
+if (copyToClipboardFlag) {
+  const content = fs.readFileSync(outputFile, 'utf8');
+  const success = copyToClipboard(content);
+  if (success) {
+    console.log(`📋  Copied to clipboard!`);
+  }
+}
+
+console.log('');

package/completion/install-powershell-completion.ps1

@@ -0,0 +1,75 @@
+# PowerShell completion installation script for make-folder-txt
+
+function Install-MakeFolderTxtCompletion {
+    param(
+        [switch]$Force,
+        [switch]$CurrentUser
+    )
+    
+    $ErrorActionPreference = 'Stop'
+    
+    # Determine PowerShell profile path
+    if ($CurrentUser) {
+        $profilePath = $PROFILE.CurrentUserCurrentHost
+    } else {
+        $profilePath = $PROFILE.AllUsersCurrentHost
+    }
+    
+    # Create profile directory if it doesn't exist
+    $profileDir = Split-Path $profilePath -Parent
+    if (-not (Test-Path $profileDir)) {
+        try {
+            New-Item -ItemType Directory -Path $profileDir -Force | Out-Null
+            Write-Host "Created profile directory: $profileDir" -ForegroundColor Green
+        } catch {
+            Write-Error "Failed to create profile directory: $profileDir"
+            return
+        }
+    }
+    
+    # Get the completion script content
+    $completionScriptPath = Join-Path $PSScriptRoot 'make-folder-txt-completion.ps1'
+    if (-not (Test-Path $completionScriptPath)) {
+        Write-Error "Completion script not found: $completionScriptPath"
+        return
+    }
+    
+    $completionContent = Get-Content $completionScriptPath -Raw
+    
+    # Check if completion is already installed
+    if (Test-Path $profilePath) {
+        $profileContent = Get-Content $profilePath -Raw
+        if ($profileContent -match 'make-folder-txt.*completion') {
+            if (-not $Force) {
+                Write-Host "make-folder-txt completion is already installed in $profilePath" -ForegroundColor Yellow
+                Write-Host "Use -Force to reinstall" -ForegroundColor Yellow
+                return
+            }
+            Write-Host "Removing existing completion..." -ForegroundColor Yellow
+            # Remove existing completion
+            $profileContent = $profileContent -replace '(?s)# make-folder-txt completion.*?Register-ArgumentComplester.*?Export-ModuleMember.*?\n', ''
+            Set-Content $profilePath $profileContent -Force
+        }
+    }
+    
+    # Add completion to profile
+    $completionBlock = @"
+
+# make-folder-txt completion
+$completionContent
+"@
+    
+    try {
+        Add-Content $profilePath $completionBlock -Force
+        Write-Host "✅ PowerShell completion installed successfully!" -ForegroundColor Green
+        Write-Host "Added to: $profilePath" -ForegroundColor Cyan
+        Write-Host "Restart PowerShell or run: . `$profile" -ForegroundColor Cyan
+    } catch {
+        Write-Error "Failed to install completion: $_"
+    }
+}
+
+# Auto-install if script is run directly
+if ($MyInvocation.InvocationName -eq $MyInvocation.MyCommand.Name) {
+    Install-MakeFolderTxtCompletion -CurrentUser
+}

package/completion/make-folder-txt-completion.bash

@@ -0,0 +1,41 @@
+#!/bin/bash
+# make-folder-txt bash completion
+
+_make_folder_txt_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+    
+    opts="--ignore-folder -ifo --ignore-file -ifi --only-folder -ofo --only-file -ofi --copy --force --help --version -h -v"
+    
+    case "${prev}" in
+        --ignore-folder|-ifo)
+            # Complete with folder names in current directory
+            local folders=$(ls -d */ 2>/dev/null | sed 's|/||g')
+            COMPREPLY=( $(compgen -W "${folders}" -- ${cur}) )
+            return 0
+            ;;
+        --ignore-file|-ifi|--only-file|-ofi)
+            # Complete with file names in current directory
+            local files=$(ls -p 2>/dev/null | grep -v /)
+            COMPREPLY=( $(compgen -W "${files}" -- ${cur}) )
+            return 0
+            ;;
+        --only-folder|-ofo)
+            # Complete with folder names in current directory
+            local folders=$(ls -d */ 2>/dev/null | sed 's|/||g')
+            COMPREPLY=( $(compgen -W "${folders}" -- ${cur}) )
+            return 0
+            ;;
+        *)
+            ;;
+    esac
+    
+    if [[ ${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+        return 0
+    fi
+}
+
+complete -F _make_folder_txt_completion make-folder-txt

package/completion/make-folder-txt-completion.ps1

@@ -0,0 +1,67 @@
+# make-folder-txt PowerShell completion script
+
+Register-ArgumentCompleter -Native -CommandName 'make-folder-txt' -ScriptBlock {
+    param($commandName, $wordToComplete, $commandAst, $fakeBoundParameters)
+
+    # Get the current argument being completed
+    $currentArgument = $wordToComplete
+
+    # Define available options
+    $options = @(
+        '--ignore-folder', '-ifo',
+        '--ignore-file', '-ifi', 
+        '--only-folder', '-ofo',
+        '--only-file', '-ofi',
+        '--copy',
+        '--force',
+        '--install-completion',
+        '--help', '-h',
+        '--version', '-v'
+    )
+
+    # Get the previous parameter to determine context
+    $previousParameter = if ($commandAst.CommandElements.Count -gt 1) {
+        $commandAst.CommandElements[-2].Extent.Text
+    } else {
+        ''
+    }
+
+    switch ($previousParameter) {
+        { $_ -in '--ignore-folder', '-ifo', '--only-folder', '-ofo' } {
+            # Complete with folder names
+            try {
+                $folders = Get-ChildItem -Directory -Name | Where-Object { $_ -like "*$currentArgument*" }
+                return $folders | ForEach-Object { 
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', "Folder: $_")
+                }
+            } catch {
+                return @()
+            }
+        }
+        { $_ -in '--ignore-file', '-ifi', '--only-file', '-ofi' } {
+            # Complete with file names
+            try {
+                $files = Get-ChildItem -File -Name | Where-Object { $_ -like "*$currentArgument*" }
+                return $files | ForEach-Object { 
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', "File: $_")
+                }
+            } catch {
+                return @()
+            }
+        }
+        default {
+            # Complete with options
+            if ($currentArgument -like '-*') {
+                $matchingOptions = $options | Where-Object { $_ -like "*$currentArgument*" }
+                return $matchingOptions | ForEach-Object { 
+                    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', "Option: $_")
+                }
+            }
+        }
+    }
+
+    return @()
+}
+
+# Export the completion function
+Export-ModuleMember -Function *

package/completion/make-folder-txt-completion.zsh

@@ -0,0 +1,26 @@
+#compdef make-folder-txt
+# make-folder-txt zsh completion
+
+_make_folder_txt() {
+    local -a arguments
+    arguments=(
+        '--ignore-folder[Ignore specific folders by name]:folder:_directories'
+        '-ifo[Ignore specific folders by name]:folder:_directories'
+        '--ignore-file[Ignore specific files by name]:file:_files'
+        '-ifi[Ignore specific files by name]:file:_files'
+        '--only-folder[Include only specific folders]:folder:_directories'
+        '-ofo[Include only specific folders]:folder:_directories'
+        '--only-file[Include only specific files]:file:_files'
+        '-ofi[Include only specific files]:file:_files'
+        '--copy[Copy output to clipboard]'
+        '--force[Include everything (overrides all ignore patterns)]'
+        '--help[Show help message]'
+        '--version[Show version information]'
+        '-h[Show help message]'
+        '-v[Show version information]'
+    )
+    
+    _arguments -s -S $arguments && return 0
+}
+
+_make_folder_txt "$@"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "make-folder-txt",
-  "version": "1.4.4",
+  "version": "2.0.1",
   "description": "Generate a single .txt file containing the full folder structure and file contents of any project, ignoring node_modules and other junk.",
   "main": "bin/make-folder-txt.js",
   "bin": {