create-next-shadcn-kit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nikunj Sonigara
+
+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,70 @@
+# create-next-shadcn-kit
+
+> Create a Next.js app with **shadcn/ui** pre-integrated — zero config.
+
+One command, a fresh Next.js project, Tailwind configured, shadcn/ui initialized, and your favorite components already installed. No juggling two CLIs.
+
+## Usage
+
+```bash
+npx create-next-shadcn-kit@latest
+```
+
+Or pass a name directly:
+
+```bash
+npx create-next-shadcn-kit my-app
+```
+
+## What it does
+
+1. Scaffolds a fresh Next.js app via `create-next-app@latest` (App Router, Tailwind, Turbopack).
+2. Runs `shadcn@latest init` inside the new project.
+3. Pre-installs the shadcn components you selected.
+4. Wires up state management — **Redux Toolkit** (default) or **Zustand**, with a sample store and (for Redux) a `<Providers>` wrapper already mounted in `app/layout`.
+5. (Optional) Sets up **Husky + lint-staged + Prettier** with a pre-commit hook that runs `eslint --fix` and `prettier --write` on staged files.
+
+You skip the "install Next → read shadcn docs → run a second init → add components one by one" ritual.
+
+## Options
+
+| Flag                                    | Description                         |
+| --------------------------------------- | ----------------------------------- |
+| `-y, --yes`                             | Skip prompts, use sensible defaults |
+| `--ts` / `--js`                         | TypeScript (default) or JavaScript  |
+| `--npm` / `--pnpm` / `--yarn` / `--bun` | Pick your package manager           |
+| `--no-husky`                            | Skip Husky + lint-staged setup      |
+| `--state=<lib>`                         | `redux` (default), `zustand`, `none`|
+| `-v, --version`                         | Print version                       |
+| `-h, --help`                            | Show help                           |
+
+## Examples
+
+```bash
+# Fully interactive
+npx create-next-shadcn-kit
+
+# Non-interactive with defaults
+npx create-next-shadcn-kit my-app --yes
+
+# Use pnpm
+npx create-next-shadcn-kit my-app --pnpm
+```
+
+## Requirements
+
+- Node.js **18.17+**
+- Network access (to fetch `create-next-app` and `shadcn`)
+
+## Development
+
+```bash
+git clone <this-repo>
+cd create-next-shadcn-kit
+npm install
+node bin/index.js test-app --yes
+```
+
+## License
+
+MIT

