@nanoforge-dev/cli 1.4.0 → 1.4.1

package/dist/nf.js

@@ -40,7 +40,7 @@ var require_package = __commonJS({
     module.exports = {
       $schema: "https://json.schemastore.org/package.json",
       name: "@nanoforge-dev/cli",
-      version: "1.4.0",
+      version: "1.4.1",
       description: "NanoForge CLI",
       keywords: [
         "nanoforge",
@@ -103,6 +103,7 @@ var require_package = __commonJS({
         commander: "catalog:cli",
         dotenv: "catalog:libs",
         "node-emoji": "catalog:cli",
+        open: "catalog:libs",
         ora: "catalog:cli",
         rc9: "catalog:libs",
         "reflect-metadata": "catalog:libs"
@@ -126,7 +127,10 @@ var require_package = __commonJS({
         typescript: "catalog:build",
         vitest: "catalog:tests"
       },
-      packageManager: "pnpm@10.28.1",
+      optionalDependencies: {
+        "@nanoforge-dev/editor": "file:../editor"
+      },
+      packageManager: "pnpm@10.33.0",
       engines: {
         node: "25"
       },
@@ -266,10 +270,10 @@ var loadLocalBinCommandLoader = /* @__PURE__ */ __name(async () => {
 }, "loadLocalBinCommandLoader");
 
 // src/command/command.loader.ts
-import { red as red6 } from "ansis";
+import { red as red7 } from "ansis";
 
 // src/lib/ui/messages.ts
-import { green } from "ansis";
+import { bold, green } from "ansis";
 
 // src/lib/ui/emojis.ts
 import { get } from "node-emoji";
@@ -304,8 +308,9 @@ var Messages = {
   BUILD_WATCH_START: "Watching for changes...",
   BUILD_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Building ${part}`, "BUILD_PART_IN_PROGRESS"),
   BUILD_PART_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((part) => `${part} updated, rebuilding`, "BUILD_PART_WATCH_IN_PROGRESS"),
+  BUILD_PART_SUCCESS: /* @__PURE__ */ __name((name) => success(`Build of ${name} succeeded!`), "BUILD_PART_SUCCESS"),
   BUILD_PART_FAILED: /* @__PURE__ */ __name((part, command) => failure(`Build of ${part} failed!
-Try running manually: ${command}`), "BUILD_PART_FAILED"),
+Try running manually: ${bold(command)}`), "BUILD_PART_FAILED"),
   // --- Install ---
   INSTALL_START: "NanoForge Installation",
   INSTALL_SUCCESS: success("Installation completed!"),
@@ -325,6 +330,7 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   NEW_START: "NanoForge Project Creation",
   NEW_SUCCESS: success("Project successfully created!"),
   NEW_FAILED: failure("Project creation failed!"),
+  NEW_GENERATION_START: "Creating project...",
   NEW_NAME_QUESTION: "What is the name of your project?",
   NEW_PACKAGE_MANAGER_QUESTION: "Which package manager do you want to use?",
   NEW_LANGUAGE_QUESTION: "Which language do you want to use?",
@@ -332,6 +338,8 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   NEW_SERVER_QUESTION: "Do you want to generate a server for multiplayer?",
   NEW_SKIP_INSTALL_QUESTION: "Do you want to skip dependency installation?",
   NEW_DOCKER_QUESTION: "Do you want to add a Dockerfile for containerization?",
+  NEW_GIT_QUESTION: "Do you want to create a git repository?",
+  NEW_GIT_REMOTE_QUESTION: "Do you want to setup a git remote? (leave empty if you don't want to)",
   // --- Create ---
   CREATE_START: "NanoForge Component/System Creation",
   CREATE_SUCCESS: success("Element successfully created!"),
@@ -353,6 +361,9 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   START_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Starting ${part}...`, "START_PART_IN_PROGRESS"),
   START_PART_SUCCESS: /* @__PURE__ */ __name((part) => success(`${part} terminated.`), "START_PART_SUCCESS"),
   START_PART_FAILED: /* @__PURE__ */ __name((part) => failure(`${part} failed!`), "START_PART_FAILED"),
+  EDITOR_START: "NanoForge Editor",
+  EDITOR_SUCCESS: "Editor ended",
+  EDITOR_FAILED: failure("Editor failed!"),
   // --- Publish ---
   PUBLISH_START: "NanoForge Publish",
   PUBLISH_SUCCESS: success("Publish completed!"),
@@ -364,7 +375,6 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   UNPUBLISH_FAILED: failure("Unpublish failed!"),
   UNPUBLISH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Unpublishing ${name}...`, "UNPUBLISH_IN_PROGRESS"),
   // --- Schematics ---
-  SCHEMATICS_START: "Running schematics",
   SCHEMATIC_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Generating ${name}...`, "SCHEMATIC_IN_PROGRESS"),
   SCHEMATIC_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Change detected, regenerating ${name}...`, "SCHEMATIC_WATCH_IN_PROGRESS"),
   SCHEMATIC_SUCCESS: /* @__PURE__ */ __name((name) => success(`${name} generated successfully!`), "SCHEMATIC_SUCCESS"),
@@ -374,10 +384,20 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   PACKAGE_MANAGER_INSTALLATION_NOTHING: "Nothing to install.",
   PACKAGE_MANAGER_INSTALLATION_SUCCEED: /* @__PURE__ */ __name((names) => names ? success(`Packages installed: ${names.map((n) => green(n)).join(", ")}`) : success("Packages installed!"), "PACKAGE_MANAGER_INSTALLATION_SUCCEED"),
   PACKAGE_MANAGER_INSTALLATION_FAILED: /* @__PURE__ */ __name((command) => failure(`Package installation failed!
-Try running manually: ${command}`), "PACKAGE_MANAGER_INSTALLATION_FAILED"),
+Try running manually: ${bold(command)}`), "PACKAGE_MANAGER_INSTALLATION_FAILED"),
+  // --- Git init ---
+  GIT_INIT_IN_PROGRESS: `Initializing git repository... ${Emojis.COFFEE}`,
+  GIT_INIT_SUCCEED: success("Git repository initialized!"),
+  GIT_INIT_FAILED: /* @__PURE__ */ __name((command) => failure(`Git repository initialization failed!
+Try running manually: ${bold(command)}`), "GIT_INIT_FAILED"),
+  // --- Git remote ---
+  GIT_REMOTE_IN_PROGRESS: `Adding git remote... ${Emojis.COFFEE}`,
+  GIT_REMOTE_SUCCEED: success("Git remote added!"),
+  GIT_REMOTE_FAILED: /* @__PURE__ */ __name((command) => failure(`Git remote addition failed!
+Try running manually: ${bold(command)}`), "GIT_REMOTE_FAILED"),
   // --- Runner ---
   RUNNER_EXECUTION_ERROR: /* @__PURE__ */ __name((command) => `
-Failed to execute command: ${command}`, "RUNNER_EXECUTION_ERROR")
+Failed to execute command: ${bold(command)}`, "RUNNER_EXECUTION_ERROR")
 };
 
 // src/lib/ui/prefixes.ts
@@ -589,6 +609,11 @@ var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInputWithDefault(inputs, "generate", false);
 }, "getDevGenerateInput");
 
