@pixpilot/scaffoldfy-configs 0.34.0 → 0.35.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @pixpilot/scaffoldfy-configs
 
+## 0.35.0
+
+### Minor Changes
+
+- add coding-agent-sandbox initial scaffoldfy config
+- improve workspace generator
+- d52ed00: Add the `coding-agent-sandbox` Scaffoldfy config for running Claude Code, OpenAI Codex, or GitHub Copilot CLI in Docker against a dedicated Git worktree.
+
+### Patch Changes
+
+- generate-packages-section.js: fix the issue with package section generation
+- 65b34e8: fix config release
+- 5a5d17b: fixes release
+- 022bded: test ci release
+
 ## 0.34.0
 
 ### Minor Changes

package/README.md

@@ -14,6 +14,16 @@ This package provides the following scaffoldfy templates:
 
 <!-- scaffoldfy-templates:start -->
 
+### coding-agent-sandbox
+
+Run an AI coding agent (Claude Code, OpenAI Codex, GitHub Copilot CLI) in Docker against a dedicated Git worktree
+
+Usage:
+
+```sh
+npx @pixpilot/scaffoldfy@latest --config https://unpkg.com/@pixpilot/scaffoldfy-configs@latest/coding-agent-sandbox/scaffoldfy.json
+```
+
 ### license-file
 
 Generate a LICENSE file with common open-source licenses

package/coding-agent-sandbox/scaffoldfy.json

@@ -0,0 +1,159 @@
+{
+  "$schema": "../node_modules/@pixpilot/scaffoldfy/schema/scaffoldfy.schema.json",
+  "name": "coding-agent-sandbox",
+  "description": "Run an AI coding agent (Claude Code, OpenAI Codex, GitHub Copilot CLI) in Docker against a dedicated Git worktree",
+  "prompts": [
+    {
+      "id": "sandboxAction",
+      "type": "select",
+      "message": "What would you like to do?",
+      "choices": [
+        {
+          "name": "Start a session with internet access",
+          "value": "online"
+        },
+        {
+          "name": "Start offline (installed CLI/image required; cloud agents cannot connect)",
+          "value": "offline"
+        },
+        {
+          "name": "Prune unused dependency/cache volumes (asks before deleting)",
+          "value": "prune"
+        }
+      ],
+      "default": "online",
+      "required": true
+    },
+    {
+      "id": "agent",
+      "type": "select",
+      "message": "Which coding agent should run this task?",
+      "choices": [
+        {
+          "name": "Claude Code",
+          "value": "claude"
+        },
+        {
+          "name": "OpenAI Codex",
+          "value": "codex"
+        },
+        {
+          "name": "GitHub Copilot CLI",
+          "value": "copilot"
+        }
+      ],
+      "default": "claude",
+      "required": true,
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction !== 'prune'"
+      }
+    },
+    {
+      "id": "repoPath",
+      "type": "input",
+      "message": "Main Git repository path",
+      "default": {
+        "type": "exec",
+        "value": "node -e \"const{execSync}=require('child_process');let p=process.cwd();try{p=execSync('git rev-parse --show-toplevel',{stdio:['ignore','pipe','ignore']}).toString().trim()}catch{}process.stdout.write(p)\""
+      },
+      "required": true,
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction !== 'prune'"
+      }
+    },
+    {
+      "id": "taskName",
+      "type": "input",
+      "message": "Task name (used for the ai/<agent>/<task> branch and the worktree)",
+      "required": true,
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction !== 'prune'"
+      }
+    },
+    {
+      "id": "skillsDir",
+      "type": "input",
+      "message": "Centralized skills/prompts directory",
+      "default": "Z:\\github\\ccpu\\skills",
+      "required": true,
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction === 'online'"
+      }
+    },
+    {
+      "id": "fullAccess",
+      "type": "confirm",
+      "message": "Let the agent act without approval prompts? (mounted data remains writable)",
+      "default": true,
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction !== 'prune'"
+      }
+    },
+    {
+      "id": "gitMountFlag",
+      "type": "select",
+      "message": "Allow writes to shared Git metadata (refs, hooks and config)?",
+      "choices": [
+        {
+          "name": "Allow Git commits and history in the container",
+          "value": ""
+        },
+        {
+          "name": "Withhold Git metadata (Git will not work in the container)",
+          "value": "--no-git-mount"
+        }
+      ],
+      "default": "",
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction !== 'prune'"
+      }
+    }
+  ],
+  "tasks": [
+    {
+      "id": "start-sandbox",
+      "name": "Start the coding agent sandbox",
+      "description": "Creates the agent worktree, starts Docker and hands the terminal to the agent",
+      "type": "exec",
+      "config": {
+        "command": "npx -y @pixpilot/coding-agent-sandbox@latest --agent {{agent}} --repo \"{{repoPath}}\" --task \"{{taskName}}\" --skills-dir \"{{skillsDir}}\" --full-access {{fullAccess}} {{gitMountFlag}}"
+      },
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction === 'online'"
+      }
+    },
+    {
+      "id": "start-offline-sandbox",
+      "name": "Start the offline coding agent sandbox",
+      "description": "Uses the installed CLI and cached image without package downloads or provisioning",
+      "type": "exec",
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction === 'offline'"
+      },
+      "config": {
+        "command": "coding-agent-sandbox --offline --agent {{agent}} --repo \"{{repoPath}}\" --task \"{{taskName}}\" --full-access {{fullAccess}} {{gitMountFlag}}"
+      }
+    },
+    {
+      "id": "prune-sandbox-volumes",
+      "name": "Prune unused sandbox caches",
+      "description": "Lists unused labeled dependency/cache volumes and asks before permanent deletion; preserves auth",
+      "type": "exec",
+      "enabled": {
+        "type": "condition",
+        "value": "sandboxAction === 'prune'"
+      },
+      "config": {
+        "command": "npx -y @pixpilot/coding-agent-sandbox@latest prune"
+      }
+    }
+  ]
+}

