diff --git a/packages/global/package.json b/packages/global/package.json
index 2fe8ace507..87e4aa673e 100644
--- a/packages/global/package.json
+++ b/packages/global/package.json
@@ -23,17 +23,20 @@
   },
   "dependencies": {
     "@voidzero-dev/vite-plus": "workspace:*",
-    "create-tsdown": "catalog:",
-    "create-vite": "catalog:",
     "cross-spawn": "catalog:",
     "oxlint": "catalog:",
     "oxlint-tsgolint": "catalog:",
-    "rolldown-vite": "workspace:*"
+    "rolldown-vite": "workspace:*",
+    "validate-npm-package-name": "catalog:"
   },
   "devDependencies": {
     "@clack/prompts": "catalog:",
+    "@std/yaml": "catalog:",
     "@types/cross-spawn": "catalog:",
+    "@types/validate-npm-package-name": "catalog:",
     "@voidzero-dev/vite-plus-tools": "workspace:",
+    "glob": "catalog:",
+    "minimatch": "catalog:",
     "mri": "catalog:",
     "picocolors": "catalog:",
     "rolldown": "workspace:*"
diff --git a/packages/global/rolldown.config.ts b/packages/global/rolldown.config.ts
index 4d629d4d43..0d3d6f3b72 100644
--- a/packages/global/rolldown.config.ts
+++ b/packages/global/rolldown.config.ts
@@ -5,12 +5,13 @@ export default defineConfig({
   external: [
     /^node:/,
     '@voidzero-dev/vite-plus/bin',
-    'create-vite',
-    'create-tsdown',
+    '@voidzero-dev/vite-plus/binding',
     // FIXME: Calling `require` for "child_process" in an environment that doesn't expose the `require` function
     'cross-spawn',
     // FIXME: will lost colors if not external
     'picocolors',
+    // FIXME: Calling `require` for "module" in an environment that doesn't expose the `require` function
+    'validate-npm-package-name',
   ],
   output: {
     format: 'esm',
diff --git a/packages/global/snap-tests/gen-check/snap.txt b/packages/global/snap-tests/gen-check/snap.txt
new file mode 100644
index 0000000000..b261ffc461
--- /dev/null
+++ b/packages/global/snap-tests/gen-check/snap.txt
@@ -0,0 +1,96 @@
+> vp gen --help # show help
+Usage: vite gen [TEMPLATE] [OPTIONS] [-- TEMPLATE_OPTIONS]
+
+Run any template (builtin, remote, or local) with automatic vite+ integration.
+
+Arguments:
+  TEMPLATE                   Template name (optional; you will be prompted if omitted)
+                            - Built-in: vite:monorepo, vite:application, vite:library, vite:generator
+                            - Remote: create-vite, @tanstack/create-start, create-next-app, create-nuxt,
+                                      github:user/repo, https://github.com/user/template-repo
+                            - Local: @company/generator-*, ./tools/create-ui-component
+
+Options (before --):
+  --directory DIR           Target directory for the generated project.
+                            Only works for built-in templates; auto-detected for remote templates.
+  --no-interactive          Run in non-interactive mode (skip prompts and use defaults)
+  --list                    List all available templates
+  -h, --help                Show this help message
+
+Template options (after --):
+  All arguments after -- are passed directly through to the template command.
+
+Examples:
+  # Interactive mode - choose template via prompt
+  vite gen
+
+  # Run any existing template (npx / pnpm dlx / yarn dlx / bunx auto-detected)
+  vite gen create-vite
+  vite gen create-next-app
+  vite gen @tanstack/create-start
+
+  # With template-specific options (after --)
+  vite gen create-vite -- --template react-ts
+  vite gen create-next-app -- --typescript --app
+
+  # Create vite+ monorepo, application, library, or generator scaffolds
+  vite gen vite:monorepo
+  vite gen vite:application
+  vite gen vite:library
+  vite gen vite:generator
+
+  # Monorepo: specify target directory
+  vite gen vite:application --directory=packages/my-app
+
+  # Combine gen command options and template options
+  vite gen vite:application --directory=apps/my-app -- --template vue-ts
+
+  # Run templates from GitHub (via degit)
+  vite gen github:user/repo
+  vite gen https://github.com/user/template-repo
+
+Note: Templates are executed via npx / pnpm dlx / yarn dlx / bunx,
+      based on the detected package manager.
+      No global installation required - always uses the latest version.
+
+Aliases: g, generate, new
+
+
+> vp gen --list # list templates
+
+📦 Available Templates
+
+Vite+ Built-in Templates:
+  • vite:monorepo                 - Create a new monorepo
+  • vite:application              - Create a new application
+  • vite:library                  - Create a new library
+  • vite:generator                - Scaffold a new code generator
+
+Popular Remote Templates:
+  • create-vite                   - Official Vite templates
+  • @tanstack/create-start        - TanStack applications
+  • create-next-app               - Next.js application
+  • create-nuxt                   - Nuxt application
+  • create-typescript-app         - TypeScript application
+  • create-react-router           - React Router application
+  • create-vue                    - Vue application
+
+Run vite gen for interactive mode
+Run vite gen <template> to use any template
+Run vite gen <template> -- <options> to pass options to the template
+
+✨ Tip: You can use ANY npm template with vite gen!
+
+
+[1]> vp gen --no-interactive # run in non-interactive mode without template name will show error
+
+Template name is required when running in non-interactive mode
+
+Usage: vite gen [TEMPLATE] [OPTIONS] [-- TEMPLATE_OPTIONS]
+
+Example: 
+  # Create a new application in non-interactive mode with a custom target directory
+  vite gen vite:application --no-interactive --directory=apps/my-app
+
+Use `vite gen --list` to list all available templates, or run `vite gen --help` for more information.
+
diff --git a/packages/global/snap-tests/gen-check/steps.json b/packages/global/snap-tests/gen-check/steps.json
new file mode 100644
index 0000000000..46fba90809
--- /dev/null
+++ b/packages/global/snap-tests/gen-check/steps.json
@@ -0,0 +1,7 @@
+{
+  "commands": [
+    "vp gen --help # show help",
+    "vp gen --list # list templates",
+    "vp gen --no-interactive # run in non-interactive mode without template name will show error"
+  ]
+}
diff --git a/packages/global/snap-tests/gen-create-tsdown-with-scope-name/snap.txt b/packages/global/snap-tests/gen-create-tsdown-with-scope-name/snap.txt
new file mode 100644
index 0000000000..383921ab0c
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-tsdown-with-scope-name/snap.txt
@@ -0,0 +1,7 @@
+> vp gen vite:library --no-interactive --directory @my-scope/my-library # create vite library with scope name
+> ls my-library/package.json # check package.json
+my-library/package.json
+
+> cat my-library/.npmrc # check .npmrc
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+@voidzero-dev:registry=https://npm.pkg.github.com/
diff --git a/packages/global/snap-tests/gen-create-tsdown-with-scope-name/steps.json b/packages/global/snap-tests/gen-create-tsdown-with-scope-name/steps.json
new file mode 100644
index 0000000000..0dcf4dd3b3
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-tsdown-with-scope-name/steps.json
@@ -0,0 +1,13 @@
+{
+  "env": {
+    "VITE_DISABLE_AUTO_INSTALL": "1"
+  },
+  "commands": [
+    {
+      "command": "vp gen vite:library --no-interactive --directory @my-scope/my-library # create vite library with scope name",
+      "ignoreOutput": true
+    },
+    "ls my-library/package.json # check package.json",
+    "cat my-library/.npmrc # check .npmrc"
+  ]
+}
diff --git a/packages/global/snap-tests/gen-create-tsdown/snap.txt b/packages/global/snap-tests/gen-create-tsdown/snap.txt
new file mode 100644
index 0000000000..1827c6fba0
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-tsdown/snap.txt
@@ -0,0 +1,11 @@
+> vp gen vite:library --no-interactive # create vite library with default values
+> ls vite-plus-library/package.json # check package.json
+vite-plus-library/package.json
+
+> cat vite-plus-library/.npmrc # check .npmrc
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+@voidzero-dev:registry=https://npm.pkg.github.com/
+
+> vp gen vite:library --no-interactive --directory my-vue -- --template vue # create vite library with custom template
+> ls my-vue/package.json # check package.json
+my-vue/package.json
diff --git a/packages/global/snap-tests/gen-create-tsdown/steps.json b/packages/global/snap-tests/gen-create-tsdown/steps.json
new file mode 100644
index 0000000000..1cecba41cd
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-tsdown/steps.json
@@ -0,0 +1,18 @@
+{
+  "env": {
+    "VITE_DISABLE_AUTO_INSTALL": "1"
+  },
+  "commands": [
+    {
+      "command": "vp gen vite:library --no-interactive # create vite library with default values",
+      "ignoreOutput": true
+    },
+    "ls vite-plus-library/package.json # check package.json",
+    "cat vite-plus-library/.npmrc # check .npmrc",
+    {
+      "command": "vp gen vite:library --no-interactive --directory my-vue -- --template vue # create vite library with custom template",
+      "ignoreOutput": true
+    },
+    "ls my-vue/package.json # check package.json"
+  ]
+}
diff --git a/packages/global/snap-tests/gen-create-vite-with-scope-name/snap.txt b/packages/global/snap-tests/gen-create-vite-with-scope-name/snap.txt
new file mode 100644
index 0000000000..1cc361e4a9
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-vite-with-scope-name/snap.txt
@@ -0,0 +1,7 @@
+> vp gen vite:application --no-interactive --directory @my-scope/my-vite-app -- --template vanilla-ts # create vite app with vanilla-ts template with scope name
+> ls my-vite-app/package.json # check package.json
+my-vite-app/package.json
+
+> cat my-vite-app/.npmrc # check .npmrc
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+@voidzero-dev:registry=https://npm.pkg.github.com/
diff --git a/packages/global/snap-tests/gen-create-vite-with-scope-name/steps.json b/packages/global/snap-tests/gen-create-vite-with-scope-name/steps.json
new file mode 100644
index 0000000000..cbf1bda3be
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-vite-with-scope-name/steps.json
@@ -0,0 +1,13 @@
+{
+  "env": {
+    "VITE_DISABLE_AUTO_INSTALL": "1"
+  },
+  "commands": [
+    {
+      "command": "vp gen vite:application --no-interactive --directory @my-scope/my-vite-app -- --template vanilla-ts # create vite app with vanilla-ts template with scope name",
+      "ignoreOutput": true
+    },
+    "ls my-vite-app/package.json # check package.json",
+    "cat my-vite-app/.npmrc # check .npmrc"
+  ]
+}
diff --git a/packages/global/snap-tests/gen-create-vite/snap.txt b/packages/global/snap-tests/gen-create-vite/snap.txt
new file mode 100644
index 0000000000..0b34ecd334
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-vite/snap.txt
@@ -0,0 +1,11 @@
+> vp gen vite:application --no-interactive # create vite app with default values
+> ls vite-plus-application/package.json # check package.json
+vite-plus-application/package.json
+
+> cat vite-plus-application/.npmrc # check .npmrc
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+@voidzero-dev:registry=https://npm.pkg.github.com/
+
+> vp gen vite:application --no-interactive --directory my-react-ts -- --template react-ts # create vite app with react-ts template
+> ls my-react-ts/package.json # check package.json
+my-react-ts/package.json
diff --git a/packages/global/snap-tests/gen-create-vite/steps.json b/packages/global/snap-tests/gen-create-vite/steps.json
new file mode 100644
index 0000000000..9365c56345
--- /dev/null
+++ b/packages/global/snap-tests/gen-create-vite/steps.json
@@ -0,0 +1,18 @@
+{
+  "env": {
+    "VITE_DISABLE_AUTO_INSTALL": "1"
+  },
+  "commands": [
+    {
+      "command": "vp gen vite:application --no-interactive # create vite app with default values",
+      "ignoreOutput": true
+    },
+    "ls vite-plus-application/package.json # check package.json",
+    "cat vite-plus-application/.npmrc # check .npmrc",
+    {
+      "command": "vp gen vite:application --no-interactive --directory my-react-ts -- --template react-ts # create vite app with react-ts template",
+      "ignoreOutput": true
+    },
+    "ls my-react-ts/package.json # check package.json"
+  ]
+}
diff --git a/packages/global/snap-tests/gen-vite-monorepo/snap.txt b/packages/global/snap-tests/gen-vite-monorepo/snap.txt
new file mode 100644
index 0000000000..3c8dea5b59
--- /dev/null
+++ b/packages/global/snap-tests/gen-vite-monorepo/snap.txt
@@ -0,0 +1,153 @@
+> vp gen vite:monorepo --no-interactive # create monorepo with default values
+> ls vite-plus-monorepo # check files created
+README.md
+apps
+package.json
+packages
+pnpm-workspace.yaml
+tsconfig.json
+vite.config.ts
+
+> cat vite-plus-monorepo/package.json # check package.json
+{
+  "name": "vite-plus-monorepo",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "ready": "vite fmt && vite lint --type-aware && vite run test -r && vite run build -r",
+    "dev": "vite run website#dev"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "devDependencies": {
+    "vite-plus": "catalog:"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "catalog:",
+      "vitest": "catalog:"
+    },
+    "peerDependencyRules": {
+      "allowAny": [
+        "vite"
+      ]
+    }
+  },
+  "packageManager": "pnpm@<semver>"
+}
+
+> cat vite-plus-monorepo/pnpm-workspace.yaml # check workspace config
+packages:
+  - apps/*
+  - packages/*
+  - tools/*
+
+catalog:
+  '@types/node': ^24
+  vite-plus: npm:@voidzero-dev/vite-plus@latest
+  vite: npm:@voidzero-dev/vite-plus@latest
+  vitest: npm:@voidzero-dev/vite-plus@latest
+  typescript: ^5
+
+catalogMode: prefer
+
+> cat vite-plus-monorepo/.npmrc # check .npmrc
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+@voidzero-dev:registry=https://npm.pkg.github.com/
+
+> test -d vite-plus-monorepo/.git && echo 'Git initialized' || echo 'No git' # check git init
+Git initialized
+
+> ls vite-plus-monorepo/apps # check apps directory created
+website
+
+> ls vite-plus-monorepo/apps/website/package.json # check website package.json
+vite-plus-monorepo/apps/website/package.json
+
+> cd vite-plus-monorepo && vp gen --no-interactive vite:application # create application in non-interactive mode
+> ls vite-plus-monorepo/apps # check apps directory created
+vite-plus-application
+website
+
+> ls vite-plus-monorepo/apps/vite-plus-application/package.json # check vite-plus-application package.json
+vite-plus-monorepo/apps/vite-plus-application/package.json
+
+> cd vite-plus-monorepo && vp gen --no-interactive vite:library # create library in non-interactive mode
+> ls vite-plus-monorepo/packages/vite-plus-library/package.json # check vite-plus-library package.json
+vite-plus-monorepo/packages/vite-plus-library/package.json
+
+> cd vite-plus-monorepo && vp gen --no-interactive vite:generator # create generator in non-interactive mode
+> ls vite-plus-monorepo/tools # check tools directory created
+vite-plus-generator
+
+> cat vite-plus-monorepo/tools/vite-plus-generator/package.json # check vite-plus-generator package.json
+{
+  "name": "vite-plus-generator",
+  "version": "0.0.0",
+  "type": "module",
+  "private": true,
+  "description": "A starter for creating a Vite+ code generator.",
+  "bin": "./bin/index.ts",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "keywords": [
+    "bingo-template",
+    "vite-plus-generator"
+  ],
+  "scripts": {
+    "test": "vite test",
+    "dev": "node bin/index.ts"
+  },
+  "dependencies": {
+    "bingo": "^0.7.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:",
+    "vite-plus": "catalog:"
+  }
+}
+
+> vp gen vite:monorepo --no-interactive --directory my-vite-plus-monorepo # create monorepo with custom directory
+> ls my-vite-plus-monorepo # check files created
+README.md
+apps
+package.json
+packages
+pnpm-workspace.yaml
+tsconfig.json
+vite.config.ts
+
+> cat my-vite-plus-monorepo/package.json # check package.json
+{
+  "name": "my-vite-plus-monorepo",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "ready": "vite fmt && vite lint --type-aware && vite run test -r && vite run build -r",
+    "dev": "vite run website#dev"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "devDependencies": {
+    "vite-plus": "catalog:"
+  },
+  "pnpm": {
+    "overrides": {
+      "vite": "catalog:",
+      "vitest": "catalog:"
+    },
+    "peerDependencyRules": {
+      "allowAny": [
+        "vite"
+      ]
+    }
+  },
+  "packageManager": "pnpm@<semver>"
+}
diff --git a/packages/global/snap-tests/gen-vite-monorepo/steps.json b/packages/global/snap-tests/gen-vite-monorepo/steps.json
new file mode 100644
index 0000000000..37840f556c
--- /dev/null
+++ b/packages/global/snap-tests/gen-vite-monorepo/steps.json
@@ -0,0 +1,38 @@
+{
+  "commands": [
+    {
+      "command": "vp gen vite:monorepo --no-interactive # create monorepo with default values",
+      "ignoreOutput": true
+    },
+    "ls vite-plus-monorepo # check files created",
+    "cat vite-plus-monorepo/package.json # check package.json",
+    "cat vite-plus-monorepo/pnpm-workspace.yaml # check workspace config",
+    "cat vite-plus-monorepo/.npmrc # check .npmrc",
+    "test -d vite-plus-monorepo/.git && echo 'Git initialized' || echo 'No git' # check git init",
+    "ls vite-plus-monorepo/apps # check apps directory created",
+    "ls vite-plus-monorepo/apps/website/package.json # check website package.json",
+    {
+      "command": "cd vite-plus-monorepo && vp gen --no-interactive vite:application # create application in non-interactive mode",
+      "ignoreOutput": true
+    },
+    "ls vite-plus-monorepo/apps # check apps directory created",
+    "ls vite-plus-monorepo/apps/vite-plus-application/package.json # check vite-plus-application package.json",
+    {
+      "command": "cd vite-plus-monorepo && vp gen --no-interactive vite:library # create library in non-interactive mode",
+      "ignoreOutput": true
+    },
+    "ls vite-plus-monorepo/packages/vite-plus-library/package.json # check vite-plus-library package.json",
+    {
+      "command": "cd vite-plus-monorepo && vp gen --no-interactive vite:generator # create generator in non-interactive mode",
+      "ignoreOutput": true
+    },
+    "ls vite-plus-monorepo/tools # check tools directory created",
+    "cat vite-plus-monorepo/tools/vite-plus-generator/package.json # check vite-plus-generator package.json",
+    {
+      "command": "vp gen vite:monorepo --no-interactive --directory my-vite-plus-monorepo # create monorepo with custom directory",
+      "ignoreOutput": true
+    },
+    "ls my-vite-plus-monorepo # check files created",
+    "cat my-vite-plus-monorepo/package.json # check package.json"
+  ]
+}
diff --git a/packages/global/snap-tests/new-monorepo/snap.txt b/packages/global/snap-tests/new-monorepo/snap.txt
deleted file mode 100644
index 1d56674d30..0000000000
--- a/packages/global/snap-tests/new-monorepo/snap.txt
+++ /dev/null
@@ -1,272 +0,0 @@
-> vp new -h # show help
-Usage: vite new [OPTION]... [DIRECTORY]
-
-Create a new Vite+ project in TypeScript.
-With no arguments, start the CLI in interactive mode.
-
-Options:
-  --monorepo                 create a monorepo project
-  --app                      add an app to existing monorepo, e.g.: vite new --app apps/website
-  --lib                      add a library to existing monorepo, e.g.: vite new --lib packages/utils
-  -t, --template NAME        use a specific template
-  --pm NAME                  use a specific package manager, e.g.: vite new --pm pnpm
-  --git                      init git repository
-  --overwrite                overwrite existing files
-
-Available templates:
-vanilla-ts     vanilla
-vue-ts         vue
-react-ts       react
-react-swc-ts   react-swc
-preact-ts      preact
-lit-ts         lit
-svelte-ts      svelte
-solid-ts       solid
-qwik-ts        qwik
-
-> vp new --template vanilla-ts --monorepo --pm pnpm --git false --overwrite hello-vite-plus # create monorepo
-
- ██╗   ██╗ ██╗ ████████╗ ███████╗
- ██║   ██║ ██║ ╚══██╔══╝ ██╔════╝   ██╗
- ██║   ██║ ██║    ██║    █████╗   ██████╗
- ╚██╗ ██╔╝ ██║    ██║    ██╔══╝    ╚██╔═╝
-  ╚████╔╝  ██║    ██║    ███████╗   ╚═╝
-   ╚═══╝   ╚═╝    ╚═╝    ╚══════╝
-
-┌  Vite+ - The Unified Toolchain for the Web
-│
-◇  Scaffolding project with vanilla-ts in hello-vite-plus/apps/website...
-│
-└  Done. Now run:
-
-   cd hello-vite-plus
-   vite run ready
-   vite run dev
-
-   To add new packages to your monorepo:
-
-   vite new --app apps/my-app
-   vite new --lib packages/my-lib
-
-
-> cd hello-vite-plus && ls -a . # check files
-.
-..
-.gitignore
-.npmrc
-README.md
-apps
-package.json
-pnpm-workspace.yaml
-tsconfig.json
-vite.config.ts
-
-> cd hello-vite-plus && cat package.json # check package.json
-{
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "ready": "vite fmt && vite run lint && vite run test:all && vite run build:all",
-    "dev": "vite run website#dev",
-    "lint": "vite lint --type-aware",
-    "test:all": "vite run -r test",
-    "build:all": "vite run -r build"
-  },
-  "devDependencies": {
-    "vite": "catalog:"
-  },
-  "pnpm": {
-    "overrides": {
-      "vite": "catalog:",
-      "tsdown": "catalog:"
-    },
-    "peerDependencyRules": {
-      "allowAny": [
-        "vite"
-      ]
-    }
-  },
-  "packageManager": "pnpm@<semver>"
-}
-
-> cd hello-vite-plus && vp new --app --template vanilla-ts apps/my-app # add app
-
- ██╗   ██╗ ██╗ ████████╗ ███████╗
- ██║   ██║ ██║ ╚══██╔══╝ ██╔════╝   ██╗
- ██║   ██║ ██║    ██║    █████╗   ██████╗
- ╚██╗ ██╔╝ ██║    ██║    ██╔══╝    ╚██╔═╝
-  ╚████╔╝  ██║    ██║    ███████╗   ╚═╝
-   ╚═══╝   ╚═╝    ╚═╝    ╚══════╝
-
-┌  Vite+ - The Unified Toolchain for the Web
-│
-◇  Scaffolding project with vanilla-ts in apps/my-app...
-│
-└  Done. Now run:
-
-   cd apps/my-app
-   vite run ready
-   vite run dev
-
-
-> cd hello-vite-plus && ls -a apps
-.
-..
-my-app
-website
-
-> cd hello-vite-plus && vp new --lib packages/my-lib --template react # add lib
-
- ██╗   ██╗ ██╗ ████████╗ ███████╗
- ██║   ██║ ██║ ╚══██╔══╝ ██╔════╝   ██╗
- ██║   ██║ ██║    ██║    █████╗   ██████╗
- ╚██╗ ██╔╝ ██║    ██║    ██╔══╝    ╚██╔═╝
-  ╚████╔╝  ██║    ██║    ███████╗   ╚═╝
-   ╚═══╝   ╚═╝    ╚═╝    ╚══════╝
-
-┌  Vite+ - The Unified Toolchain for the Web
-│
-◇  Scaffolding library with react in packages/my-lib...
-[?25l│
-◒  $ create-tsdown --overwrite --template react --name packages/my-lib...
-◇  $ create-tsdown --overwrite --template react --name packages/my-lib succeeded
-[?25h│
-└  Done. Now run:
-
-   cd packages/my-lib
-   vite run ready
-   vite run dev
-
-
-> cd hello-vite-plus && ls -a packages && cat packages/my-lib/package.json # check package.json
-.
-..
-my-lib
-{
-  "name": "my-lib",
-  "version": "0.0.0",
-  "description": "A starter for creating a React component library.",
-  "type": "module",
-  "license": "MIT",
-  "homepage": "https://github.com/author/library#readme",
-  "bugs": {
-    "url": "https://github.com/author/library/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/author/library.git"
-  },
-  "author": "Author Name <author.name@mail.com>",
-  "files": [
-    "dist"
-  ],
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js",
-    "./package.json": "./package.json"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "vite lib",
-    "dev": "vite lib --watch",
-    "playground": "vite --config playground/vite.config.ts",
-    "test": "vite test",
-    "typecheck": "tsc --noEmit",
-    "release": "bumpp && pnpm publish",
-    "prepublishOnly": "pnpm run build",
-    "ready": "vite fmt && vite lint --type-aware && vite run build && vite test --passWithNoTests"
-  },
-  "devDependencies": {
-    "@testing-library/jest-dom": "^6.6.3",
-    "@testing-library/react": "^16.3.0",
-    "@types/node": "catalog:",
-    "@types/react": "^19.1.3",
-    "@types/react-dom": "^19.1.4",
-    "@vitejs/plugin-react": "^4.4.1",
-    "bumpp": "catalog:",
-    "happy-dom": "catalog:",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
-    "tsdown": "catalog:",
-    "typescript": "catalog:",
-    "vite": "catalog:",
-    "vitest": "catalog:"
-  }
-}
-
-> cd hello-vite-plus && vp new --lib tools/my-tool --template default # add lib new not exists tools directory
-
- ██╗   ██╗ ██╗ ████████╗ ███████╗
- ██║   ██║ ██║ ╚══██╔══╝ ██╔════╝   ██╗
- ██║   ██║ ██║    ██║    █████╗   ██████╗
- ╚██╗ ██╔╝ ██║    ██║    ██╔══╝    ╚██╔═╝
-  ╚████╔╝  ██║    ██║    ███████╗   ╚═╝
-   ╚═══╝   ╚═╝    ╚═╝    ╚══════╝
-
-┌  Vite+ - The Unified Toolchain for the Web
-│
-◇  Scaffolding library with default in tools/my-tool...
-[?25l│
-◒  $ create-tsdown --overwrite --template default --name tools/my-tool...
-◇  $ create-tsdown --overwrite --template default --name tools/my-tool succeeded
-[?25h│
-└  Done. Now run:
-
-   cd tools/my-tool
-   vite run ready
-   vite run dev
-
-
-> cd hello-vite-plus && ls -a tools && cat tools/my-tool/package.json # check package.json
-.
-..
-my-tool
-{
-  "name": "my-tool",
-  "version": "0.0.0",
-  "description": "A starter for creating a TypeScript package.",
-  "type": "module",
-  "license": "MIT",
-  "homepage": "https://github.com/author/library#readme",
-  "bugs": {
-    "url": "https://github.com/author/library/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/author/library.git"
-  },
-  "author": "Author Name <author.name@mail.com>",
-  "files": [
-    "dist"
-  ],
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js",
-    "./package.json": "./package.json"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "build": "vite lib",
-    "dev": "vite lib --watch",
-    "test": "vite test",
-    "typecheck": "tsc --noEmit",
-    "release": "bumpp && npm publish",
-    "ready": "vite fmt && vite lint --type-aware && vite run build && vite test --passWithNoTests"
-  },
-  "devDependencies": {
-    "@types/node": "catalog:",
-    "bumpp": "catalog:",
-    "tsdown": "catalog:",
-    "typescript": "catalog:",
-    "vitest": "catalog:"
-  }
-}
diff --git a/packages/global/snap-tests/new-monorepo/steps.json b/packages/global/snap-tests/new-monorepo/steps.json
deleted file mode 100644
index 6762910485..0000000000
--- a/packages/global/snap-tests/new-monorepo/steps.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "ignoredPlatforms": ["win32"],
-  "commands": [
-    "vp new -h # show help",
-    "vp new --template vanilla-ts --monorepo --pm pnpm --git false --overwrite hello-vite-plus # create monorepo",
-    "cd hello-vite-plus && ls -a . # check files",
-    "cd hello-vite-plus && cat package.json # check package.json",
-    "cd hello-vite-plus && vp new --app --template vanilla-ts apps/my-app # add app",
-    "cd hello-vite-plus && ls -a apps",
-    "cd hello-vite-plus && vp new --lib packages/my-lib --template react # add lib",
-    "cd hello-vite-plus && ls -a packages && cat packages/my-lib/package.json # check package.json",
-    "cd hello-vite-plus && vp new --lib tools/my-tool --template default # add lib new not exists tools directory",
-    "cd hello-vite-plus && ls -a tools && cat tools/my-tool/package.json # check package.json"
-  ]
-}
diff --git a/packages/global/snap-tests/new-singlerepo/snap.txt b/packages/global/snap-tests/new-singlerepo/snap.txt
deleted file mode 100644
index 5f15afbeeb..0000000000
--- a/packages/global/snap-tests/new-singlerepo/snap.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-> vp new --template vanilla-ts --monorepo false --pm pnpm --git false --overwrite hello-vite-plus # create singlerepo
-
- ██╗   ██╗ ██╗ ████████╗ ███████╗
- ██║   ██║ ██║ ╚══██╔══╝ ██╔════╝   ██╗
- ██║   ██║ ██║    ██║    █████╗   ██████╗
- ╚██╗ ██╔╝ ██║    ██║    ██╔══╝    ╚██╔═╝
-  ╚████╔╝  ██║    ██║    ███████╗   ╚═╝
-   ╚═══╝   ╚═╝    ╚═╝    ╚══════╝
-
-┌  Vite+ - The Unified Toolchain for the Web
-│
-◇  Scaffolding project with vanilla-ts in hello-vite-plus...
-│
-└  Done. Now run:
-
-   cd hello-vite-plus
-   vite run ready
-   vite run dev
-
-
-> cd hello-vite-plus && ls -a . # check files
-.
-..
-.gitignore
-.npmrc
-index.html
-package.json
-public
-src
-tsconfig.json
-
-> cd hello-vite-plus && cat package.json # check package.json
-{
-  "name": "hello-vite-plus",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite dev",
-    "build": "tsc && vite build",
-    "preview": "vite preview",
-    "ready": "vite fmt && vite lint --type-aware && vite run build && vite test --passWithNoTests"
-  },
-  "devDependencies": {
-    "typescript": "~5.9.3",
-    "vite": "npm:@voidzero-dev/vite-plus@latest"
-  },
-  "pnpm": {
-    "overrides": {
-      "vite": "npm:@voidzero-dev/vite-plus@latest"
-    },
-    "peerDependencyRules": {
-      "allowAny": [
-        "vite"
-      ]
-    }
-  },
-  "packageManager": "pnpm@<semver>"
-}
diff --git a/packages/global/snap-tests/new-singlerepo/steps.json b/packages/global/snap-tests/new-singlerepo/steps.json
deleted file mode 100644
index 6eced55474..0000000000
--- a/packages/global/snap-tests/new-singlerepo/steps.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "ignoredPlatforms": ["win32"],
-  "commands": [
-    "vp new --template vanilla-ts --monorepo false --pm pnpm --git false --overwrite hello-vite-plus # create singlerepo",
-    "cd hello-vite-plus && ls -a . # check files",
-    "cd hello-vite-plus && cat package.json # check package.json"
-  ]
-}
diff --git a/packages/global/src/gen.ts b/packages/global/src/gen.ts
new file mode 100644
index 0000000000..a34c7f916b
--- /dev/null
+++ b/packages/global/src/gen.ts
@@ -0,0 +1,607 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import * as prompts from '@clack/prompts';
+import { downloadPackageManager } from '@voidzero-dev/vite-plus/binding';
+import mri from 'mri';
+import colors from 'picocolors';
+
+import { runCommandSilently } from './gen/command.ts';
+import { discoverTemplate } from './gen/discovery.ts';
+import { performAutoMigration } from './gen/migration.ts';
+import { cancelAndExit, checkProjectDirExists, promptPackageNameAndTargetDir } from './gen/prompts.ts';
+import { executeBuiltinTemplate, executeMonorepoTemplate, executeRemoteTemplate } from './gen/templates/index.ts';
+import {
+  BuiltinTemplate,
+  DependencyType,
+  type ExecutionResult,
+  PackageManager,
+  TemplateType,
+  type ViteOptions,
+  type WorkspaceInfo,
+} from './gen/types.ts';
+import { formatTargetDir, setPackageManager, templatesDir } from './gen/utils.ts';
+import { detectWorkspace, updatePackageJsonWithDeps, updateWorkspaceConfig } from './gen/workspace.ts';
+
+const { blue, cyan, green, gray, blueBright } = colors;
+
+// prettier-ignore
+const helpMessage = `\
+Usage: vite gen [TEMPLATE] [OPTIONS] [-- TEMPLATE_OPTIONS]
+
+Run any template (builtin, remote, or local) with automatic vite+ integration.
+
+Arguments:
+  TEMPLATE                   Template name (optional; you will be prompted if omitted)
+                            - Built-in: vite:monorepo, vite:application, vite:library, vite:generator
+                            - Remote: create-vite, @tanstack/create-start, create-next-app, create-nuxt,
+                                      github:user/repo, https://github.com/user/template-repo
+                            - Local: @company/generator-*, ./tools/create-ui-component
+
+Options (before --):
+  --directory DIR           Target directory for the generated project.
+                            Only works for built-in templates; auto-detected for remote templates.
+  --no-interactive          Run in non-interactive mode (skip prompts and use defaults)
+  --list                    List all available templates
+  -h, --help                Show this help message
+
+Template options (after --):
+  All arguments after -- are passed directly through to the template command.
+
+Examples:
+  ${gray('# Interactive mode - choose template via prompt')}
+  vite gen
+
+  ${gray('# Run any existing template (npx / pnpm dlx / yarn dlx / bunx auto-detected)')}
+  vite gen create-vite
+  vite gen create-next-app
+  vite gen @tanstack/create-start
+
+  ${gray('# With template-specific options (after --)')}
+  vite gen create-vite -- --template react-ts
+  vite gen create-next-app -- --typescript --app
+
+  ${gray('# Create vite+ monorepo, application, library, or generator scaffolds')}
+  vite gen vite:monorepo
+  vite gen vite:application
+  vite gen vite:library
+  vite gen vite:generator
+
+  ${gray('# Monorepo: specify target directory')}
+  vite gen vite:application --directory=packages/my-app
+
+  ${gray('# Combine gen command options and template options')}
+  vite gen vite:application --directory=apps/my-app -- --template vue-ts
+
+  ${gray('# Run templates from GitHub (via degit)')}
+  vite gen github:user/repo
+  vite gen https://github.com/user/template-repo
+
+Note: Templates are executed via npx / pnpm dlx / yarn dlx / bunx,
+      based on the detected package manager.
+      No global installation required - always uses the latest version.
+
+Aliases: ${gray('g, generate, new')}
+`;
+
+// Parse CLI arguments: split on '--' separator
+function parseArgs() {
+  const args = process.argv.slice(3); // Skip 'node', 'vite', 'gen'
+  const separatorIndex = args.indexOf('--');
+
+  // Arguments before -- are vite+ options
+  const viteArgs = separatorIndex >= 0 ? args.slice(0, separatorIndex) : args;
+
+  // Arguments after -- are template options
+  const templateArgs = separatorIndex >= 0 ? args.slice(separatorIndex + 1) : [];
+
+  const parsed = mri<{
+    directory?: string;
+    interactive?: boolean;
+    list?: boolean;
+    help?: boolean;
+  }>(viteArgs, {
+    alias: { h: 'help' },
+    boolean: ['help', 'list', 'all', 'interactive'],
+    string: ['directory'],
+    default: { interactive: process.stdin.isTTY },
+  });
+
+  const templateName = parsed._[0] as string | undefined;
+
+  return {
+    templateName,
+    viteOptions: {
+      directory: parsed.directory,
+      interactive: parsed.interactive,
+      list: parsed.list || false,
+      help: parsed.help || false,
+    } as ViteOptions,
+    templateArgs,
+  };
+}
+
+async function main() {
+  const { templateName, viteOptions, templateArgs } = parseArgs();
+
+  // #region Handle help flag
+  if (viteOptions.help) {
+    console.log(helpMessage);
+    return;
+  }
+  // #endregion
+
+  // #region Handle list flag
+  if (viteOptions.list) {
+    showAvailableTemplates();
+    return;
+  }
+  // #endregion
+
+  // #region Handle required arguments
+  if (!templateName && !viteOptions.interactive) {
+    console.error(`
+Template name is required when running in non-interactive mode
+
+Usage: vite gen [TEMPLATE] [OPTIONS] [-- TEMPLATE_OPTIONS]
+
+Example: 
+  ${gray('# Create a new application in non-interactive mode with a custom target directory')}
+  vite gen vite:application --no-interactive --directory=apps/my-app
+
+Use \`vite gen --list\` to list all available templates, or run \`vite gen --help\` for more information.
+`);
+    process.exit(1);
+  }
+  // #endregion
+
+  // #region Prepare Stage
+  if (viteOptions.interactive) {
+    const logo = fs.readFileSync(path.join(templatesDir, 'vite-plus-logo.txt'), 'utf-8');
+    console.log(blueBright(logo));
+  }
+  prompts.intro(`${blueBright('Vite+')} - The Unified Toolchain for the Web`);
+
+  // check --directory option is valid
+  let targetDir = '';
+  let packageName = '';
+  if (viteOptions.directory) {
+    const formatted = formatTargetDir(viteOptions.directory);
+    if (formatted.error) {
+      prompts.log.error(formatted.error);
+      cancelAndExit('The --directory option is invalid', 1);
+    }
+    targetDir = formatted.directory;
+    packageName = formatted.packageName;
+  }
+
+  const workspaceInfoOptional = await detectWorkspace(process.cwd());
+  const isMonorepo = workspaceInfoOptional.isMonorepo;
+
+  // Interactive mode: prompt for template if not provided
+  let selectedTemplateName = templateName as string;
+  let selectedTemplateArgs = [...templateArgs];
+
+  if (!selectedTemplateName) {
+    const templates: { label: string; value: string; hint: string }[] = [];
+    if (isMonorepo) {
+      // find local templates in the monorepo
+      for (const pkg of workspaceInfoOptional.packages) {
+        if (pkg.isTemplatePackage) {
+          templates.push({
+            label: pkg.name,
+            value: pkg.name,
+            hint: pkg.description ?? pkg.path,
+          });
+        }
+      }
+    } else {
+      templates.push({
+        label: 'Vite+ Monorepo',
+        value: BuiltinTemplate.monorepo,
+        hint: 'Create a new vite+ monorepo project',
+      });
+    }
+    const template = await prompts.select({
+      message: 'Which template would you like to use?',
+      options: [
+        ...templates,
+        {
+          label: 'Vite+ Application',
+          value: BuiltinTemplate.application,
+          hint: 'Create vite applications',
+        },
+        {
+          label: 'Vite+ Library',
+          value: BuiltinTemplate.library,
+          hint: 'Create vite libraries',
+        },
+        // TODO: only support builtin generator template in monorepo for now
+        ...(isMonorepo
+          ? [{
+            label: 'Vite+ Generator',
+            value: BuiltinTemplate.generator,
+            hint: 'Scaffold a new code generator',
+          }]
+          : []),
+        {
+          label: 'TanStack Start',
+          value: '@tanstack/create-start@latest',
+          hint: 'Create TanStack applications and libraries',
+        },
+        {
+          label: 'Others',
+          value: 'other',
+          hint: 'Enter a custom template package name',
+        },
+      ],
+    });
+
+    if (prompts.isCancel(template)) {
+      cancelAndExit();
+    }
+
+    // Handle custom template input
+    if (template === 'other') {
+      const customTemplate = await prompts.text({
+        message: 'Enter the template package name:',
+        placeholder: 'e.g., create-next-app, create-nuxt',
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return 'Template name is required';
+          }
+        },
+      });
+
+      if (prompts.isCancel(customTemplate)) {
+        cancelAndExit();
+      }
+
+      selectedTemplateName = customTemplate;
+    } else {
+      selectedTemplateName = template;
+    }
+  }
+
+  // Prompt for package manager or use default
+  let packageManager: PackageManager = workspaceInfoOptional.packageManager as PackageManager;
+  if (!packageManager) {
+    if (viteOptions.interactive) {
+      const selected = await prompts.select({
+        message: 'Which package manager would you like to use?',
+        options: [
+          { value: PackageManager.pnpm, hint: 'recommended' },
+          { value: PackageManager.yarn },
+          { value: PackageManager.npm },
+        ],
+        initialValue: PackageManager.pnpm,
+      });
+
+      if (prompts.isCancel(selected)) {
+        cancelAndExit();
+      }
+
+      packageManager = selected;
+    } else {
+      // --no-interactive: use pnpm as default
+      packageManager = PackageManager.pnpm;
+      prompts.log.info(`Using default package manager: ${cyan(packageManager)}`);
+    }
+  }
+
+  // ensure the package manager is installed by vite-plus
+  const spinner = prompts.spinner();
+  spinner.start(`${packageManager}@${workspaceInfoOptional.packageManagerVersion} installing...`);
+  const downloadResult = await downloadPackageManager({
+    name: packageManager,
+    version: workspaceInfoOptional.packageManagerVersion,
+  });
+  spinner.stop(`${packageManager}@${downloadResult.version} installed`);
+  const workspaceInfo: WorkspaceInfo = {
+    ...workspaceInfoOptional,
+    packageManager,
+    downloadPackageManager: downloadResult,
+  };
+
+  // Discover template
+  const templateInfo = discoverTemplate(
+    selectedTemplateName,
+    selectedTemplateArgs,
+    workspaceInfo,
+    viteOptions.interactive,
+  );
+
+  // only for builtin templates
+  if (targetDir) {
+    if (templateInfo.type !== TemplateType.builtin) {
+      cancelAndExit('The --directory option is only available for builtin templates', 1);
+    }
+    // reset auto detect parent directory
+    templateInfo.parentDir = undefined;
+  }
+
+  // #endregion
+
+  // #region Handle monorepo template
+  if (templateInfo.command === BuiltinTemplate.monorepo) {
+    // Validate: cannot create monorepo inside an existing monorepo
+    if (isMonorepo) {
+      prompts.log.info(
+        'You are already in a monorepo workspace.\nUse a different template or run this command outside the monorepo',
+      );
+      cancelAndExit('Cannot create a monorepo inside an existing monorepo', 1);
+    }
+
+    if (!packageName) {
+      const selected = await promptPackageNameAndTargetDir('vite-plus-monorepo', viteOptions.interactive);
+      packageName = selected.packageName;
+      targetDir = selected.targetDir;
+    }
+
+    prompts.log.info(`Target directory: ${cyan(targetDir)}`);
+    await checkProjectDirExists(path.join(workspaceInfo.rootDir, targetDir), viteOptions.interactive);
+    const result = await executeMonorepoTemplate(
+      workspaceInfo,
+      { ...templateInfo, packageName, targetDir },
+      viteOptions.interactive,
+    );
+    if (result.exitCode !== 0) {
+      cancelAndExit(`Failed to create monorepo, exit code: ${result.exitCode}`, result.exitCode);
+    }
+
+    await runViteInstall(path.join(workspaceInfo.rootDir, result.projectDir!));
+    prompts.outro(green('✨ Generation completed!'));
+    showNextSteps(result.projectDir!);
+    return;
+  }
+  // #endregion
+
+  // #region Handle single project template
+
+  if (isMonorepo && viteOptions.interactive) {
+    if (!targetDir) {
+      // no custom target directory provided, prompt for parent directory
+      let parentDir: string | undefined;
+      if (workspaceInfo.parentDirs.length > 0) {
+        const defaultParentDir = templateInfo.parentDir ?? workspaceInfo.parentDirs[0];
+        const selected = await prompts.select({
+          message: 'Where should the new package be added to the monorepo:',
+          options: workspaceInfo.parentDirs.map((dir) => ({
+            label: `${dir}/`,
+            value: dir,
+            hint: ``,
+          })).concat([{
+            label: 'other',
+            value: 'other',
+            hint: 'Enter a custom target directory',
+          }]),
+          initialValue: defaultParentDir,
+        });
+
+        if (prompts.isCancel(selected)) {
+          cancelAndExit();
+        }
+
+        if (selected !== 'other') {
+          parentDir = selected;
+        }
+      }
+
+      if (!parentDir) {
+        const customTargetDir = await prompts.text({
+          message: 'Where should the new package be added to the monorepo:',
+          placeholder: 'e.g., packages/',
+          validate: (value) => {
+            return formatTargetDir(value).error;
+          },
+        });
+
+        if (prompts.isCancel(customTargetDir)) {
+          cancelAndExit();
+        }
+
+        parentDir = customTargetDir;
+      }
+
+      templateInfo.parentDir = parentDir;
+    }
+  }
+
+  let result: ExecutionResult;
+  if (templateInfo.type === TemplateType.builtin) {
+    // prompt for package name if not provided
+    if (!targetDir) {
+      let defaultPackageName = `vite-plus-${templateInfo.command.split(':')[1]}`;
+      if (workspaceInfo.monorepoScope) {
+        defaultPackageName = `${workspaceInfo.monorepoScope}/${defaultPackageName}`;
+      }
+      const selected = await promptPackageNameAndTargetDir(defaultPackageName, viteOptions.interactive);
+      packageName = selected.packageName;
+      targetDir = templateInfo.parentDir ? path.join(templateInfo.parentDir, selected.targetDir) : selected.targetDir;
+    }
+    await checkProjectDirExists(targetDir, viteOptions.interactive);
+    prompts.log.info(`Target directory: ${cyan(targetDir)}`);
+    result = await executeBuiltinTemplate(workspaceInfo, { ...templateInfo, packageName, targetDir });
+  } else {
+    result = await executeRemoteTemplate(
+      workspaceInfo,
+      templateInfo,
+    );
+  }
+
+  if (result.exitCode !== 0) {
+    process.exit(result.exitCode);
+  }
+  const projectDir = result.projectDir;
+  if (!projectDir) {
+    process.exit(0);
+  }
+
+  // Show detected project directory
+  prompts.log.success(`Detected project directory: ${green(projectDir)}`);
+  const fullPath = path.join(workspaceInfo.rootDir, projectDir);
+
+  // Auto-migration to vite-plus
+  await performAutoMigration(
+    workspaceInfo,
+    projectDir,
+  );
+
+  // Monorepo integration
+  if (isMonorepo) {
+    prompts.log.step('Monorepo integration...');
+
+    if (workspaceInfo.packages.length > 0) {
+      if (viteOptions.interactive) {
+        const selectedDepTypeOptions = await prompts.multiselect({
+          message: `Add workspace dependencies to the ${green(projectDir)}?`,
+          options: [
+            {
+              value: DependencyType.dependencies,
+            },
+            {
+              value: DependencyType.devDependencies,
+            },
+            {
+              value: DependencyType.peerDependencies,
+            },
+            {
+              value: DependencyType.optionalDependencies,
+            },
+          ],
+          required: false,
+        });
+
+        let selectedDepTypes: DependencyType[] = [];
+        if (!prompts.isCancel(selectedDepTypeOptions)) {
+          selectedDepTypes = selectedDepTypeOptions;
+        }
+
+        for (const selectedDepType of selectedDepTypes) {
+          const selected = await prompts.multiselect({
+            message: `Which packages should be added as ${selectedDepType} to ${green(projectDir)}?`,
+            // FIXME: ignore itself as dependency
+            options: workspaceInfo.packages.map(pkg => ({
+              value: pkg.name,
+              label: pkg.path,
+            })),
+            required: false,
+          });
+          let selectedDeps: string[] = [];
+          if (!prompts.isCancel(selected)) {
+            selectedDeps = selected;
+          }
+
+          if (selectedDeps.length > 0) {
+            // FIXME: should use `vite add` command instead
+            updatePackageJsonWithDeps(workspaceInfo.rootDir, projectDir, selectedDeps, selectedDepType);
+          }
+        }
+      }
+    }
+
+    updateWorkspaceConfig(projectDir, workspaceInfo);
+    // install dependencies in the root of the monorepo
+    await runViteInstall(workspaceInfo.rootDir);
+  } else {
+    // single project
+    // set package manager in the project directory
+    setPackageManager(fullPath, workspaceInfo.downloadPackageManager);
+    // install dependencies in the project directory
+    await runViteInstall(fullPath);
+  }
+
+  // Show comprehensive summary
+  prompts.outro(green('✨ Generation completed!'));
+
+  // Display summary
+  console.log(`\n${blue('Summary:')}`);
+  console.log(
+    `  ${gray('•')} Template: ${cyan(selectedTemplateName)}`,
+  );
+  console.log(`  ${gray('•')} Created: ${green(projectDir)}`);
+
+  // Show next steps
+  showNextSteps(projectDir);
+  // #endregion
+}
+
+function showNextSteps(projectDir: string) {
+  console.log(`\n${gray('Next steps:')}`);
+  console.log(`  ${cyan(`cd ${projectDir}`)}`);
+  console.log(`  ${cyan('vite run dev')}`);
+  console.log('');
+}
+
+function showAvailableTemplates() {
+  console.log('');
+  console.log(cyan('📦 Available Templates'));
+  console.log('');
+
+  console.log(blue('Vite+ Built-in Templates:'));
+  console.log('  • vite:monorepo                 ' + gray('- Create a new monorepo'));
+  console.log('  • vite:application              ' + gray('- Create a new application'));
+  console.log('  • vite:library                  ' + gray('- Create a new library'));
+  console.log('  • vite:generator                ' + gray('- Scaffold a new code generator'));
+  console.log('');
+
+  console.log(green('Popular Remote Templates:'));
+  console.log('  • create-vite                   ' + gray('- Official Vite templates'));
+  console.log('  • @tanstack/create-start        ' + gray('- TanStack applications'));
+  console.log('  • create-next-app               ' + gray('- Next.js application'));
+  console.log('  • create-nuxt                   ' + gray('- Nuxt application'));
+  console.log('  • create-typescript-app         ' + gray('- TypeScript application'));
+  console.log('  • create-react-router           ' + gray('- React Router application'));
+  console.log('  • create-vue                    ' + gray('- Vue application'));
+
+  console.log(
+    '\n' +
+      gray('Run ') +
+      cyan('vite gen') +
+      gray(' for interactive mode'),
+  );
+  console.log(
+    gray('Run ') +
+      cyan('vite gen <template>') +
+      gray(' to use any template'),
+  );
+  console.log(
+    gray('Run ') +
+      cyan('vite gen <template> -- <options>') +
+      gray(' to pass options to the template'),
+  );
+
+  console.log('');
+  console.log('✨ Tip: You can use ANY npm template with vite gen!');
+  console.log('');
+}
+
+async function runViteInstall(cwd: string) {
+  // install dependencies on non-CI environment
+  if (process.env.CI) {
+    return;
+  }
+
+  const spinner = prompts.spinner();
+  spinner.start(`Running vite install...`);
+  const { exitCode, stderr, stdout } = await runCommandSilently({
+    command: 'vite',
+    args: ['install'],
+    cwd,
+    envs: process.env,
+  });
+  if (exitCode === 0) {
+    spinner.stop(`Dependencies installed`);
+  } else {
+    spinner.stop(`Install failed`);
+    prompts.log.info(stdout.toString());
+    prompts.log.error(stderr.toString());
+    prompts.log.info(`You may need to run it manually in ${cwd}`);
+  }
+}
+
+main().catch((err) => {
+  prompts.log.error(err.message);
+  console.error(err);
+  cancelAndExit(`Failed to generate code: ${err.message}`, 1);
+});
diff --git a/packages/global/src/gen/__tests__/__snapshots__/utils.spec.ts.snap b/packages/global/src/gen/__tests__/__snapshots__/utils.spec.ts.snap
new file mode 100644
index 0000000000..4846bbac07
--- /dev/null
+++ b/packages/global/src/gen/__tests__/__snapshots__/utils.spec.ts.snap
@@ -0,0 +1,93 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`formatTargetDir > should format target dir with invalid input 1`] = `
+{
+  "directory": "",
+  "error": "Parsed package name "." is invalid: name cannot start with a period",
+  "packageName": "",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with invalid input 2`] = `
+{
+  "directory": "",
+  "error": "Absolute path is not allowed",
+  "packageName": "",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with invalid input 3`] = `
+{
+  "directory": "",
+  "error": "Parsed package name "@scope" is invalid: name can only contain URL-friendly characters",
+  "packageName": "",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with invalid input 4`] = `
+{
+  "directory": "",
+  "error": "Relative path contains ".." which is not allowed",
+  "packageName": "",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with invalid package name 1`] = `"Parsed package name "my-package@" is invalid: name can only contain URL-friendly characters"`;
+
+exports[`formatTargetDir > should format target dir with invalid package name 2`] = `"Parsed package name "my-package@1.0.0" is invalid: name can only contain URL-friendly characters"`;
+
+exports[`formatTargetDir > should format target dir with valid input 1`] = `
+{
+  "directory": "my-package",
+  "packageName": "my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 2`] = `
+{
+  "directory": "my-package",
+  "packageName": "my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 3`] = `
+{
+  "directory": "my-package",
+  "packageName": "@my-scope/my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 4`] = `
+{
+  "directory": "foo/my-package",
+  "packageName": "@my-scope/my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 5`] = `
+{
+  "directory": "foo/my-package",
+  "packageName": "@my-scope/my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 6`] = `
+{
+  "directory": "foo/bar/my-package",
+  "packageName": "@scope/my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 7`] = `
+{
+  "directory": "foo/bar/my-package",
+  "packageName": "@scope/my-package",
+}
+`;
+
+exports[`formatTargetDir > should format target dir with valid input 8`] = `
+{
+  "directory": "foo/bar/@scope/my-package/sub-package",
+  "packageName": "sub-package",
+}
+`;
diff --git a/packages/global/src/gen/__tests__/utils.spec.ts b/packages/global/src/gen/__tests__/utils.spec.ts
new file mode 100644
index 0000000000..271c1add33
--- /dev/null
+++ b/packages/global/src/gen/__tests__/utils.spec.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+
+import { formatTargetDir, getProjectDirFromPackageName } from '../utils.ts';
+
+describe('getProjectDirFromPackageName', () => {
+  it('should get project dir from package name', () => {
+    expect(getProjectDirFromPackageName('@my/package')).toBe('package');
+    expect(getProjectDirFromPackageName('my-package')).toBe('my-package');
+  });
+});
+
+describe('formatTargetDir', () => {
+  it('should format target dir with invalid input', () => {
+    expect(formatTargetDir('.')).matchSnapshot();
+    expect(formatTargetDir('/foo/bar')).matchSnapshot();
+    expect(formatTargetDir('@scope/')).matchSnapshot();
+    expect(formatTargetDir('../../foo/bar')).matchSnapshot();
+  });
+
+  it('should format target dir with valid input', () => {
+    expect(formatTargetDir('./my-package')).matchSnapshot();
+    expect(formatTargetDir('my-package')).matchSnapshot();
+    expect(formatTargetDir('@my-scope/my-package')).matchSnapshot();
+    expect(formatTargetDir('foo/@my-scope/my-package')).matchSnapshot();
+    expect(formatTargetDir('./foo/@my-scope/my-package')).matchSnapshot();
+    expect(formatTargetDir('./foo/bar/@scope/my-package')).matchSnapshot();
+    expect(formatTargetDir('./foo/bar/@scope/my-package/')).matchSnapshot();
+    expect(formatTargetDir('./foo/bar/@scope/my-package/sub-package')).matchSnapshot();
+  });
+
+  it('should format target dir with invalid package name', () => {
+    expect(formatTargetDir('my-package@').error).matchSnapshot();
+    expect(formatTargetDir('my-package@1.0.0').error).matchSnapshot();
+  });
+});
diff --git a/packages/global/src/gen/command.ts b/packages/global/src/gen/command.ts
new file mode 100644
index 0000000000..c41b7ec9d8
--- /dev/null
+++ b/packages/global/src/gen/command.ts
@@ -0,0 +1,173 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { runCommand as runCommandWithFspy } from '@voidzero-dev/vite-plus/binding';
+import spawn from 'cross-spawn';
+
+import type { ExecutionResult, WorkspaceInfo } from './types.ts';
+
+export interface RunCommandOptions {
+  command: string;
+  args: string[];
+  cwd: string;
+  envs: NodeJS.ProcessEnv;
+}
+
+// Run a command and detect the project directory
+export async function runCommandAndDetectProjectDir(
+  options: RunCommandOptions,
+  parentDir?: string,
+): Promise<ExecutionResult> {
+  const cwd = parentDir ? path.join(options.cwd, parentDir) : options.cwd;
+  const existingDirs = new Set<string>();
+  if (parentDir) {
+    await fs.mkdir(cwd, { recursive: true });
+    // Get existing subdirectories before running the command
+    const entries = await fs.readdir(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        existingDirs.add(entry.name);
+      }
+    }
+  }
+
+  const result = await runCommandWithFspy({
+    binName: options.command,
+    args: options.args,
+    envs: options.envs as Record<string, string>,
+    cwd,
+  });
+
+  // Detect project directory from path accesses
+  // Find the closest directory containing package.json relative to cwd
+  let projectDir: string | undefined;
+  let minDepth = Infinity;
+
+  for (const [filePath, pathAccess] of Object.entries(result.pathAccesses)) {
+    // Look for package.json writes
+    if (pathAccess.write && filePath.endsWith('package.json') && !filePath.includes('node_modules')) {
+      // Extract directory from package.json path
+      const dir = path.dirname(filePath);
+
+      // Skip if it's the current directory
+      if (dir === '.' || dir === '') {
+        continue;
+      }
+      // Skip if this is an existing directory (created before the command ran)
+      if (existingDirs.has(dir)) {
+        continue;
+      }
+
+      // Calculate depth (number of path segments)
+      const depth = dir.split(path.sep).length;
+
+      // Keep the closest (shallowest) directory
+      if (depth < minDepth) {
+        minDepth = depth;
+        projectDir = dir;
+      }
+    }
+  }
+
+  // If parentDir is provided, join it with the project directory
+  if (parentDir && projectDir) {
+    projectDir = path.join(parentDir, projectDir);
+  }
+
+  return {
+    exitCode: result.exitCode,
+    projectDir,
+  };
+}
+
+export interface RunCommandResult extends ExecutionResult {
+  stdout: Buffer;
+  stderr: Buffer;
+}
+
+export async function runCommand(options: RunCommandOptions): Promise<ExecutionResult> {
+  const child = spawn(options.command, options.args, {
+    stdio: 'inherit',
+    cwd: options.cwd,
+    env: options.envs,
+  });
+  const promise = new Promise<ExecutionResult>((resolve, reject) => {
+    child.on('close', (code) => {
+      resolve({ exitCode: code ?? 0 });
+    });
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+  return await promise;
+}
+
+export async function runCommandSilently(options: RunCommandOptions): Promise<RunCommandResult> {
+  const child = spawn(options.command, options.args, {
+    stdio: 'pipe',
+    cwd: options.cwd,
+    env: options.envs,
+  });
+  const promise = new Promise<RunCommandResult>((resolve, reject) => {
+    const stdout: Buffer[] = [];
+    const stderr: Buffer[] = [];
+    child.stdout?.on('data', (data) => {
+      stdout.push(data);
+    });
+    child.stderr?.on('data', (data) => {
+      stderr.push(data);
+    });
+    child.on('close', (code) => {
+      resolve({ exitCode: code ?? 0, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) });
+    });
+    child.on('error', (err) => {
+      reject(err);
+    });
+  });
+  return await promise;
+}
+
+// Get the package runner command for each package manager
+export function getPackageRunner(workspaceInfo: WorkspaceInfo) {
+  switch (workspaceInfo.packageManager) {
+    case 'pnpm':
+      return {
+        command: 'pnpm',
+        args: ['dlx'],
+      };
+    case 'yarn':
+      return {
+        command: 'yarn',
+        args: ['dlx'],
+      };
+    case 'npm':
+    default:
+      return { command: 'npx', args: [] };
+  }
+}
+
+// TODO: will use `vite dlx` instead, see https://github.com/voidzero-dev/vite-task/issues/27
+export function formatDlxCommand(packageName: string, args: string[], workspaceInfo: WorkspaceInfo) {
+  const runner = getPackageRunner(workspaceInfo);
+  const dlxArgs = runner.command === 'npm' ? ['--', ...args] : args;
+  return {
+    command: runner.command,
+    args: [...runner.args, packageName, ...dlxArgs],
+  };
+}
+
+export function prependToPathToEnvs(extraPath: string, envs: NodeJS.ProcessEnv) {
+  const delimiter = path.delimiter;
+  const pathKey = Object.keys(envs).find(
+    (key) => key.toLowerCase() === 'path',
+  ) ?? 'PATH';
+
+  const current = envs[pathKey] ?? '';
+
+  // avoid duplicate
+  const parts = current.split(delimiter).filter(Boolean);
+  if (!parts.includes(extraPath)) {
+    envs[pathKey] = extraPath + (current ? delimiter + current : '');
+  }
+  return envs;
+}
diff --git a/packages/global/src/gen/discovery.ts b/packages/global/src/gen/discovery.ts
new file mode 100644
index 0000000000..d90e887ac0
--- /dev/null
+++ b/packages/global/src/gen/discovery.ts
@@ -0,0 +1,136 @@
+import path from 'node:path';
+
+import { prependToPathToEnvs } from './command.ts';
+import { BuiltinTemplate, type TemplateInfo, TemplateType, type WorkspaceInfo } from './types.ts';
+import { readJsonFile } from './utils.ts';
+
+// Check if template name is a GitHub URL
+export function isGitHubUrl(templateName: string): boolean {
+  return (
+    templateName.startsWith('https://github.com/') ||
+    templateName.startsWith('github:') ||
+    templateName.includes('github.com/')
+  );
+}
+
+// Convert GitHub URL to degit format
+export function parseGitHubUrl(url: string): string | null {
+  // github:user/repo → user/repo
+  if (url.startsWith('github:')) {
+    return url.slice(7);
+  }
+
+  // https://github.com/user/repo → user/repo
+  const match = url.match(/github\.com\/([^/]+\/[^/]+)/);
+  if (match) {
+    return match[1].replace(/\.git$/, '');
+  }
+
+  return null;
+}
+
+// Discover and identify a template
+export function discoverTemplate(
+  templateName: string,
+  templateArgs: string[],
+  workspaceInfo: WorkspaceInfo,
+  interactive?: boolean,
+): TemplateInfo {
+  const envs = prependToPathToEnvs(workspaceInfo.downloadPackageManager.binPrefix, {
+    ...process.env,
+  });
+  const parentDir = inferParentDir(templateName, workspaceInfo);
+  // Check for built-in templates
+  if (templateName.startsWith('vite:')) {
+    return {
+      command: templateName,
+      args: [...templateArgs],
+      envs,
+      type: TemplateType.builtin,
+      parentDir,
+      interactive,
+    };
+  }
+
+  // Check for GitHub URLs
+  if (isGitHubUrl(templateName)) {
+    const degitPath = parseGitHubUrl(templateName);
+    if (degitPath) {
+      return {
+        command: 'degit',
+        args: [degitPath, templateName, ...templateArgs],
+        envs,
+        type: TemplateType.remote,
+        parentDir,
+        interactive,
+      };
+    }
+  }
+
+  // Check for local package
+  const localPackage = workspaceInfo.packages.find(pkg => pkg.name === templateName);
+  if (localPackage) {
+    const localPackagePath = path.join(workspaceInfo.rootDir, localPackage.path);
+    const packageJsonPath = path.join(localPackagePath, 'package.json');
+    const pkg = readJsonFile<
+      { dependencies?: Record<string, string>; keywords?: string[]; bin?: Record<string, string> | string }
+    >(packageJsonPath);
+    let binPath = '';
+    if (pkg.bin) {
+      if (typeof pkg.bin === 'string') {
+        binPath = path.join(localPackagePath, pkg.bin);
+      } else {
+        const binName = Object.keys(pkg.bin)[0];
+        binPath = path.join(localPackagePath, pkg.bin[binName]);
+      }
+    }
+    const args = [binPath, ...templateArgs];
+    let type: TemplateType = TemplateType.remote;
+    if (pkg.keywords?.includes('bingo-template') || !!pkg.dependencies?.bingo) {
+      type = TemplateType.bingo;
+      // add `--skip-requests` by default for bingo templates
+      args.push('--skip-requests');
+    }
+    if (binPath) {
+      return {
+        command: 'node',
+        args,
+        envs,
+        type,
+        parentDir,
+        interactive,
+      };
+    }
+  }
+
+  return {
+    command: templateName,
+    args: [...templateArgs],
+    envs,
+    type: TemplateType.remote,
+    parentDir,
+    interactive,
+  };
+}
+
+// Infer the parent directory of the generated package based on the template name
+function inferParentDir(templateName: string, workspaceInfo: WorkspaceInfo): string | undefined {
+  if (workspaceInfo.parentDirs.length === 0) {
+    return;
+  }
+  // apps/applications by default
+  let rule = /app/i;
+  if (templateName === BuiltinTemplate.library) {
+    // libraries/packages/components
+    rule = /lib|component|package/i;
+  } else if (templateName === BuiltinTemplate.generator) {
+    // generators/tools
+    rule = /generator|tool/i;
+  }
+  for (const parentDir of workspaceInfo.parentDirs) {
+    if (rule.test(parentDir)) {
+      return parentDir;
+    }
+  }
+  return;
+}
diff --git a/packages/global/src/gen/migration.ts b/packages/global/src/gen/migration.ts
new file mode 100644
index 0000000000..542b1331a1
--- /dev/null
+++ b/packages/global/src/gen/migration.ts
@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import * as prompts from '@clack/prompts';
+import colors from 'picocolors';
+
+import type { WorkspaceInfo } from './types.ts';
+import { editJsonFile, editOrCreateFile, readJsonFile, templatesDir } from './utils.ts';
+
+const { gray } = colors;
+const viteTools = ['vite', 'vitest', 'oxlint', 'oxfmt', 'tsdown'];
+
+// Detect standalone vite-related tools in project
+export function detectStandaloneViteTools(projectDir: string, cwd: string): string[] {
+  const packageJsonPath = path.join(cwd, projectDir, 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return [];
+  }
+
+  const pkg = readJsonFile(packageJsonPath);
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  const detected: string[] = [];
+  for (const tool of viteTools) {
+    if (allDeps[tool]) {
+      detected.push(tool);
+    }
+  }
+  return detected;
+}
+
+// Migrate standalone vite tools to vite-plus
+export function migrateToVitePlus(projectDir: string, cwd: string, isMonorepo: boolean): void {
+  const packageJsonPath = path.join(cwd, projectDir, 'package.json');
+  editJsonFile(packageJsonPath, (pkg) => {
+    // Track where vite was originally located (dependencies or devDependencies)
+    const viteInDependencies = !!pkg.dependencies?.['vite'];
+
+    // Remove standalone tools
+    for (const tool of viteTools) {
+      if (pkg.dependencies?.[tool]) {
+        delete pkg.dependencies[tool];
+      }
+      if (pkg.devDependencies?.[tool]) {
+        delete pkg.devDependencies[tool];
+      }
+    }
+
+    // Add vite-plus to the same location where vite was originally
+    if (isMonorepo) {
+      // Use catalog for monorepo
+      if (viteInDependencies) {
+        pkg.dependencies['vite'] = 'catalog:';
+      } else {
+        if (!pkg.devDependencies) pkg.devDependencies = {};
+        pkg.devDependencies['vite'] = 'catalog:';
+      }
+      if (pkg.devDependencies?.['typescript']) {
+        pkg.devDependencies['typescript'] = 'catalog:';
+      }
+    } else {
+      // Use npm alias for standalone
+      // TODO: use stable version of vite-plus after released to npm
+      if (viteInDependencies) {
+        pkg.dependencies['vite'] = 'npm:@voidzero-dev/vite-plus@latest';
+      } else {
+        if (!pkg.devDependencies) pkg.devDependencies = {};
+        pkg.devDependencies['vite'] = 'npm:@voidzero-dev/vite-plus@latest';
+      }
+
+      // set .npmrc to use vite-plus
+      editOrCreateFile(path.join(cwd, projectDir, '.npmrc'), (content) => {
+        const npmrc = fs.readFileSync(path.join(templatesDir, 'config/_npmrc'), 'utf-8');
+        return content ? `${content.trimEnd()}\n${npmrc}` : npmrc;
+      });
+    }
+
+    // Update scripts if needed
+    // TODO: use ast-grep to update scripts
+    if (pkg.scripts) {
+      // Update common script patterns
+      if (pkg.scripts.dev === 'vite') {
+        pkg.scripts.dev = 'vite dev';
+      }
+      if (pkg.scripts.dev === 'tsdown --watch') {
+        pkg.scripts.dev = 'vite lib --watch';
+      }
+      if (pkg.scripts.build === 'tsdown') {
+        pkg.scripts.build = 'vite lib';
+      }
+      if (pkg.scripts.test === 'vitest' || pkg.scripts.test === 'vitest run') {
+        pkg.scripts.test = 'vite test';
+      }
+      if (pkg.scripts.lint === 'oxlint') {
+        pkg.scripts.lint = 'vite lint';
+      }
+      if (pkg.scripts.format === 'oxfmt') {
+        pkg.scripts.format = 'vite fmt';
+      }
+    }
+    return pkg;
+  });
+}
+
+// Perform auto-migration with prompts and feedback
+export async function performAutoMigration(
+  workspaceInfo: WorkspaceInfo,
+  projectDir: string,
+) {
+  const standaloneTools = detectStandaloneViteTools(projectDir, workspaceInfo.rootDir);
+  if (standaloneTools.length === 0) {
+    return; // No migration needed
+  }
+
+  migrateToVitePlus(projectDir, workspaceInfo.rootDir, workspaceInfo.isMonorepo);
+  prompts.log.success(`Migrated to vite-plus ${gray('✓')}`);
+  prompts.log.info(`  ${gray('•')} Removed: ${standaloneTools.join(', ')}`);
+  prompts.log.info(
+    `  ${gray('•')} Added: vite ${
+      gray(workspaceInfo.isMonorepo ? '(catalog:)' : '(npm:@voidzero-dev/vite-plus@latest)')
+    }`,
+  );
+}
diff --git a/packages/global/src/gen/prompts.ts b/packages/global/src/gen/prompts.ts
new file mode 100644
index 0000000000..d56ea716e7
--- /dev/null
+++ b/packages/global/src/gen/prompts.ts
@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+
+import * as prompts from '@clack/prompts';
+import colors from 'picocolors';
+import validateNpmPackageName from 'validate-npm-package-name';
+
+import { emptyDir, getProjectDirFromPackageName, isEmpty } from './utils.ts';
+
+const { cyan } = colors;
+
+export async function promptPackageNameAndTargetDir(
+  defaultPackageName: string,
+  interactive?: boolean,
+) {
+  let packageName: string;
+  let targetDir: string;
+
+  if (interactive) {
+    const selected = await prompts.text({
+      message: 'Package name:',
+      placeholder: defaultPackageName,
+      defaultValue: defaultPackageName,
+      validate: value => {
+        if (value.length === 0) return;
+
+        const result = validateNpmPackageName(value);
+        if (result.validForNewPackages) return;
+        return result.errors?.[0] ?? result.warnings?.[0] ?? 'Invalid package name';
+      },
+    });
+    if (prompts.isCancel(selected)) {
+      cancelAndExit();
+    }
+    packageName = selected;
+    targetDir = getProjectDirFromPackageName(packageName);
+  } else {
+    // --no-interactive: use default
+    packageName = defaultPackageName;
+    targetDir = getProjectDirFromPackageName(packageName);
+    prompts.log.info(`Using default package name: ${cyan(packageName)}`);
+  }
+
+  return { packageName, targetDir };
+}
+
+export async function checkProjectDirExists(projectDirFullPath: string, interactive?: boolean) {
+  if (!fs.existsSync(projectDirFullPath) || isEmpty(projectDirFullPath)) {
+    return;
+  }
+  if (!interactive) {
+    prompts.log.info('Use --directory to specify a different location or remove the directory first');
+    cancelAndExit(`Target directory "${projectDirFullPath}" is not empty`, 1);
+  }
+
+  // Handle directory if it exists and is not empty
+  const overwrite = await prompts.select({
+    message: `Target directory "${projectDirFullPath}" is not empty. Please choose how to proceed:`,
+    options: [
+      {
+        label: 'Cancel operation',
+        value: 'no',
+      },
+      {
+        label: 'Remove existing files and continue',
+        value: 'yes',
+      },
+    ],
+  });
+
+  if (prompts.isCancel(overwrite)) {
+    cancelAndExit();
+  }
+
+  switch (overwrite) {
+    case 'yes':
+      emptyDir(projectDirFullPath);
+      break;
+    case 'no':
+      cancelAndExit();
+  }
+}
+
+export function cancelAndExit(message = 'Operation cancelled', exitCode = 0): never {
+  prompts.cancel(message);
+  process.exit(exitCode);
+}
diff --git a/packages/global/src/gen/templates/builtin.ts b/packages/global/src/gen/templates/builtin.ts
new file mode 100644
index 0000000000..70f53399ce
--- /dev/null
+++ b/packages/global/src/gen/templates/builtin.ts
@@ -0,0 +1,49 @@
+import assert from 'node:assert';
+import path from 'node:path';
+
+import { BuiltinTemplate, type BuiltinTemplateInfo, type ExecutionResult, type WorkspaceInfo } from '../types.ts';
+import { setPackageName } from '../utils.ts';
+import { executeGeneratorScaffold } from './generator.ts';
+import { runRemoteTemplateCommand } from './remote.ts';
+
+export async function executeBuiltinTemplate(
+  workspaceInfo: WorkspaceInfo,
+  templateInfo: BuiltinTemplateInfo,
+): Promise<ExecutionResult> {
+  assert(templateInfo.targetDir, 'targetDir is required');
+  assert(templateInfo.packageName, 'packageName is required');
+
+  if (templateInfo.command === BuiltinTemplate.generator) {
+    return await executeGeneratorScaffold(workspaceInfo, templateInfo);
+  }
+
+  if (templateInfo.command === BuiltinTemplate.application) {
+    templateInfo.command = 'create-vite@latest';
+  }
+
+  if (templateInfo.command === BuiltinTemplate.library) {
+    templateInfo.command = 'create-tsdown@latest';
+    if (!templateInfo.interactive) {
+      // set default template for tsdown
+      if (!templateInfo.args.find(arg => arg.startsWith('--template') || arg.startsWith('-t'))) {
+        templateInfo.args.push('--template', 'default');
+      }
+    }
+  }
+
+  templateInfo.args.unshift(templateInfo.targetDir);
+  if (!templateInfo.interactive) {
+    templateInfo.args.push('--no-interactive');
+  }
+
+  // Handle remote/external templates with fspy monitoring
+  const result = await runRemoteTemplateCommand(workspaceInfo, workspaceInfo.rootDir, templateInfo, false);
+  const fullPath = path.join(workspaceInfo.rootDir, templateInfo.targetDir);
+  // set package name in the project directory
+  setPackageName(fullPath, templateInfo.packageName);
+
+  return {
+    ...result,
+    projectDir: templateInfo.targetDir,
+  };
+}
diff --git a/packages/global/src/gen/templates/generator.ts b/packages/global/src/gen/templates/generator.ts
new file mode 100644
index 0000000000..24a3ec9668
--- /dev/null
+++ b/packages/global/src/gen/templates/generator.ts
@@ -0,0 +1,44 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import * as prompts from '@clack/prompts';
+
+import type { BuiltinTemplateInfo, ExecutionResult, WorkspaceInfo } from '../types.ts';
+import { copyDir, editJsonFile, templatesDir } from '../utils.ts';
+
+// Execute generator scaffold template
+export async function executeGeneratorScaffold(
+  workspaceInfo: WorkspaceInfo,
+  templateInfo: BuiltinTemplateInfo,
+): Promise<ExecutionResult> {
+  prompts.log.step('Creating generator scaffold...');
+  let description: string | undefined;
+  if (templateInfo.interactive) {
+    const defaultDescription = 'Generate new components for our monorepo';
+    const descPrompt = await prompts.text({
+      message: 'Description:',
+      placeholder: defaultDescription,
+      defaultValue: defaultDescription,
+    });
+
+    if (!prompts.isCancel(descPrompt)) {
+      description = descPrompt;
+    }
+  }
+
+  const fullPath = path.join(workspaceInfo.rootDir, templateInfo.targetDir);
+  // Copy template files
+  const templateDir = path.join(templatesDir, 'generator');
+  copyDir(templateDir, fullPath);
+  fs.chmodSync(path.join(fullPath, 'bin/index.ts'), '755');
+  editJsonFile(path.join(fullPath, 'package.json'), (pkg) => {
+    pkg.name = templateInfo.packageName;
+    if (description) {
+      pkg.description = description;
+    }
+    return pkg;
+  });
+
+  prompts.log.success('Generator scaffold created');
+  return { exitCode: 0, projectDir: templateInfo.targetDir };
+}
diff --git a/packages/global/src/gen/templates/index.ts b/packages/global/src/gen/templates/index.ts
new file mode 100644
index 0000000000..0947fa2a97
--- /dev/null
+++ b/packages/global/src/gen/templates/index.ts
@@ -0,0 +1,3 @@
+export * from './builtin.ts';
+export * from './monorepo.ts';
+export * from './remote.ts';
diff --git a/packages/global/src/gen/templates/monorepo.ts b/packages/global/src/gen/templates/monorepo.ts
new file mode 100644
index 0000000000..2fa222380a
--- /dev/null
+++ b/packages/global/src/gen/templates/monorepo.ts
@@ -0,0 +1,182 @@
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import * as prompts from '@clack/prompts';
+import spawn from 'cross-spawn';
+
+import { discoverTemplate } from '../discovery.ts';
+import { migrateToVitePlus } from '../migration.ts';
+import { type BuiltinTemplateInfo, type ExecutionResult, PackageManager, type WorkspaceInfo } from '../types.ts';
+import {
+  copyDir,
+  editJsonFile,
+  getScopeFromPackageName,
+  renameFiles,
+  setPackageManager,
+  setPackageName,
+  templatesDir,
+} from '../utils.ts';
+
+import { runRemoteTemplateCommand } from './remote.ts';
+
+// Execute vite:monorepo - copy from templates/monorepo
+export async function executeMonorepoTemplate(
+  workspaceInfo: WorkspaceInfo,
+  templateInfo: BuiltinTemplateInfo,
+  interactive: boolean,
+): Promise<ExecutionResult> {
+  prompts.log.step('Creating vite+ monorepo...');
+  assert(templateInfo.packageName, 'packageName is required');
+  assert(templateInfo.targetDir, 'targetDir is required');
+
+  workspaceInfo.monorepoScope = getScopeFromPackageName(templateInfo.packageName);
+  const fullPath = path.join(workspaceInfo.rootDir, templateInfo.targetDir);
+
+  // Copy template files
+  const templateDir = path.join(templatesDir, 'monorepo');
+  copyDir(templateDir, fullPath);
+  renameFiles(fullPath);
+
+  // set project name
+  editJsonFile(path.join(fullPath, 'package.json'), (pkg) => {
+    pkg.name = templateInfo.packageName;
+    return pkg;
+  });
+
+  // Adjust package.json based on package manager
+  if (workspaceInfo.packageManager === PackageManager.pnpm) {
+    // remove workspaces field
+    editJsonFile(path.join(fullPath, 'package.json'), (pkg) => {
+      pkg.workspaces = undefined;
+      // remove resolutions field
+      pkg.resolutions = undefined;
+      return pkg;
+    });
+    const yarnrcPath = path.join(fullPath, '.yarnrc.yml');
+    if (fs.existsSync(yarnrcPath)) {
+      fs.unlinkSync(yarnrcPath);
+    }
+  } else if (workspaceInfo.packageManager === PackageManager.yarn) {
+    // remove pnpm field
+    editJsonFile(path.join(fullPath, 'package.json'), (pkg) => {
+      pkg.pnpm = undefined;
+      return pkg;
+    });
+    const pnpmWorkspacePath = path.join(fullPath, 'pnpm-workspace.yaml');
+    if (fs.existsSync(pnpmWorkspacePath)) {
+      fs.unlinkSync(pnpmWorkspacePath);
+    }
+  } else {
+    // npm
+    // remove pnpm field
+    editJsonFile(path.join(fullPath, 'package.json'), (pkg) => {
+      pkg.pnpm = undefined;
+      return pkg;
+    });
+    const pnpmWorkspacePath = path.join(fullPath, 'pnpm-workspace.yaml');
+    if (fs.existsSync(pnpmWorkspacePath)) {
+      fs.unlinkSync(pnpmWorkspacePath);
+    }
+    const yarnrcPath = path.join(fullPath, '.yarnrc.yml');
+    if (fs.existsSync(yarnrcPath)) {
+      fs.unlinkSync(yarnrcPath);
+    }
+  }
+
+  setPackageManager(fullPath, workspaceInfo.downloadPackageManager);
+  prompts.log.success('Monorepo template created');
+
+  // Ask user to init git repository or auto-init if --no-interactive
+  let initGit = true; // Default to yes
+  if (interactive) {
+    const selected = await prompts.confirm({
+      message: `Initialize git repository:`,
+      initialValue: true,
+    });
+    if (prompts.isCancel(selected)) {
+      prompts.log.info('Operation cancelled. Skipping git initialization');
+      initGit = false;
+    } else {
+      initGit = selected;
+    }
+  } else {
+    prompts.log.info(`Initializing git repository (default: yes)`);
+  }
+
+  if (initGit) {
+    const gitResult = spawn.sync('git', ['init'], {
+      stdio: 'pipe',
+      cwd: fullPath,
+    });
+
+    if (gitResult.status === 0) {
+      prompts.log.success('Git repository initialized');
+    } else {
+      prompts.log.warn('Failed to initialize git repository');
+      if (gitResult.stderr) {
+        prompts.log.info(gitResult.stderr.toString());
+      }
+    }
+  }
+
+  // Automatically create a default application in apps/website
+  prompts.log.step('Creating default application in apps/website...');
+
+  const appDir = 'apps/website';
+  const appTemplateInfo = discoverTemplate('create-vite@latest', [
+    appDir,
+    '--template',
+    'vanilla-ts',
+    '--no-interactive',
+  ], workspaceInfo);
+  const appResult = await runRemoteTemplateCommand(
+    workspaceInfo,
+    fullPath,
+    appTemplateInfo,
+  );
+
+  if (appResult.exitCode !== 0) {
+    prompts.log.error(`Failed to create default application: ${appResult.exitCode}`);
+    return appResult;
+  }
+
+  const appPackageName = workspaceInfo.monorepoScope ? `${workspaceInfo.monorepoScope}/website` : 'website';
+  setPackageName(path.join(fullPath, appDir), appPackageName);
+  // Perform auto-migration on the created app
+  migrateToVitePlus(
+    appDir,
+    fullPath, // The monorepo directory
+    true, // Always in monorepo context
+  );
+
+  // Automatically create a default library in packages/utils
+  prompts.log.step('Creating default library in packages/utils...');
+  const libraryDir = 'packages/utils';
+  const libraryTemplateInfo = discoverTemplate('create-tsdown@latest', [
+    libraryDir,
+    '--template',
+    'default',
+    '--no-interactive',
+  ], workspaceInfo);
+  const libraryResult = await runRemoteTemplateCommand(
+    workspaceInfo,
+    fullPath,
+    libraryTemplateInfo,
+  );
+  if (libraryResult.exitCode !== 0) {
+    prompts.log.error(`Failed to create default library, exit code: ${libraryResult.exitCode}`);
+    return libraryResult;
+  }
+
+  const libraryPackageName = workspaceInfo.monorepoScope ? `${workspaceInfo.monorepoScope}/utils` : 'utils';
+  setPackageName(path.join(fullPath, libraryDir), libraryPackageName);
+  // Perform auto-migration on the created library
+  migrateToVitePlus(
+    libraryDir,
+    fullPath, // The monorepo directory
+    true, // Always in monorepo context
+  );
+
+  return { exitCode: 0, projectDir: templateInfo.targetDir };
+}
diff --git a/packages/global/src/gen/templates/remote.ts b/packages/global/src/gen/templates/remote.ts
new file mode 100644
index 0000000000..bae78ec7d8
--- /dev/null
+++ b/packages/global/src/gen/templates/remote.ts
@@ -0,0 +1,93 @@
+import * as prompts from '@clack/prompts';
+import colors from 'picocolors';
+
+import { formatDlxCommand, runCommand, runCommandAndDetectProjectDir } from '../command.ts';
+import type { ExecutionResult, TemplateInfo, WorkspaceInfo } from '../types.ts';
+
+const { gray, yellow } = colors;
+
+export async function executeRemoteTemplate(
+  workspaceInfo: WorkspaceInfo,
+  templateInfo: TemplateInfo,
+): Promise<ExecutionResult> {
+  prompts.log.step('Executing template...');
+
+  let isGitHubTemplate = templateInfo.command === 'degit';
+  let result: ExecutionResult;
+  if (templateInfo.command === 'node') {
+    // Template found locally - execute directly
+    const command = templateInfo.command;
+    const args = templateInfo.args;
+    const envs = templateInfo.envs;
+    prompts.log.info(`Running: ${gray(`${command} ${args.join(' ')}`)}`);
+    result = await runCommandAndDetectProjectDir(
+      { command, args, cwd: workspaceInfo.rootDir, envs },
+      templateInfo.parentDir,
+    );
+  } else {
+    // TODO: prompt for project name if not provided for degit
+    // Template not found - use package manager runner (npx/pnpm dlx/etc.)
+    result = await runRemoteTemplateCommand(
+      workspaceInfo,
+      workspaceInfo.rootDir,
+      templateInfo,
+      true,
+    );
+  }
+
+  const exitCode = result.exitCode;
+  // Provide troubleshooting tips
+  if (exitCode === 127) {
+    prompts.log.info(yellow('\nTroubleshooting:'));
+    prompts.log.info(`  ${gray('•')} Command not found. Make sure Node.js is installed`);
+    // prompts.log.info(`  ${gray('•')} Check if ${command} is available in PATH`);
+  } else if (isGitHubTemplate && exitCode !== 0) {
+    prompts.log.info(yellow('\nTroubleshooting:'));
+    prompts.log.info(`  ${gray('•')} Make sure the GitHub repository exists`);
+    prompts.log.info(`  ${gray('•')} Check your internet connection`);
+    prompts.log.info(`  ${gray('•')} Repository might be private (requires authentication)`);
+  }
+  return result;
+}
+
+// Run a remote template command and support detect the created project directory
+export async function runRemoteTemplateCommand(
+  workspaceInfo: WorkspaceInfo,
+  cwd: string,
+  templateInfo: TemplateInfo,
+  detectCreatedProjectDir?: boolean,
+): Promise<ExecutionResult> {
+  autoFixRemoteTemplateCommand(templateInfo, workspaceInfo);
+  const remotePackageName = templateInfo.command;
+  const execArgs = [...templateInfo.args];
+  const envs = templateInfo.envs;
+  const { command, args } = formatDlxCommand(remotePackageName, execArgs, workspaceInfo);
+  prompts.log.info(`Running: ${gray(`${command} ${args.join(' ')}`)}`);
+  if (detectCreatedProjectDir) {
+    return await runCommandAndDetectProjectDir({ command, args, cwd, envs }, templateInfo.parentDir);
+  }
+  return await runCommand({ command, args, cwd, envs });
+}
+
+function autoFixRemoteTemplateCommand(templateInfo: TemplateInfo, workspaceInfo: WorkspaceInfo) {
+  // @tanstack/create-start@latest, create-vite@latest
+  let packageName = templateInfo.command;
+  const indexOfAt = packageName.indexOf('@', 2);
+  if (indexOfAt !== -1) {
+    packageName = packageName.substring(0, indexOfAt);
+  }
+  if (packageName === 'create-vite') {
+    // don't run dev server after installation
+    // https://github.com/vitejs/vite/blob/main/packages/create-vite/src/index.ts#L46
+    templateInfo.args.push('--no-immediate');
+  }
+
+  if (workspaceInfo.isMonorepo) {
+    // don't run git init on monorepo
+    if (packageName === 'create-nuxt') {
+      templateInfo.args.push('--no-gitInit');
+    } else if (packageName === '@tanstack/create-start') {
+      templateInfo.args.push('--no-git');
+    }
+  }
+}
diff --git a/packages/global/src/gen/types.ts b/packages/global/src/gen/types.ts
new file mode 100644
index 0000000000..95540c5992
--- /dev/null
+++ b/packages/global/src/gen/types.ts
@@ -0,0 +1,91 @@
+import type { DownloadPackageManagerResult } from '@voidzero-dev/vite-plus/binding';
+
+export const BuiltinTemplate = {
+  generator: 'vite:generator',
+  monorepo: 'vite:monorepo',
+  application: 'vite:application',
+  library: 'vite:library',
+} as const;
+export type BuiltinTemplate = (typeof BuiltinTemplate)[keyof typeof BuiltinTemplate];
+
+export const TemplateType = {
+  builtin: 'builtin',
+  bingo: 'bingo',
+  remote: 'remote',
+} as const;
+export type TemplateType = (typeof TemplateType)[keyof typeof TemplateType];
+
+export interface TemplateInfo {
+  command: string;
+  args: string[];
+  envs: NodeJS.ProcessEnv;
+  type: TemplateType;
+  // The parent directory of the generated package, only for monorepo
+  // For example, "packages"
+  parentDir?: string;
+  interactive?: boolean;
+}
+
+export interface BuiltinTemplateInfo extends Omit<TemplateInfo, 'parentDir'> {
+  packageName: string;
+  targetDir: string;
+}
+
+export const PackageManager = {
+  pnpm: 'pnpm',
+  npm: 'npm',
+  yarn: 'yarn',
+} as const;
+export type PackageManager = (typeof PackageManager)[keyof typeof PackageManager];
+
+export const DependencyType = {
+  dependencies: 'dependencies',
+  devDependencies: 'devDependencies',
+  peerDependencies: 'peerDependencies',
+  optionalDependencies: 'optionalDependencies',
+} as const;
+export type DependencyType = (typeof DependencyType)[keyof typeof DependencyType];
+
+export interface WorkspaceInfo {
+  rootDir: string;
+  isMonorepo: boolean;
+  // The scope of the monorepo, e.g. @my
+  // This is used to determine the scope of the generated package
+  // For example, if the monorepo scope is @my, then the generated package will be @my/my-package
+  monorepoScope: string;
+  // The patterns of the workspace packages
+  // For example, ["apps/*", "packages/*", "services/*", "tools/*"]
+  workspacePatterns: string[];
+  // The parent directories of the generated package
+  // For example, ["apps", "packages", "services", "tools"]
+  parentDirs: string[];
+  packageManager: PackageManager;
+  packageManagerVersion: string;
+  downloadPackageManager: DownloadPackageManagerResult;
+  packages: WorkspacePackage[];
+}
+
+export interface WorkspaceInfoOptional extends Omit<WorkspaceInfo, 'packageManager' | 'downloadPackageManager'> {
+  packageManager?: PackageManager;
+}
+
+export interface WorkspacePackage {
+  name: string;
+  // The path of the package relative to the workspace root
+  path: string;
+  description?: string;
+  version?: string;
+  isTemplatePackage: boolean;
+}
+
+export interface ViteOptions {
+  directory?: string;
+  interactive: boolean;
+  list: boolean;
+  help: boolean;
+}
+
+export interface ExecutionResult {
+  exitCode: number;
+  projectDir?: string;
+}
diff --git a/packages/global/src/gen/utils.ts b/packages/global/src/gen/utils.ts
new file mode 100644
index 0000000000..347be39ced
--- /dev/null
+++ b/packages/global/src/gen/utils.ts
@@ -0,0 +1,189 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { parse as parseYaml, stringify as stringifyYaml } from '@std/yaml';
+import type { DownloadPackageManagerResult } from '@voidzero-dev/vite-plus/binding';
+import validateNpmPackageName from 'validate-npm-package-name';
+
+// Get the package root directory (packages/global)
+// Built files are in dist/, templates are in templates/
+// So from dist/ we need to go up to the package root
+export const pkgRoot = import.meta.dirname.endsWith('dist')
+  ? path.dirname(import.meta.dirname)
+  : path.join(import.meta.dirname, '../..');
+
+export const templatesDir = path.join(pkgRoot, 'templates');
+
+// Helper functions for file operations
+export function copy(src: string, dest: string) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    copyDir(src, dest);
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+export function copyDir(srcDir: string, destDir: string) {
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const file of fs.readdirSync(srcDir)) {
+    const srcFile = path.resolve(srcDir, file);
+    const destFile = path.resolve(destDir, file);
+    copy(srcFile, destFile);
+  }
+}
+
+export function editFile(file: string, callback: (content: string) => string) {
+  const content = fs.readFileSync(file, 'utf-8');
+  fs.writeFileSync(file, callback(content), 'utf-8');
+}
+
+export function editOrCreateFile(file: string, callback: (content: string) => string) {
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, '', 'utf-8');
+  }
+  editFile(file, callback);
+}
+
+export function readYamlFile<T = Record<string, any>>(file: string): T {
+  const content = fs.readFileSync(file, 'utf-8');
+  return parseYaml(content) as T;
+}
+
+export function editYamlFile<T = Record<string, any>>(file: string, callback: (content: T) => T) {
+  const yaml = readYamlFile<T>(file);
+  const newYaml = callback(yaml);
+  fs.writeFileSync(file, stringifyYaml(newYaml), 'utf-8');
+}
+
+export function editOrCreateYamlFile<T = Record<string, any>>(file: string, callback: (content: T) => T) {
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, '', 'utf-8');
+  }
+  editYamlFile(file, callback);
+}
+
+export function readJsonFile<T = Record<string, any>>(file: string): T {
+  const content = fs.readFileSync(file, 'utf-8');
+  return JSON.parse(content) as T;
+}
+
+export function editJsonFile<T = Record<string, any>>(file: string, callback: (content: T) => T) {
+  const json = readJsonFile<T>(file);
+  const newJson = callback(json);
+  fs.writeFileSync(file, JSON.stringify(newJson, null, 2) + '\n', 'utf-8');
+}
+
+export function isEmpty(path: string) {
+  const files = fs.readdirSync(path);
+  return files.length === 0 || (files.length === 1 && files[0] === '.git');
+}
+
+export function emptyDir(dir: string) {
+  if (!fs.existsSync(dir)) {
+    return;
+  }
+  for (const file of fs.readdirSync(dir)) {
+    if (file === '.git') {
+      continue;
+    }
+    fs.rmSync(path.resolve(dir, file), { recursive: true, force: true });
+  }
+}
+
+/**
+ * Format the target directory into a valid directory name and package name
+ *
+ * Examples:
+ * ```
+ * # invalid target directories
+ * ./ -> { directory: '', packageName: '', error: 'Invalid target directory' }
+ * /foo/bar -> { directory: '', packageName: '', error: 'Absolute path is not allowed' }
+ * @scope/ -> { directory: '', packageName: '', error: 'Invalid target directory' }
+ * ../../foo/bar -> { directory: '', packageName: '', error: 'Invalid target directory' }
+ *
+ * # valid target directories
+ * ./my-package -> { directory: './my-package', packageName: 'my-package' }
+ * ./foo/bar-package -> { directory: './foo/bar-package', packageName: 'bar-package' }
+ * ./foo/bar-package/ -> { directory: './foo/bar-package', packageName: 'bar-package' }
+ * my-package -> { directory: 'my-package', packageName: 'my-package' }
+ * @my-scope/my-package -> { directory: 'my-package', packageName: '@my-scope/my-package' }
+ * foo/@my-scope/my-package -> { directory: 'foo/my-package', packageName: '@scope/my-package' }
+ * ./foo/@my-scope/my-package -> { directory: './foo/my-package', packageName: '@scope/my-package' }
+ * ./foo/bar/@scope/my-package -> { directory: './foo/bar/my-package', packageName: '@scope/my-package' }
+ * ```
+ */
+export function formatTargetDir(input: string): { directory: string; packageName: string; error?: string } {
+  let targetDir = path.normalize(input.trim());
+  const parsed = path.parse(targetDir);
+  if (parsed.root || path.isAbsolute(targetDir)) {
+    return { directory: '', packageName: '', error: 'Absolute path is not allowed' };
+  }
+  if (targetDir.includes('..')) {
+    return { directory: '', packageName: '', error: 'Relative path contains ".." which is not allowed' };
+  }
+  let packageName = parsed.base;
+  const parentName = path.basename(parsed.dir);
+  if (parentName.startsWith('@')) {
+    // skip scope directory
+    // ./@my-scope/my-package -> ./my-package
+    targetDir = path.join(path.dirname(parsed.dir), packageName);
+    packageName = `${parentName}/${packageName}`;
+  }
+  const result = validateNpmPackageName(packageName);
+  if (!result.validForNewPackages) {
+    // invalid package name
+    const message = result.errors?.[0] ?? result.warnings?.[0] ?? 'Invalid package name';
+    return { directory: '', packageName: '', error: `Parsed package name "${packageName}" is invalid: ${message}` };
+  }
+  return { directory: targetDir, packageName };
+}
+
+// Get the project directory from the project name
+// If the project name is a scoped package name, return the second part
+// Otherwise, return the project name
+export function getProjectDirFromPackageName(packageName: string) {
+  if (packageName.startsWith('@')) {
+    return packageName.split('/')[1];
+  }
+  return packageName;
+}
+
+export function getScopeFromPackageName(packageName: string) {
+  if (packageName.startsWith('@')) {
+    return packageName.split('/')[0];
+  }
+  return '';
+}
+
+export const RENAME_FILES: Record<string, string> = {
+  _gitignore: '.gitignore',
+  '_npmrc': '.npmrc',
+  '_yarnrc.yml': '.yarnrc.yml',
+};
+
+export function renameFiles(projectDir: string) {
+  for (const [from, to] of Object.entries(RENAME_FILES)) {
+    const fromPath = path.join(projectDir, from);
+    if (fs.existsSync(fromPath)) {
+      fs.renameSync(fromPath, path.join(projectDir, to));
+    }
+  }
+}
+
+export function setPackageManager(projectDir: string, downloadPackageManager: DownloadPackageManagerResult) {
+  // set package manager
+  editJsonFile<{ packageManager?: string }>(path.join(projectDir, 'package.json'), (pkg) => {
+    if (!pkg.packageManager) {
+      pkg.packageManager = `${downloadPackageManager.name}@${downloadPackageManager.version}`;
+    }
+    return pkg;
+  });
+}
+
+export function setPackageName(projectDir: string, packageName: string) {
+  editJsonFile<{ name?: string }>(path.join(projectDir, 'package.json'), (pkg) => {
+    pkg.name = packageName;
+    return pkg;
+  });
+}
diff --git a/packages/global/src/gen/workspace.ts b/packages/global/src/gen/workspace.ts
new file mode 100644
index 0000000000..3df24617c3
--- /dev/null
+++ b/packages/global/src/gen/workspace.ts
@@ -0,0 +1,192 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { globSync } from 'glob';
+import { minimatch } from 'minimatch';
+
+import { detectWorkspace as detectWorkspaceBinding } from '@voidzero-dev/vite-plus/binding';
+
+import {
+  DependencyType,
+  PackageManager,
+  type WorkspaceInfo,
+  type WorkspaceInfoOptional,
+  type WorkspacePackage,
+} from './types.ts';
+import { getScopeFromPackageName } from './utils.ts';
+import { editJsonFile, editOrCreateYamlFile, readJsonFile, readYamlFile } from './utils.ts';
+
+export function findPackageJsonFilesFromPatterns(patterns: string[], cwd: string): string[] {
+  if (patterns.length === 0) {
+    return [];
+  }
+  return globSync(patterns.map(pattern => `${pattern}/package.json`), { absolute: true, cwd });
+}
+
+// Detect if we're in a monorepo and get workspace info
+export async function detectWorkspace(rootDir: string): Promise<WorkspaceInfoOptional> {
+  const bindingResult = await detectWorkspaceBinding(rootDir);
+  const result: WorkspaceInfoOptional = {
+    rootDir,
+    packageManager: undefined,
+    packageManagerVersion: 'latest',
+    isMonorepo: false,
+    monorepoScope: '',
+    workspacePatterns: [],
+    parentDirs: [],
+    packages: [],
+  };
+  if (bindingResult.packageManagerName) {
+    result.packageManager = bindingResult.packageManagerName as PackageManager;
+  }
+  if (bindingResult.packageManagerVersion) {
+    result.packageManagerVersion = bindingResult.packageManagerVersion;
+  }
+  if (bindingResult.isMonorepo) {
+    result.isMonorepo = bindingResult.isMonorepo;
+  }
+  if (bindingResult.root) {
+    // automatically correct the root directory from cwd
+    result.rootDir = bindingResult.root;
+  }
+
+  // Extract parent directories from workspace patterns
+  if (result.isMonorepo) {
+    const pnpmWorkspaceFile = path.join(result.rootDir, 'pnpm-workspace.yaml');
+    const packageJsonFile = path.join(result.rootDir, 'package.json');
+    if (fs.existsSync(pnpmWorkspaceFile)) {
+      const workspaceConfig = readYamlFile<{ packages?: string[] }>(pnpmWorkspaceFile);
+      if (Array.isArray(workspaceConfig.packages)) {
+        result.workspacePatterns = workspaceConfig.packages;
+      }
+    } else if (fs.existsSync(packageJsonFile)) {
+      // Check for npm/yarn workspace
+      const pkg = readJsonFile<{ workspaces?: string[] }>(packageJsonFile);
+      if (Array.isArray(pkg.workspaces)) {
+        result.workspacePatterns = pkg.workspaces;
+      }
+    }
+
+    const dirs = new Set<string>();
+    for (const pattern of result.workspacePatterns) {
+      // Extract directory from patterns like "apps/*", "packages/*", "foo/bar/*", "website", etc
+      if (!pattern.endsWith('*')) {
+        continue;
+      }
+      // Extract the directory name, ignore the wildcard
+      const dir = pattern.replace(/\/\*{1,2}$/, '');
+      if (dir) {
+        dirs.add(dir);
+      }
+    }
+    result.parentDirs = Array.from(dirs).sort();
+
+    // Extract the scope from the package.json
+    const pkg = readJsonFile<{ name?: string }>(packageJsonFile);
+    if (pkg.name) {
+      result.monorepoScope = getScopeFromPackageName(pkg.name);
+    }
+    result.packages = discoverWorkspacePackages(result.workspacePatterns, result.rootDir);
+  }
+
+  return result;
+}
+
+// Discover all workspace packages
+export function discoverWorkspacePackages(workspacePatterns: string[], rootDir: string): WorkspacePackage[] {
+  const packages: WorkspacePackage[] = [];
+
+  if (workspacePatterns.length === 0) {
+    return packages;
+  }
+
+  // Find all package.json files in the workspace
+  const packageJsonRelativePaths = globSync(workspacePatterns.map(pattern => `${pattern}/package.json`), {
+    absolute: false,
+    cwd: rootDir,
+  });
+  for (const packageJsonRelativePath of packageJsonRelativePaths) {
+    const packageJsonPath = path.join(rootDir, packageJsonRelativePath);
+    const pkg = readJsonFile<
+      {
+        name?: string;
+        description?: string;
+        version?: string;
+        dependencies?: Record<string, string>;
+        keywords?: string[];
+      }
+    >(packageJsonPath);
+    if (!pkg.name) {
+      continue;
+    }
+    const isTemplatePackage = pkg.keywords?.includes('vite-plus-template') ||
+      pkg.keywords?.includes('bingo-template') || !!pkg.dependencies?.bingo;
+    packages.push({
+      name: pkg.name,
+      path: path.dirname(packageJsonRelativePath),
+      description: pkg.description,
+      version: pkg.version,
+      isTemplatePackage,
+    });
+  }
+
+  return packages;
+}
+
+// Update package.json with workspace dependencies
+export function updatePackageJsonWithDeps(
+  rootDir: string,
+  projectDir: string,
+  dependencies: string[],
+  dependencyType: DependencyType,
+) {
+  const packageJsonPath = path.join(rootDir, projectDir, 'package.json');
+  editJsonFile<{ [key in DependencyType]?: Record<string, string> }>(packageJsonPath, (pkg) => {
+    if (!pkg[dependencyType]) {
+      pkg[dependencyType] = {};
+    }
+    for (const dep of dependencies) {
+      pkg[dependencyType][dep] = 'workspace:*';
+    }
+    return pkg;
+  });
+}
+
+// Update workspace configuration to include new project
+export function updateWorkspaceConfig(
+  projectPath: string,
+  workspaceInfo: WorkspaceInfo,
+) {
+  // Check if project path matches any workspace pattern
+  for (const pattern of workspaceInfo.workspacePatterns) {
+    if (minimatch(projectPath, pattern)) {
+      return;
+    }
+  }
+
+  // Derive pattern from project path (e.g., "packages/my-app" -> "packages/*", "website" -> "website", "foo/bar/app" -> "foo/bar/*")
+  let pattern = path.dirname(projectPath);
+  if (!pattern) {
+    // "website" -> "website"
+    pattern = projectPath;
+  } else {
+    // "foo/bar/app" -> "foo/bar/*"
+    pattern = `${pattern}/*`;
+  }
+
+  if (workspaceInfo.packageManager === PackageManager.pnpm) {
+    editOrCreateYamlFile<{ packages?: string[] }>(
+      path.join(workspaceInfo.rootDir, 'pnpm-workspace.yaml'),
+      (workspaceConfig) => {
+        workspaceConfig.packages = [...(workspaceConfig.packages || []), pattern];
+        return workspaceConfig;
+      },
+    );
+  } else {
+    // Update package.json workspaces
+    editJsonFile<{ workspaces?: string[] }>(path.join(workspaceInfo.rootDir, 'package.json'), (pkg) => {
+      pkg.workspaces = [...(pkg.workspaces || []), pattern];
+      return pkg;
+    });
+  }
+}
diff --git a/packages/global/src/index.ts b/packages/global/src/index.ts
index 2cce75cbf3..2cd08e85bc 100644
--- a/packages/global/src/index.ts
+++ b/packages/global/src/index.ts
@@ -1,8 +1,9 @@
-// Parse command line arguments to intercept 'new' command
+// Parse command line arguments to intercept 'new' and 'gen' commands
 const args = process.argv.slice(2);
 
-if (args[0] === 'new') {
-  import('./new.ts');
+const command = args[0];
+if (command === 'gen' || command === 'g' || command === 'generate' || command === 'new') {
+  import('./gen.ts');
 } else {
   // Delegate all other commands to vite-plus CLI
   import('@voidzero-dev/vite-plus/bin');
diff --git a/packages/global/src/new.ts b/packages/global/src/new.ts
deleted file mode 100644
index 654a63bbf7..0000000000
--- a/packages/global/src/new.ts
+++ /dev/null
@@ -1,1017 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { scheduler } from 'node:timers/promises';
-import { fileURLToPath } from 'node:url';
-
-import * as prompts from '@clack/prompts';
-import spawn from 'cross-spawn';
-import mri from 'mri';
-import colors from 'picocolors';
-
-// refactor from https://github.com/vitejs/vite/blob/main/packages/create-vite/src/index.ts
-
-const {
-  blue,
-  blueBright,
-  cyan,
-  green,
-  greenBright,
-  gray,
-  magenta,
-  red,
-  redBright,
-  reset,
-  yellow,
-} = colors;
-
-const argv = mri<{
-  monorepo?: boolean;
-  template?: string;
-  help?: boolean;
-  overwrite?: boolean;
-  app?: boolean;
-  lib?: boolean;
-  git?: boolean;
-  pm?: string;
-}>(process.argv.slice(3), {
-  alias: { h: 'help', t: 'template' },
-  boolean: ['help', 'overwrite', 'monorepo', 'app', 'lib', 'git'],
-  string: ['template', 'pm'],
-});
-const cwd = process.cwd();
-const pkgRoot = path.dirname(import.meta.dirname);
-
-// prettier-ignore
-const helpMessage = `\
-Usage: vite new [OPTION]... [DIRECTORY]
-
-Create a new Vite+ project in TypeScript.
-With no arguments, start the CLI in interactive mode.
-
-Options:
-  --monorepo                 create a monorepo project
-  --app                      add an app to existing monorepo, e.g.: vite new --app apps/website
-  --lib                      add a library to existing monorepo, e.g.: vite new --lib packages/utils
-  -t, --template NAME        use a specific template
-  --pm NAME                  use a specific package manager, e.g.: vite new --pm pnpm
-  --git                      init git repository
-  --overwrite                overwrite existing files
-
-Available templates:
-${yellow('vanilla-ts     vanilla')}
-${green('vue-ts         vue')}
-${cyan('react-ts       react')}
-${cyan('react-swc-ts   react-swc')}
-${magenta('preact-ts      preact')}
-${redBright('lit-ts         lit')}
-${red('svelte-ts      svelte')}
-${blue('solid-ts       solid')}
-${blueBright('qwik-ts        qwik')}`;
-
-type ColorFunc = (str: string | number) => string;
-type Framework = {
-  name: string;
-  display: string;
-  color: ColorFunc;
-  variants: FrameworkVariant[];
-};
-type FrameworkVariant = {
-  name: string;
-  display: string;
-  color: ColorFunc;
-  customCommand?: string;
-};
-
-const FRAMEWORKS: Framework[] = [
-  {
-    name: 'vanilla',
-    display: 'Vanilla',
-    color: yellow,
-    variants: [
-      {
-        name: 'vanilla-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'vanilla',
-        display: 'JavaScript',
-        color: yellow,
-      },
-    ],
-  },
-  {
-    name: 'vue',
-    display: 'Vue',
-    color: green,
-    variants: [
-      {
-        name: 'vue-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'vue',
-        display: 'JavaScript',
-        color: yellow,
-      },
-      {
-        name: 'custom-create-vue',
-        display: 'Official Vue Starter ↗',
-        color: green,
-        customCommand: 'npm create vue@latest TARGET_DIR',
-      },
-      {
-        name: 'custom-nuxt',
-        display: 'Nuxt ↗',
-        color: greenBright,
-        customCommand: 'npm exec nuxi init TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'react',
-    display: 'React',
-    color: cyan,
-    variants: [
-      {
-        name: 'react-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'react-swc-ts',
-        display: 'TypeScript + SWC',
-        color: blue,
-      },
-      {
-        name: 'react',
-        display: 'JavaScript',
-        color: yellow,
-      },
-      {
-        name: 'react-swc',
-        display: 'JavaScript + SWC',
-        color: yellow,
-      },
-      {
-        name: 'custom-react-router',
-        display: 'React Router v7 ↗',
-        color: cyan,
-        customCommand: 'npm create react-router@latest TARGET_DIR',
-      },
-      {
-        name: 'custom-tanstack-router-react',
-        display: 'TanStack Router ↗',
-        color: cyan,
-        customCommand: 'npm create -- tsrouter-app@latest TARGET_DIR --framework React --interactive',
-      },
-      {
-        name: 'redwoodsdk-standard',
-        display: 'RedwoodSDK ↗',
-        color: red,
-        customCommand: 'npm exec degit redwoodjs/sdk/starters/standard TARGET_DIR',
-      },
-      {
-        name: 'rsc',
-        display: 'RSC ↗',
-        color: magenta,
-        customCommand: 'npm exec degit vitejs/vite-plugin-react/packages/plugin-rsc/examples/starter TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'preact',
-    display: 'Preact',
-    color: magenta,
-    variants: [
-      {
-        name: 'preact-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'preact',
-        display: 'JavaScript',
-        color: yellow,
-      },
-      {
-        name: 'custom-create-preact',
-        display: 'Official Preact Starter ↗',
-        color: magenta,
-        customCommand: 'npm create preact@latest TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'lit',
-    display: 'Lit',
-    color: redBright,
-    variants: [
-      {
-        name: 'lit-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'lit',
-        display: 'JavaScript',
-        color: yellow,
-      },
-    ],
-  },
-  {
-    name: 'svelte',
-    display: 'Svelte',
-    color: red,
-    variants: [
-      {
-        name: 'svelte-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'svelte',
-        display: 'JavaScript',
-        color: yellow,
-      },
-      {
-        name: 'custom-svelte-kit',
-        display: 'SvelteKit ↗',
-        color: red,
-        customCommand: 'npm exec sv create TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'solid',
-    display: 'Solid',
-    color: blue,
-    variants: [
-      {
-        name: 'solid-ts',
-        display: 'TypeScript',
-        color: blue,
-      },
-      {
-        name: 'solid',
-        display: 'JavaScript',
-        color: yellow,
-      },
-      {
-        name: 'custom-tanstack-router-solid',
-        display: 'TanStack Router ↗',
-        color: cyan,
-        customCommand: 'npm create -- tsrouter-app@latest TARGET_DIR --framework Solid --interactive',
-      },
-    ],
-  },
-  {
-    name: 'qwik',
-    display: 'Qwik',
-    color: blueBright,
-    variants: [
-      {
-        name: 'qwik-ts',
-        display: 'TypeScript',
-        color: blueBright,
-      },
-      {
-        name: 'qwik',
-        display: 'JavaScript',
-        color: yellow,
-      },
-      {
-        name: 'custom-qwik-city',
-        display: 'QwikCity ↗',
-        color: blueBright,
-        customCommand: 'npm create qwik@latest basic TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'angular',
-    display: 'Angular',
-    color: red,
-    variants: [
-      {
-        name: 'custom-angular',
-        display: 'Angular ↗',
-        color: red,
-        customCommand: 'npm exec @angular/cli@latest new TARGET_DIR',
-      },
-      {
-        name: 'custom-analog',
-        display: 'Analog ↗',
-        color: yellow,
-        customCommand: 'npm create analog@latest TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'marko',
-    display: 'Marko',
-    color: magenta,
-    variants: [
-      {
-        name: 'marko-run',
-        display: 'Marko Run ↗',
-        color: magenta,
-        customCommand: 'npm create -- marko@latest --name TARGET_DIR',
-      },
-    ],
-  },
-  {
-    name: 'others',
-    display: 'Others',
-    color: reset,
-    variants: [
-      {
-        name: 'create-vite-extra',
-        display: 'Extra Vite Starters ↗',
-        color: reset,
-        customCommand: 'npm create vite-extra@latest TARGET_DIR',
-      },
-      {
-        name: 'create-electron-vite',
-        display: 'Electron ↗',
-        color: reset,
-        customCommand: 'npm create electron-vite@latest TARGET_DIR',
-      },
-    ],
-  },
-];
-
-const TEMPLATES = FRAMEWORKS.map((f) => f.variants.map((v) => v.name)).reduce(
-  (a, b) => a.concat(b),
-  [],
-);
-
-// refactor from https://github.com/Gugustinette/create-tsdown/blob/main/src/options/index.ts#L51
-type LibraryTemplate = {
-  name: string;
-  display: string;
-};
-
-const LIBRARY_TEMPLATES: LibraryTemplate[] = [
-  {
-    name: 'default',
-    display: 'Default',
-  },
-  {
-    name: 'minimal',
-    display: 'Minimal',
-  },
-  {
-    name: 'react',
-    display: 'React',
-  },
-  {
-    name: 'vue',
-    display: 'Vue',
-  },
-  {
-    name: 'solid',
-    display: 'Solid',
-  },
-];
-
-const defaultTargetDir = 'vite-plus-project';
-
-async function init() {
-  const argTargetDir = argv._[0]
-    ? formatTargetDir(String(argv._[0]))
-    : undefined;
-  const argTemplate = argv.template;
-  const argOverwrite = argv.overwrite;
-  const argGit = argv.git;
-  let argPackageManager = argv.pm;
-  let argCreateMonorepo = argv.monorepo;
-  const argCreateApp = argv.app;
-  const argCreateLib = argv.lib;
-  const isCreateAppOrLib = argCreateApp || argCreateLib;
-
-  const help = argv.help;
-  if (help) {
-    console.log(helpMessage);
-    return;
-  }
-
-  const cancel = () => prompts.cancel('Operation cancelled');
-
-  const logo = fs.readFileSync(path.join(pkgRoot, 'templates/vite-plus-logo.txt'), 'utf-8');
-  console.log(blueBright(logo));
-  prompts.intro(`${blueBright('Vite+')} - The Unified Toolchain for the Web`);
-
-  // --app and --lib should inside monorepo
-  if (isCreateAppOrLib) {
-    const monorepoRoot = findMonorepoRoot();
-    if (!monorepoRoot) {
-      prompts.log.error('Not in a monorepo. The --app and --lib flags can only be used inside a monorepo.');
-      prompts.outro('Run `vite new` to create a monorepo first.');
-      return;
-    }
-  }
-
-  // 0. Handle monorepo
-  if (typeof argCreateMonorepo !== 'boolean' && !isCreateAppOrLib) {
-    const createMonorepo = await prompts.confirm({
-      message: 'Monorepo:',
-      initialValue: true,
-    });
-    if (prompts.isCancel(createMonorepo)) return cancel();
-    argCreateMonorepo = createMonorepo;
-  }
-
-  // 1. Get project name and target dir
-  let targetDir = argTargetDir;
-  if (!targetDir) {
-    const projectName = await prompts.text({
-      message: 'Project name:',
-      defaultValue: defaultTargetDir,
-      placeholder: defaultTargetDir,
-      validate: (value) => {
-        return value.length === 0 || formatTargetDir(value).length > 0
-          ? undefined
-          : 'Invalid project name';
-      },
-    });
-    if (prompts.isCancel(projectName)) return cancel();
-    targetDir = formatTargetDir(projectName);
-  }
-
-  // 2. Handle directory if exist and not empty
-  if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
-    const overwrite = argOverwrite
-      ? 'yes'
-      : await prompts.select({
-        message: (targetDir === '.'
-          ? 'Current directory'
-          : `Target directory "${targetDir}"`) +
-          ` is not empty. Please choose how to proceed:`,
-        options: [
-          {
-            label: 'Cancel operation',
-            value: 'no',
-          },
-          {
-            label: 'Remove existing files and continue',
-            value: 'yes',
-          },
-          {
-            label: 'Ignore files and continue',
-            value: 'ignore',
-          },
-        ],
-      });
-    if (prompts.isCancel(overwrite)) return cancel();
-    switch (overwrite) {
-      case 'yes':
-        emptyDir(targetDir);
-        break;
-      case 'no':
-        cancel();
-        return;
-    }
-  }
-
-  // 3. Get package name
-  let packageName = path.basename(path.resolve(targetDir));
-  if (!isValidPackageName(packageName)) {
-    const packageNameResult = await prompts.text({
-      message: 'Package name:',
-      defaultValue: toValidPackageName(packageName),
-      placeholder: toValidPackageName(packageName),
-      validate(dir) {
-        if (!isValidPackageName(dir)) {
-          return 'Invalid package.json name';
-        }
-      },
-    });
-    if (prompts.isCancel(packageNameResult)) return cancel();
-    packageName = packageNameResult;
-  }
-
-  const rawTargetDir = targetDir;
-
-  // 4. Choose a framework and variant
-  let template = argTemplate;
-  let hasInvalidArgTemplate = false;
-  if (argTemplate) {
-    if (argCreateLib && !LIBRARY_TEMPLATES.some((t) => t.name === argTemplate)) {
-      template = undefined;
-      hasInvalidArgTemplate = true;
-    } else if (argCreateApp && !TEMPLATES.includes(argTemplate)) {
-      template = undefined;
-      hasInvalidArgTemplate = true;
-    }
-  }
-  if (!template) {
-    if (argCreateLib) {
-      const libraryTemplate = await prompts.select({
-        message: 'Select a library template:',
-        options: LIBRARY_TEMPLATES.map((template) => {
-          return {
-            label: template.display || template.name,
-            value: template.name,
-          };
-        }),
-      });
-      if (prompts.isCancel(libraryTemplate)) return cancel();
-      template = libraryTemplate;
-    } else {
-      const framework = await prompts.select({
-        message: hasInvalidArgTemplate
-          ? `"${argTemplate}" isn't a valid template. Please choose from below: `
-          : 'Select a framework:',
-        options: FRAMEWORKS.map((framework) => {
-          const frameworkColor = framework.color;
-          return {
-            label: frameworkColor(framework.display || framework.name),
-            value: framework,
-          };
-        }),
-      });
-      if (prompts.isCancel(framework)) return cancel();
-
-      const variant = await prompts.select({
-        message: 'Select a variant:',
-        options: framework.variants.map((variant) => {
-          const variantColor = variant.color;
-          return {
-            label: variantColor(variant.display || variant.name),
-            value: variant.name,
-          };
-        }),
-      });
-      if (prompts.isCancel(variant)) return cancel();
-
-      template = variant;
-    }
-  }
-
-  let selectedPackageManager = argPackageManager ?? 'pnpm';
-  if (!isCreateAppOrLib && !argPackageManager) {
-    // select a package manager
-    const packageManager = await prompts.select({
-      message: 'Which package manager would you like to use?',
-      options: [
-        { label: 'pnpm', value: 'pnpm', hint: 'recommended' },
-        { label: 'yarn', value: 'yarn' },
-        { label: 'npm', value: 'npm' },
-      ],
-      initialValue: selectedPackageManager,
-    });
-    if (prompts.isCancel(packageManager)) return cancel();
-
-    selectedPackageManager = packageManager;
-  }
-
-  if (argCreateMonorepo) {
-    // init a monorepo
-    await initMonorepo(path.join(cwd, targetDir), selectedPackageManager);
-
-    // create a default app: apps/website
-    targetDir = path.join(targetDir, 'apps/website');
-  }
-
-  const root = path.join(cwd, targetDir);
-  const rawRoot = path.join(cwd, rawTargetDir);
-  const cdProjectName = path.relative(cwd, rawRoot);
-  const appOrLibName = path.relative(cwd, root);
-  const isMonorepo = argCreateMonorepo ?? isCreateAppOrLib;
-
-  // 5. Create project
-  if (argCreateLib) {
-    prompts.log.step(`Scaffolding library with ${green(template)} in ${appOrLibName}...`);
-    // use create-tsdown to create a library project
-    const createTsdownBin = fileURLToPath(import.meta.resolve('create-tsdown/run'));
-    const createTsdownArgs = [
-      createTsdownBin,
-      '--overwrite',
-      '--template',
-      template,
-      '--name',
-      targetDir,
-    ];
-    const command = `create-tsdown ${createTsdownArgs.slice(1).join(' ')}`;
-    const spinner = prompts.spinner();
-    spinner.start(gray(`$ ${command}`));
-    const { status, stderr, stdout } = await runCommand('node', createTsdownArgs, {
-      cwd,
-    });
-    if (status && status > 0) {
-      prompts.log.info(stdout.toString());
-      prompts.log.error(stderr.toString());
-      process.exit(status);
-    }
-    spinner.stop(gray(`$ ${command} succeeded`));
-    // fix "Duplicated package name: react-components-starter or tsdown-starter" name to user input
-    editFile(path.join(root, 'package.json'), (content) => {
-      const pkg = JSON.parse(content);
-      pkg.name = path.basename(root);
-      return JSON.stringify(pkg, null, 2) + '\n';
-    });
-  } else {
-    prompts.log.step(`Scaffolding project with ${green(template)} in ${appOrLibName}...`);
-    // use create-vite to create a app project
-    const createViteBin = fileURLToPath(import.meta.resolve('create-vite/index.js'));
-    const { customCommand } = FRAMEWORKS.flatMap((f) => f.variants).find((v) => v.name === template) ?? {};
-    if (customCommand) {
-      // print the custom command
-      const cwd = path.dirname(root);
-      fs.mkdirSync(cwd, { recursive: true });
-      const appName = isMonorepo ? path.basename(targetDir) : targetDir;
-      prompts.log.info(customCommand.replace('TARGET_DIR', appName) + ' ...');
-      const createViteArgs = [
-        createViteBin,
-        '--overwrite',
-        '--template',
-        template,
-        appName,
-      ];
-      const command = `create-vite ${createViteArgs.slice(1).join(' ')}`;
-      prompts.log.info(gray(`$ ${command} ...`));
-      const { status } = spawn.sync('node', createViteArgs, {
-        stdio: 'inherit',
-        cwd,
-      });
-      if (status && status > 0) {
-        process.exit(status);
-      }
-    } else {
-      const createViteArgs = [
-        createViteBin,
-        '--overwrite',
-        '--template',
-        template,
-        targetDir,
-      ];
-      const { status, stderr, stdout } = spawn.sync('node', createViteArgs, {
-        stdio: 'pipe',
-      });
-      if (status && status > 0) {
-        prompts.log.info(stdout.toString());
-        prompts.log.error(stderr.toString());
-        process.exit(status);
-      }
-    }
-  }
-
-  await fixPackageJsonForVitePlus(root, selectedPackageManager, isMonorepo);
-
-  // install dependencies on non-CI environment
-  if (!process.env.CI) {
-    const spinner = prompts.spinner();
-    spinner.start('Installing dependencies...');
-    const { status, stderr, stdout } = await runCommand('vite', ['install'], {
-      cwd: rawRoot,
-    });
-    if (status && status > 0) {
-      prompts.log.info(stdout.toString());
-      prompts.log.error(stderr.toString());
-      process.exit(status);
-    }
-    spinner.stop('Dependencies installed');
-  }
-
-  // first init, ask user to init git
-  if (!isCreateAppOrLib) {
-    const initGit = typeof argGit === 'boolean' ? argGit : await prompts.confirm({
-      message: `Initialize git repository? (git init ${cdProjectName})`,
-      initialValue: true,
-    });
-    if (prompts.isCancel(initGit)) return cancel();
-    if (initGit) {
-      const { status, stderr, stdout } = spawn.sync('git', ['init', cdProjectName], {
-        stdio: 'pipe',
-      });
-      if (status && status > 0) {
-        prompts.log.info(stdout.toString());
-        prompts.log.error(stderr.toString());
-      }
-    }
-  }
-
-  let doneMessage = '';
-  doneMessage += `Done. Now run:\n`;
-  if (rawRoot !== cwd) {
-    doneMessage += green(`\n   cd ${cdProjectName.includes(' ') ? `"${cdProjectName}"` : cdProjectName}`);
-  }
-  doneMessage += green(`\n   vite run ready`);
-  doneMessage += green(`\n   vite run dev`);
-
-  if (argCreateMonorepo) {
-    doneMessage += `\n\n   To add new packages to your monorepo:\n`;
-    doneMessage += `\n   vite new --app apps/my-app`;
-    doneMessage += `\n   vite new --lib packages/my-lib`;
-  }
-  prompts.outro(doneMessage);
-}
-
-function formatTargetDir(targetDir: string) {
-  return targetDir.trim().replace(/\/+$/g, '');
-}
-
-function copy(src: string, dest: string) {
-  const stat = fs.statSync(src);
-  if (stat.isDirectory()) {
-    copyDir(src, dest);
-  } else {
-    fs.copyFileSync(src, dest);
-  }
-}
-
-function isValidPackageName(projectName: string) {
-  return /^(?:@[a-z\d\-*~][a-z\d\-*._~]*\/)?[a-z\d\-~][a-z\d\-._~]*$/.test(
-    projectName,
-  );
-}
-
-function toValidPackageName(projectName: string) {
-  return projectName
-    .trim()
-    .toLowerCase()
-    .replace(/\s+/g, '-')
-    .replace(/^[._]/, '')
-    .replace(/[^a-z\d\-~]+/g, '-');
-}
-
-function copyDir(srcDir: string, destDir: string) {
-  fs.mkdirSync(destDir, { recursive: true });
-  for (const file of fs.readdirSync(srcDir)) {
-    const srcFile = path.resolve(srcDir, file);
-    const destFile = path.resolve(destDir, file);
-    copy(srcFile, destFile);
-  }
-}
-
-function isEmpty(path: string) {
-  const files = fs.readdirSync(path);
-  return files.length === 0 || (files.length === 1 && files[0] === '.git');
-}
-
-function emptyDir(dir: string) {
-  if (!fs.existsSync(dir)) {
-    return;
-  }
-  for (const file of fs.readdirSync(dir)) {
-    if (file === '.git') {
-      continue;
-    }
-    fs.rmSync(path.resolve(dir, file), { recursive: true, force: true });
-  }
-}
-
-function editFile(file: string, callback: (content: string) => string) {
-  const content = fs.readFileSync(file, 'utf-8');
-  fs.writeFileSync(file, callback(content), 'utf-8');
-}
-
-async function initMonorepo(rootProjectDir: string, packageManager: string) {
-  const templateDir = path.resolve(
-    pkgRoot,
-    'templates/monorepo',
-  );
-  copyDir(templateDir, rootProjectDir);
-  renameFiles(rootProjectDir);
-  if (packageManager === 'pnpm') {
-    // remove workspaces field
-    editFile(path.join(rootProjectDir, 'package.json'), (content) => {
-      const pkg = JSON.parse(content);
-      pkg.workspaces = undefined;
-      // remove resolutions field
-      pkg.resolutions = undefined;
-      return JSON.stringify(pkg, null, 2) + '\n';
-    });
-    fs.unlinkSync(path.join(rootProjectDir, '.yarnrc.yml'));
-  } else if (packageManager === 'yarn') {
-    // remove pnpm field
-    editFile(path.join(rootProjectDir, 'package.json'), (content) => {
-      const pkg = JSON.parse(content);
-      pkg.pnpm = undefined;
-      return JSON.stringify(pkg, null, 2) + '\n';
-    });
-    fs.unlinkSync(path.join(rootProjectDir, 'pnpm-workspace.yaml'));
-  } else {
-    // npm
-    // remove pnpm field
-    editFile(path.join(rootProjectDir, 'package.json'), (content) => {
-      const pkg = JSON.parse(content);
-      pkg.pnpm = undefined;
-      return JSON.stringify(pkg, null, 2) + '\n';
-    });
-    fs.unlinkSync(path.join(rootProjectDir, 'pnpm-workspace.yaml'));
-    fs.unlinkSync(path.join(rootProjectDir, '.yarnrc.yml'));
-  }
-
-  await setPackageManager(rootProjectDir, packageManager);
-}
-
-const RENAME_FILES: Record<string, string> = {
-  _gitignore: '.gitignore',
-  _npmrc: '.npmrc',
-  '_yarnrc.yml': '.yarnrc.yml',
-};
-
-function renameFiles(projectDir: string) {
-  for (const [from, to] of Object.entries(RENAME_FILES)) {
-    fs.renameSync(path.join(projectDir, from), path.join(projectDir, to));
-  }
-}
-
-async function fixPackageJsonForVitePlus(projectDir: string, selectedPackageManager: string, isMonorepo?: boolean) {
-  editFile(path.join(projectDir, 'package.json'), (content) => {
-    const pkg = JSON.parse(content);
-
-    // force to use the latest vite-plus instead of vite
-    if (isMonorepo) {
-      // change deps version to catalog
-      const names = ['@types/node', 'bumpp', 'happy-dom', 'vitest', 'typescript', 'tsdown', 'vite'];
-      for (const name of names) {
-        if (pkg.devDependencies?.[name]) {
-          pkg.devDependencies[name] = `catalog:`;
-        }
-      }
-    } else {
-      const viteVersion = 'npm:@voidzero-dev/vite-plus@latest';
-      pkg.devDependencies['vite'] = viteVersion;
-      if (selectedPackageManager === 'pnpm') {
-        pkg.pnpm = {
-          ...pkg.pnpm,
-          overrides: {
-            ...pkg.pnpm?.overrides,
-            vite: viteVersion,
-          },
-          peerDependencyRules: {
-            ...pkg.pnpm?.peerDependencyRules,
-            allowAny: [
-              ...pkg.pnpm?.peerDependencyRules?.allowAny ?? [],
-              'vite',
-            ],
-          },
-        };
-      } else {
-        pkg.resolutions = {
-          ...pkg.resolutions,
-          vite: viteVersion,
-        };
-      }
-    }
-    // fix vite dev command
-    if (pkg.scripts?.dev === 'vite') {
-      pkg.scripts.dev = 'vite dev';
-    }
-    // fix tsdown build and dev command
-    if (pkg.scripts?.build === 'tsdown') {
-      pkg.scripts.build = 'vite lib';
-    }
-    if (pkg.scripts?.dev === 'tsdown --watch') {
-      pkg.scripts.dev = 'vite lib --watch';
-    }
-    if (pkg.scripts?.test === 'vitest' || pkg.scripts?.test === 'vitest run') {
-      pkg.scripts.test = 'vite test';
-    }
-    // try to add ready script
-    if (!pkg.scripts?.ready) {
-      pkg.scripts.ready = 'vite fmt && vite lint --type-aware && vite run build && vite test --passWithNoTests';
-    }
-    // fix empty pkg.name
-    if (!pkg.name) {
-      pkg.name = path.basename(projectDir);
-    }
-    return JSON.stringify(pkg, null, 2) + '\n';
-  });
-
-  if (isMonorepo) {
-    // remove .github, .vscode directories
-    fs.rmSync(path.join(projectDir, '.github'), { recursive: true, force: true });
-    fs.rmSync(path.join(projectDir, '.vscode'), { recursive: true, force: true });
-  } else {
-    await setPackageManager(projectDir, selectedPackageManager);
-    // copy .npmrc file to install vite-plus
-    if (selectedPackageManager === 'yarn') {
-      copy(path.join(pkgRoot, 'templates/config/_yarnrc.yml'), path.join(projectDir, '.yarnrc.yml'));
-    } else {
-      copy(path.join(pkgRoot, 'templates/config/_npmrc'), path.join(projectDir, '.npmrc'));
-    }
-  }
-
-  // remove package-lock.json when package manager is not npm
-  if (selectedPackageManager !== 'npm') {
-    fs.rmSync(path.join(projectDir, 'package-lock.json'), { force: true });
-  }
-}
-
-async function setPackageManager(projectDir: string, packageManager: string) {
-  // Fixed fallback versions for each package manager
-  const FALLBACK_VERSIONS: Record<string, string> = {
-    pnpm: '10.17.0',
-    yarn: '4.10.2',
-    npm: '11.6.0',
-  };
-
-  let version: string;
-  const name = packageManager === 'yarn' ? '@yarnpkg/cli-dist' : packageManager;
-
-  // Try to fetch with retries
-  let retries = 3;
-  let lastError: Error | null = null;
-
-  while (retries > 0) {
-    try {
-      const response = await fetch(`https://registry.npmjs.org/${name}/latest`);
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch latest version for package "${name}" (network request failure). HTTP ${response.status}: ${response.statusText}`,
-        );
-      }
-      const pkgInfo = (await response.json()) as { version: string };
-      version = pkgInfo.version;
-      break; // Success, exit retry loop
-    } catch (err) {
-      lastError = err as Error;
-      retries--;
-      if (retries > 0) {
-        // Wait a bit before retrying (exponential backoff)
-        await scheduler.wait((4 - retries) * 500);
-      }
-    }
-  }
-
-  // If all retries failed, use fallback version
-  if (retries === 0) {
-    version = FALLBACK_VERSIONS[packageManager];
-    prompts.log.warn(`Failed to fetch latest ${packageManager} version after 3 retries: ${lastError?.message}`);
-    prompts.log.warn(
-      `Could not retrieve the latest version of ${packageManager}. Using fallback version: ${packageManager}@${version}. ` +
-        `This may not be the most up-to-date version. Your project will still work, but you can manually update the package manager version in package.json later if you wish.`,
-    );
-  }
-
-  // set package manager
-  editFile(path.join(projectDir, 'package.json'), (content) => {
-    const pkg = JSON.parse(content);
-    pkg.packageManager = `${packageManager}@${version!}`;
-    return JSON.stringify(pkg, null, 2) + '\n';
-  });
-}
-
-function findMonorepoRoot(): string | null {
-  let currentDir = process.cwd();
-
-  while (currentDir !== path.dirname(currentDir)) {
-    const pnpmWorkspaceFile = path.join(currentDir, 'pnpm-workspace.yaml');
-    const packageJson = path.join(currentDir, 'package.json');
-
-    // Check if this is a pnpm monorepo
-    if (fs.existsSync(pnpmWorkspaceFile)) {
-      return currentDir;
-    }
-
-    // Check if this is a npm/yarn monorepo
-    if (fs.existsSync(packageJson)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packageJson, 'utf-8'));
-        if (pkg.workspaces) {
-          return currentDir;
-        }
-      } catch {
-        // Continue searching
-      }
-    }
-
-    currentDir = path.dirname(currentDir);
-  }
-
-  return null;
-}
-
-function runCommand(command: string, args: string[], options?: { cwd?: string }) {
-  const child = spawn(command, args, {
-    stdio: 'pipe',
-    cwd: options?.cwd,
-  });
-  const promise = new Promise<{ status: number; stdout: Buffer; stderr: Buffer }>((resolve, reject) => {
-    const stdout: Buffer[] = [];
-    const stderr: Buffer[] = [];
-    child.stdout?.on('data', (data) => {
-      stdout.push(data);
-    });
-    child.stderr?.on('data', (data) => {
-      stderr.push(data);
-    });
-    child.on('close', (code) => {
-      resolve({ status: code ?? 0, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) });
-    });
-    child.on('error', (err) => {
-      reject(err);
-    });
-  });
-  return promise;
-}
-
-init().catch((err) => {
-  console.error('[vite+] Failed to initialize project: %s', err);
-  process.exit(1);
-});
diff --git a/packages/global/templates/generator/README.md b/packages/global/templates/generator/README.md
new file mode 100644
index 0000000000..442d9738a8
--- /dev/null
+++ b/packages/global/templates/generator/README.md
@@ -0,0 +1,35 @@
+# Vite+ Code Generator Starter
+
+A starter for creating a Vite+ code generator.
+
+## Usage
+
+From monorepo root:
+
+```bash
+# run and select the generator
+vite gen
+```
+
+## Development
+
+```bash
+# Edit the template
+code src/template.ts
+
+# Test the generator CLI
+vite run dev
+
+# Run tests
+vite run test
+```
+
+## Customization
+
+Edit `src/template.ts` to customize:
+
+- Options schema (using Zod)
+- File generation logic
+- Scripts and suggestions
+
+More information about the [Bingo Templates](https://create.bingo/) can be found [here](https://create.bingo/build/concepts/creations).
diff --git a/packages/global/templates/generator/bin/index.ts b/packages/global/templates/generator/bin/index.ts
new file mode 100755
index 0000000000..0e838241b9
--- /dev/null
+++ b/packages/global/templates/generator/bin/index.ts
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import { runTemplateCLI } from 'bingo';
+
+import template from '../src/template.ts';
+
+process.exitCode = await runTemplateCLI(template);
diff --git a/packages/global/templates/generator/package.json b/packages/global/templates/generator/package.json
new file mode 100644
index 0000000000..b2ae79e56b
--- /dev/null
+++ b/packages/global/templates/generator/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "vite-plus-generator-template",
+  "version": "0.0.0",
+  "type": "module",
+  "private": true,
+  "description": "A starter for creating a Vite+ code generator.",
+  "bin": "./bin/index.ts",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "keywords": [
+    "bingo-template",
+    "vite-plus-generator"
+  ],
+  "scripts": {
+    "test": "vite test",
+    "dev": "node bin/index.ts"
+  },
+  "dependencies": {
+    "bingo": "^0.7.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "typescript": "catalog:",
+    "vite-plus": "catalog:"
+  }
+}
diff --git a/packages/global/templates/generator/src/template.ts b/packages/global/templates/generator/src/template.ts
new file mode 100644
index 0000000000..97b77d9d18
--- /dev/null
+++ b/packages/global/templates/generator/src/template.ts
@@ -0,0 +1,66 @@
+import { createTemplate } from 'bingo';
+import { z } from 'zod';
+
+import pkgJson from '../package.json' with { type: 'json' };
+
+export default createTemplate({
+  about: {
+    name: pkgJson.name,
+    description: pkgJson.description,
+  },
+
+  // Define your options using Zod schemas
+  options: {
+    name: z.string().describe('Package name'),
+    // TODO: Add more options as needed
+  },
+
+  // Generate files based on options
+  async produce({ options }) {
+    return {
+      // see https://www.create.bingo/build/concepts/creations#files
+      files: {
+        'package.json': JSON.stringify(
+          {
+            name: options.name,
+            version: '0.0.0',
+            type: 'module',
+            // TODO: Add more package.json fields
+          },
+          null,
+          2,
+        ),
+        src: {
+          'index.ts': `export const name = '${options.name}';
+`,
+        },
+        'tsconfig.json': JSON.stringify(
+          {
+            compilerOptions: {
+              declaration: true,
+              esModuleInterop: true,
+              module: 'NodeNext',
+              moduleResolution: 'NodeNext',
+              outDir: 'lib',
+              skipLibCheck: true,
+              strict: true,
+              target: 'ES2022',
+            },
+            include: ['src'],
+          },
+          null,
+          2,
+        ),
+        // TODO: Add more files
+      },
+      // see https://www.create.bingo/build/concepts/creations#scripts
+      scripts: [
+        // Optional: Add scripts to run after generation
+      ],
+      // see https://www.create.bingo/build/concepts/creations#suggestions
+      suggestions: [
+        // Optional: Add suggestions for users
+      ],
+    };
+  },
+});
diff --git a/packages/global/templates/generator/tsconfig.json b/packages/global/templates/generator/tsconfig.json
new file mode 100644
index 0000000000..67f82c834d
--- /dev/null
+++ b/packages/global/templates/generator/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "noEmit": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "allowImportingTsExtensions": true
+  }
+}
diff --git a/packages/global/templates/minimal-js/.oxlintrc.json b/packages/global/templates/minimal-js/.oxlintrc.json
deleted file mode 100644
index d71deeeee8..0000000000
--- a/packages/global/templates/minimal-js/.oxlintrc.json
+++ /dev/null
@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "no-eval": "error"
-  }
-}
diff --git a/packages/global/templates/minimal-js/index.html b/packages/global/templates/minimal-js/index.html
deleted file mode 100644
index d86d5c0891..0000000000
--- a/packages/global/templates/minimal-js/index.html
+++ /dev/null
@@ -1 +0,0 @@
-<script type="module" src="./src/index.js"></script>
diff --git a/packages/global/templates/minimal-js/package.json b/packages/global/templates/minimal-js/package.json
deleted file mode 100644
index 30973a923f..0000000000
--- a/packages/global/templates/minimal-js/package.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-  "name": "vite-plus-template-minimal-js",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "main": "src/index.js",
-  ".": {
-    "types": "dist/index.d.ts",
-    "default": "src/index.js"
-  },
-  "scripts": {
-    "build": "tsc --build --verbose"
-  },
-  "devDependencies": {
-    "@types/node": "catalog:",
-    "typescript": "catalog:",
-    "@voidzero-dev/vite-plus": "workspace:*"
-  }
-}
diff --git a/packages/global/templates/minimal-js/src/index.js b/packages/global/templates/minimal-js/src/index.js
deleted file mode 100644
index c65b3e06a7..0000000000
--- a/packages/global/templates/minimal-js/src/index.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/**
- * Greetings earthlings, we have not taken over your radiooooo 🎶
- *
- * @param {string} name
- * @returns {string}
- */
-export const greet = name => {
-  return `Hello, ${name}!`;
-};
-
-console.log(greet('World'));
diff --git a/packages/global/templates/minimal-js/tsconfig.json b/packages/global/templates/minimal-js/tsconfig.json
deleted file mode 100644
index 7efb1fe5a2..0000000000
--- a/packages/global/templates/minimal-js/tsconfig.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "checkJs": true,
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "lib": ["esnext", "dom", "dom.iterable"],
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "noEmitOnError": true,
-    "noErrorTruncation": true,
-    "outDir": "dist",
-    "resolveJsonModule": true,
-    "strict": true,
-    "target": "esnext",
-    "types": ["node"],
-    "verbatimModuleSyntax": true
-  },
-  "include": ["src"]
-}
diff --git a/packages/global/templates/minimal/index.html b/packages/global/templates/minimal/index.html
deleted file mode 100644
index 04819b329a..0000000000
--- a/packages/global/templates/minimal/index.html
+++ /dev/null
@@ -1 +0,0 @@
-<script type="module" src="./src/index.ts"></script>
diff --git a/packages/global/templates/minimal/package.json b/packages/global/templates/minimal/package.json
deleted file mode 100644
index 1d2c944ca0..0000000000
--- a/packages/global/templates/minimal/package.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "vite-plus-template-minimal",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  ".": {
-    "types": "dist/index.d.ts",
-    "default": "dist/index.js"
-  },
-  "scripts": {},
-  "devDependencies": {
-    "@voidzero-dev/vite-plus": "workspace:*"
-  }
-}
diff --git a/packages/global/templates/minimal/src/index.ts b/packages/global/templates/minimal/src/index.ts
deleted file mode 100644
index e9fe0090d6..0000000000
--- a/packages/global/templates/minimal/src/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-console.log('Hello, world!');
diff --git a/packages/global/templates/minimal/tsconfig.json b/packages/global/templates/minimal/tsconfig.json
deleted file mode 100644
index 0a4864cf93..0000000000
--- a/packages/global/templates/minimal/tsconfig.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "lib": ["esnext", "dom", "dom.iterable"],
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "noEmitOnError": true,
-    "noErrorTruncation": true,
-    "outDir": "dist",
-    "resolveJsonModule": true,
-    "strict": true,
-    "target": "esnext",
-    "types": ["node"],
-    "verbatimModuleSyntax": true
-  },
-  "include": ["src"]
-}
diff --git a/packages/global/templates/monorepo/README.md b/packages/global/templates/monorepo/README.md
index d3ad5aa9a2..a6ee74fed6 100644
--- a/packages/global/templates/monorepo/README.md
+++ b/packages/global/templates/monorepo/README.md
@@ -13,13 +13,13 @@ vite run ready
 - Run the tests:
 
 ```bash
-vite run test
+vite run test -r
 ```
 
 - Build the monorepo:
 
 ```bash
-vite run build
+vite run build -r
 ```
 
 - Run the development server:
diff --git a/packages/global/templates/monorepo/_yarnrc.yml b/packages/global/templates/monorepo/_yarnrc.yml
index e0b10c6a1e..f0f5e7a5cc 100644
--- a/packages/global/templates/monorepo/_yarnrc.yml
+++ b/packages/global/templates/monorepo/_yarnrc.yml
@@ -5,11 +5,10 @@ npmScopes:
     npmAuthToken: '${GITHUB_TOKEN}'
 
 catalog:
-  '@types/node': ^24.5.0
-  '@voidzero-dev/vite-plus': latest
-  bumpp: ^10.1.0
-  happy-dom: ^18.0.1
-  vite: npm:@voidzero-dev/vite-plus
-  vitest: ^3.2.4
-  typescript: ^5.9.2
-  tsdown: ^0.15.1
+  '@types/node': ^24
+  vite-plus: npm:@voidzero-dev/vite-plus@latest
+  vite: npm:@voidzero-dev/vite-plus@latest
+  vitest: npm:@voidzero-dev/vite-plus@latest
+  typescript: ^5
+
+catalogMode: prefer
diff --git a/packages/global/templates/monorepo/package.json b/packages/global/templates/monorepo/package.json
index c3109f967e..0de6e7a3b8 100644
--- a/packages/global/templates/monorepo/package.json
+++ b/packages/global/templates/monorepo/package.json
@@ -1,4 +1,5 @@
 {
+  "name": "vite-plus-monorepo-template",
   "private": true,
   "version": "0.0.0",
   "type": "module",
@@ -8,19 +9,19 @@
     "tools/*"
   ],
   "scripts": {
-    "ready": "vite fmt && vite run lint && vite run test:all && vite run build:all",
-    "dev": "vite run website#dev",
-    "lint": "vite lint --type-aware",
-    "test:all": "vite run -r test",
-    "build:all": "vite run -r build"
+    "ready": "vite fmt && vite lint --type-aware && vite run test -r && vite run build -r",
+    "dev": "vite run website#dev"
+  },
+  "engines": {
+    "node": ">=22.12.0"
   },
   "devDependencies": {
-    "vite": "catalog:"
+    "vite-plus": "catalog:"
   },
   "pnpm": {
     "overrides": {
       "vite": "catalog:",
-      "tsdown": "catalog:"
+      "vitest": "catalog:"
     },
     "peerDependencyRules": {
       "allowAny": [
@@ -30,6 +31,6 @@
   },
   "resolutions": {
     "vite": "catalog:",
-    "tsdown": "catalog:"
+    "vitest": "catalog:"
   }
 }
diff --git a/packages/global/templates/monorepo/pnpm-workspace.yaml b/packages/global/templates/monorepo/pnpm-workspace.yaml
index a0244d7cbe..dfa85ebd7a 100644
--- a/packages/global/templates/monorepo/pnpm-workspace.yaml
+++ b/packages/global/templates/monorepo/pnpm-workspace.yaml
@@ -4,13 +4,10 @@ packages:
   - tools/*
 
 catalog:
-  '@types/node': ^24.5.0
-  '@voidzero-dev/vite-plus': latest
-  bumpp: ^10.1.0
-  happy-dom: ^18.0.1
+  '@types/node': ^24
+  vite-plus: npm:@voidzero-dev/vite-plus@latest
   vite: npm:@voidzero-dev/vite-plus@latest
-  vitest: ^3.2.4
-  typescript: ^5.9.2
-  tsdown: ^0.15.1
+  vitest: npm:@voidzero-dev/vite-plus@latest
+  typescript: ^5
 
 catalogMode: prefer
diff --git a/packages/tools/src/snap-test.ts b/packages/tools/src/snap-test.ts
index 236cdb7b97..2e851a93c7 100755
--- a/packages/tools/src/snap-test.ts
+++ b/packages/tools/src/snap-test.ts
@@ -107,10 +107,19 @@ export async function snapTest() {
   process.exit(0); // Ensure exit even if there are pending timed-out steps
 }
 
+interface Command {
+  command: string;
+  /**
+   * If true, the stdout and stderr output of the command will be ignored.
+   * This is useful for commands that stdout/stderr is unstable.
+   */
+  ignoreOutput?: boolean;
+}
+
 interface Steps {
   ignoredPlatforms?: string[];
   env: Record<string, string>;
-  commands: string[];
+  commands: (string | Command)[];
 }
 
 async function runTestCase(name: string, tempTmpDir: string, casesDir: string) {
@@ -153,7 +162,8 @@ async function runTestCase(name: string, tempTmpDir: string, casesDir: string) {
 
   const cwd = npath.toPortablePath(caseTmpDir);
   for (const command of steps.commands) {
-    debug('running command: %s, cwd: %s, env: %o', command, caseTmpDir, env);
+    const cmd = typeof command === 'string' ? { command } : command;
+    debug('running command: %o, cwd: %s, env: %o', cmd, caseTmpDir, env);
 
     // While `@yarnpkg/shell` supports capturing output via in-memory `Writable` streams,
     // it seems not to have stable ordering of stdout/stderr chunks.
@@ -162,15 +172,15 @@ async function runTestCase(name: string, tempTmpDir: string, casesDir: string) {
     const outputStream = await open(outputStreamPath, 'w');
 
     const exitCode = await Promise.race([
-      execute(stripComments(command), [], {
+      execute(stripComments(cmd.command), [], {
         env,
         cwd,
         stdin: null,
         // Declared to be `Writable` but `FileHandle` works too.
         // @ts-expect-error
-        stderr: outputStream,
+        stderr: cmd.ignoreOutput ? null : outputStream,
         // @ts-expect-error
-        stdout: outputStream,
+        stdout: cmd.ignoreOutput ? null : outputStream,
         glob: {
           // Disable glob expansion. Pass args like '--filter=*' as-is.
           isGlobPattern: () => false,
@@ -184,7 +194,7 @@ async function runTestCase(name: string, tempTmpDir: string, casesDir: string) {
 
     const output = readFileSync(outputStreamPath, 'utf-8');
 
-    let commandLine = `> ${command}`;
+    let commandLine = `> ${cmd.command}`;
     if (exitCode !== 0) {
       commandLine = (exitCode === undefined ? '[timeout]' : `[${exitCode}]`) + commandLine;
     }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c9745686b3..1eadeb97a3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -78,6 +78,9 @@ catalogs:
     '@types/strip-comments':
       specifier: ^2.0.4
       version: 2.0.4
+    '@types/validate-npm-package-name':
+      specifier: ^4.0.2
+      version: 4.0.2
     '@types/ws':
       specifier: ^8.18.0
       version: 8.18.1
@@ -99,12 +102,6 @@ catalogs:
     consola:
       specifier: ^3.4.2
       version: 3.4.2
-    create-tsdown:
-      specifier: 0.0.3
-      version: 0.0.3
-    create-vite:
-      specifier: ^8.0.0
-      version: 8.1.0
     cross-spawn:
       specifier: ^7.0.5
       version: 7.0.6
@@ -222,6 +219,9 @@ catalogs:
     valibot:
       specifier: 1.1.0
       version: 1.1.0
+    validate-npm-package-name:
+      specifier: ^7.0.0
+      version: 7.0.0
     vitepress:
       specifier: 2.0.0-alpha.12
       version: 2.0.0-alpha.12
@@ -518,12 +518,6 @@ importers:
       '@voidzero-dev/vite-plus':
         specifier: workspace:*
         version: link:../cli
-      create-tsdown:
-        specifier: 'catalog:'
-        version: 0.0.3(typescript@5.9.3)
-      create-vite:
-        specifier: 'catalog:'
-        version: 8.1.0
       cross-spawn:
         specifier: 'catalog:'
         version: 7.0.6
@@ -536,16 +530,31 @@ importers:
       rolldown-vite:
         specifier: workspace:*
         version: link:../../rolldown-vite/packages/vite
+      validate-npm-package-name:
+        specifier: 'catalog:'
+        version: 7.0.0
     devDependencies:
       '@clack/prompts':
         specifier: 'catalog:'
         version: 0.11.0
+      '@std/yaml':
+        specifier: 'catalog:'
+        version: '@jsr/std__yaml@1.0.10'
       '@types/cross-spawn':
         specifier: 'catalog:'
         version: 6.0.6
+      '@types/validate-npm-package-name':
+        specifier: 'catalog:'
+        version: 4.0.2
       '@voidzero-dev/vite-plus-tools':
         specifier: 'workspace:'
         version: link:../tools
+      glob:
+        specifier: 'catalog:'
+        version: 12.0.0
+      minimatch:
+        specifier: 'catalog:'
+        version: 10.1.1
       mri:
         specifier: 'catalog:'
         version: 1.2.0
@@ -4162,6 +4171,9 @@ packages:
   '@types/unist@3.0.3':
     resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
 
+  '@types/validate-npm-package-name@4.0.2':
+    resolution: {integrity: sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw==}
+
   '@types/web-bluetooth@0.0.21':
     resolution: {integrity: sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==}
 
@@ -4897,9 +4909,6 @@ packages:
     resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==}
     engines: {node: '>= 14.16.0'}
 
-  citty@0.1.6:
-    resolution: {integrity: sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==}
-
   cjs-module-lexer@1.4.3:
     resolution: {integrity: sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==}
 
@@ -4983,9 +4992,6 @@ packages:
   confbox@0.1.8:
     resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==}
 
-  confbox@0.2.2:
-    resolution: {integrity: sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==}
-
   connect@3.7.0:
     resolution: {integrity: sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==}
     engines: {node: '>= 0.10.0'}
@@ -5056,21 +5062,6 @@ packages:
     resolution: {integrity: sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==}
     engines: {node: '>= 14'}
 
-  create-tsdown@0.0.3:
-    resolution: {integrity: sha512-ERk/4zjBAV464JWVI9GOtDunTxPXq9nIxBgpX3pfBnL2oOcLQ6KkdLOJ/TB/ysem0IsoKFYFJ+PGgPpMGLVrkw==}
-    engines: {node: '>=18.0.0'}
-    hasBin: true
-    peerDependencies:
-      typescript: ^5.0.0
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-
-  create-vite@8.1.0:
-    resolution: {integrity: sha512-JkgaTpyvvvEh9s1JBheRDW/LxUMp562revOmN30anozgioou6T/5uY4duWuwX6u/O41hoQ5N+lt8CXzaQ0cMHw==}
-    engines: {node: ^20.19.0 || >=22.12.0}
-    hasBin: true
-
   cross-spawn@7.0.6:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
@@ -5509,9 +5500,6 @@ packages:
     resolution: {integrity: sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==}
     engines: {node: '>=12.0.0'}
 
-  exsolve@1.0.8:
-    resolution: {integrity: sha512-LmDxfWXwcTArk8fUEnOfSZpHOJ6zOMUJKOtFLFqJLoKJetuQG874Uc7/Kki7zFLzYybmZhp1M7+98pfMqeX8yA==}
-
   extract-zip@2.0.1:
     resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
     engines: {node: '>= 10.17.0'}
@@ -5705,10 +5693,6 @@ packages:
     resolution: {integrity: sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg==}
     engines: {node: '>= 14'}
 
-  giget@2.0.0:
-    resolution: {integrity: sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA==}
-    hasBin: true
-
   glob-parent@5.1.2:
     resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
     engines: {node: '>= 6'}
@@ -6488,11 +6472,6 @@ packages:
   nth-check@2.1.1:
     resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==}
 
-  nypm@0.6.2:
-    resolution: {integrity: sha512-7eM+hpOtrKrBDCh7Ypu2lJ9Z7PNZBdi/8AT3AX8xoCj43BBVHD0hPSTEvMtkMpfs8FCqBGhxB+uToIQimA111g==}
-    engines: {node: ^14.16.0 || >=16.10.0}
-    hasBin: true
-
   object-assign@4.1.1:
     resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
     engines: {node: '>=0.10.0'}
@@ -6713,9 +6692,6 @@ packages:
   pkg-types@1.3.1:
     resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}
 
-  pkg-types@2.3.0:
-    resolution: {integrity: sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==}
-
   playwright-chromium@1.56.1:
     resolution: {integrity: sha512-5TU+NMrofQg2j+DwIaQL/9eC84hs5YGz5Wng8OOdgq+kmu8usPLedxx2pJJ1Pb2TNFNiz3167RsUNFFvY3srNA==}
     engines: {node: '>=18'}
@@ -7974,6 +7950,10 @@ packages:
     resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
 
+  validate-npm-package-name@7.0.0:
+    resolution: {integrity: sha512-bwVk/OK+Qu108aJcMAEiU4yavHUI7aN20TgZNBj9MR2iU1zPUl1Z1Otr7771ExfYTPTvfN8ZJ1pbr5Iklgt4xg==}
+    engines: {node: ^20.17.0 || >=22.9.0}
+
   varint@6.0.0:
     resolution: {integrity: sha512-cXEIW6cfr15lFv563k4GuVuW/fiwjknytD37jIOLSdSWuOI6WnO/oKwmP2FQTU2l01LP8/M5TSAJpzUaGe3uWg==}
 
@@ -10878,6 +10858,8 @@ snapshots:
 
   '@types/unist@3.0.3': {}
 
+  '@types/validate-npm-package-name@4.0.2': {}
+
   '@types/web-bluetooth@0.0.21': {}
 
   '@types/whatwg-mimetype@3.0.2': {}
@@ -11806,10 +11788,6 @@ snapshots:
     dependencies:
       readdirp: 4.1.2
 
-  citty@0.1.6:
-    dependencies:
-      consola: 3.4.2
-
   cjs-module-lexer@1.4.3: {}
 
   cjs-module-lexer@2.1.1: {}
@@ -11882,8 +11860,6 @@ snapshots:
 
   confbox@0.1.8: {}
 
-  confbox@0.2.2: {}
-
   connect@3.7.0:
     dependencies:
       debug: 2.6.9
@@ -11959,22 +11935,6 @@ snapshots:
       crc-32: 1.2.2
       readable-stream: 4.7.0
 
-  create-tsdown@0.0.3(typescript@5.9.3):
-    dependencies:
-      '@clack/prompts': 0.11.0
-      ansis: 4.2.0
-      cac: 6.7.14
-      debug: 4.4.3(supports-color@8.1.1)
-      diff: 8.0.2
-      giget: 2.0.0
-      rolldown: link:rolldown/packages/rolldown
-    optionalDependencies:
-      typescript: 5.9.3
-    transitivePeerDependencies:
-      - supports-color
-
-  create-vite@8.1.0: {}
-
   cross-spawn@7.0.6:
     dependencies:
       path-key: 3.1.1
@@ -12468,8 +12428,6 @@ snapshots:
 
   expect-type@1.2.2: {}
 
-  exsolve@1.0.8: {}
-
   extract-zip@2.0.1:
     dependencies:
       debug: 4.4.3(supports-color@8.1.1)
@@ -12674,15 +12632,6 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  giget@2.0.0:
-    dependencies:
-      citty: 0.1.6
-      consola: 3.4.2
-      defu: 6.1.4
-      node-fetch-native: 1.6.7
-      nypm: 0.6.2
-      pathe: 2.0.3
-
   glob-parent@5.1.2:
     dependencies:
       is-glob: 4.0.3
@@ -13428,14 +13377,6 @@ snapshots:
     dependencies:
       boolbase: 1.0.0
 
-  nypm@0.6.2:
-    dependencies:
-      citty: 0.1.6
-      consola: 3.4.2
-      pathe: 2.0.3
-      pkg-types: 2.3.0
-      tinyexec: 1.0.2
-
   object-assign@4.1.1: {}
 
   obug@2.0.0(ms@2.1.3):
@@ -13731,12 +13672,6 @@ snapshots:
       mlly: 1.8.0
       pathe: 2.0.3
 
-  pkg-types@2.3.0:
-    dependencies:
-      confbox: 0.2.2
-      exsolve: 1.0.8
-      pathe: 2.0.3
-
   playwright-chromium@1.56.1:
     dependencies:
       playwright-core: 1.56.1
@@ -14938,6 +14873,8 @@ snapshots:
 
   validate-npm-package-name@5.0.1: {}
 
+  validate-npm-package-name@7.0.0: {}
+
   varint@6.0.0: {}
 
   vary@1.1.2: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index bf1b45b644..e384a6b7c6 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -34,6 +34,7 @@ catalog:
   '@types/semver': ^7.7.1
   '@types/serve-static': ^2.0.0
   '@types/strip-comments': ^2.0.4
+  '@types/validate-npm-package-name': ^4.0.2
   '@types/ws': ^8.18.0
   '@vitest/browser': ^4.0.9
   '@vitest/browser-playwright': ^4.0.9
@@ -47,8 +48,6 @@ catalog:
   change-case: ^5.4.4
   connect: ^3.7.0
   consola: ^3.4.2
-  create-tsdown: 0.0.3
-  create-vite: ^8.0.0
   cross-spawn: ^7.0.5
   debug: ^4.4.3
   dedent: ^1.5.3
@@ -101,6 +100,7 @@ catalog:
   typescript: ^5.9.3
   unified: ^11.0.5
   valibot: 1.1.0
+  validate-npm-package-name: ^7.0.0
   vitepress: 2.0.0-alpha.12
   vitepress-plugin-group-icons: ^1.0.0
   vitepress-plugin-llms: ^1.1.0
@@ -125,7 +125,6 @@ minimumReleaseAgeExclude:
   - '@oxc-transform/*'
   - '@oxfmt/*'
   - '@oxlint-tsgolint/*'
-  - create-vite
   - oxc-minify
   - oxc-parser
   - oxc-transform
diff --git a/rfcs/code-generator.md b/rfcs/code-generator.md
new file mode 100644
index 0000000000..e0014bb6a7
--- /dev/null
+++ b/rfcs/code-generator.md
@@ -0,0 +1,2199 @@
+# RFC: Vite+ Code Generator
+
+## Background
+
+Reference:
+
+- [Nx Code Generation](https://nx.dev/docs/features/generate-code)
+- [Turborepo Code Generation](https://turborepo.com/docs/guides/generating-code)
+- [Bingo Framework](https://www.create.bingo/about)
+
+The code generator function is an essential feature for a company's continuously iterated monorepo. Without it, creating a new project can only be done by manually copying and pasting and then modifying the files to make them usable, which likely leads to missing changes.
+
+## Comparison of Existing Solutions
+
+| Feature                      | Nx                                        | Turbo                                        | Bingo                                                                               |
+| ---------------------------- | ----------------------------------------- | -------------------------------------------- | ----------------------------------------------------------------------------------- |
+| Generator approach           | Nx plugin's generator feature             | Based on [PLOP](https://plopjs.com/) wrapper | Repository templating engine with type-safe options                                 |
+| Monorepo reuse               | ✅                                        | ✅                                           | ✅                                                                                  |
+| Template engine              | [EJS](https://github.com/nrwl/nx)         | Handlebars                                   | [Template Literals](https://www.create.bingo/build/concepts/templates) / Handlebars |
+| Input validation             | schema.json                               | validate(input): true \| string              | Zod schemas (type-safe)                                                             |
+| Advanced features            | Tree API for file operations              | Medium                                       | Network requests, shell scripts, blocks/presets                                     |
+| Complexity of implementation | High (through @nx/devkit tree operations) | Medium                                       | Medium (TypeScript-based)                                                           |
+| Type safety                  | Medium (JSON Schema)                      | Low (JavaScript)                             | High (Zod + TypeScript)                                                             |
+
+## Why Bingo's Approach?
+
+Bingo offers several advantages:
+
+1. **Type Safety**: Uses Zod schemas with TypeScript for compile-time validation
+2. **Modern Architecture**: Built from the ground up with modern JavaScript/TypeScript
+3. **Flexible**: Supports simple templates to complex block-based systems
+4. **Extensible**: Can execute network requests and shell scripts beyond file generation
+5. **Two Modes**: Setup (create new) and Transition (update existing) modes
+6. **Testable**: Built-in testing utilities for template development
+7. **Existing Ecosystem**: Can directly run existing bingo templates from npm
+
+## Integration Strategy: Dual-Mode Support
+
+**Key Decision**: `vite gen` supports BOTH bingo templates AND any existing `create-*` template through intelligent migration:
+
+### Two Ways to Write Generators
+
+**Option 1: Bingo Templates (Recommended for Custom Generators)**
+
+Best for creating **reusable local generators** within your monorepo:
+
+```bash
+# Run workspace-local bingo generator
+vite gen @company/generator-ui-lib
+
+# Or any bingo template from npm
+vite gen create-typescript-app
+```
+
+**Why use bingo**:
+
+- ✅ **Easier to write**: Type-safe with Zod schemas
+- ✅ **Better DX**: Full control over file generation
+- ✅ **Testable**: Built-in testing utilities
+- ✅ **Quick start**: Use `@vite-plus/create-generator` to scaffold a generator
+- ✅ **Perfect for**: Company-specific patterns and standards
+
+**Option 2: Universal Templates (Any create-\* package)**
+
+Run **ANY** existing `create-*` template from the ecosystem:
+
+```bash
+# Run any existing template
+vite gen create-vite
+vite gen create-next-app
+vite gen create-nuxt
+```
+
+**Why use universal templates**:
+
+- ✅ **No work required**: Use existing templates as-is
+- ✅ **Zero learning curve**: Use familiar templates
+- ✅ **Huge ecosystem**: Thousands of templates available
+- ✅ **No maintenance**: Template authors maintain them
+
+### Auto-Migration for ALL Templates
+
+**Important**: Regardless of whether you use bingo or universal templates, **all generated code goes through the same auto-detect and migrate logic**:
+
+```
+ANY template (bingo or universal)
+  ↓
+Template generates code
+  ↓
+vite+ auto-detects vite-related tools:
+  • Standalone vite, vitest, oxlint, oxfmt
+  ↓
+Auto-migrate to unified vite-plus:
+  • Dependencies: vite + vitest + oxlint + oxfmt → vite-plus
+  • Configs: Merge vitest.config.ts, .oxlintrc, .oxfmtrc → vite.config.ts
+  ↓
+Monorepo integration:
+  • Prompt for workspace dependencies
+  • Update workspace config (pnpm-workspace.yaml, package.json, etc.)
+```
+
+**Scope of Auto-Migration**:
+
+- ✅ Consolidate vite/vitest/oxlint/oxfmt dependencies → vite-plus
+- ✅ Merge tool configurations into vite.config.ts
+- ❌ Does NOT migrate ESLint → oxlint (if template uses ESLint, it stays)
+- ❌ Does NOT create vite-task.json (optional, separate feature)
+- ❌ Does NOT change TypeScript config (remains as generated)
+
+**Bingo templates get the same migration treatment** - the difference is just that bingo makes it easier to write generators with type safety and testing.
+
+### How It Works
+
+```
+┌──────────────────────────┐
+│  vite gen <name>         │
+└───────────┬──────────────┘
+            │
+      ┌─────▼─────────┐
+      │ Detect & Load │
+      │ Template Type │
+      └─────┬─────────┘
+            │
+    ┌───────┴────────┐
+    │                │
+┌───▼──────┐   ┌─────▼──────┐
+│  Bingo   │   │ Universal  │
+│ Template │   │ (create-*) │
+└───┬──────┘   └─────┬──────┘
+    │                │
+    └────────┬───────┘
+             │
+      ┌──────▼─────────┐
+      │ Execute        │
+      │ Template       │
+      └──────┬─────────┘
+             │
+      ┌──────▼─────────────┐
+      │ Auto-Detect        │
+      │ Generated Code     │
+      │ (ALL templates)    │
+      └──────┬─────────────┘
+             │
+      ┌──────▼─────────────┐
+      │ Auto-Migrate       │
+      │ vite-tools         │
+      │ → vite-plus        │
+      └──────┬─────────────┘
+             │
+      ┌──────▼─────────────┐
+      │ Monorepo           │
+      │ Integration        │
+      │ • Workspace deps   │
+      │ • Update configs   │
+      └────────────────────┘
+```
+
+## Monorepo-Specific Enhancements
+
+After any template runs, vite+ adds monorepo-specific features:
+
+### 1. Auto-Migration to vite-plus Unified Toolchain (for ALL templates)
+
+**After any template runs** (bingo or universal), vite+ automatically detects standalone vite-related tools and offers to consolidate them into the unified vite-plus dependency.
+
+**Purpose**: Simplify dependency management by consolidating vite, vitest, oxlint, and oxfmt into a single vite-plus package.
+
+```bash
+$ vite gen create-vite --template react-ts
+
+# create-vite runs normally...
+✔ Project name: › my-app
+✔ Select a framework: › React
+✔ Select a variant: › TypeScript
+
+Scaffolding project in ./packages/my-app...
+
+# After template completes, vite+ detects standalone tools
+◇  Template completed! Detecting vite-related tools...
+│
+◆  Detected standalone vite tools:
+│  ✓ vite ^5.0.0
+│  ✓ vitest ^1.0.0
+│
+◆  Upgrade to vite-plus unified toolchain?
+│
+│  This will:
+│  • Replace vite + vitest dependencies → single vite-plus dependency
+│  • Merge vitest.config.ts → vite.config.ts (test section)
+│  • Remove vitest.config.ts
+│
+│  Benefits:
+│  • Simplified dependency management (1 instead of 2+ dependencies)
+│  • Unified configuration in vite.config.ts
+│  • Better integration with vite+ task runner and caching
+│
+│  ● Yes / ○ No
+│
+◇  Migrating to vite-plus...
+│  ✓ Updated package.json (vite + vitest → vite-plus)
+│  ✓ Merged vitest.config.ts → vite.config.ts
+│  ✓ Removed vitest.config.ts
+│
+└  Migration completed!
+```
+
+**Scope of Auto-Migration**:
+
+This is a **dependency consolidation** feature, not a tool replacement feature.
+
+✅ **What it does**:
+
+- Consolidate standalone vite/vitest/oxlint/oxfmt dependencies → single vite-plus dependency
+- Merge vitest.config.ts → vite.config.ts (test section)
+- Merge .oxlintrc → vite.config.ts (oxlint section)
+- Merge .oxfmtrc → vite.config.ts (oxfmt section)
+- Remove redundant standalone config files
+
+❌ **What it does NOT do**:
+
+- Does NOT migrate ESLint → oxlint (different tools, not consolidation)
+- Does NOT migrate Prettier → oxfmt (different tools, not consolidation)
+- Does NOT create vite-task.json (separate feature, not required)
+- Does NOT change TypeScript configuration (remains as generated)
+- Does NOT modify build tools (webpack/rollup → vite)
+
+**Why this design**:
+
+- Templates that use vite/vitest/oxlint/oxfmt can be simplified to use vite-plus
+- Templates that use other tools (ESLint, Prettier, Jest) remain unchanged
+- Users keep their chosen tools, just with optimized vite-related dependencies
+
+**Migration Engine powered by [ast-grep](https://ast-grep.github.io/)**:
+
+- Structural search and replace for accurate code transformation
+- YAML-based rules for easy maintenance
+- Safe, reversible transformations
+- **Note**: Uses the same migration engine as `vite migration` command (see [migration-command.md](./migration-command.md))
+
+### 2. Target Directory Selection (Monorepo)
+
+When running `vite gen` in a monorepo workspace, vite+ prompts users to select which parent directory to create the new package in:
+
+```bash
+$ vite gen create-vite
+
+◆  Where should we create the new package?
+│  ○ apps/        (Applications)
+│  ● packages/    (Shared packages)
+│  ○ services/    (Backend services)
+│  ○ tools/       (Development tools)
+│
+◇  Selected: packages/
+│
+# Template runs...
+✔ Project name: › my-lib
+```
+
+**How it works**:
+
+- Detects package manager from lock files (pnpm-lock.yaml, package-lock.json, yarn.lock, bun.lockb)
+- Reads workspace configuration:
+  - **pnpm**: Read `pnpm-workspace.yaml` → `packages` field
+  - **npm/yarn**: Read root `package.json` → `workspaces` field
+  - **bun**: Read root `package.json` → `workspaces` field
+- Extracts parent directories from patterns (e.g., `apps/*`, `packages/*`)
+- Prompts user to select one
+- Passes the selected directory to the template (if template supports directory options)
+- Or changes working directory before running template
+
+**Benefits**:
+
+- Clear organization in monorepo
+- Users don't need to remember directory structure
+- Consistent with workspace organization
+- Can be skipped with `--directory` flag: `vite gen create-vite --directory=packages`
+
+### 3. Workspace Dependency Prompts
+
+Inspired by [Turbo's generator](https://turborepo.com/docs/guides/generating-code), vite+ prompts users to select existing workspace packages as dependencies:
+
+```bash
+$ vite gen @company/generator-ui-lib --name=design-system
+
+◇ Library name: design-system
+◇ Framework: React
+◇ Include Storybook? Yes
+
+◆ Add workspace packages as dependencies?
+│  ◼ @company/theme
+│  ◼ @company/utils
+│  ◻ @company/icons
+│  ◻ @company/hooks
+└
+
+✅ Created design-system with dependencies:
+   - @company/theme@workspace:*
+   - @company/utils@workspace:*
+```
+
+This feature:
+
+- **Auto-discovers** all packages in the workspace
+- **Interactive selection** with multi-select checkbox UI
+- **Smart defaults** based on package type or naming conventions
+- **Proper version ranges** using `workspace:*` protocol
+- **Updates package.json** automatically after generation
+
+## Core Concepts
+
+### 1. Templates
+
+A template describes how to initialize or modify a repository given a set of options.
+
+```typescript
+import { createTemplate } from 'bingo';
+import { z } from 'zod';
+
+export default createTemplate({
+  // Define options using Zod schemas for type safety
+  options: {
+    name: z.string().describe('Package name'),
+    directory: z.enum(['apps', 'packages']).default('packages'),
+    framework: z.enum(['react', 'vue', 'svelte']).default('react'),
+  },
+
+  // Optional: Prepare default values
+  async prepare({ fs, options }) {
+    return {
+      name: options.name || await fs.readdir('.').then(d => d[0]),
+    };
+  },
+
+  // Core production function
+  async produce({ options }) {
+    const projectPath = `${options.directory}/${options.name}`;
+
+    return {
+      files: {
+        [`${projectPath}/package.json`]: JSON.stringify(
+          {
+            name: options.name,
+            version: '0.0.1',
+            dependencies: {
+              [options.framework]: 'latest',
+            },
+          },
+          null,
+          2,
+        ),
+        [`${projectPath}/src/index.ts`]: `export const app = '${options.name}';`,
+      },
+      scripts: [
+        { phase: 0, commands: [`cd ${projectPath}`, 'vite install'] },
+        { phase: 1, commands: ['vite build'] },
+      ],
+      suggestions: [
+        `✅ Created ${options.name} in ${projectPath}`,
+        `Next: cd ${projectPath} && vite dev`,
+      ],
+    };
+  },
+
+  // Setup mode: additional logic for new repositories
+  async setup({ options }) {
+    return {
+      requests: [
+        {
+          url: 'https://api.github.com/repos/:owner/:repo/labels',
+          method: 'POST',
+          body: { name: 'vite-plus', color: 'ff6b6b' },
+        },
+      ],
+    };
+  },
+
+  // Transition mode: logic for updating existing repositories
+  async transition({ options }) {
+    return {
+      scripts: [
+        {
+          phase: 0,
+          commands: ['rm -rf old-config'],
+          silent: true, // Don't error if file doesn't exist
+        },
+      ],
+    };
+  },
+});
+```
+
+### 2. Creations
+
+A Creation is an in-memory representation of repository changes that templates produce.
+
+**Structure:**
+
+```typescript
+interface Creation {
+  // Direct changes (always applied)
+  files?: Files; // Hierarchical file structure
+  requests?: Request[]; // Network API calls
+  scripts?: Script[]; // Shell commands
+
+  // Indirect guidance
+  suggestions?: string[]; // Tips for manual steps
+}
+```
+
+**Files Format:**
+
+```typescript
+// Strings become files, objects become directories
+const files = {
+  'README.md': '# My App',
+  'src': {
+    'index.ts': 'export {}',
+    'utils': {
+      'helpers.ts': 'export const helper = () => {}',
+    },
+  },
+};
+```
+
+**Scripts with Phases:**
+
+```typescript
+const scripts = [
+  // Phase 0: runs first
+  { phase: 0, commands: ['vite install'] },
+  { phase: 0, commands: ['git init'] },
+
+  // Phase 1: runs after phase 0 completes
+  { phase: 1, commands: ['vite build'] },
+  { phase: 1, commands: ['vite format'] },
+];
+```
+
+### 3. Modes
+
+Templates operate in two modes:
+
+**Setup Mode**: Creates a brand new repository
+
+- Runs `setup()` function for additional creations
+- Creates GitHub repository (if configured)
+- Initializes git with initial commit
+
+**Transition Mode**: Updates an existing repository
+
+- Runs `transition()` function for migration logic
+- Optionally cleans up old files
+- Preserves existing git history
+
+The CLI automatically infers the correct mode based on whether running in an existing repo.
+
+### 4. Blocks and Presets
+
+For complex templates with many configurable features, use the Stratum engine:
+
+```typescript
+import { createStratumTemplate } from 'bingo-stratum';
+
+export default createStratumTemplate({
+  // Define blocks (individual features)
+  blocks: {
+    linting: createBlock({
+      about: { name: 'ESLint Configuration' },
+      produce: ({ options }) => ({
+        files: {
+          '.eslintrc.json': JSON.stringify({ extends: ['eslint:recommended'] }),
+        },
+      }),
+    }),
+
+    testing: createBlock({
+      about: { name: 'Vitest Setup' },
+      produce: ({ options }) => ({
+        files: {
+          'vitest.config.ts': 'export default {}',
+        },
+      }),
+    }),
+  },
+
+  // Define presets (block combinations)
+  presets: {
+    minimal: { blocks: [] },
+    common: { blocks: ['linting'] },
+    everything: { blocks: ['linting', 'testing'] },
+  },
+
+  // Suggested default
+  suggested: 'common',
+});
+```
+
+### 5. Inputs
+
+Inputs are composable units for data retrieval and processing:
+
+```typescript
+import { createInput } from 'bingo';
+
+const readPackageJson = createInput({
+  async produce({ fs }) {
+    const content = await fs.readFile('package.json', 'utf-8');
+    return JSON.parse(content);
+  },
+});
+
+const detectFramework = createInput({
+  async produce({ take }) {
+    const pkg = await take(readPackageJson);
+
+    if (pkg.dependencies?.react) return 'react';
+    if (pkg.dependencies?.vue) return 'vue';
+    if (pkg.dependencies?.svelte) return 'svelte';
+
+    return 'vanilla';
+  },
+});
+```
+
+## Interactive Mode
+
+When running `vite gen` without specifying a template, users enter interactive mode with a beautiful template selection interface.
+
+### Template Selection Menu
+
+Interactive mode presents a curated list of known templates:
+
+```bash
+$ vite gen
+
+┌  🎨 Vite+ Code Generator
+│
+◆  Which template would you like to use?
+│  ○ Vite+ Monorepo (Create a new vite+ monorepo project)
+│  ○ Vite+ Generator (Scaffold a new code generator)
+│  ○ Vite (Create vite applications and libraries)
+│  ○ TanStack Start (Create TanStack applications and libraries)
+│  ● Other (Enter a custom template package name)
+└
+```
+
+### Known Templates with Auto-Configuration
+
+Interactive mode includes pre-configured templates with automatic argument injection:
+
+| Template Option     | Built-in Alias           | Description                                |
+| ------------------- | ------------------------ | ------------------------------------------ |
+| **Vite+ Monorepo**  | `vite:monorepo`          | Create a new vite+ monorepo project        |
+| **Vite+ Generator** | `vite:generator`         | Scaffold a new code generator              |
+| **Vite**            | `create-vite`            | Create vite applications and libraries     |
+| **TanStack Start**  | `@tanstack/create-start` | Create TanStack applications and libraries |
+| **Other**           | _(user input)_           | Custom template package name               |
+
+### Custom Template Input
+
+When selecting "Other", users can input any npm template:
+
+```bash
+◆  Which template would you like to use?
+│  ● Other (Enter a custom template package name)
+│
+◇  Enter the template package name:
+│  create-next-app
+│
+◇  Discovering template: create-next-app
+...
+```
+
+### Benefits
+
+- **Discoverability**: Users can explore available templates without documentation
+- **Ease of Use**: No need to remember exact template names or arguments
+- **Guided Experience**: Clear hints help users choose the right template
+- **Flexibility**: "Other" option allows any npm template
+- **Consistency**: Same post-processing (migration, monorepo integration) applies to all
+
+## CLI Usage
+
+```bash
+# Interactive mode - prompts for template selection
+vite gen
+
+# Built-in vite+ templates
+vite gen vite:monorepo                               # Vite+ monorepo
+vite gen vite:generator                              # Vite+ generator scaffold
+vite gen vite:application                            # Vite+ application
+vite gen vite:library                                # Vite+ library
+
+# Run known templates directly
+vite gen create-vite                                 # Vite apps/libs
+vite gen @tanstack/create-start                      # TanStack apps/libs
+
+# Run ANY template from npm
+vite gen create-next-app          # Next.js
+vite gen create-nuxt              # Nuxt
+vite gen create-typescript-app    # TypeScript (bingo)
+vite gen @company/generator-api   # Workspace-local bingo generator
+
+# Run built-in vite+ generators
+vite gen vite:monorepo
+vite gen vite:generator
+vite gen vite:application
+vite gen vite:library
+
+# Pass through template options (use -- separator)
+vite gen create-vite -- --template react-ts
+vite gen create-next-app -- --typescript --app
+
+# Control migrations (vite+ options, before --)
+vite gen create-vite --no-migrate                    # Skip all migrations
+vite gen create-vite --migrate=vite-plus             # Only migrate to vite-plus
+
+# Control target directory (vite+ options, before --)
+vite gen create-vite --directory=packages            # Skip directory selection
+
+# Control workspace dependencies (vite+ options, before --)
+vite gen create-vite --deps=@company/utils,@company/logger  # Pre-select
+vite gen create-vite --no-prompt                     # Skip workspace dependency prompt
+
+# Combine vite+ options and template options
+vite gen create-vite --directory=apps --no-migrate --deps=@company/utils -- --template react-ts
+
+# List available templates
+vite gen --list               # Shows built-in and popular templates
+vite gen --list --all         # Shows all installed templates
+
+# Dry run (show what would be generated/migrated)
+vite gen create-vite --dry-run
+
+# Combine with template options
+vite gen create-vite --dry-run -- --template vue-ts
+
+# Help
+vite gen --help
+
+# Aliases
+vite g
+vite generate
+```
+
+## @vite-plus/create-generator Scaffold
+
+To make it easier for users to create custom generators, we provide `@vite-plus/create-generator` - a bingo template that scaffolds a complete generator package.
+
+### What It Generates
+
+```
+tools/generators/{generator-name}/
+├── package.json              # Pre-configured with bingo, zod, bin entry
+├── bin/
+│   └── index.js              # CLI entrypoint
+├── src/
+│   ├── template.ts           # Main template with example code
+│   └── template.test.ts      # Test examples using bingo/testers
+├── tsconfig.json             # TypeScript configuration
+└── README.md                 # Usage and customization guide
+```
+
+### Scaffold Template
+
+```typescript
+// Generated src/template.ts includes helpful examples and comments
+import { createTemplate } from 'bingo';
+import { z } from 'zod';
+
+export default createTemplate({
+  about: {
+    name: '{Generator Name}',
+    description: '{Description}',
+  },
+
+  // TODO: Define your options using Zod schemas
+  options: {
+    name: z.string().describe('Package name'),
+    // Add more options as needed
+  },
+
+  // TODO: Customize the file generation logic
+  async produce({ options }) {
+    return {
+      files: {
+        // Define files to generate
+        [`{output-path}/package.json`]: JSON.stringify(
+          {
+            name: options.name,
+            version: '0.1.0',
+          },
+          null,
+          2,
+        ),
+      },
+      scripts: [
+        // Optional: Add scripts to run after generation
+      ],
+      suggestions: [
+        // Optional: Add suggestions for users
+        `✅ Created ${options.name}`,
+      ],
+    };
+  },
+});
+```
+
+### Usage
+
+```bash
+# Step 1: Create the generator scaffold
+vite gen @vite-plus/create-generator
+
+# Step 2: Customize the template
+cd tools/generators/your-generator
+# Edit src/template.ts
+
+# Step 3: Test your generator
+vite gen @company/your-generator
+
+# Step 4: Run tests
+vite test
+```
+
+### Benefits
+
+The scaffold saves you from:
+
+- ✅ Setting up package.json with correct bin entry
+- ✅ Configuring TypeScript for the generator
+- ✅ Writing boilerplate bingo template code
+- ✅ Setting up test infrastructure
+- ✅ Creating README documentation
+
+You get:
+
+- ✅ Working example template with comments
+- ✅ Complete test setup
+- ✅ TypeScript configuration
+- ✅ Ready to customize for your needs
+
+## Technical Implementation Details
+
+### Detecting Generated Project Directory
+
+**Challenge**: After running a template command, we need to know which directory was created to apply migrations.
+
+**Solution**: Use `fspy` (a Rust file system monitoring crate) to monitor file operations during template execution, then derive the project directory from file paths.
+
+#### What fspy Achieves
+
+**Core Functionality**:
+
+- Monitor specific file operations (read/write of package.json) in real-time during template execution
+- Capture paths when package.json is written or read
+- Provide event stream of package.json operations
+- Efficient event-based watching without polling
+
+**How vite+ Uses It**:
+
+1. Start fspy watcher to monitor package.json operations before executing template
+2. Execute template (template creates package.json in new project)
+3. Capture package.json write/create path (e.g., `packages/my-app/package.json`)
+4. Stop watcher when template completes
+5. **Derive project directory** from package.json path (e.g., from `packages/my-app/package.json` → extract `packages/my-app`)
+6. Use detected directory for subsequent migrations and workspace integration
+
+**Deduction Logic**:
+
+- Monitor for package.json file write/create operations
+- When package.json is written, capture its full path
+- Extract parent directory from the path (everything before `/package.json`)
+- This is the project directory
+
+**Example**:
+
+```
+Captured file operation:
+- packages/my-app/package.json      ← write
+
+Derived project directory: packages/my-app
+```
+
+**Benefits of Using fspy**:
+
+- ✅ Real-time detection during template execution
+- ✅ Accurate - every template creates package.json
+- ✅ Efficient - only monitors package.json, not all files
+- ✅ Simple - package.json path directly reveals project directory
+- ✅ Works for all templates regardless of output format
+- ✅ Rust-based performance
+
+**Why This is Necessary**:
+
+After detecting the project directory, we can:
+
+1. **Apply migrations** in the correct location
+2. **Update package.json** in the right project
+3. **Register path** in workspace configuration (pnpm-workspace.yaml or package.json)
+4. **Display next steps** with correct `cd` command
+
+## Implementation Architecture
+
+### Directory Structure
+
+```
+packages/
+└── vite-generator/
+    ├── src/
+    │   ├── index.ts            # Main entry point
+    │   ├── cli.ts              # CLI command handler
+    │   ├── runner.ts           # Universal template runner
+    │   ├── discovery.ts        # Template/package discovery
+    │   ├── executor.ts         # Template execution with fspy monitoring
+    │   ├── detector.ts         # Detect generated code patterns
+    │   ├── migrator.ts         # Apply migrations with ast-grep
+    │   ├── workspace.ts        # Monorepo integration
+    │   ├── dependencies.ts     # Workspace dependency selection
+    │   └── directory.ts        # Project directory detection
+    ├── migrations/             # Migration rules (YAML)
+    │   ├── vite-build.yaml
+    │   ├── eslint-to-oxlint.yaml
+    │   ├── vitest-config.yaml
+    │   └── typescript-config.yaml
+    ├── package.json
+    └── tsconfig.json
+```
+
+**Key Dependencies**:
+
+- `fspy` - File system monitoring for detecting created directories
+- `@ast-grep/napi` - AST-based code transformation
+- `@clack/prompts` - Beautiful CLI prompts
+- `commander` - CLI argument parsing
+- `yaml` - Parse pnpm-workspace.yaml
+- `minimatch` or `micromatch` - Glob pattern matching for workspace patterns
+
+### Template Discovery
+
+Templates can be located in multiple places:
+
+1. **Built-in scaffolds**: `@vite-plus/create-generator` - Scaffold for creating new generators
+2. **Workspace packages**: Generators within the monorepo (e.g., `@company/generator-api`, `tools/create-microservice`)
+3. **npm packages**: Any template from npm - bingo templates, create-* templates, etc.
+4. **Built-in vite+**: Optional monorepo-specific generators (e.g., `vite:application`)
+
+**Resolution Order:**
+
+```
+1. Check if name is "@vite-plus/create-generator" → generator scaffold
+2. Check if name starts with "vite:" → built-in vite+ generator
+3. Check workspace packages for matching name → workspace-local generator
+4. Check node_modules/{name}/package.json → installed template (any type)
+5. Check if it's an npm package name → offer to install from registry
+6. Error: template not found
+```
+
+**Template Type Detection**:
+
+- **Bingo template**: Has `bingo` dependency or `bingo-template` keyword
+- **Universal template**: Has `bin` entry in package.json
+- Both types are executed the same way and get the same post-processing
+
+**Example Workspace Structure:**
+
+```
+monorepo/
+├── apps/                  # Applications (user can select)
+│   └── web-app/
+├── packages/              # Shared packages (user can select)
+│   └── shared-lib/
+├── services/              # Backend services (user can select)
+├── tools/                 # Development tools (user can select)
+│   └── generators/
+│       ├── ui-lib/             # @company/generator-ui-lib
+│       └── react-component/    # @company/generator-component
+├── pnpm-workspace.yaml    # For pnpm
+├── pnpm-lock.yaml         # Indicates pnpm usage
+└── package.json           # Root package.json (workspaces field for npm/yarn/bun)
+```
+
+**Workspace Configuration Examples:**
+
+**For pnpm (pnpm-workspace.yaml):**
+
+```yaml
+packages:
+  - 'apps/*'
+  - 'packages/*'
+  - 'services/*'
+  - 'tools/*'
+```
+
+**For npm/yarn/bun (package.json):**
+
+```json
+{
+  "name": "my-monorepo",
+  "private": true,
+  "workspaces": [
+    "apps/*",
+    "packages/*",
+    "services/*",
+    "tools/*"
+  ]
+}
+```
+
+**Detection Logic:**
+
+1. Check for lock files to determine package manager
+2. Read workspace config from appropriate file
+3. Extract parent directories: `apps`, `packages`, `services`, `tools`
+4. Prompt user to select one
+
+### Template Execution Pipeline
+
+vite+ acts as an intelligent wrapper that:
+
+1. **Pre-processing**:
+   - Detect template type (bingo vs universal)
+   - **If in monorepo**: Prompt for target directory (apps, packages, services, etc.)
+   - Discover workspace packages for dependency selection
+   - Capture pre-generation snapshot (for universal templates)
+
+2. **Execution**:
+   - Parse CLI arguments: options before `--` are for vite+, options after `--` are for template
+   - Execute the template using Node.js: `node node_modules/{template}/bin/index.js [args-after---]`
+   - Pass through template arguments (everything after `--`)
+   - Template runs with full interactivity
+
+3. **Post-processing** (same for ALL templates):
+   - **Detect & Migrate**: Analyze generated code with ast-grep
+     - Detect standalone vite/vitest/oxlint/oxfmt
+     - Prompt user to upgrade to vite-plus unified toolchain
+     - Apply migration if confirmed
+   - **Monorepo Integration**:
+     - Prompt for workspace dependencies to add
+     - Update generated package.json with selected dependencies
+     - Update workspace config if needed (add to pnpm-workspace.yaml or package.json workspaces)
+     - Run `vite install` to link workspace dependencies
+
+**Implementation Note**:
+
+- vite+ CLI parses options before `--` (e.g., `--no-migrate`, `--deps`)
+- Options after `--` are passed through to the template as-is
+- No Rust-JS bridge needed - we shell out to Node.js to run templates
+
+### Template Execution Flow
+
+```
+1. User runs: vite gen [template-name] [vite-options] -- [template-options]
+   ↓
+2. vite+ parses CLI arguments (split on -- separator)
+   ↓
+3. IF no template-name provided: Enter interactive mode
+   ├─ Show template selection menu (Vite+ Monorepo, Vite+ Generator, Vite, TanStack, Other)
+   ├─ Handle special templates with auto-argument injection
+   └─ Continue with selected template
+   ↓
+4. vite+ checks if running in a monorepo workspace
+   ↓
+5. IF in monorepo: Prompt user to select target directory (apps, packages, etc.)
+   ↓
+6. vite+ discovers and identifies template type (bingo vs universal)
+   ↓
+7. vite+ captures pre-generation snapshot (file list)
+   ↓
+8. vite+ loads workspace packages for dependency selection
+   ↓
+9. vite+ starts fspy watcher to monitor package.json operations
+   ↓
+10. vite+ executes template: node node_modules/{template}/bin/index.js [template-options]
+    (with cwd set to selected directory or passing directory as argument)
+    ↓
+11. Template runs (handles all prompts, validation, file generation)
+    ↓
+12. Template completes successfully
+    ↓
+13. vite+ stops fspy watcher and derives project directory from package.json path
+    ↓
+14. vite+ post-processes in detected project directory (same for ALL templates):
+
+   AUTO-MIGRATE TO VITE-PLUS:
+   ├─ Detect standalone vite/vitest/oxlint/oxfmt
+   ├─ Prompt to upgrade to vite-plus unified toolchain
+   └─ If yes, apply migration with ast-grep:
+       ├─ Dependencies: vite + vitest + oxlint + oxfmt → vite-plus
+       ├─ Merge vitest.config.ts → vite.config.ts
+       ├─ Merge .oxlintrc → vite.config.ts
+       ├─ Merge .oxfmtrc → vite.config.ts
+       └─ Remove standalone config files
+
+   MONOREPO INTEGRATION:
+   ├─ Prompt user to select workspace dependencies
+   ├─ Update package.json with workspace:* dependencies
+   ├─ Check if project path matches workspace patterns
+   ├─ If not matched: Update workspace config (pnpm-workspace.yaml or package.json)
+   ├─ Run vite install to link workspace dependencies
+   └─ Display next steps and tips
+```
+
+This approach is **simple and robust**:
+
+- ✅ No need to embed a JavaScript runtime in Rust
+- ✅ No need to maintain compatibility with template APIs
+- ✅ Any template works out of the box (bingo or universal)
+- ✅ Template authors can publish to npm normally
+- ✅ Adds vite+ optimization through intelligent migration
+- ✅ Seamless monorepo integration
+
+**Implementation Notes**:
+
+- **GitHub Templates**: Uses degit via npx for zero-config cloning
+- **Error Handling**: Provides context-specific troubleshooting tips
+- **Update Mode**: Foundation in place for transition mode generators
+- **Caching**: Relies on native npm/pnpm caching mechanisms
+
+## Usage Examples
+
+### Example 1: Universal Template (create-vite) with Auto-Execution
+
+When a template is not installed locally, vite+ automatically uses the appropriate package manager runner:
+
+```bash
+$ vite gen create-vite -- --template react-ts
+
+┌  🎨 Vite+ Code Generator
+│
+◇  Discovering template: create-vite
+│
+●  Template not installed locally, will run using pnpm dlx
+│
+◇  Executing template...
+│
+●  Running: pnpm dlx create-vite --template react-ts
+│
+# Template runs interactively via pnpm dlx...
+
+# vite+ prompts for target directory in monorepo
+◆  Where should we create the new package?
+│  ○ apps/        (Applications)
+│  ● packages/    (Shared packages)
+│  ○ services/    (Backend services)
+│
+◇  Selected: packages/
+│
+# Template prompts
+✔ Project name: › my-react-app
+✔ Select a framework: › React
+✔ Select a variant: › TypeScript
+
+Scaffolding project in ./packages/my-react-app...
+
+Done. Now run:
+  cd my-react-app
+  vite install
+  vite dev
+
+# vite+ detects standalone vite tools
+◇  Template completed! Detecting vite-related tools...
+│
+◆  Detected standalone vite tools:
+│  ✓ vite ^5.0.0
+│  ✓ vitest ^1.0.0
+│
+◆  Upgrade to vite-plus unified toolchain?
+│
+│  This will:
+│  • Replace vite + vitest with single vite-plus dependency
+│  • Merge vitest.config.ts into vite.config.ts
+│  • Remove standalone vitest.config.ts
+│
+│  Benefits:
+│  • Unified dependency management
+│  • Single configuration file
+│  • Better integration with vite+ task runner
+│
+│  ● Yes / ○ No
+│
+◇  Migrating to vite-plus...
+│  ✓ Updated package.json (vite + vitest → vite-plus)
+│  ✓ Merged vitest.config.ts → vite.config.ts
+│  ✓ Removed vitest.config.ts
+│
+◆  Add workspace packages as dependencies?
+│
+│  ◼ @company/ui-components - Shared React components
+│  ◼ @company/utils - Utility functions
+│  ◻ @company/api-client - API client library
+│
+◇  Selected: @company/ui-components, @company/utils
+│
+◇  Updating packages/my-react-app/package.json...
+◇  Added dependencies:
+│  - @company/ui-components@workspace:*
+│  - @company/utils@workspace:*
+│
+◇  Checking workspace configuration...
+◇  Project matches pattern 'packages/*' ✓
+◇  Running vite install...
+│
+└  Done!
+
+🎉 Successfully created my-react-app with vite-plus
+
+Next steps:
+  cd packages/my-react-app
+  vite dev
+```
+
+### Example 2: Complete Monorepo Integration Flow
+
+This example shows the full monorepo integration with workspace dependency selection:
+
+```bash
+$ cd my-monorepo
+$ vite gen create-vite -- --template react-ts
+
+┌  🎨 Vite+ Code Generator
+│
+◆  Where should we create the new package?
+│  ○ apps/
+│  ● packages/
+│  ○ tools/
+│
+◇  Selected: packages/
+│
+◇  Discovering template: create-vite
+│
+●  Template not installed locally, will run using pnpm dlx
+│
+◇  Executing template...
+│
+●  Running: pnpm dlx create-vite --template react-ts
+│
+# create-vite runs interactively...
+✔ Project name: › ui-components
+✔ Select a framework: › React
+✔ Select a variant: › TypeScript
+
+Scaffolding project in ./ui-components...
+
+Done. Now run:
+  cd ui-components
+  npm install
+  npm run dev
+
+◆  Template executed successfully
+│
+◆  Detected project directory: packages/ui-components
+│
+◇  Auto-migration to vite+...
+│
+●  Detected standalone vite tools: vite, vitest
+│
+◆  Upgrade to vite-plus unified toolchain?
+│  ● Yes / ○ No
+│
+●  This will:
+│  • Replace vite + vitest with single vite dependency
+│  • Update script commands to use vite CLI
+│  • Use catalog: version
+│
+◆  Migrated to vite-plus ✓
+│  • Removed: vite, vitest
+│  • Added: vite (catalog:)
+│
+◇  Monorepo integration...
+│
+◆  Add workspace packages as dependencies?
+│  ◼ @company/utils - Utility functions
+│  ◼ @company/theme - Design tokens and theme
+│  ◻ @company/icons - Icon library
+│  ◻ @company/api-client - API client
+│
+◇  Selected: @company/utils, @company/theme
+│
+◆  Added 2 workspace dependencies
+│  • @company/utils@workspace:*
+│  • @company/theme@workspace:*
+│
+◆  Project matches workspace pattern ✓
+│
+◒  Running vite install...
+│
+◆  Dependencies linked
+│
+└  ✨ Generation completed!
+
+Next steps:
+  cd packages/ui-components
+  vite dev
+```
+
+### Example 3: Creating a Generator Scaffold
+
+Use the built-in `vite:generator` to quickly scaffold a new generator:
+
+```bash
+$ vite gen vite:generator
+
+┌  🎨 Vite+ Code Generator
+│
+◇  Discovering template: vite:generator
+│
+◆  Found builtin template: vite:generator
+│
+◇  Creating generator scaffold...
+│
+◇  Generator name:
+│  ui-lib
+│
+◇  Package name:
+│  @company/generator-ui-lib
+│
+◇  Description:
+│  Generate new UI component libraries
+│
+◇  Where to create?
+│  tools/generators/ui-lib
+│
+◆  Generator scaffold created
+│  • package.json
+│  • bin/index.js
+│  • src/template.ts
+│  • README.md
+│  • tsconfig.json
+│
+◆  Detected project directory: tools/generators/ui-lib
+│
+◇  Monorepo integration...
+│
+◆  Project doesn't match existing workspace patterns
+│
+◆  Update workspace configuration to include this project?
+│  ● Yes
+│
+◆  Updated workspace configuration
+│
+◒  Running vite install...
+│
+◆  Dependencies linked
+│
+└  ✨ Generation completed!
+
+Summary:
+  • Template: vite:generator (builtin)
+  • Created: tools/generators/ui-lib
+  • Actions: Updated workspace config
+
+Next steps:
+  cd tools/generators/ui-lib
+  # Edit src/template.ts to customize your generator
+  # Then test it with: vite gen @company/generator-ui-lib
+```
+
+The generated scaffold includes:
+
+- **package.json**: Pre-configured with bingo, zod, bin entry, keywords
+- **bin/index.js**: Executable entry point that runs the template
+- **src/template.ts**: Example bingo template with TODO comments for customization
+- **README.md**: Usage instructions and development guide
+- **tsconfig.json**: TypeScript configuration extending monorepo root
+
+### Example 4: Built-in vite:application Generator
+
+Use the built-in `vite:application` generator for a vite+ optimized project:
+
+```bash
+$ vite gen vite:application
+
+┌  🎨 Vite+ Code Generator
+│
+◇  Discovering template: vite:application
+│
+◆  Found builtin template: vite:application
+│
+◇  Creating vite application...
+│
+◆  Select a framework:
+│  ● React (React with TypeScript)
+│  ○ Vue (Vue with TypeScript)
+│  ○ Svelte (Svelte with TypeScript)
+│  ○ Solid (Solid with TypeScript)
+│  ○ Vanilla (Vanilla TypeScript)
+│
+◇  Project name:
+│  my-app
+│
+◇  Generating react-ts project...
+│
+# create-vite runs...
+│
+◆  Project generated with vite+ configuration
+│  • Added vite-task.json with build/test/lint/dev tasks
+│
+◆  Detected project directory: my-app
+│
+◇  Auto-migration to vite+...
+│
+●  Detected standalone vite tools: vite
+│
+◆  Migrated to vite-plus ✓
+│
+└  ✨ Generation completed!
+
+Summary:
+  • Template: vite:application (builtin)
+  • Created: my-app
+  • Actions: Migrated to vite-plus
+
+Next steps:
+  cd my-app
+  vite dev
+```
+
+The generated project includes:
+
+- Standard create-vite project structure
+- **vite-task.json**: Pre-configured tasks (build, test, lint, dev)
+- **Migrated**: Already using vite-plus instead of standalone vite
+- **Ready**: Immediately usable with vite+ task runner
+
+### Example 5: Bingo Template (create-typescript-app)
+
+```bash
+# Use create-typescript-app (a popular bingo template)
+vite gen create-typescript-app
+
+┌  vite gen create-typescript-app
+│
+# vite+ prompts for target directory first
+◆  Where should we create the new package?
+│  ○ apps/
+│  ● packages/
+│  ○ tools/
+│
+◇  Selected: packages/
+│
+# Bingo's interactive prompts
+◇  Repository name: my-lib
+◇  Repository owner: mycompany
+◇  Which preset? › common
+│
+└  Template completed successfully!
+
+# vite+ ALSO detects standalone vite tools (even for bingo templates)
+◇  Template completed! Detecting vite-related tools...
+│
+◆  Detected standalone vite tools:
+│  ✓ vite ^5.0.0
+│  ✓ vitest ^1.0.0
+│
+◆  Upgrade to vite-plus unified toolchain?
+│
+│  This will:
+│  • Replace vite + vitest with single vite-plus dependency
+│  • Merge vitest.config.ts into vite.config.ts
+│
+│  ● Yes / ○ No
+│
+◇  Migrating to vite-plus...
+│  ✓ Updated package.json dependencies
+│  ✓ Merged vitest.config.ts → vite.config.ts
+│  ✓ Removed vitest.config.ts
+│
+◆  Add workspace packages as dependencies?
+│
+│  ◼ @mycompany/utils - Utility functions
+│  ◼ @mycompany/logger - Logging library
+│  ◻ @mycompany/database - Database client
+│
+◇  Selected: @mycompany/utils, @mycompany/logger
+│
+◇  Updating packages/my-lib/package.json...
+◇  Checking workspace configuration...
+◇  Project matches pattern 'packages/*' ✓
+◇  Running vite install...
+│
+└  Done!
+
+🎉 Successfully created my-lib with vite+ optimizations
+
+Next steps:
+  cd packages/my-lib
+  vite dev
+```
+
+**Notice**: Even though create-typescript-app is a bingo template, it still gets the same auto-migration treatment to optimize for vite+!
+
+### Example 3: Creating a Workspace-Local Bingo Generator
+
+#### Quick Start with @vite-plus/create-generator
+
+Use the official scaffold to quickly create a new generator:
+
+```bash
+# Create a new generator in your monorepo
+vite gen @vite-plus/create-generator
+
+┌  @vite-plus/create-generator
+│
+◇  Generator name: ui-lib
+◇  Generator package name: @company/generator-ui-lib
+◇  Description: Generate new UI component libraries for our monorepo
+◇  Where to create? › tools/generators/ui-lib
+│
+◇  Creating generator scaffold...
+│  ✓ Created package.json
+│  ✓ Created bin/index.js
+│  ✓ Created src/template.ts
+│  ✓ Created src/template.test.ts
+│  ✓ Created README.md
+│
+◇  Installing dependencies...
+│
+└  Done!
+
+✅ Generator created at tools/generators/ui-lib
+
+Next steps:
+  1. cd tools/generators/ui-lib
+  2. Edit src/template.ts to define your generator logic
+  3. Test with: vite gen @company/generator-ui-lib
+```
+
+#### Generated Structure
+
+In a real monorepo, write custom bingo generators as proper packages alongside your apps and libraries:
+
+```
+monorepo/
+├── apps/
+│   ├── api-gateway/
+│   └── web-app/
+├── packages/                    # Generated packages go here
+├── tools/
+│   └── generators/
+│       └── ui-lib/              # The generator package
+│           ├── package.json
+│           ├── bin/
+│           │   └── index.js
+│           ├── src/
+│           │   └── template.ts
+│           └── templates/
+│               ├── package.json.hbs
+│               └── src/
+│                   └── index.ts.hbs
+└── pnpm-workspace.yaml
+```
+
+**Generator Package Configuration** (auto-generated by `@vite-plus/create-generator`):
+
+```json
+// tools/generators/ui-lib/package.json
+{
+  "name": "@company/generator-ui-lib",
+  "version": "1.0.0",
+  "type": "module",
+  "private": true,
+  "description": "Generate new UI component libraries for our monorepo",
+  "bin": {
+    "create-ui-lib": "./bin/index.js"
+  },
+  "keywords": ["bingo-template", "vite-plus-generator"],
+  "scripts": {
+    "test": "vitest"
+  },
+  "dependencies": {
+    "bingo": "^0.5.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "bingo-testers": "^0.5.0",
+    "vitest": "^1.0.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0"
+  }
+}
+```
+
+**Template Implementation** (scaffold provided by `@vite-plus/create-generator`):
+
+The scaffold includes a complete, working example that you can customize:
+
+```typescript
+// tools/generators/ui-lib/src/template.ts
+import { createTemplate } from 'bingo';
+import { z } from 'zod';
+
+// This file is scaffolded by @vite-plus/create-generator
+// Edit the options and produce() function to customize your generator
+
+export default createTemplate({
+  about: {
+    name: 'UI Library Generator',
+    description: 'Create a new React component library with TypeScript',
+  },
+
+  options: {
+    name: z.string()
+      .regex(/^[a-z][a-z0-9-]*$/, 'Must be lowercase with hyphens')
+      .describe('Library name (e.g., design-system, ui-components)'),
+
+    framework: z.enum(['react', 'vue', 'svelte'])
+      .default('react')
+      .describe('UI framework'),
+
+    storybook: z.boolean()
+      .default(true)
+      .describe('Include Storybook for component documentation'),
+
+    cssInJs: z.boolean()
+      .default(false)
+      .describe('Include CSS-in-JS library (styled-components)'),
+  },
+
+  async produce({ options }) {
+    const libPath = `packages/${options.name}`;
+    const packageName = `@company/${options.name}`;
+
+    return {
+      files: {
+        [`${libPath}/package.json`]: JSON.stringify(
+          {
+            name: packageName,
+            version: '0.1.0',
+            type: 'module',
+            private: true,
+            main: './dist/index.js',
+            module: './dist/index.mjs',
+            types: './dist/index.d.ts',
+            exports: {
+              '.': {
+                import: './dist/index.mjs',
+                require: './dist/index.js',
+                types: './dist/index.d.ts',
+              },
+            },
+            scripts: {
+              dev: 'vite',
+              build: 'vite build && tsc --emitDeclarationOnly',
+              test: 'vitest',
+              lint: 'oxlint',
+              ...(options.storybook && { storybook: 'storybook dev -p 6006' }),
+            },
+            peerDependencies: {
+              [options.framework]: '^18.0.0',
+            },
+            dependencies: {
+              ...(options.cssInJs && { 'styled-components': '^6.0.0' }),
+            },
+            devDependencies: {
+              '@types/react': '^18.0.0',
+              '@vitejs/plugin-react': '^4.2.0',
+              typescript: '^5.3.0',
+              vitest: '^1.0.0',
+              vite: '^5.0.0',
+              ...(options.storybook && {
+                '@storybook/react': '^7.6.0',
+                '@storybook/react-vite': '^7.6.0',
+              }),
+            },
+          },
+          null,
+          2,
+        ),
+
+        [`${libPath}/tsconfig.json`]: JSON.stringify(
+          {
+            extends: '../../tsconfig.base.json',
+            compilerOptions: {
+              outDir: './dist',
+              rootDir: './src',
+              declaration: true,
+              declarationMap: true,
+            },
+            include: ['src/**/*'],
+          },
+          null,
+          2,
+        ),
+
+        [`${libPath}/vite.config.ts`]: `
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    lib: {
+      entry: './src/index.ts',
+      formats: ['es', 'cjs'],
+      fileName: (format) => \`index.\${format === 'es' ? 'mjs' : 'js'}\`,
+    },
+    rollupOptions: {
+      external: ['react', 'react-dom'],
+    },
+  },
+});
+        `.trim(),
+
+        [`${servicePath}/src/index.ts`]: `
+import express from 'express';
+${options.authentication ? "import { authMiddleware } from './middleware/auth.js';" : ''}
+${options.database !== 'none' ? `import { initDatabase } from './database.js';` : ''}
+
+const app = express();
+const PORT = ${options.port};
+
+// Middleware
+app.use(express.json());
+${options.authentication ? 'app.use(authMiddleware);' : ''}
+
+// Routes
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    service: '${options.name}',
+    timestamp: new Date().toISOString(),
+  });
+});
+
+app.get('/api/${options.name}', (req, res) => {
+  res.json({ message: 'Hello from ${options.name}!' });
+});
+
+// Start server
+async function start() {
+  ${options.database !== 'none' ? 'await initDatabase();' : ''}
+
+  app.listen(PORT, () => {
+    console.log(\`🚀 ${options.name} running on http://localhost:\${PORT}\`);
+  });
+}
+
+start().catch(console.error);
+        `.trim(),
+
+        ...(options.database !== 'none' && {
+          [`${servicePath}/src/database.ts`]: `
+import { ${getDatabaseClient(options.database)} } from '${getDatabasePackage(options.database)}';
+
+export async function initDatabase() {
+  // TODO: Initialize ${options.database} connection
+  console.log('📦 Database connected');
+}
+          `.trim(),
+        }),
+
+        ...(options.authentication && {
+          [`${servicePath}/src/middleware/auth.ts`]: `
+import { Request, Response, NextFunction } from 'express';
+
+export function authMiddleware(req: Request, res: Response, next: NextFunction) {
+  // TODO: Implement JWT authentication
+  next();
+}
+          `.trim(),
+        }),
+
+        [`${servicePath}/.env.example`]: [
+          `PORT=${options.port}`,
+          `NODE_ENV=development`,
+          options.database !== 'none' && `DATABASE_URL=${getDatabaseUrl(options.database, options.name)}`,
+        ].filter(Boolean).join('\n'),
+
+        [`${servicePath}/README.md`]: `
+# ${packageName}
+
+API microservice for ${options.name}.
+
+## Development
+
+\`\`\`bash
+# Install dependencies
+vite install
+
+# Start dev server
+vite dev
+
+# Run tests
+vite test
+
+# Build
+vite build
+\`\`\`
+
+## Configuration
+
+- Port: ${options.port}
+- Database: ${options.database}
+- Authentication: ${options.authentication ? 'Enabled' : 'Disabled'}
+        `.trim(),
+      },
+
+      scripts: [
+        {
+          phase: 0,
+          commands: [
+            `cd ${libPath}`,
+            'vite install',
+          ],
+        },
+      ],
+
+      suggestions: [
+        `✅ Created ${options.name} component library in ${libPath}`,
+        ``,
+        `Next steps:`,
+        `  1. cd ${libPath}`,
+        `  2. Add your components to src/components/`,
+        `  3. Export them in src/index.ts`,
+        `  4. vite build`,
+        options.storybook && `  5. npm run storybook (view component docs)`,
+        ``,
+        `The library is ready to be used in other packages!`,
+      ].filter(Boolean),
+    };
+  },
+});
+```
+
+**CLI Entrypoint** (auto-generated by `@vite-plus/create-generator`):
+
+```javascript
+#!/usr/bin/env node
+// tools/generators/ui-lib/bin/index.js
+import { runTemplate } from 'bingo';
+import template from '../src/template.js';
+
+runTemplate(template);
+```
+
+**README** (auto-generated by `@vite-plus/create-generator`):
+
+```markdown
+# @company/generator-ui-lib
+
+Generate new UI component libraries for our monorepo.
+
+## Usage
+
+From monorepo root:
+
+\`\`\`bash
+vite gen @company/generator-ui-lib
+\`\`\`
+
+With options:
+
+\`\`\`bash
+vite gen @company/generator-ui-lib --name=design-system --framework=react
+\`\`\`
+
+## Development
+
+\`\`\`bash
+
+# Run tests
+
+vite test
+
+# Test the generator
+
+vite gen @company/generator-ui-lib
+\`\`\`
+
+## Customization
+
+Edit `src/template.ts` to customize:
+
+- Options schema (using Zod)
+- File generation logic
+- Scripts and suggestions
+```
+
+**Usage in the Monorepo:**
+
+```bash
+# Run from monorepo root
+vite gen @company/generator-ui-lib
+
+# Bingo generator prompts
+┌  @company/generator-ui-lib
+│
+◇  Library name: design-system
+◇  Framework: React
+◇  Include Storybook? Yes
+◇  Include CSS-in-JS? No
+│
+└  Template completed!
+
+# vite+ ALSO detects standalone vite tools (even for bingo templates!)
+◇  Template completed! Detecting vite-related tools...
+│
+◆  Detected standalone vite tools:
+│  ✓ vite ^5.0.0
+│  ✓ vitest ^1.0.0
+│
+◆  Upgrade to vite-plus unified toolchain?
+│
+│  This will:
+│  • Replace vite + vitest with vite-plus
+│  • Merge configs into vite.config.ts
+│
+│  ● Yes / ○ No
+│
+◇  Migrating to vite-plus...
+│  ✓ Updated package.json dependencies
+│  ✓ Merged vitest.config.ts → vite.config.ts
+│  ✓ Removed standalone config files
+│
+◆  Add workspace packages as dependencies?
+│
+│  ◼ @company/theme - Design tokens and theme
+│  ◼ @company/utils - Utility functions
+│  ◼ @company/icons - Icon library
+│  ◻ @company/hooks - React hooks
+│
+◇  Selected: @company/theme, @company/utils, @company/icons
+│
+◇  Updating packages/design-system/package.json...
+◇  Checking workspace configuration...
+◇  Project matches pattern 'packages/*' ✓
+◇  Running vite install...
+│
+└  Done!
+
+✅ Created design-system component library with vite+ optimizations
+
+Next steps:
+  1. cd packages/design-system
+  2. Add components to src/components/
+  3. Export in src/index.ts
+  4. vite build
+  5. npm run storybook (view docs)
+
+# CLI options
+vite gen @company/generator-ui-lib --name=icons --no-migrate  # Skip migrations
+vite gen @company/generator-ui-lib --name=hooks --deps=@company/utils  # Pre-select deps
+```
+
+**Key Point**: Even your own bingo generators benefit from auto-migration! You can generate code using standalone vite/vitest/oxlint, and vite+ will automatically consolidate them into vite-plus.
+
+**Tip**: Use `vite gen @vite-plus/create-generator` to quickly scaffold a new generator in your monorepo!
+
+**Testing the Generator:**
+
+```typescript
+// tools/generators/ui-lib/src/template.test.ts
+import { testTemplate } from 'bingo/testers';
+import { describe, expect, it } from 'vitest';
+import template from './template.js';
+
+describe('UI Library Generator', () => {
+  it('generates library with storybook', async () => {
+    const result = await testTemplate(template, {
+      options: {
+        name: 'design-system',
+        framework: 'react',
+        storybook: true,
+        cssInJs: false,
+      },
+    });
+
+    expect(result.files['packages/design-system/package.json']).toContain('@company/design-system');
+    expect(result.files['packages/design-system/package.json']).toContain('@storybook/react');
+    expect(result.files['packages/design-system/src/components/Button.tsx']).toBeDefined();
+    expect(result.files['packages/design-system/.storybook/main.ts']).toBeDefined();
+  });
+
+  it('generates library without storybook', async () => {
+    const result = await testTemplate(template, {
+      options: {
+        name: 'icons',
+        framework: 'react',
+        storybook: false,
+        cssInJs: false,
+      },
+    });
+
+    expect(result.files['packages/icons/.storybook/main.ts']).toBeUndefined();
+    expect(result.files['packages/icons/src/components/Button.stories.tsx']).toBeUndefined();
+  });
+});
+```
+
+### Built-in vite+ Generator (Optional)
+
+For monorepo-specific needs, vite+ can provide thin wrappers:
+
+```bash
+# Built-in generator that configures vite-task.json automatically
+vite gen vite:library --name=shared-utils
+
+# This could wrap an existing bingo template and add:
+# - vite-task.json with build/test/lint tasks
+# - Proper workspace structure
+# - TypeScript configuration for monorepo
+```
+
+## Technical Considerations
+
+### 1. Process Execution & Directory Detection
+
+- **Subprocess Management**: Use Node.js `child_process.spawn()` to execute templates
+- **Stdio Handling**: Use `inherit` mode to pass through stdin/stdout/stderr for interactive prompts
+- **Directory Detection**: Use `fspy` to monitor package.json operations during template execution
+  - Watch specifically for package.json write/create operations
+  - Capture package.json file path when written
+  - Derive project root from package.json path (extract parent directory)
+  - Handle multiple package.json writes (choose the first top-level one)
+  - Handle in-place generation (package.json created in cwd)
+- **Exit Codes**: Properly handle template exit codes and surface errors
+- **Working Directory**: Use `cwd` option to ensure template runs in the correct directory
+
+### 2. Package Manager Detection & Workspace Config
+
+- **Auto-detect**: Determine package manager from lock files
+  - `pnpm-lock.yaml` → pnpm
+  - `package-lock.json` → npm
+  - `yarn.lock` → yarn
+  - `bun.lockb` → bun
+- **Read Workspace Config**: Based on detected package manager
+  - **pnpm**: Read `pnpm-workspace.yaml`, parse `packages` array
+  - **npm/yarn/bun**: Read root `package.json`, parse `workspaces` array
+- **Respect Workspace**: Use the same package manager as the monorepo
+- **Installation**: When prompting to install, use the detected package manager
+
+### 3. Template Detection
+
+- **package.json Parsing**: Read package.json to check for bingo dependency
+- **Bin Entry**: Look for bin field to find the executable
+- **Keywords**: Check for "bingo-template" keyword as fallback
+- **Validation**: Warn if package doesn't look like a valid bingo template
+
+### 4. Monorepo Integration
+
+- **Workspace Detection**: Check if running in a monorepo workspace
+- **Directory Selection**: Prompt user to select target directory (apps, packages, services, etc.)
+  - Read workspace config (pnpm-workspace.yaml or package.json workspaces)
+  - Extract parent directories from workspace patterns
+  - Present as interactive selection
+  - Can be overridden with `--directory` flag
+- **Workspace Package Discovery**: Load all packages from workspace with their metadata
+  - Use detected package manager's workspace patterns
+  - Resolve glob patterns to find all packages
+- **Dependency Selection UI**: Multi-select prompt for choosing workspace dependencies
+- **Smart Filtering**: Filter packages by type (exclude generators, include libraries)
+- **Version Protocol**: Use `workspace:*` for workspace dependencies
+- **Package.json Updates**: Parse and update generated package.json with selected deps
+- **Workspace Registration**: Check if detected project matches existing workspace patterns
+  - If matches (e.g., `packages/my-app` matches `packages/*`): ✅ No update needed
+  - If not matched: Update workspace config file
+    - **pnpm**: Add pattern to pnpm-workspace.yaml `packages` array
+    - **npm/yarn/bun**: Add pattern to package.json `workspaces` array
+- **Dependency Installation**: Run `vite install` to link workspace dependencies
+- **Path Normalization**: Ensure paths are relative to workspace root
+- **Idempotency**: Don't duplicate patterns if already exist
+
+### 5. Error Handling
+
+- **Clear Messages**: Distinguish between vite+ errors and template errors
+- **Installation Failures**: Handle vite install failures gracefully
+- **Partial Completion**: If template creates files but errors, inform user
+- **Troubleshooting**: Provide hints for common issues (Node.js not found, etc.)
+
+### 6. Testing
+
+Testing can leverage bingo's own test utilities:
+
+```typescript
+// Template authors test using bingo's testing tools
+import { testTemplate } from 'bingo/testers';
+import { expect, test } from 'vitest';
+import template from './template';
+
+test('generates React app', async () => {
+  const result = await testTemplate(template, {
+    options: { name: 'my-app', framework: 'react' },
+  });
+
+  expect(result.files['package.json']).toContain('react');
+});
+```
+
+vite+ template runner logic is also tested using TypeScript/Vitest:
+
+```typescript
+// In vite_generator package
+import { describe, expect, it } from 'vitest';
+import { detectBingoTemplate, loadWorkspacePackages } from './discovery';
+
+describe('Template Detection', () => {
+  it('detects bingo template from package.json', async () => {
+    const pkg = {
+      name: 'create-typescript-app',
+      dependencies: { 'bingo': '^0.5.0' },
+      bin: { 'create-typescript-app': './bin/index.js' },
+    };
+
+    expect(detectBingoTemplate(pkg)).toBe(true);
+  });
+
+  it('detects bingo template from keywords', async () => {
+    const pkg = {
+      name: 'my-template',
+      keywords: ['bingo-template'],
+      bin: { 'my-template': './index.js' },
+    };
+
+    expect(detectBingoTemplate(pkg)).toBe(true);
+  });
+});
+
+describe('Workspace Package Discovery', () => {
+  it('loads all workspace packages', async () => {
+    const packages = await loadWorkspacePackages('/path/to/monorepo');
+
+    expect(packages).toContainEqual({
+      name: '@company/logger',
+      path: 'packages/logger',
+      description: 'Logging library',
+    });
+  });
+
+  it('filters out generator packages', async () => {
+    const packages = await loadWorkspacePackages('/path/to/monorepo', {
+      excludeGenerators: true,
+    });
+
+    expect(packages.every(pkg => !pkg.name.includes('generator'))).toBe(true);
+  });
+});
+```
+
+## Comparison: Bingo vs Universal Templates
+
+| Aspect                 | Bingo Templates              | Universal Templates             |
+| ---------------------- | ---------------------------- | ------------------------------- |
+| **Writing Experience** | ✅ Type-safe (Zod), testable | ⚠️ No standard, varies           |
+| **Examples**           | @company/generator-ui-lib    | create-vite, create-next-app    |
+| **Customization**      | ✅ Full control              | ⚠️ Limited to template options   |
+| **Auto-Migration**     | ✅ Yes (same as universal)   | ✅ Yes (same as bingo)          |
+| **Ecosystem**          | ~5-10 bingo templates        | Thousands of create-* templates |
+| **Learning Curve**     | Medium (learn bingo)         | Zero (use familiar templates)   |
+| **Maintenance**        | Maintained by you            | Maintained by template authors  |
+| **Best For**           | Custom company generators    | Quick starts, standard setups   |
+
+**Key Point**: Both bingo and universal templates get the **same auto-migration to vite-plus**. The difference is only in the authoring experience:
+
+- **Choose bingo** when you want to write custom generators with type safety and testing
+- **Choose universal** when you want to use existing templates from the ecosystem
+- **Both get auto-migrated** to vite-plus unified toolchain automatically!
+
+## Open Questions
+
+1. **Auto-installation UX**: Should we auto-install templates or always prompt first?
+2. **Template Caching**: Should we cache installed templates or always fetch latest?
+3. **Built-in Generators**: Which built-in generators (if any) should we provide?
+4. **Directory Selection**:
+   - Should we infer descriptions from directory names (e.g., "apps" → "Applications")?
+   - Should we support adding custom directories via `--directory=custom/path`?
+   - Should we remember last selected directory for next generation?
+5. **Dependency Selection**:
+   - Should we filter packages by type (e.g., exclude test utilities)?
+   - Should we have smart defaults based on generator type?
+   - Should we support dependency groups (e.g., "common backend libs")?
+6. **Version Protocol**: Always use `workspace:*` or allow specific version ranges?
+7. **Migration Safety**:
+   - Should we create backups before applying migrations?
+   - How to handle migration conflicts?
+   - Support rollback of migrations?
+8. **ast-grep Integration**:
+   - Should migration rules be YAML or TypeScript?
+   - Should we allow custom user-defined migrations?
+9. **Extensibility**:
+   - Plugin system for third-party migrations?
+   - How to share migrations across teams?
+
+## Success Criteria
+
+A successful implementation should:
+
+### Template Support
+
+1. ✅ Run ANY bingo template from npm without modification (via npx/pnpm dlx)
+2. ✅ Run ANY create-* or other universal templates (via npx/pnpm dlx)
+3. ✅ Support workspace-local bingo generators (scan workspace patterns)
+4. ✅ Auto-detect template type (bingo vs universal)
+5. ✅ Parse CLI arguments correctly (vite+ options before `--`, template options after `--`)
+6. ✅ Pass through template options correctly (everything after `--`)
+7. ✅ Handle interactive prompts properly (stdio inheritance)
+8. ✅ Detect generated project directory (directory scanning for package.json)
+9. ✅ Built-in @vite-plus/create-generator for scaffolding new generators
+10. ✅ Built-in vite:application and vite:library placeholders
+
+### Auto-Migration to vite-plus
+
+9. ✅ Automatically detect standalone vite/vitest/oxlint/oxfmt (in detected project directory)
+10. ✅ Prompt to upgrade to vite-plus unified toolchain
+11. ✅ Consolidate dependencies (vite + vitest + oxlint + oxfmt → unified vite)
+12. ✅ Update script commands (vitest → vite test, oxlint → vite lint, etc.)
+13. ✅ Provide clear before/after explanations
+14. ✅ Be safe and reversible
+15. ⏳ Merge configurations (vitest.config.ts, .oxlintrc, .oxfmtrc → vite.config.ts) - Future enhancement with ast-grep
+
+### Monorepo Integration
+
+16. ✅ Detect monorepo workspace and prompt for target directory
+17. ✅ Support `--directory` flag to skip directory selection
+18. ✅ Integrate with workspace (auto-update pnpm-workspace.yaml or package.json workspaces if needed)
+19. ✅ Prompt for workspace dependencies with multi-select UI
+20. ✅ Use `workspace:*` protocol for internal dependencies
+21. ✅ Run `vite install` to link dependencies
+22. ✅ Work with npm, pnpm, yarn, and bun package managers
+23. ✅ Smart package filtering (exclude generators from dependency selection)
+24. ✅ Support `--deps` flag for pre-selecting dependencies
+25. ✅ Workspace pattern matching and auto-update
+
+### Developer Experience
+
+26. ✅ No installation required (use npx/pnpm dlx/yarn dlx/bunx)
+27. ✅ Clear error messages distinguishing vite+ vs template errors
+28. ✅ Beautiful interactive prompts with @clack/prompts
+29. ✅ Show progress and feedback during generation/migration
+30. ✅ Display helpful next steps after completion (with correct directory path)
+31. ✅ Interactive mode with curated template selection
+32. ✅ Automatic argument injection for known templates
+
+## Benefits of This Approach
+
+### For vite+ Users
+
+- 🎯 **Maximum Choice**: Use bingo templates OR any create-* template
+- 🚀 **Zero Learning Curve**: Use familiar templates (create-vite, create-next-app, etc.)
+- 🔧 **Automatic Optimization**: Intelligent migration to vite+ toolchain
+- 🌍 **Entire Ecosystem**: Access to thousands of existing templates
+- 💼 **Company Generators**: Build reusable bingo templates for your team
+- 🔄 **Future-proof**: Works with templates created in the future
+
+### For Template Authors
+
+**Bingo Template Authors:**
+
+- ✍️ **Full Control**: Type-safe, testable, company-specific generators
+- 📦 **Monorepo-first**: Perfect for workspace-local generators
+- 🧪 **Built-in Testing**: Use bingo's testing utilities
+- 🚀 **Quick Start**: Use `@vite-plus/create-generator` to scaffold new generators
+
+**Universal Template Authors:**
+
+- ⚡ **Zero Effort**: Templates work as-is
+- 👥 **Wider Audience**: Automatically compatible with vite+
+- 🔄 **No Maintenance**: vite+ handles the optimization
+
+### For vite+ Maintainers
+
+- 🎯 **Best of Both Worlds**: Support both approaches
+- 🐛 **Simpler Architecture**: Templates run as-is, no complex API
+- 📚 **Leverage Docs**: Point to existing template documentation
+- ⚡ **Immediate Value**: Add value through intelligent post-processing
+- 🔧 **Extensible**: Easy to add new migrations as vite+ evolves
+
+## Related RFCs
+
+- [migration-command.md](./migration-command.md) - `vite migration` command for migrating existing projects
+  - Shares the same migration engine and rules
+  - `vite gen` runs migrations after template generation
+  - `vite migration` runs migrations on existing projects
+
+## References
+
+### Template Frameworks
+
+- [Bingo Framework](https://www.create.bingo/) - Type-safe repository templates
+- [Bingo FAQs](https://www.create.bingo/faqs/)
+- [create-typescript-app](https://github.com/JoshuaKGoldberg/create-typescript-app) - Production bingo template
+- [create-vite](https://github.com/vitejs/vite/tree/main/packages/create-vite) - Official Vite templates
+
+### Code Transformation
+
+- [ast-grep](https://ast-grep.github.io/) - Structural search and replace tool
+- [Turborepo Codemods](https://turborepo.com/docs/reference/turbo-codemod) - Similar migration approach
+- [jscodeshift](https://github.com/facebook/jscodeshift) - Alternative AST transformation tool
+
+### Inspiration
+
+- [Nx Generators](https://nx.dev/docs/features/generate-code) - Nx's generator system
+- [Turborepo Code Generation](https://turborepo.com/docs/guides/generating-code) - Turbo's PLOP-based approach
+- [PLOP Documentation](https://plopjs.com/documentation/) - Micro-generator framework
+
+### Tools
+
+- [Zod](https://zod.dev/) - TypeScript schema validation
+- [@clack/prompts](https://www.npmjs.com/package/@clack/prompts) - Beautiful CLI prompts