feat: always suggest rerun command (#746)

## PR Checklist

- [x] Addresses an existing open issue: fixes #655
- [x] That issue was marked as [`status: accepting
prs`](https://github.com/JoshuaKGoldberg/create-typescript-app/issues?q=is%3Aopen+is%3Aissue+label%3A%22status%3A+accepting+prs%22)
- [x] Steps in
[CONTRIBUTING.md](https://github.com/JoshuaKGoldberg/create-typescript-app/blob/main/.github/CONTRIBUTING.md)
were taken

## Overview

Finally finishes switching over from using `process.exit` to stop on
error towards returning more informative results, the way Go does. This
rounds out #652. cc @kristo-baricevic - yay!

```plaintext
┌  Welcome to create-typescript-app ! 🎉
│
│  ⚠️ This template is early stage, opinionated, and not endorsed by the TypeScript team. ⚠️
│  ⚠️ If any tooling it sets displeases you, you can always remove that portion manually. ⚠️
│
◇  ✅ Passed checking GitHub authentication.
│
■  How much tooling would you like the template to set up for you?
│  Everything! 🙌
│
│
●  Tip: to run again with the same input values, use: npx create-typescript-app --mode migrate --author JoshuaKGoldberg --description "Fills in missing allcontributors entries for a repository. 👪" --email [email protected] --funding JoshuaKGoldberg --owner JoshuaKGoldberg --repository all-contributors-auto-action --title "All Contributors Auto Action"
│
└  Operation cancelled. Exiting - maybe another time? 👋
```

_(that extra `│` before the tip is annoying me, but I don't want to
spend time dealing with its edge cases)_

Author: JoshuaKGoldberg

src/bin/index.test.ts

@@ -3,14 +3,20 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import { bin } from "./index.js";
 
+const mockCancel = vi.fn();
 const mockOutro = vi.fn();
 
 vi.mock("@clack/prompts", () => ({
+	get cancel() {
+		return mockCancel;
+	},
 	intro: vi.fn(),
+	log: {
+		info: vi.fn(),
+	},
 	get outro() {
 		return mockOutro;
 	},
-	spinner: vi.fn(),
 }));
 
 const mockLogLine = vi.fn();
@@ -58,6 +64,17 @@ describe("bin", () => {
 		vi.spyOn(console, "clear").mockImplementation(() => undefined);
 	});
 
+	it("returns 1 when promptForMode returns undefined", async () => {
+		mockPromptForMode.mockResolvedValue(undefined);
+
+		const result = await bin([]);
+
+		expect(mockOutro).toHaveBeenCalledWith(
+			chalk.red("Operation cancelled. Exiting - maybe another time? 👋"),
+		);
+		expect(result).toEqual(1);
+	});
+
 	it("returns 1 when promptForMode returns an error", async () => {
 		const error = new Error("Oh no!");
 		mockPromptForMode.mockResolvedValue(error);
@@ -68,19 +85,54 @@ describe("bin", () => {
 		expect(result).toEqual(1);
 	});
 
-	it("returns the result of a runner promptForMode returns a mode", async () => {
+	it("returns the success result of the corresponding runner without cancel logging when promptForMode returns a mode that succeeds", async () => {
 		const mode = "create";
 		const args = ["--owner", "abc123"];
-		const expected = 0;
+		const code = 0;
 
 		mockPromptForMode.mockResolvedValue(mode);
-		mockCreate.mockResolvedValue(expected);
+		mockCreate.mockResolvedValue({ code, options: {} });
 
 		const result = await bin(args);
 
 		expect(mockCreate).toHaveBeenCalledWith(args);
+		expect(mockCancel).not.toHaveBeenCalled();
 		expect(mockInitialize).not.toHaveBeenCalled();
 		expect(mockMigrate).not.toHaveBeenCalled();
-		expect(result).toEqual(expected);
+		expect(result).toEqual(code);
+	});
+
+	it("returns the cancel result of the corresponding runner and cancel logs when promptForMode returns a mode that cancels", async () => {
+		const mode = "create";
+		const args = ["--owner", "abc123"];
+		const code = 2;
+
+		mockPromptForMode.mockResolvedValue(mode);
+		mockCreate.mockResolvedValue({ code, options: {} });
+
+		const result = await bin(args);
+
+		expect(mockCreate).toHaveBeenCalledWith(args);
+		expect(mockCancel).toHaveBeenCalledWith(
+			`Operation cancelled. Exiting - maybe another time? 👋`,
+		);
+		expect(result).toEqual(code);
+	});
+
+	it("returns the cancel result of the corresponding runner and cancel logs when promptForMode returns a mode that fails", async () => {
+		const mode = "create";
+		const args = ["--owner", "abc123"];
+		const code = 1;
+
+		mockPromptForMode.mockResolvedValue(mode);
+		mockCreate.mockResolvedValue({ code, options: {} });
+
+		const result = await bin(args);
+
+		expect(mockCreate).toHaveBeenCalledWith(args);
+		expect(mockCancel).toHaveBeenCalledWith(
+			`Operation failed. Exiting - maybe another time? 👋`,
+		);
+		expect(result).toEqual(code);
 	});
 });

src/bin/index.ts

@@ -2,12 +2,17 @@ import * as prompts from "@clack/prompts";
 import chalk from "chalk";
 import { parseArgs } from "node:util";
 
+import { createRerunSuggestion } from "../create/createRerunSuggestion.js";
 import { create } from "../create/index.js";
 import { initialize } from "../initialize/index.js";
 import { migrate } from "../migrate/index.js";
 import { logLine } from "../shared/cli/lines.js";
+import { StatusCodes } from "../shared/codes.js";
 import { promptForMode } from "./mode.js";
 
+const operationMessage = (verb: string) =>
+	`Operation ${verb}. Exiting - maybe another time? 👋`;
+
 export async function bin(args: string[]) {
 	console.clear();
 
@@ -40,17 +45,28 @@ export async function bin(args: string[]) {
 	});
 
 	const mode = await promptForMode(values.mode);
-	if (mode instanceof Error) {
-		prompts.outro(chalk.red(mode.message));
+	if (typeof mode !== "string") {
+		prompts.outro(chalk.red(mode?.message ?? operationMessage("cancelled")));
 		return 1;
 	}
 
-	logLine();
-	logLine(
-		chalk.blue(
-			"Let's collect some information to fill out repository details...",
-		),
+	const { code, options } = await { create, initialize, migrate }[mode](args);
+
+	prompts.log.info(
+		[
+			chalk.italic(`Tip: to run again with the same input values, use:`),
+			chalk.blue(createRerunSuggestion(mode, options)),
+		].join(" "),
 	);
 
-	return await { create, initialize, migrate }[mode](args);
+	if (code) {
+		logLine();
+		prompts.cancel(
+			code === StatusCodes.Cancelled
+				? operationMessage("cancelled")
+				: operationMessage("failed"),
+		);
+	}
+
+	return code;
 }

src/bin/mode.ts

@@ -1,7 +1,16 @@
 import * as prompts from "@clack/prompts";
 import chalk from "chalk";
 
-import { handlePromptCancel } from "../shared/prompts.js";
+import { StatusCode } from "../shared/codes.js";
+import { filterPromptCancel } from "../shared/prompts.js";
+import { Options } from "../shared/types.js";
+
+export interface ModeResult {
+	code: StatusCode;
+	options: Partial<Options>;
+}
+
+export type ModeRunner = (args: string[]) => Promise<ModeResult>;
 
 export type Mode = "create" | "initialize" | "migrate";
 
@@ -11,9 +20,7 @@ function isMode(input: boolean | string): input is Mode {
 	return allowedModes.includes(input as Mode);
 }
 
-export async function promptForMode(
-	input: boolean | string | undefined,
-): Promise<Error | Mode> {
+export async function promptForMode(input: boolean | string | undefined) {
 	if (input) {
 		if (!isMode(input)) {
 			return new Error(
@@ -26,7 +33,7 @@ export async function promptForMode(
 		return input;
 	}
 
-	const selection = handlePromptCancel(
+	const selection = filterPromptCancel(
 		(await prompts.select({
 			message: chalk.blue("How would you like to use the template?"),
 			options: [

src/create/createAndEnterRepository.ts

@@ -0,0 +1,14 @@
+import { $ } from "execa";
+import fs from "node:fs/promises";
+
+export async function createAndEnterRepository(repository: string) {
+	if ((await fs.readdir(".")).includes(repository)) {
+		return false;
+	}
+
+	await fs.mkdir(repository);
+	process.chdir(repository);
+	await $`git init`;
+
+	return true;
+}

src/create/createRerunSuggestion.ts

@@ -8,7 +8,10 @@ function getFirstMatchingArg(key: string) {
 	);
 }
 
-export function createRerunSuggestion(mode: Mode, options: Options): string {
+export function createRerunSuggestion(
+	mode: Mode,
+	options: Partial<Options>,
+): string {
 	const args = Object.entries(options)
 		.filter(([, value]) => !!value)
 		.map(([key, value]) => {

src/create/index.test.ts

@@ -0,0 +1,71 @@
+import chalk from "chalk";
+import { describe, expect, it, vi } from "vitest";
+
+import { StatusCodes } from "../shared/codes.js";
+import { create } from "./index.js";
+
+const mockOutro = vi.fn();
+
+vi.mock("@clack/prompts", () => ({
+	get outro() {
+		return mockOutro;
+	},
+	spinner: vi.fn(),
+}));
+
+const mockReadOptions = vi.fn();
+
+vi.mock("../shared/options/readOptions.js", () => ({
+	get readOptions() {
+		return mockReadOptions;
+	},
+}));
+
+const mockCreateAndEnterRepository = vi.fn();
+
+vi.mock("./createAndEnterRepository.js", () => ({
+	get createAndEnterRepository() {
+		return mockCreateAndEnterRepository;
+	},
+}));
+
+const optionsBase = {
+	repository: "TestRepository",
+};
+
+describe("create", () => {
+	it("returns a cancellation code when readOptions cancels", async () => {
+		mockReadOptions.mockResolvedValue({
+			cancelled: true,
+			options: optionsBase,
+		});
+
+		const result = await create([]);
+
+		expect(result).toEqual({
+			code: StatusCodes.Cancelled,
+			options: optionsBase,
+		});
+	});
+
+	it("returns a failure code when createAndEnterRepository returns false", async () => {
+		mockReadOptions.mockResolvedValue({
+			cancelled: false,
+			options: optionsBase,
+		});
+
+		mockCreateAndEnterRepository.mockResolvedValue(false);
+
+		const result = await create([]);
+
+		expect(result).toEqual({
+			code: StatusCodes.Failure,
+			options: optionsBase,
+		});
+		expect(mockOutro).toHaveBeenCalledWith(
+			chalk.red(
+				"The TestRepository directory already exists. Please remove the directory or try a different name.",
+			),
+		);
+	});
+});