@pixpilot/scaffoldfy-configs 0.46.0 → 0.48.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pixpilot/scaffoldfy-configs
 
+## 0.48.0
+
+### Minor Changes
+
+- add support for pre-set answers in configuration
+
+## 0.47.0
+
+### Minor Changes
+
+- support answers in scaffoldfy configs
+
 ## 0.46.0
 
 ### Minor Changes

package/README.md

@@ -134,16 +134,6 @@ Usage:
 npx @pixpilot/scaffoldfy@latest --config https://unpkg.com/@pixpilot/scaffoldfy-configs@latest/update-root-package-json/scaffoldfy.json
 ```
 
-### workspace-generator
-
-Generate workspace with apps and packages
-
-Usage:
-
-```sh
-npx @pixpilot/scaffoldfy@latest --config https://unpkg.com/@pixpilot/scaffoldfy-configs@latest/workspace-generator/scaffoldfy.jsonc
-```
-
 ### workspace-initializer
 
 Initial setup for a pnpm + Turbo monorepo template, including project info, license, and initial package generation.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pixpilot/scaffoldfy-configs",
   "type": "module",
-  "version": "0.46.0",
+  "version": "0.48.0",
   "author": "PixPilot <m.doaie@hotmail.com>",
   "license": "MIT",
   "repository": {
@@ -30,10 +30,10 @@
     "@types/node": "^22.18.11",
     "eslint": "^9.38.0",
     "@internal/eslint-config": "0.3.0",
-    "@internal/tsdown-config": "0.1.0",
     "@internal/prettier-config": "0.0.1",
+    "@internal/tsdown-config": "0.1.0",
     "@internal/vitest-config": "0.1.0",
-    "@pixpilot/scaffoldfy": "0.57.0"
+    "@pixpilot/scaffoldfy": "0.58.0"
   },
   "prettier": "@internal/prettier-config",
   "publishConfig": {

package/test/package-generator-answers.test.ts

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import {
+  loadTasksWithInheritance,
+  resolveConfigAnswers,
+  validateScaffoldfyJsonFile,
+} from '@pixpilot/scaffoldfy';
+import { describe, expect, it } from 'vitest';
+
+// The repo's own package generator (`pnpm gen:package`), which answers the prompts of
+// workspace-package-generator in its `answers` field
+const generatorPath = path.join(
+  __dirname,
+  '..',
+  '..',
+  '..',
+  'generators',
+  'package',
+  'scaffoldfy.jsonc',
+);
+
+describe('package generator answers', () => {
+  it('should be a valid config', () => {
+    expect(validateScaffoldfyJsonFile(generatorPath).valid).toBe(true);
+  });
+
+  it('should answer existing workspace-package-generator prompts', async () => {
+    const { configs = [] } = await loadTasksWithInheritance(generatorPath, {
+      sequential: true,
+    });
+
+    expect(resolveConfigAnswers(configs)).toEqual({
+      workspace: 'packages',
+      bundler: 'tsdown',
+      author: 'PixPilot',
+      authorEmail: 'm.doaie@hotmail.com',
+      repoOwner: 'pixpilot',
+      orgName: 'pixpilot',
+      licenseType: 'MIT',
+    });
+  });
+});

package/test/workspace-generator.test.ts

@@ -1,236 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import process from 'node:process';
-import { afterEach, describe, expect, it } from 'vitest';
-
-const SCRIPT_PATH = path.join(
-  __dirname,
-  '..',
-  'workspace-generator',
-  'scripts',
-  'setup-workspace.cjs',
-);
-const temporaryDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of temporaryDirectories.splice(0)) {
-    fs.rmSync(directory, { force: true, recursive: true });
-  }
-});
-
-function createFakeGit(testDirectory: string): string {
-  const binDirectory = path.join(testDirectory, 'bin');
-  const fakeGitPath = path.join(binDirectory, 'fake-git.cjs');
-  const gitCommandPath = path.join(
-    binDirectory,
-    process.platform === 'win32' ? 'git.exe' : 'git',
-  );
-  const pnpmCommandPath = path.join(
-    binDirectory,
-    process.platform === 'win32' ? 'pnpm.exe' : 'pnpm',
-  );
-
-  fs.mkdirSync(binDirectory, { recursive: true });
-  fs.writeFileSync(
-    fakeGitPath,
-    [
-      "'use strict';",
-      "const fs = require('node:fs');",
-      "const Module = require('node:module');",
-      "const path = require('node:path');",
-      'function applyGitOperation(command, args) {',
-      "  if (command === 'clone') {",
-      '  const destination = args.at(-1);',
-      "  if (destination === '.') {",
-      "    fs.writeFileSync(path.join(process.cwd(), 'base-template.txt'), 'base');",
-      "    fs.writeFileSync(path.join(process.cwd(), 'package.json'), JSON.stringify({ scripts: { lint: 'base-lint' }, devDependencies: { 'base-dependency': '1.0.0' } }));",
-      "    fs.writeFileSync(path.join(process.cwd(), 'pnpm-workspace.yaml'), \"packages:\\n  - 'packages/**'\\n  - 'tooling/**'\\ncatalogs:\\n  dev:\\n    tsdown: ^1.0.0\\n    typescript-eslint: ^1.0.0\\n\");",
-      '  } else {',
-      '    fs.mkdirSync(destination, { recursive: true });',
-      '  }',
-      "  } else if (command === 'pnpm' || command === 'install') {",
-      "    fs.writeFileSync(path.join(process.cwd(), 'pnpm-lock.yaml'), 'lock');",
-      "  } else if (command === 'sparse-checkout') {",
-      "  const sourceDirectories = args.filter((arg) => !arg.startsWith('-') && arg !== 'set');",
-      '  for (const sourceDirectory of sourceDirectories) {',
-      "    if (sourceDirectory === 'package.json') {",
-      "      fs.writeFileSync(path.join(process.cwd(), sourceDirectory), JSON.stringify({ scripts: { 'web:dev': 'source-web-dev', 'web:build': 'source-web-build', dev: 'source-dev', native: 'source-native', 'expo:clean:install': 'source-expo-clean-install', 'expo:clean:run': 'source-expo-clean-run', 'android:dev': 'source-android-dev', 'android:clean:dev': 'source-android-clean-dev', 'ios:dev': 'source-ios-dev', 'ios:clean:dev': 'source-ios-clean-dev' }, devDependencies: { 'template-dependency': '1.0.0' } }));",
-      "    } else if (sourceDirectory === 'pnpm-workspace.yaml') {",
-      '      fs.writeFileSync(path.join(process.cwd(), sourceDirectory), "packages:\\n  - apps/*\\n  - packages/*\\n  - tooling/*\\ncatalogs:\\n  dev:\\n    template-dependency: ^1.0.0\\n    \\"typescript-eslint\\": ^2.0.0\\n");',
-      "    } else if (sourceDirectory === '.github/workflows') {",
-      '      fs.mkdirSync(path.join(process.cwd(), sourceDirectory), { recursive: true });',
-      "      fs.writeFileSync(path.join(process.cwd(), sourceDirectory, 'ci.yml'), 'ci');",
-      '    } else {',
-      '      const templateDirectory = path.join(process.cwd(), sourceDirectory);',
-      '      fs.mkdirSync(templateDirectory, { recursive: true });',
-      "      fs.writeFileSync(path.join(templateDirectory, 'template.txt'), sourceDirectory);",
-      '    }',
-      '  }',
-      '}',
-      '}',
-      "if (process.env.SCAFFOLDFY_FAKE_GIT_MODE === 'preload') {",
-      '  const resolveFilename = Module._resolveFilename;',
-      '  Module._resolveFilename = function resolveFakeGit(request, ...args) {',
-      '    const command = path.basename(request);',
-      "    if (command === 'clone' || command === 'install' || command === 'pnpm' || command === 'sparse-checkout') {",
-      "      applyGitOperation(command === 'install' ? 'pnpm' : command, process.argv.slice(2));",
-      "      return path.join(__dirname, 'noop.cjs');",
-      '    }',
-      '    return resolveFilename.call(this, request, ...args);',
-      '  };',
-      '} else {',
-      '  const [command, ...args] = process.argv.slice(2);',
-      '  applyGitOperation(command, args);',
-      '}',
-    ].join('\n'),
-  );
-
-  if (process.platform === 'win32') {
-    fs.writeFileSync(path.join(binDirectory, 'noop.cjs'), "'use strict';\n");
-    fs.copyFileSync(process.execPath, gitCommandPath);
-    fs.copyFileSync(process.execPath, pnpmCommandPath);
-  } else {
-    fs.writeFileSync(
-      gitCommandPath,
-      `#!${process.execPath}\nrequire('./fake-git.cjs');\n`,
-    );
-    fs.chmodSync(gitCommandPath, 0o755);
-    fs.writeFileSync(
-      pnpmCommandPath,
-      `#!${process.execPath}\nrequire('./fake-git.cjs');\n`,
-    );
-    fs.chmodSync(pnpmCommandPath, 0o755);
-  }
-
-  return binDirectory;
-}
-
-function runSetup(workspaceApps: string): string {
-  const testDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'scaffoldfy-workspace-'));
-  const workspaceDirectory = path.join(testDirectory, 'workspace');
-  temporaryDirectories.push(testDirectory);
-  fs.mkdirSync(workspaceDirectory);
-  const gitBinDirectory = createFakeGit(testDirectory);
-  const fakeGitPath = path.join(gitBinDirectory, 'fake-git.cjs');
-
-  execFileSync(process.execPath, [SCRIPT_PATH], {
-    cwd: workspaceDirectory,
-    stdio: 'pipe',
-    env: {
-      ...process.env,
-      PATH: `${gitBinDirectory}${path.delimiter}${process.env['PATH'] ?? ''}`,
-      ...(process.platform === 'win32' && {
-        NODE_OPTIONS: `--require=${fakeGitPath} ${process.env['NODE_OPTIONS'] ?? ''}`,
-        Path: `${gitBinDirectory}${path.delimiter}${process.env['Path'] ?? ''}`,
-        SCAFFOLDFY_FAKE_GIT_MODE: 'preload',
-      }),
-      WORKSPACE_APPS: workspaceApps,
-    },
-  });
-
-  return workspaceDirectory;
-}
-
-describe('workspace-generator setup script', () => {
-  it('should clone the base template when only Library is selected', () => {
-    const workspaceDirectory = runSetup('library');
-
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'base-template.txt'), 'utf8'),
-    ).toBe('base');
-    expect(fs.existsSync(path.join(workspaceDirectory, 'apps'))).toBe(false);
-  });
-
-  it('should add the selected app and its required workspace files', () => {
-    const workspaceDirectory = runSetup('nextjs-cloudflare');
-
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'base-template.txt'), 'utf8'),
-    ).toBe('base');
-    expect(
-      fs.readFileSync(
-        path.join(workspaceDirectory, 'apps', 'web', 'template.txt'),
-        'utf8',
-      ),
-    ).toBe('apps/web');
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'packages', 'template.txt'), 'utf8'),
-    ).toBe('packages');
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'tooling', 'template.txt'), 'utf8'),
-    ).toBe('tooling');
-    expect(
-      fs.readFileSync(
-        path.join(workspaceDirectory, '.github', 'workflows', 'ci.yml'),
-        'utf8',
-      ),
-    ).toBe('ci');
-
-    const packageJson = JSON.parse(
-      fs.readFileSync(path.join(workspaceDirectory, 'package.json'), 'utf8'),
-    );
-    expect(packageJson.scripts).toMatchObject({
-      lint: 'base-lint',
-      'web:dev': 'source-web-dev',
-    });
-    expect(packageJson.devDependencies).toMatchObject({
-      'base-dependency': '1.0.0',
-      'template-dependency': '1.0.0',
-    });
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'pnpm-workspace.yaml'), 'utf8'),
-    ).toContain('  - apps/*');
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'pnpm-workspace.yaml'), 'utf8'),
-    ).not.toContain('apps/**');
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'pnpm-workspace.yaml'), 'utf8'),
-    ).toContain('    tsdown: ^1.0.0');
-    expect(
-      fs.readFileSync(path.join(workspaceDirectory, 'pnpm-workspace.yaml'), 'utf8'),
-    ).toContain('    template-dependency: ^1.0.0');
-    expect(fs.readFileSync(path.join(workspaceDirectory, 'pnpm-lock.yaml'), 'utf8')).toBe(
-      'lock',
-    );
-  });
-
-  it('should add every selected app to the base workspace', () => {
-    const workspaceDirectory = runSetup(
-      'library,nextjs-cloudflare,chrome-extension,expo',
-    );
-
-    expect(
-      fs.readFileSync(
-        path.join(workspaceDirectory, 'apps', 'web', 'template.txt'),
-        'utf8',
-      ),
-    ).toBe('apps/web');
-    expect(
-      fs.readFileSync(
-        path.join(workspaceDirectory, 'apps', 'chrome-extension', 'template.txt'),
-        'utf8',
-      ),
-    ).toBe('apps/chrome-extension');
-    expect(
-      fs.readFileSync(
-        path.join(workspaceDirectory, 'apps', 'expo', 'template.txt'),
-        'utf8',
-      ),
-    ).toBe('apps/expo');
-
-    const packageJson = JSON.parse(
-      fs.readFileSync(path.join(workspaceDirectory, 'package.json'), 'utf8'),
-    );
-    expect(packageJson.scripts).toMatchObject({
-      dev: 'source-dev',
-      native: 'source-native',
-      'web:dev': 'source-web-dev',
-    });
-  });
-
-  it('should fail when no workspace app is selected', () => {
-    expect(() => runSetup('')).toThrow('Select at least one workspace app.');
-  });
-});

