@amxts/cli 0.1.0

package/src/module.mjs

@@ -0,0 +1,150 @@
+// `amxts module add` installs a module and lists it in amxts.config.ts in one
+// step; `amxts module list` shows what the config lists and what is installed:
+//
+//   amxts module add menu-core           npm install -D @amxts/menu-core @amxts/config-core,
+//                                        both into modules in amxts.config.ts - config-core
+//                                        after menu-core, "// needed by menu-core" -
+//                                        then amxts prepare, which names them for the editor
+//   amxts module add @you/greeter        any package from npm - with a warning
+//                                        when the amxts catalog does not list it
+//   amxts module add ../greeter          a module from its folder
+//   amxts module list                    what the config lists, what is installed,
+//                                        what else the catalog has
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { configEntries, installTarget, loadCatalog, resolveModule, taglineOf, withRequired } from './catalog.mjs';
+import { addToConfig, CONFIG_FILE, newConfig, readConfigModules } from './config.mjs';
+import { FROM_SOURCE, installedCore, needLocalCore, needProject, readJson } from './core.mjs';
+import { prepare } from './includes.mjs';
+import { addArgs, commandLine, detectPackageManager, execAmxts, run, versionOf } from './pm.mjs';
+import { c, CliError, log } from './ui.mjs';
+
+/**
+ * @param {string[]} names
+ * @param {{ local?: boolean, skipInstall?: boolean, skipConfig?: boolean }} options
+ */
+export async function moduleAdd(names, options = {}) {
+	if (names.length === 0) throw new CliError('Which module?', 'amxts module add menu-core   (or a package name, or a folder)');
+	const dir = needProject();
+	const pm = detectPackageManager(dir);
+
+	// --local, the default when the project's core is a checkout: the official
+	// modules from the folders that core takes them from.
+	const core = await installedCore(dir);
+	const local = options.local ?? (core ? core.fromSource : FROM_SOURCE);
+	const [source, catalog] = await Promise.all([local && !core?.fromSource ? needLocalCore() : core, loadCatalog()]);
+	const localModules = local ? source.api.localModules() : {};
+	const from = { catalog, local, localModules };
+	const wanted = names.map(name => resolveModule(name, from));
+	for (const module of wanted.filter(each => !each.dir && !each.listed)) log.warn(`${module.name} is not in the amxts catalog: it is installed from npm as it is`);
+	const project = readJson(join(dir, 'package.json'));
+	const deps = { ...project?.dependencies, ...project?.devDependencies };
+	// What a module needs comes along, unless the project has it: yarn does
+	// not install peer dependencies by itself.
+	const all = withRequired(wanted, from);
+	const toInstall = all.filter(module => wanted.includes(module) || !deps[module.name]);
+
+	if (!options.skipInstall) {
+		if (!versionOf(pm)) throw new CliError(`${pm} is not installed, and this project uses it`, `Install ${pm}, or add the package by hand and run amxts module add ${names.join(' ')} --skip-install.`);
+		const argv = addArgs(pm, toInstall.map(module => installTarget(module, dir, pm)));
+		log.step(`${commandLine(argv)}`);
+		const result = await run(argv, { cwd: dir });
+		if (result.code !== 0) throw new CliError(`${commandLine(argv)} failed`, 'The package manager says why, above.');
+	}
+
+	// Only a package that is a module goes into the config, with what it
+	// requires right after it.
+	const notModules = wanted.filter((module) => {
+		const json = readJson(join(dir, 'node_modules', module.name, 'package.json')) ?? (module.dir ? readJson(join(module.dir, 'package.json')) : null);
+		return json && !json.amxts?.module;
+	});
+	for (const module of notModules) log.warn(`${module.name} is not an amxts module (its package.json has no "amxts" field): installed, not added to ${CONFIG_FILE}`);
+	const entries = configEntries(all.filter(module => !notModules.includes(module)), wanted);
+	if (options.skipConfig || entries.length === 0) return;
+	if (!await addModules(dir, entries)) return;
+
+	// The editor config names the modules the config lists: prepared again
+	// now that it lists these - the install's own prepare ran before.
+	const projectCore = await installedCore(dir);
+	if (projectCore) await prepare(projectCore);
+}
+
+/**
+ * Lists modules in amxts.config.ts, a new one when there is none. Whether it changed.
+ * @param {string} dir
+ * @param {import('./catalog.mjs').ConfigEntry[]} entries
+ */
+async function addModules(dir, entries) {
+	const path = join(dir, CONFIG_FILE);
+	const names = entries.map(each => each.name).join(', ');
+	if (!existsSync(path)) {
+		writeFileSync(path, newConfig(entries));
+		log.success(`Created ${CONFIG_FILE} with ${names}`);
+		return true;
+	}
+	const { text, added } = await addToConfig(readFileSync(path, 'utf8'), entries);
+	if (added.length === 0) {
+		log.info(`${CONFIG_FILE} lists ${names} already`);
+		return false;
+	}
+	writeFileSync(path, text);
+	log.success(`Added ${added.map(name => c.bold(name)).join(', ')} to ${CONFIG_FILE}`);
+	return true;
+}
+
+/** Every installed package with an "amxts" field: node_modules and its scopes. */
+function installedModules(dir) {
+	const found = new Map();
+	const add = (packageDir) => {
+		const json = readJson(join(packageDir, 'package.json'));
+		if (json?.name && json.amxts?.module && !found.has(json.name)) {
+			const requires = Object.keys(json.peerDependencies ?? {}).filter(name => name !== '@amxts/core');
+			found.set(json.name, { name: json.name, version: json.version ?? '', dir: packageDir, requires });
+		}
+	};
+	const modulesDir = join(dir, 'node_modules');
+	if (existsSync(modulesDir)) {
+		for (const name of readdirSync(modulesDir)) {
+			if (name.startsWith('.')) continue;
+			if (name.startsWith('@')) {
+				for (const inner of readdirSync(join(modulesDir, name))) add(join(modulesDir, name, inner));
+			} else {
+				add(join(modulesDir, name));
+			}
+		}
+	}
+	return found;
+}
+
+export async function moduleList() {
+	const dir = needProject();
+	const [listed, catalog] = await Promise.all([readConfigModules(dir), loadCatalog()]);
+	const names = listed ?? [];
+	const installed = installedModules(dir);
+	const available = catalog.filter(module => !installed.has(module.npm));
+	const add = `${execAmxts(detectPackageManager(dir))} module add`;
+	const pad = Math.max(10, ...[...names, ...installed.keys(), ...available.map(module => module.name)].map(name => name.length));
+	const row = (mark, name, rest) => console.log(`  ${mark} ${name.padEnd(pad)}  ${rest}`);
+
+	console.log(c.bold(listed === null ? `No ${CONFIG_FILE} here` : `In ${CONFIG_FILE}`));
+	if (listed && listed.length === 0) console.log(c.dim('  no modules yet'));
+	for (const name of names) {
+		const module = installed.get(name);
+		if (module) row(c.green('✔'), name, `${c.dim(module.version)}  ${taglineOf(module.dir)}`);
+		else row(c.red('✖'), name, c.red(`not installed - ${add} ${name}`));
+	}
+
+	const others = [...installed.values()].filter(module => !names.includes(module.name));
+	if (others.length) {
+		console.log(c.bold('\nInstalled, not in the config'));
+		for (const module of others) {
+			const by = names.filter(name => installed.get(name)?.requires.includes(module.name));
+			row(c.yellow('•'), module.name, `${c.dim(module.version)}  ${c.dim(by.length ? `comes along: ${by.join(', ')} needs it` : `not used - add it to modules to use it`)}`);
+		}
+	}
+
+	if (available.length) {
+		console.log(c.bold('\nIn the amxts catalog'));
+		for (const module of available) row(c.dim('○'), module.name, c.dim(`${module.description}${module.type === 'community' ? ' (community)' : ''} - ${add} ${module.name}`));
+	}
+}

