scaffinity 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deviprasad Rai P
+
+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,202 @@
+# ⚡ Scaffinity
+
+> Generate, export, and share project structures as portable JSON blueprints — with a single command.
+
+[![npm version](https://img.shields.io/npm/v/scaffinity.svg)](https://www.npmjs.com/package/scaffinity)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/devi5040/scaffinity/pulls)
+
+---
+
+## The Problem
+
+Every new project starts the same way — manually creating folders, files, config boilerplate. You either do it by hand each time or maintain a growing list of templates nobody on your team can find.
+
+**Scaffinity fixes this.** Define your entire project structure in a single JSON file. Generate it anywhere. Share it with anyone.
+
+---
+
+## Install
+
+```bash
+npm install -g scaffinity
+```
+
+---
+
+## Three Commands
+
+### 1. `generate` — JSON blueprint → real project
+
+```bash
+scaffinity generate blueprint.json
+scaffinity generate blueprint.json -o ./my-new-project
+scaffinity generate blueprint.json --dry --verbose   # preview first
+```
+
+### 2. `export` — existing project → JSON blueprint
+
+```bash
+scaffinity export ./my-project -o blueprint.json
+scaffinity export . --ignore dist coverage --depth 4
+```
+
+### 3. `init` — build a blueprint interactively
+
+```bash
+scaffinity init
+```
+
+---
+
+## Blueprint Format
+
+A blueprint is just a JSON file. Objects are directories, strings or `null` are files.
+
+```json
+{
+  "src": {
+    "modules": {
+      "auth": {
+        "auth.controller.ts": "",
+        "auth.service.ts": "",
+        "auth.routes.ts": ""
+      }
+    },
+    "middleware": {
+      "error.middleware.ts": ""
+    },
+    "main.ts": "import express from 'express'\n\nconst app = express()\n"
+  },
+  ".env.example": "PORT=3000\nNODE_ENV=development",
+  ".gitignore": "node_modules\ndist\n.env\n"
+}
+```
+
+Files with string values get that content written directly. `null` creates an empty file.
+
+---
+
+## Real World Example
+
+**Generate a full Express + TypeScript API structure:**
+
+```bash
+# Download the community blueprint
+curl -O https://raw.githubusercontent.com/devi5040/scaffinity/main/examples/express-ts-api.json
+
+# Generate the project
+scaffinity generate express-ts-api.json -o ./my-api
+```
+
+Output:
+
+```
+✅ Blueprint loaded
+
+  mkdir: my-api/src
+  mkdir: my-api/src/modules
+  mkdir: my-api/src/modules/auth
+  create: my-api/src/modules/auth/auth.controller.ts
+  create: my-api/src/modules/auth/auth.service.ts
+  ...
+
+📦 Scaffinity Summary
+────────────────────────────────────────
+  ✓ Created : 25 files/dirs
+────────────────────────────────────────
+
+✅ Project structure generated at: ./my-api
+```
+
+**Export your current project as a shareable blueprint:**
+
+```bash
+scaffinity export ./my-project -o team-blueprint.json
+# Share team-blueprint.json with your team — they run one command to replicate your structure
+```
+
+---
+
+## Options
+
+### `generate`
+
+| Option               | Description                                   |
+| -------------------- | --------------------------------------------- |
+| `-o, --output <dir>` | Output directory (default: current directory) |
+| `-d, --dry`          | Dry run — preview without creating files      |
+| `-v, --verbose`      | Show each file/folder being created           |
+
+### `export`
+
+| Option                       | Description                              |
+| ---------------------------- | ---------------------------------------- |
+| `-o, --output <file>`        | Save blueprint to file (default: stdout) |
+| `-i, --ignore <patterns...>` | Additional patterns to ignore            |
+| `--depth <number>`           | Maximum directory depth (default: 10)    |
+
+---
+
+## Community Blueprints
+
+Ready-made blueprints in the [`/examples`](./examples) folder:
+
+| Blueprint                                               | Description                   |
+| ------------------------------------------------------- | ----------------------------- |
+| [`express-ts-api.json`](./examples/express-ts-api.json) | Express + TypeScript REST API |
+| [`nextjs-app.json`](./examples/nextjs-app.json)         | Next.js App Router project    |
+
+**Have a blueprint to share?** Open a PR and add it to `/examples`.
+
+---
+
+## Programmatic Usage
+
+```typescript
+import { generateCommand, exportCommand } from "scaffinity";
+
+// Generate from a blueprint object directly
+await generateCommand("blueprint.json", {
+  output: "./my-project",
+  verbose: true,
+});
+
+// Export a project to blueprint
+await exportCommand("./existing-project", {
+  output: "blueprint.json",
+  ignore: ["dist", "coverage"],
+});
+```
+
+---
+
+## Why Scaffinity over Yeoman / degit / framework CLIs?
+
+|                         | Scaffinity | Yeoman | degit | Framework CLIs |
+| ----------------------- | ---------- | ------ | ----- | -------------- |
+| Language agnostic       | ✅         | ✅     | ✅    | ❌             |
+| Portable JSON format    | ✅         | ❌     | ❌    | ❌             |
+| Export existing project | ✅         | ❌     | ❌    | ❌             |
+| Zero config             | ✅         | ❌     | ✅    | ✅             |
+| File content support    | ✅         | ✅     | ✅    | ✅             |
+| Shareable blueprint     | ✅         | ❌     | ✅    | ❌             |
+
+---
+
+## Contributing
+
+PRs are welcome. To add a community blueprint, add a JSON file to `/examples` and open a PR.
+
+```bash
+git clone https://github.com/devi5040/scaffinity
+cd scaffinity
+npm install
+npm run dev -- generate examples/express-ts-api.json --dry --verbose
+```
+
+---
+
+## License
+
+MIT © [Deviprasad Rai](https://github.com/devi5040)

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_chalk4 = __toESM(require("chalk"));
+var import_commander = require("commander");
+
+// src/commands/generate.ts
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_ora = __toESM(require("ora"));
+function isFileContent(value) {
+  return typeof value === "string" || value === null || typeof value === "object" && value != null && "template" in value;
+}
+function resolveContent(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && "template" in value) {
+    const v = value;
+    return `//Generated from template: ${v.template}
+// Options: ${JSON.stringify(v.options ?? {}, null, 2)}
+`;
+  }
+  return "";
+}
+async function processNode(node, currentPath, result, options) {
+  for (const [key, value] of Object.entries(node)) {
+    const fullPath = import_path.default.join(currentPath, key);
+    if (isFileContent(value)) {
+      if (options.dry) {
+        result.created.push(fullPath);
+        if (options.verbose) {
+          console.log(
+            import_chalk.default.cyan("  [dry] create file:"),
+            import_chalk.default.white(fullPath)
+          );
+        }
+      } else {
+        try {
+          await import_fs_extra.default.ensureDir(import_path.default.dirname(fullPath));
+          if (await import_fs_extra.default.pathExists(fullPath)) {
+            result.skipped.push(fullPath);
+            if (options.verbose)
+              console.log(import_chalk.default.yellow(" skip:"), import_chalk.default.white(fullPath));
+          } else {
+            await import_fs_extra.default.writeFile(fullPath, resolveContent(value), "utf-8");
+            result.created.push(fullPath);
+            if (options.verbose)
+              console.log(import_chalk.default.green("  create:"), import_chalk.default.white(fullPath));
+          }
+        } catch (error) {
+          result.errors.push(fullPath);
+          console.log(import_chalk.default.red(" error:"), import_chalk.default.white(fullPath));
+        }
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (!options.dry) await import_fs_extra.default.ensureDir(fullPath);
+      if (options.verbose)
+        console.log(import_chalk.default.blue(" makedir:"), import_chalk.default.white(fullPath));
+      await processNode(value, fullPath, result, options);
+    }
+  }
+}
+async function generateCommand(jsonFile, options) {
+  const spinner = (0, import_ora.default)({
+    text: "Reading blueprint...",
+    stream: process.stdout
+  }).start();
+  try {
+    const absoluteJson = import_path.default.resolve(process.cwd(), jsonFile);
+    if (!await import_fs_extra.default.pathExists(absoluteJson)) {
+      spinner.fail(import_chalk.default.red(`Blueprint file not found: ${jsonFile}`));
+      process.exit(1);
+    }
+    const raw = await import_fs_extra.default.readFile(absoluteJson, "utf-8");
+    let structre;
+    try {
+      structre = JSON.parse(raw);
+    } catch {
+      spinner.fail(import_chalk.default.red("Invalid Json in blueprint file"));
+      process.exit(1);
+    }
+    const outputDir = import_path.default.resolve(process.cwd(), options.output ?? ".");
+    await import_fs_extra.default.ensureDir(outputDir);
+    spinner.succeed("Blueprint loaded");
+    if (options.dry)
+      console.log(import_chalk.default.yellow("\nDry-run - no files will be created\n"));
+    if (options.verbose) console.log(import_chalk.default.dim("\nProcessing Structure:\n"));
+    const result = { created: [], skipped: [], errors: [] };
+    await processNode(structre, outputDir, result, options);
+    console.log("\n" + import_chalk.default.bold("Scaffinity summary"));
+    console.log(import_chalk.default.dim("-".repeat(40)));
+    console.log(
+      import_chalk.default.green(`  \u2713 Created : ${result.created.length} files/dirs`)
+    );
+    if (result.skipped.length > 0)
+      console.log(
+        import_chalk.default.yellow(`  \u26A0 Skipped : ${result.skipped.length} (already exist)`)
+      );
+    if (result.errors.length > 0)
+      console.log(import_chalk.default.red(`  \u2717 Errors  : ${result.errors.length}`));
+    console.log(import_chalk.default.dim("-".repeat(40)));
+    if (!options.dry && result.created.length > 0)
+      console.log(
+        import_chalk.default.green(
+          `
+\u2705 Project structure generated at: ${import_chalk.default.bold(outputDir)}
+`
+        )
+      );
+  } catch (error) {
+    spinner.fail(import_chalk.default.red("Generation failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/export.ts
+var import_path2 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".DS_Store",
+  "Thumbs.db",
+  "*.log",
+  ".env",
+  ".env.local"
+];
+function matchesIgnore(name, ignoreList) {
+  return ignoreList.some((pattern) => {
+    if (pattern.startsWith("*")) return name.endsWith(pattern.slice(1));
+    return name === pattern;
+  });
+}
+async function buildStructure(dirPath, ignoreList, currentDepth, maxDepth) {
+  const result = {};
+  if (currentDepth > maxDepth) return result;
+  const entries = await import_fs_extra2.default.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (matchesIgnore(entry.name, ignoreList)) continue;
+    const fullPath = import_path2.default.join(dirPath, entry.name);
+    if (entry.isDirectory())
+      result[entry.name] = await buildStructure(
+        fullPath,
+        ignoreList,
+        currentDepth + 1,
+        maxDepth
+      );
+    else if (entry.isFile()) result[entry.name] = null;
+  }
+  return result;
+}
+async function exportCommand(projectPath, options) {
+  const spinner = (0, import_ora2.default)("Scanning project structure...").start();
+  try {
+    const absolutePath = import_path2.default.resolve(process.cwd(), projectPath);
+    if (!await import_fs_extra2.default.pathExists(absolutePath)) {
+      spinner.fail(import_chalk2.default.red(`Path not found: ${projectPath}`));
+      process.exit(1);
+    }
+    const stat = await import_fs_extra2.default.stat(absolutePath);
+    if (!stat.isDirectory()) {
+      spinner.fail(import_chalk2.default.red(`Path is not a directory: ${projectPath}`));
+      process.exit(1);
+    }
+    const ignoreList = [...DEFAULT_IGNORE, ...options.ignore ?? []];
+    const maxDepth = options.depth ?? 10;
+    const structure = await buildStructure(
+      absolutePath,
+      ignoreList,
+      0,
+      maxDepth
+    );
+    spinner.succeed("Structure scanned");
+    const json = JSON.stringify(structure, null, 2);
+    if (options.output) {
+      const outputPath = import_path2.default.resolve(process.cwd(), options.output);
+      await import_fs_extra2.default.writeFile(outputPath, json, "utf-8");
+      console.log(
+        import_chalk2.default.green(`
+\u2705 Blueprint exported to: ${import_chalk2.default.bold(outputPath)}
+`)
+      );
+    } else
+      console.log(json);
+    const fileCount = (json.match(/:null/g) ?? []).length;
+    const dirCount = Object.keys(structure).length;
+    if (options.output) {
+      console.log(
+        import_chalk2.default.dim(`   Directories: ${dirCount} | Files: ${fileCount}`)
+      );
+      console.log(import_chalk2.default.dim(`   Ignored: ${ignoreList.join(", ")}
+`));
+    }
+  } catch (error) {
+    spinner.fail(import_chalk2.default.red("Export failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_prompts = __toESM(require("prompts"));
+var import_path3 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+async function buildInteractive() {
+  const root = {};
+  const queue = [{ node: root, currentPath: "/", label: "root" }];
+  console.log(import_chalk3.default.bold.cyan("\n Scaffinity Interactive Builder"));
+  console.log(import_chalk3.default.dim("Build your project structure step by step.\n"));
+  console.log(
+    import_chalk3.default.dim("Commands: add file -> type name with extension (e.g. index.ts)")
+  );
+  console.log(
+    import_chalk3.default.dim("          add dir -> type name without extension (e.g. src)")
+  );
+  console.log(import_chalk3.default.dim("          done -> finish current directory\n"));
+  while (queue.length > 0) {
+    const current = queue.shift();
+    console.log(import_chalk3.default.blue(`
+ ${current?.label} (${current?.currentPath})`));
+    let continueAdding = true;
+    while (continueAdding) {
+      const { action } = await (0, import_prompts.default)({
+        type: "select",
+        name: "action",
+        message: `Add to ${import_chalk3.default.cyan(current.label)}:`,
+        choices: [
+          { title: "Add file", value: "file" },
+          { title: "Add directory", value: "dir" },
+          { title: "Done with this directory", value: "done" }
+        ]
+      });
+      if (!action || action === "done") {
+        continueAdding = false;
+        break;
+      }
+      if (action === "file") {
+        const { fileName } = await (0, import_prompts.default)({
+          type: "text",
+          name: "fileName",
+          message: "File name (e.g. index.ts, .env.example):",
+          validate: (v) => v.trim().length > 0 ? true : "File name should not be empty"
+        });
+        if (fileName) {
+          const { content } = await (0, import_prompts.default)({
+            type: "text",
+            name: "content",
+            message: "File content (leave empty for blank file):"
+          });
+          current.node[fileName.trim()] = content?.trim() ?? null;
+          console.log(import_chalk3.default.green(` Added file: ${fileName.trim()}`));
+        }
+      }
+      if (action === "dir") {
+        const { dirName } = await (0, import_prompts.default)({
+          type: "text",
+          name: "dirName",
+          message: "Directory Name",
+          validate: (v) => v.trim().length > 0 ? true : "Directory name cannot be empty"
+        });
+        if (dirName) {
+          const newNode = {};
+          current.node[dirName.trim()] = newNode;
+          console.log(import_chalk3.default.blue(`Added directory: ${dirName.trim()}`));
+          queue.push({
+            node: newNode,
+            currentPath: import_path3.default.join(current.currentPath, dirName.trim()),
+            label: dirName.trim()
+          });
+        }
+      }
+    }
+  }
+  return root;
+}
+async function initCommand() {
+  try {
+    const structure = await buildInteractive();
+    console.log(import_chalk3.default.bold("\n Your blueprint:\n"));
+    console.log(import_chalk3.default.dim(JSON.stringify(structure, null, 2)));
+    const { outputFile } = await (0, import_prompts.default)({
+      type: "text",
+      name: "outputFile",
+      message: "Save blueprint as: ",
+      initial: "scaffold.json"
+    });
+    if (outputFile) {
+      const outputPath = import_path3.default.resolve(process.cwd(), outputFile);
+      await import_fs_extra3.default.writeFile(
+        outputPath,
+        JSON.stringify(structure, null, 2),
+        "utf-8"
+      );
+      console.log(
+        import_chalk3.default.green(`
+ Blueprint saved to: ${import_chalk3.default.bold(outputPath)}`)
+      );
+      console.log(
+        import_chalk3.default.dim(
+          `
+Run: Scaffinity generate ${outputFile} to create your structure
+`
+        )
+      );
+    }
+  } catch (error) {
+    console.error(import_chalk3.default.red("Init failed"), error);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+var program = new import_commander.Command();
+console.log(
+  import_chalk4.default.bold.cyan("\n Scaffinity") + import_chalk4.default.dim(" - Project structure generator\n")
+);
+program.name("scaffinity").description(
+  "Generate, export, and share project structures as portable JSON blueprints"
+).version("1.0.0");
+program.command("generate <blueprint>").alias("g").description("Generate project structure from a JSON blueprint file").option(
+  "-o, --output <dir>",
+  "Output directory (default: current repository)"
+).option("-d, --dry", "Dry run - preview without creating files").option("-v, --verbose", "Show each file/folder being created").action(
+  async (blueprint, options) => {
+    await generateCommand(blueprint, {
+      output: options.output,
+      dry: options.dry ?? false,
+      verbose: options.verbose ?? false
+    });
+  }
+);
+program.command("export <path>").alias("e").description("Export an existing project structure to a JSON blueprint").option("-o, --output <file>", "Save blueprint to file (default: stdout)").option("-i, --ignore <patterns...>", "Additional patterns to ignore").option("--depth <number>", "Maximum directory depth (default: 10)", parseInt).action(
+  async (projectPath, options) => {
+    await exportCommand(projectPath, {
+      output: options.output,
+      ignore: options.ignore,
+      depth: options.depth
+    });
+  }
+);
+program.command("init").alias("i").description("Interactively build a JSON blueprint step by step").action(async () => {
+  await initCommand();
+});
+program.addHelpText(
+  "after",
+  `
+    ${import_chalk4.default.bold("Examples:")}
+    ${import_chalk4.default.cyan("scaffinity generate blueprint.json")}          Generate from blueprint
+    ${import_chalk4.default.cyan("scaffinity generate blueprint.json -o ./app")} Generate into specific folder
+    ${import_chalk4.default.cyan("scaffinity export ./my-project -o out.json")}  Export existing project
+    ${import_chalk4.default.cyan("scaffinity init")}                             Interactive builder
+    
+    ${import_chalk4.default.bold("Blueprint format:")}
+    ${import_chalk4.default.dim("{")}
+    ${import_chalk4.default.dim('   "src": {')}
+    ${import_chalk4.default.dim('       "index.ts":"",')}
+    ${import_chalk4.default.dim('       "utils":{')}
+    ${import_chalk4.default.dim('           "helper.ts":"// Your content here"')}
+    ${import_chalk4.default.dim("       }")}
+    ${import_chalk4.default.dim("   },")}
+    ${import_chalk4.default.dim(' "env.example":"PORT=3000\\nNODE_ENV=development"')}
+    ${import_chalk4.default.dim("}")}
+    
+    ${import_chalk4.default.dim("Github: https://github.com/devi5040/scaffinity")}`
+);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) program.outputHelp;

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+type FileContent = string | {
+    template: string;
+    options?: Record<string, unknown>;
+};
+type StructureNode = {
+    [key: string]: StructureNode | FileContent | null;
+};
+interface GenerateOptions {
+    output?: string;
+    dry?: boolean;
+    verbose?: boolean;
+}
+interface ExportOptions {
+    output?: string;
+    ignore?: string[];
+    depth?: number;
+}
+interface ScaffoldResult {
+    created: string[];
+    skipped: string[];
+    errors: string[];
+}
+
+declare function generateCommand(jsonFile: string, options: GenerateOptions): Promise<void>;
+
+declare function exportCommand(projectPath: string, options: ExportOptions): Promise<void>;
+
+declare function initCommand(): Promise<void>;
+
+export { type ExportOptions, type GenerateOptions, type ScaffoldResult, type StructureNode, exportCommand, generateCommand, initCommand };

package/dist/index.js

@@ -0,0 +1,358 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  exportCommand: () => exportCommand,
+  generateCommand: () => generateCommand,
+  initCommand: () => initCommand
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands/generate.ts
+var import_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_ora = __toESM(require("ora"));
+function isFileContent(value) {
+  return typeof value === "string" || value === null || typeof value === "object" && value != null && "template" in value;
+}
+function resolveContent(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && "template" in value) {
+    const v = value;
+    return `//Generated from template: ${v.template}
+// Options: ${JSON.stringify(v.options ?? {}, null, 2)}
+`;
+  }
+  return "";
+}
+async function processNode(node, currentPath, result, options) {
+  for (const [key, value] of Object.entries(node)) {
+    const fullPath = import_path.default.join(currentPath, key);
+    if (isFileContent(value)) {
+      if (options.dry) {
+        result.created.push(fullPath);
+        if (options.verbose) {
+          console.log(
+            import_chalk.default.cyan("  [dry] create file:"),
+            import_chalk.default.white(fullPath)
+          );
+        }
+      } else {
+        try {
+          await import_fs_extra.default.ensureDir(import_path.default.dirname(fullPath));
+          if (await import_fs_extra.default.pathExists(fullPath)) {
+            result.skipped.push(fullPath);
+            if (options.verbose)
+              console.log(import_chalk.default.yellow(" skip:"), import_chalk.default.white(fullPath));
+          } else {
+            await import_fs_extra.default.writeFile(fullPath, resolveContent(value), "utf-8");
+            result.created.push(fullPath);
+            if (options.verbose)
+              console.log(import_chalk.default.green("  create:"), import_chalk.default.white(fullPath));
+          }
+        } catch (error) {
+          result.errors.push(fullPath);
+          console.log(import_chalk.default.red(" error:"), import_chalk.default.white(fullPath));
+        }
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (!options.dry) await import_fs_extra.default.ensureDir(fullPath);
+      if (options.verbose)
+        console.log(import_chalk.default.blue(" makedir:"), import_chalk.default.white(fullPath));
+      await processNode(value, fullPath, result, options);
+    }
+  }
+}
+async function generateCommand(jsonFile, options) {
+  const spinner = (0, import_ora.default)({
+    text: "Reading blueprint...",
+    stream: process.stdout
+  }).start();
+  try {
+    const absoluteJson = import_path.default.resolve(process.cwd(), jsonFile);
+    if (!await import_fs_extra.default.pathExists(absoluteJson)) {
+      spinner.fail(import_chalk.default.red(`Blueprint file not found: ${jsonFile}`));
+      process.exit(1);
+    }
+    const raw = await import_fs_extra.default.readFile(absoluteJson, "utf-8");
+    let structre;
+    try {
+      structre = JSON.parse(raw);
+    } catch {
+      spinner.fail(import_chalk.default.red("Invalid Json in blueprint file"));
+      process.exit(1);
+    }
+    const outputDir = import_path.default.resolve(process.cwd(), options.output ?? ".");
+    await import_fs_extra.default.ensureDir(outputDir);
+    spinner.succeed("Blueprint loaded");
+    if (options.dry)
+      console.log(import_chalk.default.yellow("\nDry-run - no files will be created\n"));
+    if (options.verbose) console.log(import_chalk.default.dim("\nProcessing Structure:\n"));
+    const result = { created: [], skipped: [], errors: [] };
+    await processNode(structre, outputDir, result, options);
+    console.log("\n" + import_chalk.default.bold("Scaffinity summary"));
+    console.log(import_chalk.default.dim("-".repeat(40)));
+    console.log(
+      import_chalk.default.green(`  \u2713 Created : ${result.created.length} files/dirs`)
+    );
+    if (result.skipped.length > 0)
+      console.log(
+        import_chalk.default.yellow(`  \u26A0 Skipped : ${result.skipped.length} (already exist)`)
+      );
+    if (result.errors.length > 0)
+      console.log(import_chalk.default.red(`  \u2717 Errors  : ${result.errors.length}`));
+    console.log(import_chalk.default.dim("-".repeat(40)));
+    if (!options.dry && result.created.length > 0)
+      console.log(
+        import_chalk.default.green(
+          `
+\u2705 Project structure generated at: ${import_chalk.default.bold(outputDir)}
+`
+        )
+      );
+  } catch (error) {
+    spinner.fail(import_chalk.default.red("Generation failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/export.ts
+var import_path2 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+var import_chalk2 = __toESM(require("chalk"));
+var import_ora2 = __toESM(require("ora"));
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".DS_Store",
+  "Thumbs.db",
+  "*.log",
+  ".env",
+  ".env.local"
+];
+function matchesIgnore(name, ignoreList) {
+  return ignoreList.some((pattern) => {
+    if (pattern.startsWith("*")) return name.endsWith(pattern.slice(1));
+    return name === pattern;
+  });
+}
+async function buildStructure(dirPath, ignoreList, currentDepth, maxDepth) {
+  const result = {};
+  if (currentDepth > maxDepth) return result;
+  const entries = await import_fs_extra2.default.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (matchesIgnore(entry.name, ignoreList)) continue;
+    const fullPath = import_path2.default.join(dirPath, entry.name);
+    if (entry.isDirectory())
+      result[entry.name] = await buildStructure(
+        fullPath,
+        ignoreList,
+        currentDepth + 1,
+        maxDepth
+      );
+    else if (entry.isFile()) result[entry.name] = null;
+  }
+  return result;
+}
+async function exportCommand(projectPath, options) {
+  const spinner = (0, import_ora2.default)("Scanning project structure...").start();
+  try {
+    const absolutePath = import_path2.default.resolve(process.cwd(), projectPath);
+    if (!await import_fs_extra2.default.pathExists(absolutePath)) {
+      spinner.fail(import_chalk2.default.red(`Path not found: ${projectPath}`));
+      process.exit(1);
+    }
+    const stat = await import_fs_extra2.default.stat(absolutePath);
+    if (!stat.isDirectory()) {
+      spinner.fail(import_chalk2.default.red(`Path is not a directory: ${projectPath}`));
+      process.exit(1);
+    }
+    const ignoreList = [...DEFAULT_IGNORE, ...options.ignore ?? []];
+    const maxDepth = options.depth ?? 10;
+    const structure = await buildStructure(
+      absolutePath,
+      ignoreList,
+      0,
+      maxDepth
+    );
+    spinner.succeed("Structure scanned");
+    const json = JSON.stringify(structure, null, 2);
+    if (options.output) {
+      const outputPath = import_path2.default.resolve(process.cwd(), options.output);
+      await import_fs_extra2.default.writeFile(outputPath, json, "utf-8");
+      console.log(
+        import_chalk2.default.green(`
+\u2705 Blueprint exported to: ${import_chalk2.default.bold(outputPath)}
+`)
+      );
+    } else
+      console.log(json);
+    const fileCount = (json.match(/:null/g) ?? []).length;
+    const dirCount = Object.keys(structure).length;
+    if (options.output) {
+      console.log(
+        import_chalk2.default.dim(`   Directories: ${dirCount} | Files: ${fileCount}`)
+      );
+      console.log(import_chalk2.default.dim(`   Ignored: ${ignoreList.join(", ")}
+`));
+    }
+  } catch (error) {
+    spinner.fail(import_chalk2.default.red("Export failed"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/commands/init.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_prompts = __toESM(require("prompts"));
+var import_path3 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+async function buildInteractive() {
+  const root = {};
+  const queue = [{ node: root, currentPath: "/", label: "root" }];
+  console.log(import_chalk3.default.bold.cyan("\n Scaffinity Interactive Builder"));
+  console.log(import_chalk3.default.dim("Build your project structure step by step.\n"));
+  console.log(
+    import_chalk3.default.dim("Commands: add file -> type name with extension (e.g. index.ts)")
+  );
+  console.log(
+    import_chalk3.default.dim("          add dir -> type name without extension (e.g. src)")
+  );
+  console.log(import_chalk3.default.dim("          done -> finish current directory\n"));
+  while (queue.length > 0) {
+    const current = queue.shift();
+    console.log(import_chalk3.default.blue(`
+ ${current?.label} (${current?.currentPath})`));
+    let continueAdding = true;
+    while (continueAdding) {
+      const { action } = await (0, import_prompts.default)({
+        type: "select",
+        name: "action",
+        message: `Add to ${import_chalk3.default.cyan(current.label)}:`,
+        choices: [
+          { title: "Add file", value: "file" },
+          { title: "Add directory", value: "dir" },
+          { title: "Done with this directory", value: "done" }
+        ]
+      });
+      if (!action || action === "done") {
+        continueAdding = false;
+        break;
+      }
+      if (action === "file") {
+        const { fileName } = await (0, import_prompts.default)({
+          type: "text",
+          name: "fileName",
+          message: "File name (e.g. index.ts, .env.example):",
+          validate: (v) => v.trim().length > 0 ? true : "File name should not be empty"
+        });
+        if (fileName) {
+          const { content } = await (0, import_prompts.default)({
+            type: "text",
+            name: "content",
+            message: "File content (leave empty for blank file):"
+          });
+          current.node[fileName.trim()] = content?.trim() ?? null;
+          console.log(import_chalk3.default.green(` Added file: ${fileName.trim()}`));
+        }
+      }
+      if (action === "dir") {
+        const { dirName } = await (0, import_prompts.default)({
+          type: "text",
+          name: "dirName",
+          message: "Directory Name",
+          validate: (v) => v.trim().length > 0 ? true : "Directory name cannot be empty"
+        });
+        if (dirName) {
+          const newNode = {};
+          current.node[dirName.trim()] = newNode;
+          console.log(import_chalk3.default.blue(`Added directory: ${dirName.trim()}`));
+          queue.push({
+            node: newNode,
+            currentPath: import_path3.default.join(current.currentPath, dirName.trim()),
+            label: dirName.trim()
+          });
+        }
+      }
+    }
+  }
+  return root;
+}
+async function initCommand() {
+  try {
+    const structure = await buildInteractive();
+    console.log(import_chalk3.default.bold("\n Your blueprint:\n"));
+    console.log(import_chalk3.default.dim(JSON.stringify(structure, null, 2)));
+    const { outputFile } = await (0, import_prompts.default)({
+      type: "text",
+      name: "outputFile",
+      message: "Save blueprint as: ",
+      initial: "scaffold.json"
+    });
+    if (outputFile) {
+      const outputPath = import_path3.default.resolve(process.cwd(), outputFile);
+      await import_fs_extra3.default.writeFile(
+        outputPath,
+        JSON.stringify(structure, null, 2),
+        "utf-8"
+      );
+      console.log(
+        import_chalk3.default.green(`
+ Blueprint saved to: ${import_chalk3.default.bold(outputPath)}`)
+      );
+      console.log(
+        import_chalk3.default.dim(
+          `
+Run: Scaffinity generate ${outputFile} to create your structure
+`
+        )
+      );
+    }
+  } catch (error) {
+    console.error(import_chalk3.default.red("Init failed"), error);
+    process.exit(1);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportCommand,
+  generateCommand,
+  initCommand
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "scaffinity",
+  "version": "1.0.1",
+  "description": "Generate, export, and share project structures as portable JSON blueprints",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "scaffinity": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup src/cli.ts src/index.ts --format cjs --dts",
+    "dev": "ts-node src/cli.ts",
+    "start": "node dist/cli.js"
+  },
+  "keywords": [
+    "scaffinity",
+    "cli",
+    "boilerplate",
+    "project-structure",
+    "generator",
+    "typescript",
+    "blueprint"
+  ],
+  "author": "Deviprasad Rai <dpraidola@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "fs-extra": "^11.3.5",
+    "ora": "^9.4.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/prompts": "^2.4.9",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}