+// src/lib/input/inputs/editor/open.input.ts
+var getEditorOpenInput = /* @__PURE__ */ __name((inputs, defaultValue) => {
+  return getBooleanInputWithDefault(inputs, "open", defaultValue);
+}, "getEditorOpenInput");
+
 // src/lib/input/inputs/install/lib.input.ts
 function getInstallLibInput(inputs) {
   return getBooleanInputWithDefault(inputs, "lib", false);
@@ -710,7 +735,7 @@ var getNewStrictOrAsk = /* @__PURE__ */ __name((inputs) => {
 }, "getNewStrictOrAsk");
 
 // src/lib/package-manager/package-manager.ts
-import { bold, red as red3 } from "ansis";
+import { red as red4 } from "ansis";
 
 // src/lib/runner/process-logger.ts
 import { green as green2, red as red2, yellow } from "ansis";
@@ -757,15 +782,16 @@ var resolveCLINodeBinaryPath = /* @__PURE__ */ __name((name) => {
 }, "resolveCLINodeBinaryPath");
 
 // src/lib/utils/spinner.ts
-var withSpinner = /* @__PURE__ */ __name(async (message, task, onError) => {
-  const spinner = getSpinner(message);
+import { red as red3 } from "ansis";
+var withSpinner = /* @__PURE__ */ __name(async (task, loadingMessage, successMessage, failureMessage, onError) => {
+  const spinner = getSpinner(loadingMessage);
   spinner.start();
   try {
     const value = await task(spinner);
-    spinner.succeed();
+    spinner.succeed(successMessage);
     return { success: true, value };
   } catch (error) {
-    spinner.fail();
+    spinner.fail(red3(failureMessage));
     if (onError) onError();
     return { success: false, error };
   }
@@ -787,12 +813,10 @@ var PackageManager = class {
   async install(directory) {
     const args = [this.commands.install, this.commands.silentFlag];
     const result = await withSpinner(
+      () => this.exec(args, directory),
       Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
-      async (spinner) => {
-        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
-        this.logSuccess(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED());
-      },
-      () => this.logFailure(this.formatFailCommand([this.commands.install]))
+      Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(),
+      Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(this.formatFailCommand([this.commands.install]))
     );
     return result.success;
   }
@@ -815,11 +839,10 @@ var PackageManager = class {
       ...flags
     ];
     const result = await withSpinner(
+      () => this.exec(args, directory),
       message,
-      async (spinner) => {
-        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
-      },
-      () => this.logBuildFailure(name)
+      Messages.BUILD_PART_SUCCESS(name),
+      Messages.BUILD_PART_FAILED(name, this.formatFailCommand(args))
     );
     return result.success;
   }
@@ -837,7 +860,25 @@ var PackageManager = class {
       console.info(Messages.START_PART_SUCCESS(name));
       return true;
     } catch {
-      console.error(red3(Messages.START_PART_FAILED(name)));
+      console.error(red4(Messages.START_PART_FAILED(name)));
+      return false;
+    }
+  }
+  async runFile(name, directory, script, params, env2 = {}, flags = [], silent = false) {
+    console.info(Messages.START_PART_IN_PROGRESS(name));
+    try {
+      const args = this.buildRunFileArgs(script, params, flags, silent);
+      await this.exec(args, directory, {
+        env: env2,
+        listeners: {
+          onStdout: createStdoutLogger(name),
+          onStderr: createStderrLogger(name)
+        }
+      });
+      console.info(Messages.START_PART_SUCCESS(name));
+      return true;
+    } catch {
+      console.error(red4(Messages.START_PART_FAILED(name)));
       return false;
     }
   }
@@ -858,12 +899,10 @@ var PackageManager = class {
     }
     const args = [this.commands.add, saveFlag, ...dependencies];
     const result = await withSpinner(
+      () => this.exec(args, directory),
       Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
-      async (spinner) => {
-        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
-        this.logSuccess(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(dependencies));
-      },
-      () => this.logFailure(this.formatFailCommand(args))
+      Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(),
+      Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(this.formatFailCommand(args))
     );
     return result.success;
   }
@@ -880,6 +919,15 @@ var PackageManager = class {
     if (this.commands.runArgsFlag) args.push(this.commands.runArgsFlag);
     return args.concat(params);
   }
+  buildRunFileArgs(script, params, flags, silent) {
+    if (!this.commands.runFile) throw new Error("Package manager does not support runFile");
+    const args = [...flags, this.commands.runFile];
+    if (silent) args.push(this.commands.silentFlag);
+    args.push(script);
+    if (params.length === 0) return args;
+    if (this.commands.runArgsFlag) args.push(this.commands.runArgsFlag);
+    return args.concat(params);
+  }
   exec(args, directory, options = {}) {
     return this.runner.run(args, {
       collect: options.collect ?? true,
@@ -892,18 +940,6 @@ var PackageManager = class {
   formatFailCommand(args) {
     return this.runner.fullCommand(args);
   }
-  logSuccess(message) {
-    console.info();
-    console.info(message);
-    console.info();
-  }
-  logFailure(command) {
-    console.error(red3(Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(bold(command))));
-  }
-  logBuildFailure(name) {
-    const command = this.formatFailCommand([this.commands.install]);
-    console.error(red3(Messages.BUILD_PART_FAILED(name, bold(command))));
-  }
   logEmpty(message) {
     console.info();
     console.info(message);
@@ -916,7 +952,7 @@ import fs2 from "fs";
 import { resolve as resolve2 } from "path";
 
 // src/lib/runner/runner.ts
-import { red as red4 } from "ansis";
+import { red as red5 } from "ansis";
 import { spawn as spawn2 } from "child_process";
 import * as process2 from "process";
 var Runner = class {
@@ -973,7 +1009,7 @@ var Runner = class {
     this.logCapturedOutput(output);
   }
   logFailedCommand(args) {
-    console.error(red4(`
+    console.error(red5(`
 Failed to execute command: ${this.binary} ${args.join(" ")}`));
   }
   logCapturedOutput(output) {
@@ -1142,17 +1178,17 @@ var copyFiles = /* @__PURE__ */ __name((from, to) => {
 }, "copyFiles");
 var resetFolder = /* @__PURE__ */ __name((folder) => {
   if (fs3.existsSync(folder)) fs3.rmSync(folder, { recursive: true, force: true });
-  fs3.mkdirSync(folder);
+  fs3.mkdirSync(folder, { recursive: true });
 }, "resetFolder");
 
 // src/lib/utils/run-safe.ts
-import { red as red5 } from "ansis";
+import { red as red6 } from "ansis";
 var runSafe = /* @__PURE__ */ __name(async (fn, fallback) => {
   try {
     return await fn();
   } catch (error) {
     const msg = getErrorMessage(error);
-    if (msg) console.error(red5(msg));
+    if (msg) console.error(red6(msg));
     return fallback;
   }
 }, "runSafe");
@@ -1828,8 +1864,44 @@ var DevAction = class extends AbstractAction {
   }
 };
 
-// src/action/actions/generate.action.ts
+// src/action/actions/editor.action.ts
+import open from "open";
 import { join as join6 } from "path";
+var EditorAction = class extends AbstractAction {
+  static {
+    __name(this, "EditorAction");
+  }
+  startMessage = Messages.EDITOR_START;
+  successMessage = Messages.EDITOR_SUCCESS;
+  failureMessage = Messages.EDITOR_FAILED;
+  async handle(args, options) {
+    const directory = getDirectoryInput(options);
+    const path = getPathInput(args);
+    const open2 = getEditorOpenInput(options, !!path);
+    void this.startEditor(directory);
+    if (open2) await this.openEditor(path);
+    return { keepAlive: true };
+  }
+  async startEditor(directory) {
+    const editorPath = join6(
+      getModulePath("@nanoforge-dev/editor/package.json", true),
+      "dist",
+      "index.js"
+    );
+    await runSafe(async () => {
+      const packageManager = PackageManagerFactory.create("local_bun" /* LOCAL_BUN */);
+      await packageManager.run("Editor", directory, editorPath, [], {}, [], true);
+    });
+  }
+  async openEditor(path) {
+    const query = path ? `?projectPath=${encodeURIComponent(path)}` : "";
+    const url = `http://localhost:3000/load-project${query}`;
+    await open(url);
+  }
+};
+
+// src/action/actions/generate.action.ts
+import { join as join7 } from "path";
 var GenerateAction = class extends AbstractAction {
   static {
     __name(this, "GenerateAction");
@@ -1888,7 +1960,7 @@ var GenerateAction = class extends AbstractAction {
       );
   }
   watchPath(directory, subDir, saveFile) {
-    return join6(getCwd(directory), subDir, saveFile);
+    return join7(getCwd(directory), subDir, saveFile);
   }
   enterWatchMode() {
     console.info();
@@ -1899,7 +1971,7 @@ var GenerateAction = class extends AbstractAction {
 };
 
 // src/action/actions/install.action.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/lib/global-config/global-config-handler.ts
 import { read, readUser, write, writeUser } from "rc9";
@@ -2143,7 +2215,7 @@ var concatDeps = /* @__PURE__ */ __name((deps) => {
 
 // src/lib/registry/registry.ts
 import fs4 from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var Registry = class {
   static {
     __name(this, "Registry");
@@ -2174,9 +2246,9 @@ var Registry = class {
   }
   static async installPackage(client2, manifest, dir) {
     const file = await client2.getFile(`/registry/${manifest.name}/-/${manifest._file}`);
-    const path = join7(dir, this.getTypeSubFolder(manifest.type));
+    const path = join8(dir, this.getTypeSubFolder(manifest.type));
     fs4.mkdirSync(path, { recursive: true });
-    fs4.writeFileSync(join7(path, manifest._file), await file.bytes());
+    fs4.writeFileSync(join8(path, manifest._file), await file.bytes());
   }
   static getTypeSubFolder(type) {
     if (type === "component") return "components";
@@ -2188,7 +2260,7 @@ var Registry = class {
     return withAuth(config2.apiKey, force, !headers ? {} : void 0);
   }
   static _getPackageFile(filename, dir) {
-    const path = join7(getCwd(dir ?? "."), filename);
+    const path = join8(getCwd(dir ?? "."), filename);
     if (!fs4.existsSync(path))
       throw new Error(
         "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.package`!"
@@ -2223,17 +2295,16 @@ var InstallAction = class extends AbstractAction {
   }
   async _installNfPackages(directory, names, isServer) {
     const deps = await resolveManifestDependencies(names, directory);
+    const part = isServer ? "server" : "client";
     const libSuccess = await this._installLibs(
       directory,
       deps.npm.map(([name, version]) => `${name}@${version}`)
     );
     if (!libSuccess) return { success: false };
-    return withSpinner(Messages.INSTALL_PACKAGES_IN_PROGRESS, async () => {
-      await Registry.install(
-        Object.values(deps.nf),
-        join8(directory, isServer ? "server" : "client")
-      );
-    });
+    return withSpinner(
+      () => Registry.install(Object.values(deps.nf), join9(directory, part)),
+      Messages.INSTALL_PACKAGES_IN_PROGRESS
+    );
   }
 };
 
@@ -2284,7 +2355,82 @@ var LogoutAction = class extends AbstractAction {
 };
 
 // src/action/actions/new.action.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
+
+// src/lib/git/git-runner.ts
+var GIT = "git";
+var GIT_COMMANDS = {
+  init: "init",
+  remote: "remote"
+};
+var GitRunner = class {
+  static {
+    __name(this, "GitRunner");
+  }
+  runner;
+  constructor() {
+    this.runner = new Runner(GIT);
+  }
+  async init(directory) {
+    const args = [GIT_COMMANDS.init];
+    const result = await withSpinner(
+      () => this.exec(args, directory),
+      Messages.GIT_INIT_IN_PROGRESS,
+      Messages.GIT_INIT_SUCCEED,
+      Messages.GIT_INIT_FAILED(this.formatFailCommand(args))
+    );
+    return result.success;
+  }
+  async addRemote(directory, remote) {
+    const args = [GIT_COMMANDS.remote, "add", "origin", remote];
+    const result = await withSpinner(
+      () => this.exec(args, directory),
+      Messages.GIT_REMOTE_IN_PROGRESS,
+      Messages.GIT_REMOTE_SUCCEED,
+      Messages.GIT_REMOTE_FAILED(this.formatFailCommand(args))
+    );
+    return result.success;
+  }
+  exec(args, directory, options = {}) {
+    return this.runner.run(args, {
+      collect: options.collect ?? true,
+      cwd: getCwd(directory),
+      env: options.env,
+      listeners: options.listeners,
+      onFail: options.onFail
+    });
+  }
+  formatFailCommand(args) {
+    return this.runner.fullCommand(args);
+  }
+};
+
+// src/lib/input/inputs/new/git-remote.input.ts
+var getGitRemoteInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "gitRemote");
+}, "getGitRemoteInput");
+var getNewGitRemoteInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getGitRemoteInput(inputs),
+    () => askInput(Messages.NEW_GIT_REMOTE_QUESTION, {
+      required: false,
+      default: ""
+    })
+  );
+}, "getNewGitRemoteInputOrAsk");
+
+// src/lib/input/inputs/new/git.input.ts
+var getNewGitInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "git");
+}, "getNewGitInput");
+var getNewGitOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewGitInput(inputs),
+    () => askConfirm(Messages.NEW_GIT_QUESTION, { default: true })
+  );
+}, "getNewGitOrAsk");
+
+// src/action/actions/new.action.ts
 var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
@@ -2297,18 +2443,16 @@ var NewAction = class extends AbstractAction {
     const values = await this.collectValues(options);
     await this.scaffold(values, cwdDirectory);
     let res = true;
+    const distDir = join10(cwdDirectory, values.directory);
     if (!values.skipInstall) {
-      res = await this.installDependencies(
-        values.packageManager,
-        join9(cwdDirectory, values.directory ?? values.name)
-      );
+      res = await this.installDependencies(values.packageManager, distDir);
     }
+    if (values.git) await this.setupGitRepository(values.gitRemote, distDir);
     return { success: res };
   }
   async collectValues(inputs) {
-    return {
+    const values = {
       name: await getNewNameInputOrAsk(inputs),
-      directory: getPathInput(inputs),
       packageManager: await getNewPackageManagerInputOrAsk(inputs),
       language: await getNewLanguageInputOrAsk(inputs),
       strict: await getNewStrictOrAsk(inputs),
@@ -2317,12 +2461,19 @@ var NewAction = class extends AbstractAction {
       skipInstall: await getNewSkipInstallOrAsk(inputs),
       docker: await getNewDockerOrAsk(inputs),
       lint: getNewLintInput(inputs),
-      editor: getEditorInput(inputs)
+      editor: getEditorInput(inputs),
+      git: await getNewGitOrAsk(inputs)
+    };
+    return {
+      ...values,
+      directory: getPathInput(inputs) ?? values.name,
+      gitRemote: values.git ? await getNewGitRemoteInputOrAsk(inputs) || null : null
     };
   }
   async scaffold(values, directory) {
     const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-    console.info(Messages.SCHEMATICS_START);
+    console.info();
+    console.info(Messages.NEW_GENERATION_START);
     console.info();
     await this.generateApplication(collection, values);
     await this.generateConfiguration(collection, values);
@@ -2347,7 +2498,7 @@ var NewAction = class extends AbstractAction {
   generateConfiguration(collection, values) {
     return executeSchematic("Configuration", collection, "configuration", {
       name: values.name,
-      directory: values.directory ?? values.name,
+      directory: values.directory,
       server: values.server,
       language: values.language,
       initFunctions: values.initFunctions
@@ -2375,14 +2526,14 @@ var NewAction = class extends AbstractAction {
   }
   async generateDocker(collection, values) {
     await executeSchematic("Docker", collection, "docker", {
-      directory: values.directory ?? values.name,
+      directory: values.directory,
       packageManager: values.packageManager
     });
   }
   partOptions(values, part) {
     return {
       part,
-      directory: values.directory ?? values.name,
+      directory: values.directory,
       language: values.language,
       initFunctions: values.initFunctions
     };
@@ -2391,6 +2542,13 @@ var NewAction = class extends AbstractAction {
     const packageManager = PackageManagerFactory.create(packageManagerName);
     return await packageManager.install(directory);
   }
+  async setupGitRepository(gitRemote, dir) {
+    const runner = new GitRunner();
+    let res;
+    res = await runner.init(dir);
+    if (res && gitRemote) res = await runner.addRemote(dir, gitRemote);
+    return res;
+  }
 };
 
 // src/lib/manifest/manifest.type.ts
@@ -2489,10 +2647,10 @@ __decorateClass([
 import { plainToInstance as plainToInstance2 } from "class-transformer";
 import { validate as validate2 } from "class-validator";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var getManifestPath = /* @__PURE__ */ __name((directory) => {
   for (const n of [MANIFEST_FILE_NAME]) {
-    const path = join10(directory, n);
+    const path = join11(directory, n);
     if (existsSync3(path)) return path;
   }
   throw new Error(`No manifest file found in directory: ${directory}`);
@@ -2527,15 +2685,16 @@ var PublishAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const manifest = await loadManifest(directory);
-    return withSpinner(Messages.PUBLISH_IN_PROGRESS(manifest.name), async () => {
-      await Registry.publish(manifest, directory);
-    });
+    return withSpinner(
+      () => Registry.publish(manifest, directory),
+      Messages.PUBLISH_IN_PROGRESS(manifest.name)
+    );
   }
 };
 
 // src/action/actions/start.action.ts
 import dotenv from "dotenv";
-import { join as join11, resolve as resolve3 } from "path";
+import { join as join12, resolve as resolve3 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
@@ -2596,14 +2755,14 @@ var StartAction = class extends AbstractAction {
   }
   buildClientParams(directory, config2, options) {
     const params = {
-      "-d": getCwd(join11(directory, options.clientDir)),
+      "-d": getCwd(join12(directory, options.clientDir)),
       "-p": options.port
     };
     if (options.watch) params["--watch"] = true;
     if (options.watch) {
       params["--watch"] = true;
       if (config2.server.enable) {
-        params["--watch-server-dir"] = getCwd(join11(directory, options.serverDir));
+        params["--watch-server-dir"] = getCwd(join12(directory, options.serverDir));
       }
     }
     if (options.ssl) {
@@ -2614,7 +2773,7 @@ var StartAction = class extends AbstractAction {
   }
   buildServerParams(directory, _config, options) {
     const params = {
-      "-d": getCwd(join11(directory, options.serverDir))
+      "-d": getCwd(join12(directory, options.serverDir))
     };
     if (options.watch) params["--watch"] = true;
     return this.buildParams(params);
@@ -2630,7 +2789,7 @@ var StartAction = class extends AbstractAction {
       ...process.env
     };
     dotenv.config({
-      path: resolve3(getCwd(join11(dir, ".env"))),
+      path: resolve3(getCwd(join12(dir, ".env"))),
       processEnv: rawEnv
     });
     const baseEnv = Object.entries(rawEnv).filter(
@@ -2664,9 +2823,10 @@ var UnpublishAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const manifest = await loadManifest(directory);
-    return withSpinner(Messages.UNPUBLISH_IN_PROGRESS(manifest.name), async () => {
-      await Registry.unpublish(manifest, directory);
-    });
+    return withSpinner(
+      () => Registry.unpublish(manifest, directory),
+      Messages.UNPUBLISH_IN_PROGRESS(manifest.name)
+    );
   }
 };
 
@@ -2694,7 +2854,7 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program2) {
-    program2.command("build").description("build your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-entry [clientEntry]", "specify the entry file of the client").option("--server-entry [serverEntry]", "specify the entry file of the server").option("--client-static-dir [clientStaticDir]", "specify the static directory of the client").option("--server-static-dir [serverStaticDir]", "specify the static directory of the server").option("--client-out-dir [clientOutDir]", "specify the output directory of the client").option("--server-out-dir [serverOutDir]", "specify the output directory of the server").option("--editor", "specify if the project must build with editor config").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
+    program2.command("build").description("build your game").option("-d, --directory <directory>", "specify the working directory of the command").option("-c, --config <config>", "path to the config file", CONFIG_FILE_NAME).option("--client-entry <clientEntry>", "specify the entry file of the client").option("--server-entry <serverEntry>", "specify the entry file of the server").option("--client-static-dir <clientStaticDir>", "specify the static directory of the client").option("--server-static-dir <serverStaticDir>", "specify the static directory of the server").option("--client-out-dir <clientOutDir>", "specify the output directory of the client").option("--server-out-dir <serverOutDir>", "specify the output directory of the server").option("--editor", "specify if the project must build with editor config").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
@@ -2718,13 +2878,13 @@ var CreateCommand = class extends AbstractCommand {
     __name(this, "CreateCommand");
   }
   load(program2) {
-    program2.command("create [type]").description("create nanoforge components or systems").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-n, --name [name]", "name of the component/system").option(
+    program2.command("create <type>").description("create nanoforge components or systems").option("-d, --directory <directory>", "specify the working directory of the command").option("-c, --config <config>", "path to the config file", CONFIG_FILE_NAME).option("-n, --name <name>", "name of the component/system").option(
       "-s, --server",
       "install components/systems on server (default install on client)",
       false
     ).option(
-      "-p, --path [path]",
-      "path to the component/system folder (default: [part]/<components|systems>)"
+      "-p, --path <path>",
+      "path to the component/system folder (default: <part>/<components|systems>)"
     ).action(async (type, rawOptions) => {
       const args = AbstractCommand.mapToInput({
         type
@@ -2747,7 +2907,7 @@ var DevCommand = class extends AbstractCommand {
     __name(this, "DevCommand");
   }
   load(program2) {
-    program2.command("dev").description("run your game in dev mode").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
+    program2.command("dev").description("run your game in dev mode").option("-d, --directory <directory>", "specify the working directory of the command").option("-c, --config <config>", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
@@ -2758,13 +2918,35 @@ var DevCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/editor.command.ts
+var EditorCommand = class extends AbstractCommand {
+  static {
+    __name(this, "EditorCommand");
+  }
+  load(program2) {
+    program2.command("editor [path]").description("start the editor").option("-d, --directory <directory>", "specify the working directory of the command").option(
+      "--open",
+      "open the editor on the default web browser (default: true if path is specified, false otherwise)"
+    ).option("--no-open", "do not open the editor on the default web browser").action(async (path, rawOptions) => {
+      const args = AbstractCommand.mapToInput({
+        path
+      });
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        open: rawOptions.open
+      });
+      await this.action.run(args, options);
+    });
+  }
+};
+
 // src/command/commands/generate.command.ts
 var GenerateCommand = class extends AbstractCommand {
   static {
     __name(this, "GenerateCommand");
   }
   load(program2) {
-    program2.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--editor", "specify if the project must generate editor main file").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
+    program2.command("generate").description("generate nanoforge files from config").option("-d, --directory <directory>", "specify the working directory of the command").option("-c, --config <config>", "path to the config file", CONFIG_FILE_NAME).option("--editor", "specify if the project must generate editor main file").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
@@ -2782,7 +2964,7 @@ var InstallCommand = class extends AbstractCommand {
     __name(this, "InstallCommand");
   }
   load(program2) {
-    program2.command("install [names...]").alias("add").description("add Nanoforge components and systems to your project").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --lib", "install library instead of component/system", false).option(
+    program2.command("install [names...]").alias("add").description("add Nanoforge components and systems to your project").option("-d, --directory <directory>", "specify the working directory of the command").option("-l, --lib", "install library instead of component/system", false).option(
       "-s, --server",
       "install components/systems on server (default install on client)",
       false
@@ -2806,7 +2988,7 @@ var LoginCommand = class extends AbstractCommand {
     __name(this, "LoginCommand");
   }
   load(program2) {
-    program2.command("login").description("login to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --local", "login only for the project", false).option("-k, --api-key <key>", "api key for Nanoforge registry").action(async (rawOptions) => {
+    program2.command("login").description("login to Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").option("-l, --local", "login only for the project", false).option("-k, --api-key <key>", "api key for Nanoforge registry").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         local: rawOptions.local,
@@ -2823,7 +3005,7 @@ var LogoutCommand = class extends AbstractCommand {
     __name(this, "LogoutCommand");
   }
   load(program2) {
-    program2.command("logout").description("logout from Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --local", "logout only for the project").action(async (rawOptions) => {
+    program2.command("logout").description("logout from Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").option("-l, --local", "logout only for the project").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         local: rawOptions.local
@@ -2839,10 +3021,13 @@ var NewCommand = class extends AbstractCommand {
     __name(this, "NewCommand");
   }
   load(program2) {
-    program2.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the working directory of the command").option("--name [name]", "specify the name of your project").option(
-      "--path [path]",
+    program2.command("new").description("create a new nanoforge project").option("-d, --directory <directory>", "specify the working directory of the command").option("--name <name>", "specify the name of your project").option(
+      "--path <path>",
       "specify the relative path where your project will be created (default: name of the project)"
-    ).option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").option("--no-lint", "do not generate lint files").option("--editor", "do add editor dependencies").action(async (rawOptions) => {
+    ).option("--package-manager <packageManager>", "specify the package manager of your project").option("--language <language>", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").option("--no-lint", "do not generate lint files").option("--editor", "do add editor dependencies").option("--git", "generate git repository").option("--no-git", "do not generate git repository").option(
+      "--git-remote <gitRemote>",
+      "setup git remote to git repository (required if --git is used)"
+    ).option("--no-git-remote", "do not setup git remote to git repository").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         name: rawOptions.name,
@@ -2855,7 +3040,9 @@ var NewCommand = class extends AbstractCommand {
         skipInstall: rawOptions.skipInstall,
         docker: rawOptions.docker,
         lint: rawOptions.lint,
-        editor: rawOptions.editor
+        editor: rawOptions.editor,
+        git: rawOptions.git,
+        gitRemote: rawOptions.gitRemote || void 0
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
     });
@@ -2868,7 +3055,7 @@ var PublishCommand = class extends AbstractCommand {
     __name(this, "PublishCommand");
   }
   load(program2) {
-    program2.command("publish").description("publish package to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").action(async (rawOptions) => {
+    program2.command("publish").description("publish package to Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory
       });
@@ -2883,7 +3070,7 @@ var StartCommand = class extends AbstractCommand {
     __name(this, "StartCommand");
   }
   load(program2) {
-    program2.command("start").description("start your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-p, --port [port]", "specify the port of the loader (the website to load the game)").option("--client-dir [clientDirectory]", "specify the directory of the client").option("--server-dir [serverDirectory]", "specify the directory of the server").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
+    program2.command("start").description("start your game").option("-d, --directory <directory>", "specify the working directory of the command").option("-c, --config <config>", "path to the config file", CONFIG_FILE_NAME).option("-p, --port <port>", "specify the port of the loader (the website to load the game)").option("--client-dir <clientDirectory>", "specify the directory of the client").option("--server-dir <serverDirectory>", "specify the directory of the server").option("--watch", "run app in watching mode", false).option("--cert <cert>", "path to the SSL certificate for HTTPS").option("--key <key>", "path to the SSL key for HTTPS").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
@@ -2905,7 +3092,7 @@ var UnpublishCommand = class extends AbstractCommand {
     __name(this, "UnpublishCommand");
   }
   load(program2) {
-    program2.command("unpublish").description("unpublish package to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").action(async (rawOptions) => {
+    program2.command("unpublish").description("unpublish package to Nanoforge registry").option("-d, --directory <directory>", "specify the working directory of the command").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory
       });
@@ -2925,6 +3112,7 @@ var CommandLoader = class {
     new BuildCommand(new BuildAction()).load(program2);
     new StartCommand(new StartAction()).load(program2);
     new DevCommand(new DevAction()).load(program2);
+    new EditorCommand(new EditorAction()).load(program2);
     new GenerateCommand(new GenerateAction()).load(program2);
     new CreateCommand(new CreateAction()).load(program2);
     new LoginCommand(new LoginAction()).load(program2);
@@ -2936,8 +3124,8 @@ var CommandLoader = class {
   static handleInvalidCommand(program2) {
     program2.on("command:*", () => {
       console.error(`
-${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program2.args.join(" "));
-      console.log(`See ${red6`--help`} for a list of available commands.
+${Prefixes.ERROR} Invalid command: ${red7`%s`}`, program2.args.join(" "));
+      console.log(`See ${red7`--help`} for a list of available commands.
 `);
       process.exit(1);
     });