package/src/modules.json

@@ -0,0 +1,47 @@
+[
+	{
+		"name": "config-core",
+		"npm": "@amxts/config-core",
+		"repo": "amxts/config-core",
+		"description": "Configs in INI, YAML or JSON, read into typed objects and written back",
+		"category": "config",
+		"type": "official",
+		"logo": "https://raw.githubusercontent.com/amxts/config-core/HEAD/assets/logo.svg",
+		"maintainers": [
+			{
+				"github": "kukson777"
+			}
+		],
+		"requires": []
+	},
+	{
+		"name": "menu-core",
+		"npm": "@amxts/menu-core",
+		"repo": "amxts/menu-core",
+		"description": "Menus from INI, YAML or JSON files, with conditions and placeholders",
+		"category": "ui",
+		"type": "official",
+		"logo": "https://raw.githubusercontent.com/amxts/menu-core/HEAD/assets/logo.svg",
+		"maintainers": [
+			{
+				"github": "kukson777"
+			}
+		],
+		"requires": ["@amxts/config-core"]
+	},
+	{
+		"name": "resemiclip",
+		"npm": "@amxts/resemiclip",
+		"repo": "amxts/resemiclip",
+		"description": "Semiclip over the ReSemiclip module - who walks through whom, as a rule over two players",
+		"category": "gameplay",
+		"type": "official",
+		"logo": "https://raw.githubusercontent.com/amxts/resemiclip/HEAD/assets/logo.svg",
+		"maintainers": [
+			{
+				"github": "kukson777"
+			}
+		],
+		"requires": []
+	}
+]

