@raulmoracode/create 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 raulmoracode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,231 @@
+# @raulmoracode/create
+
+Professional CLI to scaffold modern React projects. Built with Node.js, TypeScript, [Clack](https://github.com/natemoo-re/clack) and pnpm.
+
+- **Package:** [`@raulmoracode/create`](https://www.npmjs.com/package/@raulmoracode/create) (published to npmjs)
+- **Repository:** [`raulmoracode/raulmoracode-create`](https://github.com/raulmoracode/raulmoracode-create)
+- **Command:** `raulmoracode-create`
+
+## Requirements
+
+- [Node.js](https://nodejs.org) 24 LTS
+- [pnpm](https://pnpm.io/installation) (declared per project via `packageManager`)
+- npm
+- [Git](https://git-scm.com/downloads) with a configured identity (`user.name` and `user.email`)
+- A GitHub account and an existing empty repository for the new project
+- `GH_TOKEN` (optional): only needed to install the private `@raulmoracode/icons` package. Without registry access, the project is generated without `.npmrc` and without icons — everything else is identical.
+- [VS Code](https://code.visualstudio.com) (optional, used to open the project at the end)
+
+## Install globally
+
+The package is published to [npmjs](https://www.npmjs.com/package/@raulmoracode/create). No authentication needed.
+
+```bash
+npm install -g @raulmoracode/create
+```
+
+Verify:
+
+```bash
+raulmoracode-create
+```
+
+## Usage
+
+```bash
+raulmoracode-create
+```
+
+The CLI guides you through the whole process with Clack prompts:
+
+1. Select the technology: **React + Vite** or **Next.js**.
+2. Select the technologies to include (everything preselected by default).
+3. Enter the project name.
+4. Enter the GitHub repository URL (the repository must already exist).
+5. The project is created with the official generators (`create-vite` / `create-next-app`) and fully configured.
+6. Git is initialized, the remote is configured, the initial commit is created and pushed to GitHub.
+7. Optionally open the project with VS Code.
+
+Available flags:
+
+```bash
+raulmoracode-create --verbose   # print the output of every external command
+raulmoracode-create --help      # show help
+raulmoracode-create --version   # show the installed version
+```
+
+## What the CLI does
+
+- Scaffolds with the **official generators** (never a hand-written template):
+  - React + Vite: `pnpm create vite@9.2.1 <name> --template react-ts` (the `create-vite` release line that scaffolds the Vite 8.x line; `create-vite@8.3.1` does not exist), then pins `vite@8.3.1`, `react@19.3.0` and `typescript@7.0.2`.
+  - Next.js: `pnpm create next-app@16.3.6 <name> --ts --app --src-dir --import-alias "@/*" --biome --use-pnpm --disable-git --yes`.
+- Installs dependencies with **pnpm** and pins exact versions (no `^` or `~`).
+- Configures **Tailwind CSS 4.3.3** (CSS-first configuration, `@tailwindcss/vite` for Vite and `@tailwindcss/postcss` for Next.js).
+- Prepares **shadcn**: writes a complete `components.json` (including the `@raulmoracode` registry) and the `cn()` helper (`src/lib/utils.ts`). No components are preinstalled; add them later with `pnpm dlx shadcn@latest add <component>`.
+- Configures the private **`@raulmoracode` registry** in `.npmrc` using `${GH_TOKEN}` (never a real token) — but only when registry access is detected; otherwise `.npmrc` and `@raulmoracode/icons` are skipped.
+- Installs **Zustand 5.0.15**, **React Hook Form 7.89.0**, **Zod 4.6.5**, **TanStack Query 5.104.0** and **@raulmoracode/icons 1.1.0**, and wires the TanStack Query provider.
+- Configures **Biome 2.5.14** (formatter, linter and organize imports) and removes the ESLint/Oxlint leftovers from the official templates.
+- Configures **Vitest 5.0.2**, **@testing-library/react 16.3.3** and **@testing-library/dom 10.4.2** (plus `jsdom`, required by Testing Library, and `clsx` + `tailwind-merge`, required by the shadcn `cn()` helper).
+- Configures **VS Code** (`.vscode/settings.json` and `.vscode/extensions.json`).
+- Pins **Node.js 24** via `.nvmrc` and writes `.editorconfig`.
+- Applies **branding**: tab title `raulmoracode` and favicon `https://cdn.raulmoracode.com/icons/favicon.ico` (in `index.html` for Vite, in the root layout metadata for Next.js).
+- Ships a minimal **starter** for React + Vite: `public/` and `src/assets/` are emptied, `App.tsx` renders a simple hello and `App.css` starts empty.
+- Ships a minimal **starter** for Next.js: `public/` is emptied and `page.tsx` renders a simple hello (its orphaned `page.module.css` is removed). `AGENTS.md` is kept and `CLAUDE.md` is removed.
+- Fills in **project metadata** in `package.json`: `author` (Raul Mora, https://raulmoracode.com), `homepage` and `repository` with the GitHub URL you enter at the start.
+- Writes **`pnpm-workspace.yaml`** with `minimumReleaseAge: 10080` plus `minimumReleaseAgeExclude` entries for every locked package, so installs keep working (pnpm enforces the policy against the whole lockfile, not just direct dependencies).
+- Initializes Git on `main`, adds the remote, creates the commit `chore: initial project setup` and pushes with `git push -u origin main` (never `--force`). If the remote already contains commits that do not exist locally, the process stops with a clear message instead of overwriting anything.
+
+## Generated projects
+
+Every generated project includes:
+
+- React + Vite or Next.js (official structure)
+- Tailwind CSS 4
+- shadcn ready (`components.json` with the `@raulmoracode` registry and the `cn()` helper)
+- `@raulmoracode` registry in `.npmrc` (`${GH_TOKEN}`, only with registry access)
+- Zustand
+- React Hook Form + Zod
+- TanStack Query (provider included)
+- Biome (format, lint, organize imports)
+- Vitest + Testing Library
+- VS Code settings
+- Branding (`raulmoracode` tab title and CDN favicon)
+- `pnpm-workspace.yaml` with `minimumReleaseAge: 10080`
+- Node.js 24 (`.nvmrc`)
+- pnpm (`pnpm-lock.yaml`, no `package-lock.json` or `yarn.lock`)
+- Git initialized and pushed to GitHub
+
+### Commands in a generated project
+
+```bash
+pnpm install
+pnpm dev
+pnpm build
+pnpm test
+pnpm check
+pnpm format
+pnpm lint
+```
+
+Add shadcn components (including the private registry):
+
+```bash
+pnpm dlx shadcn@latest add card
+pnpm dlx shadcn@latest add @raulmoracode/<component>
+```
+
+After adding components, normalize their style with Biome (the shadcn CLI uses its own formatting):
+
+```bash
+pnpm exec biome check --write .
+```
+
+Vite projects resolve the `@/*` alias to `src/*` (`tsconfig.app.json`, root `tsconfig.json` and `vite.config.ts`).
+
+Every generated project ships an `AGENTS.md` file with guidelines for AI coding agents (source of truth, conventions, validation, Git safety and security rules), plus a project tooling section (pnpm exclusively, script map and the shadcn workflow).
+
+## GitHub authentication
+
+The CLI runs `git push -u origin main`, so Git must be authenticated against GitHub. Any of these work:
+
+- [GitHub CLI](https://cli.github.com): `gh auth login`
+- A credential manager / SSH key configured for `github.com`
+- A `GH_TOKEN` / `GITHUB_TOKEN` environment variable together with a credential helper
+
+### Note on `GH_TOKEN` and pnpm >= 11.5.3
+
+The generated `.npmrc` references `${GH_TOKEN}` as mandated. However, since **pnpm 11.5.3** environment variables are **not** expanded in project-level `.npmrc` credential values (a security fix for [GHSA-3qhv-2rgh-x77r](https://github.com/pnpm/security/advisories/GHSA-3qhv-2rgh-x77r)): pnpm prints a warning and ignores that line, while the registry mapping (`@raulmoracode:registry=...`) still applies. To authenticate installs from GitHub Packages, keep your token in a **user-level** location where expansion works:
+
+```bash
+pnpm config set //npm.pkg.github.com/:_authToken "$GH_TOKEN"
+```
+
+or in `~/.npmrc`:
+
+```ini
+//npm.pkg.github.com/:_authToken=${GH_TOKEN}
+```
+
+## npm
+
+### Install
+
+```bash
+npm install -g @raulmoracode/create
+```
+
+### Update the global installation
+
+```bash
+npm install -g @raulmoracode/create
+```
+
+### Publish (maintainers)
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+npm publish --access public
+```
+
+Create the `NPM_TOKEN` (granular, read+write on `@raulmoracode/create`) at `npmjs.com > Access Tokens` and save it as `Settings > Secrets > Actions > NPM_TOKEN`.
+
+The repository also ships a GitHub Actions workflow (`.github/workflows/publish.yml`) that builds, tests and publishes the package to npmjs on every `v*` tag using `NPM_TOKEN`.
+
+## Development
+
+```bash
+pnpm install
+pnpm build
+pnpm test
+```
+
+Other useful scripts:
+
+```bash
+pnpm check    # biome check .
+pnpm format   # biome format --write .
+pnpm lint     # biome lint .
+```
+
+### Architecture
+
+```text
+src/
+├── index.ts               # entry point (shebang)
+├── cli/                   # orchestration and Clack output
+├── prompts/               # user interaction (Clack)
+├── generators/            # project configuration steps
+├── frameworks/            # vite / next specific logic
+├── git/                   # git command builders and wrappers
+├── config/                # configuration file templates
+└── utils/                 # exec, filesystem, validation
+tests/                     # vitest suite (external commands are mocked)
+```
+
+External commands are always executed with argument arrays through `utils/exec.ts` (never string interpolation), and every user input is validated before use.
+
+### Verified adjustments
+
+The following deviations from the naive expected configuration were verified against the real tools and are intentional:
+
+- **`create-vite@9.2.1`** is used for Vite projects because `create-vite@8.3.1` does not exist; the 9.x line is the one that scaffolds the Vite 8.x line. `vite` is then pinned to `8.3.1` exactly.
+- **`components.json`** must contain the full shadcn configuration (`$schema`, `style`, `tailwind`, `rsc`, `tsx`, `aliases`) because shadcn 4.x rejects a config with only `registries` — and `pnpm dlx shadcn@latest add card` is a hard requirement. The `@raulmoracode` registry entry is exactly the mandated one.
+- **`biome.json`** enables organize imports through `assist.actions.source.organizeImports` because Biome 2.5.14 removed the top-level `organizeImports` key; it ignores `dist`/`.next` build output; and disables `noSvgWithoutTitle`/`noAmbiguousAnchorText`, which fire on the official Vite/Next template demo assets.
+- **`jsdom`** (Testing Library DOM environment) and **`clsx` + `tailwind-merge`** (shadcn `cn()` helper) are installed because they are strictly required by the mandated Testing Library and shadcn setups.
+
+## Packaging and local verification
+
+```bash
+pnpm build
+npm pack
+npm install -g ./raulmoracode-create-1.0.0.tgz
+raulmoracode-create
+```
+
+The packaged tarball contains `dist/` (including the `raulmoracode-create` bin with its shebang), `README.md` and `LICENSE`.
+
+## License
+
+[MIT](LICENSE)

package/dist/cli/args.js

@@ -0,0 +1,34 @@
+export const VERSION = "1.0.0";
+export function parseArgs(argv) {
+    return {
+        help: argv.includes("--help") || argv.includes("-h"),
+        version: argv.includes("--version") || argv.includes("-V"),
+        verbose: argv.includes("--verbose"),
+    };
+}
+export function helpText() {
+    return [
+        `raulmoracode-create v${VERSION} — scaffolds React + Vite / Next.js projects.`,
+        "",
+        "Usage:",
+        "  raulmoracode-create [options]",
+        "",
+        "Options:",
+        "  --verbose        Print the output of every external command.",
+        "  -h, --help       Show this help message.",
+        "  -V, --version    Show the installed version.",
+        "",
+        "Environment:",
+        "  GH_TOKEN (optional)  Enables the private @raulmoracode/icons package.",
+        "                       Without registry access the project is generated",
+        "                       without .npmrc and without icons.",
+        "",
+        "Examples:",
+        "  raulmoracode-create",
+        "  raulmoracode-create --verbose",
+        "",
+    ].join("\n");
+}
+export function printHelp() {
+    console.log(helpText());
+}

package/dist/cli/output.js

@@ -0,0 +1,20 @@
+import { intro, log, outro } from "@clack/prompts";
+export function showIntro() {
+    intro("Raulmoracode Create");
+}
+export function showError(message) {
+    log.error(message);
+}
+export function showWarning(message) {
+    log.warn(message);
+}
+export function showSummary(params) {
+    const { projectName, githubUrl, frameworkLabel } = params;
+    log.success("Project created successfully!");
+    log.message(`Framework: ${frameworkLabel}`);
+    log.message(`Local:     ./${projectName}`);
+    log.message(`GitHub:    ${githubUrl}`);
+}
+export function showFarewell() {
+    outro("Proyecto creado correctamente.\n¡Hasta pronto!");
+}

package/dist/cli/run.js

@@ -0,0 +1,326 @@
+import { intro, log, tasks } from "@clack/prompts";
+import { applyPrivateAccess } from "../config/tech.js";
+import { getFramework } from "../frameworks/index.js";
+import { configureBiome, formatProject, } from "../generators/configure-biome.js";
+import { configureGitHooks } from "../generators/configure-git-hooks.js";
+import { augmentGitignore, configureEditorconfig, configureNode, } from "../generators/configure-node.js";
+import { installDependencies, normalizePackageJson, patchPackageJson, refreshPnpmWorkspaceExcludes, } from "../generators/configure-project.js";
+import { configureRegistry } from "../generators/configure-registry.js";
+import { configureShadcn } from "../generators/configure-shadcn.js";
+import { configureTesting } from "../generators/configure-testing.js";
+import { configureVscode } from "../generators/configure-vscode.js";
+import { createProject } from "../generators/create-project.js";
+import { createCommit } from "../git/commit.js";
+import { initRepository } from "../git/init.js";
+import { push, remoteHasDivergentCommits } from "../git/push.js";
+import { addRemote, lsRemote } from "../git/remote.js";
+import { promptOpenInVscode } from "../prompts/confirm.js";
+import { promptFramework } from "../prompts/framework.js";
+import { promptGitHubUrl } from "../prompts/github.js";
+import { promptProjectName } from "../prompts/project.js";
+import { promptTechPreset } from "../prompts/tech.js";
+import { ExecError, exec } from "../utils/exec.js";
+import { ensureDir, isDirectoryEmpty, pathExists, removeEmptyDir, removeIfExists, resolvePath, } from "../utils/filesystem.js";
+import { checkPrivateRegistryAccess } from "../utils/registry.js";
+import { satisfiesNodeVersion } from "../utils/validation.js";
+import { showFarewell, showSummary, showWarning } from "./output.js";
+const MINIMUM_NODE_MAJOR = 24;
+export const REMOTE_CONFLICT_MESSAGE = [
+    "El repositorio remoto ya contiene cambios que no existen localmente.",
+    "",
+    "No se realizará ningún push destructivo.",
+    "Por favor, revisa el repositorio y vuelve a ejecutar el proceso.",
+].join("\n");
+export class PreflightError extends Error {
+}
+/**
+ * Decides whether the generated directory must be removed after a failure.
+ *
+ * Past `checkDestination`, everything under `./<name>` was created by this run
+ * (the destination either did not exist or was an empty dir we removed), so it
+ * is safe to delete. Two exceptions:
+ * - `null` (failure before any task ran): nothing was created, nothing to clean.
+ * - `"Pushing to GitHub"`: the project is complete locally, only the push
+ *   failed — deleting it would destroy a perfectly good project.
+ */
+export function shouldRemoveProjectDir(failedStep) {
+    if (failedStep === null) {
+        return false;
+    }
+    if (failedStep === "Pushing to GitHub") {
+        return false;
+    }
+    return true;
+}
+async function requireCommand(command, instructions, verbose) {
+    try {
+        await exec(command, ["--version"], { verbose });
+    }
+    catch (error) {
+        if (error instanceof ExecError && error.spawnError) {
+            throw new PreflightError(`${command} no está instalado o no disponible en el PATH.\n${instructions}`);
+        }
+        throw new PreflightError(`No se pudo ejecutar "${command} --version".`);
+    }
+}
+async function requireGitIdentity(verbose) {
+    const name = await exec("git", ["config", "--get", "user.name"], { verbose });
+    const email = await exec("git", ["config", "--get", "user.email"], {
+        verbose,
+    });
+    if (!name.stdout.trim() || !email.stdout.trim()) {
+        throw new PreflightError("Git no tiene configurada la identidad (user.name y user.email), necesaria para crear el commit inicial.\n" +
+            'Ejecuta: git config --global user.name "Tu Nombre" && git config --global user.email "tu@email.com"');
+    }
+}
+async function preflightChecks(verbose) {
+    const nodeCheck = satisfiesNodeVersion(process.version, MINIMUM_NODE_MAJOR);
+    if (!nodeCheck.valid) {
+        throw new PreflightError(`${nodeCheck.error}\nInstala Node.js ${MINIMUM_NODE_MAJOR} LTS: https://nodejs.org`);
+    }
+    await requireCommand("pnpm", "Instala pnpm: https://pnpm.io/installation", verbose);
+    await requireCommand("git", "Instala Git: https://git-scm.com/downloads", verbose);
+    await requireGitIdentity(verbose);
+}
+async function checkDestination(projectName) {
+    const projectDir = resolvePath(process.cwd(), projectName);
+    if (await pathExists(projectDir)) {
+        if (await isDirectoryEmpty(projectDir)) {
+            await removeEmptyDir(projectDir);
+            return { projectDir, reusedEmptyDir: true };
+        }
+        throw new PreflightError(`El directorio "./${projectName}" ya existe y no está vacío.\n` +
+            "Muévalo, renómbralo o elimínalo antes de continuar. No se borrará ningún contenido existente.");
+    }
+    return { projectDir, reusedEmptyDir: false };
+}
+async function checkRemoteAccess(githubUrl, verbose) {
+    try {
+        await lsRemote(githubUrl, verbose);
+    }
+    catch {
+        throw new PreflightError(`No se pudo acceder al repositorio ${githubUrl}.\n` +
+            "Comprueba la URL, tu conexión a internet y tu autenticación de GitHub (https o gh auth).");
+    }
+}
+export async function run(options = {}) {
+    const verbose = options.verbose ?? false;
+    intro("Raulmoracode Create");
+    let projectName = "";
+    let cleanupDir = null;
+    let restoreEmptyDir = false;
+    let failedStep = null;
+    try {
+        await preflightChecks(verbose);
+        const frameworkId = await promptFramework();
+        const { selection, notes } = await promptTechPreset();
+        for (const note of notes) {
+            showWarning(note);
+        }
+        projectName = await promptProjectName();
+        const githubUrl = await promptGitHubUrl();
+        const { projectDir, reusedEmptyDir } = await checkDestination(projectName);
+        cleanupDir = projectDir;
+        restoreEmptyDir = reusedEmptyDir;
+        await checkRemoteAccess(githubUrl, verbose);
+        const hasPrivateAccess = await checkPrivateRegistryAccess();
+        const effectiveSelection = applyPrivateAccess(selection, hasPrivateAccess);
+        if (selection.registry && !hasPrivateAccess) {
+            showWarning("Sin acceso al registro privado @raulmoracode (GH_TOKEN ausente o sin permisos): " +
+                "se omite @raulmoracode/icons y el .npmrc.");
+        }
+        const framework = getFramework(frameworkId);
+        await tasks([
+            {
+                title: "Creating project",
+                task: async (message) => {
+                    failedStep = "Creating project";
+                    message(`Scaffolding with ${framework.label}`);
+                    await createProject(framework, projectName, process.cwd(), verbose);
+                    if (effectiveSelection.tailwind) {
+                        message("Configuring Tailwind CSS");
+                        await framework.configureTailwind(projectDir);
+                    }
+                    message("Configuring branding");
+                    await framework.configureBranding(projectDir);
+                    if (effectiveSelection.shadcn) {
+                        message("Configuring shadcn");
+                        await configureShadcn(projectDir, framework);
+                    }
+                    if (effectiveSelection.registry) {
+                        message("Configuring @raulmoracode registry");
+                        await configureRegistry(projectDir);
+                    }
+                    if (effectiveSelection["tanstack-query"]) {
+                        message("Configuring TanStack Query");
+                        await framework.configureTanStackQuery(projectDir);
+                    }
+                    if (framework.configureStarter) {
+                        message("Configuring starter");
+                        await framework.configureStarter(projectDir);
+                    }
+                    if (effectiveSelection.biome) {
+                        message("Configuring Biome");
+                        await configureBiome(projectDir);
+                    }
+                    if (effectiveSelection.testing) {
+                        message("Configuring testing");
+                        await configureTesting(projectDir);
+                    }
+                    if (effectiveSelection.vscode) {
+                        message("Configuring VS Code");
+                        await configureVscode(projectDir);
+                    }
+                    message("Configuring Node version");
+                    await configureNode(projectDir);
+                    await configureEditorconfig(projectDir);
+                    if (effectiveSelection.husky) {
+                        message("Configuring Git hooks");
+                        await configureGitHooks(projectDir, effectiveSelection);
+                    }
+                    await patchPackageJson(projectDir, framework, projectName, githubUrl, effectiveSelection);
+                    await augmentGitignore(projectDir);
+                    return "Project created";
+                },
+            },
+            {
+                title: "Installing dependencies",
+                task: async (message) => {
+                    failedStep = "Installing dependencies";
+                    message("Installing base and additional dependencies");
+                    await installDependencies(projectDir, framework, verbose, effectiveSelection);
+                    await normalizePackageJson(projectDir);
+                    if (effectiveSelection.biome) {
+                        message("Formatting project with Biome");
+                        await formatProject(projectDir, verbose);
+                    }
+                    message("Configuring pnpm workspace");
+                    await refreshPnpmWorkspaceExcludes(projectDir, framework, verbose, effectiveSelection);
+                    if (effectiveSelection.zustand) {
+                        message("Zustand configured");
+                    }
+                    if (effectiveSelection.forms) {
+                        message("React Hook Form + Zod configured");
+                    }
+                    if (effectiveSelection["tanstack-query"]) {
+                        message("TanStack Query configured");
+                    }
+                    if (effectiveSelection.tailwind) {
+                        message("Tailwind configured");
+                    }
+                    if (effectiveSelection.biome) {
+                        message("Biome configured");
+                    }
+                    if (effectiveSelection.testing) {
+                        message("Testing configured");
+                    }
+                    return "Dependencies installed";
+                },
+            },
+            {
+                title: "Initializing Git",
+                task: async () => {
+                    failedStep = "Initializing Git";
+                    await initRepository(projectDir, verbose);
+                    if (effectiveSelection.husky) {
+                        await exec("pnpm", ["exec", "husky"], {
+                            cwd: projectDir,
+                            verbose,
+                        });
+                    }
+                    return "Git initialized";
+                },
+            },
+            {
+                title: "Configuring remote",
+                task: async () => {
+                    failedStep = "Configuring remote";
+                    await addRemote(projectDir, githubUrl, verbose);
+                    return "Remote configured";
+                },
+            },
+            {
+                title: "Creating initial commit",
+                task: async () => {
+                    failedStep = "Creating initial commit";
+                    await createCommit(projectDir, verbose);
+                    return "Initial commit created";
+                },
+            },
+            {
+                title: "Pushing to GitHub",
+                task: async () => {
+                    failedStep = "Pushing to GitHub";
+                    const hasConflicts = await remoteHasDivergentCommits(projectDir, verbose);
+                    if (hasConflicts) {
+                        throw new Error(REMOTE_CONFLICT_MESSAGE);
+                    }
+                    await push(projectDir, verbose);
+                    return "Pushed to GitHub";
+                },
+            },
+        ]);
+        showSummary({ projectName, githubUrl, frameworkLabel: framework.label });
+        const openInVscode = await promptOpenInVscode();
+        if (openInVscode) {
+            try {
+                await exec("code", ["."], { cwd: projectDir, verbose });
+            }
+            catch (error) {
+                if (error instanceof ExecError && error.spawnError) {
+                    showWarning('El comando "code" no está disponible. Abre el proyecto manualmente con VS Code.');
+                }
+                else {
+                    showWarning("No se pudo abrir VS Code automáticamente. Abre el proyecto manualmente.");
+                }
+            }
+        }
+        showFarewell();
+    }
+    catch (error) {
+        const cancelled = error instanceof ExecError &&
+            (error.signal === "SIGINT" || error.signal === "SIGTERM");
+        let cleaned = false;
+        if (shouldRemoveProjectDir(failedStep) && cleanupDir !== null) {
+            try {
+                await removeIfExists(cleanupDir);
+                cleaned = true;
+            }
+            catch {
+                cleaned = false;
+            }
+        }
+        else if (failedStep === null && restoreEmptyDir && cleanupDir !== null) {
+            try {
+                await ensureDir(cleanupDir);
+            }
+            catch {
+                // Best effort: restoring an empty dir must never hide the real error.
+            }
+        }
+        if (cancelled) {
+            if (cleaned) {
+                log.error(`Operación cancelada. Se eliminó "./${projectName}" (todo su contenido lo había creado el CLI).`);
+            }
+            else {
+                log.error("Operación cancelada por el usuario.");
+            }
+            process.exit(130);
+        }
+        if (error instanceof Error) {
+            log.error(error.message);
+        }
+        else {
+            log.error(String(error));
+        }
+        if (cleaned) {
+            showWarning(`Se eliminó "./${projectName}" (todo su contenido lo había creado el CLI). ` +
+                "Vuelve a ejecutar raulmoracode-create para reintentar.");
+        }
+        else if (failedStep === "Pushing to GitHub") {
+            showWarning(`El proyecto está completo en "./${projectName}": solo falló el push. ` +
+                `Reintenta con: git -C "./${projectName}" push -u origin main`);
+        }
+        process.exit(1);
+    }
+}