@nanoforge-dev/cli 1.0.0

package/dist/nf.js

@@ -0,0 +1,1597 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module2) {
+    module2.exports = {
+      $schema: "https://json.schemastore.org/package.json",
+      name: "@nanoforge-dev/cli",
+      version: "1.0.0",
+      description: "NanoForge CLI",
+      keywords: [
+        "nanoforge",
+        "game",
+        "cli"
+      ],
+      homepage: "https://github.com/NanoForge-dev/CLI#readme",
+      bugs: "https://github.com/NanoForge-dev/cli/issues",
+      license: "MIT",
+      contributors: [
+        "Bill <timothe.jacquot@epitech.eu>",
+        "Exelo <exelo.corp@gmail.com>",
+        "Fexkoser <martin.fillon@epitech.eu>",
+        "Tchips <leo.outmizguine@epitech.eu>"
+      ],
+      files: [
+        "dist"
+      ],
+      bin: {
+        nf: "dist/nf.js"
+      },
+      type: "module",
+      directories: {
+        lib: "src"
+      },
+      repository: {
+        type: "git",
+        url: "git+https://github.com/NanoForge-dev/CLI.git"
+      },
+      funding: "",
+      scripts: {
+        build: "tsc --noEmit && tsup",
+        start: "node dist/nf.js",
+        lint: "prettier --check . && eslint --format=pretty src",
+        format: "prettier --write . && eslint --fix --format=pretty src",
+        prepack: "pnpm run build && pnpm run lint",
+        changelog: "git cliff --prepend ./CHANGELOG.md -u -c ./cliff.toml -r . --include-path '.'",
+        release: "cliff-jumper",
+        prepare: "husky"
+      },
+      dependencies: {
+        "@angular-devkit/schematics": "^21.0.1",
+        "@angular-devkit/schematics-cli": "^21.0.1",
+        "@inquirer/prompts": "^7.9.0",
+        "@nanoforge-dev/loader-client": "^1.0.1",
+        "@nanoforge-dev/loader-server": "^1.0.1",
+        "@nanoforge-dev/schematics": "^1.0.2",
+        ansis: "^4.2.0",
+        chokidar: "^4.0.3",
+        "class-transformer": "^0.5.1",
+        "class-validator": "^0.14.2",
+        "cli-table3": "^0.6.5",
+        commander: "^14.0.2",
+        "node-emoji": "^2.2.0",
+        ora: "^9.0.0",
+        "reflect-metadata": "^0.2.2"
+      },
+      devDependencies: {
+        "@commitlint/cli": "^20.1.0",
+        "@commitlint/config-conventional": "^20.0.0",
+        "@eslint/js": "^9.39.0",
+        "@favware/cliff-jumper": "^6.0.0",
+        "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+        "@types/inquirer": "^9.0.9",
+        "@types/node": "^24.10.1",
+        "@typescript-eslint/eslint-plugin": "^8.46.2",
+        "@typescript-eslint/parser": "^8.46.2",
+        eslint: "^9.39.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-formatter-pretty": "^7.0.0",
+        "eslint-plugin-prettier": "^5.5.4",
+        globals: "^16.5.0",
+        husky: "^9.1.7",
+        "lint-staged": "^16.2.6",
+        prettier: "^3.6.2",
+        taze: "^19.9.0",
+        tsup: "^8.5.1",
+        typescript: "^5.9.3",
+        "typescript-eslint": "^8.46.2"
+      },
+      packageManager: "pnpm@10.24.0",
+      engines: {
+        node: "24.11.1"
+      },
+      publishConfig: {
+        access: "public"
+      },
+      "lint-staged": {
+        "**/*.ts": [
+          "prettier --write"
+        ],
+        "src/**/*.ts": [
+          "eslint --fix"
+        ]
+      }
+    };
+  }
+});
+
+// src/bin/nf.ts
+import { program } from "commander";
+import "reflect-metadata";
+
+// src/lib/utils/local-binaries.ts
+import { existsSync } from "fs";
+import { join, posix } from "path";
+var localBinPathSegments = [process.cwd(), "node_modules", "@nanoforge-dev", "cli", "dist"];
+var localBinExists = /* @__PURE__ */ __name(() => {
+  return existsSync(join(...localBinPathSegments));
+}, "localBinExists");
+var loadLocalBinCommandLoader = /* @__PURE__ */ __name(async () => {
+  const commandsFile = await import(posix.join(...localBinPathSegments, "command.loader.js"));
+  return commandsFile.CommandLoader;
+}, "loadLocalBinCommandLoader");
+
+// src/command/command.loader.ts
+import { red as red6 } from "ansis";
+
+// src/lib/ui/messages.ts
+import { green } from "ansis";
+
+// src/lib/ui/emojis.ts
+import { get } from "node-emoji";
+var Emojis = {
+  HEART: get("heart"),
+  COFFEE: get("coffee"),
+  BEER: get("beer"),
+  BROKEN_HEART: get("broken_heart"),
+  CRYING: get("crying_cat_face"),
+  HEART_EYES: get("heart_eyes_cat"),
+  JOY: get("joy_cat"),
+  KISSING: get("kissing_cat"),
+  SCREAM: get("scream_cat"),
+  ROCKET: get("rocket"),
+  SMIRK: get("smirk_cat"),
+  RAISED_HANDS: get("raised_hands"),
+  POINT_RIGHT: get("point_right"),
+  SPARKLES: get("sparkles"),
+  BOOM: get("boom"),
+  PRAY: get("pray"),
+  WINE: get("wine_glass")
+};
+
+// src/lib/ui/messages.ts
+var Messages = {
+  BUILD_START: "NanoForge Build",
+  BUILD_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Building ${part}...`, "BUILD_PART_IN_PROGRESS"),
+  BUILD_NOTHING: "Nothing to build, terminated.",
+  BUILD_SUCCESS: `${Emojis.ROCKET}  Build succeeded !`,
+  BUILD_PART_FAILED: /* @__PURE__ */ __name((part, commandToRunManually) => `${Emojis.SCREAM}  Build of ${part} failed !
+In case you don't see any errors above, consider manually running the failed command ${commandToRunManually} to see more details on why it errored out.`, "BUILD_PART_FAILED"),
+  BUILD_FAILED: `${Emojis.SCREAM}  Build failed !`,
+  INSTALL_START: "NanoForge Installation",
+  INSTALL_NAMES_QUESTION: "Witch libraries do you want to install ?",
+  NEW_START: "NanoForge Project Creation",
+  NEW_SUCCESS: `${Emojis.ROCKET}  Project successfully created !`,
+  NEW_FAILED: `${Emojis.SCREAM}  Project creation failed !`,
+  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 ?",
+  NEW_STRICT_QUESTION: "Do you want to use types strict mode ?",
+  NEW_SERVER_QUESTION: "Do you want generate a server to create a multiplayer game ?",
+  NEW_SKIP_INSTALL_QUESTION: "Do you want to skip installation ?",
+  SCHEMATICS_START: "Schematics execution",
+  SCHEMATIC_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Executing schematic ${name}...`, "SCHEMATIC_IN_PROGRESS"),
+  SCHEMATIC_SUCCESS: /* @__PURE__ */ __name((name) => `${Emojis.ROCKET}  Schematic ${name} executed successfully !`, "SCHEMATIC_SUCCESS"),
+  SCHEMATIC_FAILED: /* @__PURE__ */ __name((name) => `${Emojis.SCREAM}  Schematic ${name} execution failed. See error below for more details.`, "SCHEMATIC_FAILED"),
+  PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS: `Installation in progress... ${Emojis.COFFEE}`,
+  PACKAGE_MANAGER_INSTALLATION_NOTHING: "Nothing to install, terminated.",
+  PACKAGE_MANAGER_INSTALLATION_SUCCEED: /* @__PURE__ */ __name((names) => names ? `${Emojis.ROCKET}  Packages successfully installed : ${names.map((name) => green(name)).join(", ")} !` : `${Emojis.ROCKET}  Packages successfully installed !`, "PACKAGE_MANAGER_INSTALLATION_SUCCEED"),
+  PACKAGE_MANAGER_INSTALLATION_FAILED: /* @__PURE__ */ __name((commandToRunManually) => `${Emojis.SCREAM}  Packages installation failed !
+In case you don't see any errors above, consider manually running the failed command ${commandToRunManually} to see more details on why it errored out.`, "PACKAGE_MANAGER_INSTALLATION_FAILED"),
+  RUN_START: "NanoForge Run",
+  RUN_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Running ${part}...`, "RUN_PART_IN_PROGRESS"),
+  RUN_PART_SUCCESS: /* @__PURE__ */ __name((part) => `${Emojis.ROCKET}  Run of ${part} terminated.`, "RUN_PART_SUCCESS"),
+  RUN_PART_FAILED: /* @__PURE__ */ __name((part) => `${Emojis.SCREAM}  Run of ${part} failed !`, "RUN_PART_FAILED"),
+  RUNNER_EXECUTION_ERROR: /* @__PURE__ */ __name((command) => `
+Failed to execute command: ${command}`, "RUNNER_EXECUTION_ERROR")
+};
+
+// src/lib/ui/prefixes.ts
+import { bgRgb } from "ansis";
+var Prefixes = {
+  INFO: bgRgb(60, 190, 100).bold.rgb(0, 0, 0)(" Info "),
+  ERROR: bgRgb(210, 0, 75).bold.rgb(0, 0, 0)(" Error ")
+};
+
+// src/action/actions/build.action.ts
+import * as ansis from "ansis";
+import * as process3 from "process";
+
+// src/lib/input/base-inputs.ts
+var getStringInput = /* @__PURE__ */ __name((input2, field) => {
+  const value = input2.get(field)?.value;
+  if (value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  throw new Error(`Invalid type for ${field}`);
+}, "getStringInput");
+var getStringInputWithDefault = /* @__PURE__ */ __name((input2, field, defaultValue) => {
+  return getStringInput(input2, field) ?? defaultValue;
+}, "getStringInputWithDefault");
+var getBooleanInput = /* @__PURE__ */ __name((input2, field) => {
+  const value = input2.get(field)?.value;
+  if (value === void 0) return void 0;
+  if (typeof value === "boolean") return value;
+  throw new Error(`Invalid type for ${field}`);
+}, "getBooleanInput");
+var getBooleanInputWithDefault = /* @__PURE__ */ __name((input2, field, defaultValue) => {
+  return getBooleanInput(input2, field) ?? defaultValue;
+}, "getBooleanInputWithDefault");
+var getArrayInput = /* @__PURE__ */ __name((input2, field) => {
+  const value = input2.get(field)?.value;
+  if (value === void 0) return void 0;
+  if (typeof value === "object" && Array.isArray(value)) return value;
+  throw new Error(`Invalid type for ${field}`);
+}, "getArrayInput");
+
+// src/lib/input/ask-inputs.ts
+var getInputOrAsk = /* @__PURE__ */ __name(async (baseInput, askCb, defaultValue) => {
+  if (baseInput !== void 0) return baseInput;
+  const res = await askCb();
+  if (res !== void 0) return res;
+  if (defaultValue !== void 0) return defaultValue;
+  throw new Error("No input provided");
+}, "getInputOrAsk");
+
+// src/lib/input/inputs/directory.input.ts
+function getDirectoryInput(inputs, withDefault = true) {
+  if (withDefault) return getStringInputWithDefault(inputs, "directory", ".");
+  return getStringInput(inputs, "directory");
+}
+__name(getDirectoryInput, "getDirectoryInput");
+
+// src/lib/input/inputs/config.input.ts
+var getConfigInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInputWithDefault(inputs, "config", ".");
+}, "getConfigInput");
+
+// src/lib/question/questions/confirm.question.ts
+import { confirm } from "@inquirer/prompts";
+
+// src/lib/utils/errors.ts
+var promptError = /* @__PURE__ */ __name((err) => {
+  if (err.name === "ExitPromptError") {
+    process.exit(1);
+  } else {
+    throw err;
+  }
+}, "promptError");
+
+// src/lib/question/questions/confirm.question.ts
+var askConfirm = /* @__PURE__ */ __name(async (question, baseOptions) => {
+  const options = {
+    default: false,
+    ...baseOptions ?? {}
+  };
+  return await confirm({
+    message: question,
+    default: options.default
+  }).catch(promptError);
+}, "askConfirm");
+
+// src/lib/question/questions/input.question.ts
+import { input } from "@inquirer/prompts";
+var askInput = /* @__PURE__ */ __name(async (question, baseOptions) => {
+  const options = {
+    required: false,
+    ...baseOptions ?? {}
+  };
+  return await input({
+    message: question,
+    required: options.required,
+    default: options.default
+  }).catch(promptError);
+}, "askInput");
+var askInputArray = /* @__PURE__ */ __name(async (question, baseOptions) => {
+  const options = {
+    required: false,
+    split: " ",
+    filter: true,
+    ...baseOptions ?? {}
+  };
+  const res = (await input({
+    message: question,
+    required: options.required,
+    default: options.default
+  }).catch(promptError)).split(options.split);
+  return options.filter ? res.filter((r) => r.length) : res;
+}, "askInputArray");
+
+// src/lib/question/questions/number.question.ts
+import { number } from "@inquirer/prompts";
+
+// src/lib/question/questions/select.question.ts
+import { checkbox, select } from "@inquirer/prompts";
+var askSelect = /* @__PURE__ */ __name(async (question, choices, baseOptions) => {
+  const options = {
+    loop: true,
+    ...baseOptions ?? {}
+  };
+  return await select({
+    message: question,
+    choices,
+    loop: options.loop,
+    default: options.default
+  }).catch(promptError);
+}, "askSelect");
+
+// src/lib/input/inputs/install/names.input.ts
+var getNamesInput = /* @__PURE__ */ __name((inputs) => {
+  return getArrayInput(inputs, "names");
+}, "getNamesInput");
+var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNamesInput(inputs),
+    () => askInputArray(Messages.INSTALL_NAMES_QUESTION, { required: true })
+  );
+}, "getInstallNamesInputOrAsk");
+
+// src/lib/runner/runner.factory.ts
+import { yellow } from "ansis";
+
+// src/lib/runner/abstract.runner.ts
+import { red } from "ansis";
+import { spawn } from "child_process";
+import * as process2 from "process";
+var AbstractRunner = class {
+  constructor(binary, args = []) {
+    this.binary = binary;
+    this.args = args;
+  }
+  static {
+    __name(this, "AbstractRunner");
+  }
+  async run(args, collect = false, cwd2 = process2.cwd(), env2, listeners, failSpinner) {
+    const options = {
+      cwd: cwd2,
+      stdio: collect ? "pipe" : "inherit",
+      shell: true,
+      env: { ...process2.env, ...env2 }
+    };
+    return new Promise((resolve, reject) => {
+      const child = spawn(
+        `${this.binary} ${[...this.args, ...args].join(" ")}`,
+        options
+      );
+      const res = [];
+      child.stdout?.on(
+        "data",
+        listeners?.onStdout ?? ((data) => res.push(data.toString().replace(/\r\n|\n/, "")))
+      );
+      child.stderr?.on(
+        "data",
+        listeners?.onStderr ?? ((data) => res.push(data.toString().replace(/\r\n|\n/, "")))
+      );
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(collect && res.length ? res.join("\n") : null);
+        } else {
+          if (failSpinner) failSpinner();
+          console.error(
+            red(Messages.RUNNER_EXECUTION_ERROR([this.binary, ...this.args, ...args].join(" ")))
+          );
+          if (res.length) {
+            console.error();
+            console.error(res.join("\n"));
+            console.error();
+          }
+          reject();
+        }
+      });
+    });
+  }
+  rawFullCommand(args) {
+    const commandArgs = [...this.args, ...args];
+    return `${this.binary} ${commandArgs.join(" ")}`;
+  }
+};
+
+// src/lib/runner/runners/bun.runner.ts
+var BunRunner = class extends AbstractRunner {
+  static {
+    __name(this, "BunRunner");
+  }
+  constructor() {
+    super("bun");
+  }
+};
+
+// src/lib/utils/path.ts
+import { join as join2 } from "path";
+var getCwd = /* @__PURE__ */ __name((directory) => {
+  return directory.startsWith("/") ? directory : join2(process.cwd(), directory);
+}, "getCwd");
+var getModulePath = /* @__PURE__ */ __name((name, removeLast = false) => {
+  const path = import.meta.resolve(name).replace(/^file:\/\//, "");
+  if (removeLast) return path.split("/").slice(0, -1).join("/");
+  return path;
+}, "getModulePath");
+
+// src/lib/runner/runners/schematic.runner.ts
+var SchematicRunner = class _SchematicRunner extends AbstractRunner {
+  static {
+    __name(this, "SchematicRunner");
+  }
+  static getModulePaths() {
+    return module.paths;
+  }
+  static findClosestSchematicsBinary() {
+    try {
+      return getModulePath("@angular-devkit/schematics-cli/bin/schematics.js");
+    } catch (e) {
+      console.error(e);
+      throw new Error("'schematics' binary path could not be found!");
+    }
+  }
+  constructor() {
+    super(`node`, [`"${_SchematicRunner.findClosestSchematicsBinary()}"`]);
+  }
+};
+
+// src/lib/runner/runner.factory.ts
+var RunnerFactory = class {
+  static {
+    __name(this, "RunnerFactory");
+  }
+  static create(runner) {
+    switch (runner) {
+      case 0 /* BUN */:
+        return new BunRunner();
+      case 1 /* SCHEMATIC */:
+        return new SchematicRunner();
+      default:
+        console.info(yellow`[WARN] Unsupported runner: ${runner}`);
+        throw Error(`Unsupported runner: ${runner}`);
+    }
+  }
+};
+
+// src/lib/package-manager/abstract.package-manager.ts
+import { bold, green as green2, red as red2, yellow as yellow2 } from "ansis";
+import ora from "ora";
+var SPINNER = /* @__PURE__ */ __name((message) => ora({
+  text: message
+}), "SPINNER");
+var FAIL_SPINNER = /* @__PURE__ */ __name((spinner) => () => spinner.fail(), "FAIL_SPINNER");
+var AbstractPackageManager = class {
+  constructor(runner) {
+    this.runner = runner;
+  }
+  static {
+    __name(this, "AbstractPackageManager");
+  }
+  async install(directory) {
+    const spinner = SPINNER(Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS);
+    spinner.start();
+    try {
+      const commandArgs = [this.cli.install, this.cli.silentFlag];
+      const collect = true;
+      await this.runner.run(
+        commandArgs,
+        collect,
+        getCwd(directory),
+        void 0,
+        void 0,
+        () => spinner.fail()
+      );
+      spinner.succeed();
+      this.printInstallSuccess();
+    } catch {
+      const commandArgs = [this.cli.install];
+      const commandToRun = this.runner.rawFullCommand(commandArgs);
+      this.printInstallFailure(commandToRun);
+    }
+  }
+  version() {
+    const commandArguments = ["--version"];
+    const collect = true;
+    return this.runner.run(commandArguments, collect);
+  }
+  addProduction(directory, dependencies) {
+    const command = [this.cli.add, this.cli.saveFlag];
+    return this.add(command, directory, dependencies);
+  }
+  addDevelopment(directory, dependencies) {
+    const command = [this.cli.add, this.cli.saveDevFlag];
+    return this.add(command, directory, dependencies);
+  }
+  async build(name, directory, entry, output, flags) {
+    if (!this.cli.build) throw new Error(`Package manager ${this.name} does not support building`);
+    const spinner = SPINNER(Messages.BUILD_PART_IN_PROGRESS(name));
+    spinner.start();
+    try {
+      const commandArgs = [
+        this.cli.build,
+        this.cli.silentFlag,
+        entry,
+        "--outdir",
+        output,
+        ...flags ?? []
+      ];
+      const collect = true;
+      await this.runner.run(
+        commandArgs,
+        collect,
+        getCwd(directory),
+        void 0,
+        void 0,
+        FAIL_SPINNER(spinner)
+      );
+      spinner.succeed();
+      return true;
+    } catch {
+      const commandArgs = [this.cli.install];
+      const commandToRun = this.runner.rawFullCommand(commandArgs);
+      console.error(red2(Messages.BUILD_PART_FAILED(name, bold(commandToRun))));
+      return false;
+    }
+  }
+  async run(name, directory, file, env2 = {}, flags = [], silent = false) {
+    if (!this.cli.run) throw new Error(`Package manager ${this.name} does not support running`);
+    try {
+      console.info(Messages.RUN_PART_IN_PROGRESS(name));
+      const commandArgs = [...flags, this.cli.run];
+      if (silent) commandArgs.push(this.cli.silentFlag);
+      commandArgs.push(file);
+      await this.runner.run(commandArgs, true, getCwd(directory), env2, {
+        onStdout: this.onRunStdout(name),
+        onStderr: this.onRunStderr(name)
+      });
+      console.info(Messages.RUN_PART_SUCCESS(name));
+      return true;
+    } catch {
+      console.error(red2(Messages.RUN_PART_FAILED(name)));
+      return false;
+    }
+  }
+  async add(args, directory, dependencies) {
+    if (!dependencies.length) {
+      console.info();
+      console.info(Messages.PACKAGE_MANAGER_INSTALLATION_NOTHING);
+      console.info();
+      return true;
+    }
+    const commandArguments = [...args, ...dependencies];
+    const spinner = SPINNER(Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS);
+    spinner.start();
+    try {
+      const collect = true;
+      await this.runner.run(
+        commandArguments,
+        collect,
+        getCwd(directory),
+        void 0,
+        void 0,
+        FAIL_SPINNER(spinner)
+      );
+      spinner.succeed();
+      this.printInstallSuccess(dependencies);
+      return true;
+    } catch {
+      spinner.fail();
+      const commandToRun = this.runner.rawFullCommand(commandArguments);
+      this.printInstallFailure(commandToRun);
+      return false;
+    }
+  }
+  printInstallSuccess(dependencies) {
+    console.info();
+    console.info(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(dependencies));
+    console.info();
+  }
+  printInstallFailure(command) {
+    console.error(red2(Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(bold(command))));
+  }
+  onRunStdout = /* @__PURE__ */ __name((name) => (chunk) => {
+    chunk.toString().replace(/\r\n|\n/g, "\n").replace(/^\n+|\n+$/g, "").split("\n").forEach((line) => {
+      const date = yellow2(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
+      const prompt = green2(`(${name}) INFO -`);
+      console.info(`${date} ${prompt} ${line}`);
+    });
+  }, "onRunStdout");
+  onRunStderr = /* @__PURE__ */ __name((name) => (chunk) => {
+    chunk.toString().replace(/\r\n|\n/g, "\n").replace(/^\n+|\n+$/g, "").split("\n").forEach((line) => {
+      const date = yellow2(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
+      const prompt = red2(`(${name}) ERROR -`);
+      console.error(`${date} ${prompt} ${line}`);
+    });
+  }, "onRunStderr");
+};
+
+// src/lib/package-manager/package-managers/bun.package-manager.ts
+var BunPackageManager = class extends AbstractPackageManager {
+  static {
+    __name(this, "BunPackageManager");
+  }
+  constructor() {
+    super(RunnerFactory.create(0 /* BUN */));
+  }
+  get name() {
+    return "bun" /* BUN */.toUpperCase();
+  }
+  get cli() {
+    return {
+      install: "install",
+      add: "add",
+      update: "update",
+      remove: "remove",
+      build: "build",
+      run: "run",
+      saveFlag: "--save",
+      saveDevFlag: "--dev",
+      silentFlag: "--silent"
+    };
+  }
+};
+
+// src/lib/package-manager/package-manager.factory.ts
+var PackageManagerFactory = class {
+  static {
+    __name(this, "PackageManagerFactory");
+  }
+  static create(name) {
+    switch (name) {
+      case "bun" /* BUN */:
+        return new BunPackageManager();
+      default:
+        throw new Error(`Package manager ${name} is not managed.`);
+    }
+  }
+};
+
+// src/lib/config/config.type.ts
+import { Expose, Type } from "class-transformer";
+import { IsBoolean, IsEnum, IsNotEmpty, IsPort, IsString, ValidateNested } from "class-validator";
+var BuildConfig = class {
+  static {
+    __name(this, "BuildConfig");
+  }
+  entryFile;
+  outDir;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "entryFile", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "outDir", 2);
+var RunConfig = class {
+  static {
+    __name(this, "RunConfig");
+  }
+  dir;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], RunConfig.prototype, "dir", 2);
+var ClientConfig = class {
+  static {
+    __name(this, "ClientConfig");
+  }
+  port;
+  gameExposurePort;
+  build;
+  runtime;
+};
+__decorateClass([
+  Expose(),
+  IsPort()
+], ClientConfig.prototype, "port", 2);
+__decorateClass([
+  Expose(),
+  IsPort()
+], ClientConfig.prototype, "gameExposurePort", 2);
+__decorateClass([
+  Expose(),
+  Type(() => BuildConfig),
+  ValidateNested()
+], ClientConfig.prototype, "build", 2);
+__decorateClass([
+  Expose(),
+  Type(() => RunConfig),
+  ValidateNested()
+], ClientConfig.prototype, "runtime", 2);
+var ServerConfig = class {
+  static {
+    __name(this, "ServerConfig");
+  }
+  enable;
+  port;
+  build;
+  runtime;
+};
+__decorateClass([
+  Expose(),
+  IsBoolean()
+], ServerConfig.prototype, "enable", 2);
+__decorateClass([
+  Expose(),
+  IsPort()
+], ServerConfig.prototype, "port", 2);
+__decorateClass([
+  Expose(),
+  Type(() => BuildConfig),
+  ValidateNested()
+], ServerConfig.prototype, "build", 2);
+__decorateClass([
+  Expose(),
+  Type(() => RunConfig),
+  ValidateNested()
+], ServerConfig.prototype, "runtime", 2);
+var Config = class {
+  static {
+    __name(this, "Config");
+  }
+  name;
+  language;
+  initFunctions;
+  client;
+  server;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], Config.prototype, "name", 2);
+__decorateClass([
+  Expose(),
+  IsEnum(["ts", "js"])
+], Config.prototype, "language", 2);
+__decorateClass([
+  Expose(),
+  IsBoolean()
+], Config.prototype, "initFunctions", 2);
+__decorateClass([
+  Expose(),
+  Type(() => ClientConfig),
+  ValidateNested()
+], Config.prototype, "client", 2);
+__decorateClass([
+  Expose(),
+  Type(() => ServerConfig),
+  ValidateNested()
+], Config.prototype, "server", 2);
+
+// src/lib/config/config-loader.ts
+import { plainToInstance } from "class-transformer";
+import { validate } from "class-validator";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join3 } from "path";
+
+// src/lib/utils/object.ts
+var isObject = /* @__PURE__ */ __name((item) => {
+  return item && typeof item === "object" && !Array.isArray(item);
+}, "isObject");
+var deepMerge = /* @__PURE__ */ __name((target, ...sources) => {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        deepMerge(target[key], source[key]);
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}, "deepMerge");
+
+// src/lib/config/config-defaults.ts
+var CONFIG_DEFAULTS = {
+  name: "nanoforge-app",
+  language: "ts",
+  initFunctions: true,
+  client: {
+    port: "3000",
+    gameExposurePort: "3001",
+    build: {
+      entryFile: "client/main.ts",
+      outDir: ".nanoforge/client"
+    },
+    runtime: {
+      dir: ".nanoforge/client"
+    }
+  },
+  server: {
+    enable: false,
+    port: "3002",
+    build: {
+      entryFile: "server/main.ts",
+      outDir: ".nanoforge/server"
+    },
+    runtime: {
+      dir: ".nanoforge/server"
+    }
+  }
+};
+
+// src/lib/config/config-loader.ts
+var config;
+var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
+  if (name) {
+    return join3(directory, name);
+  } else {
+    for (const n of ["nanoforge.config.json"]) {
+      const path = join3(directory, n);
+      if (existsSync2(path)) return path;
+    }
+    throw new Error(`Unsupported config: ${name}`);
+  }
+}, "getConfigPath");
+var loadConfig = /* @__PURE__ */ __name(async (directory, name) => {
+  if (config) return config;
+  let rawData;
+  const path = getConfigPath(directory, name);
+  if (!path) throw new Error("No config file found");
+  try {
+    rawData = deepMerge(CONFIG_DEFAULTS, JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    rawData = null;
+  }
+  if (!rawData) throw new Error(`Not able to read config file : ${path}`);
+  const data = plainToInstance(Config, rawData, {
+    excludeExtraneousValues: true
+  });
+  const errors = await validate(data);
+  if (errors.length > 0)
+    throw new Error(`Invalid config :
+${errors.toString().replace(/,/g, "\n")}`);
+  config = data;
+  return config;
+}, "loadConfig");
+
+// src/action/common/config.ts
+var getConfig = /* @__PURE__ */ __name((inputs, dir) => {
+  return loadConfig(dir, getConfigInput(inputs));
+}, "getConfig");
+
+// src/action/abstract.action.ts
+var AbstractAction = class {
+  static {
+    __name(this, "AbstractAction");
+  }
+};
+
+// src/action/actions/build.action.ts
+var BuildAction = class extends AbstractAction {
+  static {
+    __name(this, "BuildAction");
+  }
+  async handle(_args, options) {
+    console.info(Messages.BUILD_START);
+    console.info();
+    try {
+      const directory = getDirectoryInput(options);
+      const config2 = await getConfig(options, directory);
+      const client = getPart(
+        config2.client.build,
+        options.get("clientDirectory")?.value,
+        "client"
+      );
+      let res = await buildPart("Client", client, directory);
+      if (config2.server.enable) {
+        const server = getPart(
+          config2.server.build,
+          options.get("serverDirectory")?.value,
+          "server"
+        );
+        res = await buildPart("Server", server, directory) ? res : false;
+      }
+      console.info();
+      if (!res) console.info(Messages.BUILD_FAILED);
+      else console.info(Messages.BUILD_SUCCESS);
+      process3.exit(0);
+    } catch (e) {
+      console.error(e);
+      process3.exit(1);
+    }
+  }
+};
+var getPart = /* @__PURE__ */ __name((config2, directoryOption, target) => {
+  return {
+    entry: config2.entryFile,
+    output: directoryOption || config2.outDir,
+    target
+  };
+}, "getPart");
+var buildPart = /* @__PURE__ */ __name(async (name, part, directory) => {
+  const packageManagerName = "bun" /* BUN */;
+  try {
+    const packageManager = PackageManagerFactory.create(packageManagerName);
+    return await packageManager.build(name, directory, part.entry, part.output, [
+      "--asset-naming",
+      "[name].[ext]",
+      "--target",
+      part.target === "client" ? "browser" : "node"
+    ]);
+  } catch (error3) {
+    if (error3 && error3.message) {
+      console.error(ansis.red(error3.message));
+    }
+    return false;
+  }
+}, "buildPart");
+
+// src/action/actions/generate.action.ts
+import * as console2 from "console";
+
+// src/lib/schematics/abstract.collection.ts
+var AbstractCollection = class {
+  constructor(collection, runner, cwd2) {
+    this.collection = collection;
+    this.runner = runner;
+    this.cwd = cwd2;
+  }
+  static {
+    __name(this, "AbstractCollection");
+  }
+  async execute(name, options, flags, failSpinner) {
+    const command = this.buildCommandLine(name, options, flags);
+    await this.runner.run(
+      command,
+      true,
+      this.cwd ? getCwd(this.cwd) : void 0,
+      void 0,
+      void 0,
+      failSpinner
+    );
+  }
+  buildCommandLine(name, options, flags = []) {
+    return [`${this.collection}:${name}`, ...flags, ...this.buildOptions(options)];
+  }
+  buildOptions(options) {
+    return options.reduce(
+      (old, option) => [...old, ...option.toCommandString()],
+      []
+    );
+  }
+};
+
+// src/lib/schematics/nanoforge.collection.ts
+var NanoforgeCollection = class _NanoforgeCollection extends AbstractCollection {
+  static {
+    __name(this, "NanoforgeCollection");
+  }
+  static schematics = [
+    {
+      name: "application",
+      alias: "application",
+      description: "Generate a new application"
+    },
+    {
+      name: "configuration",
+      alias: "config",
+      description: "Generate a CLI configuration file"
+    },
+    {
+      name: "part-base",
+      alias: "base",
+      description: "Generate a NanoForge Part Base"
+    },
+    {
+      name: "part-main",
+      alias: "main",
+      description: "Generate a NanoForge Part Main file"
+    }
+  ];
+  constructor(runner, cwd2) {
+    super("@nanoforge-dev/schematics", runner, cwd2);
+  }
+  async execute(name, options, flags, failSpinner) {
+    const schematic = this.validate(name);
+    await super.execute(schematic, options, flags, failSpinner);
+  }
+  getSchematics() {
+    return _NanoforgeCollection.schematics;
+  }
+  validate(name) {
+    const schematic = _NanoforgeCollection.schematics.find(
+      (s) => s.name === name || s.alias === name
+    );
+    if (schematic === void 0 || schematic === null) {
+      throw new Error(
+        `Invalid schematic "${name}". Please, ensure that "${name}" exists in this collection.`
+      );
+    }
+    return schematic.name;
+  }
+};
+
+// src/lib/schematics/collection.factory.ts
+var CollectionFactory = class {
+  static {
+    __name(this, "CollectionFactory");
+  }
+  static create(collection, directory) {
+    const schematicRunner = RunnerFactory.create(1 /* SCHEMATIC */);
+    if (collection === "@nanoforge-dev/schematics" /* NANOFORGE */) {
+      return new NanoforgeCollection(schematicRunner, directory);
+    } else {
+      return new NanoforgeCollection(schematicRunner, directory);
+    }
+  }
+};
+
+// src/lib/utils/formatting.ts
+var toKebabCase = /* @__PURE__ */ __name((str) => {
+  return str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}, "toKebabCase");
+
+// src/lib/schematics/schematic.option.ts
+var SchematicOption = class {
+  constructor(name, value) {
+    this.name = name;
+    this.value = value;
+  }
+  static {
+    __name(this, "SchematicOption");
+  }
+  get normalizedName() {
+    return toKebabCase(this.name);
+  }
+  toCommandString(prefix) {
+    const normalizedName = `${prefix ? `${prefix}.` : ""}${this.normalizedName}`;
+    if (typeof this.value === "string") {
+      if (this.name === "name") {
+        return [`--${normalizedName}=${this.format()}`];
+      } else if (this.name === "version" || this.name === "path") {
+        return [`--${normalizedName}=${this.value}`];
+      } else {
+        return [`--${normalizedName}="${this.value}"`];
+      }
+    } else if (typeof this.value === "boolean") {
+      const str = normalizedName;
+      return this.value ? [`--${str}`] : [`--no-${str}`];
+    } else if (Array.isArray(this.value)) {
+      return this.value.reduce(
+        (old, option) => [
+          ...old,
+          ...option.toCommandString(normalizedName)
+        ],
+        []
+      );
+    } else {
+      return [`--${normalizedName}=${this.value}`];
+    }
+  }
+  format() {
+    return toKebabCase(this.value).split("").reduce((content, char) => {
+      if (char === "(" || char === ")" || char === "[" || char === "]") {
+        return `${content}\\${char}`;
+      }
+      return `${content}${char}`;
+    }, "");
+  }
+};
+
+// src/action/common/spinner.ts
+import ora2 from "ora";
+var getSpinner = /* @__PURE__ */ __name((message) => ora2({
+  text: message
+}), "getSpinner");
+
+// src/action/common/schematics.ts
+var executeSchematic = /* @__PURE__ */ __name(async (name, collection, schematicName, options) => {
+  const spinner = getSpinner(Messages.SCHEMATIC_IN_PROGRESS(name));
+  spinner.start();
+  await collection.execute(
+    schematicName,
+    mapSchematicOptions(options),
+    void 0,
+    () => spinner.fail(Messages.SCHEMATIC_FAILED(name))
+  );
+  spinner.succeed(Messages.SCHEMATIC_SUCCESS(name));
+}, "executeSchematic");
+var mapSchematicOptions = /* @__PURE__ */ __name((inputs) => {
+  return Object.entries(inputs).reduce((old, [key, value]) => {
+    if (value === void 0) return old;
+    return [
+      ...old,
+      new SchematicOption(key, typeof value === "object" ? mapSchematicOptions(value) : value)
+    ];
+  }, []);
+}, "mapSchematicOptions");
+
+// src/action/actions/generate.action.ts
+var GenerateAction = class extends AbstractAction {
+  static {
+    __name(this, "GenerateAction");
+  }
+  async handle(_args, options) {
+    console2.info(Messages.NEW_START);
+    try {
+      const directory = getDirectoryInput(options);
+      const config2 = await getConfig(options, directory);
+      const values = await getSchemaValues(config2);
+      await generateFiles(values, directory);
+      console2.info();
+      console2.info(Messages.NEW_SUCCESS);
+      process.exit(0);
+    } catch (e) {
+      console2.error(Messages.NEW_FAILED);
+      console2.error(e);
+      process.exit(1);
+    }
+  }
+};
+var getSchemaValues = /* @__PURE__ */ __name(async (config2) => {
+  return {
+    name: config2.name,
+    directory: ".",
+    language: config2.language,
+    server: config2.server.enable,
+    initFunctions: config2.initFunctions
+  };
+}, "getSchemaValues");
+var generateFiles = /* @__PURE__ */ __name(async (values, directory) => {
+  console2.info();
+  const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+  console2.info();
+  console2.info(Messages.SCHEMATICS_START);
+  console2.info();
+  await executeSchematic("Client main file", collection, "part-main", {
+    name: values.name,
+    part: "client",
+    directory: values.directory,
+    language: values.language,
+    initFunctions: values.initFunctions
+  });
+  if (values.server) {
+    await executeSchematic("Server main file", collection, "part-main", {
+      name: values.name,
+      part: "server",
+      directory: values.directory,
+      language: values.language,
+      initFunctions: values.initFunctions
+    });
+  }
+}, "generateFiles");
+
+// src/action/actions/install.action.ts
+import * as ansis2 from "ansis";
+import * as process4 from "process";
+var InstallAction = class extends AbstractAction {
+  static {
+    __name(this, "InstallAction");
+  }
+  async handle(args, options) {
+    console.info(Messages.INSTALL_START);
+    console.info();
+    try {
+      const names = await getInstallNamesInputOrAsk(args);
+      const directory = getDirectoryInput(options);
+      await installPackages(names, directory);
+      process4.exit(0);
+    } catch (e) {
+      console.error(e);
+      process4.exit(1);
+    }
+  }
+};
+var installPackages = /* @__PURE__ */ __name(async (names, directory) => {
+  const packageManagerName = "bun" /* BUN */;
+  try {
+    const packageManager = PackageManagerFactory.create(packageManagerName);
+    await packageManager.addProduction(directory, names);
+  } catch (error3) {
+    if (error3 && error3.message) {
+      console.error(ansis2.red(error3.message));
+    }
+  }
+}, "installPackages");
+
+// src/lib/input/inputs/new/init-functions.input.ts
+var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "initFunctions", false);
+}, "getNewInitFunctionsWithDefault");
+
+// src/lib/input/inputs/new/language.input.ts
+var getLanguageInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "language");
+}, "getLanguageInput");
+var getNewLanguageInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getLanguageInput(inputs),
+    () => askSelect(Messages.NEW_LANGUAGE_QUESTION, [{ value: "ts" }, { value: "js" }], {
+      default: "ts"
+    })
+  );
+}, "getNewLanguageInputOrAsk");
+
+// 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");
+}, "getPackageManagerInput");
+var getNewPackageManagerInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getPackageManagerInput(inputs),
+    () => askSelect(
+      Messages.NEW_PACKAGE_MANAGER_QUESTION,
+      [{ value: "npm" }, { value: "yarn" }, { value: "pnpm" }, { value: "bun" }],
+      {
+        default: "npm"
+      }
+    )
+  );
+}, "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");
+}, "getNewServerInput");
+var getNewServerOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewServerInput(inputs),
+    () => askConfirm(Messages.NEW_SERVER_QUESTION, { default: false })
+  );
+}, "getNewServerOrAsk");
+
+// src/lib/input/inputs/new/skip-install.input.ts
+var getNewSkipInstallInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "skipInstall");
+}, "getNewSkipInstallInput");
+var getNewSkipInstallOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewSkipInstallInput(inputs),
+    () => askConfirm(Messages.NEW_SKIP_INSTALL_QUESTION, { default: false })
+  );
+}, "getNewSkipInstallOrAsk");
+
+// src/lib/input/inputs/new/strict.input.ts
+var getNewStrictInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "strict");
+}, "getNewStrictInput");
+var getNewStrictOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewStrictInput(inputs),
+    () => askConfirm(Messages.NEW_STRICT_QUESTION, { default: true })
+  );
+}, "getNewStrictOrAsk");
+
+// src/action/actions/new.action.ts
+var NewAction = class extends AbstractAction {
+  static {
+    __name(this, "NewAction");
+  }
+  async handle(_args, options) {
+    console.info(Messages.NEW_START);
+    try {
+      const directory = getDirectoryInput(options);
+      const values = await getSchemaValues2(options);
+      await generateApplicationFiles(values, directory);
+      console.info();
+      console.info(Messages.NEW_SUCCESS);
+      process.exit(0);
+    } catch {
+      console.error(Messages.NEW_FAILED);
+      process.exit(1);
+    }
+  }
+};
+var getSchemaValues2 = /* @__PURE__ */ __name(async (inputs) => {
+  return {
+    name: await getNewNameInputOrAsk(inputs),
+    directory: getNewPathInput(inputs),
+    packageManager: await getNewPackageManagerInputOrAsk(inputs),
+    language: await getNewLanguageInputOrAsk(inputs),
+    strict: await getNewStrictOrAsk(inputs),
+    server: await getNewServerOrAsk(inputs),
+    initFunctions: getNewInitFunctionsWithDefault(inputs),
+    skipInstall: await getNewSkipInstallOrAsk(inputs)
+  };
+}, "getSchemaValues");
+var generateApplicationFiles = /* @__PURE__ */ __name(async (values, directory) => {
+  console.info();
+  const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+  console.info();
+  console.info(Messages.SCHEMATICS_START);
+  console.info();
+  await executeSchematic("Application", collection, "application", {
+    name: values.name,
+    directory: values.directory,
+    packageManager: values.packageManager,
+    language: values.language,
+    strict: values.strict,
+    server: values.server
+  });
+  await executeSchematic("Configuration", collection, "configuration", {
+    name: values.name,
+    directory: values.directory,
+    server: values.server
+  });
+  await executeSchematic("Base Client", collection, "part-base", {
+    name: values.name,
+    part: "client",
+    directory: values.directory,
+    language: values.language,
+    initFunctions: values.initFunctions
+  });
+  await executeSchematic("Client main file", collection, "part-main", {
+    name: values.name,
+    part: "client",
+    directory: values.directory,
+    language: values.language,
+    initFunctions: values.initFunctions
+  });
+  if (values.server) {
+    await executeSchematic("Base server", collection, "part-base", {
+      name: values.name,
+      part: "server",
+      directory: values.directory,
+      language: values.language,
+      initFunctions: values.initFunctions
+    });
+    await executeSchematic("Server main file", collection, "part-main", {
+      name: values.name,
+      part: "server",
+      directory: values.directory,
+      language: values.language,
+      initFunctions: values.initFunctions
+    });
+  }
+}, "generateApplicationFiles");
+
+// src/action/actions/start.action.ts
+import * as ansis3 from "ansis";
+import * as console3 from "console";
+import { join as join4 } from "path";
+var StartAction = class extends AbstractAction {
+  static {
+    __name(this, "StartAction");
+  }
+  async handle(_args, options) {
+    console3.info(Messages.RUN_START);
+    console3.info();
+    try {
+      const directory = getDirectoryInput(options);
+      const config2 = await getConfig(options, directory);
+      const clientDir = config2.client.runtime.dir;
+      const serverDir = config2.server.runtime.dir;
+      const clientPort = getStringInputWithDefault(options, "clientPort", config2.client.port);
+      await Promise.all([
+        config2.server.enable ? this.startServer(directory, serverDir) : void 0,
+        this.startClient(clientPort, directory, clientDir)
+      ]);
+      process.exit(0);
+    } catch (e) {
+      console3.error(e);
+      process.exit(1);
+    }
+  }
+  async startClient(port, directory, gameDir) {
+    const path = getModulePath("@nanoforge-dev/loader-client/package.json", true);
+    return runPart("Client", path, {
+      PORT: port,
+      GAME_DIR: getCwd(join4(directory, gameDir))
+    });
+  }
+  startServer(directory, gameDir) {
+    const path = getModulePath("@nanoforge-dev/loader-server/package.json", true);
+    return runPart("Server", path, {
+      GAME_DIR: getCwd(join4(directory, gameDir))
+    });
+  }
+};
+var runPart = /* @__PURE__ */ __name(async (part, directory, env2, flags) => {
+  const packageManagerName = "bun" /* BUN */;
+  try {
+    const packageManager = PackageManagerFactory.create(packageManagerName);
+    await packageManager.run(part, directory, "start", env2, flags, true);
+  } catch (error3) {
+    if (error3 && error3.message) {
+      console3.error(ansis3.red(error3.message));
+    }
+  }
+}, "runPart");
+
+// src/command/abstract.command.ts
+var AbstractCommand = class {
+  constructor(action) {
+    this.action = action;
+  }
+  static {
+    __name(this, "AbstractCommand");
+  }
+};
+
+// src/command/commands/build.command.ts
+var BuildCommand = class extends AbstractCommand {
+  static {
+    __name(this, "BuildCommand");
+  }
+  load(program2) {
+    program2.command("build").description("build your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").option("--client-outDir [clientDirectory]", "specify the output directory of the client").option("--server-outDir [serverDirectory]", "specify the output directory of the server").action(async (rawOptions) => {
+      const options = /* @__PURE__ */ new Map();
+      options.set("directory", { value: rawOptions.directory });
+      options.set("config", { value: rawOptions.config });
+      options.set("clientDirectory", { value: rawOptions.clientOutDir });
+      options.set("serverDirectory", { value: rawOptions.serverOutDir });
+      const args = /* @__PURE__ */ new Map();
+      await this.action.handle(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 directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").action(async (rawOptions) => {
+      const options = /* @__PURE__ */ new Map();
+      options.set("directory", { value: rawOptions.directory });
+      options.set("config", { value: rawOptions.config });
+      const args = /* @__PURE__ */ new Map();
+      await this.action.handle(args, options);
+    });
+  }
+};
+
+// src/command/commands/install.command.ts
+var InstallCommand = class extends AbstractCommand {
+  static {
+    __name(this, "InstallCommand");
+  }
+  load(program2) {
+    program2.command("install [names...]").alias("add").description("add NanoForge library to your project").option("-d, --directory [directory]", "specify the directory of your project").action(async (names, rawOptions) => {
+      const options = /* @__PURE__ */ new Map();
+      options.set("directory", { value: rawOptions.directory });
+      const args = /* @__PURE__ */ new Map();
+      args.set("names", { value: names.length ? names : void 0 });
+      await this.action.handle(args, options);
+    });
+  }
+};
+
+// src/command/commands/new.command.ts
+var NewCommand = class extends AbstractCommand {
+  static {
+    __name(this, "NewCommand");
+  }
+  load(program2) {
+    program2.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the directory of your project").option("--name [name]", "specify the name of your project").option("--path [path]", "specify the path of your 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").action(async (rawOptions) => {
+      const options = /* @__PURE__ */ new Map();
+      options.set("directory", { value: rawOptions.directory });
+      options.set("name", { value: rawOptions.name });
+      options.set("path", { value: rawOptions.path });
+      options.set("packageManager", { value: rawOptions.packageManager });
+      options.set("language", { value: rawOptions.language });
+      options.set("strict", { value: rawOptions.strict });
+      options.set("server", { value: rawOptions.server });
+      options.set("initFunctions", { value: rawOptions.initFunctions });
+      options.set("skipInstall", { value: rawOptions.skipInstall });
+      const args = /* @__PURE__ */ new Map();
+      await this.action.handle(args, options);
+    });
+  }
+};
+
+// src/command/commands/start.command.ts
+var StartCommand = class extends AbstractCommand {
+  static {
+    __name(this, "StartCommand");
+  }
+  load(program2) {
+    program2.command("start").description("start your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").option(
+      "-p, --client-port [clientPort]",
+      "specify the port of the loader (the website to load the game)"
+    ).option("--game-exposure-port [gameExposurePort]", "specify the port of the game exposure").option("--server-port [serverPort]", "specify the port of the server").action(async (rawOptions) => {
+      const options = /* @__PURE__ */ new Map();
+      options.set("directory", { value: rawOptions.directory });
+      options.set("config", { value: rawOptions.config });
+      options.set("clientPort", { value: rawOptions.clientPort });
+      options.set("gameExposurePort", {
+        value: rawOptions.gameExposurePort
+      });
+      options.set("serverPort", { value: rawOptions.serverPort });
+      const args = /* @__PURE__ */ new Map();
+      await this.action.handle(args, options);
+    });
+  }
+};
+
+// src/command/command.loader.ts
+var CommandLoader = class {
+  static {
+    __name(this, "CommandLoader");
+  }
+  static async load(program2) {
+    new BuildCommand(new BuildAction()).load(program2);
+    new GenerateCommand(new GenerateAction()).load(program2);
+    new InstallCommand(new InstallAction()).load(program2);
+    new NewCommand(new NewAction()).load(program2);
+    new StartCommand(new StartAction()).load(program2);
+    this.handleInvalidCommand(program2);
+  }
+  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.
+`);
+      process.exit(1);
+    });
+  }
+};
+
+// src/bin/nf.ts
+var bootstrap = /* @__PURE__ */ __name(async () => {
+  program.version(
+    (await Promise.resolve().then(() => __toESM(require_package(), 1))).version ?? "unknown",
+    "-v, --version",
+    "output the current version"
+  ).usage("<command> [options]").helpOption("-h, --help", "output usage information");
+  if (localBinExists()) {
+    const localCommandLoader = await loadLocalBinCommandLoader();
+    await localCommandLoader.load(program);
+  } else {
+    await CommandLoader.load(program);
+  }
+  await program.parseAsync(process.argv);
+  if (!process.argv.slice(2).length) {
+    program.outputHelp();
+  }
+}, "bootstrap");
+bootstrap().then();