@nanoforge-dev/cli 1.3.0 → 1.4.0

package/dist/command.loader.js

@@ -77,6 +77,11 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   NEW_SERVER_QUESTION: "Do you want to generate a server for multiplayer?",
   NEW_SKIP_INSTALL_QUESTION: "Do you want to skip dependency installation?",
   NEW_DOCKER_QUESTION: "Do you want to add a Dockerfile for containerization?",
+  // --- Create ---
+  CREATE_START: "NanoForge Component/System Creation",
+  CREATE_SUCCESS: success("Element successfully created!"),
+  CREATE_FAILED: failure("Creation failed!"),
+  CREATE_NAME_QUESTION: "What is the name of your component/system?",
   // --- Generate ---
   GENERATE_START: "NanoForge Generate",
   GENERATE_SUCCESS: success("Generation succeeded!"),
@@ -133,7 +138,7 @@ var getSpinner = /* @__PURE__ */ __name((message) => ora({ text: message }), "ge
 
 // src/action/actions/build.action.ts
 import { watch } from "chokidar";
-import { dirname, join as join3 } from "path";
+import { dirname, join as join4 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -182,21 +187,10 @@ var getConfigInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInputWithDefault(inputs, "config", ".");
 }, "getConfigInput");
 
-// src/lib/input/inputs/watch.input.ts
-var getWatchInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "watch", false);
-}, "getWatchInput");
-
-// src/lib/input/inputs/dev/generate.input.ts
-var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "generate", false);
-}, "getDevGenerateInput");
-
-// src/lib/input/inputs/install/lib.input.ts
-function getInstallLibInput(inputs) {
-  return getBooleanInputWithDefault(inputs, "lib", false);
-}
-__name(getInstallLibInput, "getInstallLibInput");
+// src/lib/input/inputs/editor.input.ts
+var getEditorInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "editor", false);
+}, "getEditorInput");
 
 // src/lib/question/questions/confirm.question.ts
 import { confirm } from "@inquirer/prompts";
@@ -286,6 +280,66 @@ var askSelect = /* @__PURE__ */ __name(async (question, choices, baseOptions) =>
   }).catch(promptError);
 }, "askSelect");
 
+// src/lib/input/inputs/name.input.ts
+var getNameInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "name");
+}, "getNameInput");
+var getNewNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNameInput(inputs),
+    () => askInput(Messages.NEW_NAME_QUESTION, {
+      required: true,
+      default: "nanoforge-app"
+    })
+  );
+}, "getNewNameInputOrAsk");
+var getCreateNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNameInput(inputs),
+    () => askInput(Messages.CREATE_NAME_QUESTION, {
+      required: true,
+      default: "example"
+    })
+  );
+}, "getCreateNameInputOrAsk");
+
+// src/lib/input/inputs/path.input.ts
+var getPathInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "path");
+}, "getPathInput");
+var getPathInputWithDefault = /* @__PURE__ */ __name((inputs, defaultValue) => {
+  return getStringInputWithDefault(inputs, "path", defaultValue);
+}, "getPathInputWithDefault");
+
+// src/lib/input/inputs/server.input.ts
+function getServerInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "server", false);
+}
+__name(getServerInput, "getServerInput");
+
+// src/lib/input/inputs/watch.input.ts
+var getWatchInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "watch", false);
+}, "getWatchInput");
+
+// src/lib/input/inputs/create/type.input.ts
+var getCreateTypeInput = /* @__PURE__ */ __name((inputs) => {
+  const res = getStringInput(inputs, "type");
+  if (res && ["component", "system"].includes(res)) return res;
+  throw new Error("Invalid type. Please enter 'component' or 'system'.");
+}, "getCreateTypeInput");
+
+// src/lib/input/inputs/dev/generate.input.ts
+var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "generate", false);
+}, "getDevGenerateInput");
+
+// src/lib/input/inputs/install/lib.input.ts
+function getInstallLibInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "lib", false);
+}
+__name(getInstallLibInput, "getInstallLibInput");
+
 // src/lib/input/inputs/install/names.input.ts
 var getNamesInput = /* @__PURE__ */ __name((inputs) => {
   return getArrayInput(inputs, "names");
@@ -297,12 +351,6 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
-// src/lib/input/inputs/install/server.input.ts
-function getInstallServerInput(inputs) {
-  return getBooleanInputWithDefault(inputs, "server", false);
-}
-__name(getInstallServerInput, "getInstallServerInput");
-
 // src/lib/input/inputs/login-out/api-key.input.ts
 var getApiKeyInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInput(inputs, "apiKey");
@@ -356,20 +404,6 @@ var getNewLintInput = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInputWithDefault(inputs, "lint", true);
 }, "getNewLintInput");
 
