@nanoforge-dev/cli 1.0.0 → 1.1.1

package/dist/nf.js

@@ -40,7 +40,7 @@ var require_package = __commonJS({
     module2.exports = {
       $schema: "https://json.schemastore.org/package.json",
       name: "@nanoforge-dev/cli",
-      version: "1.0.0",
+      version: "1.1.1",
       description: "NanoForge CLI",
       keywords: [
         "nanoforge",
@@ -79,58 +79,60 @@ var require_package = __commonJS({
         prepack: "pnpm run build && pnpm run lint",
         changelog: "git cliff --prepend ./CHANGELOG.md -u -c ./cliff.toml -r . --include-path '.'",
         release: "cliff-jumper",
+        test: "pnpm run test:unit && pnpm run test:e2e",
+        "test:unit": "vitest run -c vitest.config.ts",
+        "test:unit:watch": "vitest -c vitest.config.ts",
+        "test:e2e": "vitest run -c vitest.config.e2e.ts",
+        "test:e2e:watch": "vitest -c vitest.config.e2e.ts",
+        "test:coverage": "pnpm run test:unit --coverage && pnpm run test:e2e",
         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"
+        "@angular-devkit/schematics": "catalog:schematics",
+        "@angular-devkit/schematics-cli": "catalog:schematics",
+        "@inquirer/prompts": "catalog:cli",
+        "@nanoforge-dev/loader-client": "catalog:loader",
+        "@nanoforge-dev/loader-server": "catalog:loader",
+        "@nanoforge-dev/schematics": "catalog:schematics",
+        ansis: "catalog:cli",
+        bun: "catalog:core",
+        chokidar: "catalog:libs",
+        "class-transformer": "catalog:libs",
+        "class-validator": "catalog:libs",
+        commander: "catalog:cli",
+        "node-emoji": "catalog:cli",
+        ora: "catalog:cli",
+        "reflect-metadata": "catalog:libs"
       },
       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"
+        "@commitlint/cli": "catalog:ci",
+        "@commitlint/config-conventional": "catalog:ci",
+        "@favware/cliff-jumper": "catalog:ci",
+        "@nanoforge-dev/actions": "catalog:ci",
+        "@nanoforge-dev/utils-eslint-config": "catalog:lint",
+        "@nanoforge-dev/utils-prettier-config": "catalog:lint",
+        "@trivago/prettier-plugin-sort-imports": "catalog:lint",
+        "@types/inquirer": "catalog:cli",
+        "@types/node": "catalog:core",
+        "@vitest/coverage-v8": "catalog:tests",
+        eslint: "catalog:lint",
+        husky: "catalog:ci",
+        "lint-staged": "catalog:ci",
+        prettier: "catalog:lint",
+        tsup: "catalog:build",
+        typescript: "catalog:build",
+        vitest: "catalog:tests"
       },
-      packageManager: "pnpm@10.24.0",
+      packageManager: "pnpm@10.28.1",
       engines: {
-        node: "24.11.1"
+        node: "25"
       },
       publishConfig: {
         access: "public"
       },
       "lint-staged": {
-        "**/*.ts": [
-          "prettier --write"
+        "**": [
+          "prettier --ignore-unknown --write"
         ],
         "src/**/*.ts": [
           "eslint --fix"
@@ -157,7 +159,7 @@ var loadLocalBinCommandLoader = /* @__PURE__ */ __name(async () => {
 }, "loadLocalBinCommandLoader");
 
 // src/command/command.loader.ts
-import { red as red6 } from "ansis";
+import { red as red8 } from "ansis";
 
 // src/lib/ui/messages.ts
 import { green } from "ansis";
@@ -187,7 +189,9 @@ var Emojis = {
 // 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_WATCH_START: "Start watching mode",
+  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_NOTHING: "Nothing to build, terminated.",
   BUILD_SUCCESS: `${Emojis.ROCKET}  Build succeeded !`,
   BUILD_PART_FAILED: /* @__PURE__ */ __name((part, commandToRunManually) => `${Emojis.SCREAM}  Build of ${part} failed !
@@ -204,8 +208,16 @@ In case you don't see any errors above, consider manually running the failed com
   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 ?",
+  GENERATE_START: "NanoForge Generate",
+  GENERATE_WATCH_START: "Start watching mode",
+  GENERATE_SUCCESS: `${Emojis.ROCKET}  Generate succeeded !`,
+  GENERATE_FAILED: `${Emojis.SCREAM}  Generate failed !`,
+  DEV_START: "NanoForge Dev mode",
+  DEV_SUCCESS: "Dev mode ended",
+  DEV_FAILED: `${Emojis.SCREAM}  Dev failed !`,
   SCHEMATICS_START: "Schematics execution",
   SCHEMATIC_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Executing schematic ${name}...`, "SCHEMATIC_IN_PROGRESS"),
+  SCHEMATIC_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Update watched. Executing schematic ${name}...`, "SCHEMATIC_WATCH_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}`,
@@ -230,7 +242,9 @@ var Prefixes = {
 
 // src/action/actions/build.action.ts
 import * as ansis from "ansis";
-import * as process3 from "process";
+import { watch } from "chokidar";
+import * as console2 from "console";
+import { dirname, join as join4 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -279,6 +293,16 @@ 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/question/questions/confirm.question.ts
 import { confirm } from "@inquirer/prompts";
 
@@ -360,6 +384,10 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
+// src/lib/package-manager/package-manager.factory.ts
+import fs2 from "fs";
+import { resolve as resolve2 } from "path";
+
 // src/lib/runner/runner.factory.ts
 import { yellow } from "ansis";
 
@@ -382,7 +410,7 @@ var AbstractRunner = class {
       shell: true,
       env: { ...process2.env, ...env2 }
     };
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       const child = spawn(
         `${this.binary} ${[...this.args, ...args].join(" ")}`,
         options
@@ -398,7 +426,7 @@ var AbstractRunner = class {
       );
       child.on("close", (code) => {
         if (code === 0) {
-          resolve(collect && res.length ? res.join("\n") : null);
+          resolve3(collect && res.length ? res.join("\n") : null);
         } else {
           if (failSpinner) failSpinner();
           console.error(
@@ -431,15 +459,59 @@ var BunRunner = class extends AbstractRunner {
 };
 
 // src/lib/utils/path.ts
-import { join as join2 } from "path";
+import fs from "fs";
+import { join as join2, resolve } from "path";
 var getCwd = /* @__PURE__ */ __name((directory) => {
-  return directory.startsWith("/") ? directory : join2(process.cwd(), directory);
+  return resolve(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");
+var resolveCLINodeBinaryPath = /* @__PURE__ */ __name((name) => {
+  let base = join2(getModulePath(".", true), "..");
+  while (base.length >= 1) {
+    const path = join2(base, "node_modules", ".bin", name);
+    try {
+      fs.accessSync(path);
+      return path;
+    } catch {
+      base = join2(base, "..");
+    }
+  }
+  throw new Error("Could not find module path");
+}, "resolveCLINodeBinaryPath");
+
+// src/lib/runner/runners/local-bun.runner.ts
+var LocalBunRunner = class extends AbstractRunner {
+  static {
+    __name(this, "LocalBunRunner");
+  }
+  constructor() {
+    super(resolveCLINodeBinaryPath("bun"));
+  }
+};
+
+// src/lib/runner/runners/npm.runner.ts
+var NpmRunner = class extends AbstractRunner {
+  static {
+    __name(this, "NpmRunner");
+  }
+  constructor() {
+    super("npm");
+  }
+};
+
+// src/lib/runner/runners/pnpm.runner.ts
+var PnpmRunner = class extends AbstractRunner {
+  static {
+    __name(this, "PnpmRunner");
+  }
+  constructor() {
+    super("pnpm");
+  }
+};
 
 // src/lib/runner/runners/schematic.runner.ts
 var SchematicRunner = class _SchematicRunner extends AbstractRunner {
@@ -462,6 +534,16 @@ var SchematicRunner = class _SchematicRunner extends AbstractRunner {
   }
 };
 
+// src/lib/runner/runners/yarn.runner.ts
+var YarnRunner = class extends AbstractRunner {
+  static {
+    __name(this, "YarnRunner");
+  }
+  constructor() {
+    super("yarn");
+  }
+};
+
 // src/lib/runner/runner.factory.ts
 var RunnerFactory = class {
   static {
@@ -471,8 +553,16 @@ var RunnerFactory = class {
     switch (runner) {
       case 0 /* BUN */:
         return new BunRunner();
-      case 1 /* SCHEMATIC */:
+      case 1 /* LOCAL_BUN */:
+        return new LocalBunRunner();
+      case 2 /* NPM */:
+        return new NpmRunner();
+      case 3 /* PNPM */:
+        return new PnpmRunner();
+      case 4 /* SCHEMATIC */:
         return new SchematicRunner();
+      case 5 /* YARN */:
+        return new YarnRunner();
       default:
         console.info(yellow`[WARN] Unsupported runner: ${runner}`);
         throw Error(`Unsupported runner: ${runner}`);
@@ -529,9 +619,11 @@ var AbstractPackageManager = class {
     const command = [this.cli.add, this.cli.saveDevFlag];
     return this.add(command, directory, dependencies);
   }
-  async build(name, directory, entry, output, flags) {
+  async build(name, directory, entry, output, flags, watch3) {
     if (!this.cli.build) throw new Error(`Package manager ${this.name} does not support building`);
-    const spinner = SPINNER(Messages.BUILD_PART_IN_PROGRESS(name));
+    const spinner = SPINNER(
+      (watch3 ? Messages.BUILD_PART_WATCH_IN_PROGRESS : Messages.BUILD_PART_IN_PROGRESS)(name)
+    );
     spinner.start();
     try {
       const commandArgs = [
@@ -561,7 +653,6 @@ var AbstractPackageManager = class {
     }
   }
   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];
@@ -578,6 +669,15 @@ var AbstractPackageManager = class {
       return false;
     }
   }
+  async runDev(directory, command, env2 = {}, flags = [], collect = true) {
+    try {
+      const commandArgs = [this.cli.exec, command, ...flags];
+      await this.runner.run(commandArgs, collect, getCwd(directory), env2);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   async add(args, directory, dependencies) {
     if (!dependencies.length) {
       console.info();
@@ -649,8 +749,36 @@ var BunPackageManager = class extends AbstractPackageManager {
       add: "add",
       update: "update",
       remove: "remove",
-      build: "build",
+      exec: "exec",
+      run: "run",
+      saveFlag: "--save",
+      saveDevFlag: "--dev",
+      silentFlag: "--silent"
+    };
+  }
+};
+
+// src/lib/package-manager/package-managers/local-bun.package-manager.ts
+var LocalBunPackageManager = class extends AbstractPackageManager {
+  static {
+    __name(this, "LocalBunPackageManager");
+  }
+  constructor() {
+    super(RunnerFactory.create(1 /* LOCAL_BUN */));
+  }
+  get name() {
+    return "local_bun" /* LOCAL_BUN */.toUpperCase();
+  }
+  get cli() {
+    return {
+      install: "install",
+      add: "add",
+      update: "update",
+      remove: "remove",
+      exec: "exec",
       run: "run",
+      build: "build",
+      runFile: "run",
       saveFlag: "--save",
       saveDevFlag: "--dev",
       silentFlag: "--silent"
@@ -658,6 +786,84 @@ var BunPackageManager = class extends AbstractPackageManager {
   }
 };
 
+// src/lib/package-manager/package-managers/npm.package-manager.ts
+var NpmPackageManager = class extends AbstractPackageManager {
+  static {
+    __name(this, "NpmPackageManager");
+  }
+  constructor() {
+    super(RunnerFactory.create(2 /* NPM */));
+  }
+  get name() {
+    return "npm" /* NPM */.toUpperCase();
+  }
+  get cli() {
+    return {
+      install: "install",
+      add: "install",
+      update: "update",
+      remove: "uninstall",
+      exec: "exec",
+      run: "run",
+      saveFlag: "--save",
+      saveDevFlag: "--save-dev",
+      silentFlag: "--silent"
+    };
+  }
+};
+
+// src/lib/package-manager/package-managers/pnpm.package-manager.ts
+var PnpmPackageManager = class extends AbstractPackageManager {
+  static {
+    __name(this, "PnpmPackageManager");
+  }
+  constructor() {
+    super(RunnerFactory.create(3 /* PNPM */));
+  }
+  get name() {
+    return "pnpm" /* PNPM */.toUpperCase();
+  }
+  get cli() {
+    return {
+      install: "install",
+      add: "add",
+      update: "update",
+      remove: "remove",
+      exec: "exec",
+      run: "run",
+      saveFlag: "-P",
+      saveDevFlag: "-D",
+      silentFlag: "--silent"
+    };
+  }
+};
+
+// src/lib/package-manager/package-managers/yarn.package-manager.ts
+var YarnPackageManager = class extends AbstractPackageManager {
+  static {
+    __name(this, "YarnPackageManager");
+  }
+  constructor() {
+    super(RunnerFactory.create(5 /* YARN */));
+  }
+  get name() {
+    return "yarn" /* YARN */.toUpperCase();
+  }
+  get cli() {
+    return {
+      install: "install",
+      add: "add",
+      update: "update",
+      remove: "remove",
+      exec: "exec",
+      run: "run",
+      saveFlag: "",
+      saveDevFlag: "-D",
+      silentFlag: "--silent"
+    };
+  }
+};
+
 // src/lib/package-manager/package-manager.factory.ts
 var PackageManagerFactory = class {
   static {
@@ -667,10 +873,39 @@ var PackageManagerFactory = class {
     switch (name) {
       case "bun" /* BUN */:
         return new BunPackageManager();
+      case "local_bun" /* LOCAL_BUN */:
+        return new LocalBunPackageManager();
+      case "npm" /* NPM */:
+        return new NpmPackageManager();
+      case "pnpm" /* PNPM */:
+        return new PnpmPackageManager();
+      case "yarn" /* YARN */:
+        return new YarnPackageManager();
       default:
         throw new Error(`Package manager ${name} is not managed.`);
     }
   }
+  static async find(directory = ".") {
+    const DEFAULT_PACKAGE_MANAGER = "npm" /* NPM */;
+    try {
+      const files = await fs2.promises.readdir(resolve2(directory));
+      if (files.includes("bun.lock")) {
+        return this.create("bun" /* BUN */);
+      }
+      if (files.includes("package-lock.json")) {
+        return this.create("npm" /* NPM */);
+      }
+      if (files.includes("pnpm-lock.yaml")) {
+        return this.create("pnpm" /* PNPM */);
+      }
+      if (files.includes("yarn.lock")) {
+        return this.create("yarn" /* YARN */);
+      }
+      return this.create(DEFAULT_PACKAGE_MANAGER);
+    } catch {
+      return this.create(DEFAULT_PACKAGE_MANAGER);
+    }
+  }
 };
 
 // src/lib/config/config.type.ts
@@ -900,32 +1135,41 @@ var BuildAction = class extends AbstractAction {
     __name(this, "BuildAction");
   }
   async handle(_args, options) {
-    console.info(Messages.BUILD_START);
-    console.info();
+    console2.info(Messages.BUILD_START);
+    console2.info();
     try {
       const directory = getDirectoryInput(options);
       const config2 = await getConfig(options, directory);
+      const watch3 = getWatchInput(options);
       const client = getPart(
         config2.client.build,
         options.get("clientDirectory")?.value,
         "client"
       );
-      let res = await buildPart("Client", client, directory);
+      let res = await buildPart("Client", client, directory, { watch: watch3 });
       if (config2.server.enable) {
         const server = getPart(
           config2.server.build,
           options.get("serverDirectory")?.value,
           "server"
         );
-        res = await buildPart("Server", server, directory) ? res : false;
+        res = await buildPart("Server", server, directory, { watch: watch3 }) ? res : false;
       }
-      console.info();
-      if (!res) console.info(Messages.BUILD_FAILED);
-      else console.info(Messages.BUILD_SUCCESS);
-      process3.exit(0);
+      console2.info();
+      if (watch3) {
+        console2.info(Messages.BUILD_WATCH_START);
+        console2.info();
+        return;
+      }
+      if (!res) {
+        console2.info(Messages.BUILD_FAILED);
+        process.exit(1);
+      }
+      console2.info(Messages.BUILD_SUCCESS);
+      process.exit(0);
     } catch (e) {
-      console.error(e);
-      process3.exit(1);
+      console2.error(e);
+      process.exit(1);
     }
   }
 };
@@ -936,26 +1180,76 @@ var getPart = /* @__PURE__ */ __name((config2, directoryOption, target) => {
     target
   };
 }, "getPart");
-var buildPart = /* @__PURE__ */ __name(async (name, part, directory) => {
-  const packageManagerName = "bun" /* BUN */;
+var buildPart = /* @__PURE__ */ __name(async (name, part, directory, options) => {
+  const packageManagerName = "local_bun" /* LOCAL_BUN */;
+  const packageManager = PackageManagerFactory.create(packageManagerName);
+  const build = /* @__PURE__ */ __name(async (watch3 = false) => {
+    try {
+      return await packageManager.build(
+        name,
+        directory,
+        part.entry,
+        part.output,
+        [
+          "--asset-naming",
+          "[name].[ext]",
+          "--target",
+          part.target === "client" ? "browser" : "node"
+        ],
+        watch3
+      );
+    } catch (error4) {
+      if (error4 && error4.message) {
+        console2.error(ansis.red(error4.message));
+      }
+      return false;
+    }
+  }, "build");
+  if (options?.watch)
+    watch(dirname(join4(getCwd(directory), part.entry))).on("change", () => build(true));
+  return await build();
+}, "buildPart");
+
+// src/action/actions/dev.action.ts
+import * as ansis2 from "ansis";
+var DevAction = class extends AbstractAction {
+  static {
+    __name(this, "DevAction");
+  }
+  async handle(_args, options) {
+    console.info(Messages.DEV_START);
+    console.info();
+    try {
+      const directory = getDirectoryInput(options);
+      const generate = getDevGenerateInput(options);
+      await Promise.all([
+        generate ? runAction("generate", [], directory, false) : void 0,
+        runAction("build", [], directory, false),
+        runAction("start", [], directory, true)
+      ]);
+      console.info(Messages.DEV_SUCCESS);
+      process.exit(0);
+    } catch (e) {
+      console.error(Messages.DEV_FAILED);
+      console.error(e);
+      process.exit(1);
+    }
+  }
+};
+var runAction = /* @__PURE__ */ __name(async (command, params, directory, stdout = false) => {
   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));
+    const packageManager = await PackageManagerFactory.find(directory);
+    await packageManager.runDev(directory, "nf", {}, [command, ...params, "--watch"], !stdout);
+  } catch (error4) {
+    if (error4 && error4.message) {
+      console.error(ansis2.red(error4.message));
     }
-    return false;
   }
-}, "buildPart");
+}, "runAction");
 
 // src/action/actions/generate.action.ts
-import * as console2 from "console";
+import * as console3 from "console";
+import { join as join5 } from "path";
 
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
@@ -1045,7 +1339,7 @@ var CollectionFactory = class {
     __name(this, "CollectionFactory");
   }
   static create(collection, directory) {
-    const schematicRunner = RunnerFactory.create(1 /* SCHEMATIC */);
+    const schematicRunner = RunnerFactory.create(4 /* SCHEMATIC */);
     if (collection === "@nanoforge-dev/schematics" /* NANOFORGE */) {
       return new NanoforgeCollection(schematicRunner, directory);
     } else {
@@ -1083,7 +1377,7 @@ var SchematicOption = class {
       }
     } else if (typeof this.value === "boolean") {
       const str = normalizedName;
-      return this.value ? [`--${str}`] : [`--no-${str}`];
+      return this.value ? [`--${str}=true`] : [`--${str}=false`];
     } else if (Array.isArray(this.value)) {
       return this.value.reduce(
         (old, option) => [
@@ -1106,6 +1400,9 @@ var SchematicOption = class {
   }
 };
 
+// src/action/common/schematics.ts
+import { watch as watch2 } from "chokidar";
+
 // src/action/common/spinner.ts
 import ora2 from "ora";
 var getSpinner = /* @__PURE__ */ __name((message) => ora2({
@@ -1113,16 +1410,22 @@ var getSpinner = /* @__PURE__ */ __name((message) => ora2({
 }), "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));
+var executeSchematic = /* @__PURE__ */ __name(async (name, collection, schematicName, options, fileToWatch) => {
+  const execute = /* @__PURE__ */ __name(async (watch3 = false) => {
+    const spinner = getSpinner(
+      (watch3 ? Messages.SCHEMATIC_WATCH_IN_PROGRESS : 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));
+  }, "execute");
+  if (fileToWatch) watch2(fileToWatch).on("change", () => execute(true));
+  return await execute();
 }, "executeSchematic");
 var mapSchematicOptions = /* @__PURE__ */ __name((inputs) => {
   return Object.entries(inputs).reduce((old, [key, value]) => {
@@ -1140,18 +1443,25 @@ var GenerateAction = class extends AbstractAction {
     __name(this, "GenerateAction");
   }
   async handle(_args, options) {
-    console2.info(Messages.NEW_START);
+    console3.info(Messages.GENERATE_START);
+    console3.info();
     try {
       const directory = getDirectoryInput(options);
       const config2 = await getConfig(options, directory);
+      const watch3 = getWatchInput(options);
       const values = await getSchemaValues(config2);
-      await generateFiles(values, directory);
-      console2.info();
-      console2.info(Messages.NEW_SUCCESS);
+      await generateFiles(values, directory, watch3);
+      console3.info();
+      if (watch3) {
+        console3.info(Messages.GENERATE_WATCH_START);
+        console3.info();
+        return;
+      }
+      console3.info(Messages.GENERATE_SUCCESS);
       process.exit(0);
     } catch (e) {
-      console2.error(Messages.NEW_FAILED);
-      console2.error(e);
+      console3.error(Messages.GENERATE_FAILED);
+      console3.error(e);
       process.exit(1);
     }
   }
@@ -1165,33 +1475,43 @@ var getSchemaValues = /* @__PURE__ */ __name(async (config2) => {
     initFunctions: config2.initFunctions
   };
 }, "getSchemaValues");
-var generateFiles = /* @__PURE__ */ __name(async (values, directory) => {
-  console2.info();
+var generateFiles = /* @__PURE__ */ __name(async (values, directory, watch3) => {
   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", {
+  console3.info(Messages.SCHEMATICS_START);
+  console3.info();
+  await executeSchematic(
+    "Client main file",
+    collection,
+    "part-main",
+    {
       name: values.name,
-      part: "server",
+      part: "client",
       directory: values.directory,
       language: values.language,
       initFunctions: values.initFunctions
-    });
+    },
+    watch3 ? join5(getCwd(directory), values.directory, ".nanoforge", "client.save.json") : void 0
+  );
+  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
+      },
+      join5(getCwd(directory), values.directory, ".nanoforge", "server.save.json")
+    );
   }
 }, "generateFiles");
 
 // src/action/actions/install.action.ts
-import * as ansis2 from "ansis";
-import * as process4 from "process";
+import * as ansis3 from "ansis";
+import * as process3 from "process";
 var InstallAction = class extends AbstractAction {
   static {
     __name(this, "InstallAction");
@@ -1203,25 +1523,31 @@ var InstallAction = class extends AbstractAction {
       const names = await getInstallNamesInputOrAsk(args);
       const directory = getDirectoryInput(options);
       await installPackages(names, directory);
-      process4.exit(0);
+      process3.exit(0);
     } catch (e) {
       console.error(e);
-      process4.exit(1);
+      process3.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));
+    const packageManager = await PackageManagerFactory.find(directory);
+    const res = await packageManager.addProduction(directory, names);
+    if (!res) process3.exit(1);
+  } catch (error4) {
+    if (error4 && error4.message) {
+      console.error(ansis3.red(error4.message));
     }
+    process3.exit(1);
   }
 }, "installPackages");
 
+// src/action/actions/new.action.ts
+import * as ansis4 from "ansis";
+import console4 from "console";
+import * as process4 from "process";
+
 // src/lib/input/inputs/new/init-functions.input.ts
 var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInputWithDefault(inputs, "initFunctions", false);
@@ -1315,17 +1641,18 @@ var NewAction = class extends AbstractAction {
     __name(this, "NewAction");
   }
   async handle(_args, options) {
-    console.info(Messages.NEW_START);
+    console4.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);
+      if (!values.skipInstall) await runInstall(directory, values.packageManager);
+      console4.info();
+      console4.info(Messages.NEW_SUCCESS);
+      process4.exit(0);
     } catch {
-      console.error(Messages.NEW_FAILED);
-      process.exit(1);
+      console4.error(Messages.NEW_FAILED);
+      process4.exit(1);
     }
   }
 };
@@ -1342,11 +1669,11 @@ var getSchemaValues2 = /* @__PURE__ */ __name(async (inputs) => {
   };
 }, "getSchemaValues");
 var generateApplicationFiles = /* @__PURE__ */ __name(async (values, directory) => {
-  console.info();
+  console4.info();
   const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-  console.info();
-  console.info(Messages.SCHEMATICS_START);
-  console.info();
+  console4.info();
+  console4.info(Messages.SCHEMATICS_START);
+  console4.info();
   await executeSchematic("Application", collection, "application", {
     name: values.name,
     directory: values.directory,
@@ -1391,56 +1718,91 @@ var generateApplicationFiles = /* @__PURE__ */ __name(async (values, directory)
     });
   }
 }, "generateApplicationFiles");
+var runInstall = /* @__PURE__ */ __name(async (directory, pkgManagerName) => {
+  try {
+    const packageManager = PackageManagerFactory.create(pkgManagerName);
+    await packageManager.install(directory);
+  } catch (error4) {
+    if (error4 && error4.message) {
+      console4.error(ansis4.red(error4.message));
+    }
+    process4.exit(1);
+  }
+}, "runInstall");
 
 // src/action/actions/start.action.ts
-import * as ansis3 from "ansis";
-import * as console3 from "console";
-import { join as join4 } from "path";
+import * as ansis5 from "ansis";
+import * as console5 from "console";
+import * as process5 from "process";
+import { join as join6 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
   }
   async handle(_args, options) {
-    console3.info(Messages.RUN_START);
-    console3.info();
+    console5.info(Messages.RUN_START);
+    console5.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);
+      const cert = getStringInput(options, "cert");
+      const key = getStringInput(options, "key");
+      const watch3 = getWatchInput(options);
       await Promise.all([
-        config2.server.enable ? this.startServer(directory, serverDir) : void 0,
-        this.startClient(clientPort, directory, clientDir)
+        config2.server.enable ? this.startServer(directory, serverDir, watch3) : void 0,
+        this.startClient(
+          clientPort,
+          directory,
+          clientDir,
+          {
+            watch: watch3,
+            serverGameDir: config2.server.enable ? serverDir : void 0
+          },
+          cert,
+          key
+        )
       ]);
-      process.exit(0);
+      process5.exit(0);
     } catch (e) {
-      console3.error(e);
-      process.exit(1);
+      console5.error(e);
+      process5.exit(1);
     }
   }
-  async startClient(port, directory, gameDir) {
+  async startClient(port, directory, gameDir, options, cert, key) {
     const path = getModulePath("@nanoforge-dev/loader-client/package.json", true);
-    return runPart("Client", path, {
+    const params = {
       PORT: port,
-      GAME_DIR: getCwd(join4(directory, gameDir))
-    });
+      GAME_DIR: getCwd(join6(directory, gameDir)),
+      CERT: cert ? join6(getCwd(directory), cert) : void 0,
+      KEY: key ? join6(getCwd(directory), key) : void 0
+    };
+    if (options?.watch) {
+      params["WATCH"] = "true";
+      if (options?.serverGameDir) {
+        params["WATCH_SERVER_GAME_DIR"] = getCwd(join6(directory, options.serverGameDir));
+      }
+    }
+    return runPart("Client", path, params);
   }
-  startServer(directory, gameDir) {
+  startServer(directory, gameDir, watch3) {
     const path = getModulePath("@nanoforge-dev/loader-server/package.json", true);
-    return runPart("Server", path, {
-      GAME_DIR: getCwd(join4(directory, gameDir))
-    });
+    const params = {
+      GAME_DIR: getCwd(join6(directory, gameDir))
+    };
+    if (watch3) params["WATCH"] = "true";
+    return runPart("Server", path, params);
   }
 };
 var runPart = /* @__PURE__ */ __name(async (part, directory, env2, flags) => {
-  const packageManagerName = "bun" /* BUN */;
   try {
-    const packageManager = PackageManagerFactory.create(packageManagerName);
+    const packageManager = await PackageManagerFactory.find(directory);
     await packageManager.run(part, directory, "start", env2, flags, true);
-  } catch (error3) {
-    if (error3 && error3.message) {
-      console3.error(ansis3.red(error3.message));
+  } catch (error4) {
+    if (error4 && error4.message) {
+      console5.error(ansis5.red(error4.message));
     }
   }
 }, "runPart");
@@ -1461,12 +1823,30 @@ var BuildCommand = class extends AbstractCommand {
     __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) => {
+    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").option("--watch", "build app in watching mode", false).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 });
+      options.set("watch", { value: rawOptions.watch });
+      const args = /* @__PURE__ */ new Map();
+      await this.action.handle(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 directory of your project").option("--generate", "generate app from config", false).action(async (rawOptions) => {
+      const options = /* @__PURE__ */ new Map();
+      options.set("directory", { value: rawOptions.directory });
+      options.set("config", { value: rawOptions.config });
+      options.set("generate", { value: rawOptions.generate });
       const args = /* @__PURE__ */ new Map();
       await this.action.handle(args, options);
     });
@@ -1479,10 +1859,11 @@ var GenerateCommand = class extends AbstractCommand {
     __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) => {
+    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").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
       const options = /* @__PURE__ */ new Map();
       options.set("directory", { value: rawOptions.directory });
       options.set("config", { value: rawOptions.config });
+      options.set("watch", { value: rawOptions.watch });
       const args = /* @__PURE__ */ new Map();
       await this.action.handle(args, options);
     });
@@ -1537,7 +1918,7 @@ var StartCommand = class extends AbstractCommand {
     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) => {
+    ).option("--game-exposure-port [gameExposurePort]", "specify the port of the game exposure").option("--server-port [serverPort]", "specify the port 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 = /* @__PURE__ */ new Map();
       options.set("directory", { value: rawOptions.directory });
       options.set("config", { value: rawOptions.config });
@@ -1546,6 +1927,9 @@ var StartCommand = class extends AbstractCommand {
         value: rawOptions.gameExposurePort
       });
       options.set("serverPort", { value: rawOptions.serverPort });
+      options.set("watch", { value: rawOptions.watch });
+      options.set("cert", { value: rawOptions.cert });
+      options.set("key", { value: rawOptions.key });
       const args = /* @__PURE__ */ new Map();
       await this.action.handle(args, options);
     });
@@ -1559,6 +1943,7 @@ var CommandLoader = class {
   }
   static async load(program2) {
     new BuildCommand(new BuildAction()).load(program2);
+    new DevCommand(new DevAction()).load(program2);
     new GenerateCommand(new GenerateAction()).load(program2);
     new InstallCommand(new InstallAction()).load(program2);
     new NewCommand(new NewAction()).load(program2);
@@ -1568,8 +1953,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: ${red8`%s`}`, program2.args.join(" "));
+      console.log(`See ${red8`--help`} for a list of available commands.
 `);
       process.exit(1);
     });