package/monorepo-generate-packages-section/generate-packages-section.js

@@ -60,6 +60,9 @@ const after = readme.substring(endIndex);
 
 const newReadme = `${before}\n\n${markdown}${after}`;
 
-fs.writeFileSync(readmePath, newReadme);
-
-console.log('README.md updated with packages.');
+if (newReadme !== readme) {
+  fs.writeFileSync(readmePath, newReadme);
+  console.log('README.md updated with packages.');
+} else {
+  console.log('README.md package section is already up to date.');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pixpilot/scaffoldfy-configs",
   "type": "module",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "author": "PixPilot <m.doaie@hotmail.com>",
   "license": "MIT",
   "repository": {
@@ -26,11 +26,11 @@
   "devDependencies": {
     "@types/node": "^22.18.11",
     "eslint": "^9.38.0",
+    "@internal/eslint-config": "0.3.0",
     "@internal/prettier-config": "0.0.1",
     "@internal/tsdown-config": "0.1.0",
     "@internal/vitest-config": "0.1.0",
-    "@pixpilot/scaffoldfy": "0.52.0",
-    "@internal/eslint-config": "0.3.0"
+    "@pixpilot/scaffoldfy": "0.53.0"
   },
   "prettier": "@internal/prettier-config",
   "publishConfig": {

package/test/workspace-generator.test.ts

@@ -27,6 +27,10 @@ function createFakeGit(testDirectory: string): string {
     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(
@@ -41,22 +45,37 @@ function createFakeGit(testDirectory: string): string {
       '  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 sourceDirectory = args.at(-1);',
-      '  const templateDirectory = path.join(process.cwd(), sourceDirectory);',
-      '  fs.mkdirSync(templateDirectory, { recursive: true });',
-      "  fs.writeFileSync(path.join(templateDirectory, 'template.txt'), sourceDirectory);",
+      "  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 === 'sparse-checkout') {",
-      '      applyGitOperation(command, process.argv.slice(2));',
+      "    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);',
@@ -71,12 +90,18 @@ function createFakeGit(testDirectory: string): string {
   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;
@@ -118,14 +143,67 @@ describe('workspace-generator setup script', () => {
     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-workspace.yaml'), 'utf8'),
+    ).toContain('    "typescript-eslint": ^2.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, 'base-template.txt'), 'utf8'),
-    ).toBe('base');
     expect(
       fs.readFileSync(
         path.join(workspaceDirectory, 'apps', 'web', 'template.txt'),
@@ -144,6 +222,15 @@ describe('workspace-generator setup script', () => {
         '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', () => {

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

@@ -15,23 +15,53 @@ const APP_TEMPLATES = {
     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 ?? '')
@@ -57,6 +87,234 @@ function copyDirectoryContents(sourceDirectory, destinationDirectory) {
   }
 }
 
+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,
@@ -84,7 +342,16 @@ function addAppTemplate(template, workspaceDirectory) {
       ],
       workspaceDirectory,
     );
-    runGit(['sparse-checkout', 'set', template.sourceDirectory], repositoryDirectory);
+    runGit(
+      [
+        'sparse-checkout',
+        'set',
+        '--skip-checks',
+        template.sourceDirectory,
+        ...TEMPLATE_SOURCE_PATHS,
+      ],
+      repositoryDirectory,
+    );
 
     const sourceDirectory = path.join(repositoryDirectory, template.sourceDirectory);
     if (!fs.existsSync(sourceDirectory)) {
@@ -94,6 +361,27 @@ function addAppTemplate(template, workspaceDirectory) {
     }
 
     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 });
   }
@@ -102,6 +390,7 @@ function addAppTemplate(template, workspaceDirectory) {
 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.');
@@ -110,11 +399,12 @@ function main() {
   ensureEmptyDirectory(workspaceDirectory);
   runGit(['clone', '--depth', '1', BASE_TEMPLATE_REPOSITORY, '.'], workspaceDirectory);
 
-  for (const app of selectedApps) {
-    const template = APP_TEMPLATES[app];
-    if (template) {
-      addAppTemplate(template, workspaceDirectory);
-    }
+  for (const app of selectedTemplates) {
+    addAppTemplate(APP_TEMPLATES[app], workspaceDirectory);
+  }
+
+  if (selectedTemplates.length > 0) {
+    refreshLockfile(workspaceDirectory);
   }
 }