@nanoforge-dev/cli 1.0.0 → 1.1.0

package/dist/command.loader.js

@@ -11,7 +11,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // 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";
@@ -41,7 +41,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 !
@@ -58,8 +60,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}`,
@@ -84,7 +94,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 join2 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -133,6 +145,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";
 
@@ -214,6 +236,10 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
+// src/lib/package-manager/package-manager.factory.ts
+import fs from "fs";
+import { resolve as resolve2 } from "path";
+
 // src/lib/runner/runner.factory.ts
 import { yellow } from "ansis";
 
@@ -236,7 +262,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
@@ -252,7 +278,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(
@@ -285,15 +311,48 @@ var BunRunner = class extends AbstractRunner {
 };
 
 // src/lib/utils/path.ts
-import { join } from "path";
+import { resolve } from "path";
 var getCwd = /* @__PURE__ */ __name((directory) => {
-  return directory.startsWith("/") ? directory : join(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 getNodeBinaryPath = /* @__PURE__ */ __name((name) => {
+  return resolve("node_modules", ".bin", name);
+}, "getNodeBinaryPath");
+
+// src/lib/runner/runners/local-bun.runner.ts
+var LocalBunRunner = class extends AbstractRunner {
+  static {
+    __name(this, "LocalBunRunner");
+  }
+  constructor() {
+    super(getNodeBinaryPath("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 {
@@ -316,6 +375,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 {
@@ -325,8 +394,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}`);
@@ -383,9 +460,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 = [
@@ -415,7 +494,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];
@@ -432,6 +510,15 @@ var AbstractPackageManager = class {
       return false;
     }
   }
+  async runDev(directory, command, env2 = {}, flags = [], collect = true) {
+    try {
+      const commandArgs = [this.cli.run, 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();
@@ -503,7 +590,6 @@ var BunPackageManager = class extends AbstractPackageManager {
       add: "add",
       update: "update",
       remove: "remove",
-      build: "build",
       run: "run",
       saveFlag: "--save",
       saveDevFlag: "--dev",
@@ -512,6 +598,108 @@ var BunPackageManager = class extends AbstractPackageManager {
   }
 };
 
+// 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",
+      run: "run",
+      build: "build",
+      runFile: "run",
+      saveFlag: "--save",
+      saveDevFlag: "--dev",
+      silentFlag: "--silent"
+    };
+  }
+};
+
+// 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",
+      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",
+      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",
+      run: "run",
+      saveFlag: "",
+      saveDevFlag: "-D",
+      silentFlag: "--silent"
+    };
+  }
+};
+
 // src/lib/package-manager/package-manager.factory.ts
 var PackageManagerFactory = class {
   static {
@@ -521,10 +709,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 fs.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
@@ -650,7 +867,7 @@ __decorateClass([
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
 import { existsSync, readFileSync } from "fs";
-import { join as join2 } from "path";
+import { join } from "path";
 
 // src/lib/utils/object.ts
 var isObject = /* @__PURE__ */ __name((item) => {
@@ -705,10 +922,10 @@ var CONFIG_DEFAULTS = {
 var config;
 var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
-    return join2(directory, name);
+    return join(directory, name);
   } else {
     for (const n of ["nanoforge.config.json"]) {
-      const path = join2(directory, n);
+      const path = join(directory, n);
       if (existsSync(path)) return path;
     }
     throw new Error(`Unsupported config: ${name}`);
@@ -754,32 +971,38 @@ 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);
+      else console2.info(Messages.BUILD_SUCCESS);
+      process.exit(0);
     } catch (e) {
-      console.error(e);
-      process3.exit(1);
+      console2.error(e);
+      process.exit(1);
     }
   }
 };
@@ -790,26 +1013,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(join2(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 join3 } from "path";
 
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
@@ -899,7 +1172,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 {
@@ -960,6 +1233,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({
@@ -967,16 +1243,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]) => {
@@ -994,18 +1276,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);
     }
   }
@@ -1019,33 +1308,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 ? join3(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
+      },
+      join3(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");
@@ -1057,25 +1356,28 @@ 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);
+    const packageManager = await PackageManagerFactory.find(directory);
     await packageManager.addProduction(directory, names);
-  } catch (error3) {
-    if (error3 && error3.message) {
-      console.error(ansis2.red(error3.message));
+  } catch (error4) {
+    if (error4 && error4.message) {
+      console.error(ansis3.red(error4.message));
     }
   }
 }, "installPackages");
 
+// src/action/actions/new.action.ts
+import * as ansis4 from "ansis";
+import console4 from "console";
+
 // src/lib/input/inputs/new/init-functions.input.ts
 var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInputWithDefault(inputs, "initFunctions", false);
@@ -1169,16 +1471,17 @@ 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);
+      if (!values.skipInstall) await runInstall(directory, values.packageManager);
+      console4.info();
+      console4.info(Messages.NEW_SUCCESS);
       process.exit(0);
     } catch {
-      console.error(Messages.NEW_FAILED);
+      console4.error(Messages.NEW_FAILED);
       process.exit(1);
     }
   }
