@atlashub/smartstack-cli 1.4.1 → 1.5.0

package/dist/index.js

@@ -966,7 +966,7 @@ var require_command = __commonJS({
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
     var path3 = require("path");
-    var fs4 = require("fs");
+    var fs5 = require("fs");
     var process11 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1899,10 +1899,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path3.resolve(baseDir, baseName);
-          if (fs4.existsSync(localBin)) return localBin;
+          if (fs5.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path3.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs4.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1914,7 +1914,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs4.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -4726,54 +4726,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs4) {
+    function patch(fs5) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs4);
-      }
-      if (!fs4.lutimes) {
-        patchLutimes(fs4);
-      }
-      fs4.chown = chownFix(fs4.chown);
-      fs4.fchown = chownFix(fs4.fchown);
-      fs4.lchown = chownFix(fs4.lchown);
-      fs4.chmod = chmodFix(fs4.chmod);
-      fs4.fchmod = chmodFix(fs4.fchmod);
-      fs4.lchmod = chmodFix(fs4.lchmod);
-      fs4.chownSync = chownFixSync(fs4.chownSync);
-      fs4.fchownSync = chownFixSync(fs4.fchownSync);
-      fs4.lchownSync = chownFixSync(fs4.lchownSync);
-      fs4.chmodSync = chmodFixSync(fs4.chmodSync);
-      fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
-      fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
-      fs4.stat = statFix(fs4.stat);
-      fs4.fstat = statFix(fs4.fstat);
-      fs4.lstat = statFix(fs4.lstat);
-      fs4.statSync = statFixSync(fs4.statSync);
-      fs4.fstatSync = statFixSync(fs4.fstatSync);
-      fs4.lstatSync = statFixSync(fs4.lstatSync);
-      if (fs4.chmod && !fs4.lchmod) {
-        fs4.lchmod = function(path3, mode, cb) {
+        patchLchmod(fs5);
+      }
+      if (!fs5.lutimes) {
+        patchLutimes(fs5);
+      }
+      fs5.chown = chownFix(fs5.chown);
+      fs5.fchown = chownFix(fs5.fchown);
+      fs5.lchown = chownFix(fs5.lchown);
+      fs5.chmod = chmodFix(fs5.chmod);
+      fs5.fchmod = chmodFix(fs5.fchmod);
+      fs5.lchmod = chmodFix(fs5.lchmod);
+      fs5.chownSync = chownFixSync(fs5.chownSync);
+      fs5.fchownSync = chownFixSync(fs5.fchownSync);
+      fs5.lchownSync = chownFixSync(fs5.lchownSync);
+      fs5.chmodSync = chmodFixSync(fs5.chmodSync);
+      fs5.fchmodSync = chmodFixSync(fs5.fchmodSync);
+      fs5.lchmodSync = chmodFixSync(fs5.lchmodSync);
+      fs5.stat = statFix(fs5.stat);
+      fs5.fstat = statFix(fs5.fstat);
+      fs5.lstat = statFix(fs5.lstat);
+      fs5.statSync = statFixSync(fs5.statSync);
+      fs5.fstatSync = statFixSync(fs5.fstatSync);
+      fs5.lstatSync = statFixSync(fs5.lstatSync);
+      if (fs5.chmod && !fs5.lchmod) {
+        fs5.lchmod = function(path3, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs4.lchmodSync = function() {
+        fs5.lchmodSync = function() {
         };
       }
-      if (fs4.chown && !fs4.lchown) {
-        fs4.lchown = function(path3, uid, gid, cb) {
+      if (fs5.chown && !fs5.lchown) {
+        fs5.lchown = function(path3, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs4.lchownSync = function() {
+        fs5.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : (function(fs$rename) {
+        fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
           function rename(from3, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from3, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs4.stat(to, function(stater, st) {
+                  fs5.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from3, to, CB);
                     else
@@ -4789,9 +4789,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs4.rename);
+        })(fs5.rename);
       }
-      fs4.read = typeof fs4.read !== "function" ? fs4.read : (function(fs$read) {
+      fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -4799,22 +4799,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs4.read);
-      fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs5.read);
+      fs5.readSync = typeof fs5.readSync !== "function" ? fs5.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs4, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs5, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -4824,10 +4824,10 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs4.readSync);
-      function patchLchmod(fs5) {
-        fs5.lchmod = function(path3, mode, callback) {
-          fs5.open(
+      })(fs5.readSync);
+      function patchLchmod(fs6) {
+        fs6.lchmod = function(path3, mode, callback) {
+          fs6.open(
             path3,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
@@ -4836,80 +4836,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs5.fchmod(fd, mode, function(err2) {
-                fs5.close(fd, function(err22) {
+              fs6.fchmod(fd, mode, function(err2) {
+                fs6.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs5.lchmodSync = function(path3, mode) {
-          var fd = fs5.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs6.lchmodSync = function(path3, mode) {
+          var fd = fs6.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs5.fchmodSync(fd, mode);
+            ret = fs6.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs5.closeSync(fd);
+                fs6.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs5.closeSync(fd);
+              fs6.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs5) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
-          fs5.lutimes = function(path3, at, mt, cb) {
-            fs5.open(path3, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs6) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+          fs6.lutimes = function(path3, at, mt, cb) {
+            fs6.open(path3, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs5.futimes(fd, at, mt, function(er2) {
-                fs5.close(fd, function(er22) {
+              fs6.futimes(fd, at, mt, function(er2) {
+                fs6.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs5.lutimesSync = function(path3, at, mt) {
-            var fd = fs5.openSync(path3, constants.O_SYMLINK);
+          fs6.lutimesSync = function(path3, at, mt) {
+            var fd = fs6.openSync(path3, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs5.futimesSync(fd, at, mt);
+              ret = fs6.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs5.closeSync(fd);
+                  fs6.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs5.closeSync(fd);
+                fs6.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs5.futimes) {
-          fs5.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs6.futimes) {
+          fs6.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs5.lutimesSync = function() {
+          fs6.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs4, target, mode, function(er) {
+          return orig.call(fs5, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4919,7 +4919,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs4, target, mode);
+            return orig.call(fs5, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4928,7 +4928,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs4, target, uid, gid, function(er) {
+          return orig.call(fs5, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -4938,7 +4938,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs4, target, uid, gid);
+            return orig.call(fs5, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -4958,13 +4958,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
+          return options ? orig.call(fs5, target, options, callback) : orig.call(fs5, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
+          var stats = options ? orig.call(fs5, target, options) : orig.call(fs5, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -4994,7 +4994,7 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs4) {
+    function legacy(fs5) {
       return {
         ReadStream,
         WriteStream
@@ -5037,7 +5037,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs4.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs5.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -5076,7 +5076,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs4.open;
+          this._open = fs5.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -5112,7 +5112,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
     "use strict";
-    var fs4 = require("fs");
+    var fs5 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -5144,12 +5144,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs4[gracefulQueue]) {
+    if (!fs5[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs4, queue);
-      fs4.close = (function(fs$close) {
+      publishQueue(fs5, queue);
+      fs5.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs4, fd, function(err) {
+          return fs$close.call(fs5, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -5161,40 +5161,40 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs4.close);
-      fs4.closeSync = (function(fs$closeSync) {
+      })(fs5.close);
+      fs5.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs4, arguments);
+          fs$closeSync.apply(fs5, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs4.closeSync);
+      })(fs5.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug(fs4[gracefulQueue]);
-          require("assert").equal(fs4[gracefulQueue].length, 0);
+          debug(fs5[gracefulQueue]);
+          require("assert").equal(fs5[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs4[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs4));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
-      module2.exports = patch(fs4);
-      fs4.__patched = true;
-    }
-    function patch(fs5) {
-      polyfills(fs5);
-      fs5.gracefulify = patch;
-      fs5.createReadStream = createReadStream;
-      fs5.createWriteStream = createWriteStream;
-      var fs$readFile = fs5.readFile;
-      fs5.readFile = readFile2;
+      publishQueue(global, fs5[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs5));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs5.__patched) {
+      module2.exports = patch(fs5);
+      fs5.__patched = true;
+    }
+    function patch(fs6) {
+      polyfills(fs6);
+      fs6.gracefulify = patch;
+      fs6.createReadStream = createReadStream;
+      fs6.createWriteStream = createWriteStream;
+      var fs$readFile = fs6.readFile;
+      fs6.readFile = readFile2;
       function readFile2(path3, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5210,8 +5210,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs5.writeFile;
-      fs5.writeFile = writeFile2;
+      var fs$writeFile = fs6.writeFile;
+      fs6.writeFile = writeFile2;
       function writeFile2(path3, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5227,9 +5227,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs5.appendFile;
+      var fs$appendFile = fs6.appendFile;
       if (fs$appendFile)
-        fs5.appendFile = appendFile;
+        fs6.appendFile = appendFile;
       function appendFile(path3, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
@@ -5245,9 +5245,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs5.copyFile;
+      var fs$copyFile = fs6.copyFile;
       if (fs$copyFile)
-        fs5.copyFile = copyFile;
+        fs6.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -5265,8 +5265,8 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs5.readdir;
-      fs5.readdir = readdir;
+      var fs$readdir = fs6.readdir;
+      fs6.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
       function readdir(path3, options, cb) {
         if (typeof options === "function")
@@ -5307,21 +5307,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs5);
+        var legStreams = legacy(fs6);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs5.ReadStream;
+      var fs$ReadStream = fs6.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs5.WriteStream;
+      var fs$WriteStream = fs6.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs5, "ReadStream", {
+      Object.defineProperty(fs6, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -5331,7 +5331,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs5, "WriteStream", {
+      Object.defineProperty(fs6, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -5342,7 +5342,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs5, "FileReadStream", {
+      Object.defineProperty(fs6, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -5353,7 +5353,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs5, "FileWriteStream", {
+      Object.defineProperty(fs6, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -5402,13 +5402,13 @@ var require_graceful_fs = __commonJS({
         });
       }
       function createReadStream(path3, options) {
-        return new fs5.ReadStream(path3, options);
+        return new fs6.ReadStream(path3, options);
       }
       function createWriteStream(path3, options) {
-        return new fs5.WriteStream(path3, options);
+        return new fs6.WriteStream(path3, options);
       }
-      var fs$open = fs5.open;
-      fs5.open = open;
+      var fs$open = fs6.open;
+      fs6.open = open;
       function open(path3, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
@@ -5424,20 +5424,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs5;
+      return fs6;
     }
     function enqueue(elem) {
       debug("ENQUEUE", elem[0].name, elem[1]);
-      fs4[gracefulQueue].push(elem);
+      fs5[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs4[gracefulQueue].length; ++i) {
-        if (fs4[gracefulQueue][i].length > 2) {
-          fs4[gracefulQueue][i][3] = now;
-          fs4[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs5[gracefulQueue].length; ++i) {
+        if (fs5[gracefulQueue][i].length > 2) {
+          fs5[gracefulQueue][i][3] = now;
+          fs5[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -5445,9 +5445,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs4[gracefulQueue].length === 0)
+      if (fs5[gracefulQueue].length === 0)
         return;
-      var elem = fs4[gracefulQueue].shift();
+      var elem = fs5[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -5469,7 +5469,7 @@ var require_graceful_fs = __commonJS({
           debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs4[gracefulQueue].push(elem);
+          fs5[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -5484,7 +5484,7 @@ var require_fs = __commonJS({
   "node_modules/fs-extra/lib/fs/index.js"(exports2) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs4 = require_graceful_fs();
+    var fs5 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -5525,26 +5525,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs4[key] === "function";
+      return typeof fs5[key] === "function";
     });
-    Object.assign(exports2, fs4);
+    Object.assign(exports2, fs5);
     api.forEach((method) => {
-      exports2[method] = u(fs4[method]);
+      exports2[method] = u(fs5[method]);
     });
     exports2.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs4.exists(filename, callback);
+        return fs5.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs4.exists(filename, resolve);
+        return fs5.exists(filename, resolve);
       });
     };
     exports2.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs4.read(fd, buffer, offset, length, position, callback);
+        return fs5.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs4.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs5.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -5552,10 +5552,10 @@ var require_fs = __commonJS({
     };
     exports2.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs4.write(fd, buffer, ...args);
+        return fs5.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs4.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs5.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -5563,10 +5563,10 @@ var require_fs = __commonJS({
     };
     exports2.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs4.readv(fd, buffers, ...args);
+        return fs5.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs4.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs5.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -5574,17 +5574,17 @@ var require_fs = __commonJS({
     };
     exports2.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs4.writev(fd, buffers, ...args);
+        return fs5.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs4.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs5.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs4.realpath.native === "function") {
-      exports2.realpath.native = u(fs4.realpath.native);
+    if (typeof fs5.realpath.native === "function") {
+      exports2.realpath.native = u(fs5.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -5617,7 +5617,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -5626,14 +5626,14 @@ var require_make_dir = __commonJS({
     };
     module2.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs4.mkdir(dir, {
+      return fs5.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module2.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs4.mkdirSync(dir, {
+      return fs5.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -5665,13 +5665,13 @@ var require_path_exists = __commonJS({
   "node_modules/fs-extra/lib/path-exists/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     function pathExists2(path3) {
-      return fs4.access(path3).then(() => true).catch(() => false);
+      return fs5.access(path3).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists2),
-      pathExistsSync: fs4.existsSync
+      pathExistsSync: fs5.existsSync
     };
   }
 });
@@ -5680,16 +5680,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "node_modules/fs-extra/lib/util/utimes.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var u = require_universalify().fromPromise;
     async function utimesMillis(path3, atime, mtime) {
-      const fd = await fs4.open(path3, "r+");
+      const fd = await fs5.open(path3, "r+");
       let closeErr = null;
       try {
-        await fs4.futimes(fd, atime, mtime);
+        await fs5.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs4.close(fd);
+          await fs5.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -5699,9 +5699,9 @@ var require_utimes = __commonJS({
       }
     }
     function utimesMillisSync(path3, atime, mtime) {
-      const fd = fs4.openSync(path3, "r+");
-      fs4.futimesSync(fd, atime, mtime);
-      return fs4.closeSync(fd);
+      const fd = fs5.openSync(path3, "r+");
+      fs5.futimesSync(fd, atime, mtime);
+      return fs5.closeSync(fd);
     }
     module2.exports = {
       utimesMillis: u(utimesMillis),
@@ -5714,11 +5714,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var path3 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file) => fs4.stat(file, { bigint: true }) : (file) => fs4.lstat(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs5.stat(file, { bigint: true }) : (file) => fs5.lstat(file, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -5729,7 +5729,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file) => fs4.statSync(file, { bigint: true }) : (file) => fs4.lstatSync(file, { bigint: true });
+      const statFunc = opts.dereference ? (file) => fs5.statSync(file, { bigint: true }) : (file) => fs5.lstatSync(file, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -5791,7 +5791,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs4.stat(destParent, { bigint: true });
+        destStat = await fs5.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5807,7 +5807,7 @@ var require_stat = __commonJS({
       if (destParent === srcParent || destParent === path3.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs4.statSync(destParent, { bigint: true });
+        destStat = fs5.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -5874,7 +5874,7 @@ var require_async = __commonJS({
 var require_copy = __commonJS({
   "node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var path3 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists: pathExists2 } = require_path_exists();
@@ -5910,7 +5910,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs4.stat : fs4.lstat;
+      const statFn = opts.dereference ? fs5.stat : fs5.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -5922,7 +5922,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs4.unlink(dest);
+        await fs5.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -5930,27 +5930,27 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs4.copyFile(src, dest);
+      await fs5.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs4.stat(src);
+        const updatedSrcStat = await fs5.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs4.chmod(dest, srcStat.mode);
+      return fs5.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs4.chmod(dest, srcMode | 128);
+      return fs5.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs4.mkdir(dest);
+        await fs5.mkdir(dest);
       }
-      await asyncIteratorConcurrentProcess(await fs4.opendir(src), async (item) => {
+      await asyncIteratorConcurrentProcess(await fs5.opendir(src), async (item) => {
         const srcItem = path3.join(src, item.name);
         const destItem = path3.join(dest, item.name);
         const include = await runFilter(srcItem, destItem, opts);
@@ -5960,22 +5960,22 @@ var require_copy = __commonJS({
         }
       });
       if (!destStat) {
-        await fs4.chmod(dest, srcStat.mode);
+        await fs5.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs4.readlink(src);
+      let resolvedSrc = await fs5.readlink(src);
       if (opts.dereference) {
         resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs4.symlink(resolvedSrc, dest);
+        return fs5.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs4.readlink(dest);
+        resolvedDest = await fs5.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs4.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs5.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
@@ -5989,8 +5989,8 @@ var require_copy = __commonJS({
           throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
         }
       }
-      await fs4.unlink(dest);
-      return fs4.symlink(resolvedSrc, dest);
+      await fs5.unlink(dest);
+      return fs5.symlink(resolvedSrc, dest);
     }
     module2.exports = copy;
   }
@@ -6000,7 +6000,7 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_graceful_fs();
+    var fs5 = require_graceful_fs();
     var path3 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
@@ -6023,11 +6023,11 @@ var require_copy_sync = __commonJS({
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
       const destParent = path3.dirname(dest);
-      if (!fs4.existsSync(destParent)) mkdirsSync(destParent);
+      if (!fs5.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs4.statSync : fs4.lstatSync;
+      const statSync = opts.dereference ? fs5.statSync : fs5.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -6042,14 +6042,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs4.unlinkSync(dest);
+        fs5.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs4.copyFileSync(src, dest);
+      fs5.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -6064,10 +6064,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs4.chmodSync(dest, srcMode);
+      return fs5.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs4.statSync(src);
+      const updatedSrcStat = fs5.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -6075,12 +6075,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs4.mkdirSync(dest);
+      fs5.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs4.opendirSync(src);
+      const dir = fs5.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -6098,18 +6098,18 @@ var require_copy_sync = __commonJS({
       return getStats(destStat, srcItem, destItem, opts);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs4.readlinkSync(src);
+      let resolvedSrc = fs5.readlinkSync(src);
       if (opts.dereference) {
         resolvedSrc = path3.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs4.symlinkSync(resolvedSrc, dest);
+        return fs5.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs4.readlinkSync(dest);
+          resolvedDest = fs5.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs4.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs5.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
@@ -6127,8 +6127,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs4.unlinkSync(dest);
-      return fs4.symlinkSync(resolvedSrc, dest);
+      fs5.unlinkSync(dest);
+      return fs5.symlinkSync(resolvedSrc, dest);
     }
     module2.exports = copySync;
   }
@@ -6150,13 +6150,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "node_modules/fs-extra/lib/remove/index.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_graceful_fs();
+    var fs5 = require_graceful_fs();
     var u = require_universalify().fromCallback;
     function remove2(path3, callback) {
-      fs4.rm(path3, { recursive: true, force: true }, callback);
+      fs5.rm(path3, { recursive: true, force: true }, callback);
     }
     function removeSync(path3) {
-      fs4.rmSync(path3, { recursive: true, force: true });
+      fs5.rmSync(path3, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove2),
@@ -6170,14 +6170,14 @@ var require_empty = __commonJS({
   "node_modules/fs-extra/lib/empty/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var path3 = require("path");
     var mkdir = require_mkdirs();
     var remove2 = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs4.readdir(dir);
+        items = await fs5.readdir(dir);
       } catch {
         return mkdir.mkdirs(dir);
       }
@@ -6186,7 +6186,7 @@ var require_empty = __commonJS({
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs4.readdirSync(dir);
+        items = fs5.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
@@ -6210,51 +6210,51 @@ var require_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path3 = require("path");
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file) {
       let stats;
       try {
-        stats = await fs4.stat(file);
+        stats = await fs5.stat(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path3.dirname(file);
       let dirStats = null;
       try {
-        dirStats = await fs4.stat(dir);
+        dirStats = await fs5.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs4.writeFile(file, "");
+          await fs5.writeFile(file, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs4.writeFile(file, "");
+        await fs5.writeFile(file, "");
       } else {
-        await fs4.readdir(dir);
+        await fs5.readdir(dir);
       }
     }
     function createFileSync(file) {
       let stats;
       try {
-        stats = fs4.statSync(file);
+        stats = fs5.statSync(file);
       } catch {
       }
       if (stats && stats.isFile()) return;
       const dir = path3.dirname(file);
       try {
-        if (!fs4.statSync(dir).isDirectory()) {
-          fs4.readdirSync(dir);
+        if (!fs5.statSync(dir).isDirectory()) {
+          fs5.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs4.writeFileSync(file, "");
+      fs5.writeFileSync(file, "");
     }
     module2.exports = {
       createFile: u(createFile),
@@ -6269,19 +6269,19 @@ var require_link = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path3 = require("path");
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists: pathExists2 } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs4.lstat(dstpath);
+        dstStat = await fs5.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs4.lstat(srcpath);
+        srcStat = await fs5.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
@@ -6292,26 +6292,26 @@ var require_link = __commonJS({
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs4.link(srcpath, dstpath);
+      await fs5.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs4.lstatSync(dstpath);
+        dstStat = fs5.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs4.lstatSync(srcpath);
+        const srcStat = fs5.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       const dir = path3.dirname(dstpath);
-      const dirExists = fs4.existsSync(dir);
-      if (dirExists) return fs4.linkSync(srcpath, dstpath);
+      const dirExists = fs5.existsSync(dir);
+      if (dirExists) return fs5.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs4.linkSync(srcpath, dstpath);
+      return fs5.linkSync(srcpath, dstpath);
     }
     module2.exports = {
       createLink: u(createLink),
@@ -6325,13 +6325,13 @@ var require_symlink_paths = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
     var path3 = require("path");
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var { pathExists: pathExists2 } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
       if (path3.isAbsolute(srcpath)) {
         try {
-          await fs4.lstat(srcpath);
+          await fs5.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw err;
@@ -6351,7 +6351,7 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs4.lstat(srcpath);
+        await fs5.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
@@ -6363,7 +6363,7 @@ var require_symlink_paths = __commonJS({
     }
     function symlinkPathsSync(srcpath, dstpath) {
       if (path3.isAbsolute(srcpath)) {
-        const exists2 = fs4.existsSync(srcpath);
+        const exists2 = fs5.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
@@ -6372,14 +6372,14 @@ var require_symlink_paths = __commonJS({
       }
       const dstdir = path3.dirname(dstpath);
       const relativeToDst = path3.join(dstdir, srcpath);
-      const exists = fs4.existsSync(relativeToDst);
+      const exists = fs5.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs4.existsSync(srcpath);
+      const srcExists = fs5.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
@@ -6397,13 +6397,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "node_modules/fs-extra/lib/ensure/symlink-type.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs4.lstat(srcpath);
+        stats = await fs5.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -6413,7 +6413,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs4.lstatSync(srcpath);
+        stats = fs5.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -6432,7 +6432,7 @@ var require_symlink = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var path3 = require("path");
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -6441,13 +6441,13 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs4.lstat(dstpath);
+        stats = await fs5.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs4.stat(srcpath),
-          fs4.stat(dstpath)
+          fs5.stat(srcpath),
+          fs5.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
@@ -6458,27 +6458,27 @@ var require_symlink = __commonJS({
       if (!await pathExists2(dir)) {
         await mkdirs(dir);
       }
-      return fs4.symlink(srcpath, dstpath, toType);
+      return fs5.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs4.lstatSync(dstpath);
+        stats = fs5.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs4.statSync(srcpath);
-        const dstStat = fs4.statSync(dstpath);
+        const srcStat = fs5.statSync(srcpath);
+        const dstStat = fs5.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
       const dir = path3.dirname(dstpath);
-      const exists = fs4.existsSync(dir);
-      if (exists) return fs4.symlinkSync(srcpath, dstpath, type);
+      const exists = fs5.existsSync(dir);
+      if (exists) return fs5.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs4.symlinkSync(srcpath, dstpath, type);
+      return fs5.symlinkSync(srcpath, dstpath, type);
     }
     module2.exports = {
       createSymlink: u(createSymlink),
@@ -6547,9 +6547,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs4 = options.fs || _fs;
+      const fs5 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs4.readFile)(file, options);
+      let data = await universalify.fromCallback(fs5.readFile)(file, options);
       data = stripBom(data);
       let obj;
       try {
@@ -6569,10 +6569,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs4 = options.fs || _fs;
+      const fs5 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs4.readFileSync(file, options);
+        let content = fs5.readFileSync(file, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -6585,15 +6585,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file, obj, options = {}) {
-      const fs4 = options.fs || _fs;
+      const fs5 = options.fs || _fs;
       const str = stringify(obj, options);
-      await universalify.fromCallback(fs4.writeFile)(file, str, options);
+      await universalify.fromCallback(fs5.writeFile)(file, str, options);
     }
     var writeFile2 = universalify.fromPromise(_writeFile);
     function writeFileSync2(file, obj, options = {}) {
-      const fs4 = options.fs || _fs;
+      const fs5 = options.fs || _fs;
       const str = stringify(obj, options);
-      return fs4.writeFileSync(file, str, options);
+      return fs5.writeFileSync(file, str, options);
     }
     module2.exports = {
       readFile: readFile2,
@@ -6624,7 +6624,7 @@ var require_output_file = __commonJS({
   "node_modules/fs-extra/lib/output-file/index.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var path3 = require("path");
     var mkdir = require_mkdirs();
     var pathExists2 = require_path_exists().pathExists;
@@ -6633,14 +6633,14 @@ var require_output_file = __commonJS({
       if (!await pathExists2(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs4.writeFile(file, data, encoding);
+      return fs5.writeFile(file, data, encoding);
     }
     function outputFileSync(file, ...args) {
       const dir = path3.dirname(file);
-      if (!fs4.existsSync(dir)) {
+      if (!fs5.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs4.writeFileSync(file, ...args);
+      fs5.writeFileSync(file, ...args);
     }
     module2.exports = {
       outputFile: u(outputFile),
@@ -6699,7 +6699,7 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_fs();
+    var fs5 = require_fs();
     var path3 = require("path");
     var { copy } = require_copy2();
     var { remove: remove2 } = require_remove();
@@ -6726,7 +6726,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs4.rename(src, dest);
+        await fs5.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -6751,7 +6751,7 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
-    var fs4 = require_graceful_fs();
+    var fs5 = require_graceful_fs();
     var path3 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
@@ -6776,12 +6776,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs4.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs5.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs4.renameSync(src, dest);
+        fs5.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -19192,7 +19192,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join6(s) {
+        value: function join7(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -28069,10 +28069,10 @@ var require_lib2 = __commonJS({
     exports2.analyse = analyse;
     var detectFile = (filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs4 = (0, node_1.default)();
+      const fs5 = (0, node_1.default)();
       const handler = (err, buffer) => {
         if (fd) {
-          fs4.closeSync(fd);
+          fs5.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -28084,9 +28084,9 @@ var require_lib2 = __commonJS({
       };
       const sampleSize = (opts === null || opts === void 0 ? void 0 : opts.sampleSize) || 0;
       if (sampleSize > 0) {
-        fd = fs4.openSync(filepath, "r");
+        fd = fs5.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(sampleSize);
-        fs4.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
+        fs5.read(fd, sample, 0, sampleSize, opts.offset, (err, bytesRead) => {
           if (err) {
             handler(err, null);
           } else {
@@ -28098,22 +28098,22 @@ var require_lib2 = __commonJS({
         });
         return;
       }
-      fs4.readFile(filepath, handler);
+      fs5.readFile(filepath, handler);
     });
     exports2.detectFile = detectFile;
     var detectFileSync = (filepath, opts = {}) => {
-      const fs4 = (0, node_1.default)();
+      const fs5 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs4.openSync(filepath, "r");
+        const fd = fs5.openSync(filepath, "r");
         let sample = Buffer.allocUnsafe(opts.sampleSize);
-        const bytesRead = fs4.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        const bytesRead = fs5.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
         if (bytesRead < opts.sampleSize) {
           sample = sample.subarray(0, bytesRead);
         }
-        fs4.closeSync(fd);
+        fs5.closeSync(fd);
         return (0, exports2.detect)(sample);
       }
-      return (0, exports2.detect)(fs4.readFileSync(filepath));
+      return (0, exports2.detect)(fs5.readFileSync(filepath));
     };
     exports2.detectFileSync = detectFileSync;
     exports2.default = {
@@ -42003,9 +42003,538 @@ var docsCommand = new Command("docs").alias("d").description("Open SmartStack do
   });
 });
 
+// src/commands/init.ts
+var import_fs_extra3 = __toESM(require_lib());
+var import_path4 = require("path");
+var import_os2 = require("os");
+var import_child_process4 = require("child_process");
+function checkPrerequisites() {
+  const check = (cmd, args) => {
+    try {
+      const result = (0, import_child_process4.spawnSync)(cmd, args, { encoding: "utf-8", shell: true, timeout: 1e4 });
+      return result.status === 0;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    dotnet: check("dotnet", ["--version"]),
+    node: check("node", ["--version"]),
+    npm: check("npm", ["--version"])
+  };
+}
+async function checkMcpServers() {
+  const result = {
+    smartstack: { installed: false },
+    context7: { installed: false }
+  };
+  const possiblePaths = [
+    (0, import_path4.join)((0, import_os2.homedir)(), ".claude", "settings.json"),
+    (0, import_path4.join)((0, import_os2.homedir)(), ".claude.json"),
+    (0, import_path4.join)((0, import_os2.homedir)(), "AppData", "Roaming", "Claude", "settings.json"),
+    (0, import_path4.join)((0, import_os2.homedir)(), "Library", "Application Support", "Claude", "settings.json")
+  ];
+  const mcpSettingsPaths = [
+    (0, import_path4.join)((0, import_os2.homedir)(), ".claude", "mcp_servers.json"),
+    (0, import_path4.join)((0, import_os2.homedir)(), ".config", "claude-code", "mcp.json")
+  ];
+  for (const settingsPath of [...possiblePaths, ...mcpSettingsPaths]) {
+    try {
+      if (await import_fs_extra3.default.pathExists(settingsPath)) {
+        const content = await import_fs_extra3.default.readFile(settingsPath, "utf-8");
+        const settings = JSON.parse(content);
+        const mcpServers = settings.mcpServers || settings.mcp_servers || settings.servers || settings;
+        if (mcpServers) {
+          if (mcpServers.smartstack || mcpServers["smartstack-mcp"] || mcpServers["@atlashub/smartstack-mcp"]) {
+            result.smartstack.installed = true;
+            const server = mcpServers.smartstack || mcpServers["smartstack-mcp"] || mcpServers["@atlashub/smartstack-mcp"];
+            result.smartstack.path = server?.command || server?.path;
+          }
+          if (mcpServers.context7 || mcpServers["context7-mcp"] || mcpServers["plugin:context7:context7"]) {
+            result.context7.installed = true;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const claudeResult = (0, import_child_process4.spawnSync)("claude", ["mcp", "list"], {
+      encoding: "utf-8",
+      shell: true,
+      timeout: 1e4
+    });
+    if (claudeResult.status === 0 && claudeResult.stdout) {
+      const output = claudeResult.stdout.toLowerCase();
+      if (output.includes("smartstack")) {
+        result.smartstack.installed = true;
+      }
+      if (output.includes("context7")) {
+        result.context7.installed = true;
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+function displayMcpStatus(status) {
+  console.log();
+  logger.info("MCP Servers Status:");
+  const smartstackStatus = status.smartstack.installed ? source_default.green("\u2713 Installed") : source_default.red("\u2717 Not found");
+  const context7Status = status.context7.installed ? source_default.green("\u2713 Installed") : source_default.red("\u2717 Not found");
+  console.log(`  SmartStack MCP: ${smartstackStatus}`);
+  console.log(`  Context7 MCP:   ${context7Status}`);
+  console.log();
+}
+function execCommand(command, cwd, dryRun = false) {
+  if (dryRun) {
+    logger.info(`[DRY RUN] ${command}`);
+    return;
+  }
+  try {
+    (0, import_child_process4.execSync)(command, {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    });
+  } catch (error) {
+    throw new Error(`Command failed: ${command}`);
+  }
+}
+async function createBackendStructure(config, dryRun) {
+  const { name } = config;
+  const srcDir = (0, import_path4.join)(name, "src");
+  logger.info("Creating .NET solution structure...");
+  execCommand(`dotnet new sln -n "${name}" -o "${name}"`, void 0, dryRun);
+  const projects = [
+    { proj: `${name}.Domain`, type: "classlib" },
+    { proj: `${name}.Application`, type: "classlib" },
+    { proj: `${name}.Infrastructure`, type: "classlib" },
+    { proj: `${name}.Api`, type: "webapi" }
+  ];
+  for (const { proj, type } of projects) {
+    execCommand(`dotnet new ${type} -n "${proj}" -o "${(0, import_path4.join)(srcDir, proj)}"`, void 0, dryRun);
+    execCommand(`dotnet sln "${(0, import_path4.join)(name, `${name}.sln`)}" add "${(0, import_path4.join)(srcDir, proj)}"`, void 0, dryRun);
+  }
+  const refs = [
+    { from: `${name}.Application`, to: `${name}.Domain` },
+    { from: `${name}.Infrastructure`, to: `${name}.Domain` },
+    { from: `${name}.Infrastructure`, to: `${name}.Application` },
+    { from: `${name}.Api`, to: `${name}.Application` },
+    { from: `${name}.Api`, to: `${name}.Infrastructure` }
+  ];
+  for (const { from: from3, to } of refs) {
+    execCommand(
+      `dotnet add "${(0, import_path4.join)(srcDir, from3)}" reference "${(0, import_path4.join)(srcDir, to)}"`,
+      void 0,
+      dryRun
+    );
+  }
+  logger.info("Installing SmartStack NuGet packages...");
+  const nugetPackages = [
+    { project: `${name}.Domain`, packages: ["SmartStack.Domain"] },
+    { project: `${name}.Application`, packages: ["SmartStack.Application"] },
+    { project: `${name}.Infrastructure`, packages: ["SmartStack.Infrastructure", "Microsoft.EntityFrameworkCore.Design"] },
+    { project: `${name}.Api`, packages: ["SmartStack.Api.Core"] }
+  ];
+  const dbPackage = {
+    sqlserver: "Microsoft.EntityFrameworkCore.SqlServer",
+    postgresql: "Npgsql.EntityFrameworkCore.PostgreSQL",
+    sqlite: "Microsoft.EntityFrameworkCore.Sqlite"
+  }[config.database];
+  nugetPackages.find((p) => p.project === `${name}.Infrastructure`)?.packages.push(dbPackage);
+  for (const { project, packages } of nugetPackages) {
+    for (const pkg2 of packages) {
+      execCommand(`dotnet add "${(0, import_path4.join)(srcDir, project)}" package ${pkg2}`, void 0, dryRun);
+    }
+  }
+}
+async function createFrontendStructure(config, dryRun) {
+  const { name, nameLower } = config;
+  const webDir = (0, import_path4.join)(name, "web", `${nameLower}-web`);
+  logger.info("Creating React application...");
+  if (!dryRun) {
+    await import_fs_extra3.default.ensureDir(webDir);
+  }
+  execCommand(`npm create vite@latest . -- --template react-ts`, webDir, dryRun);
+  execCommand("npm install", webDir, dryRun);
+  logger.info("Installing @atlashub/smartstack-react...");
+  execCommand("npm install @atlashub/smartstack-react", webDir, dryRun);
+  execCommand("npm install axios react-router-dom i18next react-i18next", webDir, dryRun);
+  execCommand("npm install -D tailwindcss @tailwindcss/vite", webDir, dryRun);
+  if (!dryRun) {
+    const viteConfig = `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'https://localhost:5001',
+        changeOrigin: true,
+        secure: false
+      }
+    }
+  }
+})
+`;
+    await import_fs_extra3.default.writeFile((0, import_path4.join)(webDir, "vite.config.ts"), viteConfig);
+  }
+  if (!dryRun) {
+    const mainTsx = `import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { BrowserRouter } from 'react-router-dom'
+import { SmartStackProvider } from '@atlashub/smartstack-react'
+import '@atlashub/smartstack-react/styles'
+import App from './App'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <BrowserRouter>
+      <SmartStackProvider apiUrl="https://localhost:5001/api">
+        <App />
+      </SmartStackProvider>
+    </BrowserRouter>
+  </StrictMode>
+)
+`;
+    await import_fs_extra3.default.writeFile((0, import_path4.join)(webDir, "src", "main.tsx"), mainTsx);
+  }
+}
+async function createConfigFiles(config, dryRun) {
+  const { name } = config;
+  if (dryRun) {
+    logger.info("[DRY RUN] Would create configuration files");
+    return;
+  }
+  const buildProps = `<Project>
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+  </PropertyGroup>
+</Project>
+`;
+  await import_fs_extra3.default.writeFile((0, import_path4.join)(name, "Directory.Build.props"), buildProps);
+  const connectionString = {
+    sqlserver: `Server=(localdb)\\mssqllocaldb;Database=${name};Trusted_Connection=True;MultipleActiveResultSets=true`,
+    postgresql: `Host=localhost;Database=${name.toLowerCase()};Username=postgres;Password=postgres`,
+    sqlite: `Data Source=${name.toLowerCase()}.db`
+  }[config.database];
+  const appSettings = {
+    ConnectionStrings: {
+      DefaultConnection: connectionString
+    },
+    SmartStack: {
+      Modules: {
+        Auth: config.modules.includes("Auth"),
+        Navigation: config.modules.includes("Navigation"),
+        AI: config.modules.includes("AI"),
+        Notifications: config.modules.includes("Notifications")
+      }
+    },
+    Jwt: {
+      Secret: "CHANGE_THIS_SECRET_IN_PRODUCTION_MIN_32_CHARS_LONG",
+      Issuer: name,
+      Audience: name,
+      ExpirationMinutes: 60
+    },
+    Logging: {
+      LogLevel: {
+        Default: "Information"
+      }
+    }
+  };
+  await import_fs_extra3.default.writeFile(
+    (0, import_path4.join)(name, "src", `${name}.Api`, "appsettings.json"),
+    JSON.stringify(appSettings, null, 2)
+  );
+  const gitignore = `## .NET
+bin/
+obj/
+*.user
+*.suo
+.vs/
+
+## Node
+node_modules/
+dist/
+
+## IDE
+.idea/
+.vscode/
+
+## Environment
+*.env
+*.env.local
+appsettings.*.json
+!appsettings.json
+!appsettings.Development.json
+
+## Build
+*.log
+`;
+  await import_fs_extra3.default.writeFile((0, import_path4.join)(name, ".gitignore"), gitignore);
+  const readme = `# ${name}
+
+A SmartStack application.
+
+## Prerequisites
+
+- .NET 10.0 SDK
+- Node.js 18+
+- npm 9+
+
+## Getting Started
+
+### Backend
+
+\`\`\`bash
+# Restore packages
+dotnet restore
+
+# Create initial migration
+dotnet ef migrations add InitialCreate -p src/${name}.Infrastructure -s src/${name}.Api
+
+# Apply migrations
+dotnet ef database update -p src/${name}.Infrastructure -s src/${name}.Api
+
+# Run the API
+dotnet run --project src/${name}.Api
+\`\`\`
+
+### Frontend
+
+\`\`\`bash
+cd web/${name.toLowerCase()}-web
+npm install
+npm run dev
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${name}/
+\u251C\u2500\u2500 src/
+\u2502   \u251C\u2500\u2500 ${name}.Domain/          # Domain entities and interfaces
+\u2502   \u251C\u2500\u2500 ${name}.Application/     # Application services and DTOs
+\u2502   \u251C\u2500\u2500 ${name}.Infrastructure/  # EF Core, repositories, external services
+\u2502   \u2514\u2500\u2500 ${name}.Api/             # Web API controllers and configuration
+\u251C\u2500\u2500 web/
+\u2502   \u2514\u2500\u2500 ${name.toLowerCase()}-web/          # React frontend
+\u2514\u2500\u2500 tests/                       # Unit and integration tests
+\`\`\`
+
+## Documentation
+
+- SmartStack: https://docs.smartstack.app
+- API Reference: https://localhost:5001/scalar (when running)
+
+---
+
+Generated with [SmartStack CLI](https://atlashub.io/products/smartstack-cli)
+`;
+  await import_fs_extra3.default.writeFile((0, import_path4.join)(name, "README.md"), readme);
+}
+async function initializeGit(config, dryRun) {
+  const { name } = config;
+  logger.info("Initializing Git repository...");
+  execCommand("git init", name, dryRun);
+  execCommand("git add .", name, dryRun);
+  execCommand('git commit -m "chore: initial SmartStack project setup"', name, dryRun);
+}
+var initCommand = new Command("init").description("Initialize a new SmartStack project").argument("<name>", "Project name").option("--full-stack", "Create full stack project (default)").option("--backend", "Create backend only").option("--frontend", "Create frontend only").option("--db <type>", "Database type (sqlserver, postgresql, sqlite)", "sqlserver").option("--dry-run", "Show what would be created without actually creating").option("-y, --yes", "Skip prompts and use defaults").option("--skip-mcp-check", "Skip MCP servers verification").action(async (name, options) => {
+  logger.header("SmartStack Project Initialization");
+  if (!options.skipMcpCheck) {
+    logger.info("Checking MCP servers...");
+    const mcpStatus = await checkMcpServers();
+    displayMcpStatus(mcpStatus);
+    const mcpMissing = [];
+    if (!mcpStatus.smartstack.installed) {
+      mcpMissing.push("SmartStack MCP");
+    }
+    if (!mcpStatus.context7.installed) {
+      mcpMissing.push("Context7 MCP");
+    }
+    if (mcpMissing.length > 0) {
+      console.log(source_default.yellow(`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502  \u26A0\uFE0F  MCP SERVERS MISSING                                                      \u2502
+\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
+\u2502  The following MCP servers are not installed:                                \u2502
+\u2502  ${mcpMissing.map((m) => `\u2022 ${m}`).join("\n\u2502  ").padEnd(74)}\u2502
+\u2502                                                                              \u2502
+\u2502  SmartStack projects require these MCP servers for optimal development:      \u2502
+\u2502  \u2022 SmartStack MCP: Conventions validation, scaffolding, API docs             \u2502
+\u2502  \u2022 Context7 MCP: Library documentation and code examples                     \u2502
+\u2502                                                                              \u2502
+\u2502  INSTALLATION:                                                               \u2502
+\u2502  \u2192 SmartStack MCP: claude mcp add smartstack                                 \u2502
+\u2502  \u2192 Context7 MCP:   claude mcp add context7                                   \u2502
+\u2502                                                                              \u2502
+\u2502  Or use --skip-mcp-check to continue without MCP servers.                    \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+`));
+      if (!options.yes) {
+        const { continueWithoutMcp } = await lib_default.prompt([
+          {
+            type: "confirm",
+            name: "continueWithoutMcp",
+            message: "Continue without MCP servers?",
+            default: false
+          }
+        ]);
+        if (!continueWithoutMcp) {
+          logger.info("Install MCP servers and try again.");
+          process.exit(0);
+        }
+      } else {
+        logger.warning("Continuing without MCP servers (--yes mode)");
+      }
+    } else {
+      logger.success("All required MCP servers are installed");
+    }
+  }
+  const prereqs = checkPrerequisites();
+  const needsBackend = !options.frontend;
+  const needsFrontend = !options.backend;
+  if (needsBackend && !prereqs.dotnet) {
+    logger.error(".NET SDK not found. Please install .NET 10.0 or later.");
+    process.exit(1);
+  }
+  if (needsFrontend && (!prereqs.node || !prereqs.npm)) {
+    logger.error("Node.js/npm not found. Please install Node.js 18 or later.");
+    process.exit(1);
+  }
+  if (await import_fs_extra3.default.pathExists(name)) {
+    logger.error(`Directory '${name}' already exists.`);
+    process.exit(1);
+  }
+  let projectType = "full-stack";
+  if (options.backend) projectType = "backend";
+  if (options.frontend) projectType = "frontend";
+  let config;
+  if (options.yes) {
+    config = {
+      name,
+      nameLower: name.toLowerCase(),
+      type: projectType,
+      database: options.db || "sqlserver",
+      modules: ["Auth", "Navigation", "Notifications"]
+    };
+  } else {
+    const answers = await lib_default.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: "What type of project do you want to create?",
+        choices: [
+          { name: "Full Stack (Backend .NET + Frontend React)", value: "full-stack" },
+          { name: "Backend Only (.NET API)", value: "backend" },
+          { name: "Frontend Only (React)", value: "frontend" }
+        ],
+        default: projectType
+      },
+      {
+        type: "list",
+        name: "database",
+        message: "Which database do you want to use?",
+        choices: [
+          { name: "SQL Server", value: "sqlserver" },
+          { name: "PostgreSQL", value: "postgresql" },
+          { name: "SQLite", value: "sqlite" }
+        ],
+        default: options.db || "sqlserver",
+        when: (ans) => ans.type !== "frontend"
+      },
+      {
+        type: "checkbox",
+        name: "modules",
+        message: "Which SmartStack modules do you want to enable?",
+        choices: [
+          { name: "Auth (JWT + OAuth)", value: "Auth", checked: true },
+          { name: "Navigation (Dynamic menus)", value: "Navigation", checked: true },
+          { name: "AI (OpenAI/Claude integration)", value: "AI", checked: false },
+          { name: "Notifications (SignalR real-time)", value: "Notifications", checked: true }
+        ],
+        when: (ans) => ans.type !== "frontend"
+      }
+    ]);
+    config = {
+      name,
+      nameLower: name.toLowerCase(),
+      type: answers.type,
+      database: answers.database || "sqlserver",
+      modules: answers.modules || []
+    };
+  }
+  const dryRun = options.dryRun || false;
+  if (dryRun) {
+    logger.warning("DRY RUN MODE - No files will be created");
+  }
+  console.log();
+  logger.info(`Project: ${source_default.cyan(config.name)}`);
+  logger.info(`Type: ${source_default.cyan(config.type)}`);
+  if (config.type !== "frontend") {
+    logger.info(`Database: ${source_default.cyan(config.database)}`);
+    logger.info(`Modules: ${source_default.cyan(config.modules.join(", ") || "None")}`);
+  }
+  console.log();
+  try {
+    if (!dryRun) {
+      await import_fs_extra3.default.ensureDir(name);
+    }
+    if (config.type === "full-stack" || config.type === "backend") {
+      await createBackendStructure(config, dryRun);
+    }
+    if (config.type === "full-stack" || config.type === "frontend") {
+      await createFrontendStructure(config, dryRun);
+    }
+    if (config.type !== "frontend") {
+      await createConfigFiles(config, dryRun);
+    }
+    await initializeGit(config, dryRun);
+    const summary = [
+      source_default.green.bold("Project created successfully!"),
+      "",
+      `Location: ${source_default.cyan((0, import_path4.join)(process.cwd(), name))}`,
+      "",
+      source_default.bold("Next steps:"),
+      ""
+    ];
+    if (config.type !== "frontend") {
+      summary.push(
+        `  1. Configure connection string in ${source_default.cyan("appsettings.json")}`,
+        `  2. Create migration: ${source_default.cyan(`dotnet ef migrations add InitialCreate -p src/${name}.Infrastructure -s src/${name}.Api`)}`,
+        `  3. Apply migration: ${source_default.cyan(`dotnet ef database update -p src/${name}.Infrastructure -s src/${name}.Api`)}`,
+        `  4. Run backend: ${source_default.cyan(`dotnet run --project src/${name}.Api`)}`
+      );
+    }
+    if (config.type !== "backend") {
+      summary.push(
+        `  5. Run frontend: ${source_default.cyan(`cd web/${name.toLowerCase()}-web && npm run dev`)}`
+      );
+    }
+    summary.push(
+      "",
+      source_default.bold("Documentation:"),
+      `  SmartStack: ${source_default.cyan("https://docs.smartstack.app")}`,
+      `  API Reference: ${source_default.cyan("https://localhost:5001/scalar")} (when running)`
+    );
+    logger.box(summary, "success");
+  } catch (error) {
+    logger.error(`Failed to create project: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  }
+});
+
 // src/lib/license.ts
 var jwt = __toESM(require_jsonwebtoken());
-var fs3 = __toESM(require_lib());
+var fs4 = __toESM(require_lib());
 var path2 = __toESM(require("path"));
 var os3 = __toESM(require("os"));
 var PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
@@ -42025,20 +42554,20 @@ function getLicenseFilePath() {
 }
 async function saveLicenseKey(licenseKey) {
   const licensePath = getLicenseFilePath();
-  await fs3.ensureDir(path2.dirname(licensePath));
-  await fs3.writeFile(licensePath, licenseKey.trim(), "utf-8");
+  await fs4.ensureDir(path2.dirname(licensePath));
+  await fs4.writeFile(licensePath, licenseKey.trim(), "utf-8");
 }
 async function loadLicenseKey() {
   const licensePath = getLicenseFilePath();
-  if (await fs3.pathExists(licensePath)) {
-    return (await fs3.readFile(licensePath, "utf-8")).trim();
+  if (await fs4.pathExists(licensePath)) {
+    return (await fs4.readFile(licensePath, "utf-8")).trim();
   }
   return null;
 }
 async function removeLicenseKey() {
   const licensePath = getLicenseFilePath();
-  if (await fs3.pathExists(licensePath)) {
-    await fs3.remove(licensePath);
+  if (await fs4.pathExists(licensePath)) {
+    await fs4.remove(licensePath);
   }
 }
 function validateLicenseKey(licenseKey) {
@@ -42179,8 +42708,8 @@ function createLicenseCommand() {
 
 // src/index.ts
 var import_fs3 = require("fs");
-var import_path4 = require("path");
-var pkg = JSON.parse((0, import_fs3.readFileSync)((0, import_path4.join)(__dirname, "..", "package.json"), "utf-8"));
+var import_path5 = require("path");
+var pkg = JSON.parse((0, import_fs3.readFileSync)((0, import_path5.join)(__dirname, "..", "package.json"), "utf-8"));
 var LICENSE_FREE_COMMANDS = ["license", "help", "--help", "-h", "--version", "-v"];
 async function main2() {
   const program2 = new Command();
@@ -42191,6 +42720,7 @@ async function main2() {
   program2.addCommand(statusCommand);
   program2.addCommand(updateCommand);
   program2.addCommand(docsCommand);
+  program2.addCommand(initCommand);
   const args = process.argv.slice(2);
   const commandName = args[0] || "";
   const requiresLicense = !LICENSE_FREE_COMMANDS.some(