-// src/lib/input/inputs/new/name.input.ts
-var getNameInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "name");
-}, "getNameInput");
-var getNewNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getNameInput(inputs),
-    () => askInput(Messages.NEW_NAME_QUESTION, {
-      required: true,
-      default: "nanoforge-app"
-    })
-  );
-}, "getNewNameInputOrAsk");
-
 // src/lib/input/inputs/new/package-manager.input.ts
 var getPackageManagerInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInput(inputs, "packageManager");
@@ -387,11 +421,6 @@ var getNewPackageManagerInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getNewPackageManagerInputOrAsk");
 
-// src/lib/input/inputs/new/path.input.ts
-var getNewPathInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "path");
-}, "getNewPathInput");
-
 // src/lib/input/inputs/new/server.input.ts
 var getNewServerInput = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInput(inputs, "server");
@@ -494,6 +523,9 @@ var PackageManager = class {
     this.commands = commands;
     this.runner = runner;
   }
+  name;
+  commands;
+  runner;
   static {
     __name(this, "PackageManager");
   }
@@ -637,6 +669,8 @@ var Runner = class {
     this.binary = binary;
     this.baseArgs = baseArgs;
   }
+  binary;
+  baseArgs;
   static {
     __name(this, "Runner");
   }
@@ -841,6 +875,21 @@ var PackageManagerFactory = class {
   }
 };
 
+// src/lib/utils/files.ts
+import fs3 from "fs";
+import { join as join2 } from "path";
+var copyFiles = /* @__PURE__ */ __name((from, to) => {
+  if (!fs3.existsSync(from)) return;
+  if (!fs3.existsSync(to)) throw new Error(`Directory ${to} does not exist`);
+  fs3.readdirSync(from, { recursive: true }).forEach((file) => {
+    fs3.copyFileSync(join2(from, file.toString()), join2(to, file.toString()));
+  });
+}, "copyFiles");
+var resetFolder = /* @__PURE__ */ __name((folder) => {
+  if (fs3.existsSync(folder)) fs3.rmSync(folder, { recursive: true, force: true });
+  fs3.mkdirSync(folder);
+}, "resetFolder");
+
 // src/lib/utils/run-safe.ts
 import { red as red5 } from "ansis";
 var runSafe = /* @__PURE__ */ __name(async (fn, fallback) => {
@@ -860,42 +909,77 @@ var BuildConfig = class {
   static {
     __name(this, "BuildConfig");
   }
-  entryFile;
-  outDir;
+  entry;
+  staticDir;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "entry", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "staticDir", 2);
+var EditorConfig = class {
+  static {
+    __name(this, "EditorConfig");
+  }
+  entry;
+  save;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "entryFile", 2);
+], EditorConfig.prototype, "entry", 2);
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "outDir", 2);
-var RunConfig = class {
+], EditorConfig.prototype, "save", 2);
+var DirsConfig = class {
   static {
-    __name(this, "RunConfig");
+    __name(this, "DirsConfig");
   }
-  dir;
+  components;
+  systems;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], RunConfig.prototype, "dir", 2);
+], DirsConfig.prototype, "components", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], DirsConfig.prototype, "systems", 2);
 var ClientConfig = class {
   static {
     __name(this, "ClientConfig");
   }
+  enable;
   port;
+  outDir;
   build;
-  runtime;
+  editor;
+  dirs;
 };
