create-gtkx 1.6.0 → 2.0.0-beta.10

package/dist/scaffolder.js

@@ -2,8 +2,8 @@ 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, isAbsolute, 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" };
@@ -16,6 +16,7 @@ import { isValidProjectName } from "./project-name.js";
 import { listTemplates, renderFile } from "./templates.js";
 const selfVersion = packageManifest.version;
 const ICON_TEMPLATE_NAME = "icon.svg";
+const TYPESCRIPT_VERSION = "^6.0.3";
 const GTKX_ENV_MODULE_HEADER = `/**
  * Generated by \`gtkx codegen\`, \`gtkx dev\`, and \`gtkx build\`; do not edit.
  */`;
@@ -25,6 +26,7 @@ const TYPESCRIPT_DEV_DEPENDENCIES = ["@types/node", "@types/react", "typescript"
 const TESTING_DEV_DEPENDENCIES = ["@gtkx/testing", "vitest"];
 const DEV_COMMAND = Object.fromEntries(PACKAGE_MANAGERS.map((manager) => [manager.value, manager.devCommand]));
 const ADD_COMMAND = Object.fromEntries(PACKAGE_MANAGERS.map((manager) => [manager.value, manager.addCommand]));
+const INSTALL_COMMAND = Object.fromEntries(PACKAGE_MANAGERS.map((manager) => [manager.value, manager.installCommand]));
 const INHERITED_SCRIPT_POLICY_VARS = ["npm_config_allow_scripts", "npm_config_allow-scripts"];
 const TESTING_TEMPLATES = new Set(["vitest.config.ts", "tests/app.test.tsx"]);
 const TYPESCRIPT_TEMPLATES = new Set(["tsconfig.json", "src/gtkx-env.d.ts"]);
@@ -39,10 +41,7 @@ const APPLICATION_ID_PREFIX = "com.";
 const APPLICATION_ID_SUFFIX = ".app";
 const APPLICATION_ID_SEGMENT_LIMIT = APPLICATION_ID_MAX_LENGTH - APPLICATION_ID_PREFIX.length -
     APPLICATION_ID_SUFFIX.length;
-const pinGtkxDependency = (name, version) => name.startsWith("@gtkx/") ? `${name}@^${version}` : name;
-const getDevCommand = (packageManager) => DEV_COMMAND[packageManager];
-const getAddCommand = (packageManager) => ADD_COMMAND[packageManager];
-const titleFromName = (name) => name.split("-").map((part) => upperFirst(part)).join(" ");
+const displayNameFromProjectName = (name) => name.split("-").map((part) => upperFirst(part)).join(" ");
 const gitConfigValue = (key) => {
     const git = tryResolveExecutable("git");
     if (git === undefined) {
@@ -74,6 +73,10 @@ const isDirEmpty = (dir) => {
     const entries = readdirSync(dir);
     return entries.length === 0 || (entries.length === 1 && entries[0] === ".git");
 };
+const shouldInitializeGit = (root) => {
+    const entry = lstatSync(root, { throwIfNoEntry: false });
+    return entry === undefined || (entry.isDirectory() && readdirSync(root).length === 0);
+};
 const getDevDependencies = ({ isTypescript, shouldIncludeTesting, }) => {
     const devDeps = [...DEV_DEPENDENCIES];
     if (isTypescript) {
@@ -84,8 +87,9 @@ const getDevDependencies = ({ isTypescript, shouldIncludeTesting, }) => {
     }
     return devDeps;
 };
+const isCancellation = (value) => p.isCancel(value);
 const guardCancellation = (value) => {
-    if (p.isCancel(value)) {
+    if (isCancellation(value)) {
         p.cancel("Operation canceled");
         throw new OperationCanceledError();
     }
@@ -103,6 +107,13 @@ const validateProjectName = (value) => {
 const validateApplicationIdFormat = (value) => isValidApplicationId(value) ? undefined : APPLICATION_ID_FORMAT_ERROR;
 const validateApplicationIdInput = (value) => value ? validateApplicationIdFormat(value) : "Application ID is required";
 const validateApplicationIdAnswer = (value) => value ? validateApplicationIdFormat(value) : undefined;
+const validateDisplayName = (value) => {
+    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) => value ? validateDisplayName(value) : undefined;
 const fail = (message) => {
     p.log.error(message);
     throw new ScaffoldAbortedError(message);
@@ -116,14 +127,6 @@ const requestedPackageManager = (value) => {
     }
     return value;
 };
-const targetStats = (root) => {
-    try {
-        return statSync(root, { throwIfNoEntry: false });
-    }
-    catch {
-        return undefined;
-    }
-};
 const validateTargetDir = (target) => {
     if (!target) {
         return "Project directory is required";
@@ -145,29 +148,29 @@ const promptApplicationId = async (name) => {
         validate: validateApplicationIdAnswer,
     }));
 };
-const detectPackageManager = async (cwd) => {
-    const detected = await nypmDetectPackageManager(cwd, { includeParentDirs: true });
-    if (!detected) {
-        return undefined;
-    }
-    return isKnownPackageManager(detected.name) ? detected.name : undefined;
+const promptDisplayName = async (name) => {
+    const defaultDisplayName = displayNameFromProjectName(name);
+    return guardCancellation(await p.text({
+        message: "Display name",
+        placeholder: defaultDisplayName,
+        defaultValue: defaultDisplayName,
+        validate: validateDisplayNameAnswer,
+    }));
 };
-const packageManagerHint = (manager, detected) => {
+const packageManagerOption = (manager, detected) => {
+    let hint;
     if (detected === manager.value) {
-        return "detected";
+        hint = "detected";
     }
-    if (manager.isRecommended) {
-        return "recommended";
+    else if (manager.isRecommended) {
+        hint = "recommended";
     }
-    return undefined;
-};
-const packageManagerOption = (manager, detected) => {
-    const hint = packageManagerHint(manager, detected);
     return { value: manager.value, label: manager.label, ...(hint !== undefined && { hint }) };
 };
 const detectedPackageManager = async () => {
     try {
-        return await detectPackageManager(process.cwd());
+        const detected = await nypmDetectPackageManager(process.cwd(), { includeParentDirs: true });
+        return detected && isKnownPackageManager(detected.name) ? detected.name : undefined;
     }
     catch {
         return undefined;
@@ -182,52 +185,64 @@ const promptPackageManager = async () => {
         initialValue: initial,
     }));
 };
-const shouldUseTypeScript = async () => guardCancellation(await p.confirm({
-    message: "Use TypeScript?",
-    initialValue: true,
-}));
-const shouldSetUpTesting = async () => guardCancellation(await p.confirm({
-    message: "Include testing setup (Vitest)?",
-    initialValue: true,
-}));
-const emptyDir = (root) => {
-    for (const entry of readdirSync(root)) {
-        if (entry === ".git") {
-            continue;
-        }
-        rmSync(join(root, entry), { recursive: true, force: true });
-    }
+const isOptionEnabled = async (value, isInteractive, message) => value ??
+    (isInteractive
+        ? guardCancellation(await p.confirm({ message, initialValue: true }))
+        : true);
+const formatFileList = (heading, files) => {
+    const indentedFiles = files.map((file) => `  ${file}`).join("\n");
+    return `${heading}:\n${indentedFiles}`;
 };
-const prepareTargetDirectory = (root, shouldEmptyTarget) => {
-    mkdirSync(root, { recursive: true });
-    if (shouldEmptyTarget) {
-        emptyDir(root);
+const reportPlannedChanges = (changes) => {
+    if (changes.length > 0) {
+        p.log.info(formatFileList("Scaffold files to replace", changes));
     }
 };
-const shouldOverwriteDirectory = async (target, options) => {
-    if (!options.isInteractive) {
-        return options.shouldOverwrite === true;
+const reportCompletedChanges = (changes) => {
+    if (changes.length > 0) {
+        p.log.success(formatFileList("Replaced scaffold files", changes));
     }
-    return guardCancellation(await p.confirm({
-        message: `Directory "${target}" is not empty. Overwrite its contents?`,
+};
+const confirmOverwrite = async (target, changes) => {
+    reportPlannedChanges(changes);
+    const shouldReplace = guardCancellation(await p.confirm({
+        message: `Directory "${target}" is not empty. Replace scaffold files?`,
         initialValue: false,
     }));
+    if (!shouldReplace) {
+        fail(`Directory "${target}" is not empty`);
+    }
 };
-const shouldEmptyTargetDirectory = async (root, target, options) => {
-    const stats = targetStats(root);
-    if (stats === undefined) {
-        return false;
+const refuseNonEmptyDirectory = (target, changes) => {
+    const heading = `Directory "${target}" is not empty. Pass --overwrite to`;
+    return fail(changes.length === 0
+        ? `${heading} scaffold into it`
+        : formatFileList(`${heading} replace these scaffold files`, changes));
+};
+const acceptNonEmptyDirectory = async (target, options, changes) => {
+    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, target) => {
+    const stats = statSync(root, { throwIfNoEntry: false });
+    if (stats !== undefined && !stats.isDirectory()) {
+        fail(`Target "${target}" is not a directory`);
     }
-    if (await shouldOverwriteDirectory(target, options)) {
-        return true;
+};
+const validateTargetAvailability = async (root, target, options, changes) => {
+    const stats = statSync(root, { throwIfNoEntry: false });
+    assertTargetIsDirectory(root, target);
+    if (stats === undefined || isDirEmpty(root)) {
+        return;
     }
-    return fail(`Directory "${target}" is not empty`);
+    await acceptNonEmptyDirectory(target, options, changes);
 };
 const resolveTarget = async (options) => {
     if (options.name === undefined && options.isInteractive) {
@@ -243,6 +258,12 @@ const resolveApplicationId = async (options, name) => {
     const error = validateApplicationIdInput(applicationId);
     return error === undefined ? applicationId : fail(error);
 };
+const resolveDisplayName = async (options, name) => {
+    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, options) => {
     if (requested !== undefined) {
         return requested;
@@ -252,39 +273,30 @@ const resolvePackageManager = async (requested, options) => {
     }
     return (await detectedPackageManager()) ?? "pnpm";
 };
-const isTypescriptSelected = async (options) => {
-    if (options.isTypescript !== undefined) {
-        return options.isTypescript;
-    }
-    return options.isInteractive ? shouldUseTypeScript() : true;
-};
-const isTestingIncluded = async (options) => {
-    if (options.shouldIncludeTesting !== undefined) {
-        return options.shouldIncludeTesting;
-    }
-    return options.isInteractive ? shouldSetUpTesting() : true;
-};
 const resolveOptions = async (options) => {
     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 isTypescriptSelected(options);
-    const shouldIncludeTesting = await isTestingIncluded(options);
+    const isTypescript = await isOptionEnabled(options.isTypescript, options.isInteractive, "Use TypeScript?");
+    const shouldIncludeTesting = await isOptionEnabled(options.shouldIncludeTesting, options.isInteractive, "Include testing setup (Vitest)?");
     return {
         target,
         root,
         isCurrentDirectory,
         name,
+        displayName,
         applicationId,
         packageManager,
         isTypescript,
         shouldIncludeTesting,
-        shouldEmptyTarget,
+        shouldInitializeGit: shouldInitialize,
+        shouldInstallDependencies: options.shouldInstallDependencies !== false,
     };
 };
 const isTemplateIncluded = (templateRelativePath, resolved) => {
@@ -296,37 +308,139 @@ const isTemplateIncluded = (templateRelativePath, resolved) => {
     }
     return true;
 };
-const toScriptExtension = (templateRelativePath, isTypescript) => isTypescript ? templateRelativePath : templateRelativePath.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
-const toIconPath = (path, applicationId) => path.endsWith(ICON_TEMPLATE_NAME) ? `${path.slice(0, -ICON_TEMPLATE_NAME.length)}${applicationId}.svg` : path;
-const toDestinationPath = (templateRelativePath, isTypescript, applicationId) => toIconPath(toScriptExtension(templateRelativePath, isTypescript), applicationId);
-const addTestScript = (root) => {
-    updateManifest(root, (manifest) => {
-        manifest.scripts.test = "vitest run";
-    });
+const destinationPath = (template, resolved) => {
+    const scriptPath = resolved.isTypescript ? template : template.replace(/\.tsx$/, ".jsx").replace(/\.ts$/, ".js");
+    return scriptPath.endsWith(ICON_TEMPLATE_NAME)
+        ? `${scriptPath.slice(0, -ICON_TEMPLATE_NAME.length)}${resolved.applicationId}.svg`
+        : scriptPath;
 };
 const templateContext = (resolved) => ({
     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, resolved) => {
-    const { applicationId, isTypescript, shouldIncludeTesting } = resolved;
+const replaceTemplateDestination = (destination) => {
+    const entry = lstatSync(destination, { throwIfNoEntry: false });
+    if (entry === undefined) {
+        return;
+    }
+    if (!entry.isFile() && !entry.isSymbolicLink()) {
+        fail(`Cannot replace scaffold file because its destination is not a file: ${destination}`);
+    }
+    rmSync(destination, { force: true });
+};
+const projectRelativeDestination = (root, destination) => {
+    const relativePath = relative(root, destination);
+    const isOutsideProject = relativePath.length === 0 || relativePath.startsWith(`..${sep}`) ||
+        isAbsolute(relativePath);
+    if (isOutsideProject) {
+        fail(`Scaffold destination is outside the project: ${destination}`);
+    }
+    return relativePath;
+};
+const assertRootIsNotSymbolicLink = (root) => {
+    const rootEntry = lstatSync(root, { throwIfNoEntry: false });
+    if (rootEntry?.isSymbolicLink()) {
+        fail(`Cannot scaffold through a symbolic link: ${root}`);
+    }
+};
+const assertSafeAncestor = (ancestor) => {
+    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, relativePath) => {
+    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 assertReplaceableDestination = (destination) => {
+    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}`);
+    }
+};
+const assertSafeDestination = (root, destination) => {
+    const relativePath = projectRelativeDestination(root, destination);
+    assertRootIsNotSymbolicLink(root);
+    assertSafeAncestors(root, relativePath);
+    assertReplaceableDestination(destination);
+};
+const plannedScaffoldFiles = async (root, resolved) => {
     const context = templateContext(resolved);
+    const files = [];
     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),
+            });
         }
-        const destination = join(root, toDestinationPath(template, isTypescript, applicationId));
-        mkdirSync(dirname(destination), { recursive: true });
-        writeFileSync(destination, await renderFile(template, context));
     }
-    if (shouldIncludeTesting) {
-        addTestScript(root);
+    return files;
+};
+const auxiliaryDestinations = (root, resolved) => resolved.packageManager === "pnpm" ? [join(root, "pnpm-workspace.yaml")] : [];
+const envModulePath = (root) => join(root, "node_modules", ".gtkx", "env.d.ts");
+const shouldWriteEnvModule = (resolved) => resolved.isTypescript && resolved.shouldInstallDependencies;
+const generatedDestinations = (root, resolved) => shouldWriteEnvModule(resolved) ? [envModulePath(root)] : [];
+const isPresent = (path) => lstatSync(path, { throwIfNoEntry: false }) !== undefined;
+const classifyScaffoldChange = (root, destination) => {
+    const entry = lstatSync(destination, { throwIfNoEntry: false });
+    if (entry === undefined) {
+        return undefined;
+    }
+    return { destination, relativePath: projectRelativeDestination(root, destination) };
+};
+const addScaffoldChange = (plan, change) => {
+    if (change === undefined) {
+        return;
+    }
+    plan.replaceDestinations.push(change.destination);
+    plan.changes.push(change.relativePath);
+};
+const planScaffoldProject = async (root, resolved) => {
+    const files = await plannedScaffoldFiles(root, resolved);
+    const reported = [...files.map((file) => file.destination), ...auxiliaryDestinations(root, resolved)];
+    const generated = generatedDestinations(root, resolved);
+    for (const destination of [...reported, ...generated]) {
+        assertSafeDestination(root, destination);
+    }
+    const plan = {
+        files,
+        replaceDestinations: generated.filter((destination) => isPresent(destination)),
+        changes: [],
+    };
+    for (const destination of reported) {
+        addScaffoldChange(plan, classifyScaffoldChange(root, destination));
+    }
+    return plan;
+};
+const scaffoldProject = (root, resolved, plan) => {
+    for (const destination of plan.replaceDestinations) {
+        replaceTemplateDestination(destination);
+    }
+    for (const file of plan.files) {
+        mkdirSync(dirname(file.destination), { recursive: true });
+        writeFileSync(file.destination, file.contents);
+    }
+    if (resolved.shouldIncludeTesting) {
+        updateManifest(root, (manifest) => {
+            manifest.scripts.test = "vitest run";
+        });
     }
 };
 const withoutInheritedScriptPolicy = async (run) => {
@@ -351,9 +465,26 @@ const installDependencies = async (options) => {
         await addDependency(dependencies, { cwd, packageManager, dev: isDev, silent: true });
     });
 };
-const pin = (names) => names.map((dependency) => pinGtkxDependency(dependency, selfVersion));
+const pin = (names) => names.map((dependency) => {
+    if (dependency.startsWith("@gtkx/")) {
+        return `${dependency}@^${selfVersion}`;
+    }
+    return dependency === "typescript" ? `${dependency}@${TYPESCRIPT_VERSION}` : dependency;
+});
+const dependencyVersions = (names) => Object.fromEntries(names.map((dependency) => {
+    if (dependency.startsWith("@gtkx/")) {
+        return [dependency, `^${selfVersion}`];
+    }
+    return [dependency, dependency === "typescript" ? TYPESCRIPT_VERSION : "latest"];
+}));
+const writeDependencies = (root, devDependencies) => {
+    updateManifest(root, (manifest) => {
+        manifest.dependencies = dependencyVersions(DEPENDENCIES);
+        manifest.devDependencies = dependencyVersions(devDependencies);
+    });
+};
 const formatRecovery = ({ resolved, devDependencies }) => {
-    const add = getAddCommand(resolved.packageManager);
+    const add = ADD_COMMAND[resolved.packageManager];
     const steps = [
         ...(resolved.isCurrentDirectory ? [] : [`cd ${resolved.target}`]),
         `${add} ${pin(DEPENDENCIES).join(" ")}`,
@@ -400,11 +531,27 @@ const installAllDependencies = async (options) => {
     });
 };
 const writeInitialEnvModule = (root) => {
-    const storeDir = join(root, "node_modules", ".gtkx");
-    mkdirSync(storeDir, { recursive: true });
-    writeFileSync(join(storeDir, "env.d.ts"), `${GTKX_ENV_MODULE_HEADER}\n`);
+    const path = envModulePath(root);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${GTKX_ENV_MODULE_HEADER}\n`);
 };
-const initializeGitRepo = async (root) => {
+const isInsideGitRepository = (root) => {
+    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, shouldInitialize) => {
+    if (!shouldInitialize || isInsideGitRepository(root)) {
+        return;
+    }
     const spinner = p.spinner();
     spinner.start("Initializing git repository...");
     try {
@@ -419,20 +566,24 @@ const initializeGitRepo = async (root) => {
     }
 };
 const printNextSteps = (resolved) => {
-    const devCmd = getDevCommand(resolved.packageManager);
+    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(`${cdStep}${installStep}${devCmd}${testingNote}`, "Next steps");
 };
-const createProjectStructure = async (root, resolved) => {
+const createProjectStructure = async (root, resolved, plan) => {
     await runWithSpinner({
         pending: "Creating project structure...",
         done: "Project structure created",
         failed: "Failed to create the project structure",
-        run: async () => {
-            prepareTargetDirectory(root, resolved.shouldEmptyTarget);
-            await scaffoldProject(root, resolved);
+        run: () => {
+            mkdirSync(root, { recursive: true });
+            scaffoldProject(root, resolved, plan);
             writeBuildAllowance(root, resolved.packageManager);
+            if (shouldWriteEnvModule(resolved)) {
+                writeInitialEnvModule(root);
+            }
         },
     });
 };
@@ -441,12 +592,18 @@ const scaffold = async (options = {}) => {
     const resolved = await resolveOptions(options);
     const { root } = resolved;
     const devDeps = getDevDependencies(resolved);
-    await createProjectStructure(root, resolved);
-    await installAllDependencies({ resolved, devDependencies: devDeps });
-    if (resolved.isTypescript) {
-        writeInitialEnvModule(root);
-    }
-    await initializeGitRepo(root);
+    assertTargetIsDirectory(root, resolved.target);
+    const plan = await planScaffoldProject(root, resolved);
+    await validateTargetAvailability(root, resolved.target, options, plan.changes);
+    await createProjectStructure(root, resolved, plan);
+    reportCompletedChanges(plan.changes);
+    if (resolved.shouldInstallDependencies) {
+        await installAllDependencies({ resolved, devDependencies: devDeps });
+    }
+    else {
+        writeDependencies(root, devDeps);
+    }
+    await initializeGitRepo(root, resolved.shouldInitializeGit);
     printNextSteps(resolved);
 };
 export { scaffold };