folder-generator 1.0.0

package/README.md

@@ -0,0 +1,152 @@
+📂 Folder Structure Generator CLI
+A powerful command-line tool to generate complete folder structures from a simple text diagram. Perfect for quickly scaffolding projects, boilerplates, or standardized directory layouts.
+
+🌟 Features
+Generate nested folders and files with a single command
+
+Supports both direct input and file input
+
+Clear visual feedback with color-coded output
+
+Flexible output directory specification
+
+Lightweight with zero dependencies (except for development)
+
+Cross-platform (Windows, macOS, Linux)
+
+📦 Installation
+Global Installation (Recommended)
+bash
+npm install -g folder-structure-generator
+(This allows running the tool from anywhere using foldgen)
+
+Local Installation
+bash
+npm install folder-structure-generator --save-dev
+(Useful when you want it as part of your project's dev tools)
+
+🚀 Basic Usage
+1. Direct Input
+bash
+foldgen --input "src/
+├── App.js
+├── index.js
+└── components/
+    ├── Button.js
+    └── Header.js"
+2. From a File
+bash
+foldgen --file structure.txt
+3. From STDIN (Piping)
+bash
+echo "config/
+├── default.json
+└── production.json" | foldgen
+🔧 Advanced Usage
+Specify Output Directory
+bash
+foldgen --input "lib/utils.js" --output ./my-project
+Combine with Other Tools
+bash
+curl https://example.com/structure.txt | foldgen --output ./src
+Generate in Current Directory
+bash
+foldgen --input "README.md"  # Creates in current folder
+📝 Syntax Guide
+The generator understands standard tree diagram notation:
+
+text
+root/
+├── file.ext
+└── folder/
+    ├── nested_file.ext
+    └── empty_folder/
+Special Characters:
+
+├── for intermediate items
+
+└── for the last item in a level
+
+│ for vertical connections
+
+(spaces) for indentation (4 spaces per level)
+
+🛠️ API Reference (for programmatic use)
+javascript
+const { parseStructure, createFiles } = require('folder-structure-generator');
+
+// Parse text to structure object
+const structure = parseStructure(`src/index.js`);
+
+// Generate files
+createFiles(structure, './output-path');
+🧩 Integration with Other Tools
+With curl:
+bash
+curl -s https://raw.githubusercontent.com/your/repo/base-structure.txt | foldgen
+In package.json scripts:
+json
+{
+  "scripts": {
+    "setup": "foldgen --file project-structure.txt --output ./src",
+    "create:components": "foldgen --input 'src/components/\n├── Button.js\n└── Modal.js'"
+  }
+}
+🏗️ Example Structures
+React Project
+text
+src/
+├── App.js
+├── index.js
+├── components/
+│   ├── Button/
+│   │   ├── index.js
+│   │   ├── styles.css
+│   │   └── tests.js
+│   └── Header.js
+├── pages/
+│   └── Home.js
+└── utils/
+    └── api.js
+Node.js API
+text
+app/
+├── config/
+│   └── database.js
+├── controllers/
+│   └── userController.js
+├── models/
+│   └── User.js
+├── routes/
+│   └── index.js
+├── app.js
+└── package.json
+❓ FAQ
+Q: Can I add content to the generated files?
+A: Currently the tool creates empty files. We're working on template support in the next version!
+
+Q: How do I handle spaces in file names?
+A: Just include them normally in your input: "My Document.docx"
+
+Q: What if I make a mistake in the syntax?
+A: The tool will show you an error with the problematic line number.
+
+🐛 Troubleshooting
+Error: EACCES permission denied
+Solution: Run with sudo or fix your npm permissions:
+
+bash
+sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}
+Error: Missing input
+Solution: Either provide --input, --file, or pipe content to the command
+
+🤝 Contributing
+Fork the repository
+
+Create a feature branch (git checkout -b feature/awesome-feature)
+
+Commit your changes (git commit -am 'Add awesome feature')
+
+Push to the branch (git push origin feature/awesome-feature)
+
+Open a Pull Request