package/src/pm.mjs

@@ -0,0 +1,111 @@
+// The package manager a project uses - npm, pnpm, yarn or bun - and the
+// commands each one spells its own way.
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import process from 'node:process';
+
+export const PACKAGE_MANAGERS = ['npm', 'pnpm', 'yarn', 'bun'];
+
+const LOCKFILES = [
+	['bun.lock', 'bun'],
+	['bun.lockb', 'bun'],
+	['pnpm-lock.yaml', 'pnpm'],
+	['yarn.lock', 'yarn'],
+	['package-lock.json', 'npm'],
+];
+
+/** The package manager that started this process - `npm create`, `pnpm dlx`, `bunx` - from its user agent. */
+export function packageManagerOfAgent(agent = process.env.npm_config_user_agent ?? '') {
+	const name = agent.split('/')[0];
+	return PACKAGE_MANAGERS.includes(name) ? name : null;
+}
+
+/**
+ * The project's package manager: its lockfile, its package.json's
+ * "packageManager", the one running this command, else npm.
+ */
+export function detectPackageManager(dir = process.cwd()) {
+	for (let at = resolve(dir); ; at = dirname(at)) {
+		for (const [file, pm] of LOCKFILES) {
+			if (existsSync(join(at, file))) return pm;
+		}
+		const pkg = join(at, 'package.json');
+		if (existsSync(pkg)) {
+			try {
+				const field = JSON.parse(readFileSync(pkg, 'utf8')).packageManager;
+				const name = typeof field === 'string' ? field.split('@')[0] : '';
+				if (PACKAGE_MANAGERS.includes(name)) return name;
+			} catch {}
+		}
+		if (dirname(at) === at) break;
+	}
+	return packageManagerOfAgent() ?? 'npm';
+}
+
+/** The version of an installed package manager (or bun, git), or null when it is not there. */
+export function versionOf(tool) {
+	// Through the shell on Windows, where npm and bun are .cmd files.
+	const run = process.platform === 'win32'
+		? spawnSync(`${tool} --version`, { encoding: 'utf8', shell: true, windowsHide: true })
+		: spawnSync(tool, ['--version'], { encoding: 'utf8' });
+	if (run.status !== 0 || !run.stdout) return null;
+	return run.stdout.trim().split('\n')[0].replace(/^v/, '');
+}
+
+/** `npm install`, `pnpm install`... - what installs a project's dependencies. */
+export function installArgs(pm) {
+	return [pm, 'install'];
+}
+
+/** What adds packages as dev dependencies. */
+export function addArgs(pm, packages) {
+	if (pm === 'npm') return ['npm', 'install', '-D', ...packages];
+	if (pm === 'bun') return ['bun', 'add', '-d', ...packages];
+	return [pm, 'add', '-D', ...packages];
+}
+
+/** How a package.json script is run: `npm run dev`, `pnpm dev`. */
+export function runScript(pm, script) {
+	return pm === 'npm' || pm === 'bun' ? `${pm} run ${script}` : `${pm} ${script}`;
+}
+
+/** How the project's amxts command is run: `npx amxts`, `pnpm amxts`. */
+export function execAmxts(pm) {
+	return { npm: 'npx amxts', pnpm: 'pnpm amxts', yarn: 'yarn amxts', bun: 'bunx amxts' }[pm] ?? 'npx amxts';
+}
+
+/** A command line as it is shown: arguments with spaces quoted. */
+export function commandLine(argv) {
+	return argv.map(arg => (/\s/.test(arg) ? `"${arg}"` : arg)).join(' ');
+}
+
+/**
+ * Runs a command. Through the shell on Windows, where npm and bun may be
+ * .cmd files; `quiet` collects the output instead of showing it, for a
+ * spinner, and hands it back for an error.
+ *
+ * @returns {Promise<{ code: number, output: string }>} its exit code, and its output when quiet
+ */
+export function run(argv, { cwd = process.cwd(), quiet = false, env } = {}) {
+	return new Promise((done) => {
+		const windows = process.platform === 'win32';
+		const [command, ...args] = windows ? [commandLine(argv)] : argv;
+		const child = spawn(command, args, {
+			cwd,
+			env: env ? { ...process.env, ...env } : process.env,
+			shell: windows,
+			stdio: quiet ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+			windowsHide: true,
+		});
+		let output = '';
+		child.stdout?.on('data', (chunk) => {
+			output += chunk;
+		});
+		child.stderr?.on('data', (chunk) => {
+			output += chunk;
+		});
+		child.on('error', error => done({ code: 127, output: `${output}${error.message}` }));
+		child.on('close', code => done({ code: code ?? 1, output }));
+	});
+}