+__decorateClass([
+  Expose(),
+  IsBoolean()
+], ClientConfig.prototype, "enable", 2);
 __decorateClass([
   Expose(),
   IsPort()
 ], ClientConfig.prototype, "port", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], ClientConfig.prototype, "outDir", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -903,21 +987,33 @@ __decorateClass([
 ], ClientConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
   ValidateNested()
-], ClientConfig.prototype, "runtime", 2);
+], ClientConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
+  ValidateNested()
+], ClientConfig.prototype, "dirs", 2);
 var ServerConfig = class {
   static {
     __name(this, "ServerConfig");
   }
   enable;
+  outDir;
   build;
-  runtime;
+  editor;
+  dirs;
 };
 __decorateClass([
   Expose(),
   IsBoolean()
 ], ServerConfig.prototype, "enable", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], ServerConfig.prototype, "outDir", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -925,9 +1021,14 @@ __decorateClass([
 ], ServerConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
   ValidateNested()
-], ServerConfig.prototype, "runtime", 2);
+], ServerConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
+  ValidateNested()
+], ServerConfig.prototype, "dirs", 2);
 var Config = class {
   static {
     __name(this, "Config");
@@ -966,13 +1067,12 @@ __decorateClass([
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
 import { existsSync, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 
 // src/lib/constants.ts
 var CONFIG_FILE_NAME = "nanoforge.config.json";
 var MANIFEST_FILE_NAME = "nanoforge.manifest.json";
 var GLOBAL_CONFIG_FILE_NAME = ".nanoforgerc";
-var NANOFORGE_DIR = ".nanoforge";
 var REGISTRY_URL = "https://api.nanoforge.dev";
 
 // src/lib/utils/object.ts
@@ -1002,23 +1102,36 @@ var CONFIG_DEFAULTS = {
   language: "ts",
   initFunctions: true,
   client: {
+    enable: true,
     port: "3000",
+    outDir: ".nanoforge/client",
     build: {
-      entryFile: "client/main.ts",
-      outDir: ".nanoforge/client"
+      entry: "client/main.ts",
+      staticDir: "client/static"
     },
-    runtime: {
-      dir: ".nanoforge/client"
+    editor: {
+      entry: ".nanoforge/editor/client/main.ts",
+      save: ".nanoforge/client.save.json"
+    },
+    dirs: {
+      components: "client/components",
+      systems: "client/systems"
     }
   },
   server: {
     enable: false,
+    outDir: ".nanoforge/server",
     build: {
-      entryFile: "server/main.ts",
-      outDir: ".nanoforge/server"
+      entry: "server/main.ts",
+      staticDir: "server/static"
+    },
+    editor: {
+      entry: ".nanoforge/editor/server/main.ts",
+      save: ".nanoforge/server.save.json"
     },
-    runtime: {
-      dir: ".nanoforge/server"
+    dirs: {
+      components: "server/components",
+      systems: "server/systems"
     }
   }
 };
@@ -1027,23 +1140,23 @@ var CONFIG_DEFAULTS = {
 var config;
 var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
-    return join2(directory, name);
+    return join3(directory, name);
   } else {
     for (const n of [CONFIG_FILE_NAME]) {
-      const path = join2(directory, n);
+      const path = join3(directory, n);
       if (existsSync(path)) return path;
     }
     throw new Error(`No config file found in directory: ${directory}`);
   }
 }, "getConfigPath");
-var loadConfig = /* @__PURE__ */ __name(async (directory, name) => {
+var loadConfig = /* @__PURE__ */ __name(async (directory, name, noThrow = false) => {
   if (config) return config;
   let rawData;
   const path = getConfigPath(directory, name);
   try {
     rawData = deepMerge(CONFIG_DEFAULTS, JSON.parse(readFileSync(path, "utf-8")));
   } catch {
-    rawData = null;
+    rawData = noThrow ? CONFIG_DEFAULTS : null;
   }
   if (!rawData) throw new Error(`Not able to read config file : ${path}`);
   const data = plainToInstance(Config, rawData, {
@@ -1058,8 +1171,8 @@ ${errors.toString().replace(/,/g, "\n")}`);
 }, "loadConfig");
 
 // src/action/common/config.ts
-var getConfig = /* @__PURE__ */ __name((inputs, dir) => {
-  return loadConfig(dir, getConfigInput(inputs));
+var getConfig = /* @__PURE__ */ __name((inputs, dir, noThrow) => {
+  return loadConfig(dir, getConfigInput(inputs), noThrow);
 }, "getConfig");
 
 // src/action/abstract.action.ts
@@ -1106,40 +1219,53 @@ var BuildAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const isEditor = getEditorInput(options);
     const isWatch = getWatchInput(options);
-    const targets = this.resolveTargets(config2, options);
+    const targets = this.resolveTargets(config2, options, isEditor);
     const results = await this.buildAll(targets, directory, isWatch);
     if (isWatch) {
       return this.enterWatchMode();
     }
     return { success: results.every(Boolean) };
   }
-  resolveTargets(config2, options) {
-    const targets = [
-      this.createTarget(
-        "Client",
-        config2.client.build,
-        "browser",
-        getStringInput(options, "clientDirectory")
-      )
-    ];
-    if (config2.server.enable) {
+  resolveTargets(config2, options, isEditor) {
+    const targets = [];
+    if (config2.client.enable)
+      targets.push(
+        this.createTarget(
+          "Client",
+          "browser",
+          getStringInputWithDefault(
+            options,
+            "clientEntry",
+            !isEditor ? config2.client.build.entry : config2.client.editor.entry
+          ),
+          getStringInputWithDefault(options, "clientStaticDir", config2.client.build.staticDir),
+          getStringInputWithDefault(options, "clientOutDir", config2.client.outDir)
+        )
+      );
+    if (config2.server.enable)
       targets.push(
         this.createTarget(
           "Server",
-          config2.server.build,
           "node",
-          getStringInput(options, "serverDirectory")
+          getStringInputWithDefault(
+            options,
+            "serverEntry",
+            !isEditor ? config2.server.build.entry : config2.server.editor.entry
+          ),
+          getStringInputWithDefault(options, "serverStaticDir", config2.server.build.staticDir),
+          getStringInputWithDefault(options, "serverOutDir", config2.server.outDir)
         )
       );
-    }
     return targets;
   }
-  createTarget(name, config2, platform, outDirOverride) {
+  createTarget(name, platform, entryFile, staticDir, outDir) {
     return {
       name,
-      entry: config2.entryFile,
-      output: outDirOverride || config2.outDir,
+      entry: entryFile,
+      static: staticDir,
+      output: outDir,
       platform
     };
   }
@@ -1153,17 +1279,18 @@ var BuildAction = class extends AbstractAction {
   }
   async buildTarget(target, directory, isWatch) {
     const packageManager = PackageManagerFactory.create("local_bun" /* LOCAL_BUN */);
-    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(
-      () => packageManager.build(
+    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(() => {
+      this.resetOut(target.output, directory);
+      this.copyFiles(target, directory);
+      return packageManager.build(
         target.name,
         directory,
         target.entry,
         target.output,
         ["--asset-naming", "[name].[ext]", "--target", target.platform],
         rebuild
-      ),
-      false
-    ), "executeBuild");
+      );
+    }, false), "executeBuild");
     if (isWatch) {
       this.watchDirectory(directory, target.entry, () => executeBuild(true));
     }
@@ -1171,7 +1298,7 @@ var BuildAction = class extends AbstractAction {
     return result !== false;
   }
   watchDirectory(directory, entry, onChange) {
-    const watchPath = dirname(join3(getCwd(directory), entry));
+    const watchPath = dirname(join4(getCwd(directory), entry));
     watch(watchPath).on("change", onChange);
   }
   enterWatchMode() {
@@ -1180,43 +1307,16 @@ var BuildAction = class extends AbstractAction {
     console.info();
     return { keepAlive: true };
   }
-};
-
-// src/action/actions/dev.action.ts
-var DevAction = class extends AbstractAction {
-  static {
-    __name(this, "DevAction");
-  }
-  startMessage = Messages.DEV_START;
-  successMessage = Messages.DEV_SUCCESS;
-  failureMessage = Messages.DEV_FAILED;
-  async handle(_args, options) {
-    const directory = getDirectoryInput(options);
-    const generate = getDevGenerateInput(options);
-    const tasks = this.buildTaskList(directory, generate);
-    await Promise.all(tasks);
-    return { keepAlive: true };
-  }
-  buildTaskList(directory, generate) {
-    const tasks = [];
-    if (generate) {
-      tasks.push(this.runSubCommand("generate", directory, { silent: true }));
-    }
-    tasks.push(this.runSubCommand("build", directory, { silent: true }));
-    tasks.push(this.runSubCommand("start", directory, { silent: false }));
-    return tasks;
+  resetOut(outDir, directory) {
+    resetFolder(getCwd(join4(directory, outDir)));
   }
-  async runSubCommand(command, directory, options) {
-    await runSafe(async () => {
-      const packageManager = await PackageManagerFactory.find(directory);
-      await packageManager.runDev(directory, "nf", {}, [command, "--watch"], options.silent);
-    });
+  copyFiles(target, directory) {
+    const from = getCwd(join4(directory, target.static));
+    const to = getCwd(join4(directory, target.output));
+    copyFiles(from, to);
   }
 };
 
-// src/action/actions/generate.action.ts
-import { join as join4 } from "path";
-
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
   constructor(collection, runner, cwd2) {
@@ -1224,6 +1324,9 @@ var AbstractCollection = class {
     this.runner = runner;
     this.cwd = cwd2;
   }
+  collection;
+  runner;
+  cwd;
   static {
     __name(this, "AbstractCollection");
   }
@@ -1273,6 +1376,16 @@ var NanoforgeCollection = class _NanoforgeCollection extends AbstractCollection
       name: "docker",
       alias: "docker",
       description: "Generate a Dockerfile for the application"
+    },
+    {
+      name: "component",
+      alias: "component",
+      description: "Generate a Component for an application"
+    },
+    {
+      name: "system",
+      alias: "system",
+      description: "Generate a System for an application"
     }
   ];
   constructor(runner, cwd2) {
@@ -1316,6 +1429,7 @@ var CollectionFactory = class {
 var toKebabCase = /* @__PURE__ */ __name((str) => {
   return str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
 }, "toKebabCase");
+var capitalize = /* @__PURE__ */ __name((str) => str.charAt(0).toUpperCase() + str.slice(1), "capitalize");
 
 // src/lib/schematics/schematic.option.ts
 var SchematicOption = class {
@@ -1323,6 +1437,8 @@ var SchematicOption = class {
     this.name = name;
     this.value = value;
   }
+  name;
+  value;
   static {
     __name(this, "SchematicOption");
   }
@@ -1393,7 +1509,72 @@ var mapSchematicOptions = /* @__PURE__ */ __name((inputs) => {
   }, []);
 }, "mapSchematicOptions");
 
+// src/action/actions/create.action.ts
+var CreateAction = class extends AbstractAction {
+  static {
+    __name(this, "CreateAction");
+  }
+  startMessage = Messages.CREATE_START;
+  successMessage = Messages.CREATE_SUCCESS;
+  failureMessage = Messages.CREATE_FAILED;
+  async handle(args, options) {
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory, true);
+    const type = getCreateTypeInput(args);
+    const name = await getCreateNameInputOrAsk(options);
+    const isServer = getServerInput(options);
+    const path = getPathInputWithDefault(
+      options,
+      config2[isServer ? "server" : "client"].dirs[type === "component" ? "components" : "systems"]
+    );
+    await this.generateElement(directory, type, {
+      name,
+      directory: path,
+      part: isServer ? "server" : "client",
+      language: config2.language
+    });
+    return {};
+  }
+  async generateElement(directory, type, values) {
+    const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+    await executeSchematic(capitalize(type), collection, type, values);
+  }
+};
+
+// src/action/actions/dev.action.ts
+var DevAction = class extends AbstractAction {
+  static {
+    __name(this, "DevAction");
+  }
+  startMessage = Messages.DEV_START;
+  successMessage = Messages.DEV_SUCCESS;
+  failureMessage = Messages.DEV_FAILED;
+  async handle(_args, options) {
+    const directory = getDirectoryInput(options);
+    const generate = getDevGenerateInput(options);
+    const tasks = this.buildTaskList(directory, generate);
+    await Promise.all(tasks);
+    return { keepAlive: true };
+  }
+  buildTaskList(directory, generate) {
+    const tasks = [];
+    if (generate) {
+      tasks.push(this.runSubCommand("generate", directory, { silent: true }));
+    }
+    tasks.push(this.runSubCommand("build", directory, { silent: true }));
+    tasks.push(this.runSubCommand("start", directory, { silent: false }));
+    return tasks;
+  }
+  async runSubCommand(command, directory, options) {
+    await runSafe(async () => {
+      const packageManager = await PackageManagerFactory.find(directory);
+      await packageManager.runDev(directory, "nf", {}, [command, "--watch"], options.silent);
+    });
+  }
+};
+
 // src/action/actions/generate.action.ts
+import { join as join5 } from "path";
 var GenerateAction = class extends AbstractAction {
   static {
     __name(this, "GenerateAction");
@@ -1404,9 +1585,9 @@ var GenerateAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const isEditor = getEditorInput(options);
     const isWatch = getWatchInput(options);
-    const values = this.extractValues(config2);
-    await this.generateParts(values, directory, isWatch);
+    await this.generateParts(config2, directory, isEditor, isWatch);
     if (isWatch) {
       return this.enterWatchMode();
     }
@@ -1414,43 +1595,45 @@ var GenerateAction = class extends AbstractAction {
   }
   extractValues(config2) {
     return {
-      name: config2.name,
       directory: ".",
       language: config2.language,
-      server: config2.server.enable,
       initFunctions: config2.initFunctions
     };
   }
-  async generateParts(values, directory, watch3) {
+  async generateParts(config2, directory, isEditor, watch3) {
     const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-    const baseOptions = this.baseSchematicOptions(values);
-    await executeSchematic(
-      "Client main file",
-      collection,
-      "part-main",
-      { ...baseOptions, part: "client" },
-      watch3 ? this.watchPath(directory, values.directory, "client") : void 0
-    );
-    if (values.server) {
+    const values = this.extractValues(config2);
+    if (config2.client.enable)
+      await executeSchematic(
+        "Client main file",
+        collection,
+        "part-main",
+        {
+          ...values,
+          part: "client",
+          outFile: !isEditor ? config2.client.build.entry : config2.client.editor.entry,
+          saveFile: config2.client.editor.save,
+          editor: isEditor
+        },
+        watch3 ? this.watchPath(directory, values.directory, config2.client.editor.save) : void 0
+      );
+    if (config2.server.enable)
       await executeSchematic(
         "Server main file",
         collection,
         "part-main",
-        { ...baseOptions, part: "server" },
-        this.watchPath(directory, values.directory, "server")
+        {
+          ...values,
+          part: "server",
+          outFile: !isEditor ? config2.server.build.entry : config2.server.editor.entry,
+          saveFile: config2.server.editor.save,
+          editor: isEditor
+        },
+        this.watchPath(directory, values.directory, config2.server.editor.save)
       );
-    }
-  }
-  baseSchematicOptions(values) {
-    return {
-      name: values.name,
-      directory: values.directory,
-      language: values.language,
-      initFunctions: values.initFunctions
-    };
   }
-  watchPath(directory, subDir, part) {
-    return join4(getCwd(directory), subDir, NANOFORGE_DIR, `${part}.save.json`);
+  watchPath(directory, subDir, saveFile) {
+    return join5(getCwd(directory), subDir, saveFile);
   }
   enterWatchMode() {
     console.info();
@@ -1461,7 +1644,7 @@ var GenerateAction = class extends AbstractAction {
 };
 
 // src/action/actions/install.action.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/lib/global-config/global-config-handler.ts
 import { read, readUser, write, writeUser } from "rc9";
@@ -1704,8 +1887,8 @@ var concatDeps = /* @__PURE__ */ __name((deps) => {
 }, "concatDeps");
 
 // src/lib/registry/registry.ts
-import fs3 from "fs";
-import { join as join5 } from "path";
+import fs4 from "fs";
+import { join as join6 } from "path";
 var Registry = class {
   static {
     __name(this, "Registry");
@@ -1736,9 +1919,9 @@ var Registry = class {
   }
   static async installPackage(client2, manifest, dir) {
     const file = await client2.getFile(`/registry/${manifest.name}/-/${manifest._file}`);
-    const path = join5(dir, this.getTypeSubFolder(manifest.type));
-    fs3.mkdirSync(path, { recursive: true });
-    fs3.writeFileSync(join5(path, manifest._file), await file.bytes());
+    const path = join6(dir, this.getTypeSubFolder(manifest.type));
+    fs4.mkdirSync(path, { recursive: true });
+    fs4.writeFileSync(join6(path, manifest._file), await file.bytes());
   }
   static getTypeSubFolder(type) {
     if (type === "component") return "components";
@@ -1750,14 +1933,14 @@ var Registry = class {
     return withAuth(config2.apiKey, force, !headers ? {} : void 0);
   }
   static _getPackageFile(filename, dir) {
-    const path = join5(getCwd(dir ?? "."), filename);
-    if (!fs3.existsSync(path))
+    const path = join6(getCwd(dir ?? "."), filename);
+    if (!fs4.existsSync(path))
       throw new Error(
-        "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.components`!"
+        "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.package`!"
       );
     try {
-      fs3.accessSync(path, fs3.constants.R_OK);
-      return fs3.openAsBlob(path);
+      fs4.accessSync(path, fs4.constants.R_OK);
+      return fs4.openAsBlob(path);
     } catch {
       throw new Error("Cannot read package file, please verify your file permissions!");
     }
@@ -1776,7 +1959,7 @@ var InstallAction = class extends AbstractAction {
     const names = await getInstallNamesInputOrAsk(args);
     const directory = getDirectoryInput(options);
     const isLib = getInstallLibInput(options);
-    const isServer = getInstallServerInput(options);
+    const isServer = getServerInput(options);
     return isLib ? this._installLibs(directory, names) : this._installNfPackages(directory, names, isServer);
   }
   async _installLibs(directory, names) {
@@ -1793,7 +1976,7 @@ var InstallAction = class extends AbstractAction {
     return withSpinner(Messages.INSTALL_PACKAGES_IN_PROGRESS, async () => {
       await Registry.install(
         Object.values(deps.nf),
-        join6(directory, isServer ? "server" : "client")
+        join7(directory, isServer ? "server" : "client")
       );
     });
   }
@@ -1846,7 +2029,7 @@ var LogoutAction = class extends AbstractAction {
 };
 
 // src/action/actions/new.action.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
@@ -1862,7 +2045,7 @@ var NewAction = class extends AbstractAction {
     if (!values.skipInstall) {
       res = await this.installDependencies(
         values.packageManager,
-        join7(cwdDirectory, values.directory ?? values.name)
+        join8(cwdDirectory, values.directory ?? values.name)
       );
     }
     return { success: res };
@@ -1870,7 +2053,7 @@ var NewAction = class extends AbstractAction {
   async collectValues(inputs) {
     return {
       name: await getNewNameInputOrAsk(inputs),
-      directory: getNewPathInput(inputs),
+      directory: getPathInput(inputs),
       packageManager: await getNewPackageManagerInputOrAsk(inputs),
       language: await getNewLanguageInputOrAsk(inputs),
       strict: await getNewStrictOrAsk(inputs),
@@ -1878,7 +2061,8 @@ var NewAction = class extends AbstractAction {
       initFunctions: getNewInitFunctionsWithDefault(inputs),
       skipInstall: await getNewSkipInstallOrAsk(inputs),
       docker: await getNewDockerOrAsk(inputs),
-      lint: getNewLintInput(inputs)
+      lint: getNewLintInput(inputs),
+      editor: getEditorInput(inputs)
     };
   }
   async scaffold(values, directory) {
@@ -1901,14 +2085,17 @@ var NewAction = class extends AbstractAction {
       language: values.language,
       strict: values.strict,
       server: values.server,
-      lint: values.lint
+      lint: values.lint,
+      editor: values.editor
     });
   }
   generateConfiguration(collection, values) {
     return executeSchematic("Configuration", collection, "configuration", {
       name: values.name,
-      directory: values.directory,
-      server: values.server
+      directory: values.directory ?? values.name,
+      server: values.server,
+      language: values.language,
+      initFunctions: values.initFunctions
     });
   }
   async generateClientParts(collection, values) {
@@ -1917,7 +2104,9 @@ var NewAction = class extends AbstractAction {
       ...partOptions,
       server: values.server
     });
-    await executeSchematic("Client main file", collection, "part-main", partOptions);
+    await executeSchematic("Client main file", collection, "part-main", {
+      ...partOptions
+    });
   }
   async generateServerParts(collection, values) {
     const partOptions = this.partOptions(values, "server");
@@ -1925,20 +2114,20 @@ var NewAction = class extends AbstractAction {
       ...partOptions,
       server: values.server
     });
-    await executeSchematic("Server main file", collection, "part-main", partOptions);
+    await executeSchematic("Server main file", collection, "part-main", {
+      ...partOptions
+    });
   }
   async generateDocker(collection, values) {
     await executeSchematic("Docker", collection, "docker", {
-      name: values.name,
-      directory: values.directory,
+      directory: values.directory ?? values.name,
       packageManager: values.packageManager
     });
   }
   partOptions(values, part) {
     return {
-      name: values.name,
       part,
-      directory: values.directory,
+      directory: values.directory ?? values.name,
       language: values.language,
       initFunctions: values.initFunctions
     };
@@ -1996,6 +2185,7 @@ var Manifest = class {
   name;
   type;
   description;
+  tags;
   dependencies;
   publish;
   npmDependencies;
@@ -2017,6 +2207,11 @@ __decorateClass([
   IsString2(),
   IsOptional()
 ], Manifest.prototype, "description", 2);
+__decorateClass([
+  Expose2(),
+  IsString2({ each: true }),
+  IsOptional()
+], Manifest.prototype, "tags", 2);
 __decorateClass([
   Expose2(),
   IsString2({ each: true }),
@@ -2039,10 +2234,10 @@ __decorateClass([
 import { plainToInstance as plainToInstance2 } from "class-transformer";
 import { validate as validate2 } from "class-validator";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 var getManifestPath = /* @__PURE__ */ __name((directory) => {
   for (const n of [MANIFEST_FILE_NAME]) {
-    const path = join8(directory, n);
+    const path = join9(directory, n);
     if (existsSync2(path)) return path;
   }
   throw new Error(`No manifest file found in directory: ${directory}`);
@@ -2085,7 +2280,7 @@ var PublishAction = class extends AbstractAction {
 
 // src/action/actions/start.action.ts
 import dotenv from "dotenv";
-import { join as join9, resolve as resolve3 } from "path";
+import { join as join10, resolve as resolve3 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
@@ -2096,10 +2291,18 @@ var StartAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const clientDir = getStringInputWithDefault(options, "clientDir", config2.client.outDir);
+    const serverDir = getStringInputWithDefault(options, "serverDir", config2.server.outDir);
     const watch3 = getWatchInput(options);
     const port = getStringInputWithDefault(options, "port", config2.client.port);
     const ssl = this.resolveSSL(options);
-    const tasks = this.buildStartTasks(config2, directory, watch3, port, ssl);
+    const tasks = this.buildStartTasks(config2, directory, {
+      clientDir,
+      serverDir,
+      watch: watch3,
+      port,
+      ssl
+    });
     await Promise.all(tasks);
     return { keepAlive: true };
   }
@@ -2114,13 +2317,16 @@ var StartAction = class extends AbstractAction {
       key
     };
   }
-  buildStartTasks(config2, directory, watch3, port, ssl) {
+  buildStartTasks(config2, directory, options) {
     const env2 = this.parseEnv(directory);
     const tasks = [];
-    if (config2.server.enable) {
-      tasks.push(this.startServer(directory, config2, { watch: watch3 }, env2));
-    }
-    tasks.push(this.startClient(directory, config2, { watch: watch3, port, ssl }, env2));
+    const { clientDir, serverDir, watch: watch3, port, ssl } = options;
+    if (config2.server.enable)
+      tasks.push(this.startServer(directory, config2, { serverDir, watch: watch3 }, env2));
+    if (config2.client.enable)
+      tasks.push(
+        this.startClient(directory, config2, { clientDir, serverDir, watch: watch3, port, ssl }, env2)
+      );
     return tasks;
   }
   async startClient(directory, config2, options, env2) {
@@ -2135,14 +2341,14 @@ var StartAction = class extends AbstractAction {
   }
   buildClientParams(directory, config2, options) {
     const params = {
-      "-d": getCwd(join9(directory, config2.client.runtime.dir)),
+      "-d": getCwd(join10(directory, options.clientDir)),
       "-p": options.port
     };
     if (options.watch) params["--watch"] = true;
     if (options.watch) {
       params["--watch"] = true;
       if (config2.server.enable) {
-        params["--watch-server-dir"] = getCwd(join9(directory, config2.server.runtime.dir));
+        params["--watch-server-dir"] = getCwd(join10(directory, options.serverDir));
       }
     }
     if (options.ssl) {
@@ -2151,9 +2357,9 @@ var StartAction = class extends AbstractAction {
     }
     return this.buildParams(params);
   }
-  buildServerParams(directory, config2, options) {
+  buildServerParams(directory, _config, options) {
     const params = {
-      "-d": getCwd(join9(directory, config2.server.runtime.dir))
+      "-d": getCwd(join10(directory, options.serverDir))
     };
     if (options.watch) params["--watch"] = true;
     return this.buildParams(params);
@@ -2169,7 +2375,7 @@ var StartAction = class extends AbstractAction {
       ...process.env
     };
     dotenv.config({
-      path: resolve3(getCwd(join9(dir, ".env"))),
+      path: resolve3(getCwd(join10(dir, ".env"))),
       processEnv: rawEnv
     });
     const baseEnv = Object.entries(rawEnv).filter(
@@ -2214,6 +2420,7 @@ var AbstractCommand = class {
   constructor(action) {
     this.action = action;
   }
+  action;
   static {
     __name(this, "AbstractCommand");
   }
@@ -2232,12 +2439,17 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program) {
-    program.command("build").description("build your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-outDir [clientDirectory]", "specify the output directory of the client").option("--server-outDir [serverDirectory]", "specify the output directory of the server").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
+    program.command("build").description("build your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-entry [clientEntry]", "specify the entry file of the client").option("--server-entry [serverEntry]", "specify the entry file of the server").option("--client-static-dir [clientStaticDir]", "specify the static directory of the client").option("--server-static-dir [serverStaticDir]", "specify the static directory of the server").option("--client-out-dir [clientOutDir]", "specify the output directory of the client").option("--server-out-dir [serverOutDir]", "specify the output directory of the server").option("--editor", "specify if the project must build with editor config").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
-        clientDirectory: rawOptions.clientOutDir,
-        serverDirectory: rawOptions.serverOutDir,
+        clientEntry: rawOptions.clientEntry,
+        serverEntry: rawOptions.serverEntry,
+        clientStaticDir: rawOptions.clientStaticDir,
+        serverStaticDir: rawOptions.serverStaticDir,
+        clientOutDir: rawOptions.clientOutDir,
+        serverOutDir: rawOptions.serverOutDir,
+        editor: rawOptions.editor,
         watch: rawOptions.watch
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
@@ -2245,6 +2457,35 @@ var BuildCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/create.command.ts
+var CreateCommand = class extends AbstractCommand {
+  static {
+    __name(this, "CreateCommand");
+  }
+  load(program) {
+    program.command("create [type]").description("create nanoforge components or systems").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-n, --name [name]", "name of the component/system").option(
+      "-s, --server",
+      "install components/systems on server (default install on client)",
+      false
+    ).option(
+      "-p, --path [path]",
+      "path to the component/system folder (default: [part]/<components|systems>)"
+    ).action(async (type, rawOptions) => {
+      const args = AbstractCommand.mapToInput({
+        type
+      });
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        name: rawOptions.name,
+        server: rawOptions.server,
+        path: rawOptions.path
+      });
+      await this.action.run(args, options);
+    });
+  }
+};
+
 // src/command/commands/dev.command.ts
 var DevCommand = class extends AbstractCommand {
   static {
@@ -2268,10 +2509,11 @@ var GenerateCommand = class extends AbstractCommand {
     __name(this, "GenerateCommand");
   }
   load(program) {
-    program.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
+    program.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--editor", "specify if the project must generate editor main file").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
+        editor: rawOptions.editor,
         watch: rawOptions.watch
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
@@ -2345,7 +2587,7 @@ var NewCommand = class extends AbstractCommand {
     program.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the working directory of the command").option("--name [name]", "specify the name of your project").option(
       "--path [path]",
       "specify the relative path where your project will be created (default: name of the project)"
-    ).option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").option("--no-lint", "do not generate lint files").action(async (rawOptions) => {
+    ).option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").option("--no-lint", "do not generate lint files").option("--editor", "do add editor dependencies").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         name: rawOptions.name,
@@ -2357,7 +2599,8 @@ var NewCommand = class extends AbstractCommand {
         initFunctions: rawOptions.initFunctions,
         skipInstall: rawOptions.skipInstall,
         docker: rawOptions.docker,
-        lint: rawOptions.lint
+        lint: rawOptions.lint,
+        editor: rawOptions.editor
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
     });
@@ -2385,11 +2628,13 @@ var StartCommand = class extends AbstractCommand {
     __name(this, "StartCommand");
   }
   load(program) {
-    program.command("start").description("start your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-p, --port [port]", "specify the port of the loader (the website to load the game)").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
+    program.command("start").description("start your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-p, --port [port]", "specify the port of the loader (the website to load the game)").option("--client-dir [clientDirectory]", "specify the directory of the client").option("--server-dir [serverDirectory]", "specify the directory of the server").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
         port: rawOptions.port,
+        clientDir: rawOptions.clientDir,
+        serverDir: rawOptions.serverDir,
         watch: rawOptions.watch,
         cert: rawOptions.cert,
         key: rawOptions.key
@@ -2426,6 +2671,7 @@ var CommandLoader = class {
     new StartCommand(new StartAction()).load(program);
     new DevCommand(new DevAction()).load(program);
     new GenerateCommand(new GenerateAction()).load(program);
+    new CreateCommand(new CreateAction()).load(program);
     new LoginCommand(new LoginAction()).load(program);
     new LogoutCommand(new LogoutAction()).load(program);
     new PublishCommand(new PublishAction()).load(program);