package/bin/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const figlet = require('figlet');
+const yargs = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+const { parseStructure, createFiles } = require('../lib/generator');
+
+// Parse command line arguments
+const argv = yargs(hideBin(process.argv))
+  .usage('Usage: $0 [options]')
+  .option('input', {
+    alias: 'i',
+    type: 'string',
+    description: 'Folder structure text'
+  })
+  .option('file', {
+    alias: 'f',
+    type: 'string',
+    description: 'Path to file containing folder structure'
+  })
+  .option('output', {
+    alias: 'o',
+    type: 'string',
+    description: 'Output directory (default: current directory)',
+    default: process.cwd()
+  })
+  .help()
+  .alias('help', 'h')
+  .argv;
+
+async function main() {
+  // Display banner
+  console.log(
+    chalk.blue(
+      figlet.textSync('FolderGen', { horizontalLayout: 'full' })
+    )
+  );
+
+  let input = argv.input;
+
+  // Read from file if specified
+  if (argv.file) {
+    try {
+      input = fs.readFileSync(argv.file, 'utf8');
+    } catch (err) {
+      console.error(chalk.red(`Error reading file: ${argv.file}`));
+      process.exit(1);
+    }
+  }
+
+  // Get input from stdin if no other source
+  if (!input && !process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    input = Buffer.concat(chunks).toString('utf8');
+  }
+
+  if (!input) {
+    console.log(chalk.red('No input provided.'));
+    console.log(chalk.yellow('Provide input via --input, --file, or stdin'));
+    process.exit(1);
+  }
+
+  try {
+    const structure = parseStructure(input);
+    createFiles(structure, argv.output);
+    console.log(chalk.bold.green('\nFolder structure created successfully!'));
+  } catch (error) {
+    console.error(chalk.red('\nError creating folder structure:'), error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/generator.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+function parseStructure(text) {
+  const lines = text.split('\n');
+  const root = { name: '', children: [] };
+  let currentPath = [root];
+  
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    
+    // Determine the depth based on indentation
+    const depth = (line.match(/[├└──]/)?.index || 0) / 4;
+    const name = line.replace(/[├└──│ ]/g, '').trim();
+    
+    // Navigate to the correct parent
+    currentPath = currentPath.slice(0, depth + 1);
+    
+    // Create new node
+    const newNode = { name, children: [] };
+    currentPath[currentPath.length - 1].children.push(newNode);
+    
+    // Add to path for potential children
+    currentPath.push(newNode);
+  }
+  
+  return root;
+}
+
+function createFiles(node, currentPath = '', rootPath = '') {
+  const fullPath = path.join(currentPath, node.name);
+  
+  if (node.name.includes('.')) {
+    // It's a file
+    fs.writeFileSync(fullPath, '');
+    console.log(chalk.green(`Created file: ${path.relative(rootPath, fullPath)}`));
+  } else {
+    // It's a directory
+    if (node.name) { // Skip empty root name
+      fs.mkdirSync(fullPath, { recursive: true });
+      console.log(chalk.blue(`Created directory: ${path.relative(rootPath || currentPath, fullPath)}`));
+    }
+    
+    // Create children
+    for (const child of node.children) {
+      createFiles(child, fullPath, rootPath || fullPath);
+    }
+  }
+}
+
+module.exports = { parseStructure, createFiles };

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "folder-generator",
+  "version": "1.0.0",
+  "description": "CLI tool to generate folder structures from text input",
+  "bin": {
+    "foldgen": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "folder",
+    "structure",
+    "generator",
+    "cli",
+    "scaffolding"
+  ],
+  "author": "shreyasghanekar35@gmail.com",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "figlet": "^1.5.2",
+    "yargs": "^17.3.1"
+  }
+}