revojs 0.3.6 → 0.3.8

package/dist/bin/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createCommandTree, runCommands } from "../commands/index.js";
+import { createCommandTree, formatError, runCommands } from "../commands/index.js";
 import { installBase64 } from "./base64.js";
 import { createRunnableDevEnvironment, createServer, isRunnableDevEnvironment, loadEnv } from "vite";
 import { parseArgs } from "util";
@@ -63,7 +63,7 @@ try {
 	});
 } catch (error) {
 	console.error(error);
-	process.exitCode = 1;
+	process.exitCode = formatError(error).exitCode;
 } finally {
 	await server.close();
 	process.exit();

package/dist/commands/index.d.ts

@@ -12,9 +12,11 @@ export interface CommandArgument extends ParseArgsOptionDescriptor {
     description?: string;
 }
 export type CommandArguments = ParseArgsOptionsConfig & Record<string, CommandArgument>;
+export type CommandFlagValues = Record<string, string | boolean | Array<string | boolean> | undefined>;
 export interface CommandContext<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
     input: Array<string>;
     arguments: CommandValues<T>;
+    flags: CommandFlagValues;
     environment?: RunnableDevEnvironment;
 }
 export interface Command<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
@@ -42,6 +44,10 @@ export interface CommandMatch {
     path: Array<string>;
     command?: Command<CommandArguments>;
 }
+export interface CommandSelectOption<T> {
+    label: string;
+    value: T;
+}
 export interface CommandHelpOptions {
     name: string;
     description?: string;
@@ -58,13 +64,18 @@ export interface CommandRunOptions {
     sections?: Record<string, Array<CommandHelpEntry>>;
     run: (command: Command<CommandArguments>, context: CommandContext<CommandArguments>) => Awaitable<void>;
 }
+export declare class CommandError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode?: number, options?: ErrorOptions);
+}
 export declare function defineCommand<const T extends ParseArgsOptionsConfig>(command: Command<T>): Command<T>;
 export declare function createCommandTree(commands: CommandLoaders): Promise<CommandTree>;
 export declare function findCommand(tree: CommandTree, positionals: Array<string>): CommandMatch;
 export declare function formatSection(title: string, entries: Array<CommandHelpEntry>): string[];
 export declare function formatFlag(flag: CommandFlag): string;
 export declare function formatHelp(options: CommandHelpOptions): string;
-export declare function parseCommand(command: Command<CommandArguments>, args: Array<string>, path: Array<string>): {
+export declare function toCommandArguments(flags?: Array<CommandFlag>): CommandArguments;
+export declare function parseCommand(command: Command<CommandArguments>, args: Array<string>, path: Array<string>, flags?: Array<CommandFlag>): {
     values: {
         [longOption: string]: string | boolean | undefined;
     } & {
@@ -72,4 +83,14 @@ export declare function parseCommand(command: Command<CommandArguments>, args: A
     };
     positionals: string[];
 };
-export declare function runCommands(options: CommandRunOptions): Promise<0 | 1>;
+export declare function runCommands(options: CommandRunOptions): Promise<0 | 2>;
+export declare function isInteractive(): boolean;
+export declare function prompt(question: string, fallback?: string): Promise<string>;
+export declare function confirm(question: string): Promise<boolean>;
+export declare function select<T>(question: string, choices: Array<CommandSelectOption<T>>): Promise<T>;
+export declare function formatTable(header: Array<string>, rows: Array<Array<string>>): string;
+export declare function formatError(error: unknown, json?: boolean): {
+    exitCode: number;
+    text: string;
+};
+export declare const USAGE_EXIT_CODE = 2;

package/dist/commands/index.js

@@ -1,5 +1,14 @@
+import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 //#region src/commands/index.ts
+var CommandError = class extends Error {
+	exitCode;
+	constructor(message, exitCode = 1, options) {
+		super(message, options);
+		this.name = "CommandError";
+		this.exitCode = exitCode;
+	}
+};
 function defineCommand(command) {
 	return command;
 }
@@ -75,7 +84,19 @@ function formatHelp(options) {
 	}))), ...formatSection("Commands", commands));
 	return lines.join("\n");
 }
