create-nevela 0.2.1 → 0.3.0

package/README.md

@@ -36,21 +36,32 @@ php nevela resource Product --fields="name:string, sku:string!, price:money"
 
 That writes the Laravel code and the dashboard pages, and creates the table. `php nevela` lists everything else.
 
-## Updating an app later
+## The nevela command
+
+Install this package once and you have a `nevela` command, in every shell:
 
 ```sh
-php nevela update
+npm install -g create-nevela
 ```
 
-That updates the Laravel package, regenerates, and updates the dashboard files you have not changed. Files you changed are kept, and everything it replaces is backed up first.
+```sh
+nevela new my-app      # anywhere: create an app
+nevela update          # anywhere: update the nevela command itself
+nevela dev             # inside an app: run the API and the dashboard
+nevela upgrade         # inside an app: bring it to the latest Nevela
+```
 
-If `php` is not a command in your shell (Git Bash with Laravel Herd), or the app is an old one, run it through this package instead. It works in any shell and on an app of any age:
+As in Grit, `update` is for the tool and `upgrade` is for an app.
+
+## Upgrading an app later
 
 ```sh
-npx create-nevela update
+nevela upgrade
 ```
 
-Installed globally (`npm install -g create-nevela`), it gives you a `nevela` command: `nevela update`, `nevela dev`, `nevela status`, `nevela resource …`. See https://nevela-docs.vercel.app/guides/updating/.
+That updates the Laravel package, regenerates, and upgrades the dashboard files you have not changed. Files you changed are kept, and everything it replaces is backed up first.
+
+Without the command installed, `npx create-nevela upgrade` does the same, in any shell and on an app of any age. So does the app's own launcher, `php nevela upgrade`. See https://nevela-docs.vercel.app/guides/updating/.
 
 ## Options
 

package/index.mjs

@@ -12,10 +12,11 @@ import os from 'node:os';
 import path from 'node:path';
 import readline from 'node:readline/promises';
 import { fileURLToPath } from 'node:url';
-import { latestRelease, onPackagist } from './packagist.mjs';
-import { COMMANDS, findProject, forward, update } from './project.mjs';
+import { isNewer, latestRelease, onPackagist } from './packagist.mjs';
+import { COMMANDS, findProject, forward, upgrade } from './project.mjs';
 import { shellLine, spawnCommand, windows } from './shell.mjs';
-import { newerVersion, runVersion } from './selfupdate.mjs';
+import { latestVersion, newerVersion, runVersion } from './selfupdate.mjs';
+import { globalInstall, INSTALL_COMMAND } from './tool.mjs';
 import { copyLaravelPackage, copyWebTemplate, fromRepository, templateRecord } from './template.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -41,12 +42,15 @@ const HELP = `
 
   Create a new Nevela app: a Laravel API and a Next.js dashboard.
 
-  ${bold('Create an app')}
-    pnpm create nevela <name> [options]
-    npm create nevela@latest <name> -- [options]
+  ${bold('Get the nevela command')}  (once; everything below is then this short)
+    npm install -g create-nevela
 
-  ${bold('Inside an app')}  (also as: nevela <command>, once installed with npm install -g create-nevela)
-    nevela update              Update Nevela and the dashboard to the latest version
+  ${bold('Anywhere')}
+    nevela new <name> [options]   Create an app. Without the command: pnpm create nevela <name>
+    nevela update                 Update the nevela command itself to the latest version
+
+  ${bold('Inside an app')}
+    nevela upgrade             Bring this app to the latest Nevela: the package and the dashboard
     nevela dev                 Run the API and the dashboard
     nevela status              Check versions, migrations, users and the dashboard
     nevela resource <Name> --fields="…" [--seed]
@@ -301,7 +305,7 @@ Everything else runs from this folder too, with \`php nevela\`:
 \`\`\`sh
 php nevela user        # add someone who can sign in
 php nevela status      # versions, migrations, users, and what the dashboard is talking to
-php nevela update      # update Nevela and the dashboard
+php nevela upgrade     # bring this app to the latest Nevela
 php nevela             # everything it can do
 \`\`\`
 
@@ -328,25 +332,82 @@ async function inProject(name, args) {
     fail(`"${name}" runs inside a Nevela app, and this folder isn't in one.`, `To create an app:  pnpm create nevela my-app`);
   }
   if (name === 'version') console.log(`create-nevela ${VERSION}`);
-  if (name !== 'update') process.exit(forward(project, name, args));
+  if (name !== 'upgrade') process.exit(forward(project, name, args));
 
