@raulmoracode/create 1.0.0

package/dist/git/push.js

@@ -0,0 +1,59 @@
+import { exec } from "../utils/exec.js";
+export function pushArgs() {
+    return ["push", "-u", "origin", "main"];
+}
+export function fetchArgs() {
+    return ["fetch", "origin"];
+}
+export function revParseArgs(ref) {
+    return ["rev-parse", ref];
+}
+export function mergeBaseIsAncestorArgs(ancestor, descendant) {
+    return ["merge-base", "--is-ancestor", ancestor, descendant];
+}
+export async function push(projectDir, verbose) {
+    await exec("git", pushArgs(), { cwd: projectDir, verbose });
+}
+export async function fetchRemote(projectDir, verbose) {
+    await exec("git", fetchArgs(), { cwd: projectDir, verbose });
+}
+export async function resolveSha(projectDir, ref, verbose) {
+    try {
+        const result = await exec("git", revParseArgs(ref), {
+            cwd: projectDir,
+            verbose,
+        });
+        const sha = result.stdout.trim();
+        return sha.length > 0 ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function isAncestor(projectDir, ancestor, descendant, verbose) {
+    try {
+        await exec("git", mergeBaseIsAncestorArgs(ancestor, descendant), {
+            cwd: projectDir,
+            verbose,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function remoteHasDivergentCommits(projectDir, verbose) {
+    await fetchRemote(projectDir, verbose);
+    const remoteSha = await resolveSha(projectDir, "origin/main", verbose);
+    if (!remoteSha) {
+        return false;
+    }
+    const localSha = await resolveSha(projectDir, "HEAD", verbose);
+    if (!localSha) {
+        return false;
+    }
+    if (remoteSha === localSha) {
+        return false;
+    }
+    return !(await isAncestor(projectDir, remoteSha, "HEAD", verbose));
+}

package/dist/git/remote.js

@@ -0,0 +1,30 @@
+import { exec } from "../utils/exec.js";
+export function remoteAddArgs(url) {
+    return ["remote", "add", "origin", url];
+}
+export function remoteGetUrlArgs() {
+    return ["remote", "get-url", "origin"];
+}
+export function lsRemoteArgs(url) {
+    return ["ls-remote", url];
+}
+export async function addRemote(projectDir, url, verbose) {
+    await exec("git", remoteAddArgs(url), { cwd: projectDir, verbose });
+}
+export async function remoteExists(projectDir, verbose) {
+    try {
+        await exec("git", remoteGetUrlArgs(), { cwd: projectDir, verbose });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function lsRemote(url, verbose) {
+    const result = await exec("git", lsRemoteArgs(url), { verbose });
+    return result.stdout;
+}
+export async function isRemoteEmpty(url, verbose) {
+    const output = await lsRemote(url, verbose);
+    return output.trim() === "";
+}

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { parseArgs, printHelp, VERSION } from "./cli/args.js";
+import { run } from "./cli/run.js";
+const args = parseArgs(process.argv.slice(2));
+if (args.help) {
+    printHelp();
+    process.exit(0);
+}
+if (args.version) {
+    console.log(VERSION);
+    process.exit(0);
+}
+run({ verbose: args.verbose }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/prompts/cancel.js

@@ -0,0 +1,8 @@
+import { cancel, isCancel } from "@clack/prompts";
+export function ensureNotCancelled(value) {
+    if (isCancel(value)) {
+        cancel("Operación cancelada.");
+        process.exit(0);
+    }
+    return value;
+}

package/dist/prompts/confirm.js

@@ -0,0 +1,11 @@
+import { confirm } from "@clack/prompts";
+import { ensureNotCancelled } from "./cancel.js";
+export async function promptOpenInVscode() {
+    const answer = ensureNotCancelled(await confirm({
+        message: `¿Quieres abrir el proyecto ahora?`,
+        active: "Sí",
+        inactive: "No",
+        initialValue: true,
+    }));
+    return Boolean(answer);
+}

package/dist/prompts/framework.js

@@ -0,0 +1,25 @@
+import { select } from "@clack/prompts";
+import { isFramework } from "../utils/validation.js";
+import { ensureNotCancelled } from "./cancel.js";
+export async function promptFramework() {
+    const framework = ensureNotCancelled(await select({
+        message: "¿Qué tecnología quieres utilizar?",
+        options: [
+            {
+                value: "vite",
+                label: "React + Vite",
+                hint: "Vite 8, React 19 y TypeScript 7",
+            },
+            {
+                value: "next",
+                label: "Next.js",
+                hint: "Next.js 16, App Router y React 19",
+            },
+        ],
+        initialValue: "vite",
+    }));
+    if (!isFramework(framework)) {
+        throw new Error(`Framework desconocido: ${String(framework)}`);
+    }
+    return framework;
+}

package/dist/prompts/github.js

@@ -0,0 +1,25 @@
+import { text } from "@clack/prompts";
+import { validateGitHubUrl } from "../utils/validation.js";
+import { ensureNotCancelled } from "./cancel.js";
+export async function promptGitHubUrl() {
+    const url = ensureNotCancelled(await text({
+        message: "¿Dónde se va a alojar el código?",
+        placeholder: "https://github.com/raulmoracode/my-project",
+        validate(value) {
+            if (!value) {
+                return "La URL del repositorio no puede estar vacía.";
+            }
+            const result = validateGitHubUrl(value);
+            return result.valid ? undefined : result.error;
+        },
+    }));
+    const trimmed = url
+        .trim()
+        .replace(/\/+$/, "")
+        .replace(/\.git$/, "");
+    const check = validateGitHubUrl(trimmed);
+    if (!check.valid) {
+        throw new Error(check.error);
+    }
+    return trimmed;
+}

package/dist/prompts/project.js

@@ -0,0 +1,22 @@
+import { text } from "@clack/prompts";
+import { validateProjectName } from "../utils/validation.js";
+import { ensureNotCancelled } from "./cancel.js";
+export async function promptProjectName() {
+    const name = ensureNotCancelled(await text({
+        message: "¿Cuál es el nombre del proyecto?",
+        placeholder: "my-project",
+        validate(value) {
+            if (!value) {
+                return "El nombre del proyecto no puede estar vacío.";
+            }
+            const result = validateProjectName(value);
+            return result.valid ? undefined : result.error;
+        },
+    }));
+    const trimmed = name.trim();
+    const check = validateProjectName(trimmed);
+    if (!check.valid) {
+        throw new Error(check.error);
+    }
+    return trimmed;
+}

package/dist/prompts/tech.js

@@ -0,0 +1,18 @@
+import { multiselect } from "@clack/prompts";
+import { resolveTechSelection, TECH_IDS, TECH_OPTIONS, } from "../config/tech.js";
+import { ensureNotCancelled } from "./cancel.js";
+export async function promptTechPreset() {
+    const values = ensureNotCancelled(await multiselect({
+        message: "¿Qué tecnologías quieres incluir? (espacio para marcar/desmarcar)",
+        options: TECH_OPTIONS.map((option) => ({
+            value: option.id,
+            label: option.label,
+            hint: option.hint,
+        })),
+        initialValues: [...TECH_IDS],
+        required: false,
+    }));
+    const selected = new Set(values);
+    const input = Object.fromEntries(TECH_IDS.map((id) => [id, selected.has(id)]));
+    return resolveTechSelection(input);
+}

package/dist/utils/exec.js

@@ -0,0 +1,107 @@
+import { spawn } from "node:child_process";
+export class ExecError extends Error {
+    command;
+    args;
+    code;
+    signal;
+    stdout;
+    stderr;
+    spawnError;
+    constructor(params) {
+        const label = `${params.command} ${params.args.join(" ")}`.trim();
+        const detail = params.spawnError
+            ? `Failed to spawn "${params.command}": ${params.spawnError}`
+            : params.stderr.trim() ||
+                params.stdout.trim() ||
+                `Exited with code ${params.code}`;
+        super(`Command failed: ${label}\n${detail}`);
+        this.name = "ExecError";
+        this.command = params.command;
+        this.args = params.args;
+        this.code = params.code;
+        this.signal = params.signal;
+        this.stdout = params.stdout;
+        this.stderr = params.stderr;
+        this.spawnError = params.spawnError ?? null;
+    }
+}
+function resolveExecutable(name) {
+    if (process.platform !== "win32")
+        return name;
+    if (/[\\/]/.test(name))
+        return name;
+    if (name.endsWith(".cmd") || name.endsWith(".exe") || name.endsWith(".bat"))
+        return name;
+    return `${name}.cmd`;
+}
+export function resolveCommand(command) {
+    return resolveExecutable(command);
+}
+export function formatCommand(command, args) {
+    return [command, ...args].join(" ");
+}
+export async function exec(command, args, options = {}) {
+    const resolved = resolveExecutable(command);
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(resolved, args, {
+                cwd: options.cwd,
+                env: options.env ?? process.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            reject(new ExecError({
+                command,
+                args,
+                code: null,
+                signal: null,
+                stdout: "",
+                stderr: "",
+                spawnError: error instanceof Error ? error.message : String(error),
+            }));
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        child.stdout?.on("data", (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            if (options.verbose)
+                process.stdout.write(text);
+        });
+        child.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            if (options.verbose)
+                process.stderr.write(text);
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new ExecError({
+                command,
+                args,
+                code: null,
+                signal: null,
+                stdout,
+                stderr,
+                spawnError: error.message,
+            }));
+        });
+        child.on("close", (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            if (code === 0) {
+                resolve({ code, stdout, stderr });
+            }
+            else {
+                reject(new ExecError({ command, args, code, signal, stdout, stderr }));
+            }
+        });
+    });
+}

package/dist/utils/filesystem.js

@@ -0,0 +1,108 @@
+import { access, chmod, mkdir, readdir, readFile, rm, rmdir, stat, writeFile, } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+export async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDirectory(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDirectoryEmpty(path) {
+    const entries = await readdir(path);
+    return entries.length === 0;
+}
+export async function listDirEntries(path) {
+    return readdir(path);
+}
+export async function ensureDir(path) {
+    await mkdir(path, { recursive: true });
+}
+export async function writeTextFile(path, content) {
+    await ensureDir(dirname(path));
+    await writeFile(path, content, "utf8");
+}
+export async function readTextFile(path) {
+    return readFile(path, "utf8");
+}
+export async function readJsonFile(path) {
+    return JSON.parse(await readFile(path, "utf8"));
+}
+export function stripJsonComments(content) {
+    let result = "";
+    let i = 0;
+    let inString = false;
+    while (i < content.length) {
+        const char = content[i] ?? "";
+        if (inString) {
+            result += char;
+            if (char === "\\") {
+                result += content[i + 1] ?? "";
+                i += 2;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            i += 1;
+            continue;
+        }
+        if (char === "/" && content[i + 1] === "/") {
+            while (i < content.length && content[i] !== "\n") {
+                i += 1;
+            }
+            continue;
+        }
+        if (char === "/" && content[i + 1] === "*") {
+            i += 2;
+            while (i < content.length &&
+                !(content[i] === "*" && content[i + 1] === "/")) {
+                i += 1;
+            }
+            i += 2;
+            continue;
+        }
+        result += char;
+        i += 1;
+    }
+    return result;
+}
+export function parseJsonc(content) {
+    return JSON.parse(stripJsonComments(content));
+}
+export async function removeIfExists(path) {
+    await rm(path, { recursive: true, force: true });
+}
+export function joinPath(...parts) {
+    return join(...parts);
+}
+export function resolvePath(...parts) {
+    return resolve(...parts);
+}
+export async function removeEmptyDir(path) {
+    try {
+        await rmdir(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function makeExecutable(path) {
+    await chmod(path, 0o755);
+}

package/dist/utils/registry.js

@@ -0,0 +1,18 @@
+const PRIVATE_ICONS_METADATA_URL = "https://npm.pkg.github.com/@raulmoracode%2Ficons";
+const REQUEST_TIMEOUT_MS = 10_000;
+export async function checkPrivateRegistryAccess() {
+    const token = process.env.GH_TOKEN;
+    if (!token) {
+        return false;
+    }
+    try {
+        const response = await fetch(PRIVATE_ICONS_METADATA_URL, {
+            headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/validation.js

@@ -0,0 +1,153 @@
+const MAX_PROJECT_NAME_LENGTH = 214;
+const RESERVED_PROJECT_NAMES = new Set([
+    "node_modules",
+    "favicon.ico",
+    "con",
+    "prn",
+    "aux",
+    "nul",
+    "com1",
+    "com2",
+    "com3",
+    "com4",
+    "com5",
+    "com6",
+    "com7",
+    "com8",
+    "com9",
+    "lpt1",
+    "lpt2",
+    "lpt3",
+    "lpt4",
+    "lpt5",
+    "lpt6",
+    "lpt7",
+    "lpt8",
+    "lpt9",
+]);
+const PROJECT_NAME_REGEX = /^[a-z0-9][a-z0-9._~-]*$/;
+const GITHUB_OWNER_REGEX = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,38})$/;
+const GITHUB_REPO_REGEX = /^[a-zA-Z0-9._-]+$/;
+export function validateProjectName(name) {
+    if (name.length === 0) {
+        return {
+            valid: false,
+            error: "El nombre del proyecto no puede estar vacío.",
+        };
+    }
+    if (name !== name.trim()) {
+        return {
+            valid: false,
+            error: "El nombre del proyecto no puede contener espacios al inicio o al final.",
+        };
+    }
+    if (name.length > MAX_PROJECT_NAME_LENGTH) {
+        return {
+            valid: false,
+            error: `El nombre del proyecto no puede superar ${MAX_PROJECT_NAME_LENGTH} caracteres.`,
+        };
+    }
+    if (name.startsWith(".") || name.startsWith("_")) {
+        return {
+            valid: false,
+            error: "El nombre del proyecto no puede empezar por '.' o '_'.",
+        };
+    }
+    if (!PROJECT_NAME_REGEX.test(name)) {
+        return {
+            valid: false,
+            error: "El nombre del proyecto solo puede contener minúsculas, números y los caracteres '-', '_', '.', '~'.",
+        };
+    }
+    if (RESERVED_PROJECT_NAMES.has(name.toLowerCase())) {
+        return {
+            valid: false,
+            error: `"${name}" es un nombre reservado y no puede utilizarse.`,
+        };
+    }
+    return { valid: true };
+}
+export function validateGitHubUrl(url) {
+    if (url.length === 0) {
+        return {
+            valid: false,
+            error: "La URL del repositorio no puede estar vacía.",
+        };
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return { valid: false, error: "La URL proporcionada no es válida." };
+    }
+    if (parsed.protocol !== "https:") {
+        return {
+            valid: false,
+            error: "La URL del repositorio debe utilizar https://.",
+        };
+    }
+    if (parsed.hostname !== "github.com") {
+        return { valid: false, error: "La URL debe apuntar a github.com." };
+    }
+    if (parsed.username || parsed.password) {
+        return { valid: false, error: "La URL no debe incluir credenciales." };
+    }
+    const parts = parsed.pathname
+        .replace(/\/+$/, "")
+        .replace(/\.git$/, "")
+        .split("/")
+        .filter(Boolean);
+    if (parts.length !== 2) {
+        return {
+            valid: false,
+            error: "Formato esperado: https://github.com/<usuario>/<repositorio>",
+        };
+    }
+    const [owner, repo] = parts;
+    if (!GITHUB_OWNER_REGEX.test(owner)) {
+        return {
+            valid: false,
+            error: "El nombre de usuario de GitHub no es válido.",
+        };
+    }
+    if (!GITHUB_REPO_REGEX.test(repo) || repo === "." || repo === "..") {
+        return { valid: false, error: "El nombre del repositorio no es válido." };
+    }
+    return { valid: true, owner, repo };
+}
+export function isFramework(value) {
+    return value === "vite" || value === "next";
+}
+export function validateFramework(value) {
+    if (isFramework(value)) {
+        return { valid: true };
+    }
+    return {
+        valid: false,
+        error: `Framework desconocido: ${String(value)}. Valores válidos: "vite", "next".`,
+    };
+}
+export function satisfiesNodeVersion(version, minimumMajor) {
+    const match = /^v?(\d+)/.exec(version);
+    if (!match) {
+        return {
+            valid: false,
+            error: `No se pudo interpretar la versión de Node.js: ${version}`,
+        };
+    }
+    const major = Number(match[1]);
+    if (!Number.isFinite(major)) {
+        return {
+            valid: false,
+            error: `No se pudo interpretar la versión de Node.js: ${version}`,
+        };
+    }
+    if (major < minimumMajor) {
+        return {
+            valid: false,
+            error: `Se requiere Node.js ${minimumMajor} o superior. Versión actual: ${version}.`,
+        };
+    }
+    return { valid: true };
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@raulmoracode/create",
+  "version": "1.0.0",
+  "description": "Professional CLI to scaffold React + Vite and Next.js projects with Tailwind CSS, shadcn, Biome, Vitest and the @raulmoracode registry.",
+  "keywords": [
+    "raulmoracode",
+    "scaffold",
+    "scaffolder",
+    "cli",
+    "react",
+    "vite",
+    "nextjs",
+    "tailwindcss",
+    "shadcn",
+    "biome",
+    "vitest",
+    "pnpm"
+  ],
+  "homepage": "https://github.com/raulmoracode/raulmoracode-create#readme",
+  "bugs": {
+    "url": "https://github.com/raulmoracode/raulmoracode-create/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raulmoracode/raulmoracode-create.git"
+  },
+  "license": "MIT",
+  "author": "raulmoracode",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "raulmoracode-create": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "biome check .",
+    "format": "biome format --write .",
+    "lint": "biome lint .",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.8.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.14",
+    "@types/node": "24.19.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.2"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@12.6.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}