scaffoldrite 1.0.0

package/dist/ast.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const validator_js_1 = require("./validator.js");
+const parser_js_1 = require("./parser.js");
+const generator_js_1 = require("./generator.js");
+const structure_js_1 = require("./structure.js");
+const validateFS_js_1 = require("./validateFS.js");
+const fsToAst_js_1 = require("./fsToAst.js");
+const index_js_1 = require("./data/index.js");
+const structurePath = "./structure.sr";
+function hasFlag(flag) {
+    return process.argv.includes(flag);
+}
+function getFlagValue(flagPrefix) {
+    return process.argv
+        .filter((arg) => arg.startsWith(flagPrefix))
+        .map((arg) => arg.split("=")[1])
+        .filter(Boolean);
+}
+function parseCSVFlag(flagName) {
+    return getFlagValue(flagName)
+        .flatMap((v) => v.split(","))
+        .map((v) => v.trim())
+        .filter(Boolean);
+}
+function getPassedFlags() {
+    return process.argv.filter((arg) => arg.startsWith("--"));
+}
+/* ===================== HELPERS ===================== */
+function confirmProceed(dir) {
+    // Skip prompt if user asked for it
+    if (hasFlag("--yes") || hasFlag("-y"))
+        return Promise.resolve(true);
+    if (!fs_1.default.existsSync(dir))
+        return Promise.resolve(true);
+    if (fs_1.default.readdirSync(dir).length === 0)
+        return Promise.resolve(true);
+    console.warn("Output directory is not empty:", dir);
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question("Proceed and apply changes? (y/N): ", (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        });
+    });
+}
+/* ===================== STRUCTURE IO ===================== */
+function saveStructure(root, rawConstraints, filePath) {
+    const lines = [];
+    function writeFolder(folder, indent = "") {
+        lines.push(`${indent}folder ${folder.name} {`);
+        for (const child of folder.children) {
+            if (child.type === "folder")
+                writeFolder(child, indent + "  ");
+            else
+                lines.push(`${indent}  file ${child.name}`);
+        }
+        lines.push(`${indent}}`);
+    }
+    for (const child of root.children) {
+        if (child.type === "folder")
+            writeFolder(child);
+        else
+            lines.push(`file ${child.name}`);
+    }
+    if (rawConstraints.length > 0) {
+        lines.push("");
+        lines.push("constraints {");
+        for (const c of rawConstraints) {
+            lines.push(`  ${c}`);
+        }
+        lines.push("}");
+    }
+    fs_1.default.writeFileSync(filePath, lines.join("\n"));
+}
+function loadAST() {
+    const content = fs_1.default.readFileSync(structurePath, "utf-8");
+    return (0, parser_js_1.parseStructure)(content);
+}
+function printTree(root, indent = "") {
+    for (const child of root.children) {
+        if (child.type === "folder") {
+            console.log(`${indent} ${child.name}`);
+            printTree(child, indent + "  ");
+        }
+        else {
+            console.log(`${indent} ${child.name}`);
+        }
+    }
+}
+/* ===================== CLI ===================== */
+const ALLOWED_FLAGS = {
+    init: ["--force", "--empty", "--from-fs"],
+    validate: ["--allow-extra"],
+    generate: ["--yes"],
+    create: ["--force", "--if-not-exists", "--yes"],
+    delete: ["--yes"],
+    rename: ["--yes"],
+    list: [],
+};
+const command = process.argv[2];
+const passedFlags = getPassedFlags();
+const allowedFlags = ALLOWED_FLAGS[command];
+if (!allowedFlags) {
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+}
+const invalidFlags = passedFlags.filter((flag) => !allowedFlags.includes(flag));
+if (invalidFlags.length > 0) {
+    console.error(`Unknown flag(s) for '${command}': ${invalidFlags.join(", ")}\n` +
+        `Run 'scaffoldrite ${command} --help' to see available options.`);
+    process.exit(1);
+}
+if (!command) {
+    console.log(`
+Usage:
+  scaffoldrite init [--force] [--empty] [--from-fs <dir>]
+  scaffoldrite validate [dir] [--allow-extra] [--allow-extra <path1> <path2> ...]
+  scaffoldrite generate [dir] [--yes]
+  scaffoldrite list
+  scaffoldrite create <path> <file|folder> [dir] [--force] [--if-not-exists]
+  scaffoldrite delete <path> [dir] [--yes]
+  scaffoldrite rename <path> <newName> [dir] [--yes]
+`);
+    process.exit(1);
+}
+function getFlagValuesAfter(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return [];
+    const values = [];
+    for (let i = index + 1; i < process.argv.length; i++) {
+        const arg = process.argv[i];
+        if (arg.startsWith("--"))
+            break;
+        values.push(arg);
+    }
+    return values;
+}
+const force = hasFlag("--force");
+const ifNotExists = hasFlag("--if-not-exists");
+const allowExtraPaths = getFlagValuesAfter("--allow-extra");
+const allowExtra = hasFlag("--allow-extra");
+const args = process.argv.slice(3).filter((a) => !a.startsWith("--"));
+const arg3 = args[0];
+const arg4 = args[1];
+const arg5 = args[2];
+(async () => {
+    /* ===== INIT ===== */
+    if (command === "init") {
+        const empty = hasFlag("--empty");
+        const fromFs = hasFlag("--from-fs");
+        const ignorePath = "./.scaffoldignore";
+        // Prevent overwriting structure.sr unless --force
+        if (fs_1.default.existsSync(structurePath) && !force) {
+            console.error("structure.sr already exists. Use --force to overwrite.");
+            process.exit(1);
+        }
+        // Prevent overwriting scaffoldignore ALWAYS
+        if (fs_1.default.existsSync(ignorePath)) {
+            console.log(".scaffoldignore already exists. It will not be overwritten.");
+        }
+        // 1 Empty init
+        if (empty) {
+            fs_1.default.writeFileSync(structurePath, "constraints {\n}\n");
+            if (!fs_1.default.existsSync(ignorePath)) {
+                fs_1.default.writeFileSync(ignorePath, index_js_1.DEFAULT_IGNORE_TEMPLATE);
+            }
+            console.log("Empty structure.sr created");
+            return;
+        }
+        // 2 Init from filesystem
+        if (fromFs) {
+            const targetDir = path_1.default.resolve(args[0] ?? process.cwd());
+            const ignoreList = (0, fsToAst_js_1.getIgnoreList)();
+            const ast = (0, fsToAst_js_1.buildASTFromFS)(targetDir, ignoreList);
+            saveStructure(ast, [], structurePath);
+            if (!fs_1.default.existsSync(ignorePath)) {
+                fs_1.default.writeFileSync(ignorePath, index_js_1.DEFAULT_IGNORE_TEMPLATE);
+            }
+            console.log(`structure.sr generated from filesystem: ${targetDir}`);
+            return;
+        }
+        // Default init
+        fs_1.default.writeFileSync(structurePath, index_js_1.DEFAULT_TEMPLATE);
+        if (!fs_1.default.existsSync(ignorePath)) {
+            fs_1.default.writeFileSync(ignorePath, index_js_1.DEFAULT_IGNORE_TEMPLATE);
+        }
+        console.log("structure.sr created");
+        return;
+    }
+    /* ===== LIST ===== */
+    if (command === "list") {
+        const structure = loadAST();
+        console.log("Current structure:");
+        printTree(structure.root);
+        return;
+    }
+    /* ===== VALIDATE ===== */
+    if (command === "validate") {
+        const structure = loadAST();
+        // Parse allow-extra here only
+        const allowExtraPaths = getFlagValuesAfter("--allow-extra");
+        const allowExtra = hasFlag("--allow-extra") && allowExtraPaths.length === 0;
+        // Find real output dir
+        const outputDirArg = args.find((a) => {
+            if (a.startsWith("--"))
+                return false;
+            if (allowExtraPaths.includes(a))
+                return false;
+            return true;
+        });
+        const outputDir = path_1.default.resolve(outputDirArg ?? process.cwd());
+        try {
+            (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+            (0, validateFS_js_1.validateFS)(structure.root, outputDir, allowExtra, allowExtraPaths);
+            console.log("All constraints and filesystem structure are valid");
+        }
+        catch (err) {
+            console.error("Validation failed:", err.message);
+        }
+        return;
+    }
+    /* ===== GENERATE ===== */
+    if (command === "generate") {
+        const structure = loadAST();
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        const outputDir = path_1.default.resolve(arg3 ?? process.cwd());
+        if (!(await confirmProceed(outputDir))) {
+            console.log("Generation cancelled.");
+            return;
+        }
+        (0, generator_js_1.generateFS)(structure.root, outputDir);
+        console.log("Generated filesystem at:", outputDir);
+        return;
+    }
+    /* ===== CREATE ===== */
+    if (command === "create") {
+        if (!arg3 || !arg4) {
+            console.error("Usage: scaffoldrite create <path> <file|folder> [outputDir] [--force] [--if-not-exists] [--yes]");
+            process.exit(1);
+        }
+        const structure = loadAST();
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        (0, structure_js_1.addNode)(structure.root, arg3, arg4, {
+            force,
+            ifNotExists,
+        });
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        const outputDir = path_1.default.resolve(arg5 ?? process.cwd());
+        if (!(await confirmProceed(outputDir))) {
+            console.log("Creation cancelled.");
+            return;
+        }
+        saveStructure(structure.root, structure.rawConstraints, structurePath);
+        (0, generator_js_1.generateFS)(structure.root, outputDir);
+        console.log("Created successfully.");
+        return;
+    }
+    /* ===== DELETE ===== */
+    if (command === "delete") {
+        if (!arg3) {
+            console.error("Usage: scaffoldrite delete <path> [outputDir] [--yes]");
+            process.exit(1);
+        }
+        const structure = loadAST();
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        (0, structure_js_1.deleteNode)(structure.root, arg3);
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        const outputDir = path_1.default.resolve(arg4 ?? process.cwd());
+        if (!(await confirmProceed(outputDir))) {
+            console.log("Deletion cancelled.");
+            return;
+        }
+        saveStructure(structure.root, structure.rawConstraints, structurePath);
+        (0, generator_js_1.generateFS)(structure.root, outputDir);
+        console.log("Deleted successfully.");
+        return;
+    }
+    /* ===== RENAME ===== */
+    if (command === "rename") {
+        if (!arg3 || !arg4) {
+            console.error("Usage: scaffoldrite rename <path> <newName> [outputDir] [--yes]");
+            process.exit(1);
+        }
+        const structure = loadAST();
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        (0, structure_js_1.renameNode)(structure.root, arg3, arg4);
+        (0, validator_js_1.validateConstraints)(structure.root, structure.constraints);
+        const outputDir = path_1.default.resolve(arg5 ?? process.cwd());
+        if (!(await confirmProceed(outputDir))) {
+            console.log("Rename cancelled.");
+            return;
+        }
+        saveStructure(structure.root, structure.rawConstraints, structurePath);
+        (0, generator_js_1.generateFS)(structure.root, outputDir);
+        console.log("Renamed successfully.");
+        return;
+    }
+    console.error(`Unknown command: ${command}`);
+})();

package/dist/constraints.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConstraints = parseConstraints;
+function splitArgs(line) {
+    const args = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"' || ch === "'") {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (ch === " " && !inQuotes) {
+            if (current.length > 0) {
+                args.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current.length > 0)
+        args.push(current);
+    return args;
+}
+function parseConstraints(input) {
+    const lines = input.split("\n");
+    const constraints = [];
+    for (let line of lines) {
+        line = line.trim();
+        if (!line)
+            continue;
+        if (line.startsWith("require ")) {
+            const path = line.replace("require ", "").trim();
+            constraints.push({ type: "require", path });
+            continue;
+        }
+        if (line.startsWith("forbid ")) {
+            const path = line.replace("forbid ", "").trim();
+            constraints.push({ type: "forbid", path });
+            continue;
+        }
+        if (line.startsWith("maxFilesByExtRecursive ")) {
+            const parts = splitArgs(line);
+            const ext = parts[1];
+            const value = Number(parts[2]);
+            const path = parts[3];
+            constraints.push({ type: "maxFilesByExtRecursive", path, value, ext });
+            continue;
+        }
+        if (line.startsWith("maxFilesRecursive ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "maxFilesRecursive", path, value });
+            continue;
+        }
+        if (line.startsWith("maxFilesByExt ")) {
+            const parts = splitArgs(line);
+            const ext = parts[1];
+            const value = Number(parts[2]);
+            const path = parts[3];
+            constraints.push({ type: "maxFilesByExt", path, value, ext });
+            continue;
+        }
+        if (line.startsWith("maxFiles ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "maxFiles", path, value });
+            continue;
+        }
+        if (line.startsWith("maxFoldersRecursive ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "maxFoldersRecursive", path, value });
+            continue;
+        }
+        if (line.startsWith("maxFolders ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "maxFolders", path, value });
+            continue;
+        }
+        if (line.startsWith("minFiles ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "minFiles", path, value });
+            continue;
+        }
+        if (line.startsWith("minFolders ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "minFolders", path, value });
+            continue;
+        }
+        // NEW RULES PARSING (WITH SCOPE)
+        if (line.startsWith("eachFolderMustContain ")) {
+            const parts = splitArgs(line);
+            const scope = parts[1];
+            // if only 3 parts, then path is root
+            const hasPath = parts.length === 4;
+            const path = hasPath ? parts[2] : "";
+            const value = hasPath ? parts[3] : parts[2];
+            constraints.push({ type: "eachFolderMustContain", path, value, scope });
+            console.log({ type: "eachFolderMustContain", path, value, scope });
+            continue;
+        }
+        if (line.startsWith("eachFolderMustContainFile ")) {
+            const parts = splitArgs(line);
+            const scope = parts[1];
+            const hasPath = parts.length === 4;
+            const path = hasPath ? parts[2] : "";
+            const value = hasPath ? parts[3] : parts[2];
+            constraints.push({ type: "eachFolderMustContainFile", path, value, scope });
+            continue;
+        }
+        if (line.startsWith("eachFolderMustContainFolder ")) {
+            const parts = splitArgs(line);
+            const scope = parts[1];
+            const hasPath = parts.length === 4;
+            const path = hasPath ? parts[2] : "";
+            const value = hasPath ? parts[3] : parts[2];
+            constraints.push({ type: "eachFolderMustContainFolder", path, value, scope });
+            continue;
+        }
+        if (line.startsWith("eachFolderMustHaveExt ")) {
+            const parts = splitArgs(line);
+            const scope = parts[1];
+            const hasPath = parts.length === 4;
+            const path = hasPath ? parts[2] : "";
+            const ext = hasPath ? parts[3] : parts[2];
+            constraints.push({ type: "eachFolderMustHaveExt", path, ext, scope });
+            continue;
+        }
+        // EXISTING RULES
+        if (line.startsWith("mustContain ")) {
+            const parts = splitArgs(line);
+            const path = parts[1];
+            const value = parts[2];
+            constraints.push({ type: "mustContain", path, value });
+            continue;
+        }
+        if (line.startsWith("fileNameRegex ")) {
+            const parts = splitArgs(line);
+            const path = parts[1];
+            const regex = parts[2];
+            constraints.push({ type: "fileNameRegex", path, regex });
+            continue;
+        }
+        if (line.startsWith("maxDepth ")) {
+            const parts = splitArgs(line);
+            const value = Number(parts[1]);
+            const path = parts[2];
+            constraints.push({ type: "maxDepth", path, value });
+            continue;
+        }
+        if (line.startsWith("mustHaveFile ")) {
+            const parts = splitArgs(line);
+            const path = parts[1];
+            const value = parts[2];
+            constraints.push({ type: "mustHaveFile", path, value });
+            continue;
+        }
+        throw new Error(`Unknown constraint: ${line}`);
+    }
+    return constraints;
+}

package/dist/data/flags.js

@@ -0,0 +1,7 @@
+"use strict";
+function parseCSVFlag(flagName) {
+    return getFlagValue(flagName)
+        .flatMap((v) => v.split(","))
+        .map((v) => v.trim())
+        .filter(Boolean);
+}

package/dist/data/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IGNORE_TEMPLATE = exports.DEFAULT_TEMPLATE = void 0;
+exports.DEFAULT_TEMPLATE = `folder src {
+  file index.ts
+}
+
+constraints {
+}
+`;
+exports.DEFAULT_IGNORE_TEMPLATE = `node_modules
+.git
+.next
+dist
+build
+coverage
+.turbo
+`;

package/dist/fsToAst.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IGNORES = void 0;
+exports.loadIgnoreList = loadIgnoreList;
+exports.getIgnoreList = getIgnoreList;
+exports.buildASTFromFS = buildASTFromFS;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ignoreFilePath = "./.scaffoldignore";
+exports.DEFAULT_IGNORES = [
+    "node_modules",
+    ".git",
+    ".next",
+    "dist",
+    "build",
+    "coverage",
+    ".turbo",
+];
+function loadIgnoreList(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return [];
+    const content = fs_1.default.readFileSync(filePath, "utf-8");
+    return content
+        .split("\n")
+        .map((x) => x.trim())
+        .map((x) => x.split("#")[0].trim())
+        .filter(Boolean);
+}
+function getIgnoreList() {
+    return fs_1.default.existsSync(ignoreFilePath)
+        ? loadIgnoreList(ignoreFilePath)
+        : exports.DEFAULT_IGNORES;
+}
+function buildASTFromFS(dir, ignoreList = []) {
+    if (!fs_1.default.existsSync(dir)) {
+        throw new Error(`Directory does not exist: ${dir}`);
+    }
+    const root = {
+        type: "folder",
+        name: path_1.default.basename(dir),
+        children: [],
+    };
+    function scan(folderPath, node) {
+        const items = fs_1.default.readdirSync(folderPath);
+        for (const item of items) {
+            if (ignoreList.includes(item))
+                continue;
+            const itemPath = path_1.default.join(folderPath, item);
+            const stat = fs_1.default.statSync(itemPath);
+            if (stat.isDirectory()) {
+                const childFolder = {
+                    type: "folder",
+                    name: item,
+                    children: [],
+                };
+                node.children.push(childFolder);
+                scan(itemPath, childFolder);
+            }
+            else {
+                const childFile = {
+                    type: "file",
+                    name: item,
+                };
+                node.children.push(childFile);
+            }
+        }
+    }
+    scan(dir, root);
+    return root;
+}

package/dist/generator.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFS = generateFS;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const visitor_js_1 = require("./visitor.js");
+function generateFS(ast, outputDir) {
+    const root = path_1.default.resolve(outputDir);
+    const expected = new Set();
+    function ensureFolder(folderPath) {
+        if (!fs_1.default.existsSync(folderPath)) {
+            fs_1.default.mkdirSync(folderPath, { recursive: true });
+        }
+    }
+    function ensureFile(filePath) {
+        if (!fs_1.default.existsSync(filePath)) {
+            fs_1.default.writeFileSync(filePath, "");
+        }
+    }
+    ensureFolder(root);
+    expected.add(root);
+    (0, visitor_js_1.visit)(ast, {
+        folder: (_, nodePath) => {
+            const fullPath = path_1.default.join(root, nodePath);
+            expected.add(fullPath);
+            ensureFolder(fullPath);
+        },
+        file: (_, nodePath) => {
+            const fullPath = path_1.default.join(root, nodePath);
+            expected.add(fullPath);
+            ensureFile(fullPath);
+        },
+    });
+    // 2️⃣ Remove extras (never root)
+    function clean(dir) {
+        for (const entry of fs_1.default.readdirSync(dir)) {
+            const fullPath = path_1.default.join(dir, entry);
+            if (!expected.has(fullPath)) {
+                fs_1.default.rmSync(fullPath, { recursive: true, force: true });
+                continue;
+            }
+            if (fs_1.default.statSync(fullPath).isDirectory()) {
+                clean(fullPath);
+            }
+        }
+    }
+    clean(root);
+}