package/src/server.mjs

@@ -0,0 +1,72 @@
+// The server a project deploys to: its addons/amxts folder, AMXTS_SERVER in
+// the project's .env. `amxts init` asks for it; `dev` and `build --deploy`
+// ask the same when it is not set - in a terminal. Elsewhere (CI, a pipe)
+// nothing is asked, and the build says it is missing.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import * as p from '@clack/prompts';
+import { setting } from './core.mjs';
+import { runScript } from './pm.mjs';
+import { c } from './ui.mjs';
+
+/** Whether a command may ask: a terminal, and not CI. */
+export function canAsk() {
+	return Boolean(process.stdin.isTTY) && !p.isCI();
+}
+
+/**
+ * Asks for the server's addons/amxts folder. `required`: an empty answer is
+ * not taken. The answer, or clack's cancel symbol on Ctrl+C.
+ * @param {string} pm the project's package manager, for the words
+ * @param {{ required?: boolean }} [options]
+ */
+export function askServer(pm, { required = false } = {}) {
+	return p.text({
+		message: `Where is the server? ${c.dim(`its addons/amxts folder, for ${runScript(pm, 'dev')}${required ? '' : ' - empty to skip'}`)}`,
+		placeholder: process.platform === 'win32' ? 'D:/hlds/cstrike/addons/amxts' : '/srv/hlds/cstrike/addons/amxts',
+		defaultValue: '',
+		validate: value => (required && !value?.trim() ? 'The plugins are deployed there: the server\'s addons/amxts folder' : undefined),
+	});
+}
+
+/** The warning for a server folder that is not there. */
+export function missingServer(server) {
+	return `${server} is not there yet: dev builds, and deploys once it is.`;
+}
+
+/** `.env`'s lines for the server. */
+export function serverEnv(server) {
+	const hint = server ? '' : '# Left empty, amxts dev asks for it - e.g. D:/hlds/cstrike/addons/amxts.\n';
+	return `# Where amxts dev deploys: the addons/amxts folder of the server.\n${hint}AMXTS_SERVER=${server.replace(/\\/g, '/')}\n`;
+}
+
+/** Sets AMXTS_SERVER in the project's .env: on its line when it has one, else after what is there. */
+export function saveServer(root, server) {
+	const path = join(root, '.env');
+	const text = existsSync(path) ? readFileSync(path, 'utf8') : '';
+	const line = /^[ \t]*AMXTS_SERVER[ \t]*=.*$/m;
+	writeFileSync(path, line.test(text)
+		? text.replace(line, `AMXTS_SERVER=${server.replace(/\\/g, '/')}`)
+		: `${text}${text && !text.endsWith('\n') ? '\n' : ''}${serverEnv(server)}`);
+}
+
+/**
+ * AMXTS_SERVER for a command that deploys. When it is not set and the
+ * command may ask, it is asked, written to .env and set for the build.
+ * @param {string} root the project's folder
+ * @param {string} pm its package manager
+ */
+export async function ensureServer(root, pm) {
+	if (setting(root, 'AMXTS_SERVER') || !canAsk()) return;
+	p.log.warn('AMXTS_SERVER is not set: where should the plugins go?');
+	const server = await askServer(pm, { required: true });
+	if (p.isCancel(server)) {
+		p.cancel('Nothing was built.');
+		process.exit(1);
+	}
+	saveServer(root, server);
+	process.env.AMXTS_SERVER = server;
+	p.log.success(`Wrote AMXTS_SERVER=${server.replace(/\\/g, '/')} to .env`);
+	if (!existsSync(server)) p.log.warn(missingServer(server));
+}

