create-gtkx 2.0.0-beta.1 → 2.0.0-beta.11

package/src/scaffolder.ts

@@ -2,14 +2,13 @@ import * as p from "@clack/prompts";
 import { APPLICATION_ID_MAX_LENGTH, isValidApplicationId } from "@gtkx/config/internal";
 import { errorMessage, tryResolveExecutable, upperFirst } from "@gtkx/utils";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
+import { lstatSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { addDependency, detectPackageManager as nypmDetectPackageManager } from "nypm";
 import { x } from "tinyexec";
 import packageManifest from "../package.json" with { type: "json" };
 import { writeBuildAllowance } from "./build-allowance.js";
 import { OperationCanceledError, ScaffoldAbortedError } from "./errors.js";
-import { getInstallHint } from "./install-hints.js";
 import { updateManifest } from "./manifest.js";
 import {
     isKnownPackageManager,
@@ -23,57 +22,49 @@ import { listTemplates, renderFile, type TemplateContext } from "./templates.js"
 type CreateOptions = {
     name?: string | undefined;
     applicationId?: string | undefined;
+    displayName?: string | undefined;
     packageManager?: string | undefined;
     isTypescript?: boolean | undefined;
     shouldIncludeTesting?: boolean | undefined;
     isInteractive?: boolean | undefined;
     shouldOverwrite?: boolean | undefined;
+    shouldInstallDependencies?: boolean | undefined;
 };
 
 type ResolvedOptions = {
     target: string;
     root: string;
-    isCurrentDirectory: boolean;
     name: string;
+    displayName: string;
     applicationId: string;
     packageManager: PackageManager;
     isTypescript: boolean;
     shouldIncludeTesting: boolean;
-    shouldEmptyTarget: boolean;
+    shouldInitializeGit: boolean;
+    shouldInstallDependencies: boolean;
 };
 
-type InstallDependenciesOptions = {
-    cwd: string;
-    packageManager: PackageManager;
-    dependencies: string[];
-    isDev: boolean;
-};
+type ScaffoldFile = { destination: string; contents: string };
 
-type InstallAllOptions = {
-    resolved: ResolvedOptions;
-    devDependencies: string[];
-};
+type ScaffoldChanges = string[];
 
-type InstallFailureOptions = {
-    error: unknown;
-    resolved: ResolvedOptions;
-    devDependencies: string[];
+type ScaffoldPlan = {
+    files: ScaffoldFile[];
+    replaceDestinations: string[];
+    changes: ScaffoldChanges;
 };
 
 type SpinnerStep = {
     pending: string;
     done: string;
     failed: string;
-    run: () => Promise<void>;
-    explain?: ((error: unknown) => void) | undefined;
+    run: () => Promise<void> | void;
+    explain?: (() => void) | undefined;
 };
 
 const selfVersion = packageManifest.version;
 const ICON_TEMPLATE_NAME = "icon.svg";
-
-const GTKX_ENV_MODULE_HEADER = `/**
- * Generated by \`gtkx codegen\`, \`gtkx dev\`, and \`gtkx build\`; do not edit.
- */`;
+const TYPESCRIPT_VERSION = "^6.0.3";
 
 const DEPENDENCIES = ["@gtkx/cairo", "@gtkx/css", "@gtkx/runtime", "@gtkx/react", "react"];
 const DEV_DEPENDENCIES = ["@gtkx/cli", "@gtkx/config", "@gtkx/mcp", "vite"];
@@ -84,8 +75,8 @@ const DEV_COMMAND: Record<PackageManager, string> = Object.fromEntries(
     PACKAGE_MANAGERS.map((manager) => [manager.value, manager.devCommand]),
 ) as Record<PackageManager, string>;
 
-const ADD_COMMAND: Record<PackageManager, string> = Object.fromEntries(
-    PACKAGE_MANAGERS.map((manager) => [manager.value, manager.addCommand]),
+const INSTALL_COMMAND: Record<PackageManager, string> = Object.fromEntries(
+    PACKAGE_MANAGERS.map((manager) => [manager.value, manager.installCommand]),
 ) as Record<PackageManager, string>;
 
 const INHERITED_SCRIPT_POLICY_VARS = ["npm_config_allow_scripts", "npm_config_allow-scripts"];
@@ -98,7 +89,6 @@ To run tests, you need a headless Wayland compositor installed:
   Fedora: sudo dnf install sway
   Ubuntu: sudo apt install sway`;
 
-const RECOVERY_HEADING = "Finish the setup by adding the dependencies again, which is safe to repeat:";
 const APPLICATION_ID_FORMAT_ERROR = "Application ID must be reverse domain notation (e.g., com.example.myapp)";
 const APPLICATION_ID_PREFIX = "com.";
 const APPLICATION_ID_SUFFIX = ".app";
@@ -106,7 +96,8 @@ const APPLICATION_ID_SUFFIX = ".app";
 const APPLICATION_ID_SEGMENT_LIMIT = APPLICATION_ID_MAX_LENGTH - APPLICATION_ID_PREFIX.length -
     APPLICATION_ID_SUFFIX.length;
 
-const titleFromName = (name: string): string => name.split("-").map((part) => upperFirst(part)).join(" ");
+const displayNameFromProjectName = (name: string): string =>
+    name.split("-").map((part) => upperFirst(part)).join(" ");
 
 const gitConfigValue = (key: string): string | null => {
     const git = tryResolveExecutable("git");
@@ -132,19 +123,6 @@ const applicationIdSegment = (name: string): string => {
 const suggestApplicationId = (name: string): string =>
     `${APPLICATION_ID_PREFIX}${applicationIdSegment(name)}${APPLICATION_ID_SUFFIX}`;
 
-const stripTrailingSlashes = (value: string): string => {
-    let end = value.length;
-
-    while (end > 0 && value[end - 1] === "/") {
-        end--;
-    }
-
-    return value.slice(0, end);
-};
-
-const formatTargetDir = (target: string): string =>
-    stripTrailingSlashes(target.trim().replaceAll(/[<>:"\\|?*]/g, ""));
-
 const deriveProjectName = (target: string): string => basename(resolve(process.cwd(), target));
 
 const isDirEmpty = (dir: string): boolean => {
@@ -153,6 +131,12 @@ const isDirEmpty = (dir: string): boolean => {
     return entries.length === 0 || (entries.length === 1 && entries[0] === ".git");
 };
 
+const shouldInitializeGit = (root: string): boolean => {
+    const entry = lstatSync(root, { throwIfNoEntry: false });
+
+    return entry === undefined || (entry.isDirectory() && readdirSync(root).length === 0);
+};
+
 const getDevDependencies = ({
     isTypescript,
     shouldIncludeTesting,
@@ -170,8 +154,10 @@ const getDevDependencies = ({
     return devDeps;
 };
 
-const guardCancellation = <T>(value: T | symbol): T => {
-    if (p.isCancel(value)) {
+const isCancellation = (value: unknown): value is typeof p.CANCEL_SYMBOL => p.isCancel(value);
+
+const guardCancellation = <T>(value: T | typeof p.CANCEL_SYMBOL): T => {
+    if (isCancellation(value)) {
         p.cancel("Operation canceled");
         throw new OperationCanceledError();
     }
@@ -200,6 +186,17 @@ const validateApplicationIdInput = (value: string | undefined): string | undefin
 const validateApplicationIdAnswer = (value: string | undefined): string | undefined =>
     value ? validateApplicationIdFormat(value) : undefined;
 
+const validateDisplayName = (value: string | undefined): string | undefined => {
+    if (value === undefined || value.trim().length === 0) {
+        return "Display name is required";
+    }
+
+    return value.includes("\n") || value.includes("\r") ? "Display name must be a single line" : undefined;
+};
+
+const validateDisplayNameAnswer = (value: string | undefined): string | undefined =>
+    value ? validateDisplayName(value) : undefined;
+
 const fail = (message: string): never => {
     p.log.error(message);
     throw new ScaffoldAbortedError(message);
@@ -226,17 +223,15 @@ const validateTargetDir = (target: string): string | undefined => {
 };
 
 const validateTargetAnswer = (value: string | undefined): string | undefined =>
-    validateTargetDir(formatTargetDir(value ?? ""));
+    validateTargetDir(value ?? "");
 
 const promptTarget = async (): Promise<string> =>
-    formatTargetDir(
-        guardCancellation(
-            await p.text({
-                message: "Project directory",
-                placeholder: "my-app",
-                validate: validateTargetAnswer,
-            }),
-        ),
+    guardCancellation(
+        await p.text({
+            message: "Project directory",
+            placeholder: "my-app",
+            validate: validateTargetAnswer,
+        }),
     );
 
 const promptApplicationId = async (name: string): Promise<string> => {
@@ -252,6 +247,19 @@ const promptApplicationId = async (name: string): Promise<string> => {
     );
 };
 
+const promptDisplayName = async (name: string): Promise<string> => {
+    const defaultDisplayName = displayNameFromProjectName(name);
+
+    return guardCancellation(
+        await p.text({
+            message: "Display name",
+            placeholder: defaultDisplayName,
+            defaultValue: defaultDisplayName,
+            validate: validateDisplayNameAnswer,
+        }),
+    );
+};
+
 const packageManagerOption = (manager: (typeof PACKAGE_MANAGERS)[number], detected: PackageManager | undefined) => {
     let hint: string | undefined;
 
@@ -292,54 +300,96 @@ const isOptionEnabled = async (
     isInteractive: boolean | undefined,
     message: string,
 ): Promise<boolean> =>
-    value ??
-    (isInteractive
-        ? guardCancellation(await p.confirm({ message, initialValue: true }))
-        : true);
-
-const emptyDir = (root: string): void => {
-    for (const entry of readdirSync(root)) {
-        if (entry === ".git") {
-            continue;
-        }
+    value ?? (!isInteractive || guardCancellation(await p.confirm({ message, initialValue: true })));
 
-        rmSync(join(root, entry), { recursive: true, force: true });
+const formatFileList = (heading: string, files: string[]): string => {
+    const indentedFiles = files.map((file) => `  ${file}`).join("\n");
+
+    return `${heading}:\n${indentedFiles}`;
+};
+
+const reportPlannedChanges = (changes: ScaffoldChanges): void => {
+    if (changes.length > 0) {
+        p.log.info(formatFileList("Scaffold files to replace", changes));
     }
 };
 
-const shouldOverwriteDirectory = async (target: string, options: CreateOptions): Promise<boolean> => {
-    if (!options.isInteractive) {
-        return options.shouldOverwrite === true;
+const reportCompletedChanges = (changes: ScaffoldChanges): void => {
+    if (changes.length > 0) {
+        p.log.success(formatFileList("Replaced scaffold files", changes));
     }
+};
 
-    return guardCancellation(
+const confirmOverwrite = async (target: string, changes: ScaffoldChanges): Promise<void> => {
+    reportPlannedChanges(changes);
+
+    const shouldReplace = guardCancellation(
         await p.confirm({
-            message: `Directory "${target}" is not empty. Overwrite its contents?`,
+            message: `Directory "${target}" is not empty. Replace scaffold files?`,
             initialValue: false,
         }),
     );
+
+    if (!shouldReplace) {
+        fail(`Directory "${target}" is not empty`);
+    }
 };
 
-const shouldEmptyTargetDirectory = async (root: string, target: string, options: CreateOptions): Promise<boolean> => {
-    const stats = statSync(root, { throwIfNoEntry: false });
+const refuseNonEmptyDirectory = (target: string, changes: ScaffoldChanges): never => {
+    const heading = `Directory "${target}" is not empty. Pass --overwrite to`;
 
-    if (stats === undefined) {
-        return false;
+    return fail(
+        changes.length === 0
+            ? `${heading} scaffold into it`
+            : formatFileList(`${heading} replace these scaffold files`, changes),
+    );
+};
+
+const acceptNonEmptyDirectory = async (
+    target: string,
+    options: CreateOptions,
+    changes: ScaffoldChanges,
+): Promise<void> => {
+    if (options.isInteractive) {
+        await confirmOverwrite(target, changes);
+
+        return;
     }
 
-    if (!stats.isDirectory()) {
-        return fail(`Target "${target}" is not a directory`);
+    if (options.shouldOverwrite === true) {
+        reportPlannedChanges(changes);
+
+        return;
     }
 
-    if (isDirEmpty(root)) {
-        return false;
+    refuseNonEmptyDirectory(target, changes);
+};
+
+const assertTargetIsDirectory = (root: string, target: string): void => {
+    const stats = lstatSync(root, { throwIfNoEntry: false });
+
+    if (stats?.isSymbolicLink()) {
+        fail(`Cannot scaffold through a symbolic link: ${root}`);
     }
 
-    if (await shouldOverwriteDirectory(target, options)) {
-        return true;
+    if (stats !== undefined && !stats.isDirectory()) {
+        fail(`Target "${target}" is not a directory`);
     }
+};
+
+const validateTargetAvailability = async (
+    root: string,
+    target: string,
+    options: CreateOptions,
+    changes: ScaffoldChanges,
+): Promise<void> => {
+    const stats = statSync(root, { throwIfNoEntry: false });
 
-    return fail(`Directory "${target}" is not empty`);
+    if (stats === undefined || isDirEmpty(root)) {
+        return;
+    }
+
+    await acceptNonEmptyDirectory(target, options, changes);
 };
 
 const resolveTarget = async (options: CreateOptions): Promise<string> => {
@@ -347,7 +397,7 @@ const resolveTarget = async (options: CreateOptions): Promise<string> => {
         return promptTarget();
     }
 
-    const target = formatTargetDir(options.name ?? "");
+    const target = options.name ?? "";
     const error = validateTargetDir(target);
 
     return error === undefined ? target : fail(error);
@@ -362,6 +412,14 @@ const resolveApplicationId = async (options: CreateOptions, name: string): Promi
     return error === undefined ? applicationId : fail(error);
 };
 
+const resolveDisplayName = async (options: CreateOptions, name: string): Promise<string> => {
+    const value = options.displayName ??
+        (options.isInteractive ? await promptDisplayName(name) : displayNameFromProjectName(name));
+    const error = validateDisplayName(value);
+
+    return error === undefined ? value.trim() : fail(error);
+};
+
 const resolvePackageManager = async (
     requested: PackageManager | undefined,
     options: CreateOptions,
@@ -381,10 +439,10 @@ const resolveOptions = async (options: CreateOptions): Promise<ResolvedOptions>
     const requested = requestedPackageManager(options.packageManager);
     const target = await resolveTarget(options);
     const name = deriveProjectName(target);
+    const displayName = await resolveDisplayName(options, name);
     const applicationId = await resolveApplicationId(options, name);
     const root = resolve(process.cwd(), target);
-    const isCurrentDirectory = root === process.cwd();
-    const shouldEmptyTarget = await shouldEmptyTargetDirectory(root, target, options);
+    const shouldInitialize = shouldInitializeGit(root);
     const packageManager = await resolvePackageManager(requested, options);
     const isTypescript = await isOptionEnabled(options.isTypescript, options.isInteractive, "Use TypeScript?");
 
@@ -397,13 +455,14 @@ const resolveOptions = async (options: CreateOptions): Promise<ResolvedOptions>
     return {
         target,
         root,
-        isCurrentDirectory,
         name,
+        displayName,
         applicationId,
         packageManager,
         isTypescript,
         shouldIncludeTesting,
-        shouldEmptyTarget,
+        shouldInitializeGit: shouldInitialize,
+        shouldInstallDependencies: options.shouldInstallDependencies !== false,
     };
 };
 
@@ -430,31 +489,93 @@ const destinationPath = (template: string, resolved: ResolvedOptions): string =>
 const templateContext = (resolved: ResolvedOptions): TemplateContext => ({
     name: resolved.name,
     applicationId: resolved.applicationId,
-    title: titleFromName(resolved.name),
+    displayName: resolved.displayName,
     shouldIncludeTesting: resolved.shouldIncludeTesting,
     isTypescript: resolved.isTypescript,
     importExtension: resolved.isTypescript ? ".js" : ".jsx",
-    developerName: gitConfigValue("user.name") ?? titleFromName(resolved.name),
+    developerName: gitConfigValue("user.name") ?? resolved.displayName,
     developerEmail: gitConfigValue("user.email"),
 });
 
-const scaffoldProject = async (root: string, resolved: ResolvedOptions): Promise<void> => {
+const assertSafeAncestor = (ancestor: string): void => {
+    const entry = lstatSync(ancestor, { throwIfNoEntry: false });
+
+    if (entry?.isSymbolicLink()) {
+        fail(`Cannot scaffold through a symbolic link: ${ancestor}`);
+    }
+
+    if (entry !== undefined && !entry.isDirectory()) {
+        fail(`Cannot scaffold through a non-directory path: ${ancestor}`);
+    }
+};
+
+const assertSafeAncestors = (root: string, relativePath: string): void => {
+    let ancestor = root;
+    const segments = relativePath.split(sep);
+    const ancestorSegments = segments.slice(0, -1);
+
+    for (const segment of ancestorSegments) {
+        ancestor = join(ancestor, segment);
+        assertSafeAncestor(ancestor);
+    }
+};
+
+const hasReplaceableDestination = (destination: string): boolean => {
+    const entry = lstatSync(destination, { throwIfNoEntry: false });
+    const isReplaceable = entry === undefined || entry.isFile() || entry.isSymbolicLink();
+
+    if (!isReplaceable) {
+        fail(`Cannot replace scaffold file because its destination is not a file: ${destination}`);
+    }
+
+    return entry !== undefined;
+};
+
+const hasExistingDestination = (root: string, destination: string): boolean => {
+    assertSafeAncestors(root, relative(root, destination));
+
+    return hasReplaceableDestination(destination);
+};
+
+const plannedScaffoldFiles = async (root: string, resolved: ResolvedOptions): Promise<ScaffoldFile[]> => {
     const context = templateContext(resolved);
+    const files: ScaffoldFile[] = [];
 
     for (const template of listTemplates()) {
-        if (!isTemplateIncluded(template, resolved)) {
-            continue;
+        if (isTemplateIncluded(template, resolved)) {
+            files.push({
+                destination: join(root, destinationPath(template, resolved)),
+                contents: await renderFile(template, context),
+            });
         }
+    }
+
+    return files;
+};
+
+const auxiliaryDestinations = (root: string, resolved: ResolvedOptions): string[] =>
+    resolved.packageManager === "pnpm" ? [join(root, "pnpm-workspace.yaml")] : [];
+
+const planScaffoldProject = async (root: string, resolved: ResolvedOptions): Promise<ScaffoldPlan> => {
+    const files = await plannedScaffoldFiles(root, resolved);
+    const destinations = [...files.map((file) => file.destination), ...auxiliaryDestinations(root, resolved)];
+    const replaceDestinations = destinations.filter((destination) => hasExistingDestination(root, destination));
+
+    return {
+        files,
+        replaceDestinations,
+        changes: replaceDestinations.map((destination) => relative(root, destination)),
+    };
+};
 
-        const destination = join(root, destinationPath(template, resolved));
-        mkdirSync(dirname(destination), { recursive: true });
-        writeFileSync(destination, await renderFile(template, context));
+const scaffoldProject = (plan: ScaffoldPlan): void => {
+    for (const destination of plan.replaceDestinations) {
+        rmSync(destination);
     }
 
-    if (resolved.shouldIncludeTesting) {
-        updateManifest(root, (manifest) => {
-            (manifest.scripts as Record<string, string>).test = "vitest run";
-        });
+    for (const file of plan.files) {
+        mkdirSync(dirname(file.destination), { recursive: true });
+        writeFileSync(file.destination, file.contents);
     }
 };
 
@@ -476,40 +597,29 @@ const withoutInheritedScriptPolicy = async (run: () => Promise<void>): Promise<v
     }
 };
 
-const installDependencies = async (options: InstallDependenciesOptions): Promise<void> => {
-    const { cwd, packageManager, dependencies, isDev } = options;
-
-    await withoutInheritedScriptPolicy(async () => {
-        await addDependency(dependencies, { cwd, packageManager, dev: isDev, silent: true });
-    });
-};
-
-const pin = (names: string[]): string[] =>
-    names.map((dependency) => dependency.startsWith("@gtkx/") ? `${dependency}@^${selfVersion}` : dependency);
-
-const formatRecovery = ({ resolved, devDependencies }: InstallFailureOptions): string => {
-    const add = ADD_COMMAND[resolved.packageManager];
+const dependencyVersions = (names: string[]): Record<string, string> => Object.fromEntries(
+    names.map((dependency) => {
+        if (dependency.startsWith("@gtkx/")) {
+            return [dependency, `^${selfVersion}`];
+        }
 
-    const steps = [
-        ...(resolved.isCurrentDirectory ? [] : [`cd ${resolved.target}`]),
-        `${add} ${pin(DEPENDENCIES).join(" ")}`,
-        `${add} -D ${pin(devDependencies).join(" ")}`,
-    ];
+        return [dependency, dependency === "typescript" ? TYPESCRIPT_VERSION : "latest"];
+    }),
+);
 
-    const indented = steps.map((step) => `  ${step}`).join("\n");
+const dependencyArguments = (names: string[]): string[] =>
+    Object.entries(dependencyVersions(names)).map(([name, version]) =>
+        version === "latest" ? name : `${name}@${version}`);
 
-    return `${RECOVERY_HEADING}\n${indented}`;
+const writeDependencies = (root: string, devDependencies: string[]): void => {
+    updateManifest(root, (manifest) => {
+        manifest.dependencies = dependencyVersions(DEPENDENCIES);
+        manifest.devDependencies = dependencyVersions(devDependencies);
+    });
 };
 
-const explainInstallFailure = (options: InstallFailureOptions): void => {
-    const hint = getInstallHint(errorMessage(options.error));
-
-    if (hint !== undefined) {
-        p.log.warn(hint);
-    }
-
-    p.log.info(formatRecovery(options));
-};
+const formatRecovery = (resolved: ResolvedOptions): string =>
+    `To finish setup, run ${INSTALL_COMMAND[resolved.packageManager]} in ${resolved.root}.`;
 
 const runWithSpinner = async (step: SpinnerStep): Promise<void> => {
     const spinner = p.spinner();
@@ -521,13 +631,12 @@ const runWithSpinner = async (step: SpinnerStep): Promise<void> => {
     } catch (error) {
         spinner.error(step.failed);
         p.log.error(errorMessage(error));
-        step.explain?.(error);
+        step.explain?.();
         throw new ScaffoldAbortedError(step.failed);
     }
 };
 
-const installAllDependencies = async (options: InstallAllOptions): Promise<void> => {
-    const { resolved, devDependencies } = options;
+const installAllDependencies = async (resolved: ResolvedOptions, devDependencies: string[]): Promise<void> => {
     const { root, packageManager } = resolved;
 
     await runWithSpinner({
@@ -535,22 +644,39 @@ const installAllDependencies = async (options: InstallAllOptions): Promise<void>
         done: "Dependencies installed",
         failed: "Failed to install dependencies",
         run: async () => {
-            await installDependencies({ cwd: root, packageManager, dependencies: pin(DEPENDENCIES), isDev: false });
-            await installDependencies({ cwd: root, packageManager, dependencies: pin(devDependencies), isDev: true });
+            await withoutInheritedScriptPolicy(async () => {
+                const options = { cwd: root, packageManager, silent: true };
+                await addDependency(dependencyArguments(DEPENDENCIES), options);
+                await addDependency(dependencyArguments(devDependencies), { ...options, dev: true });
+            });
         },
-        explain: (error) => {
-            explainInstallFailure({ error, resolved, devDependencies });
+        explain: () => {
+            p.log.info(formatRecovery(resolved));
         },
     });
 };
 
-const writeInitialEnvModule = (root: string): void => {
-    const storeDir = join(root, "node_modules", ".gtkx");
-    mkdirSync(storeDir, { recursive: true });
-    writeFileSync(join(storeDir, "env.d.ts"), `${GTKX_ENV_MODULE_HEADER}\n`);
+const isInsideGitRepository = (root: string): boolean => {
+    const git = tryResolveExecutable("git");
+
+    if (git === undefined) {
+        return false;
+    }
+
+    try {
+        execFileSync(git, ["-C", root, "rev-parse", "--show-toplevel"], { stdio: "ignore" });
+
+        return true;
+    } catch {
+        return false;
+    }
 };
 
-const initializeGitRepo = async (root: string): Promise<void> => {
+const initializeGitRepo = async (root: string, shouldInitialize: boolean): Promise<void> => {
+    if (!shouldInitialize || isInsideGitRepository(root)) {
+        return;
+    }
+
     const spinner = p.spinner();
     spinner.start("Initializing git repository...");
 
@@ -567,24 +693,23 @@ const initializeGitRepo = async (root: string): Promise<void> => {
 
 const printNextSteps = (resolved: ResolvedOptions): void => {
     const devCmd = DEV_COMMAND[resolved.packageManager];
-    const cdStep = resolved.isCurrentDirectory ? "" : `cd ${resolved.target}\n`;
+    const installStep = resolved.shouldInstallDependencies ? "" : `${INSTALL_COMMAND[resolved.packageManager]}\n`;
     const testingNote = resolved.shouldIncludeTesting ? HEADLESS_COMPOSITOR_NOTE : "";
-    p.note(`${cdStep}${devCmd}${testingNote}`, "Next steps");
+    p.note(`${installStep}${devCmd}${testingNote}`, `Run in ${resolved.root}`);
 };
 
-const createProjectStructure = async (root: string, resolved: ResolvedOptions): Promise<void> => {
+const createProjectStructure = async (
+    root: string,
+    resolved: ResolvedOptions,
+    plan: ScaffoldPlan,
+): Promise<void> => {
     await runWithSpinner({
         pending: "Creating project structure...",
         done: "Project structure created",
         failed: "Failed to create the project structure",
-        run: async () => {
+        run: () => {
             mkdirSync(root, { recursive: true });
-
-            if (resolved.shouldEmptyTarget) {
-                emptyDir(root);
-            }
-
-            await scaffoldProject(root, resolved);
+            scaffoldProject(plan);
             writeBuildAllowance(root, resolved.packageManager);
         },
     });
@@ -595,14 +720,18 @@ const scaffold = async (options: CreateOptions = {}): Promise<void> => {
     const resolved = await resolveOptions(options);
     const { root } = resolved;
     const devDeps = getDevDependencies(resolved);
-    await createProjectStructure(root, resolved);
-    await installAllDependencies({ resolved, devDependencies: devDeps });
+    assertTargetIsDirectory(root, resolved.target);
+    const plan = await planScaffoldProject(root, resolved);
+    await validateTargetAvailability(root, resolved.target, options, plan.changes);
+    await createProjectStructure(root, resolved, plan);
+    writeDependencies(root, devDeps);
+    reportCompletedChanges(plan.changes);
 
-    if (resolved.isTypescript) {
-        writeInitialEnvModule(root);
+    if (resolved.shouldInstallDependencies) {
+        await installAllDependencies(resolved, devDeps);
     }
 
-    await initializeGitRepo(root);
+    await initializeGitRepo(root, resolved.shouldInitializeGit);
     printNextSteps(resolved);
 };