@@ -1196,11 +1499,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,
@@ -1245,56 +1548,78 @@ 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));
+    }
+  }
+}, "runInstall");
 
 // src/action/actions/start.action.ts
-import * as ansis3 from "ansis";
-import * as console3 from "console";
-import { join as join3 } from "path";
+import * as ansis5 from "ansis";
+import * as console5 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();
+    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 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
+        })
       ]);
       process.exit(0);
     } catch (e) {
-      console3.error(e);
+      console5.error(e);
       process.exit(1);
     }
   }
-  async startClient(port, directory, gameDir) {
+  async startClient(port, directory, gameDir, options) {
     const path = getModulePath("@nanoforge-dev/loader-client/package.json", true);
-    return runPart("Client", path, {
+    const params = {
       PORT: port,
-      GAME_DIR: getCwd(join3(directory, gameDir))
-    });
+      GAME_DIR: getCwd(join4(directory, gameDir))
+    };
+    if (options?.watch) {
+      params["WATCH"] = "true";
+      if (options?.serverGameDir) {
+        params["WATCH_SERVER_GAME_DIR"] = getCwd(join4(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(join3(directory, gameDir))
-    });
+    const params = {
+      GAME_DIR: getCwd(join4(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");
@@ -1315,12 +1640,30 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program) {
-    program.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) => {
+    program.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(program) {
+    program.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);
     });
@@ -1333,10 +1676,11 @@ var GenerateCommand = class extends AbstractCommand {
     __name(this, "GenerateCommand");
   }
   load(program) {
-    program.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").action(async (rawOptions) => {
+    program.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);
     });
@@ -1391,7 +1735,7 @@ var StartCommand = class extends AbstractCommand {
     program.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).action(async (rawOptions) => {
       const options = /* @__PURE__ */ new Map();
       options.set("directory", { value: rawOptions.directory });
       options.set("config", { value: rawOptions.config });
@@ -1400,6 +1744,7 @@ var StartCommand = class extends AbstractCommand {
         value: rawOptions.gameExposurePort
       });
       options.set("serverPort", { value: rawOptions.serverPort });
+      options.set("watch", { value: rawOptions.watch });
       const args = /* @__PURE__ */ new Map();
       await this.action.handle(args, options);
     });
@@ -1413,6 +1758,7 @@ var CommandLoader = class {
   }
   static async load(program) {
     new BuildCommand(new BuildAction()).load(program);
+    new DevCommand(new DevAction()).load(program);
     new GenerateCommand(new GenerateAction()).load(program);
     new InstallCommand(new InstallAction()).load(program);
     new NewCommand(new NewAction()).load(program);
@@ -1422,8 +1768,8 @@ var CommandLoader = class {
   static handleInvalidCommand(program) {
     program.on("command:*", () => {
       console.error(`
-${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program.args.join(" "));
-      console.log(`See ${red6`--help`} for a list of available commands.
+${Prefixes.ERROR} Invalid command: ${red8`%s`}`, program.args.join(" "));
+      console.log(`See ${red8`--help`} for a list of available commands.
 `);
       process.exit(1);
     });