folder-generator 2.0.0 → 3.0.1

package/bin/cli.js

@@ -1,6 +1,5 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const fs = require('fs');
-const path = require('path');
 const chalk = require('chalk');
 const { parseStructure, createFiles } = require('../lib/generator');
 const yargs = require('yargs/yargs');
@@ -27,23 +26,18 @@ async function main() {
   if (argv.file) {
     try {
       input = fs.readFileSync(argv.file, 'utf8');
-    } catch (err) {
+    } catch {
       console.error(chalk.red(`Error reading file: ${argv.file}`));
       process.exit(1);
     }
   } else if (argv.input) {
     input = argv.input;
   } else if (!process.stdin.isTTY) {
-    // Read from stdin if piped
     const chunks = [];
     for await (const chunk of process.stdin) chunks.push(chunk);
     input = Buffer.concat(chunks).toString('utf8');
   } else {
     console.error(chalk.red('Error: No input provided'));
-    console.log(chalk.yellow('Usage:'));
-    console.log(chalk.yellow('  foldgen --input "your/structure"'));
-    console.log(chalk.yellow('  foldgen --file structure.txt'));
-    console.log(chalk.yellow('  echo "structure" | foldgen'));
     process.exit(1);
   }
 
@@ -51,11 +45,11 @@ async function main() {
     console.log(chalk.yellow('\nParsing structure...'));
     const structure = parseStructure(input);
     createFiles(structure);
-    console.log(chalk.bold.green('\n✔ Folder structure created successfully!'));
-  } catch (error) {
-    console.error(chalk.red('\n✖ Error creating structure:'), error.message);
+    console.log(chalk.green.bold('\n✔ Folder structure created successfully!\n'));
+  } catch (err) {
+    console.error(chalk.red('\n✖ Error:'), err.message);
     process.exit(1);
   }
 }
 
-main();
+main();

package/lib/generator.js

@@ -2,64 +2,131 @@ const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
 
+/**
+ * Entry point parser
+ * Automatically detects tree-format vs indented-path format
+ */
 function parseStructure(text) {
+  if (text.includes('├──') || text.includes('└──')) {
+    return parseTreeFormat(text);
+  }
+  return parseIndentedPathFormat(text);
+}
+
+/**
+ * =========================
+ * TREE FORMAT PARSER (OLD)
+ * =========================
+ * Supports:
+ * ├── backend/
+ * │   └── main.go
+ */
+function parseTreeFormat(text) {
   const lines = text.split('\n').filter(line => line.trim());
-  const root = { name: '', children: [], isDirectory: true }; // Root is always a directory
+  const root = { name: '', children: [], isDirectory: true };
   let stack = [{ node: root, depth: -1 }];
 
   for (const line of lines) {
-    // Calculate depth based on leading tree characters
     const depth = (line.match(/^[ │├└─]*/)[0].length) / 4;
 
-    // Extract the name, remove comments (using //), and trim whitespace
     let name = line.replace(/^[ │├└─]*/, '').split('//')[0].trim();
     if (!name) continue;
 
-    // A name ending with '/' is a directory
     const isDirectory = name.endsWith('/');
-    if (isDirectory) {
-      name = name.slice(0, -1); // Remove the trailing '/' from the name
-    }
+    if (isDirectory) name = name.slice(0, -1);
 
-    // Find the correct parent in the stack based on depth
     while (depth <= stack[stack.length - 1].depth) {
       stack.pop();
     }
 
     const parent = stack[stack.length - 1].node;
     const newNode = { name, children: [], isDirectory };
+
     parent.children.push(newNode);
     stack.push({ node: newNode, depth });
   }
+
   return root;
 }
 
+/**
+ * =====================================
+ * INDENTED + PATH FORMAT PARSER (NEW)
+ * =====================================
+ * Supports:
+ *
+ * backend/
+ *   cmd/server/main.go
+ *   internal/config/config.go
+ */
+function parseIndentedPathFormat(text) {
+  const lines = text.split('\n').filter(line => line.trim());
+  const root = { name: '', children: [], isDirectory: true };
+  const stack = [{ node: root, indent: -1 }];
+
+  for (const line of lines) {
+    const indent = line.match(/^\s*/)[0].length;
+
+    // ⬇️ strip inline comments BEFORE processing
+    const raw = line.trim().replace(/(#|\/\/|--).*/, '').trim();
+    if (!raw) continue;
+
+    const isExplicitDir = raw.endsWith('/');
+    const trimmed = raw.replace(/\/$/, '');
+
+    while (stack.length && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+
+    let parent = stack[stack.length - 1].node;
+    const parts = trimmed.split('/');
+
+    parts.forEach((part, index) => {
+      const isLast = index === parts.length - 1;
+      const isDirectory = !isLast || isExplicitDir;
+
+      let existing = parent.children.find(c => c.name === part);
+      if (!existing) {
+        existing = { name: part, children: [], isDirectory };
+        parent.children.push(existing);
+      }
+      parent = existing;
+    });
+
+    if (isExplicitDir) {
+      stack.push({ node: parent, indent });
+    }
+  }
+
+  return root;
+}
+
+
 
+/**
+ * ======================
+ * FILE CREATION (OLD)
+ * ======================
+ */
 function createFiles(node, currentPath = '.') {
   if (!node) return;
 
-  // The root node has an empty name and represents the starting path.
   const fullPath = node.name ? path.join(currentPath, node.name) : currentPath;
 
-  // Process only nodes with names (skips the initial root container)
   if (node.name) {
     if (node.isDirectory) {
-      // It's a directory
       fs.mkdirSync(fullPath, { recursive: true });
       console.log(chalk.blue(`✓ Created directory: ${fullPath}`));
     } else {
-      // It's a file
-      // Ensure parent directory exists before creating the file.
       fs.mkdirSync(path.dirname(fullPath), { recursive: true });
       fs.writeFileSync(fullPath, '');
       console.log(chalk.green(`✓ Created file: ${fullPath}`));
     }
   }
 
-  // Process children recursively, passing the new parent path
   node.children.forEach(child => {
     createFiles(child, fullPath);
   });
 }
 
-module.exports = { parseStructure, createFiles };
+module.exports = { parseStructure, createFiles };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "folder-generator",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "description": "CLI tool to generate folder structures from text input",
   "bin": {
     "foldgen": "./bin/cli.js"