@octanejs/cli 0.0.1 → 0.0.3

package/src/kernel/command.js

@@ -18,6 +18,9 @@
  * @property {CommandEntry[]} [subcommands]
  * @property {boolean} [requiresProject] refuse to run outside a package.json,
  *   for commands that write into one
+ * @property {boolean} [passthrough] read the tokens after a bare `--` as
+ *   `input.rest`. Without it they are a usage error rather than a silent drop,
+ *   on the same reasoning as an unknown flag
  * @property {(ctx: import('./context.js').Ctx, input: CommandInput) => Promise<CommandResult>} [run]
  */
 

package/src/kernel/install.js

@@ -8,6 +8,13 @@ const MANAGERS = {
 	bun: { add: ['add'], dev: '-d' },
 };
 
+/**
+ * The managers this CLI knows how to drive. Derived rather than written out, so
+ * that a flag can never offer a manager `installCommand` would silently answer
+ * with npm's spelling.
+ */
+export const PACKAGE_MANAGERS = Object.keys(MANAGERS);
+
 /**
  * @param {import('./project.js').Project} project
  * @param {string[]} names

package/src/kernel/main.js

@@ -109,6 +109,20 @@ async function dispatch(argv, options) {
 		return EXIT.OK;
 	}
 
+	// A command that has not asked for `rest` would drop these on the floor. That
+	// is the same failure the parser refuses for an unknown flag, and it arrives
+	// here by an ordinary route: npm eats the `--` and forwards what follows, so
+	// `npm create octane app -- --template spa` is correct and the identical line
+	// under pnpm or yarn hands the `--` straight through. Dropped silently, the
+	// run then fails saying --template is required, naming the one flag that was
+	// in fact supplied.
+	if (parsed.rest.length > 0 && !module.passthrough) {
+		throw usageError(
+			`Unexpected arguments after --: ${parsed.rest.join(' ')}`,
+			'npm needs `--` to forward flags. pnpm and yarn forward them already, so drop it there.',
+		);
+	}
+
 	// Commands that write into a project need one to exist. Without this they
 	// fail deep inside an fs call with a raw ENOENT stack.
 	if (module.requiresProject && ctx.project().manifestPath === null) {

package/src/kernel/registry.js

@@ -9,6 +9,11 @@
  * @type {import('./command.js').CommandEntry[]}
  */
 export const COMMANDS = [
+	{
+		name: 'create',
+		summary: 'Create an Octane app in a new directory.',
+		load: () => import('../commands/create.js'),
+	},
 	{
 		name: 'init',
 		summary: 'Wire Octane into the project in this directory.',

package/src/kernel/ui.js

@@ -60,6 +60,20 @@ export function createUi({ mode, yes = false, stdout = process.stdout }) {
 		);
 	};
 
+	/**
+	 * Whether `--yes` already answers this question.
+	 *
+	 * It means "stop asking me", which is as true on a terminal as it is in a
+	 * pipe. Consulting it only once the CLI had decided nobody was watching made
+	 * the flag do nothing in the one place people type it by hand, and left a
+	 * caller wanting an unattended run no choice but to claim there was no
+	 * terminal, which costs the interactive rendering with it. A question with no
+	 * default has nothing to answer with, so it is still asked.
+	 *
+	 * @param {unknown} initial
+	 */
+	const answered = (initial) => yes && initial !== undefined;
+
 	/** @param {unknown} value */
 	const guard = (value) => {
 		if (clack.isCancel(value)) throw new CliError('Cancelled.');
@@ -124,15 +138,36 @@ export function createUi({ mode, yes = false, stdout = process.stdout }) {
 		 * @returns {Promise<string>}
 		 */
 		async select({ message, flag, options, initial }) {
+			if (answered(initial)) return String(initial);
 			if (mode !== 'interactive') return String(unattended(flag, initial));
 			return String(guard(await clack.select({ message, options, initialValue: initial })));
 		},
 
+		/**
+		 * A free-text answer. `initial` is what an empty submission means, not
+		 * pre-filled input: someone accepting the offer by pressing enter and
+		 * someone typing it out should land in the same place.
+		 *
+		 * @param {{ message: string, flag: string, placeholder?: string, initial?: string }} options
+		 * @returns {Promise<string>}
+		 */
+		async text({ message, flag, placeholder, initial }) {
+			if (answered(initial)) return String(initial);
+			if (mode !== 'interactive') return String(unattended(flag, initial));
+			const answer = String(
+				guard(await clack.text({ message, placeholder, defaultValue: initial })),
+			);
+			return answer.trim() === '' && initial !== undefined ? initial : answer.trim();
+		},
+
 		/**
 		 * @param {{ message: string, flag: string, options: Choice[], initial?: string[] }} options
 		 * @returns {Promise<string[]>}
 		 */
 		async multiselect({ message, flag, options, initial }) {
+			// `answered` is a boolean, not a type guard, and this is the one prompt
+			// that hands its default straight back rather than coercing it.
+			if (answered(initial)) return /** @type {string[]} */ (initial);
 			if (mode !== 'interactive') {
 				return /** @type {string[]} */ (unattended(flag, initial));
 			}
@@ -146,6 +181,7 @@ export function createUi({ mode, yes = false, stdout = process.stdout }) {
 		 * @returns {Promise<boolean>}
 		 */
 		async confirm({ message, flag, initial = true }) {
+			if (answered(initial)) return Boolean(initial);
 			if (mode !== 'interactive') return Boolean(unattended(flag, initial));
 			return Boolean(guard(await clack.confirm({ message, initialValue: initial })));
 		},