-function parseCommand(command, args, path) {
+function toCommandArguments(flags = []) {
+	const options = {};
+	for (const flag of flags) {
+		const option = {
+			type: flag.type,
+			multiple: flag.multiple ?? false
+		};
+		if (flag.short) option.short = flag.short;
+		options[flag.name] = option;
+	}
+	return options;
+}
+function parseCommand(command, args, path, flags) {
 	const consumable = [...path];
 	return parseArgs({
 		args: args.filter((argument) => {
@@ -87,6 +108,7 @@ function parseCommand(command, args, path) {
 		strict: false,
 		allowPositionals: true,
 		options: {
+			...toCommandArguments(flags),
 			...command.arguments,
 			help: {
 				type: "boolean",
@@ -101,11 +123,14 @@ async function runCommands(options) {
 		args: options.args,
 		strict: false,
 		allowPositionals: true,
-		options: { help: {
-			type: "boolean",
-			short: "h",
-			default: false
-		} }
+		options: {
+			...toCommandArguments(options.flags),
+			help: {
+				type: "boolean",
+				short: "h",
+				default: false
+			}
+		}
 	});
 	const helpRequested = parsed.values.help === true || parsed.positionals[0] === "help";
 	const match = findCommand(options.tree, parsed.positionals);
@@ -120,18 +145,88 @@ async function runCommands(options) {
 	};
 	if (!match.command || helpRequested) {
 		help();
-		return helpRequested || match.command ? 0 : 1;
+		return helpRequested || match.command ? 0 : 2;
 	}
-	const context = parseCommand(match.command, options.args, match.path);
+	const context = parseCommand(match.command, options.args, match.path, options.flags);
 	if (context.values.help) {
 		help();
 		return 0;
 	}
+	const flags = {};
+	for (const flag of options.flags ?? []) flags[flag.name] = context.values[flag.name];
 	await options.run(match.command, {
 		input: context.positionals,
-		arguments: context.values
+		arguments: context.values,
+		flags
 	});
 	return 0;
 }
+function isInteractive() {
+	return process.stdin.isTTY === true && process.stderr.isTTY === true;
+}
+async function prompt(question, fallback) {
+	if (!isInteractive()) throw new CommandError(`${question} Answer missing, pass it as an argument.`, 2);
+	const readline = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	try {
+		return (await readline.question(fallback ? `${question} (${fallback}) ` : `${question} `)).trim() || fallback || "";
+	} finally {
+		readline.close();
+	}
+}
+async function confirm(question) {
+	const answer = await prompt(`${question} [y/N]`);
+	return [
+		"y",
+		"yes",
+		"j",
+		"ja"
+	].includes(answer.toLowerCase());
+}
+async function select(question, choices) {
+	if (choices.length === 0) throw new CommandError(`${question} No options available.`, 2);
+	const lines = [question];
+	for (const [index, choice] of choices.entries()) lines.push(`  ${index + 1}. ${choice.label}`);
+	while (true) {
+		const answer = Number(await prompt(`${lines.join("\n")}\n>`, "1"));
+		const choice = choices[answer - 1];
+		if (Number.isInteger(answer) && choice) return choice.value;
+		lines.splice(0, lines.length, `Choose a number from 1 to ${choices.length}.`);
+	}
+}
+function formatTable(header, rows) {
+	const widths = new Array();
+	for (const row of [header, ...rows]) for (const [index, cell] of row.entries()) widths[index] = Math.max(widths[index] ?? 0, cell.length);
+	const lines = new Array();
+	for (const row of [header, ...rows]) {
+		const cells = new Array();
+		for (const [index, cell] of row.entries()) if (index === row.length - 1) cells.push(cell);
+		else cells.push(cell.padEnd(widths[index] ?? 0));
+		lines.push(cells.join("  ").trimEnd());
+	}
+	return lines.join("\n");
+}
+function formatError(error, json = false) {
+	let message = String(error);
+	let exitCode = 1;
+	if (error instanceof CommandError) {
+		message = error.message;
+		exitCode = error.exitCode;
+	} else if (error instanceof Error) message = error.message;
+	if (json) return {
+		exitCode,
+		text: JSON.stringify({
+			error: message,
+			exitCode
+		})
+	};
+	return {
+		exitCode,
+		text: message
+	};
+}
+var USAGE_EXIT_CODE = 2;
 //#endregion
-export { createCommandTree, defineCommand, findCommand, formatFlag, formatHelp, formatSection, parseCommand, runCommands };
+export { CommandError, USAGE_EXIT_CODE, confirm, createCommandTree, defineCommand, findCommand, formatError, formatFlag, formatHelp, formatSection, formatTable, isInteractive, parseCommand, prompt, runCommands, select, toCommandArguments };

package/dist/package.js

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "revojs";
-var version = "0.3.6";
+var version = "0.3.8";
 var repository = {
 	"type": "git",
 	"url": "git+https://github.com/tellua/revojs.git"
@@ -40,7 +40,7 @@ var dependencies = {
 	"vite": "^8.3.4"
 };
 var devDependencies = {
-	"@revojs/tsconfig": "0.3.6",
+	"@revojs/tsconfig": "0.3.8",
 	"@types/node": "^26.6.4"
 };
 var optionalDependencies = { "typescript": "^7.0.2" };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "revojs",
-    "version": "0.3.6",
+    "version": "0.3.8",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -47,7 +47,7 @@
         "vite": "^8.3.4"
     },
     "devDependencies": {
-        "@revojs/tsconfig": "0.3.6",
+        "@revojs/tsconfig": "0.3.8",
         "@types/node": "^26.6.4"
     },
     "optionalDependencies": {