package/workspace-generator/scaffoldfy.jsonc

@@ -1,66 +0,0 @@
-{
-  "$schema": "../node_modules/@pixpilot/scaffoldfy/schema/scaffoldfy.schema.json",
-  // "extends": ["../workspace-initializer/scaffoldfy.json"],
-  "name": "pnpm-turbo-monorepo-template-setup",
-  "description": "Generate workspace with apps and packages",
-  "prompts": [
-    {
-      "id": "workspaceApps",
-      "type": "checkbox",
-      "message": "Select the apps to include:",
-      "choices": [
-        {
-          "name": "Library",
-          "value": "library"
-        },
-        {
-          "name": "Next.js Cloudflare",
-          "value": "nextjs-cloudflare"
-        },
-        {
-          "name": "Chrome Extension",
-          "value": "chrome-extension"
-        },
-        {
-          "name": "Expo",
-          "value": "expo"
-        }
-      ]
-    }
-    // {
-    //   "id": "workspaceTools",
-    //   "type": "checkbox",
-    //   "message": "Select the packages to include:",
-    //   "choices": [
-    //     {
-    //       "name": "storybook",
-    //       "value": "storybook"
-    //     }
-    //   ]
-    // }
-    // {
-    //   "id": "nextjsVisualTest",
-    //   "type": "input",
-    //   "message": "Next.js visual-test value:",
-    //   "enabled": {
-    //     "type": "condition",
-    //     "value": "workspaceApps.includes('nextjs')"
-    //   }
-    // },
-  ],
-  "tasks": [
-    {
-      "id": "setup-workspace",
-      "name": "Set up workspace apps",
-      "description": "Clone the monorepo template and add each selected app",
-      "type": "exec-file",
-      "config": {
-        "file": "./scripts/setup-workspace.cjs",
-        "runtime": "node",
-        "parameters": {
-          "WORKSPACE_APPS": "{{workspaceApps}}"
-        }
-      }
-    }
-  ]
-}

