@amxts/cli 0.1.0

package/src/core.mjs

@@ -0,0 +1,272 @@
+// The core a command works with, and Bun, which runs the core's build.
+//
+// The command is a package of its own, @amxts/cli; the core is the project's
+// - its node_modules/@amxts/core, found from the folder the command runs in.
+// The command talks to it only through
+// `@amxts/core/cli-api`: the core's version, the contract version (`cliApi`),
+// and the tasks it runs (`task()`). A core this command cannot drive is an
+// error that says which of the two to update.
+//
+// Creating a project or a module needs no core: they run on their own.
+// `--local` takes the core from this machine instead of npm (localCore()).
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { addArgs, commandLine, detectPackageManager, versionOf } from './pm.mjs';
+import { CliError, debug } from './ui.mjs';
+
+/** The command's own package folder: packages/cli in its repository. */
+export const CLI_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
+export const CLI_PACKAGE = readJson(join(CLI_DIR, 'package.json'));
+export const VERSION = String(CLI_PACKAGE.version);
+
+/** The cores this command works with: the range a new project asks for. */
+export const CORE_RANGE = '^0.1.0';
+/** The version of `@amxts/core/cli-api` this command speaks. */
+export const CLI_API = 3;
+
+/**
+ * Run from a checkout of the command's repository (npm link, a clone) rather
+ * than from npm: then a new project takes the core and the official modules
+ * from this machine by default, as --local says - they are not on npm to fetch.
+ */
+export const FROM_SOURCE = existsSync(join(CLI_DIR, '..', '..', '.git')) && readJson(join(CLI_DIR, '..', '..', 'package.json'))?.name === 'amxts-cli';
+
+/** A JSON file's contents, or null when it is missing or not JSON. */
+export function readJson(path) {
+	try {
+		return JSON.parse(readFileSync(path, 'utf8'));
+	} catch {
+		return null;
+	}
+}
+
+/** A setting as the build sees it: the environment, else the project's .env (which Bun reads). */
+export function setting(dir, name) {
+	if (process.env[name]) return process.env[name];
+	const env = join(dir, '.env');
+	if (!existsSync(env)) return '';
+	const line = readFileSync(env, 'utf8').split(/\r?\n/).find(each => each.trim().split('=')[0].trim() === name);
+	return line ? line.slice(line.indexOf('=') + 1).trim().replace(/^(["'])(.*)\1$/, '$2') : '';
+}
+
+/**
+ * @typedef {object} Core
+ * @property {string} dir its folder (a link resolved to its target)
+ * @property {string} version its version
+ * @property {boolean} fromSource whether it is a checkout rather than a package from npm
+ * @property {typeof import('@amxts/core/cli-api')} api what it offers the command
+ */
+
+/** The project's folder: the nearest one up with a package.json, or null. */
+export function findProject(from = process.cwd()) {
+	for (let at = resolve(from); ; at = dirname(at)) {
+		if (existsSync(join(at, 'package.json'))) return at;
+		if (dirname(at) === at) return null;
+	}
+}
+
+/** Where @amxts/core is installed for a folder, resolved from it as Node resolves it; null when it is not. */
+export function coreDirFrom(dir) {
+	try {
+		return dirname(createRequire(join(dir, 'package.json')).resolve('@amxts/core/package.json'));
+	} catch {
+		return null;
+	}
+}
+
+const loaded = new Map();
+
+/** "2.1.0" as [2, 1, 0]; a pre-release tag is left out. */
+function parts(version) {
+	return String(version).split('-')[0].split('.').map(each => Number.parseInt(each, 10) || 0);
+}
+
+/** Whether a version is in a caret range: `^0.1.0` takes 0.1.x from 0.1.0 up. */
+export function satisfies(version, range = CORE_RANGE) {
+	const [major, minor, patch] = parts(version);
+	const [wantMajor, wantMinor, wantPatch] = parts(range.replace(/^\^/, ''));
+	if (major !== wantMajor) return false;
+	// Below 1.0 the minor is the breaking number: ^0.1.0 does not take 0.2.0.
+	if (major === 0 && minor !== wantMinor) return false;
+	return minor > wantMinor || (minor === wantMinor && patch >= wantPatch);
+}
+
+/** Whether a version is past a caret range, not below it: its major, or below 1.0 its minor, is the higher. */
+function pastRange(version, range = CORE_RANGE) {
+	const [major, minor] = parts(version);
+	const [wantMajor, wantMinor] = parts(range.replace(/^\^/, ''));
+	return major !== wantMajor ? major > wantMajor : major === 0 && minor > wantMinor;
+}
+
+/** What to do about a core this command cannot drive: update the command when the core is the newer, else the core. */
+function updateHint(coreIsNewer) {
+	const pm = detectPackageManager();
+	return coreIsNewer
+		? `Update the command: npm install -g @amxts/cli@latest - a project's own ${pm === 'npm' ? 'npx amxts' : `${pm} amxts`} comes with its core`
+		: `Update the core: ${commandLine(addArgs(pm, ['@amxts/core@latest']))}`;
+}
+
+/**
+ * The core in a folder, checked: its version is one this command works with,
+ * and it speaks the same `cli-api`.
+ * @param {string} dir the core's folder
+ * @returns {Promise<Core>} the core, ready to drive
+ */
+export async function loadCore(dir) {
+	if (loaded.has(dir)) return loaded.get(dir);
+	const version = String(readJson(join(dir, 'package.json'))?.version ?? '0.0.0');
+	if (!satisfies(version)) {
+		throw new CliError(`@amxts/core ${version} is not a core amxts ${VERSION} works with (${CORE_RANGE})`, updateHint(pastRange(version)));
+	}
+	let api;
+	try {
+		const entry = createRequire(join(dir, 'package.json')).resolve('@amxts/core/cli-api');
+		api = await import(pathToFileURL(entry).href);
+	} catch (error) {
+		if (debug()) throw error;
+		throw new CliError(`@amxts/core ${version} has no cli-api, which amxts ${VERSION} runs it through`, updateHint(false));
+	}
+	if (api.cliApi !== CLI_API) {
+		throw new CliError(`@amxts/core ${version} speaks cli-api ${api.cliApi}, amxts ${VERSION} speaks ${CLI_API}`, updateHint(api.cliApi > CLI_API));
+	}
+	/** @type {Core} */
+	const core = { dir, version, fromSource: Boolean(api.fromSource), api };
+	loaded.set(dir, core);
+	return core;
+}
+
+/** The project's folder, or an error that says how to create one. */
+export function needProject(from = process.cwd()) {
+	const project = findProject(from);
+	if (project) return project;
+	throw new CliError('This folder is not in a project: no package.json here or above', 'Create one with: npm create amxts@latest');
+}
+
+/**
+ * The core installed for a folder, checked; null when there is none.
+ * @returns {Promise<Core | null>} the core, or null
+ */
+export async function installedCore(from = process.cwd()) {
+	const dir = coreDirFrom(from);
+	return dir ? loadCore(dir) : null;
+}
+
+/**
+ * The project's core: @amxts/core as the folder the command runs in has it
+ * installed. An error that says how to install it when it is not.
+ * @returns {Promise<Core>} the core, ready to drive
+ */
+export async function projectCore(from = process.cwd()) {
+	const core = await installedCore(from);
+	if (core) return core;
+	const project = needProject(from);
+	throw new CliError('@amxts/core is not installed in this project', `Install it: ${commandLine(addArgs(detectPackageManager(project), ['@amxts/core']))}`);
+}
+
+/**
+ * The core on this machine, for --local: the folder AMXTS_CORE names, else the
+ * one the command itself resolves - its checkout links the core beside it
+ * (its package.json's `file:` link), and an installed command sits next to
+ * the project's core. Null when there is none.
+ * @returns {Promise<Core | null>} the core, or null
+ */
+export async function localCore() {
+	const dir = process.env.AMXTS_CORE ? resolve(process.env.AMXTS_CORE) : coreDirFrom(CLI_DIR);
+	return dir && existsSync(join(dir, 'package.json')) ? loadCore(dir) : null;
+}
+
+/** The local core, or an error that says how to point the command at one. */
+export async function needLocalCore() {
+	const core = await localCore();
+	if (core) return core;
+	throw new CliError('--local: there is no core on this machine to take', 'Set AMXTS_CORE to the core\'s folder (a checkout of @amxts/core), or run npm install in the command\'s checkout, which links the core beside it.');
+}
+
+/**
+ * The TypeScript parser, which amxts.config.ts is read with: the project's
+ * core's, else the one on this machine.
+ * @returns {Promise<typeof import('typescript')>} the typescript module
+ */
+export async function coreTypeScript(from = process.cwd()) {
+	const core = await installedCore(from) ?? await localCore();
+	if (!core) throw new CliError('amxts reads amxts.config.ts with the core\'s TypeScript, and @amxts/core is not installed here', 'Install the project\'s dependencies first.');
+	return core.api.typescript();
+}
+
+const BUN_HINT = [
+	'Bun comes with @amxts/core: install the project\'s dependencies again, letting',
+	'the package manager run bun\'s install script. Where it cannot (no package',
+	'for this platform), install Bun yourself and run the command again:',
+	'  npm install -g bun',
+	process.platform === 'win32' ? '  or: powershell -c "irm bun.sh/install.ps1 | iex"' : '  or: curl -fsSL https://bun.sh/install | bash',
+].join('\n');
+
+let pathVersion;
+
+/** The version of a Bun on PATH, or null when there is none. */
+function bunOnPath() {
+	pathVersion ??= versionOf('bun');
+	return pathVersion;
+}
+
+/**
+ * The Bun the core's tasks and tests run on: the one installed with the core
+ * (its cli-api's bunBinary(), from the `bun` package it depends on), else a
+ * Bun on PATH, as `bun`; null when there is neither.
+ * @param {Core | null} [core]
+ * @returns {string | null} the binary, or `bun`
+ */
+export function bunFor(core) {
+	const own = core?.api.bunBinary?.();
+	if (own) return own;
+	return bunOnPath() ? 'bun' : null;
+}
+
+/** The version of the Bun bunFor() gives, or null. */
+export function bunVersion(core) {
+	const binary = bunFor(core);
+	if (!binary) return null;
+	if (binary === 'bun') return bunOnPath();
+	const run = spawnSync(binary, ['--version'], { encoding: 'utf8' });
+	return run.status === 0 ? run.stdout.trim() : null;
+}
+
+/** The Bun to run, or an error that says how to get one. */
+export function needBun(core, what = 'builds plugins') {
+	const binary = bunFor(core);
+	if (!binary) throw new CliError(`amxts ${what} with Bun, and there is none: not with @amxts/core, not on PATH`, BUN_HINT);
+	return binary;
+}
+
+/**
+ * Runs one of the core's tasks in the current folder, its output straight to
+ * the terminal: `prepare`, `build`, `check`, `typecheck`. Returns its exit code.
+ * @param {Core} core
+ * @param {string} name
+ * @param {string[]} [args]
+ */
+export function runTask(core, name, args = []) {
+	const task = core.api.task(name, args);
+	const env = { ...process.env, ...(debug() ? { AMXTS_DEBUG: '1' } : {}) };
+	if (task.runtime === 'node') {
+		return spawnSync(process.execPath, task.args, { stdio: 'inherit', env }).status ?? 1;
+	}
+	const binary = needBun(core);
+	// A Bun on PATH goes through the shell on Windows, where it may be
+	// bun.cmd; a path with a space is quoted for it.
+	const result = binary === 'bun' && process.platform === 'win32'
+		? spawnSync(commandLine(['bun', ...task.args]), { stdio: 'inherit', shell: true, env })
+		: spawnSync(binary, task.args, { stdio: 'inherit', env });
+	if (result.error) throw new CliError(`Bun did not start: ${result.error.message}`, BUN_HINT);
+	return result.status ?? 1;
+}
+
+/** Runs a task and stops with its exit code when it fails. */
+export function runTaskOrExit(core, name, args = []) {
+	const code = runTask(core, name, args);
+	if (code !== 0) process.exit(code);
+}

package/src/includes.mjs

@@ -0,0 +1,181 @@
+// The includes a project's build looks in besides its own includes/: the ones
+// its server has. They serve what needs Pawn's declarations - a plugin's
+// include contract, the natives and forwards of other Pawn plugins, a Pawn
+// test suite - while the API itself comes generated with the core.
+//
+// - AMXTS_SERVER set, and addons/amxmodx/scripting/include beside it: the
+//   build reads the server's own, exactly what is installed there. Nothing
+//   is fetched.
+// - Otherwise `target` in amxts.config.ts says which server the project is
+//   for: "rehlds" (ReHLDS, ReGameDLL and ReAPI; the default) - ReAPI's
+//   includes, fetched into .amxts/include from the release the core's API is
+//   generated from (its cli-api's includeSources()), sha256 checked; "hlds" -
+//   nothing to fetch, AMX Mod X's own includes come with the core.
+//
+// `amxts prepare` (after every install) and every build make sure of it;
+// `amxts init` does it as it creates the project, and asks the target when no
+// server is known. Everything here is plain Node - fetch and node:zlib - the
+// same on Windows and Linux.
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import process from 'node:process';
+import { inflateRawSync } from 'node:zlib';
+import { readConfigTarget } from './config.mjs';
+import { findProject, runTaskOrExit, setting } from './core.mjs';
+import { c, CliError, log } from './ui.mjs';
+
+/** The servers a project can be for, as `target` in amxts.config.ts and `--target` name them. */
+export const TARGETS = {
+	rehlds: 'ReHLDS + ReGameDLL + ReAPI',
+	hlds: 'plain HLDS',
+};
+
+/** Where the command puts the includes it fetches, in the project. */
+export const FETCHED = '.amxts/include';
+
+const STAMP = 'source.json';
+
+/** The server's own includes: addons/amxmodx/scripting/include beside AMXTS_SERVER (addons/amxts), or null when it is not there. */
+export function serverIncludes(server) {
+	if (!server) return null;
+	const dir = resolve(server, '..', 'amxmodx', 'scripting', 'include');
+	return existsSync(dir) ? dir : null;
+}
+
+/** Which server a folder of includes is from: ReAPI's reapi.inc says rehlds. */
+export function targetOf(includes) {
+	return existsSync(join(includes, 'reapi.inc')) ? 'rehlds' : 'hlds';
+}
+
+/**
+ * The files of a .zip, by their path inside it: stored and deflated
+ * entries, which is what a release archive has.
+ * @param {Uint8Array} zip
+ * @returns {Map<string, Uint8Array>} the files
+ */
+export function unzip(zip) {
+	const view = new DataView(zip.buffer, zip.byteOffset, zip.byteLength);
+	let end = -1;
+	for (let at = zip.length - 22; at >= Math.max(0, zip.length - 22 - 0xFFFF); at--) {
+		if (view.getUint32(at, true) === 0x06054B50) {
+			end = at;
+			break;
+		}
+	}
+	if (end < 0) throw new Error('not a zip archive');
+	const files = new Map();
+	const decoder = new TextDecoder();
+	let at = view.getUint32(end + 16, true);
+	for (let i = view.getUint16(end + 10, true); i > 0; i--) {
+		if (view.getUint32(at, true) !== 0x02014B50) throw new Error('a broken zip archive');
+		const method = view.getUint16(at + 10, true);
+		const size = view.getUint32(at + 20, true);
+		const nameLength = view.getUint16(at + 28, true);
+		const local = view.getUint32(at + 42, true);
+		const name = decoder.decode(zip.subarray(at + 46, at + 46 + nameLength));
+		at += 46 + nameLength + view.getUint16(at + 30, true) + view.getUint16(at + 32, true);
+		if (name.endsWith('/')) continue;
+		const start = local + 30 + view.getUint16(local + 26, true) + view.getUint16(local + 28, true);
+		const data = zip.subarray(start, start + size);
+		if (method === 0) files.set(name, data);
+		else if (method === 8) files.set(name, new Uint8Array(inflateRawSync(data)));
+		else throw new Error(`${name}: compression method ${method}`);
+	}
+	return files;
+}
+
+/**
+ * Downloads a source as the core pins it and gives its .inc files by name.
+ * @param {{ name: string, version: string, url: string, sha256: string, include?: string }} source
+ */
+export async function fetchIncludes(source) {
+	const hint = `Check the connection, then run amxts prepare - or set AMXTS_SERVER to a server with ${source.name}, whose own includes the build takes.`;
+	let data;
+	try {
+		const response = await fetch(source.url, { signal: AbortSignal.timeout(60_000) });
+		if (!response.ok) throw new Error(`${source.url} answered ${response.status}`);
+		data = new Uint8Array(await response.arrayBuffer());
+	} catch (error) {
+		throw new CliError(`Could not download ${source.name} ${source.version}'s includes: ${error.message}`, hint);
+	}
+	const sha256 = createHash('sha256').update(data).digest('hex');
+	if (sha256 !== source.sha256) {
+		throw new CliError(`${source.name} ${source.version} from ${source.url} is not the file the core pins (sha256 ${sha256})`, 'The release was changed under the same URL; update @amxts/core, or set AMXTS_SERVER to use the server\'s own includes.');
+	}
+	const files = new Map();
+	if (!source.url.endsWith('.zip')) {
+		files.set(basename(new URL(source.url).pathname), data);
+		return files;
+	}
+	for (const [path, content] of unzip(data)) {
+		if (path.startsWith(source.include ?? '') && path.endsWith('.inc')) files.set(basename(path), content);
+	}
+	return files;
+}
+
+/**
+ * @typedef {object} Includes
+ * @property {'server' | 'fetched' | 'core'} from the server's own, fetched into .amxts/include, or AMX Mod X's that come with the core
+ * @property {'rehlds' | 'hlds'} target the server they are for
+ * @property {string | null} dir where they are
+ * @property {string} [version] what was fetched: "ReAPI 5.26.0.338"
+ * @property {boolean} [fetched] fetched just now
+ */
+
+/**
+ * Makes sure the project has the includes of the server it is for, and says
+ * where they are. A download that fails is a CliError that says what to do.
+ * @param {import('./core.mjs').Core} core the project's core
+ * @param {string} root the project's folder
+ * @param {{ target?: string }} [options] the target, when the config is not written yet
+ * @returns {Promise<Includes>} where the includes are
+ */
+export async function ensureIncludes(core, root, options = {}) {
+	const own = serverIncludes(setting(root, 'AMXTS_SERVER'));
+	if (own) return { from: 'server', target: targetOf(own), dir: own };
+
+	const target = options.target ?? (await readConfigTarget(root)) ?? 'rehlds';
+	const dir = join(root, FETCHED);
+	if (target === 'hlds') {
+		rmSync(dir, { recursive: true, force: true });
+		return { from: 'core', target, dir: null };
+	}
+	const source = core.api.includeSources?.().reapi;
+	if (!source) throw new CliError(`@amxts/core ${core.version} does not say which ReAPI release to fetch`, 'Update the core.');
+	const version = `${source.name} ${source.version}`;
+	const stamp = join(dir, STAMP);
+	try {
+		if (JSON.parse(readFileSync(stamp, 'utf8')).sha256 === source.sha256) return { from: 'fetched', target, dir, version };
+	} catch {}
+
+	const files = await fetchIncludes(source);
+	rmSync(dir, { recursive: true, force: true });
+	mkdirSync(dir, { recursive: true });
+	for (const [name, content] of files) writeFileSync(join(dir, name), content);
+	writeFileSync(stamp, `${JSON.stringify({ name: source.name, version: source.version, license: source.license, home: source.home, sha256: source.sha256 }, null, '\t')}\n`);
+	return { from: 'fetched', target, dir, version, fetched: true };
+}
+
+/**
+ * What `amxts prepare` does, and dev, build and typecheck first: the
+ * server's includes, then the core's prepare task (the editor config). An
+ * include that cannot be fetched is a warning - the build needs one only
+ * where a plugin names it, and says so there. `quiet`, for a command that
+ * says what the project is itself (dev, build, typecheck): the core's line
+ * about the editor config only with --debug.
+ * @param {import('./core.mjs').Core} core the project's core
+ * @param {{ quiet?: boolean }} [options]
+ */
+export async function prepare(core, { quiet = false } = {}) {
+	const root = findProject() ?? process.cwd();
+	try {
+		const includes = await ensureIncludes(core, root);
+		if (includes.fetched) log.success(`Fetched ${includes.version}'s includes ${c.dim(`(${FETCHED})`)}`);
+	} catch (error) {
+		if (!(error instanceof CliError)) throw error;
+		log.warn(error.message);
+		if (error.hint) log.hint(error.hint);
+	}
+	runTaskOrExit(core, 'prepare', quiet ? ['--quiet'] : []);
+}

package/src/info.mjs

@@ -0,0 +1,85 @@
+// `amxts info`: what a bug report needs - the versions of
+// everything the build depends on, the project, its modules and its server.
+// It works anywhere: outside a project it says so and goes on.
+import { existsSync } from 'node:fs';
+import { release } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
+import { readConfigModules } from './config.mjs';
+import { bunFor, bunVersion, CLI_DIR, installedCore, readJson, setting, VERSION } from './core.mjs';
+import { detectPackageManager, versionOf } from './pm.mjs';
+import { c, CliError } from './ui.mjs';
+
+/** The project's core, or why it cannot be used: not installed, or not one this command works with. */
+async function core(dir) {
+	try {
+		const found = await installedCore(dir);
+		return { core: found, problem: found ? '' : c.dim('not installed here') };
+	} catch (error) {
+		if (error instanceof CliError) return { core: null, problem: c.red(`${error.message} - ${error.hint}`) };
+		throw error;
+	}
+}
+
+/**
+ * The system the build compiles for, as the core decides it from .env and the
+ * server's folder: "Linux (hlds_linux)". A core without serverSystem() builds
+ * for this machine.
+ */
+function serverSystem(found, dir, server) {
+	if (!found) return c.dim('unknown without the core');
+	if (!found.api.serverSystem) return c.dim('this machine\'s (the core does not tell)');
+	try {
+		const env = { ...process.env, AMXTS_SERVER: server, AMXTS_SERVER_OS: setting(dir, 'AMXTS_SERVER_OS') };
+		const decided = found.api.serverSystem([], env);
+		const note = decided.from === 'host' ? c.dim(' - set AMXTS_SERVER, AMXTS_SERVER_OS or pass --os when the server runs another') : '';
+		return `${found.api.describeSystem(decided)}${note}`;
+	} catch (error) {
+		return c.red(error.message);
+	}
+}
+
+export async function info() {
+	const dir = process.cwd();
+	const project = readJson(join(dir, 'package.json'));
+	const pm = detectPackageManager(dir);
+	const { core: found, problem } = await core(dir);
+	const tools = found?.api.toolchain();
+	const modules = found ? await readConfigModules(dir) : null;
+	const server = setting(dir, 'AMXTS_SERVER');
+	const system = serverSystem(found, dir, server);
+	const bun = bunFor(found);
+	const bunV = bunVersion(found);
+
+	const rows = [
+		['Operating system', `${process.platform === 'win32' ? 'Windows' : process.platform} ${release()} (${process.arch})`],
+		['Node.js', process.version.replace(/^v/, '')],
+		['Bun', bunV ? `${bunV} ${c.dim(bun === 'bun' ? '(on PATH)' : bun)}` : c.red('none - not with @amxts/core, not on PATH; the build needs it')],
+		['Package manager', `${pm} ${versionOf(pm) ?? c.red('not installed')}`],
+		['@amxts/cli', `${VERSION} ${c.dim(CLI_DIR)}`],
+		['@amxts/core', found ? `${found.version} ${c.dim(found.dir)}` : problem],
+		...(tools
+			? [
+					['AssemblyScript', `${tools.assemblyscript.version ?? '?'} + amxts patch${tools.assemblyscript.built ? '' : c.red(' (not built: runtime/deps/assemblyscript)')}`],
+					['WAMR', `${tools.wamr.version ?? '?'} + amxts patch, wamrc ${tools.wamr.wamrc ? 'found' : c.red('missing')}`],
+				]
+			: []),
+		['Project', project ? `${project.name ?? '(no name)'} ${c.dim(dir)}` : c.dim('none here (no package.json)')],
+		['Modules', modules === null
+			? c.dim(found ? 'no amxts.config.ts' : 'unknown without the core')
+			: modules.length === 0
+				? c.dim('none')
+				: modules.map((name) => {
+						const version = readJson(join(dir, 'node_modules', name, 'package.json'))?.version;
+						return version ? `${name} ${version}` : `${name} ${c.red('(not installed)')}`;
+					}).join(', ')],
+		['AMXTS_SERVER', server ? `${server}${existsSync(server) ? '' : c.red(' (not found)')}` : c.dim('not set')],
+		['Server system', system],
+		['AMXTS_DOCS_LANG', setting(dir, 'AMXTS_DOCS_LANG') || c.dim('en')],
+	];
+	const width = Math.max(...rows.map(([label]) => label.length));
+	console.log(c.bold('amxts info') + c.dim(' - paste this into a bug report'));
+	console.log();
+	for (const [label, value] of rows) console.log(`  ${c.dim(label.padEnd(width))}  ${value}`);
+	console.log();
+}

package/src/init-module.mjs

@@ -0,0 +1,117 @@
+// A new module package from templates/module/ - a working module, its
+// playground project and a test:
+//
+//   amxts init --module greeter            ./greeter, package "greeter"
+//   amxts init --module @you/greeter       ./greeter, package "@you/greeter"
+//   amxts init --module greeter --natives  with src/natives.ts: natives for Pawn plugins
+//   amxts init --module greeter --dir x    into ./x
+//
+// The template has the name in its forms and the author (git config
+// user.name) as {{placeholders}}; `// #if natives` blocks are kept only with
+// --natives. The core is a peer dependency, the range this command works with;
+// with --local (the default from a checkout) it is also a dev dependency
+// linked to the core on this machine, since it is not on npm to install.
+import { existsSync, readdirSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import process from 'node:process';
+import { shortName, specFor } from './catalog.mjs';
+import { CLI_DIR, CORE_RANGE, FROM_SOURCE, needLocalCore } from './core.mjs';
+import { LINT_DEPENDENCIES, LINT_SCRIPTS } from './lint.mjs';
+import { detectPackageManager, execAmxts, installArgs, runScript } from './pm.mjs';
+import { copyTemplate, gitAuthor, writeFile } from './template.mjs';
+import { c, CliError, log } from './ui.mjs';
+
+export const MODULE_NAME = /^(?:@[a-z0-9][\w.-]*\/)?[a-z][a-z0-9-]*$/;
+
+/**
+ * @param {{ module: string, natives?: boolean, dir?: string, pm?: string, local?: boolean }} options
+ */
+export async function initModule(options) {
+	const pkgName = options.module;
+	if (!MODULE_NAME.test(pkgName)) {
+		throw new CliError(`"${pkgName}" is not a package name for a module`, 'Lowercase letters, digits and dashes: greeter, @you/greeter');
+	}
+	const natives = Boolean(options.natives);
+
+	/** The package's name without its scope: the module's name - "kill-feed". */
+	const name = shortName(pkgName);
+	const words = name.split('-').filter(Boolean);
+	const camel = words.map((word, i) => (i === 0 ? word : word[0].toUpperCase() + word.slice(1))).join('');
+	const title = words.map(word => word[0].toUpperCase() + word.slice(1)).join(' ');
+
+	const values = {
+		name,
+		package: pkgName,
+		title,
+		camel,
+		configKey: camel,
+		Options: `${title.replace(/ /g, '')}Options`,
+		include: name.replace(/-/g, '_'),
+		year: String(new Date().getFullYear()),
+		author: gitAuthor(),
+	};
+
+	const dir = resolve(options.dir ?? name);
+	if (existsSync(dir) && readdirSync(dir).length > 0) {
+		throw new CliError(`${dir} is there and not empty`, 'Pick another folder with --dir.');
+	}
+
+	const pm = options.pm ?? detectPackageManager();
+	const localCore = (options.local ?? FROM_SOURCE) ? await needLocalCore() : null;
+
+	const written = copyTemplate(join(CLI_DIR, 'templates', 'module'), dir, values, { natives }, path => path === 'src/natives.ts' && !natives);
+
+	const amxts = { module: 'src/index.ts' };
+	if (natives) Object.assign(amxts, { natives: 'src/natives.ts', include: `include/${values.include}.inc` });
+
+	writeFile(join(dir, 'package.json'), `${JSON.stringify({
+		name: pkgName,
+		type: 'module',
+		version: '0.1.0',
+		description: `${title} for amxts plugins.`,
+		license: 'MIT',
+		keywords: ['amxts-module', 'amxmodx', 'counter-strike'],
+		exports: { '.': './src/index.ts' },
+		types: './src/index.ts',
+		files: ['README.md', 'README.ru.md', ...(natives ? ['include'] : []), 'src'],
+		amxts,
+		scripts: {
+			build: 'amxts build',
+			check: 'amxts check',
+			test: 'amxts test',
+			...LINT_SCRIPTS,
+		},
+		peerDependencies: { '@amxts/core': CORE_RANGE },
+		devDependencies: Object.fromEntries(Object.entries({
+			...(localCore ? { '@amxts/core': specFor({ name: '@amxts/core', dir: localCore.dir }, dir, pm) } : {}),
+			...LINT_DEPENDENCIES,
+			'@types/bun': '^1.4.2',
+			'typescript': '^6.0.3',
+		}).sort(([a], [b]) => a.localeCompare(b))),
+	}, null, '\t')}\n`);
+	written.push('package.json');
+
+	// The playground is a project of its own that takes the module by its path,
+	// as a project takes one from npm.
+	writeFile(join(dir, 'playground', 'package.json'), `${JSON.stringify({
+		name: `${name}-playground`,
+		type: 'module',
+		private: true,
+		devDependencies: { [pkgName]: 'file:..' },
+	}, null, '\t')}\n`);
+	written.push('playground/package.json');
+
+	const at = relative(process.cwd(), dir) || '.';
+	for (const file of written.sort()) console.log(`  ${c.dim(`${at}/`)}${file}`);
+	console.log();
+	log.success(`${c.bold(pkgName)} is in ${c.cyan(at)}`);
+
+	console.log(`\n  Next:\n`);
+	for (const line of [
+		`cd ${at}`,
+		installArgs(pm).join(' '),
+		...(natives ? [`${execAmxts(pm)} build   ${c.dim(`# writes include/${values.include}.inc from src/natives.ts`)}`] : []),
+		runScript(pm, 'test'),
+	]) console.log(`    ${c.cyan(line)}`);
+	console.log();
+}