-  // Updating is the one command that must not run on stale code itself.
+  // Upgrading is the one command that must not run on stale code itself: it is the newest
+  // installer that knows what an older app needs repaired. So even a nevela command that
+  // hasn't been updated in a while upgrades an app correctly.
   if (!process.env.NEVELA_NO_SELF_UPDATE && !fromRepository) {
     const newer = await newerVersion(VERSION);
     if (newer) {
-      const status = await runVersion(newer, ['update', ...args]);
+      const status = await runVersion(newer, ['upgrade', ...args]);
       if (status !== null) process.exit(status);
     }
   }
-  console.log(`\n  ${indigo(bold('Nevela'))} ${dim('update')}\n`);
+  console.log(`\n  ${indigo(bold('Nevela'))} ${dim('upgrade')}\n`);
   const releases = await latestRelease();
-  const status = await update(project, args, { latest: releases, say: (line) => console.log(`  ${green('✔')} ${line}`) });
+  const status = await upgrade(project, args, { latest: releases, say: (line) => console.log(`  ${green('✔')} ${line}`) });
   process.exit(status);
 }
 
+/**
+ * `nevela update`, from anywhere: update the nevela command itself.
+ *
+ * As in Grit, updating the tool and upgrading an app are two commands. This one doesn't
+ * touch any app; it ends by saying how to upgrade the one you are in, if you are in one.
+ *
+ * It returns instead of calling process.exit(): on Windows, exiting in the same moment a
+ * fetch() has just finished trips an assertion inside Node and prints a crash.
+ */
+async function updateTool(args) {
+  const project = findProject(process.cwd());
+  const install = fromRepository ? null : globalInstall(here);
+
+  if (!install) {
+    // Run through npx or `pnpm dlx`, which fetch the latest every time, started by an
+    // older nevela command that fetched this one to do its work, or a copy in a project's
+    // own node_modules. There is no installed command to update. Inside an app, "update" used to mean "upgrade this app", and
+    // instructions saying so are still around, so that is what it does.
+    if (project) {
+      console.log(`\n  ${dim(`"update" now updates the nevela command, and an app is brought up to date with "upgrade". Upgrading this app.`)}`);
+      await inProject('upgrade', args);
+    }
+    console.log(`\n  ${indigo(bold('Nevela'))} ${dim(`v${VERSION}`)}\n`);
+    console.log(`  The nevela command isn't installed on this computer, so there is nothing to update.`);
+    console.log(`  To install it:  ${bold(INSTALL_COMMAND)}`);
+    console.log(`  Then, anywhere: ${bold('nevela new my-app')}   and inside an app: ${bold('nevela upgrade')}, ${bold('nevela dev')}\n`);
+    return;
+  }
+
+  console.log(`\n  ${indigo(bold('Nevela'))} ${dim('update')}\n`);
+  const latest = await latestVersion();
+  const newer = latest !== null && isNewer(latest, VERSION) ? latest : null;
+  if (latest === null) {
+    // Not the same as being up to date, so it isn't reported as that.
+    console.log(`  ${red('!')} Couldn't reach npm to see whether there is a newer nevela than ${bold(VERSION)}. Nothing was changed.`);
+    console.log(`    Try again when you are online, or run:  ${install.command.join(' ')}`);
+    process.exitCode = 1;
+  } else if (!newer) {
+    console.log(`  ${green('✔')} nevela ${bold(VERSION)} is the latest.`);
+  } else {
+    console.log(`  Updating the nevela command ${bold(VERSION)} → ${bold(newer)} ${dim(`(${install.command.join(' ')})`)}\n`);
+    const [command, ...rest] = install.command;
+    const result = spawnCommand(command, rest, { stdio: 'inherit' });
+    if (result.error || result.status !== 0) {
+      fail(`Couldn't update the nevela command.`, `Run it yourself to see why:  ${install.command.join(' ')}`);
+    }
+    console.log(`\n  ${green('✔')} nevela is now ${bold(newer)}.`);
+  }
+  if (project) {
+    console.log(`  ${dim('This app is not changed by that. To bring it to the latest Nevela:')} ${bold('nevela upgrade')}`);
+  }
+  console.log('');
+}
+
 async function main() {
   const argv = process.argv.slice(2);
   if (argv[0] === 'new') argv.shift();
+  else if (argv[0] === 'update') return updateTool(argv.slice(1));
   else if (COMMANDS.includes(argv[0])) await inProject(argv[0], argv.slice(1));
   const options = parseArgs(argv);
 
@@ -399,7 +460,7 @@ async function main() {
     write(path.join(web, 'pnpm-workspace.yaml'), 'allowBuilds:\n  sharp: true\n');
   }
   // Which dashboard this app started from, with a fingerprint of every file in it.
-  // `nevela update` compares against these to tell the files you changed from the ones
+  // `nevela upgrade` compares against these to tell the files you changed from the ones
   // you didn't, so an update never overwrites your work.
   write(path.join(web, '.nevela.json'), `${JSON.stringify(templateRecord(VERSION), null, 4)}\n`);
   writeRootFiles(root, { name, title, pm, admin: options.user ? ADMIN : null });
@@ -510,7 +571,7 @@ async function main() {
     console.log(`  ${dim(`That account is in this app's local database only. Add your own: ${nevela} user`)}`);
   }
   console.log(`\n  Add your first resource: ${dim(`${nevela} resource Product --fields="name:string, price:money"`)}`);
-  console.log(`  Check the app: ${dim(`${nevela} status`)}   Update it later: ${dim(`${nevela} update`)}   Everything: ${dim(nevela)}`);
+  console.log(`  Check the app: ${dim(`${nevela} status`)}   Upgrade it later: ${dim(`${nevela} upgrade`)}   Everything: ${dim(nevela)}`);
   if (nevela !== 'php nevela') {
     console.log(`\n  ${dim(`In this shell "php" isn't a command (your PHP is php.bat), so use ${nevela}. In PowerShell, php nevela works too.`)}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nevela",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Create a new Nevela app: a Laravel API and a Next.js dashboard from one resource description.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "selfupdate.mjs",
     "shell.mjs",
     "project.mjs",
+    "tool.mjs",
     "template",
     "LICENSE"
   ],

package/project.mjs

@@ -2,7 +2,7 @@
 //
 // The same commands as the app's own `php nevela`, but started from Node. That matters in
 // shells where typing `php` doesn't work (Git Bash with Laravel Herd, where PHP is
-// php.bat), and for `update`, which has to work on an app of any age, including one from
+// php.bat), and for `upgrade`, which has to work on an app of any age, including one from
 // before the app had a launcher at all.
 
 import fs from 'node:fs';
@@ -11,7 +11,7 @@ import { isNewer, satisfiesCaret } from './packagist.mjs';
 import { spawnCommand } from './shell.mjs';
 
 /** What `nevela <name>` runs: these go to `php artisan nevela:<name>`. */
-const NEVELA = ['update', 'dev', 'status', 'version', 'resource', 'generate', 'seed', 'user'];
+const NEVELA = ['upgrade', 'dev', 'status', 'version', 'resource', 'generate', 'seed', 'user'];
 /** These go to the artisan command of the same name. */
 const ARTISAN = ['migrate', 'tinker', 'test', 'serve'];
 
@@ -108,8 +108,13 @@ function inApp(project, command, args) {
   return result.status ?? 1;
 }
 
-/** `nevela update`: bring an app of any age to the latest Nevela. */
-export async function update(project, args, { latest, say }) {
+/**
+ * `nevela upgrade`: bring an app of any age to the latest Nevela.
+ *
+ * The artisan command is called by its older name, nevela:update, which every version of
+ * the package answers to (from 0.3.0 it is an alias of nevela:upgrade).
+ */
+export async function upgrade(project, args, { latest, say }) {
   const check = args.includes('--check');
   const manifestFile = path.join(project.api, 'composer.json');
   const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));

package/selfupdate.mjs

@@ -14,17 +14,27 @@ import { isNewer } from './packagist.mjs';
 
 const REGISTRY = 'https://registry.npmjs.org/create-nevela';
 
-/** The newest create-nevela on npm when it is newer than `current`, else null. Never throws. */
-export async function newerVersion(current) {
+/** The newest create-nevela on npm, or null when npm couldn't be asked. Never throws. */
+export async function latestVersion() {
   try {
     const response = await fetch(`${REGISTRY}/latest`, { signal: AbortSignal.timeout(4000) });
     const latest = (await response.json()).version;
-    return isNewer(latest, current) ? latest : null;
+    return typeof latest === 'string' && /^\d+\.\d+\.\d+$/.test(latest) ? latest : null;
   } catch {
     return null;
   }
 }
 
+/**
+ * The newest create-nevela on npm when it is newer than `current`, else null. Never throws.
+ * Null also when npm couldn't be asked: callers that only want to run the newest carry on
+ * with what they have.
+ */
+export async function newerVersion(current) {
+  const latest = await latestVersion();
+  return latest !== null && isNewer(latest, current) ? latest : null;
+}
+
 /**
  * Unpack a .tar (already gunzipped) into `dir`. Enough of the format for an npm tarball:
  * regular files and directories, with the long-name extensions npm uses.

package/template/laravel/README.md

@@ -43,7 +43,7 @@ Needs PHP 8.2 or newer and Laravel 11, 12 or 13.
 | `nevela:generate` | Regenerate after changing a descriptor. Your own code is kept. |
 | `nevela:seed` | Fill a resource with plausible records, and print how long it took. |
 | `nevela:user` | Create someone who can sign in. |
-| `nevela:update` | Update the package, the generated code and the dashboard. |
+| `nevela:upgrade` | Bring the app to the latest Nevela: the package, the generated code and the dashboard. `nevela:update` is its older name and still works. |
 
 Full documentation: https://nevela-docs.vercel.app
 

package/template/laravel/src/Console/StatusCommand.php

@@ -30,7 +30,7 @@ final class StatusCommand extends Command
         $latest = Releases::latest();
         $row('Nevela', Nevela::VERSION.match (true) {
             $latest === null => ' <fg=gray>(couldn\'t check for a newer one)</>',
-            version_compare($latest, Nevela::VERSION, '>') => " <fg=yellow>({$latest} is out: php nevela update)</>",
+            version_compare($latest, Nevela::VERSION, '>') => " <fg=yellow>({$latest} is out: php nevela upgrade)</>",
             default => ' <fg=green>(latest)</>',
         });
         $row('Laravel / PHP', app()->version().' / '.PHP_VERSION);
@@ -99,7 +99,7 @@ final class StatusCommand extends Command
             // What this app has made its own. An update leaves every one of these alone.
             $changes = $state->yourChanges($web);
             if ($changes === null) {
-                $row('Your dashboard changes', '<fg=gray>not tracked yet: php nevela update records them</>');
+                $row('Your dashboard changes', '<fg=gray>not tracked yet: php nevela upgrade records them</>');
             } else {
                 $count = count($changes['changed']) + count($changes['deleted']);
                 $row('Your dashboard changes', $count === 0 ? 'none' : "{$count} file(s), kept on every update");

package/template/laravel/src/Console/UpdateCommand.php

@@ -16,12 +16,18 @@ use Throwable;
 
 final class UpdateCommand extends Command
 {
-    protected $signature = 'nevela:update
+    protected $signature = 'nevela:upgrade
         {--check : Show what would change, and change nothing}
-        {--skip-package : Leave the nevela/laravel package as it is; update only the dashboard}
-        {--undo : Put the dashboard back as it was before the last update}';
+        {--skip-package : Leave the nevela/laravel package as it is; upgrade only the dashboard}
+        {--undo : Put the dashboard back as it was before the last upgrade}';
 
-    protected $description = 'Update Nevela: the package, the generated code and the dashboard';
+    /**
+     * The name this command had before 0.3.0, and still answers to. As in Grit, "update"
+     * is now what the nevela command does to itself, and "upgrade" is what it does to an app.
+     */
+    protected $aliases = ['nevela:update'];
+
+    protected $description = 'Bring this app to the latest Nevela: the package, the generated code and the dashboard';
 
     /** Apps created before the dashboard recorded its version all came from this template. */
     private const FIRST_TRACKED = '0.1.1';
@@ -184,7 +190,7 @@ final class UpdateCommand extends Command
         // The package's own files have just been replaced. Finish in a new process, so the
         // rest runs on the new code instead of a mix of old and new.
         $php = (new PhpExecutableFinder)->find(false) ?: 'php';
-        $rest = new Process([$php, 'artisan', 'nevela:update', '--skip-package'], base_path(), null, null, null);
+        $rest = new Process([$php, 'artisan', 'nevela:upgrade', '--skip-package'], base_path(), null, null, null);
         $rest->run(fn ($type, $buffer) => $this->output->write($buffer));
 
         return $rest->getExitCode() ?? self::FAILURE;
@@ -312,7 +318,7 @@ final class UpdateCommand extends Command
             $state->write($web);
 
             if ($touched) {
-                $this->line("  Every file this replaced was copied to <fg=cyan>{$this->relative($web)}/{$backup}</> first. To put it all back: <fg=cyan>php nevela update --undo</>");
+                $this->line("  Every file this replaced was copied to <fg=cyan>{$this->relative($web)}/{$backup}</> first. To put it all back: <fg=cyan>php nevela upgrade --undo</>");
             }
         }
         if ($done[DashboardUpdate::CONFLICT] !== []) {

package/template/laravel/src/Generator/ResourceGenerator.php

@@ -225,7 +225,8 @@ final class ResourceGenerator
         \$name = array_shift(\$args) ?? 'help';
 
         // What you type => the artisan command it runs.
-        \$nevela = ['resource', 'generate', 'seed', 'user', 'update', 'dev', 'status', 'version'];
+        // "update" is what upgrade was called before 0.3.0; it still works.
+        \$nevela = ['resource', 'generate', 'seed', 'user', 'upgrade', 'update', 'dev', 'status', 'version'];
         \$artisan = ['migrate', 'tinker', 'test', 'serve'];
         if (in_array(\$name, ['--version', '-v', '-V'], true)) {
             \$name = 'version';
@@ -254,7 +255,7 @@ final class ResourceGenerator
               php nevela generate              regenerate after editing a descriptor
               php nevela seed Product          fill a resource with records
               php nevela user                  create someone who can sign in
-              php nevela update                update Nevela and the dashboard
+              php nevela upgrade               bring this app to the latest Nevela
               php nevela version               which Nevela this is
 
               php nevela migrate               php artisan migrate

package/template/laravel/src/Nevela.php

@@ -18,7 +18,7 @@ use Nevela\Laravel\Support\Naming;
 final class Nevela
 {
     /** Written by `pnpm release`; the same number as the repository's git tag. */
-    public const VERSION = '0.2.1';
+    public const VERSION = '0.3.0';
 
     /** @var array<string, Descriptor> */
     private static array $descriptors = [];

package/template/laravel/src/Support/Descriptor.php

@@ -148,16 +148,16 @@ final class Descriptor
         return str_replace('-', '_', Naming::snake($this->name));
     }
 
-    /** Split on commas that are not inside enum parentheses. @return list<string> */
+    /** Split on commas that are not inside parentheses or square brackets. @return list<string> */
     private static function splitSpec(string $spec): array
     {
         $parts = [];
         $depth = 0;
         $current = '';
         foreach (str_split($spec) as $char) {
-            if ($char === '(') {
+            if ($char === '(' || $char === '[') {
                 $depth++;
-            } elseif ($char === ')') {
+            } elseif ($char === ')' || $char === ']') {
                 $depth--;
             }
             if ($char === ',' && $depth === 0) {

package/template/laravel/src/Support/Field.php

@@ -106,12 +106,15 @@ final class Field
      *   category:belongsTo(Category)      stored as categoryId
      *   image:image                       an optimised image; image:image(product) names a profile
      *   manual:file(pdf|document)         any other upload
+     *
+     * Grit's and Flare's spellings are understood too: see normalise().
      */
     public static function parse(string $token): self
     {
-        $token = trim($token);
+        $written = trim($token);
+        $token = self::normalise($written);
         if (! preg_match('/^([A-Za-z][A-Za-z0-9_]*):([A-Za-z_]+)(?:\(([^)]*)\))?([?!]{0,2})$/', $token, $m)) {
-            throw new InvalidArgumentException("Invalid field \"{$token}\". Expected name:type, e.g. price:money or status:enum(draft|live)?");
+            throw new InvalidArgumentException("Invalid field \"{$written}\". Expected name:type, e.g. price:money, status:enum(draft|live)?, image:image or category:belongsTo(Category).");
         }
         [, $name, $type, $args, $suffix] = $m + [3 => '', 4 => ''];
         $name = Naming::camel($name);
@@ -142,6 +145,30 @@ final class Field
         return new self($name, $kind, $format, $required, $unique);
     }
 
+    /**
+     * The other ways people write a field, turned into Nevela's own.
+     *
+     * Grit puts what a type takes after a second colon, and Flare in square brackets, so
+     * someone coming from either types what they know:
+     *
+     *   image:file:image          image:file[image]        image:file:[image]     → image:file(image)
+     *   category:belongs_to:Category                                              → category:belongs_to(Category)
+     *   status:enum:draft|live    docs:file:[pdf, image]                          → …(draft|live), …(pdf|image)
+     */
+    private static function normalise(string $token): string
+    {
+        // Spaces around the punctuation don't mean anything: "file: [ image ]".
+        $token = (string) preg_replace('/\s*([:\[\]])\s*/', '$1', $token);
+        if (preg_match('/^([^:()\[\]]+):([A-Za-z_]+):?\[([^\[\]()]*)\]([?!]{0,2})$/', $token, $m)
+            || preg_match('/^([^:()\[\]]+):([A-Za-z_]+):([^:()\[\]?!]+)([?!]{0,2})$/', $token, $m)) {
+            $list = implode('|', array_filter(array_map('trim', preg_split('/[,|]/', $m[3])), fn ($value) => $value !== ''));
+
+            return "{$m[1]}:{$m[2]}({$list}){$m[4]}";
+        }
+
+        return $token;
+    }
+
     /** @param array<string, mixed> $data */
     public static function fromArray(string $name, array $data): self
     {

package/template/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nevela-web",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "private": true,
   "type": "module",
   "scripts": {

package/template.mjs

@@ -81,7 +81,7 @@ export function copyWebTemplate(to, { name, title }) {
 
 /**
  * A fingerprint of every template file, and the template's dependencies: what the app
- * records in .nevela.json so that `nevela update` can tell, later and exactly, which
+ * records in .nevela.json so that `nevela upgrade` can tell, later and exactly, which
  * files the developer changed. The same fingerprint the Laravel package computes: SHA-1
  * with line endings ignored.
  */

package/tool.mjs

@@ -0,0 +1,58 @@
+// `nevela update`: the nevela command updating itself, from any folder.
+//
+// Two different things get newer, and they have two different commands, as in Grit:
+//
+//   nevela update     the `nevela` command on this computer
+//   nevela upgrade    the app you are in: its Nevela package and its dashboard
+//
+// Updating the command means asking the package manager that installed it to install the
+// latest. Which one that was is read from where this file is running from.
+
+import fs from 'node:fs';
+
+/** The command that installs the latest create-nevela globally, for each package manager. */
+const INSTALL = {
+  npm: ['npm', 'install', '-g', 'create-nevela@latest'],
+  pnpm: ['pnpm', 'add', '-g', 'create-nevela@latest'],
+  yarn: ['yarn', 'global', 'add', 'create-nevela@latest'],
+  bun: ['bun', 'add', '-g', 'create-nevela@latest'],
+};
+
+/**
+ * How the running copy was installed, from the folder it is in.
+ *
+ * Returns the package manager and the command that updates it, or null when this copy
+ * isn't the installed command: it was fetched for a single run (npx, pnpm dlx, a
+ * self-update), it is the repository itself, or it is a dependency in some project's own
+ * node_modules. Updating the global command would not change the copy that is running in
+ * any of those cases.
+ *
+ * @param {string} dir     The folder this package is running from
+ * @param {(file: string) => boolean} exists  Whether a file exists; replaceable in tests
+ */
+export function globalInstall(dir, exists = fs.existsSync) {
+  const plain = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+  const where = plain.toLowerCase();
+
+  // Fetched for one run and thrown away afterwards.
+  if (/\/_npx\/|\/dlx[-/]|\/\.?bunx-|\/xfs-[0-9a-f]+\/|\/create-nevela-\d[^/]*\/package$/.test(where)) return null;
+  // Installed, as opposed to checked out: it sits in somebody's node_modules.
+  if (!/\/node_modules\/create-nevela$/.test(where)) return null;
+
+  // pnpm, yarn and bun each keep global packages in a folder of their own.
+  if (/\/pnpm\/global\//.test(where)) return { manager: 'pnpm', command: INSTALL.pnpm };
+  if (/\/\.bun\/install\/global\//.test(where)) return { manager: 'bun', command: INSTALL.bun };
+  if (/\/yarn\/(data\/)?global\/|\/\.config\/yarn\/global\//.test(where)) return { manager: 'yarn', command: INSTALL.yarn };
+
+  // npm's global folder is a plain node_modules, like a project's. Two things tell them
+  // apart: a project has a package.json beside its node_modules, and a dependency of a
+  // dependency (or pnpm's local store) sits in a node_modules inside another.
+  if (where.split('/node_modules/').length !== 2) return null;
+  const owner = plain.slice(0, where.lastIndexOf('/node_modules/'));
+  if (exists(`${owner}/package.json`)) return null;
+
+  return { manager: 'npm', command: INSTALL.npm };
+}
+
+/** What to type to get the `nevela` command, for someone who doesn't have it yet. */
+export const INSTALL_COMMAND = INSTALL.npm.join(' ').replace('@latest', '');