package/bin/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { main } from '../src/index.js';
+
+main().catch((err) => {
+  console.error();
+  console.error(err?.message || err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "create-next-shadcn-kit",
+    "version": "0.1.0",
+    "description": "Create a Next.js app with shadcn/ui pre-integrated — zero config.",
+    "keywords": [
+        "nextjs",
+        "next",
+        "shadcn",
+        "shadcn-ui",
+        "cli",
+        "scaffold",
+        "starter",
+        "create-next-app",
+        "tailwind"
+    ],
+    "author": "Nikunj Sonigara <nikunjsonigara987@gmail.com>",
+    "license": "MIT",
+    "type": "module",
+    "bin": {
+        "create-next-shadcn-kit": "bin/index.js"
+    },
+    "files": [
+        "bin",
+        "src",
+        "README.md",
+        "LICENSE"
+    ],
+    "engines": {
+        "node": ">=18.17.0"
+    },
+    "scripts": {
+        "start": "node bin/index.js",
+        "test:local": "node bin/index.js test-app --yes"
+    },
+    "dependencies": {
+        "picocolors": "^1.1.1",
+        "prompts": "^2.4.2"
+    }
+}

package/src/index.js

@@ -0,0 +1,80 @@
+import { createRequire } from "node:module";
+import pc from "picocolors";
+import { parseArgs } from "./utils.js";
+import { promptConfig } from "./prompts.js";
+import { scaffold } from "./scaffold.js";
+
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+
+export async function main() {
+    const args = parseArgs(process.argv.slice(2));
+
+    if (args.help) {
+        printHelp();
+        return;
+    }
+
+    if (args.version) {
+        console.log(pkg.version);
+        return;
+    }
+
+    assertNodeVersion();
+
+    console.log();
+    console.log(pc.bold(pc.cyan("◆ create-next-shadcn-kit")) + pc.dim(` v${pkg.version} — Next.js + shadcn/ui starter`));
+
+    const config = await promptConfig(args);
+    await scaffold(config);
+
+    console.log();
+    console.log(pc.green("✔ Success!") + " Your project is ready.");
+    console.log();
+    console.log("Next steps:");
+    console.log(pc.cyan(`  cd ${config.projectName}`));
+    console.log(pc.cyan(`  ${devCommand(config.packageManager)}`));
+    console.log();
+    console.log(pc.dim("Docs: https://ui.shadcn.com"));
+    console.log();
+}
+
+function devCommand(pm) {
+    if (pm === "npm") return "npm run dev";
+    if (pm === "yarn") return "yarn dev";
+    return `${pm} dev`;
+}
+
+function assertNodeVersion() {
+    const major = Number(process.versions.node.split(".")[0]);
+    if (major < 18) {
+        throw new Error(`Node.js 18.17+ is required. You are running ${process.versions.node}.`);
+    }
+}
+
+function printHelp() {
+    console.log(`
+${pc.bold("create-next-shadcn-kit")} — Create a Next.js app with shadcn/ui pre-integrated.
+
+${pc.bold("Usage:")}
+  npx create-next-shadcn-kit [project-name] [options]
+
+${pc.bold("Options:")}
+  -y, --yes             Skip prompts and use defaults
+  --ts, --typescript    Use TypeScript (default)
+  --js, --javascript    Use JavaScript
+  --npm                 Use npm (default)
+  --pnpm                Use pnpm
+  --yarn                Use yarn
+  --bun                 Use bun
+  --no-husky            Skip Husky + lint-staged setup
+  --state=<lib>         State management: redux (default), zustand, none
+  -v, --version         Show version
+  -h, --help            Show this help
+
+${pc.bold("Examples:")}
+  npx create-next-shadcn-kit
+  npx create-next-shadcn-kit my-app
+  npx create-next-shadcn-kit my-app --yes --pnpm
+`);
+}

package/src/prompts.js

@@ -0,0 +1,156 @@
+import prompts from "prompts";
+import pc from "picocolors";
+import { isValidProjectName } from "./utils.js";
+
+const COMPONENT_CHOICES = [
+    { title: "button", value: "button", selected: true },
+    { title: "card", value: "card", selected: true },
+    { title: "input", value: "input", selected: true },
+    { title: "label", value: "label", selected: true },
+    { title: "form", value: "form", selected: false },
+    { title: "dialog", value: "dialog", selected: false },
+    { title: "dropdown-menu", value: "dropdown-menu", selected: false },
+    { title: "select", value: "select", selected: false },
+    { title: "sonner (toast)", value: "sonner", selected: false },
+    { title: "tabs", value: "tabs", selected: false },
+    { title: "textarea", value: "textarea", selected: false },
+    { title: "tooltip", value: "tooltip", selected: false },
+    { title: "avatar", value: "avatar", selected: false },
+    { title: "badge", value: "badge", selected: false },
+    { title: "separator", value: "separator", selected: false },
+    { title: "skeleton", value: "skeleton", selected: false },
+    { title: "table", value: "table", selected: false },
+];
+
+const onCancel = () => {
+    console.log();
+    console.log(pc.red("✖") + " Cancelled");
+    process.exit(1);
+};
+
+export async function promptConfig(args) {
+    if (args.yes) {
+        return {
+            projectName: args.projectName || "my-app",
+            typescript: args.typescript ?? true,
+            eslint: true,
+            srcDir: true,
+            importAlias: "@/*",
+            packageManager: args.packageManager || "npm",
+            husky: args.husky ?? true,
+            state: args.state || "redux",
+            components: ["button", "card", "input", "label"],
+        };
+    }
+
+    const questions = [];
+
+    if (!args.projectName) {
+        questions.push({
+            type: "text",
+            name: "projectName",
+            message: "Project name:",
+            initial: "my-app",
+            validate: (v) => (isValidProjectName(v) ? true : "Invalid project name"),
+        });
+    }
+
+    if (args.typescript === undefined) {
+        questions.push({
+            type: "toggle",
+            name: "typescript",
+            message: "Use TypeScript?",
+            initial: true,
+            active: "yes",
+            inactive: "no",
+        });
+    }
+
+    questions.push(
+        {
+            type: "toggle",
+            name: "eslint",
+            message: "Use ESLint?",
+            initial: true,
+            active: "yes",
+            inactive: "no",
+        },
+        {
+            type: "toggle",
+            name: "srcDir",
+            message: "Use a `src/` directory?",
+            initial: true,
+            active: "yes",
+            inactive: "no",
+        },
+        {
+            type: "text",
+            name: "importAlias",
+            message: "Import alias:",
+            initial: "@/*",
+        },
+    );
+
+    if (!args.packageManager) {
+        questions.push({
+            type: "select",
+            name: "packageManager",
+            message: "Package manager:",
+            choices: [
+                { title: "npm", value: "npm" },
+                { title: "pnpm", value: "pnpm" },
+                { title: "yarn", value: "yarn" },
+                { title: "bun", value: "bun" },
+            ],
+            initial: 0,
+        });
+    }
+
+    if (args.husky === undefined) {
+        questions.push({
+            type: "toggle",
+            name: "husky",
+            message: "Set up Husky + lint-staged (pre-commit hooks)?",
+            initial: true,
+            active: "yes",
+            inactive: "no",
+        });
+    }
+
+    if (!args.state) {
+        questions.push({
+            type: "select",
+            name: "state",
+            message: "State management:",
+            choices: [
+                { title: "Redux Toolkit", value: "redux" },
+                { title: "Zustand", value: "zustand" },
+                { title: "None", value: "none" },
+            ],
+            initial: 0,
+        });
+    }
+
+    questions.push({
+        type: "multiselect",
+        name: "components",
+        message: "Pre-install components:",
+        choices: COMPONENT_CHOICES,
+        hint: "(space to toggle, enter to confirm)",
+        instructions: false,
+    });
+
+    const answers = await prompts(questions, { onCancel });
+
+    return {
+        projectName: args.projectName || answers.projectName,
+        typescript: args.typescript ?? answers.typescript,
+        eslint: answers.eslint,
+        srcDir: answers.srcDir,
+        importAlias: answers.importAlias || "@/*",
+        packageManager: args.packageManager || answers.packageManager,
+        husky: args.husky ?? answers.husky ?? true,
+        state: args.state || answers.state || "redux",
+        components: answers.components || [],
+    };
+}

package/src/scaffold.js

@@ -0,0 +1,382 @@
+import path from "node:path";
+import fs from "node:fs";
+import pc from "picocolors";
+import { run } from "./utils.js";
+
+export async function scaffold(config) {
+    const cwd = process.cwd();
+    const projectPath = path.resolve(cwd, config.projectName);
+
+    if (fs.existsSync(projectPath) && fs.readdirSync(projectPath).length > 0) {
+        throw new Error(`Directory "${config.projectName}" already exists and is not empty.`);
+    }
+
+    console.log();
+    console.log(pc.cyan("◆") + " Creating Next.js app...");
+    console.log();
+
+    const cnaArgs = [
+        "create-next-app@latest",
+        config.projectName,
+        config.typescript ? "--typescript" : "--javascript",
+        config.eslint ? "--eslint" : "--no-eslint",
+        "--tailwind",
+        "--app",
+        config.srcDir ? "--src-dir" : "--no-src-dir",
+        "--turbopack",
+        `--import-alias=${config.importAlias}`,
+        `--use-${config.packageManager}`,
+        "--yes",
+    ];
+
+    await run("npx", cnaArgs);
+
+    console.log();
+    console.log(pc.cyan("◆") + " Initializing shadcn/ui...");
+    console.log();
+
+    const shadcnRunner = runnerFor(config.packageManager);
+
+    await run(shadcnRunner.cmd, [...shadcnRunner.args, "shadcn@latest", "init", "--yes", "--defaults"], { cwd: projectPath });
+
+    if (config.components.length > 0) {
+        console.log();
+        console.log(pc.cyan("◆") + ` Adding components: ${pc.dim(config.components.join(", "))}`);
+        console.log();
+
+        await run(shadcnRunner.cmd, [...shadcnRunner.args, "shadcn@latest", "add", ...config.components, "--yes"], { cwd: projectPath });
+    }
+
+    if (config.state === "redux") {
+        await setupRedux(projectPath, config);
+    } else if (config.state === "zustand") {
+        await setupZustand(projectPath, config);
+    }
+
+    if (config.husky) {
+        await setupHusky(projectPath, config);
+    }
+}
+
+function appDirFor(projectPath, config) {
+    return config.srcDir ? path.join(projectPath, "src", "app") : path.join(projectPath, "app");
+}
+
+function storeDirFor(projectPath, config) {
+    return config.srcDir ? path.join(projectPath, "src", "store") : path.join(projectPath, "store");
+}
+
+async function setupRedux(projectPath, config) {
+    console.log();
+    console.log(pc.cyan("◆") + " Setting up Redux Toolkit...");
+    console.log();
+
+    const installer = installerFor(config.packageManager, false);
+    await run(installer.cmd, [...installer.args, "@reduxjs/toolkit", "react-redux"], { cwd: projectPath });
+
+    const storeDir = storeDirFor(projectPath, config);
+    fs.mkdirSync(storeDir, { recursive: true });
+
+    const ts = config.typescript;
+    const storeExt = ts ? "ts" : "js";
+    const compExt = ts ? "tsx" : "js";
+
+    const storeIndex = ts
+        ? `import { configureStore } from "@reduxjs/toolkit";
+import counterReducer from "./counterSlice";
+
+export const store = configureStore({
+  reducer: {
+    counter: counterReducer,
+  },
+});
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+`
+        : `import { configureStore } from "@reduxjs/toolkit";
+import counterReducer from "./counterSlice";
+
+export const store = configureStore({
+  reducer: {
+    counter: counterReducer,
+  },
+});
+`;
+    fs.writeFileSync(path.join(storeDir, `index.${storeExt}`), storeIndex);
+
+    const counterSlice = ts
+        ? `import { createSlice, PayloadAction } from "@reduxjs/toolkit";
+
+interface CounterState {
+  value: number;
+}
+
+const initialState: CounterState = { value: 0 };
+
+const counterSlice = createSlice({
+  name: "counter",
+  initialState,
+  reducers: {
+    increment: (state) => {
+      state.value += 1;
+    },
+    decrement: (state) => {
+      state.value -= 1;
+    },
+    incrementByAmount: (state, action: PayloadAction<number>) => {
+      state.value += action.payload;
+    },
+  },
+});
+
+export const { increment, decrement, incrementByAmount } = counterSlice.actions;
+export default counterSlice.reducer;
+`
+        : `import { createSlice } from "@reduxjs/toolkit";
+
+const initialState = { value: 0 };
+
+const counterSlice = createSlice({
+  name: "counter",
+  initialState,
+  reducers: {
+    increment: (state) => {
+      state.value += 1;
+    },
+    decrement: (state) => {
+      state.value -= 1;
+    },
+    incrementByAmount: (state, action) => {
+      state.value += action.payload;
+    },
+  },
+});
+
+export const { increment, decrement, incrementByAmount } = counterSlice.actions;
+export default counterSlice.reducer;
+`;
+    fs.writeFileSync(path.join(storeDir, `counterSlice.${storeExt}`), counterSlice);
+
+    if (ts) {
+        const hooks = `import { useDispatch, useSelector } from "react-redux";
+import type { TypedUseSelectorHook } from "react-redux";
+import type { RootState, AppDispatch } from "./index";
+
+export const useAppDispatch: () => AppDispatch = useDispatch;
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
+`;
+        fs.writeFileSync(path.join(storeDir, "hooks.ts"), hooks);
+    }
+
+    const appDir = appDirFor(projectPath, config);
+    const providers = ts
+        ? `"use client";
+
+import { Provider } from "react-redux";
+import { store } from "@/store";
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  return <Provider store={store}>{children}</Provider>;
+}
+`
+        : `"use client";
+
+import { Provider } from "react-redux";
+import { store } from "@/store";
+
+export function Providers({ children }) {
+  return <Provider store={store}>{children}</Provider>;
+}
+`;
+    fs.writeFileSync(path.join(appDir, `providers.${compExt}`), providers);
+
+    patchLayoutWithProviders(appDir, ts);
+}
+
+async function setupZustand(projectPath, config) {
+    console.log();
+    console.log(pc.cyan("◆") + " Setting up Zustand...");
+    console.log();
+
+    const installer = installerFor(config.packageManager, false);
+    await run(installer.cmd, [...installer.args, "zustand"], { cwd: projectPath });
+
+    const storeDir = storeDirFor(projectPath, config);
+    fs.mkdirSync(storeDir, { recursive: true });
+
+    const ts = config.typescript;
+    const ext = ts ? "ts" : "js";
+    const contents = ts
+        ? `import { create } from "zustand";
+
+interface CounterState {
+  count: number;
+  increment: () => void;
+  decrement: () => void;
+  reset: () => void;
+}
+
+export const useCounterStore = create<CounterState>((set) => ({
+  count: 0,
+  increment: () => set((s) => ({ count: s.count + 1 })),
+  decrement: () => set((s) => ({ count: s.count - 1 })),
+  reset: () => set({ count: 0 }),
+}));
+`
+        : `import { create } from "zustand";
+
+export const useCounterStore = create((set) => ({
+  count: 0,
+  increment: () => set((s) => ({ count: s.count + 1 })),
+  decrement: () => set((s) => ({ count: s.count - 1 })),
+  reset: () => set({ count: 0 }),
+}));
+`;
+    fs.writeFileSync(path.join(storeDir, `useCounterStore.${ext}`), contents);
+}
+
+function patchLayoutWithProviders(appDir, ts) {
+    const layoutPath = path.join(appDir, ts ? "layout.tsx" : "layout.js");
+    if (!fs.existsSync(layoutPath)) {
+        console.log(pc.yellow("⚠") + ` Could not find ${path.basename(layoutPath)} — wrap {children} with <Providers> manually.`);
+        return;
+    }
+
+    let layout = fs.readFileSync(layoutPath, "utf8");
+    const original = layout;
+
+    if (!layout.includes(`from "./providers"`)) {
+        if (/import\s+["']\.\/globals\.css["'];?/.test(layout)) {
+            layout = layout.replace(
+                /(import\s+["']\.\/globals\.css["'];?)/,
+                `$1\nimport { Providers } from "./providers";`
+            );
+        } else {
+            layout = `import { Providers } from "./providers";\n${layout}`;
+        }
+    }
+
+    if (!layout.includes("<Providers>") && layout.includes("{children}")) {
+        layout = layout.replace("{children}", "<Providers>{children}</Providers>");
+    }
+
+    if (layout === original) {
+        console.log(pc.yellow("⚠") + " Could not auto-wrap layout — please wrap {children} with <Providers> manually.");
+        return;
+    }
+
+    fs.writeFileSync(layoutPath, layout);
+}
+
+async function setupHusky(projectPath, config) {
+    console.log();
+    console.log(pc.cyan("◆") + " Setting up Husky + lint-staged + Prettier...");
+    console.log();
+
+    const installer = installerFor(config.packageManager, true);
+    await run(
+        installer.cmd,
+        [...installer.args, "husky@^8", "lint-staged", "prettier"],
+        { cwd: projectPath }
+    );
+
+    const pkgPath = path.join(projectPath, "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    pkg.scripts = {
+        ...pkg.scripts,
+        prepare: "husky install",
+        format: "prettier --check .",
+        "format:fix": "prettier --write .",
+        "lint:fix": "eslint --fix",
+        ...(config.typescript ? { typecheck: "tsc --noEmit" } : {}),
+    };
+    delete pkg["lint-staged"];
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+
+    const runner = runnerFor(config.packageManager);
+    await run(runner.cmd, [...runner.args, "husky", "install"], {
+        cwd: projectPath,
+    });
+
+    await run("git", ["config", "core.hooksPath", ".husky"], { cwd: projectPath });
+
+    const huskyDir = path.join(projectPath, ".husky");
+    if (!fs.existsSync(huskyDir)) fs.mkdirSync(huskyDir, { recursive: true });
+
+    const hookCmd = config.typescript
+        ? "npx tsc --noEmit && npx lint-staged"
+        : "npx lint-staged";
+    const preCommit = `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${hookCmd}
+`;
+    const preCommitPath = path.join(huskyDir, "pre-commit");
+    fs.writeFileSync(preCommitPath, preCommit);
+    fs.chmodSync(preCommitPath, 0o755);
+
+    const jsGlob = config.typescript ? "*.{js,jsx,ts,tsx}" : "*.{js,jsx}";
+    const lintStagedConfig = {
+        [jsGlob]: ["eslint --fix", "prettier --write"],
+        "*.{json,css,scss,md,mdx,yml,yaml,html}": ["prettier --write"],
+    };
+    fs.writeFileSync(
+        path.join(projectPath, ".lintstagedrc.json"),
+        JSON.stringify(lintStagedConfig, null, 2) + "\n"
+    );
+
+    const prettierrc = {
+        semi: true,
+        singleQuote: false,
+        tabWidth: 2,
+        trailingComma: "es5",
+        printWidth: 100,
+        arrowParens: "always",
+        endOfLine: "lf",
+    };
+    fs.writeFileSync(path.join(projectPath, ".prettierrc"), JSON.stringify(prettierrc, null, 2) + "\n");
+
+    const prettierIgnore = [
+        "node_modules",
+        ".next",
+        "out",
+        "build",
+        "dist",
+        "coverage",
+        "package-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "bun.lockb",
+        "",
+    ].join("\n");
+    fs.writeFileSync(path.join(projectPath, ".prettierignore"), prettierIgnore);
+}
+
+function installerFor(pm, dev = true) {
+    switch (pm) {
+        case "pnpm":
+            return { cmd: "pnpm", args: dev ? ["add", "-D"] : ["add"] };
+        case "yarn":
+            return { cmd: "yarn", args: dev ? ["add", "-D"] : ["add"] };
+        case "bun":
+            return { cmd: "bun", args: dev ? ["add", "-d"] : ["add"] };
+        case "npm":
+        default:
+            return { cmd: "npm", args: dev ? ["install", "-D"] : ["install"] };
+    }
+}
+
+function runnerFor(pm) {
+    switch (pm) {
+        case "pnpm":
+            return { cmd: "pnpm", args: ["dlx"] };
+        case "yarn":
+            return { cmd: "yarn", args: ["dlx"] };
+        case "bun":
+            return { cmd: "bunx", args: [] };
+        case "npm":
+        default:
+            return { cmd: "npx", args: [] };
+    }
+}

package/src/utils.js

@@ -0,0 +1,70 @@
+import { spawn } from "node:child_process";
+
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith("--")) {
+            const eq = arg.indexOf("=");
+            if (eq !== -1) {
+                flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+            } else {
+                const key = arg.slice(2);
+                const next = argv[i + 1];
+                if (next && !next.startsWith("-")) {
+                    flags[key] = next;
+                    i++;
+                } else {
+                    flags[key] = true;
+                }
+            }
+        } else if (arg.startsWith("-") && arg.length > 1) {
+            flags[arg.slice(1)] = true;
+        } else {
+            positional.push(arg);
+        }
+    }
+
+    const pm = flags.pnpm ? "pnpm" : flags.yarn ? "yarn" : flags.bun ? "bun" : flags.npm ? "npm" : undefined;
+
+    let ts;
+    if (flags.ts || flags.typescript) ts = true;
+    else if (flags.js || flags.javascript) ts = false;
+
+    const state = ["redux", "zustand", "none"].includes(flags.state) ? flags.state : undefined;
+
+    return {
+        projectName: positional[0],
+        yes: Boolean(flags.yes || flags.y),
+        help: Boolean(flags.help || flags.h),
+        version: Boolean(flags.version || flags.v),
+        typescript: ts,
+        packageManager: pm,
+        husky: flags["no-husky"] ? false : undefined,
+        state,
+    };
+}
+
+export function run(cmd, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            stdio: "inherit",
+            shell: process.platform === "win32",
+            ...options,
+        });
+        child.on("error", reject);
+        child.on("close", (code) => {
+            if (code === 0) resolve();
+            else reject(new Error(`Command failed: ${cmd} ${args.join(" ")} (exit ${code})`));
+        });
+    });
+}
+
+export function isValidProjectName(name) {
+    if (!name || typeof name !== "string") return false;
+    if (name.length > 214) return false;
+    if (name === "." || name === "..") return false;
+    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i.test(name);
+}