package/workspace-generator/scripts/setup-workspace.cjs

@@ -1,411 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const { execFileSync } = require('node:child_process');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const process = require('node:process');
-
-const BASE_TEMPLATE_REPOSITORY =
-  'https://github.com/pixpilot/pnpm-turbo-monorepo-template.git';
-
-const APP_TEMPLATES = {
-  'nextjs-cloudflare': {
-    repository: 'https://github.com/ccpu/nextjs-cloudflare-monorepo-template.git',
-    sourceDirectory: 'apps/web',
-    destinationDirectory: 'apps/web',
-    rootScripts: ['web:dev', 'web:build'],
-  },
-  'chrome-extension': {
-    repository: 'https://github.com/ccpu/chrome-extension-monorepo-template.git',
-    sourceDirectory: 'apps/chrome-extension',
-    destinationDirectory: 'apps/chrome-extension',
-    rootScripts: ['dev'],
-  },
-  expo: {
-    repository: 'https://github.com/ccpu/full-stack-starter.git',
-    sourceDirectory: 'apps/expo',
-    destinationDirectory: 'apps/expo',
-    rootScripts: [
-      'native',
-      'expo:clean:install',
-      'expo:clean:run',
-      'android:dev',
-      'android:clean:dev',
-      'ios:dev',
-      'ios:clean:dev',
-    ],
-  },
-};
-
-const TEMPLATE_SOURCE_PATHS = [
-  'package.json',
-  'pnpm-workspace.yaml',
-  'packages',
-  'tooling',
-  '.github/workflows',
-];
-const JSON_INDENTATION = 2;
-const LINE_BREAK_PATTERN = /\r?\n/u;
-const TOP_LEVEL_SECTION_PATTERN = /^[^\s#][^:]*:/u;
-const INDENTED_LIST_ENTRY_PATTERN = /^ {2}- /u;
-
-function runGit(args, cwd) {
-  execFileSync('git', args, { cwd, stdio: 'inherit' });
-}
-
-function refreshLockfile(cwd) {
-  execFileSync('pnpm', ['install', '--lockfile-only', '--ignore-scripts'], {
-    cwd,
-    stdio: 'inherit',
-  });
-}
-
-function getSelectedApps() {
-  return new Set(
-    (process.env.WORKSPACE_APPS ?? '')
-      .split(',')
-      .map((app) => app.trim())
-      .filter(Boolean),
-  );
-}
-
-function ensureEmptyDirectory(directory) {
-  if (fs.readdirSync(directory).length > 0) {
-    throw new Error(`Workspace directory must be empty: ${directory}`);
-  }
-}
-
-function copyDirectoryContents(sourceDirectory, destinationDirectory) {
-  for (const entry of fs.readdirSync(sourceDirectory, { withFileTypes: true })) {
-    fs.cpSync(
-      path.join(sourceDirectory, entry.name),
-      path.join(destinationDirectory, entry.name),
-      { recursive: entry.isDirectory(), errorOnExist: true, force: false },
-    );
-  }
-}
-
-function overlayDirectoryContents(sourceDirectory, destinationDirectory) {
-  if (!fs.existsSync(sourceDirectory)) {
-    return;
-  }
-
-  fs.mkdirSync(destinationDirectory, { recursive: true });
-
-  for (const entry of fs.readdirSync(sourceDirectory, { withFileTypes: true })) {
-    fs.cpSync(
-      path.join(sourceDirectory, entry.name),
-      path.join(destinationDirectory, entry.name),
-      { recursive: entry.isDirectory(), force: true },
-    );
-  }
-}
-
-function mergeDependencySections(basePackage, templatePackage) {
-  return [
-    'dependencies',
-    'devDependencies',
-    'optionalDependencies',
-    'peerDependencies',
-  ].reduce(
-    (mergedPackage, section) =>
-      templatePackage[section]
-        ? {
-            ...mergedPackage,
-            [section]: {
-              ...templatePackage[section],
-              ...mergedPackage[section],
-            },
-          }
-        : mergedPackage,
-    basePackage,
-  );
-}
-
-function mergeRootPackageManifest(template, repositoryDirectory, workspaceDirectory) {
-  const packageJsonPath = path.join(workspaceDirectory, 'package.json');
-  const templatePackageJsonPath = path.join(repositoryDirectory, 'package.json');
-  const basePackage = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-  const templatePackage = JSON.parse(fs.readFileSync(templatePackageJsonPath, 'utf8'));
-  const packageWithDependencies = mergeDependencySections(basePackage, templatePackage);
-  const templateScripts = Object.fromEntries(
-    template.rootScripts.flatMap((scriptName) => {
-      const script = templatePackage.scripts?.[scriptName];
-
-      return script ? [[scriptName, script]] : [];
-    }),
-  );
-
-  const mergedPackage = {
-    ...packageWithDependencies,
-    scripts: {
-      ...templateScripts,
-      ...packageWithDependencies.scripts,
-    },
-  };
-
-  fs.writeFileSync(
-    packageJsonPath,
-    `${JSON.stringify(mergedPackage, null, JSON_INDENTATION)}\n`,
-  );
-}
-
-function escapeRegularExpression(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-}
-
-function normalizeYamlKey(value) {
-  return value.replace(/^['"]|['"]$/gu, '');
-}
-
-function getCatalogEntries(workspaceManifest) {
-  const catalogEntries = new Map();
-  let isInCatalogsSection = false;
-  let catalogName;
-
-  for (const line of workspaceManifest.split(LINE_BREAK_PATTERN)) {
-    if (line === 'catalogs:') {
-      isInCatalogsSection = true;
-    } else if (isInCatalogsSection && TOP_LEVEL_SECTION_PATTERN.test(line)) {
-      isInCatalogsSection = false;
-    } else if (isInCatalogsSection) {
-      const catalogMatch = line.match(/^ {2}(?<catalogName>[^:\r\n]+):[\t ]*$/u);
-      const entryMatch = line.match(/^ {4}(?<key>['"][^'"]+['"]|[^:]+):/u);
-
-      if (catalogMatch) {
-        const { catalogName: nextCatalogName } = catalogMatch.groups;
-        catalogName = nextCatalogName;
-        catalogEntries.set(catalogName, []);
-      } else if (catalogName && entryMatch) {
-        const { key } = entryMatch.groups;
-        catalogEntries.get(catalogName).push({ key, line });
-      }
-    }
-  }
-
-  return catalogEntries;
-}
-
-function getYamlListEntries(workspaceManifest, sectionName) {
-  const entries = [];
-  let isInSection = false;
-
-  for (const line of workspaceManifest.split(LINE_BREAK_PATTERN)) {
-    if (line === `${sectionName}:`) {
-      isInSection = true;
-    } else if (isInSection && TOP_LEVEL_SECTION_PATTERN.test(line)) {
-      isInSection = false;
-    } else if (isInSection && INDENTED_LIST_ENTRY_PATTERN.test(line)) {
-      entries.push(line);
-    }
-  }
-
-  return entries;
-}
-
-function mergeCatalogEntries(baseWorkspaceManifest, templateWorkspaceManifest) {
-  let mergedWorkspaceManifest = baseWorkspaceManifest;
-  const lineEnding = baseWorkspaceManifest.includes('\r\n') ? '\r\n' : '\n';
-
-  for (const [catalogName, entries] of getCatalogEntries(templateWorkspaceManifest)) {
-    const catalogHeader = new RegExp(
-      `^ {2}${escapeRegularExpression(catalogName)}:[\\t ]*(?:\\r?\\n|$)`,
-      'mu',
-    );
-
-    if (!catalogHeader.test(mergedWorkspaceManifest)) {
-      mergedWorkspaceManifest = mergedWorkspaceManifest.replace(
-        /^catalogs:[\t ]*(?:\r?\n|$)/mu,
-        (header) =>
-          `${header}  ${catalogName}:${lineEnding}${entries.map((entry) => entry.line).join(lineEnding)}${lineEnding}`,
-      );
-    } else {
-      for (const entry of entries) {
-        const entryPattern = new RegExp(
-          `^ {4}['"]?${escapeRegularExpression(normalizeYamlKey(entry.key))}['"]?:[^\\r\\n]*`,
-          'mu',
-        );
-
-        if (entryPattern.test(mergedWorkspaceManifest)) {
-          mergedWorkspaceManifest = mergedWorkspaceManifest.replace(
-            entryPattern,
-            entry.line,
-          );
-        } else {
-          const catalogMatch = catalogHeader.exec(mergedWorkspaceManifest);
-          const catalogContents = mergedWorkspaceManifest.slice(
-            catalogMatch.index + catalogMatch[0].length,
-          );
-          const nextCatalogMatch = catalogContents.match(
-            /^(?: {2})?[^\s#][^:]*:[\t ]*(?:\r?\n|$)/mu,
-          );
-          const insertionIndex = nextCatalogMatch
-            ? catalogMatch.index + catalogMatch[0].length + nextCatalogMatch.index
-            : mergedWorkspaceManifest.length;
-
-          mergedWorkspaceManifest = `${mergedWorkspaceManifest.slice(0, insertionIndex)}${entry.line}${lineEnding}${mergedWorkspaceManifest.slice(insertionIndex)}`;
-        }
-      }
-    }
-  }
-
-  return mergedWorkspaceManifest;
-}
-
-function mergeYamlListEntries(
-  baseWorkspaceManifest,
-  templateWorkspaceManifest,
-  sectionName,
-) {
-  const templateEntries = getYamlListEntries(templateWorkspaceManifest, sectionName);
-  if (templateEntries.length === 0) {
-    return baseWorkspaceManifest;
-  }
-
-  const lineEnding = baseWorkspaceManifest.includes('\r\n') ? '\r\n' : '\n';
-  const lines = baseWorkspaceManifest.split(LINE_BREAK_PATTERN);
-  const sectionIndex = lines.indexOf(`${sectionName}:`);
-
-  if (sectionIndex === -1) {
-    return `${baseWorkspaceManifest.trimEnd()}${lineEnding}${sectionName}:${lineEnding}${templateEntries.join(lineEnding)}${lineEnding}`;
-  }
-
-  let sectionEndIndex = sectionIndex + 1;
-  while (
-    sectionEndIndex < lines.length &&
-    !TOP_LEVEL_SECTION_PATTERN.test(lines[sectionEndIndex])
-  ) {
-    sectionEndIndex += 1;
-  }
-
-  const existingEntries = new Set(
-    lines
-      .slice(sectionIndex + 1, sectionEndIndex)
-      .filter((line) => INDENTED_LIST_ENTRY_PATTERN.test(line)),
-  );
-  const missingEntries = templateEntries.filter((entry) => !existingEntries.has(entry));
-
-  lines.splice(sectionEndIndex, 0, ...missingEntries);
-  return lines.join(lineEnding);
-}
-
-function mergeWorkspaceManifest(templateWorkspaceManifestPath, workspaceManifestPath) {
-  const baseWorkspaceManifest = fs.readFileSync(workspaceManifestPath, 'utf8');
-  const templateWorkspaceManifest = fs.readFileSync(
-    templateWorkspaceManifestPath,
-    'utf8',
-  );
-  const catalogMergedWorkspaceManifest = mergeCatalogEntries(
-    baseWorkspaceManifest,
-    templateWorkspaceManifest,
-  );
-  const mergedWorkspaceManifest = mergeYamlListEntries(
-    catalogMergedWorkspaceManifest,
-    templateWorkspaceManifest,
-    'packages',
-  );
-  const workspaceManifestWithTemplatePackages = mergeYamlListEntries(
-    mergedWorkspaceManifest,
-    templateWorkspaceManifest,
-    'onlyBuiltDependencies',
-  );
-
-  fs.writeFileSync(workspaceManifestPath, workspaceManifestWithTemplatePackages);
-}
-
-function addAppTemplate(template, workspaceDirectory) {
-  const destinationDirectory = path.join(
-    workspaceDirectory,
-    template.destinationDirectory,
-  );
-  fs.mkdirSync(destinationDirectory, { recursive: true });
-
-  if (fs.readdirSync(destinationDirectory).length > 0) {
-    throw new Error(`App destination already exists: ${destinationDirectory}`);
-  }
-
-  const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'scaffoldfy-app-'));
-  const repositoryDirectory = path.join(temporaryDirectory, 'repository');
-
-  try {
-    runGit(
-      [
-        'clone',
-        '--depth',
-        '1',
-        '--filter=blob:none',
-        '--sparse',
-        template.repository,
-        repositoryDirectory,
-      ],
-      workspaceDirectory,
-    );
-    runGit(
-      [
-        'sparse-checkout',
-        'set',
-        '--skip-checks',
-        template.sourceDirectory,
-        ...TEMPLATE_SOURCE_PATHS,
-      ],
-      repositoryDirectory,
-    );
-
-    const sourceDirectory = path.join(repositoryDirectory, template.sourceDirectory);
-    if (!fs.existsSync(sourceDirectory)) {
-      throw new Error(
-        `Template directory "${template.sourceDirectory}" was not found in ${template.repository}`,
-      );
-    }
-
-    copyDirectoryContents(sourceDirectory, destinationDirectory);
-    overlayDirectoryContents(
-      path.join(repositoryDirectory, 'packages'),
-      path.join(workspaceDirectory, 'packages'),
-    );
-    overlayDirectoryContents(
-      path.join(repositoryDirectory, 'tooling'),
-      path.join(workspaceDirectory, 'tooling'),
-    );
-    overlayDirectoryContents(
-      path.join(repositoryDirectory, '.github', 'workflows'),
-      path.join(workspaceDirectory, '.github', 'workflows'),
-    );
-    mergeRootPackageManifest(template, repositoryDirectory, workspaceDirectory);
-
-    const templateWorkspaceManifestPath = path.join(
-      repositoryDirectory,
-      'pnpm-workspace.yaml',
-    );
-    const workspaceManifestPath = path.join(workspaceDirectory, 'pnpm-workspace.yaml');
-
-    mergeWorkspaceManifest(templateWorkspaceManifestPath, workspaceManifestPath);
-  } finally {
-    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
-  }
-}
-
-function main() {
-  const workspaceDirectory = process.cwd();
-  const selectedApps = getSelectedApps();
-  const selectedTemplates = [...selectedApps].filter((app) => APP_TEMPLATES[app]);
-
-  if (selectedApps.size === 0) {
-    throw new Error('Select at least one workspace app.');
-  }
-
-  ensureEmptyDirectory(workspaceDirectory);
-  runGit(['clone', '--depth', '1', BASE_TEMPLATE_REPOSITORY, '.'], workspaceDirectory);
-
-  for (const app of selectedTemplates) {
-    addAppTemplate(APP_TEMPLATES[app], workspaceDirectory);
-  }
-
-  if (selectedTemplates.length > 0) {
-    refreshLockfile(workspaceDirectory);
-  }
-}
-
-main();