folder-generator 1.0.0 → 1.2.0

package/bin/cli.js

@@ -3,75 +3,34 @@
 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);
-    }
-  }
+// Normalize input across operating systems
+function normalizeInput(input) {
+  return input
+    .replace(/\r\n/g, '\n')  // Convert Windows line endings
+    .replace(/\\/g, '/')     // Normalize path separators
+    .replace(/\/\//g, '/');  // Remove duplicate slashes
+}
 
-  // 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');
-  }
+const input = process.argv.slice(2).join(' ');
 
-  if (!input) {
-    console.log(chalk.red('No input provided.'));
-    console.log(chalk.yellow('Provide input via --input, --file, or stdin'));
-    process.exit(1);
-  }
+if (!input) {
+  console.error(chalk.red('Please provide a folder structure as text.'));
+  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);
-  }
+try {
+  const normalized = normalizeInput(input);
+  const structure = parseStructure(normalized);
+  
+  // Debug: Uncomment to see parsed structure
+  // console.log('Parsed structure:', JSON.stringify(structure, null, 2));
+  
+  createFiles(structure);
+  console.log(chalk.bold.green('\nFolder structure created successfully!'));
+} catch (error) {
+  console.error(chalk.red('\nError creating folder structure:'), error);
+  process.exit(1);
 }
 
-main();

package/lib/generator.js

@@ -3,50 +3,47 @@ const path = require('path');
 const chalk = require('chalk');
 
 function parseStructure(text) {
-  const lines = text.split('\n');
+  const lines = text.split('\n').filter(line => line.trim());
   const root = { name: '', children: [] };
-  let currentPath = [root];
-  
+  let stack = [{ node: root, depth: -1 }];
+
   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
+    // Calculate depth based on leading whitespace and tree characters
+    const depth = Math.max(0, (line.match(/^[ │├└─]*/)[0].length / 4));
+    const name = line.replace(/^[ │├└─]*/, '').trim();
+
+    if (!name) continue;
+
+    // Find the correct parent
+    while (depth <= stack[stack.length - 1].depth) {
+      stack.pop();
+    }
+
+    const parent = stack[stack.length - 1].node;
     const newNode = { name, children: [] };
-    currentPath[currentPath.length - 1].children.push(newNode);
-    
-    // Add to path for potential children
-    currentPath.push(newNode);
+    parent.children.push(newNode);
+    stack.push({ node: newNode, depth });
   }
-  
+
   return root;
 }
 
-function createFiles(node, currentPath = '', rootPath = '') {
-  const fullPath = path.join(currentPath, node.name);
-  
+function createFiles(node, basePath = '.') {
+  const fullPath = path.join(basePath, node.name);
+
   if (node.name.includes('.')) {
-    // It's a file
+    // Ensure parent directory exists
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
     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);
-    }
+    console.log(chalk.green(`Created file: ${fullPath}`));
+  } else if (node.name) {
+    fs.mkdirSync(fullPath, { recursive: true });
+    console.log(chalk.blue(`Created directory: ${fullPath}`));
   }
+
+  node.children.forEach(child => {
+    createFiles(child, node.name ? fullPath : basePath);
+  });
 }
 
 module.exports = { parseStructure, createFiles };

package/package.json

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