@nanoforge-dev/cli 1.3.0 → 1.4.1

package/dist/nf.js

@@ -40,7 +40,7 @@ var require_package = __commonJS({
     module.exports = {
       $schema: "https://json.schemastore.org/package.json",
       name: "@nanoforge-dev/cli",
-      version: "1.3.0",
+      version: "1.4.1",
       description: "NanoForge CLI",
       keywords: [
         "nanoforge",
@@ -103,6 +103,7 @@ var require_package = __commonJS({
         commander: "catalog:cli",
         dotenv: "catalog:libs",
         "node-emoji": "catalog:cli",
+        open: "catalog:libs",
         ora: "catalog:cli",
         rc9: "catalog:libs",
         "reflect-metadata": "catalog:libs"
@@ -126,7 +127,10 @@ var require_package = __commonJS({
         typescript: "catalog:build",
         vitest: "catalog:tests"
       },
-      packageManager: "pnpm@10.28.1",
+      optionalDependencies: {
+        "@nanoforge-dev/editor": "file:../editor"
+      },
+      packageManager: "pnpm@10.33.0",
       engines: {
         node: "25"
       },
@@ -149,6 +153,110 @@ var require_package = __commonJS({
 import { program } from "commander";
 import "reflect-metadata";
 
+// src/lib/tree-kill/tree-kill.ts
+import { execSync, spawn } from "child_process";
+var treeKill = /* @__PURE__ */ __name((pid, signal) => {
+  function extracted(resolve4) {
+    const tree = {};
+    const pidsToProcess = {};
+    tree[pid] = [];
+    pidsToProcess[pid] = 1;
+    switch (process.platform) {
+      case "win32":
+        execSync("taskkill /pid " + pid + " /T /F");
+        resolve4();
+        break;
+      case "darwin":
+        buildProcessTree(
+          pid,
+          tree,
+          pidsToProcess,
+          function(parentPid) {
+            return spawn("pgrep", ["-P", parentPid]);
+          },
+          function() {
+            killAll(tree, signal);
+            resolve4();
+          }
+        );
+        break;
+      default:
+        buildProcessTree(
+          pid,
+          tree,
+          pidsToProcess,
+          function(parentPid) {
+            return spawn("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+          },
+          function() {
+            killAll(tree, signal);
+            resolve4();
+          }
+        );
+        break;
+    }
+  }
+  __name(extracted, "extracted");
+  return new Promise((resolve4) => {
+    extracted(resolve4);
+  });
+}, "treeKill");
+function killAll(tree, signal) {
+  const killed = {};
+  Object.keys(tree).reverse().forEach(function(pidStr) {
+    const pid = Number(pidStr);
+    tree[pid]?.forEach(function(pidpid) {
+      if (!killed[pidpid]) {
+        killPid(pidpid, signal);
+        killed[pidpid] = true;
+      }
+    });
+    if (!killed[pid]) {
+      killPid(pid, signal);
+      killed[pid] = true;
+    }
+  });
+}
+__name(killAll, "killAll");
+function killPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (err) {
+    const e = err;
+    if (e.code !== "ESRCH") throw err;
+  }
+}
+__name(killPid, "killPid");
+function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+  const ps = spawnChildProcessesList(parentPid.toString());
+  let allData = "";
+  ps.stdout.on("data", function(data) {
+    allData += data.toString("ascii");
+  });
+  const onClose = /* @__PURE__ */ __name(function(code) {
+    delete pidsToProcess[parentPid];
+    if (code != 0) {
+      if (Object.keys(pidsToProcess).length == 0) {
+        cb();
+      }
+      return;
+    }
+    if (allData)
+      allData.match(/\d+/g)?.forEach(function(pid) {
+        const intPid = Number(pid);
+        if (tree[parentPid] === void 0) {
+          tree[parentPid] = [];
+        }
+        tree[parentPid].push(intPid);
+        tree[intPid] = [];
+        pidsToProcess[intPid] = 1;
+        buildProcessTree(intPid, tree, pidsToProcess, spawnChildProcessesList, cb);
+      });
+  }, "onClose");
+  ps.on("close", onClose);
+}
+__name(buildProcessTree, "buildProcessTree");
+
 // src/lib/utils/local-binaries.ts
 import { existsSync } from "fs";
 import { join, posix } from "path";
@@ -162,10 +270,10 @@ var loadLocalBinCommandLoader = /* @__PURE__ */ __name(async () => {
 }, "loadLocalBinCommandLoader");
 
 // src/command/command.loader.ts
-import { red as red6 } from "ansis";
+import { red as red7 } from "ansis";
 
 // src/lib/ui/messages.ts
-import { green } from "ansis";
+import { bold, green } from "ansis";
 
 // src/lib/ui/emojis.ts
 import { get } from "node-emoji";
@@ -200,8 +308,9 @@ var Messages = {
   BUILD_WATCH_START: "Watching for changes...",
   BUILD_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Building ${part}`, "BUILD_PART_IN_PROGRESS"),
   BUILD_PART_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((part) => `${part} updated, rebuilding`, "BUILD_PART_WATCH_IN_PROGRESS"),
+  BUILD_PART_SUCCESS: /* @__PURE__ */ __name((name) => success(`Build of ${name} succeeded!`), "BUILD_PART_SUCCESS"),
   BUILD_PART_FAILED: /* @__PURE__ */ __name((part, command) => failure(`Build of ${part} failed!
-Try running manually: ${command}`), "BUILD_PART_FAILED"),
+Try running manually: ${bold(command)}`), "BUILD_PART_FAILED"),
   // --- Install ---
   INSTALL_START: "NanoForge Installation",
   INSTALL_SUCCESS: success("Installation completed!"),
@@ -221,6 +330,7 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   NEW_START: "NanoForge Project Creation",
   NEW_SUCCESS: success("Project successfully created!"),
   NEW_FAILED: failure("Project creation failed!"),
+  NEW_GENERATION_START: "Creating project...",
   NEW_NAME_QUESTION: "What is the name of your project?",
   NEW_PACKAGE_MANAGER_QUESTION: "Which package manager do you want to use?",
   NEW_LANGUAGE_QUESTION: "Which language do you want to use?",
@@ -228,6 +338,13 @@ 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?",
+  NEW_GIT_QUESTION: "Do you want to create a git repository?",
+  NEW_GIT_REMOTE_QUESTION: "Do you want to setup a git remote? (leave empty if you don't want to)",
+  // --- 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!"),
@@ -244,6 +361,9 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   START_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Starting ${part}...`, "START_PART_IN_PROGRESS"),
   START_PART_SUCCESS: /* @__PURE__ */ __name((part) => success(`${part} terminated.`), "START_PART_SUCCESS"),
   START_PART_FAILED: /* @__PURE__ */ __name((part) => failure(`${part} failed!`), "START_PART_FAILED"),
+  EDITOR_START: "NanoForge Editor",
+  EDITOR_SUCCESS: "Editor ended",
+  EDITOR_FAILED: failure("Editor failed!"),
   // --- Publish ---
   PUBLISH_START: "NanoForge Publish",
   PUBLISH_SUCCESS: success("Publish completed!"),
@@ -255,7 +375,6 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   UNPUBLISH_FAILED: failure("Unpublish failed!"),
   UNPUBLISH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Unpublishing ${name}...`, "UNPUBLISH_IN_PROGRESS"),
   // --- Schematics ---
-  SCHEMATICS_START: "Running schematics",
   SCHEMATIC_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Generating ${name}...`, "SCHEMATIC_IN_PROGRESS"),
   SCHEMATIC_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Change detected, regenerating ${name}...`, "SCHEMATIC_WATCH_IN_PROGRESS"),
   SCHEMATIC_SUCCESS: /* @__PURE__ */ __name((name) => success(`${name} generated successfully!`), "SCHEMATIC_SUCCESS"),
@@ -265,10 +384,20 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   PACKAGE_MANAGER_INSTALLATION_NOTHING: "Nothing to install.",
   PACKAGE_MANAGER_INSTALLATION_SUCCEED: /* @__PURE__ */ __name((names) => names ? success(`Packages installed: ${names.map((n) => green(n)).join(", ")}`) : success("Packages installed!"), "PACKAGE_MANAGER_INSTALLATION_SUCCEED"),
   PACKAGE_MANAGER_INSTALLATION_FAILED: /* @__PURE__ */ __name((command) => failure(`Package installation failed!
-Try running manually: ${command}`), "PACKAGE_MANAGER_INSTALLATION_FAILED"),
+Try running manually: ${bold(command)}`), "PACKAGE_MANAGER_INSTALLATION_FAILED"),
+  // --- Git init ---
+  GIT_INIT_IN_PROGRESS: `Initializing git repository... ${Emojis.COFFEE}`,
+  GIT_INIT_SUCCEED: success("Git repository initialized!"),
+  GIT_INIT_FAILED: /* @__PURE__ */ __name((command) => failure(`Git repository initialization failed!
+Try running manually: ${bold(command)}`), "GIT_INIT_FAILED"),
+  // --- Git remote ---
+  GIT_REMOTE_IN_PROGRESS: `Adding git remote... ${Emojis.COFFEE}`,
+  GIT_REMOTE_SUCCEED: success("Git remote added!"),
+  GIT_REMOTE_FAILED: /* @__PURE__ */ __name((command) => failure(`Git remote addition failed!
+Try running manually: ${bold(command)}`), "GIT_REMOTE_FAILED"),
   // --- Runner ---
   RUNNER_EXECUTION_ERROR: /* @__PURE__ */ __name((command) => `
-Failed to execute command: ${command}`, "RUNNER_EXECUTION_ERROR")
+Failed to execute command: ${bold(command)}`, "RUNNER_EXECUTION_ERROR")
 };
 
 // src/lib/ui/prefixes.ts
@@ -284,7 +413,7 @@ var getSpinner = /* @__PURE__ */ __name((message) => ora({ text: message }), "ge
 
 // src/action/actions/build.action.ts
 import { watch } from "chokidar";
-import { dirname, join as join4 } from "path";
+import { dirname, join as join5 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -333,21 +462,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";
@@ -437,6 +555,71 @@ 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/editor/open.input.ts
+var getEditorOpenInput = /* @__PURE__ */ __name((inputs, defaultValue) => {
+  return getBooleanInputWithDefault(inputs, "open", defaultValue);
+}, "getEditorOpenInput");
+
+// 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");
@@ -448,12 +631,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");
@@ -507,20 +684,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");
@@ -538,11 +701,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");
@@ -577,7 +735,7 @@ var getNewStrictOrAsk = /* @__PURE__ */ __name((inputs) => {
 }, "getNewStrictOrAsk");
 
 // src/lib/package-manager/package-manager.ts
-import { bold, red as red3 } from "ansis";
+import { red as red4 } from "ansis";
 
 // src/lib/runner/process-logger.ts
 import { green as green2, red as red2, yellow } from "ansis";
@@ -624,15 +782,16 @@ var resolveCLINodeBinaryPath = /* @__PURE__ */ __name((name) => {
 }, "resolveCLINodeBinaryPath");
 
 // src/lib/utils/spinner.ts
-var withSpinner = /* @__PURE__ */ __name(async (message, task, onError) => {
-  const spinner = getSpinner(message);
+import { red as red3 } from "ansis";
+var withSpinner = /* @__PURE__ */ __name(async (task, loadingMessage, successMessage, failureMessage, onError) => {
+  const spinner = getSpinner(loadingMessage);
   spinner.start();
   try {
     const value = await task(spinner);
-    spinner.succeed();
+    spinner.succeed(successMessage);
     return { success: true, value };
   } catch (error) {
-    spinner.fail();
+    spinner.fail(red3(failureMessage));
     if (onError) onError();
     return { success: false, error };
   }
@@ -645,18 +804,19 @@ var PackageManager = class {
     this.commands = commands;
     this.runner = runner;
   }
+  name;
+  commands;
+  runner;
   static {
     __name(this, "PackageManager");
   }
   async install(directory) {
     const args = [this.commands.install, this.commands.silentFlag];
     const result = await withSpinner(
+      () => this.exec(args, directory),
       Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
-      async (spinner) => {
-        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
-        this.logSuccess(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED());
-      },
-      () => this.logFailure(this.formatFailCommand([this.commands.install]))
+      Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(),
+      Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(this.formatFailCommand([this.commands.install]))
     );
     return result.success;
   }
@@ -679,11 +839,10 @@ var PackageManager = class {
       ...flags
     ];
     const result = await withSpinner(
+      () => this.exec(args, directory),
       message,
-      async (spinner) => {
-        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
-      },
-      () => this.logBuildFailure(name)
+      Messages.BUILD_PART_SUCCESS(name),
+      Messages.BUILD_PART_FAILED(name, this.formatFailCommand(args))
     );
     return result.success;
   }
@@ -701,7 +860,25 @@ var PackageManager = class {
       console.info(Messages.START_PART_SUCCESS(name));
       return true;
     } catch {
-      console.error(red3(Messages.START_PART_FAILED(name)));
+      console.error(red4(Messages.START_PART_FAILED(name)));
+      return false;
+    }
+  }
+  async runFile(name, directory, script, params, env2 = {}, flags = [], silent = false) {
+    console.info(Messages.START_PART_IN_PROGRESS(name));
+    try {
+      const args = this.buildRunFileArgs(script, params, flags, silent);
+      await this.exec(args, directory, {
+        env: env2,
+        listeners: {
+          onStdout: createStdoutLogger(name),
+          onStderr: createStderrLogger(name)
+        }
+      });
+      console.info(Messages.START_PART_SUCCESS(name));
+      return true;
+    } catch {
+      console.error(red4(Messages.START_PART_FAILED(name)));
       return false;
     }
   }
@@ -722,12 +899,10 @@ var PackageManager = class {
     }
     const args = [this.commands.add, saveFlag, ...dependencies];
     const result = await withSpinner(
+      () => this.exec(args, directory),
       Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
-      async (spinner) => {
-        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
-        this.logSuccess(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(dependencies));
-      },
-      () => this.logFailure(this.formatFailCommand(args))
+      Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(),
+      Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(this.formatFailCommand(args))
     );
     return result.success;
   }
@@ -744,6 +919,15 @@ var PackageManager = class {
     if (this.commands.runArgsFlag) args.push(this.commands.runArgsFlag);
     return args.concat(params);
   }
+  buildRunFileArgs(script, params, flags, silent) {
+    if (!this.commands.runFile) throw new Error("Package manager does not support runFile");
+    const args = [...flags, this.commands.runFile];
+    if (silent) args.push(this.commands.silentFlag);
+    args.push(script);
+    if (params.length === 0) return args;
+    if (this.commands.runArgsFlag) args.push(this.commands.runArgsFlag);
+    return args.concat(params);
+  }
   exec(args, directory, options = {}) {
     return this.runner.run(args, {
       collect: options.collect ?? true,
@@ -756,18 +940,6 @@ var PackageManager = class {
   formatFailCommand(args) {
     return this.runner.fullCommand(args);
   }
-  logSuccess(message) {
-    console.info();
-    console.info(message);
-    console.info();
-  }
-  logFailure(command) {
-    console.error(red3(Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(bold(command))));
-  }
-  logBuildFailure(name) {
-    const command = this.formatFailCommand([this.commands.install]);
-    console.error(red3(Messages.BUILD_PART_FAILED(name, bold(command))));
-  }
   logEmpty(message) {
     console.info();
     console.info(message);
@@ -780,14 +952,16 @@ import fs2 from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/lib/runner/runner.ts
-import { red as red4 } from "ansis";
-import { spawn } from "child_process";
+import { red as red5 } from "ansis";
+import { spawn as spawn2 } from "child_process";
 import * as process2 from "process";
 var Runner = class {
   constructor(binary, baseArgs = []) {
     this.binary = binary;
     this.baseArgs = baseArgs;
   }
+  binary;
+  baseArgs;
   static {
     __name(this, "Runner");
   }
@@ -796,7 +970,7 @@ var Runner = class {
     const spawnOpts = this.buildSpawnOptions(collect, cwd2, env2);
     const fullArgs = [...this.baseArgs, ...args];
     return new Promise((resolve4, reject) => {
-      const child = spawn(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
+      const child = spawn2(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
       const output = this.attachOutputHandlers(child, listeners);
       child.on("close", (code) => {
         if (code === 0) {
@@ -835,7 +1009,7 @@ var Runner = class {
     this.logCapturedOutput(output);
   }
   logFailedCommand(args) {
-    console.error(red4(`
+    console.error(red5(`
 Failed to execute command: ${this.binary} ${args.join(" ")}`));
   }
   logCapturedOutput(output) {
@@ -992,14 +1166,29 @@ var PackageManagerFactory = class {
   }
 };
 
+// src/lib/utils/files.ts
+import fs3 from "fs";
+import { join as join3 } 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(join3(from, file.toString()), join3(to, file.toString()));
+  });
+}, "copyFiles");
+var resetFolder = /* @__PURE__ */ __name((folder) => {
+  if (fs3.existsSync(folder)) fs3.rmSync(folder, { recursive: true, force: true });
+  fs3.mkdirSync(folder, { recursive: true });
+}, "resetFolder");
+
 // src/lib/utils/run-safe.ts
-import { red as red5 } from "ansis";
+import { red as red6 } from "ansis";
 var runSafe = /* @__PURE__ */ __name(async (fn, fallback) => {
   try {
     return await fn();
   } catch (error) {
     const msg = getErrorMessage(error);
-    if (msg) console.error(red5(msg));
+    if (msg) console.error(red6(msg));
     return fallback;
   }
 }, "runSafe");
@@ -1011,42 +1200,77 @@ var BuildConfig = class {
   static {
     __name(this, "BuildConfig");
   }
-  entryFile;
-  outDir;
+  entry;
+  staticDir;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "entryFile", 2);
+], BuildConfig.prototype, "entry", 2);
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "outDir", 2);
-var RunConfig = class {
+], BuildConfig.prototype, "staticDir", 2);
+var EditorConfig = class {
   static {
-    __name(this, "RunConfig");
+    __name(this, "EditorConfig");
   }
-  dir;
+  entry;
+  save;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], RunConfig.prototype, "dir", 2);
+], EditorConfig.prototype, "entry", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], EditorConfig.prototype, "save", 2);
+var DirsConfig = class {
+  static {
+    __name(this, "DirsConfig");
+  }
+  components;
+  systems;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], 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),
@@ -1054,21 +1278,33 @@ __decorateClass([
 ], ClientConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
+  ValidateNested()
+], ClientConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
   ValidateNested()
-], ClientConfig.prototype, "runtime", 2);
+], 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),
@@ -1076,9 +1312,14 @@ __decorateClass([
 ], ServerConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
+  ValidateNested()
+], ServerConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
   ValidateNested()
-], ServerConfig.prototype, "runtime", 2);
+], ServerConfig.prototype, "dirs", 2);
 var Config = class {
   static {
     __name(this, "Config");
@@ -1117,13 +1358,12 @@ __decorateClass([
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } 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
@@ -1153,23 +1393,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"
+    },
+    editor: {
+      entry: ".nanoforge/editor/client/main.ts",
+      save: ".nanoforge/client.save.json"
     },
-    runtime: {
-      dir: ".nanoforge/client"
+    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"
     }
   }
 };
@@ -1178,23 +1431,23 @@ var CONFIG_DEFAULTS = {
 var config;
 var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
-    return join3(directory, name);
+    return join4(directory, name);
   } else {
     for (const n of [CONFIG_FILE_NAME]) {
-      const path = join3(directory, n);
+      const path = join4(directory, n);
       if (existsSync2(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, {
@@ -1209,8 +1462,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
@@ -1257,40 +1510,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
     };
   }
@@ -1304,17 +1570,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));
     }
@@ -1322,7 +1589,7 @@ var BuildAction = class extends AbstractAction {
     return result !== false;
   }
   watchDirectory(directory, entry, onChange) {
-    const watchPath = dirname(join4(getCwd(directory), entry));
+    const watchPath = dirname(join5(getCwd(directory), entry));
     watch(watchPath).on("change", onChange);
   }
   enterWatchMode() {
@@ -1331,43 +1598,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");
+  resetOut(outDir, directory) {
+    resetFolder(getCwd(join5(directory, outDir)));
   }
-  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);
-    });
+  copyFiles(target, directory) {
+    const from = getCwd(join5(directory, target.static));
+    const to = getCwd(join5(directory, target.output));
+    copyFiles(from, to);
   }
 };
 
-// src/action/actions/generate.action.ts
-import { join as join5 } from "path";
-
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
   constructor(collection, runner, cwd2) {
@@ -1375,6 +1615,9 @@ var AbstractCollection = class {
     this.runner = runner;
     this.cwd = cwd2;
   }
+  collection;
+  runner;
+  cwd;
   static {
     __name(this, "AbstractCollection");
   }
@@ -1424,6 +1667,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) {
@@ -1467,6 +1720,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 {
@@ -1474,6 +1728,8 @@ var SchematicOption = class {
     this.name = name;
     this.value = value;
   }
+  name;
+  value;
   static {
     __name(this, "SchematicOption");
   }
@@ -1544,7 +1800,108 @@ 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/editor.action.ts
+import open from "open";
+import { join as join6 } from "path";
+var EditorAction = class extends AbstractAction {
+  static {
+    __name(this, "EditorAction");
+  }
+  startMessage = Messages.EDITOR_START;
+  successMessage = Messages.EDITOR_SUCCESS;
+  failureMessage = Messages.EDITOR_FAILED;
+  async handle(args, options) {
+    const directory = getDirectoryInput(options);
+    const path = getPathInput(args);
+    const open2 = getEditorOpenInput(options, !!path);
+    void this.startEditor(directory);
+    if (open2) await this.openEditor(path);
+    return { keepAlive: true };
+  }
+  async startEditor(directory) {
+    const editorPath = join6(
+      getModulePath("@nanoforge-dev/editor/package.json", true),
+      "dist",
+      "index.js"
+    );
+    await runSafe(async () => {
+      const packageManager = PackageManagerFactory.create("local_bun" /* LOCAL_BUN */);
+      await packageManager.run("Editor", directory, editorPath, [], {}, [], true);
+    });
+  }
+  async openEditor(path) {
+    const query = path ? `?projectPath=${encodeURIComponent(path)}` : "";
+    const url = `http://localhost:3000/load-project${query}`;
+    await open(url);
+  }
+};
+
 // src/action/actions/generate.action.ts
+import { join as join7 } from "path";
 var GenerateAction = class extends AbstractAction {
   static {
     __name(this, "GenerateAction");
@@ -1555,9 +1912,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();
     }
@@ -1565,43 +1922,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 join5(getCwd(directory), subDir, NANOFORGE_DIR, `${part}.save.json`);
+  watchPath(directory, subDir, saveFile) {
+    return join7(getCwd(directory), subDir, saveFile);
   }
   enterWatchMode() {
     console.info();
@@ -1612,7 +1971,7 @@ var GenerateAction = class extends AbstractAction {
 };
 
 // src/action/actions/install.action.ts
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 
 // src/lib/global-config/global-config-handler.ts
 import { read, readUser, write, writeUser } from "rc9";
@@ -1855,8 +2214,8 @@ var concatDeps = /* @__PURE__ */ __name((deps) => {
 }, "concatDeps");
 
 // src/lib/registry/registry.ts
-import fs3 from "fs";
-import { join as join6 } from "path";
+import fs4 from "fs";
+import { join as join8 } from "path";
 var Registry = class {
   static {
     __name(this, "Registry");
@@ -1887,9 +2246,9 @@ var Registry = class {
   }
   static async installPackage(client2, manifest, dir) {
     const file = await client2.getFile(`/registry/${manifest.name}/-/${manifest._file}`);
-    const path = join6(dir, this.getTypeSubFolder(manifest.type));
-    fs3.mkdirSync(path, { recursive: true });
-    fs3.writeFileSync(join6(path, manifest._file), await file.bytes());
+    const path = join8(dir, this.getTypeSubFolder(manifest.type));
+    fs4.mkdirSync(path, { recursive: true });
+    fs4.writeFileSync(join8(path, manifest._file), await file.bytes());
   }
   static getTypeSubFolder(type) {
     if (type === "component") return "components";
@@ -1901,14 +2260,14 @@ var Registry = class {
     return withAuth(config2.apiKey, force, !headers ? {} : void 0);
   }
   static _getPackageFile(filename, dir) {
-    const path = join6(getCwd(dir ?? "."), filename);
-    if (!fs3.existsSync(path))
+    const path = join8(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!");
     }
@@ -1927,7 +2286,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) {
@@ -1936,17 +2295,16 @@ var InstallAction = class extends AbstractAction {
   }
   async _installNfPackages(directory, names, isServer) {
     const deps = await resolveManifestDependencies(names, directory);
+    const part = isServer ? "server" : "client";
     const libSuccess = await this._installLibs(
       directory,
       deps.npm.map(([name, version]) => `${name}@${version}`)
     );
     if (!libSuccess) return { success: false };
-    return withSpinner(Messages.INSTALL_PACKAGES_IN_PROGRESS, async () => {
-      await Registry.install(
-        Object.values(deps.nf),
-        join7(directory, isServer ? "server" : "client")
-      );
-    });
+    return withSpinner(
+      () => Registry.install(Object.values(deps.nf), join9(directory, part)),
+      Messages.INSTALL_PACKAGES_IN_PROGRESS
+    );
   }
 };
 
@@ -1997,7 +2355,82 @@ var LogoutAction = class extends AbstractAction {
 };
 
 // src/action/actions/new.action.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
+
+// src/lib/git/git-runner.ts
+var GIT = "git";
+var GIT_COMMANDS = {
+  init: "init",
+  remote: "remote"
+};
+var GitRunner = class {
+  static {
+    __name(this, "GitRunner");
+  }
+  runner;
+  constructor() {
+    this.runner = new Runner(GIT);
+  }
+  async init(directory) {
+    const args = [GIT_COMMANDS.init];
+    const result = await withSpinner(
+      () => this.exec(args, directory),
+      Messages.GIT_INIT_IN_PROGRESS,
+      Messages.GIT_INIT_SUCCEED,
+      Messages.GIT_INIT_FAILED(this.formatFailCommand(args))
+    );
+    return result.success;
+  }
+  async addRemote(directory, remote) {
+    const args = [GIT_COMMANDS.remote, "add", "origin", remote];
+    const result = await withSpinner(
+      () => this.exec(args, directory),
+      Messages.GIT_REMOTE_IN_PROGRESS,
+      Messages.GIT_REMOTE_SUCCEED,
+      Messages.GIT_REMOTE_FAILED(this.formatFailCommand(args))
+    );
+    return result.success;
+  }
+  exec(args, directory, options = {}) {
+    return this.runner.run(args, {
+      collect: options.collect ?? true,
+      cwd: getCwd(directory),
+      env: options.env,
+      listeners: options.listeners,
+      onFail: options.onFail
+    });
+  }
+  formatFailCommand(args) {
+    return this.runner.fullCommand(args);
+  }
+};
+
+// src/lib/input/inputs/new/git-remote.input.ts
+var getGitRemoteInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "gitRemote");
+}, "getGitRemoteInput");
+var getNewGitRemoteInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getGitRemoteInput(inputs),
+    () => askInput(Messages.NEW_GIT_REMOTE_QUESTION, {
+      required: false,
+      default: ""
+    })
+  );
+}, "getNewGitRemoteInputOrAsk");
+
+// src/lib/input/inputs/new/git.input.ts
+var getNewGitInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "git");
+}, "getNewGitInput");
+var getNewGitOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewGitInput(inputs),
+    () => askConfirm(Messages.NEW_GIT_QUESTION, { default: true })
+  );
+}, "getNewGitOrAsk");
+
+// src/action/actions/new.action.ts
 var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
@@ -2010,18 +2443,16 @@ var NewAction = class extends AbstractAction {
     const values = await this.collectValues(options);
     await this.scaffold(values, cwdDirectory);
     let res = true;
+    const distDir = join10(cwdDirectory, values.directory);
     if (!values.skipInstall) {
-      res = await this.installDependencies(
-        values.packageManager,
-        join8(cwdDirectory, values.directory ?? values.name)
-      );
+      res = await this.installDependencies(values.packageManager, distDir);
     }
+    if (values.git) await this.setupGitRepository(values.gitRemote, distDir);
     return { success: res };
   }
   async collectValues(inputs) {
-    return {
+    const values = {
       name: await getNewNameInputOrAsk(inputs),
-      directory: getNewPathInput(inputs),
       packageManager: await getNewPackageManagerInputOrAsk(inputs),
       language: await getNewLanguageInputOrAsk(inputs),
       strict: await getNewStrictOrAsk(inputs),
@@ -2029,12 +2460,20 @@ 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),
+      git: await getNewGitOrAsk(inputs)
+    };
+    return {
+      ...values,
+      directory: getPathInput(inputs) ?? values.name,
+      gitRemote: values.git ? await getNewGitRemoteInputOrAsk(inputs) || null : null
     };
   }
   async scaffold(values, directory) {
     const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-    console.info(Messages.SCHEMATICS_START);
+    console.info();
+    console.info(Messages.NEW_GENERATION_START);
     console.info();
     await this.generateApplication(collection, values);
     await this.generateConfiguration(collection, values);
@@ -2052,14 +2491,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
+      server: values.server,
+      language: values.language,
+      initFunctions: values.initFunctions
     });
   }
   async generateClientParts(collection, values) {
@@ -2068,7 +2510,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");
@@ -2076,18 +2520,18 @@ 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,
       packageManager: values.packageManager
     });
   }
   partOptions(values, part) {
     return {
-      name: values.name,
       part,
       directory: values.directory,
       language: values.language,
@@ -2098,6 +2542,13 @@ var NewAction = class extends AbstractAction {
     const packageManager = PackageManagerFactory.create(packageManagerName);
     return await packageManager.install(directory);
   }
+  async setupGitRepository(gitRemote, dir) {
+    const runner = new GitRunner();
+    let res;
+    res = await runner.init(dir);
+    if (res && gitRemote) res = await runner.addRemote(dir, gitRemote);
+    return res;
+  }
 };
 
 // src/lib/manifest/manifest.type.ts
@@ -2147,6 +2598,7 @@ var Manifest = class {
   name;
   type;
   description;
+  tags;
   dependencies;
   publish;
   npmDependencies;
@@ -2168,6 +2620,11 @@ __decorateClass([
   IsString2(),
   IsOptional()
 ], Manifest.prototype, "description", 2);
+__decorateClass([
+  Expose2(),
+  IsString2({ each: true }),
+  IsOptional()
+], Manifest.prototype, "tags", 2);
 __decorateClass([
   Expose2(),
   IsString2({ each: true }),
@@ -2190,10 +2647,10 @@ __decorateClass([
 import { plainToInstance as plainToInstance2 } from "class-transformer";
 import { validate as validate2 } from "class-validator";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 var getManifestPath = /* @__PURE__ */ __name((directory) => {
   for (const n of [MANIFEST_FILE_NAME]) {
-    const path = join9(directory, n);
+    const path = join11(directory, n);
     if (existsSync3(path)) return path;
   }
   throw new Error(`No manifest file found in directory: ${directory}`);
@@ -2228,15 +2685,16 @@ var PublishAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const manifest = await loadManifest(directory);
-    return withSpinner(Messages.PUBLISH_IN_PROGRESS(manifest.name), async () => {
-      await Registry.publish(manifest, directory);
-    });
+    return withSpinner(
+      () => Registry.publish(manifest, directory),
+      Messages.PUBLISH_IN_PROGRESS(manifest.name)
+    );
   }
 };
 
 // src/action/actions/start.action.ts
 import dotenv from "dotenv";
-import { join as join10, resolve as resolve3 } from "path";
+import { join as join12, resolve as resolve3 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
@@ -2247,10 +2705,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 };
   }
@@ -2265,13 +2731,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) {
@@ -2286,14 +2755,14 @@ var StartAction = class extends AbstractAction {
   }
   buildClientParams(directory, config2, options) {
     const params = {
-      "-d": getCwd(join10(directory, config2.client.runtime.dir)),
+      "-d": getCwd(join12(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(join10(directory, config2.server.runtime.dir));
+        params["--watch-server-dir"] = getCwd(join12(directory, options.serverDir));
       }
     }
     if (options.ssl) {
@@ -2302,9 +2771,9 @@ var StartAction = class extends AbstractAction {
     }
     return this.buildParams(params);
   }
-  buildServerParams(directory, config2, options) {
+  buildServerParams(directory, _config, options) {
     const params = {
-      "-d": getCwd(join10(directory, config2.server.runtime.dir))
+      "-d": getCwd(join12(directory, options.serverDir))
     };
     if (options.watch) params["--watch"] = true;
     return this.buildParams(params);
@@ -2320,7 +2789,7 @@ var StartAction = class extends AbstractAction {
       ...process.env
     };
     dotenv.config({
-      path: resolve3(getCwd(join10(dir, ".env"))),
+      path: resolve3(getCwd(join12(dir, ".env"))),
       processEnv: rawEnv
     });
     const baseEnv = Object.entries(rawEnv).filter(
@@ -2354,9 +2823,10 @@ var UnpublishAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const manifest = await loadManifest(directory);
-    return withSpinner(Messages.UNPUBLISH_IN_PROGRESS(manifest.name), async () => {
-      await Registry.unpublish(manifest, directory);
-    });
+    return withSpinner(
+      () => Registry.unpublish(manifest, directory),
+      Messages.UNPUBLISH_IN_PROGRESS(manifest.name)
+    );
   }
 };
 
@@ -2365,6 +2835,7 @@ var AbstractCommand = class {
   constructor(action) {
     this.action = action;
   }
+  action;
   static {
     __name(this, "AbstractCommand");
   }
@@ -2383,12 +2854,17 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program2) {
-    program2.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) => {
+    program2.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);
@@ -2396,13 +2872,42 @@ var BuildCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/create.command.ts
+var CreateCommand = class extends AbstractCommand {
+  static {
+    __name(this, "CreateCommand");
+  }
+  load(program2) {
+    program2.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 {
     __name(this, "DevCommand");
   }
   load(program2) {
-    program2.command("dev").description("run your game in dev mode").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
+    program2.command("dev").description("run your game in dev mode").option("-d, --directory <directory>", "specify the working directory of the command").option("-c, --config <config>", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
@@ -2413,16 +2918,39 @@ var DevCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/editor.command.ts
+var EditorCommand = class extends AbstractCommand {
+  static {
+    __name(this, "EditorCommand");
+  }
+  load(program2) {
+    program2.command("editor [path]").description("start the editor").option("-d, --directory <directory>", "specify the working directory of the command").option(
+      "--open",
+      "open the editor on the default web browser (default: true if path is specified, false otherwise)"
+    ).option("--no-open", "do not open the editor on the default web browser").action(async (path, rawOptions) => {
+      const args = AbstractCommand.mapToInput({
+        path
+      });
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        open: rawOptions.open
+      });
+      await this.action.run(args, options);
+    });
+  }
+};
+
 // src/command/commands/generate.command.ts
 var GenerateCommand = class extends AbstractCommand {
   static {
     __name(this, "GenerateCommand");
   }
   load(program2) {
-    program2.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) => {
+    program2.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);
@@ -2436,7 +2964,7 @@ var InstallCommand = class extends AbstractCommand {
     __name(this, "InstallCommand");
   }
   load(program2) {
-    program2.command("install [names...]").alias("add").description("add Nanoforge components and systems to your project").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --lib", "install library instead of component/system", false).option(
+    program2.command("install [names...]").alias("add").description("add Nanoforge components and systems to your project").option("-d, --directory <directory>", "specify the working directory of the command").option("-l, --lib", "install library instead of component/system", false).option(
       "-s, --server",
       "install components/systems on server (default install on client)",
       false
@@ -2460,7 +2988,7 @@ var LoginCommand = class extends AbstractCommand {
     __name(this, "LoginCommand");
   }
   load(program2) {
-    program2.command("login").description("login to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --local", "login only for the project", false).option("-k, --api-key <key>", "api key for Nanoforge registry").action(async (rawOptions) => {
+    program2.command("login").description("login to Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").option("-l, --local", "login only for the project", false).option("-k, --api-key <key>", "api key for Nanoforge registry").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         local: rawOptions.local,
@@ -2477,7 +3005,7 @@ var LogoutCommand = class extends AbstractCommand {
     __name(this, "LogoutCommand");
   }
   load(program2) {
-    program2.command("logout").description("logout from Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --local", "logout only for the project").action(async (rawOptions) => {
+    program2.command("logout").description("logout from Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").option("-l, --local", "logout only for the project").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         local: rawOptions.local
@@ -2493,10 +3021,13 @@ var NewCommand = class extends AbstractCommand {
     __name(this, "NewCommand");
   }
   load(program2) {
-    program2.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]",
+    program2.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").option("--git", "generate git repository").option("--no-git", "do not generate git repository").option(
+      "--git-remote <gitRemote>",
+      "setup git remote to git repository (required if --git is used)"
+    ).option("--no-git-remote", "do not setup git remote to git repository").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         name: rawOptions.name,
@@ -2508,7 +3039,10 @@ var NewCommand = class extends AbstractCommand {
         initFunctions: rawOptions.initFunctions,
         skipInstall: rawOptions.skipInstall,
         docker: rawOptions.docker,
-        lint: rawOptions.lint
+        lint: rawOptions.lint,
+        editor: rawOptions.editor,
+        git: rawOptions.git,
+        gitRemote: rawOptions.gitRemote || void 0
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
     });
@@ -2521,7 +3055,7 @@ var PublishCommand = class extends AbstractCommand {
     __name(this, "PublishCommand");
   }
   load(program2) {
-    program2.command("publish").description("publish package to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").action(async (rawOptions) => {
+    program2.command("publish").description("publish package to Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory
       });
@@ -2536,11 +3070,13 @@ var StartCommand = class extends AbstractCommand {
     __name(this, "StartCommand");
   }
   load(program2) {
-    program2.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) => {
+    program2.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
@@ -2556,7 +3092,7 @@ var UnpublishCommand = class extends AbstractCommand {
     __name(this, "UnpublishCommand");
   }
   load(program2) {
-    program2.command("unpublish").description("unpublish package to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").action(async (rawOptions) => {
+    program2.command("unpublish").description("unpublish package to Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory
       });
@@ -2576,7 +3112,9 @@ var CommandLoader = class {
     new BuildCommand(new BuildAction()).load(program2);
     new StartCommand(new StartAction()).load(program2);
     new DevCommand(new DevAction()).load(program2);
+    new EditorCommand(new EditorAction()).load(program2);
     new GenerateCommand(new GenerateAction()).load(program2);
+    new CreateCommand(new CreateAction()).load(program2);
     new LoginCommand(new LoginAction()).load(program2);
     new LogoutCommand(new LogoutAction()).load(program2);
     new PublishCommand(new PublishAction()).load(program2);
@@ -2586,8 +3124,8 @@ var CommandLoader = class {
   static handleInvalidCommand(program2) {
     program2.on("command:*", () => {
       console.error(`
-${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program2.args.join(" "));
-      console.log(`See ${red6`--help`} for a list of available commands.
+${Prefixes.ERROR} Invalid command: ${red7`%s`}`, program2.args.join(" "));
+      console.log(`See ${red7`--help`} for a list of available commands.
 `);
       process.exit(1);
     });
@@ -2596,6 +3134,14 @@ ${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program2.args.join(" "));
 
 // src/bin/nf.ts
 var bootstrap = /* @__PURE__ */ __name(async () => {
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT", "SIGBREAK"];
+  signals.forEach((signal) => {
+    const listener = /* @__PURE__ */ __name(async () => {
+      process.off(signal, listener);
+      await treeKill(process.pid, signal);
+    }, "listener");
+    process.on(signal, listener);
+  });
   program.version(
     (await Promise.resolve().then(() => __toESM(require_package(), 1))).version ?? "unknown",
     "-v, --version",