package/src/system.mjs

@@ -0,0 +1,32 @@
+// Which system a project's server runs, Windows or Linux: the build compiles
+// each plugin in that system's object format, and a plugin built for one does
+// not load on the other.
+//
+// The build decides it (the core's `serverSystem()`, through cli-api): --os,
+// AMXTS_SERVER_OS in .env, what the AMXTS_SERVER folder holds, this machine.
+// `amxts init` needs it before a core is installed, so it reads the server's
+// folder the same way here - hlds_linux or hlds.exe beside the game - and
+// asks when there is nothing to read.
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import process from 'node:process';
+
+/** The systems, as `--os` and AMXTS_SERVER_OS name them. */
+export const SYSTEMS = { windows: 'Windows', linux: 'Linux' };
+
+/** This machine's system. */
+export const HOST_SYSTEM = process.platform === 'win32' ? 'windows' : 'linux';
+
+/**
+ * What the server's files say it runs, or null: `server` is its addons/amxts,
+ * so hlds is three folders up.
+ * @param {string} server
+ * @returns {'windows' | 'linux' | null} the system, or null
+ */
+export function serverSystemOf(server) {
+	if (!server) return null;
+	const hlds = resolve(server, '..', '..', '..');
+	if (existsSync(join(hlds, 'hlds_linux'))) return 'linux';
+	if (existsSync(join(hlds, 'hlds.exe'))) return 'windows';
+	return null;
+}

package/src/template.mjs

@@ -0,0 +1,74 @@
+// The starters in templates/ are written as the files they become, with
+// {{placeholders}} and conditional blocks:
+//
+//   // #if menu-core            kept only when the flag is on
+//   // #if !lint                kept only when it is off
+//   // #endif
+//
+// (`<!-- #if x -->` in Markdown, `# #if x` in .gitignore). A file named `_x`
+// is written as `.x`: npm leaves a .gitignore out of a published package.
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/** The {{author}} a starter is written with: git's user.name, else "you". */
+export function gitAuthor() {
+	return spawnSync('git', ['config', 'user.name'], { encoding: 'utf8' }).stdout?.trim() || 'you';
+}
+
+const IF = /^\s*(?:\/\/|<!--|#)\s*#if\s+(!?)([\w-]+)/;
+const ENDIF = /^\s*(?:\/\/|<!--|#)\s*#endif\b/;
+
+/**
+ * @param {string} text
+ * @param {Record<string, string>} values
+ * @param {Record<string, boolean>} flags
+ */
+export function fill(text, values, flags = {}) {
+	const lines = [];
+	let keep = true;
+	for (const line of text.split('\n')) {
+		const open = line.match(IF);
+		if (open) {
+			keep = open[1] === '!' ? !flags[open[2]] : Boolean(flags[open[2]]);
+			continue;
+		}
+		if (ENDIF.test(line)) {
+			keep = true;
+			continue;
+		}
+		if (keep) lines.push(line);
+	}
+	return lines.join('\n').replace(/\{\{([\w.-]+)\}\}/g, (whole, key) => values[key] ?? whole);
+}
+
+/**
+ * Writes a template folder into `to`. `skip` leaves a file out by its path in
+ * the template; a file that fills to nothing but blank lines is left out too.
+ * Returns the paths written, relative to `to`.
+ */
+export function copyTemplate(from, to, values, flags = {}, skip = () => false, base = '') {
+	const written = [];
+	for (const entry of readdirSync(from)) {
+		const source = join(from, entry);
+		const path = base ? `${base}/${entry}` : entry;
+		if (skip(path)) continue;
+		const name = fill(entry.replace(/^_/, '.'), values, flags);
+		if (statSync(source).isDirectory()) {
+			written.push(...copyTemplate(source, join(to, name), values, flags, skip, path).map(each => `${name}/${each}`));
+			continue;
+		}
+		const text = fill(readFileSync(source, 'utf8'), values, flags);
+		if (!/\S/.test(text)) continue;
+		mkdirSync(to, { recursive: true });
+		writeFileSync(join(to, name), text);
+		written.push(name);
+	}
+	return written;
+}
+
+/** Writes one file, making its folder. */
+export function writeFile(path, text) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, text);
+}

