create-fs-structure 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+```text
+MIT License
+
+Copyright (c) 2025 Maxim Bulavchikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# Create Structure
+
+CLI tool to create directory and file structure from a text scheme.
+
+## Installation
+
+```bash
+# Install globally
+npm install -g create-structure
+
+# Or use with npx
+npx create-structure scheme.txt ./my-project
+```
+
+## Usage
+```bash
+# Create structure from scheme.ts (or .txt) in current directory
+create-structure
+
+# Specify scheme file and target directory
+create-structure ./my-scheme.txt ./my-project
+
+# Dry run (show what would be created)
+create-structure --dry-run scheme.txt ./my-project
+
+# Show help
+create-structure --help
+```
+
+## Scheme Format
+```bash
+# Create a text (.ts or .txt) file with your desired structure:
+
+text
+├── components/
+│   ├── Button/
+│   │   ├── Button.tsx
+│   │   └── index.ts
+│   └── Header.tsx
+├── utils/
+│   └── helpers.ts
+└── package.json
+```

package/bin/cli.cjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+const { createStructureFromScheme, parseLine } = require('../lib/createStructure.cjs');
+const { existsSync, statSync, readFileSync } = require('fs');
+const { join, resolve } = require('path');
+
+// Функция для вывода справки
+function showHelp() {
+  console.log(`
+Использование: node create-structure.js [ПУТЬ_К_СХЕМЕ] [ЦЕЛЕВАЯ_ПАПКА]
+
+Аргументы:
+  ПУТЬ_К_СХЕМЕ    Путь к файлу схемы (по умолчанию: ./scheme.ts)
+  ЦЕЛЕВАЯ_ПАПКА   Путь к папке для создания структуры (по умолчанию: текущая папка)
+
+Особенности:
+  - Если файл уже существует, он не будет перезаписан
+  - Если папка уже существует, скрипт продолжит работу внутри нее
+  - Несуществующие родительские папки будут созданы автоматически
+  - Файлы получают базовое содержимое в зависимости от расширения
+
+Примеры:
+  node create-structure.js                       # Использует scheme.ts и создает в текущей папке
+  node create-structure.js ./my-scheme.txt       # Использует my-scheme.txt в текущей папке
+  node create-structure.js scheme.ts ./my-app    # Использует scheme.ts, создает в ./my-app
+  node create-structure.js ../scheme.txt ../proj # Использует схему на уровень выше
+
+Поддерживаемые форматы схемы:
+  ├── components/          # Папка
+  │   ├── Button.tsx      # Файл
+  └── utils/              # Папка
+`);
+}
+
+function dryRun(schemeFile, targetDir) {
+  console.log(`📄 Схема: ${schemeFile}`);
+  console.log(`📁 Целевая папка: ${resolve(targetDir)}`);
+
+  if (!existsSync(schemeFile)) {
+    console.error(`❌ Файл схемы не найден: ${schemeFile}`);
+    process.exit(1);
+  }
+
+  const content = readFileSync(schemeFile, "utf8");
+  const lines = content.split("\n");
+
+  console.log("\n📋 Планируемые действия:");
+
+  const pathStack = [targetDir];
+  let minLevel = Infinity;
+  const parsedLines = [];
+
+  // Парсим все строки
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const parsed = parseLine(line);
+    if (!parsed) continue;
+    if (parsed.level < minLevel) minLevel = parsed.level;
+    parsedLines.push(parsed);
+  }
+
+  // Симулируем создание
+  for (const parsed of parsedLines) {
+    const normalizedLevel = parsed.level - minLevel;
+    while (pathStack.length > normalizedLevel + 1) {
+      pathStack.pop();
+    }
+
+    const currentPath = pathStack.slice(1).join("/");
+    const fullPath = join(targetDir, currentPath, parsed.name);
+
+    if (existsSync(fullPath)) {
+      const stats = statSync(fullPath);
+      const type = stats.isDirectory() ? "папка" : "файл";
+      console.log(
+        `  ⏭️  Будет пропущен (уже существует): ${fullPath} (${type})`
+      );
+    } else {
+      const type = parsed.isDir ? "папка" : "файл";
+      console.log(`  ✅ Будет создан: ${fullPath} (${type})`);
+    }
+
+    if (parsed.isDir) {
+      pathStack.push(parsed.name);
+    }
+  }
+
+  console.log(
+    "\n🔍 Проверка завершена. Для создания файлов запустите без флага --dry-run"
+  );
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log("create-structure v1.0.0");
+    return;
+  }
+
+  const dryRunFlag = args.includes("--dry-run");
+  if (dryRunFlag) {
+    console.log("🔍 Режим проверки (dry run) - файлы не будут созданы");
+  }
+
+  const filteredArgs = args.filter(
+    (arg) => !arg.startsWith("--") && !arg.startsWith("-")
+  );
+
+  let schemeFile = "scheme.ts";
+  let targetDir = ".";
+
+  if (filteredArgs.length === 1) {
+    const arg = filteredArgs[0];
+    if (existsSync(arg) && statSync(arg).isFile()) {
+      schemeFile = arg;
+    } else {
+      targetDir = arg;
+    }
+  } else if (filteredArgs.length >= 2) {
+    schemeFile = filteredArgs[0];
+    targetDir = filteredArgs[1];
+  }
+
+  if (dryRunFlag) {
+    dryRun(schemeFile, targetDir);
+    return;
+  }
+
+  // Запускаем создание структуры
+  createStructureFromScheme(schemeFile, targetDir);
+}
+
+// Запуск
+main();

package/bin/index.cjs

@@ -0,0 +1,4 @@
+export {
+  createStructureFromScheme,
+  parseLine,
+} from "../lib/createStructure.cjs";

package/bin/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "main": "./cli.js"
+}

package/lib/createStructure.cjs

@@ -0,0 +1,154 @@
+const { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } = require('fs');
+const { join, dirname, extname, basename, resolve } = require('path');
+
+function parseLine(line) {
+  // Удаляем символы дерева, оставляем только отступы
+  let indent = 0;
+
+  // Считаем отступы до первого не-дерева символа
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (
+      char === " " ||
+      char === "│" ||
+      char === "├" ||
+      char === "└" ||
+      char === "─"
+    ) {
+      indent++;
+    } else {
+      break;
+    }
+  }
+
+  // Каждые 4 символа = 1 уровень
+  const level = Math.floor(indent / 4);
+
+  // Получаем чистую строку
+  const clean = line.slice(indent).trim();
+  if (!clean) return null;
+
+  const isDir = clean.endsWith("/");
+  const name = isDir ? clean.slice(0, -1) : clean;
+
+  return { level, isDir, name };
+}
+
+function createStructureFromScheme(schemeFile, targetDir = ".") {
+  try {
+    if (!existsSync(schemeFile)) {
+      throw new Error(`Файл схемы не найден: ${schemeFile}`);
+    }
+
+    const content = readFileSync(schemeFile, "utf8");
+    const lines = content.split("\n");
+
+    const pathStack = [targetDir];
+    let createdCount = 0;
+    let skippedCount = 0;
+
+    console.log(`📄 Чтение схемы из: ${schemeFile}`);
+    console.log(`📁 Создание структуры в: ${resolve(targetDir)}\n`);
+
+    // Сначала найдем минимальный отступ, чтобы нормализовать уровни
+    let minLevel = Infinity;
+    const parsedLines = [];
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      // Парсим строку
+      const parsed = parseLine(line);
+      if (!parsed) continue;
+
+      // Запоминаем минимальный уровень
+      if (parsed.level < minLevel) {
+        minLevel = parsed.level;
+      }
+
+      parsedLines.push(parsed);
+    }
+
+    // Обрабатываем каждую строку
+    for (const parsed of parsedLines) {
+      // Нормализуем уровень (вычитаем минимальный)
+      const normalizedLevel = parsed.level - minLevel;
+
+      // Обновляем стек пути - это КРИТИЧЕСКИ важная часть!
+      while (pathStack.length > normalizedLevel + 1) {
+        pathStack.pop();
+      }
+
+      // Строим полный путь
+      const currentPath = pathStack.slice(1).join("/");
+      const fullPath = join(targetDir, currentPath, parsed.name);
+
+      // Создаем элемент
+      if (parsed.isDir) {
+        try {
+          if (existsSync(fullPath)) {
+            console.log(`✓ Папка уже существует: ${fullPath}`);
+            skippedCount++;
+          } else {
+            mkdirSync(fullPath, { recursive: true });
+            console.log(`✓ Создана новая папка: ${fullPath}`);
+            createdCount++;
+          }
+          // Добавляем папку в стек для следующего уровня
+          pathStack.push(parsed.name);
+        } catch (err) {
+          console.error(`✗ Ошибка создания папки ${fullPath}:`, err.message);
+        }
+      } else {
+        try {
+          // Создаем родительскую папку если нужно
+          const parentDir = dirname(fullPath);
+          if (!existsSync(parentDir)) {
+            mkdirSync(parentDir, { recursive: true });
+            console.log(`✓ Создана родительская папка: ${parentDir}`);
+            createdCount++;
+          }
+
+          // Проверяем существование файла
+          if (existsSync(fullPath)) {
+            console.log(`✓ Файл уже существует: ${fullPath}`);
+            skippedCount++;
+            continue;
+          }
+
+          // Создаем файл с базовым содержимым
+          const ext = extname(parsed.name);
+          let content = "";
+
+          if (ext === ".tsx" || ext === ".ts") {
+            const componentName = basename(parsed.name, ext);
+            content = `// ${parsed.name}\n// Auto-generated\n\nexport const ${componentName} = () => {\n  return (\n    <div>\n      {/* Content */}\n    </div>\n  );\n}\n`;
+          } else if (ext === ".css") {
+            content = `/* ${parsed.name} */\n/* Auto-generated */\n\n.container {\n  /* Styles */\n}\n`;
+          } else {
+            content = `// ${parsed.name}\n// Auto-generated\n`;
+          }
+
+          writeFileSync(fullPath, content);
+          console.log(`✓ Создан новый файл: ${fullPath}`);
+          createdCount++;
+        } catch (err) {
+          console.error(`✗ Ошибка создания файла ${fullPath}:`, err.message);
+        }
+      }
+    }
+
+    console.log(`\n📊 Результат:`);
+    console.log(`  ✅ Создано новых элементов: ${createdCount}`);
+    console.log(`  ⏭️  Пропущено существующих: ${skippedCount}`);
+    console.log(`\n🎉 Структура успешно создана в ${resolve(targetDir)}`);
+  } catch (error) {
+    console.error("❌ Ошибка:", error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+    parseLine,
+    createStructureFromScheme
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "create-fs-structure",
+  "version": "1.0.0",
+  "description": "CLI tool to create directory and file structure from a text scheme",
+  "main": "bin/index.js",
+  "type": "commonjs",
+  "bin": {
+    "create-structure": "./bin/cli.cjs"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "scaffolding",
+    "generator",
+    "cli",
+    "structure",
+    "filesystem"
+  ],
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-username/create-structure.git"
+  },
+  "bugs": {
+    "url": "https://github.com/your-username/create-structure/issues"
+  },
+  "homepage": "https://github.com/your-username/create-structure#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}