make-folder-txt 1.0.4 → 1.1.0

package/README.md

@@ -53,9 +53,18 @@ That's it. A `my-project.txt` file will be created in the same directory.
 Ignore specific folders/files by name:
 
 ```bash
-make-folder-txt --ignore-folder logs
-make-folder-txt --ignore-file .env
-make-folder-txt --ignore-folder dist --ignore-folder coverage --ignore-file secrets.txt
+make-folder-txt --ignore-folder examples extensions docs
+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
+```
+
+Include only specific folders/files by name (everything else is ignored):
+
+```bash
+make-folder-txt --only-folder src docs
+make-folder-txt --only-file package.json README.md
+make-folder-txt --only-folder src --only-file package.json
 ```
 
 ---

package/bin/make-folder-txt.js

@@ -19,12 +19,28 @@ const BINARY_EXTS = new Set([
 
 // ── helpers ───────────────────────────────────────────────────────────────────
 
-function collectFiles(dir, rootDir, ignoreDirs, ignoreFiles, indent = "", lines = [], filePaths = []) {
+function collectFiles(
+  dir,
+  rootDir,
+  ignoreDirs,
+  ignoreFiles,
+  onlyFolders,
+  onlyFiles,
+  options = {},
+) {
+  const {
+    indent = "",
+    lines = [],
+    filePaths = [],
+    inSelectedFolder = false,
+    hasOnlyFilters = false,
+  } = options;
+
   let entries;
   try {
     entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
-    return { lines, filePaths };
+    return { lines, filePaths, hasIncluded: false };
   }
 
   entries.sort((a, b) => {
@@ -39,20 +55,53 @@ function collectFiles(dir, rootDir, ignoreDirs, ignoreFiles, indent = "", lines
 
     if (entry.isDirectory()) {
       if (ignoreDirs.has(entry.name)) {
-        lines.push(`${indent}${connector}${entry.name}/  [skipped]`);
+        if (!hasOnlyFilters) {
+          lines.push(`${indent}${connector}${entry.name}/  [skipped]`);
+        }
         return;
       }
-      lines.push(`${indent}${connector}${entry.name}/`);
-      collectFiles(path.join(dir, entry.name), rootDir, ignoreDirs, ignoreFiles, childIndent, lines, filePaths);
+
+      const childPath = path.join(dir, entry.name);
+      const childInSelectedFolder = inSelectedFolder || onlyFolders.has(entry.name);
+      const childLines = [];
+      const childFiles = [];
+      const child = collectFiles(
+        childPath,
+        rootDir,
+        ignoreDirs,
+        ignoreFiles,
+        onlyFolders,
+        onlyFiles,
+        {
+          indent: childIndent,
+          lines: childLines,
+          filePaths: childFiles,
+          inSelectedFolder: childInSelectedFolder,
+          hasOnlyFilters,
+        },
+      );
+
+      const explicitlySelectedFolder = hasOnlyFilters && onlyFolders.has(entry.name);
+      const shouldIncludeDir = !hasOnlyFilters || child.hasIncluded || explicitlySelectedFolder;
+
+      if (shouldIncludeDir) {
+        lines.push(`${indent}${connector}${entry.name}/`);
+        lines.push(...child.lines);
+        filePaths.push(...child.filePaths);
+      }
     } else {
       if (ignoreFiles.has(entry.name)) return;
+
+      const shouldIncludeFile = !hasOnlyFilters || inSelectedFolder || onlyFiles.has(entry.name);
+      if (!shouldIncludeFile) return;
+
       lines.push(`${indent}${connector}${entry.name}`);
       const relPath = "/" + path.relative(rootDir, path.join(dir, entry.name)).split(path.sep).join("/");
       filePaths.push({ abs: path.join(dir, entry.name), rel: relPath });
     }
   });
 
-  return { lines, filePaths };
+  return { lines, filePaths, hasIncluded: filePaths.length > 0 || lines.length > 0 };
 }
 
 function readContent(absPath) {
@@ -81,37 +130,109 @@ if (args.includes("-v") || args.includes("--version")) {
 
 const ignoreDirs = new Set(IGNORE_DIRS);
 const ignoreFiles = new Set(IGNORE_FILES);
+const onlyFolders = new Set();
+const onlyFiles = new Set();
 let outputArg = null;
 
 for (let i = 0; i < args.length; i += 1) {
   const arg = args[i];
 
-  if (arg === "--ignore-folder" || arg.startsWith("--ignore-folder=")) {
-    const value = arg.startsWith("--ignore-folder=")
-      ? arg.slice("--ignore-folder=".length)
-      : args[i + 1];
-    if (!value || value.startsWith("-")) {
+  if (arg === "--ignore-folder") {
+    let consumed = 0;
+    while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+      ignoreDirs.add(args[i + 1]);
+      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=")) {
+    const value = arg.slice("--ignore-folder=".length);
+    if (!value) {
       console.error("Error: --ignore-folder requires a folder name.");
       process.exit(1);
     }
-    if (!arg.includes("=")) i += 1;
     ignoreDirs.add(value);
     continue;
   }
 
-  if (arg === "--ignore-file" || arg.startsWith("--ignore-file=")) {
-    const value = arg.startsWith("--ignore-file=")
-      ? arg.slice("--ignore-file=".length)
-      : args[i + 1];
-    if (!value || value.startsWith("-")) {
+  if (arg === "--ignore-file") {
+    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=")) {
+    const value = arg.slice("--ignore-file=".length);
+    if (!value) {
       console.error("Error: --ignore-file requires a file name.");
       process.exit(1);
     }
-    if (!arg.includes("=")) i += 1;
     ignoreFiles.add(value);
     continue;
   }
 
+  if (arg === "--only-folder") {
+    let consumed = 0;
+    while (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+      onlyFolders.add(args[i + 1]);
+      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=")) {
+    const value = arg.slice("--only-folder=".length);
+    if (!value) {
+      console.error("Error: --only-folder requires a folder name.");
+      process.exit(1);
+    }
+    onlyFolders.add(value);
+    continue;
+  }
+
+  if (arg === "--only-file") {
+    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=")) {
+    const value = arg.slice("--only-file=".length);
+    if (!value) {
+      console.error("Error: --only-file requires a file name.");
+      process.exit(1);
+    }
+    onlyFiles.add(value);
+    continue;
+  }
+
   if (arg.startsWith("-")) {
     console.error(`Error: Unknown option "${arg}".`);
     process.exit(1);
@@ -136,7 +257,16 @@ const outputFile = outputArg
 
 console.log(`\n📂  Scanning: ${folderPath}`);
 
-const { lines: treeLines, filePaths } = collectFiles(folderPath, folderPath, ignoreDirs, ignoreFiles);
+const hasOnlyFilters = onlyFolders.size > 0 || onlyFiles.size > 0;
+const { lines: treeLines, filePaths } = collectFiles(
+  folderPath,
+  folderPath,
+  ignoreDirs,
+  ignoreFiles,
+  onlyFolders,
+  onlyFiles,
+  { hasOnlyFilters },
+);
 
 // ── build output ──────────────────────────────────────────────────────────────
 const out = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "make-folder-txt",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "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": {