package/src/ui.mjs

@@ -0,0 +1,101 @@
+// How the amxts command talks: colors when the terminal has them, one line
+// per step, and an error as one line with a hint under it. The stack of an
+// error is printed only with --debug (or AMXTS_DEBUG=1).
+import process from 'node:process';
+
+/** Whether the output takes colors: a terminal, and NO_COLOR not set; FORCE_COLOR wins. */
+function colorful(stream = process.stdout) {
+	if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0') return true;
+	if (process.env.NO_COLOR !== undefined || process.env.TERM === 'dumb') return false;
+	return Boolean(stream.isTTY);
+}
+
+const enabled = colorful();
+
+function paint(open, close) {
+	return text => (enabled ? `\x1B[${open}m${text}\x1B[${close}m` : String(text));
+}
+
+export const c = {
+	bold: paint(1, 22),
+	dim: paint(2, 22),
+	red: paint(31, 39),
+	green: paint(32, 39),
+	yellow: paint(33, 39),
+	blue: paint(34, 39),
+	magenta: paint(35, 39),
+	cyan: paint(36, 39),
+	gray: paint(90, 39),
+};
+
+/** An error the user can do something about: the message, and what to do. */
+export class CliError extends Error {
+	/**
+	 * @param {string} message one line: what went wrong
+	 * @param {string} [hint] one or more lines: what to do about it
+	 */
+	constructor(message, hint) {
+		super(message);
+		this.name = 'CliError';
+		this.hint = hint;
+	}
+}
+
+export const debug = () => process.argv.includes('--debug') || process.env.AMXTS_DEBUG === '1';
+
+export const log = {
+	info: text => console.log(`${c.cyan('i')} ${text}`),
+	success: text => console.log(`${c.green('✔')} ${text}`),
+	warn: text => console.log(`${c.yellow('▲')} ${text}`),
+	step: text => console.log(`${c.cyan('◇')} ${text}`),
+	error: text => process.stderr.write(`${c.red('✖')} ${text}\n`),
+	hint: text => process.stderr.write(`${String(text).split('\n').map(line => `  ${c.dim(line)}`).join('\n')}\n`),
+};
+
+/** An error, printed as the user should see it: one line and its hint; the stack only with --debug. */
+export function report(error) {
+	if (error instanceof CliError) {
+		log.error(error.message);
+		if (error.hint) log.hint(error.hint);
+	} else {
+		const [first, ...rest] = (error instanceof Error ? error.message : String(error)).trim().split('\n');
+		log.error(first);
+		if (rest.length) process.stderr.write(`${rest.map(line => `  ${line}`).join('\n')}\n`);
+		if (!debug()) log.hint('Run it again with --debug to see where it happened.');
+	}
+	if (debug() && error instanceof Error && error.stack) process.stderr.write(`${c.gray(error.stack)}\n`);
+}
+
+/** The line a command starts with: `amxts 0.1.0 · build`. */
+export function banner(version, what) {
+	console.log(`${c.bold(c.cyan('amxts'))} ${c.dim(version)}${what ? c.dim(` · ${what}`) : ''}`);
+}
+
+/** The closest of `known` to `given`, when it is close enough to be a typo. */
+export function closest(given, known) {
+	let best = null;
+	let distance = Infinity;
+	for (const each of known) {
+		const d = levenshtein(given.toLowerCase(), each.toLowerCase());
+		if (d < distance) {
+			best = each;
+			distance = d;
+		}
+	}
+	const prefix = given.length >= 2 ? known.find(each => each.startsWith(given)) : undefined;
+	if (prefix) return prefix;
+	return distance <= (given.length <= 3 ? 1 : 2) ? best : null;
+}
+
+/** Edits between two words, a swap of neighbours counted as one: `buidl` is one from `build`. */
+function levenshtein(a, b) {
+	const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array.from({ length: b.length }, (_, j) => (i === 0 ? j + 1 : 0))]);
+	for (let i = 1; i <= a.length; i++) {
+		for (let j = 1; j <= b.length; j++) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+			if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+		}
+	}
+	return d[a.length][b.length];
+}

package/templates/module/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) {{year}} {{author}}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.