@octanejs/cli 0.0.0 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/cli",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "type": "module",
   "engines": {
     "node": ">=22"

package/src/commands/create.js

@@ -0,0 +1,206 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { defineCommand } from '../kernel/command.js';
+import { detectProject } from '../kernel/project.js';
+import { CliError, EXIT } from '../kernel/errors.js';
+import { PACKAGE_MANAGERS } from '../kernel/install.js';
+import { applyInit } from './init/index.js';
+import { MODES } from './init/templates.js';
+
+/** What the project is called when someone accepts the prompt as offered. */
+export const DEFAULT_DIRECTORY = 'octane-app';
+
+/**
+ * Which package manager ran this command.
+ *
+ * `npm create`, `pnpm create` and `yarn create` all set `npm_config_user_agent`
+ * to something starting `name/version`. It is the only signal there is: the
+ * directory is new, so there is no lockfile to detect, and without this a
+ * `pnpm create` would be handed to npm and answered with the wrong lockfile.
+ *
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {string | undefined}
+ */
+export function invokedThrough(env) {
+	const name = (env.npm_config_user_agent ?? '').split('/')[0];
+	return PACKAGE_MANAGERS.includes(name) ? name : undefined;
+}
+
+/**
+ * Write a directory name so the shell the next step gets pasted into reads it
+ * as a name. It is whatever someone typed at the prompt, and this command
+ * accepts spaces and leading dashes in it.
+ *
+ * A leading dash needs more than quoting: `cd` parses its argument for options
+ * first, so `cd '-app'` fails the same way `cd -app` does, and a lone `cd -`
+ * silently goes somewhere else entirely. `./` in front makes it a path again.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+export function shellArgument(value) {
+	const name = value.startsWith('-') ? `./${value}` : value;
+	return /^[\w./@-]+$/.test(name) ? name : `'${name.replaceAll("'", String.raw`'\''`)}'`;
+}
+
+/**
+ * npm rejects a name with uppercase letters or most punctuation, and the
+ * directory someone types is not bound by that.
+ *
+ * @param {string} directory
+ * @returns {string}
+ */
+export function packageNameFor(directory) {
+	const name = path
+		.basename(directory)
+		.toLowerCase()
+		.replace(/[^a-z0-9._-]+/g, '-')
+		.replace(/^[._-]+|-+$/g, '');
+	return name === '' ? DEFAULT_DIRECTORY : name;
+}
+
+export default defineCommand({
+	// The whole point is to run where no project exists yet.
+	requiresProject: false,
+	description:
+		'Create an Octane app in a new directory: the files, the config, and the dependencies.\n' +
+		'This is what `npm create octane` runs.',
+	positionals: [{ name: 'directory', description: 'Directory to create the app in.' }],
+	flags: {
+		template: {
+			type: 'string',
+			short: 't',
+			choices: Object.keys(MODES),
+			placeholder: '<name>',
+			description: 'spa for a client-only app, fullstack for routing and SSR.',
+		},
+		install: {
+			type: 'boolean',
+			default: true,
+			description: 'Install dependencies (--no-install skips).',
+		},
+		'package-manager': {
+			type: 'string',
+			choices: PACKAGE_MANAGERS,
+			placeholder: '<name>',
+			description: 'Install with this one instead of the one that ran the command.',
+		},
+	},
+
+	async run(ctx, input) {
+		if (input.positionals.length > 1) {
+			throw new CliError(`Unexpected argument ${input.positionals[1]}.`);
+		}
+
+		const directory =
+			input.positionals[0] ??
+			(await ctx.ui.text({
+				message: 'Project name',
+				flag: '<directory>',
+				placeholder: DEFAULT_DIRECTORY,
+				initial: DEFAULT_DIRECTORY,
+			}));
+
+		const target = path.resolve(ctx.cwd, directory);
+		const existed = existsSync(target);
+		// A name that lands on a file is a mistake worth saying out loud. Reading
+		// it as a directory throws ENOTDIR, and a raw stack tells someone who
+		// mistyped a name nothing about what to do next.
+		if (existed && !statSync(target).isDirectory()) {
+			throw new CliError(`${directory} already exists and is not a directory.`);
+		}
+		// A repository with nothing in it is not a project. `mkdir app && cd app &&
+		// git init` is a common enough way to start that refusing it would leave
+		// this check protecting work that is not there, which is all it is for.
+		if (existed && readdirSync(target).some((entry) => entry !== '.git')) {
+			// Emptying someone's directory is not this command's call to make.
+			throw new CliError(`${directory} already exists and is not empty.`);
+		}
+
+		// `mkdirSync` with `recursive` makes every missing parent too, so a name
+		// like `apps/web` creates two directories. Undoing only the leaf would
+		// leave an empty tree standing, which is not nothing. Leaf first, and only
+		// the ones that were not already there.
+		/** @type {string[]} */
+		const made = [];
+		for (let dir = target; !existsSync(dir) && path.dirname(dir) !== dir; dir = path.dirname(dir)) {
+			made.push(dir);
+		}
+
+		mkdirSync(target, { recursive: true });
+		writeFileSync(
+			path.join(target, 'package.json'),
+			`${JSON.stringify(
+				{ name: packageNameFor(target), private: true, version: '0.0.0', type: 'module' },
+				null,
+				2,
+			)}\n`,
+		);
+		// What sits there before the scaffold runs: the manifest just written, and
+		// a `.git` if the directory came with one. The cleanup below asks what was
+		// added rather than counting entries, so it cannot disagree with the rule
+		// above about what an empty directory may already hold.
+		const before = new Set(readdirSync(target));
+
+		// Whoever ran `create` owns this project's tooling, and there is no
+		// lockfile to work that out from in a directory this new.
+		const packageManager = input.flags['package-manager'] ?? invokedThrough(ctx.env);
+
+		let result;
+		let wrote = false;
+		try {
+			result = await applyInit(ctx, detectProject(target), {
+				title: 'octane create',
+				mode: input.flags.template,
+				modeFlag: '--template',
+				install: input.flags.install,
+				packageManager,
+			});
+		} finally {
+			// Nothing written means no project, and a lone package.json is not one.
+			// Declining the confirm is a normal answer and a failure is not, but
+			// both leave the same nothing behind, and the directory left over would
+			// make the obvious retry fail as already occupied. Only what this
+			// command made goes, so a directory that was already there survives
+			// with its `.git`, which is also why this cannot be inferred afterwards
+			// from whether the directory is still standing.
+			wrote = readdirSync(target).some((entry) => !before.has(entry));
+			if (!wrote) {
+				rmSync(path.join(target, 'package.json'), { force: true });
+				for (const dir of made) {
+					// Anything left in one of these by now is not ours to remove.
+					if (readdirSync(dir).length > 0) break;
+					rmSync(dir, { recursive: true, force: true });
+				}
+			}
+		}
+
+		if (!wrote) {
+			ctx.ui.log('');
+			ctx.ui.log('Nothing was created.');
+			return result;
+		}
+		if (result.exitCode !== undefined && result.exitCode !== EXIT.OK) return result;
+
+		// Spelled for the manager they used, since telling a pnpm user to run npm
+		// is how a project ends up with two lockfiles. `run` is the one spelling
+		// every manager accepts.
+		const runner = packageManager ?? 'npm';
+		// Skipping the install leaves the manifest with no dependencies in it at
+		// all, because dependencies are recorded by handing them to the package
+		// manager rather than by writing ranges. A bare `install` would resolve an
+		// empty manifest, succeed at nothing, and leave `run dev` to fail on a
+		// missing octane. The exact packages were printed above, so send them
+		// there rather than spelling a command that does not do the job.
+		ctx.ui.log('');
+		ctx.ui.note('Next', [
+			`cd ${shellArgument(directory)}`,
+			...(input.flags.install === false
+				? ['install the packages listed under "Do this by hand"']
+				: []),
+			`${runner} run dev`,
+		]);
+
+		return { json: { ...result.json, directory, packageManager: runner } };
+	},
+});

package/src/commands/init/index.js

@@ -1,16 +1,21 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { defineCommand } from '../../kernel/command.js';
 import { setCompilerOption } from '../../kernel/edit.js';
 import { CliError, EXIT } from '../../kernel/errors.js';
-import { installPackages } from '../../kernel/install.js';
+import { PACKAGE_MANAGERS, installPackages } from '../../kernel/install.js';
 import {
 	MODES,
+	PRETTIER_CONFIG_FILES,
 	SCRIPTS,
+	SSR_MARKERS,
 	VITE_SCRIPTS,
 	appComponent,
+	clientEntry,
+	indexHtml,
 	integrationFor,
 	octaneConfig,
+	prettierConfig,
 	tsconfig,
 	viteConfig,
 } from './templates.js';
@@ -45,6 +50,67 @@ const writeFile = (file, body) => () => {
 	writeFileSync(file, body);
 };
 
+/**
+ * Where a project keeps its Prettier settings, and what they say, so a caller
+ * can tell whether the plugin is already registered there.
+ *
+ * The `prettier` field of package.json holds either the settings themselves or
+ * a path to them, and the two have to be read differently. `declared` is null
+ * when the settings are real but out of reach: the field may name a shareable
+ * config, and resolving a bare module specifier is the package manager's job.
+ *
+ * @param {string} root
+ * @param {string[]} files config files found in the project, in Prettier's search order
+ * @param {unknown} fromManifest the `prettier` field of package.json
+ * @returns {{ where: string, declared: string | null }}
+ */
+function prettierSettings(root, files, fromManifest) {
+	// package.json comes first in Prettier's own search order, ahead of every
+	// config file, so when a project has both it is the field that decides. Read
+	// the file instead and init can approve a config Prettier never loads.
+	if (fromManifest === undefined) {
+		return { where: files[0], declared: readFileSync(path.join(root, files[0]), 'utf8') };
+	}
+	if (typeof fromManifest !== 'string') {
+		return {
+			where: 'the prettier field of package.json',
+			declared: JSON.stringify(fromManifest),
+		};
+	}
+	// A path is relative to the package.json naming it. Anything that does not
+	// land on a file is a specifier for the resolver, not a path.
+	const file = path.resolve(root, fromManifest);
+	return existsSync(file) && statSync(file).isFile()
+		? { where: path.relative(root, file), declared: readFileSync(file, 'utf8') }
+		: { where: fromManifest, declared: null };
+}
+
+/**
+ * The TypeScript range `tsrx-tsc` will start under, read from the plugin that
+ * ships it once that plugin is on disk.
+ *
+ * It is a required peer there, not a dependency, so nothing carries a compiler
+ * of its own. npm and pnpm install a required peer themselves; yarn does not,
+ * and leaves a project whose `typecheck` script dies on `Cannot find module
+ * 'typescript'`. Naming the package with no range is not the fix either: that
+ * takes the newest major, which `tsrx-tsc` cannot start under. So the range
+ * comes from the toolchain's own declaration, never from a guess here.
+ *
+ * @param {string} root
+ * @returns {string | null} null when the plugin is not installed yet
+ */
+function toolchainTypescriptRange(root) {
+	try {
+		const manifest = JSON.parse(
+			readFileSync(path.join(root, 'node_modules/@tsrx/typescript-plugin/package.json'), 'utf8'),
+		);
+		const range = manifest.peerDependencies?.typescript;
+		return typeof range === 'string' && range !== '' ? range : null;
+	} catch {
+		return null;
+	}
+}
+
 /**
  * @param {import('../../kernel/project.js').Project} project
  * @param {keyof typeof MODES} mode
@@ -63,7 +129,7 @@ function plan(project, mode, integration) {
 		changes.push({
 			file: 'tsconfig.json',
 			summary: 'create, configured for .tsrx',
-			apply: writeFile(at('tsconfig.json'), `${JSON.stringify(tsconfig, null, 2)}\n`),
+			apply: writeFile(at('tsconfig.json'), tsconfig),
 		});
 	} else {
 		const file = project.tsconfig.path;
@@ -96,6 +162,30 @@ function plan(project, mode, integration) {
 		}
 	}
 
+	// Formatting is nobody's bundler's business, so this runs whichever one the
+	// project uses. Without the plugin Prettier cannot parse `.tsrx` at all.
+	const prettierFiles = PRETTIER_CONFIG_FILES.filter((file) => existsSync(at(file)));
+	if (prettierFiles.length === 0 && project.manifest.prettier === undefined) {
+		changes.push({
+			file: '.prettierrc',
+			summary: 'create, registering @tsrx/prettier-plugin',
+			apply: writeFile(at('.prettierrc'), prettierConfig),
+		});
+	} else {
+		// Their config is theirs, and it can be JSON, YAML, or JavaScript. Reading
+		// it as text is enough to tell whether the plugin is already named, which
+		// is all that decides between staying quiet and stating the edit.
+		const { where, declared } = prettierSettings(root, prettierFiles, project.manifest.prettier);
+		if (declared === null) {
+			// Saying "add it" would be a guess, and so would saying nothing.
+			manual.push(
+				`Prettier settings come from ${where}, which this command cannot read: check that "@tsrx/prettier-plugin" is among its plugins.`,
+			);
+		} else if (!declared.includes('@tsrx/prettier-plugin')) {
+			manual.push(`Add "@tsrx/prettier-plugin" to the Prettier plugins in ${where}.`);
+		}
+	}
+
 	const bundlerConfigPath = project.bundlerConfigPath ?? at('vite.config.ts');
 	if (!project.bundlerConfigPath) {
 		changes.push({
@@ -127,18 +217,63 @@ function plan(project, mode, integration) {
 		);
 	}
 
-	if (mode === 'fullstack' && scaffoldsVite) {
-		if (!project.octaneConfigPath) {
+	if (scaffoldsVite) {
+		if (mode === 'fullstack' && !project.octaneConfigPath) {
 			changes.push({
 				file: 'octane.config.ts',
 				summary: 'create, with one route at /',
 				apply: writeFile(at('octane.config.ts'), octaneConfig),
 			});
 		}
-		if (!existsSync(at('src/App.tsrx'))) {
+
+		// Without a shell and an entry there is nothing to serve: `vite` has no
+		// page to open and a fullstack build fails outright, because the plugin
+		// requires an index.html once octane.config.ts declares routes. Each file
+		// is written only when it is absent, so an existing project keeps its own.
+		const writesShell = !existsSync(at('index.html'));
+		// spa is plain Vite, so the page loads the entry itself and the two files
+		// only make sense together. fullstack needs no entry here: the plugin
+		// injects hydration, in dev through its middleware and in production at
+		// transformIndexHtml.
+		// Guarded like every other file here: a project can have lost its
+		// index.html and still own the entry that used to be loaded from it.
+		const writesClientEntry = writesShell && mode === 'spa' && !existsSync(at('src/main.ts'));
+		if (writesShell) {
+			changes.push({
+				file: 'index.html',
+				summary:
+					mode === 'fullstack' ? 'create, carrying the SSR markers' : 'create, loading src/main.ts',
+				apply: writeFile(at('index.html'), indexHtml(mode)),
+			});
+			if (writesClientEntry) {
+				changes.push({
+					file: 'src/main.ts',
+					summary: 'create, mounting App into #root',
+					apply: writeFile(at('src/main.ts'), clientEntry),
+				});
+			}
+		} else if (mode === 'fullstack') {
+			// Their index.html is theirs to edit, and splicing markers into
+			// arbitrary HTML is the same guesswork as rewriting a bundler config.
+			const html = readFileSync(at('index.html'), 'utf8');
+			const missing = SSR_MARKERS.filter((marker) => !html.includes(marker));
+			if (missing.length > 0) {
+				manual.push(`In index.html, add ${missing.join(' and ')}: SSR renders into those markers.`);
+			}
+		}
+
+		// fullstack always needs it, because octane.config.ts names it as the
+		// route entry. spa needs it only alongside the entry that imports it, so a
+		// project with its own page does not collect an orphan component. That is
+		// the entry this run writes, not the shell: keeping someone's src/main.ts
+		// means keeping whatever it imports, which is not this file.
+		if ((mode === 'fullstack' || writesClientEntry) && !existsSync(at('src/App.tsrx'))) {
 			changes.push({
 				file: 'src/App.tsrx',
-				summary: 'create the route entry referenced by octane.config.ts',
+				summary:
+					mode === 'fullstack'
+						? 'create the route entry referenced by octane.config.ts'
+						: 'create the entry component',
 				apply: writeFile(at('src/App.tsrx'), appComponent),
 			});
 		}
@@ -162,6 +297,134 @@ function plan(project, mode, integration) {
 	return { changes, manual };
 }
 
+/**
+ * Wire Octane into the project at `project.root`: plan the files, report them,
+ * apply them, install what is missing.
+ *
+ * Shared with `octane create`, which is the same work against a directory it
+ * has just made rather than one that was already there. Driving this from
+ * outside, by re-entering `main` with an argv, meant a second copy of every
+ * question about whether the CLI can prompt; one `ctx` removes that.
+ *
+ * @param {import('../../kernel/context.js').Ctx} ctx
+ * @param {import('../../kernel/project.js').Project} project
+ * @param {{ title: string, mode?: string, modeFlag?: string, install?: boolean,
+ *   packageManager?: string }} options
+ * @returns {Promise<{ exitCode?: number, json: Record<string, unknown> }>}
+ */
+export async function applyInit(ctx, project, options) {
+	const mode = /** @type {keyof typeof MODES} */ (
+		options.mode ??
+			(await ctx.ui.select({
+				message: 'What are you building?',
+				flag: options.modeFlag ?? '--mode',
+				initial: 'spa',
+				options: Object.entries(MODES).map(([value, entry]) => ({
+					value,
+					label: entry.label,
+					hint: entry.hint,
+				})),
+			}))
+	);
+
+	// Detection reads a lockfile, and a project that has never been installed
+	// has none to read. A caller that knows which manager it was invoked
+	// through can say so, rather than watching the fallback write the wrong
+	// kind of lockfile into a brand-new project.
+	const installing =
+		options.packageManager === undefined
+			? project
+			: {
+					...project,
+					packageManager: /** @type {typeof project.packageManager} */ (options.packageManager),
+				};
+
+	const integration = integrationFor(project.bundler, mode);
+	const { changes, manual } = plan(project, mode, integration);
+	const declared = project.declaredDependencies;
+	const dependencies = integration.dependencies.filter((name) => !declared[name]);
+	const devDependencies = integration.devDependencies.filter((name) => !declared[name]);
+
+	ctx.ui.intro(options.title);
+
+	if (changes.length === 0 && dependencies.length === 0 && devDependencies.length === 0) {
+		ctx.ui.outro('Already set up. Run `octane doctor` to confirm.');
+		return { json: { ok: true, mode, changes: [], installed: [] } };
+	}
+
+	ctx.ui.note(
+		ctx.dryRun ? 'Would change' : 'Will change',
+		changes.length > 0
+			? changes.map((c) => `${c.file}  ${ctx.ui.colors.dim(c.summary)}`)
+			: ['nothing'],
+	);
+	if (dependencies.length + devDependencies.length > 0) {
+		ctx.ui.note('Will install', [
+			...dependencies,
+			...devDependencies.map((name) => `${name} (dev)`),
+		]);
+	}
+
+	if (ctx.dryRun) {
+		return { json: { ok: true, dryRun: true, mode, changes: changes.map((c) => c.file), manual } };
+	}
+
+	const confirmed = await ctx.ui.confirm({ message: 'Apply?', flag: '--yes', initial: true });
+	if (!confirmed)
+		return { exitCode: EXIT.OK, json: { ok: true, mode, changes: [], installed: [] } };
+
+	for (const change of changes) change.apply();
+
+	/** @type {string[]} */
+	const installed = [];
+	if (options.install !== false && dependencies.length + devDependencies.length > 0) {
+		const spinner = ctx.ui.spinner(`Installing with ${installing.packageManager ?? 'npm'}`);
+		try {
+			for (const [names, dev] of [
+				[dependencies, false],
+				[devDependencies, true],
+			]) {
+				if (/** @type {string[]} */ (names).length === 0) continue;
+				await installPackages(ctx, installing, /** @type {string[]} */ (names), {
+					dev: Boolean(dev),
+				});
+				installed.push(.../** @type {string[]} */ (names));
+			}
+
+			// Now that the plugin is on disk it can say which TypeScript it runs
+			// under. A package manager that installs required peers has already
+			// put one there and this pins the same range explicitly; one that does
+			// not, like yarn, would otherwise leave `typecheck` unable to start.
+			if (!declared.typescript) {
+				const range = toolchainTypescriptRange(project.root);
+				if (range === null) {
+					manual.push('Install typescript, at the range @tsrx/typescript-plugin declares.');
+				} else {
+					await installPackages(ctx, installing, [`typescript@${range}`], { dev: true });
+					installed.push('typescript');
+				}
+			}
+		} catch (error) {
+			spinner.stop('Install failed');
+			throw error;
+		}
+		spinner.stop(`Installed ${installed.length} package(s)`);
+	} else if (dependencies.length + devDependencies.length > 0) {
+		// The range lives in the plugin, which is not installed yet, so it cannot
+		// be quoted here. Naming the package without one would send people to the
+		// newest major, which `tsrx-tsc` cannot start under.
+		manual.push(
+			`Install: ${[...dependencies, ...devDependencies].join(' ')}`,
+			'then typescript, at the range @tsrx/typescript-plugin declares as its peer.',
+		);
+	}
+
+	if (manual.length > 0) ctx.ui.note('Do this by hand', manual);
+	ctx.ui.outro('Run `octane doctor` to verify the result.');
+
+	return { json: { ok: true, mode, changes: changes.map((c) => c.file), installed, manual } };
+}
+
 export default defineCommand({
 	requiresProject: true,
 	description:
@@ -179,99 +442,27 @@ export default defineCommand({
 			default: true,
 			description: 'Install dependencies (--no-install skips).',
 		},
+		'package-manager': {
+			type: 'string',
+			choices: PACKAGE_MANAGERS,
+			placeholder: '<name>',
+			description: 'Install with this one instead of the project’s own.',
+		},
 		force: { type: 'boolean', description: 'Proceed even with uncommitted changes.' },
 	},
 
 	async run(ctx, input) {
-		const project = ctx.project();
-
 		if (!input.flags.force && !ctx.dryRun && (await isDirty(ctx))) {
 			throw new CliError('This project has uncommitted changes.', {
 				hint: 'Commit or stash first so you can review what init writes, or pass --force.',
 			});
 		}
 
-		const mode = /** @type {keyof typeof MODES} */ (
-			input.flags.mode ??
-				(await ctx.ui.select({
-					message: 'What are you building?',
-					flag: '--mode',
-					initial: 'spa',
-					options: Object.entries(MODES).map(([value, entry]) => ({
-						value,
-						label: entry.label,
-						hint: entry.hint,
-					})),
-				}))
-		);
-
-		const integration = integrationFor(project.bundler, mode);
-		const { changes, manual } = plan(project, mode, integration);
-		const declared = project.declaredDependencies;
-		const dependencies = integration.dependencies.filter((name) => !declared[name]);
-		const devDependencies = integration.devDependencies.filter((name) => !declared[name]);
-
-		ctx.ui.intro('octane init');
-
-		if (changes.length === 0 && dependencies.length === 0 && devDependencies.length === 0) {
-			ctx.ui.outro('Already set up. Run `octane doctor` to confirm.');
-			return { json: { ok: true, mode, changes: [], installed: [] } };
-		}
-
-		ctx.ui.note(
-			ctx.dryRun ? 'Would change' : 'Will change',
-			changes.length > 0
-				? changes.map((c) => `${c.file}  ${ctx.ui.colors.dim(c.summary)}`)
-				: ['nothing'],
-		);
-		if (dependencies.length + devDependencies.length > 0) {
-			ctx.ui.note('Will install', [
-				...dependencies,
-				...devDependencies.map((name) => `${name} (dev)`),
-			]);
-		}
-
-		if (ctx.dryRun) {
-			return {
-				json: { ok: true, dryRun: true, mode, changes: changes.map((c) => c.file), manual },
-			};
-		}
-
-		const confirmed = await ctx.ui.confirm({ message: 'Apply?', flag: '--yes', initial: true });
-		if (!confirmed)
-			return { exitCode: EXIT.OK, json: { ok: true, mode, changes: [], installed: [] } };
-
-		for (const change of changes) change.apply();
-
-		/** @type {string[]} */
-		const installed = [];
-		if (input.flags.install && dependencies.length + devDependencies.length > 0) {
-			const spinner = ctx.ui.spinner(`Installing with ${project.packageManager ?? 'npm'}`);
-			try {
-				for (const [names, dev] of [
-					[dependencies, false],
-					[devDependencies, true],
-				]) {
-					if (/** @type {string[]} */ (names).length === 0) continue;
-					await installPackages(ctx, project, /** @type {string[]} */ (names), {
-						dev: Boolean(dev),
-					});
-					installed.push(.../** @type {string[]} */ (names));
-				}
-			} catch (error) {
-				spinner.stop('Install failed');
-				throw error;
-			}
-			spinner.stop(`Installed ${installed.length} package(s)`);
-		} else if (dependencies.length + devDependencies.length > 0) {
-			manual.push(`Install: ${[...dependencies, ...devDependencies].join(' ')}`);
-		}
-
-		if (manual.length > 0) ctx.ui.note('Do this by hand', manual);
-		ctx.ui.outro('Run `octane doctor` to verify the result.');
-
-		return {
-			json: { ok: true, mode, changes: changes.map((c) => c.file), installed, manual },
-		};
+		return applyInit(ctx, ctx.project(), {
+			title: 'octane init',
+			mode: input.flags.mode,
+			install: input.flags.install,
+			packageManager: input.flags['package-manager'],
+		});
 	},
 });