belazywithreact 0.1.0__py3-none-any.whl

belazywithreact/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

belazywithreact/cli.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from .scaffold import ProjectOptions, create_project
+from .validators import check_node_tools, resolve_destination
+
+app = typer.Typer(
+    name="belazywithreact",
+    help="Scaffold a React + TypeScript project with your preferred starter tools.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+
+@app.callback()
+def main() -> None:
+    pass
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Name of the project directory to create."),
+    styling: str = typer.Option("both", "--styling", help="Styling setup: css, tailwind, or both."),
+    router: bool = typer.Option(True, "--router/--no-router", help="Configure React Router."),
+    axios: bool = typer.Option(True, "--axios/--no-axios", help="Install Axios and add an API client."),
+    zustand: bool = typer.Option(True, "--zustand/--no-zustand", help="Install Zustand and add an example store."),
+    eslint: bool = typer.Option(True, "--eslint/--no-eslint", help="Configure ESLint for TypeScript and React."),
+    prettier: bool = typer.Option(True, "--prettier/--no-prettier", help="Install Prettier and add a format script."),
+    vitest: bool = typer.Option(True, "--vitest/--no-vitest", help="Install Vitest and add a test script."),
+    package_manager: str = typer.Option("npm", "--package-manager", help="Package manager (npm only in v0.1.0)."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation; never overwrite existing paths."),
+) -> None:
+    styling = styling.lower().strip()
+    if styling not in {"css", "tailwind", "both"}:
+        console.print("[red]Invalid --styling value.[/red] Choose css, tailwind, or both.")
+        raise typer.Exit(code=2)
+    package_manager = package_manager.lower().strip()
+    if package_manager != "npm":
+        console.print("[red]Only npm is supported in version 0.1.0.[/red]")
+        raise typer.Exit(code=2)
+
+    try:
+        destination = resolve_destination(name, Path.cwd())
+        if destination.exists() or destination.is_symlink():
+            console.print(f"[red]Destination already exists:[/red] {destination}")
+            console.print("Choose a different project name. Existing files will not be overwritten.")
+            raise typer.Exit(code=2)
+        check_node_tools()
+    except (ValueError, RuntimeError) as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=2) from exc
+
+    options = ProjectOptions(
+        styling=styling, router=router, axios=axios, zustand=zustand,
+        eslint=eslint, prettier=prettier, vitest=vitest, package_manager=package_manager,
+    )
+    if not yes:
+        console.print(Panel.fit(
+            f"[bold]Project:[/bold] {name}\n"
+            f"[bold]Styling:[/bold] {styling}\n"
+            f"[bold]Router:[/bold] {'yes' if router else 'no'}\n"
+            f"[bold]Axios:[/bold] {'yes' if axios else 'no'}\n"
+            f"[bold]Zustand:[/bold] {'yes' if zustand else 'no'}\n"
+            f"[bold]ESLint:[/bold] {'yes' if eslint else 'no'}\n"
+            f"[bold]Prettier:[/bold] {'yes' if prettier else 'no'}\n"
+            f"[bold]Vitest:[/bold] {'yes' if vitest else 'no'}\n"
+            "[bold]Package manager:[/bold] npm",
+            title="belazywithreact setup",
+        ))
+        if not typer.confirm("Create this project?"):
+            console.print("Cancelled.")
+            raise typer.Exit()
+
+    try:
+        with console.status("[bold green]Creating your React project...[/bold green]"):
+            create_project(name, destination, options)
+    except KeyboardInterrupt as exc:
+        console.print("[yellow]Setup interrupted.[/yellow] Any partial project is preserved; inspect it before retrying.")
+        raise typer.Exit(code=130) from exc
+    except FileExistsError as exc:
+        console.print(f"[red]{exc}[/red]")
+        raise typer.Exit(code=2) from exc
+    except Exception as exc:
+        console.print(f"[red]Setup failed:[/red] {exc}")
+        console.print(
+            "The project directory may have been partially created. Inspect it before retrying; "
+            "belazywithreact does not delete it automatically."
+        )
+        raise typer.Exit(code=1) from exc
+
+    console.print(f"\n[bold green]Done![/bold green] Created [cyan]{name}[/cyan].")
+    console.print(f"Next:\n  cd {name}\n  npm run dev")
+    if vitest:
+        console.print("Run tests with: npm test")
+
+
+if __name__ == "__main__":
+    app()

belazywithreact/scaffold.py

@@ -0,0 +1,367 @@
+import json
+import os
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from .validators import resolve_destination
+
+CREATE_VITE_VERSION = "9.2.1"
+_IS_WINDOWS = os.name == "nt"
+
+Runner = Callable[..., subprocess.CompletedProcess]
+
+
+@dataclass(frozen=True)
+class ProjectOptions:
+    styling: str = "both"
+    router: bool = True
+    axios: bool = True
+    zustand: bool = True
+    eslint: bool = True
+    prettier: bool = True
+    vitest: bool = True
+    package_manager: str = "npm"
+
+
+def run_command(
+    command: list[str],
+    *,
+    cwd: Path | None = None,
+    runner: Runner = subprocess.run,
+) -> None:
+    """Run commands cross-platform, including Windows npm .cmd launchers."""
+    working_directory = str(cwd) if cwd else None
+
+    if _IS_WINDOWS and command and command[0].lower() == "npm":
+        npm_cmd = shutil.which("npm.cmd") or shutil.which("npm")
+
+        if not npm_cmd:
+            raise FileNotFoundError(
+                "Cannot find npm.cmd. Install Node.js LTS "
+                "and reopen PowerShell."
+            )
+
+        # list2cmdline quotes spaces but does not escape cmd.exe operators.
+        # Keep the working CALL/npm.cmd invocation; reject shell syntax first.
+        if any(re.search(r'[&|<>^%!"\r\n]', arg) for arg in command[1:]):
+            raise ValueError("Unsafe shell characters in npm arguments.")
+        args = subprocess.list2cmdline(command[1:])
+        command_line = f'call "{npm_cmd}" {args}'
+
+        runner(
+            command_line,
+            cwd=working_directory,
+            check=True,
+            shell=True,
+        )
+        return
+
+    runner(
+        command,
+        cwd=working_directory,
+        check=True,
+    )
+
+
+def _write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content.rstrip() + "\n", encoding="utf-8")
+
+
+def _add_gitkeep(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+    if not any(path.iterdir()):
+        (path / ".gitkeep").write_text("", encoding="utf-8")
+
+
+def configure_project(destination: Path, options: ProjectOptions) -> None:
+    src = destination / "src"
+    gitignore = destination / ".gitignore"
+    existing_ignore = gitignore.read_text(encoding="utf-8") if gitignore.exists() else ""
+    _write(gitignore, existing_ignore.rstrip() + "\n\n# Local environment values\n.env\n.env.*\n!.env.example\n")
+    for folder in ("assets", "components", "hooks", "layouts", "pages", "services", "store", "types", "utils"):
+        _add_gitkeep(src / folder)
+
+    _write(src / "components" / "Button.tsx", '''import type { ButtonHTMLAttributes, PropsWithChildren } from "react";
+
+type ButtonProps = PropsWithChildren<ButtonHTMLAttributes<HTMLButtonElement>>;
+
+export function Button({ children, className = "", ...props }: ButtonProps) {
+  return (
+    <button className={`app-button ${className}`.trim()} {...props}>
+      {children}
+    </button>
+  );
+}
+''')
+    _write(src / "pages" / "HomePage.tsx", '''import { Button } from "../components/Button";
+
+export function HomePage() {
+  return (
+    <main className="page">
+      <p className="eyebrow">Your project is ready</p>
+      <h1>Build something great.</h1>
+      <p className="intro">
+        This React + TypeScript starter was created with belazywithreact.
+      </p>
+      <Button onClick={() => window.alert("Your setup is working!")}>
+        Test the starter
+      </Button>
+    </main>
+  );
+}
+''')
+
+    css = '''@import "./tailwind.css";
+
+:root {
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  color: #172033;
+  background: #f6f8fc;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+}
+* { box-sizing: border-box; }
+body { margin: 0; min-width: 320px; min-height: 100vh; }
+button { font: inherit; }
+.page {
+  width: min(760px, calc(100% - 40px));
+  margin: 12vh auto;
+  padding: clamp(24px, 5vw, 56px);
+  border: 1px solid #e1e7f0;
+  border-radius: 28px;
+  background: white;
+  box-shadow: 0 24px 70px rgb(31 49 82 / 9%);
+}
+.eyebrow { color: #6558d3; font-size: .8rem; font-weight: 800; letter-spacing: .12em; text-transform: uppercase; }
+h1 { margin: 12px 0; font-size: clamp(2.2rem, 6vw, 4rem); letter-spacing: -.055em; line-height: 1.05; }
+.intro { max-width: 560px; color: #59657a; font-size: 1.1rem; line-height: 1.7; }
+.app-button { margin-top: 18px; padding: 12px 18px; color: white; background: #5145cd; border: 0; border-radius: 12px; cursor: pointer; font-weight: 700; }
+.app-button:hover { background: #4035b2; }
+'''
+    if options.styling in {"tailwind", "both"}:
+        _write(src / "styles" / "tailwind.css", '@import "tailwindcss";')
+        _write(destination / "vite.config.ts", '''import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig } from "vite";
+
+export default defineConfig({ plugins: [react(), tailwindcss()] });
+''')
+    else:
+        _write(src / "styles" / "tailwind.css", "/* Tailwind is disabled for this project. */")
+
+    _write(src / "styles" / "index.css", css)
+    app_content = '''import "./styles/index.css";
+import { HomePage } from "./pages/HomePage";
+
+export default function App() {
+  return <HomePage />;
+}
+'''
+    if options.router:
+        app_content = '''import { BrowserRouter, Route, Routes } from "react-router-dom";
+import "./styles/index.css";
+import { HomePage } from "./pages/HomePage";
+
+function NotFoundPage() {
+  return <main className="page"><h1>Page not found</h1><p>Check the URL and try again.</p></main>;
+}
+
+export default function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<HomePage />} />
+        <Route path="*" element={<NotFoundPage />} />
+      </Routes>
+    </BrowserRouter>
+  );
+}
+'''
+    _write(src / "App.tsx", app_content)
+    _write(src / "main.tsx", '''import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App";
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode><App /></StrictMode>,
+);
+''')
+    if options.eslint:
+        _write(destination / "eslint.config.js", '''import js from "@eslint/js";
+import globals from "globals";
+import reactHooks from "eslint-plugin-react-hooks";
+import reactRefresh from "eslint-plugin-react-refresh";
+import tseslint from "typescript-eslint";
+import { defineConfig, globalIgnores } from "eslint/config";
+
+export default defineConfig([
+  globalIgnores(["dist", "coverage"]),
+  {
+    files: ["**/*.{ts,tsx}"],
+    extends: [js.configs.recommended, tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended, reactRefresh.configs.vite],
+    languageOptions: { globals: globals.browser },
+  },
+]);
+''')
+
+    if options.axios:
+        _write(src / "services" / "api.ts", '''import axios from "axios";
+
+export const api = axios.create({
+  baseURL: import.meta.env.VITE_API_BASE_URL ?? "",
+  timeout: 15_000,
+  headers: { "Content-Type": "application/json" },
+});
+''')
+        _write(destination / ".env.example", "VITE_API_BASE_URL=https://api.example.com")
+    else:
+        _write(destination / ".env.example", "# Add VITE_ prefixed public environment variables here.")
+
+    if options.zustand:
+        _write(src / "store" / "useAppStore.ts", '''import { create } from "zustand";
+
+type AppState = {
+  count: number;
+  increment: () => void;
+  reset: () => void;
+};
+
+export const useAppStore = create<AppState>((set) => ({
+  count: 0,
+  increment: () => set((state) => ({ count: state.count + 1 })),
+  reset: () => set({ count: 0 }),
+}));
+''')
+
+    if options.vitest:
+        _write(src / "utils" / "example.test.ts", '''import { describe, expect, it } from "vitest";
+
+describe("starter test", () => {
+  it("runs Vitest successfully", () => {
+    expect(1 + 1).toBe(2);
+  });
+});
+''')
+
+    test_script = '\n- `npm test` — run Vitest' if options.vitest else ""
+    format_script = '\n- `npm run format` — format files with Prettier' if options.prettier else ""
+    lint_script = '\n- `npm run lint` — run ESLint' if options.eslint else ""
+    readme = f'''# {destination.name}
+
+React + TypeScript starter generated by **belazywithreact**.
+
+## Start development
+
+```bash
+npm run dev
+```
+
+## Available scripts
+
+- `npm run dev` — start the Vite development server
+- `npm run build` — type-check and build for production{lint_script}{test_script}{format_script}
+
+## Project structure
+
+- `src/components` — reusable UI components
+- `src/pages` — route-level pages
+- `src/hooks` — reusable React hooks
+- `src/services` — API clients and service functions
+- `src/store` — client-side state
+- `src/styles` — global CSS and Tailwind entry point
+- `src/utils` — shared utilities
+'''
+    _write(destination / "README.md", readme)
+
+
+def create_project(name: str, destination: Path, options: ProjectOptions, *, runner: Runner = subprocess.run) -> None:
+    if options.package_manager != "npm":
+        raise ValueError("Only npm is supported in belazywithreact 0.1.0.")
+    if options.styling not in {"css", "tailwind", "both"}:
+        raise ValueError("Styling must be css, tailwind, or both.")
+    # Validate library callers too, before any shell command or file write.
+    if destination.is_symlink() or destination.exists():
+        raise FileExistsError(
+            f"Destination already exists: {destination}. Choose another name; existing files are never overwritten."
+        )
+    if resolve_destination(name, destination.parent) != destination.resolve():
+        raise ValueError("Project name must match the destination directory.")
+
+    run_command(
+        ["npm", "create", f"vite@{CREATE_VITE_VERSION}", name, "--", "--template", "react-ts", "--no-interactive"],
+        cwd=destination.parent,
+        runner=runner,
+    )
+    if not destination.is_dir():
+        raise RuntimeError("Vite completed without creating the expected directory. Check npm output.")
+
+    configure_project(destination, options)
+
+    dependencies: list[str] = []
+    dev_dependencies: list[str] = []
+    if options.router:
+        dependencies.append("react-router-dom@7.18.4")
+    if options.axios:
+        dependencies.append("axios@1.20.0")
+    if options.zustand:
+        dependencies.append("zustand@5.0.15")
+    if options.styling in {"tailwind", "both"}:
+        dev_dependencies.extend(["tailwindcss@4.3.3", "@tailwindcss/vite@4.3.3"])
+    if options.eslint:
+        dev_dependencies.extend(["eslint@10.12.0", "@eslint/js@10.0.1", "typescript-eslint@8.71.2",
+                                 "globals@17.13.0", "eslint-plugin-react-hooks@7.1.1",
+                                 "eslint-plugin-react-refresh@0.5.7"])
+    if options.prettier:
+        dev_dependencies.append("prettier@3.9.10")
+    if options.vitest:
+        dev_dependencies.append("vitest@5.0.4")
+
+    if dependencies:
+        run_command(["npm", "install", *dependencies], cwd=destination, runner=runner)
+    if dev_dependencies:
+        run_command(["npm", "install", "--save-dev", *dev_dependencies], cwd=destination, runner=runner)
+
+    package_json_path = destination / "package.json"
+    package_data = json.loads(package_json_path.read_text(encoding="utf-8"))
+    scripts = package_data.setdefault("scripts", {})
+    # Current Vite templates use Oxlint. Explicitly honor the ESLint option.
+    for section in ("dependencies", "devDependencies"):
+        package_data.get(section, {}).pop("oxlint", None)
+        package_data.get(section, {}).pop("oxlint-tsgolint", None)
+    for config_name in (".oxlintrc.json", "oxlint.config.ts"):
+        (destination / config_name).unlink(missing_ok=True)
+    if options.eslint:
+        scripts["lint"] = "eslint ."
+    if options.vitest:
+        scripts["test"] = "vitest run"
+        scripts["test:watch"] = "vitest"
+    if options.prettier:
+        scripts["format"] = "prettier --write ."
+        _write(destination / ".prettierignore", "node_modules\ndist\ncoverage\npackage-lock.json\n")
+
+    if not options.eslint:
+        scripts.pop("lint", None)
+        for config_name in ("eslint.config.js", "eslint.config.mjs", ".eslintrc", ".eslintrc.json"):
+            config_path = destination / config_name
+            if config_path.exists():
+                config_path.unlink()
+        eslint_packages = {
+            "eslint", "@eslint/js", "eslint-plugin-react-hooks",
+            "eslint-plugin-react-refresh", "typescript-eslint", "globals",
+        }
+        for section in ("dependencies", "devDependencies"):
+            packages = package_data.get(section, {})
+            for package_name in eslint_packages:
+                packages.pop(package_name, None)
+
+    package_json_path.write_text(json.dumps(package_data, indent=2) + "\n", encoding="utf-8")
+    # Always install: minimal projects have no optional installation commands.
+    # This also synchronizes the lockfile after removing optional tooling.
+    run_command(["npm", "install"], cwd=destination, runner=runner)

belazywithreact/validators.py

@@ -0,0 +1,60 @@
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+_PROJECT_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
+_WINDOWS_RESERVED = {"con", "prn", "aux", "nul", "conin$", "conout$"} | {
+    f"{prefix}{number}" for prefix in ("com", "lpt") for number in range(1, 10)
+}
+
+
+def validate_project_name(name: str) -> str:
+    if not name or name in {".", ".."}:
+        raise ValueError("Project name must be a non-empty directory name.")
+    if not _PROJECT_NAME.fullmatch(name):
+        raise ValueError(
+            "Project name may contain only letters, numbers, dots, underscores, and hyphens, "
+            "and must start with a letter or number."
+        )
+    if name.endswith(".") or name.endswith(" "):
+        raise ValueError("Project name cannot end with a dot or space.")
+    if name.split(".", 1)[0].lower() in _WINDOWS_RESERVED:
+        raise ValueError("Project name is reserved on Windows. Choose another name.")
+    if len(name) > 214 or name.lower() in {"node_modules", "favicon.ico"}:
+        raise ValueError("Project name is reserved by npm or exceeds 214 characters.")
+    return name
+
+
+def resolve_destination(name: str, cwd: Path | None = None) -> Path:
+    validate_project_name(name)
+    base = (cwd or Path.cwd()).resolve()
+    destination = (base / name).resolve()
+    if destination == base or base not in destination.parents:
+        raise ValueError("Destination must be a child directory of the current directory.")
+    if (base / name).is_symlink():
+        raise ValueError("Destination is a symbolic link. Choose another project name.")
+    return destination
+
+
+def check_node_tools() -> tuple[str, str]:
+    node = shutil.which("node")
+    npm = shutil.which("npm.cmd") or shutil.which("npm")
+    missing = []
+    if not node:
+        missing.append("Node.js (node)")
+    if not npm:
+        missing.append("npm")
+    if missing:
+        raise RuntimeError(
+            "Missing required tool(s): " + ", ".join(missing) +
+            ". Install a supported Node.js LTS release, then reopen your terminal."
+        )
+    try:
+        result = subprocess.run([node, "--version"], check=True, capture_output=True, text=True, timeout=10)
+        version = tuple(int(part) for part in result.stdout.strip().lstrip("v").split("."))
+    except (OSError, subprocess.SubprocessError, ValueError) as exc:
+        raise RuntimeError("Cannot run Node.js. Check the installation and PATH, then reopen your terminal.") from exc
+    if version < (22, 13, 0) or version[0] % 2:
+        raise RuntimeError("Use Node.js 22.13+ on an even-numbered release; Node.js 24 LTS is recommended.")
+    return node, npm

belazywithreact-0.1.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.5
+Name: belazywithreact
+Version: 0.1.0
+Summary: A Python CLI that scaffolds ready-to-use React projects.
+Project-URL: Homepage, https://github.com/Sanju2911/belazywithreact
+Project-URL: Repository, https://github.com/Sanju2911/belazywithreact
+Project-URL: Issues, https://github.com/Sanju2911/belazywithreact/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,react,scaffold,typescript,vite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Requires-Dist: rich<15.0,>=13.7
+Requires-Dist: typer<1.0,>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=6.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# belazywithreact
+
+[![CI](https://github.com/Sanju2911/belazywithreact/actions/workflows/tests.yml/badge.svg)](https://github.com/Sanju2911/belazywithreact/actions/workflows/tests.yml)
+
+A Python CLI that creates a React + TypeScript app with Vite and a useful starter
+structure. Version **0.1.0** is the initial release. npm is the supported package
+manager.
+
+## Prerequisites
+
+- Python 3.10 or newer.
+- An even-numbered Node.js release >=22.13; Node.js 24 LTS is recommended.
+- npm on PATH and internet access to download packages from the npm registry.
+
+Check `python --version`, `node --version`, and `npm --version`.
+
+## Installation
+
+Install a published release from PyPI:
+
+```powershell
+python -m pip install belazywithreact
+belazywithreact --help
+```
+
+Install from a local checkout:
+
+```powershell
+python -m pip install .
+```
+
+For development on Windows, a virtual environment avoids global changes and
+does not require changing PowerShell's execution policy:
+
+```powershell
+py -m venv .venv
+.\.venv\Scripts\python.exe -m pip install -e ".[dev]"
+.\.venv\Scripts\belazywithreact.exe --help
+```
+
+On macOS/Linux use `python3 -m venv .venv`, then `.venv/bin/python` and
+`.venv/bin/belazywithreact` instead.
+
+## Usage
+
+```powershell
+belazywithreact create my-app
+cd my-app
+npm run dev
+```
+
+Creation asks for confirmation. `--yes` skips that question and still refuses
+to overwrite an existing destination, including an empty directory.
+
+Defaults include CSS + Tailwind CSS 4, React Router, Axios, Zustand, ESLint,
+Prettier, and Vitest. Tailwind uses its official Vite plugin and CSS import;
+customize its theme in CSS. ESLint is explicitly configured for TypeScript and
+React. `npm test` runs once, and `npm run test:watch` starts watch mode.
+
+A minimal CSS app:
+
+```powershell
+belazywithreact create my-app --styling css --no-router --no-axios --no-zustand --no-eslint --no-prettier --no-vitest --yes
+```
+
+| Option | Default | Behavior |
+| --- | --- | --- |
+| `--styling css\|tailwind\|both` | `both` | Enables Tailwind in tailwind/both; custom starter CSS is always included |
+| `--router` / `--no-router` | enabled | Home and fallback routes with BrowserRouter |
+| `--axios` / `--no-axios` | enabled | Axios API client and public API base URL example |
+| `--zustand` / `--no-zustand` | enabled | Example counter store |
+| `--eslint` / `--no-eslint` | enabled | ESLint config, dependencies, and lint script |
+| `--prettier` / `--no-prettier` | enabled | Format script and ignore file |
+| `--vitest` / `--no-vitest` | enabled | Test scripts and example unit test |
+| `--package-manager npm` | `npm` | Only npm is supported in 0.1.0 |
+| `--yes`, `-y` | disabled | Skip confirmation |
+
+Use `belazywithreact create --help` for all options.
+
+## Generated structure
+
+```text
+my-app/
+  src/
+    assets/
+    components/Button.tsx
+    hooks/
+    layouts/
+    pages/HomePage.tsx
+    services/api.ts          # when Axios is enabled
+    store/useAppStore.ts     # when Zustand is enabled
+    styles/index.css
+    styles/tailwind.css
+    types/
+    utils/example.test.ts    # when Vitest is enabled
+    App.tsx
+    main.tsx
+  .env.example
+  eslint.config.js          # when ESLint is enabled
+  vite.config.ts
+  package.json
+  package-lock.json
+  README.md
+```
+
+The Button supports native button props and children. Customize the generated
+components, folders, API client, and store after creation. Empty starter folders
+contain .gitkeep files. The scaffold does not provide authentication, backend
+services, deployment, or arbitrary folder/component generation flags.
+
+Validate your generated app:
+
+```powershell
+npm ci
+npm test
+npm run lint
+npm run build
+```
+
+Test and lint commands require their respective enabled options.
+BrowserRouter deployments need a server fallback to index.html for route URLs.
+All `VITE_` environment variables are public browser values, never secrets.
+
+## Troubleshooting
+
+- **Missing Node/npm or WinError 2:** install Node.js 24 LTS and reopen the
+  terminal so PATH updates. On Windows, check `where.exe node` and
+  `where.exe npm`; `npm.cmd --version` should work. The CLI preserves its
+  tested `call "<resolved npm.cmd>"` launch method for paths containing spaces.
+- **Unsupported Node version:** upgrade to an even-numbered release >=22.13.
+  The generated tooling needs a newer Node version than some older Vite releases.
+- **Invalid name:** use a directory name starting with a letter or number and
+  containing only letters, numbers, dots, underscores, or hyphens. Names cannot
+  end in a dot, exceed 214 characters, use Windows device names like CON/LPT1,
+  or use npm-reserved names. Path separators and shell operators are rejected.
+  Vite normalizes uppercase directory names to valid npm package names.
+- **Destination exists:** choose another name; existing files are preserved.
+- **npm failure or interruption:** read npm's output and check network/PATH.
+  Partial projects are preserved. Inspect them before manually removing or
+  repairing them; a retry with the same name will refuse to overwrite them.
+- **Dependency advisory:** run `npm audit` and review compatible upgrades;
+  do not blindly force a major upgrade.
+
+## Architecture and development
+
+`cli.py` parses options with Typer and prints progress/errors with Rich.
+`validators.py` validates names, destination boundaries, and Node prerequisites.
+`scaffold.py` invokes create-vite **9.2.1**, writes the starter files, installs
+selected tools, updates package.json, and synchronizes package-lock.json. npm
+output remains visible, and failures return nonzero status. Interruption during
+creation returns 130. The CLI never deletes a partial project automatically.
+
+The Vite creator and optional-tool install requests specify reviewed versions;
+Vite's base template and npm semver ranges can still resolve newer compatible
+dependencies. Commit the generated lockfile and use `npm ci` for reproducible
+app installations. Revalidate dependencies before a future CLI release.
+
+```powershell
+python -m pytest
+python -m build
+python -m twine check --strict dist/*
+python scripts/check_dist.py
+```
+
+Unit tests mock npm and run offline. CI checks Python 3.10, 3.12, and 3.14 on
+Windows, macOS, and Linux, validates distributions, and builds real default and
+minimal React apps. See [CONTRIBUTING.md](CONTRIBUTING.md) for contributions,
+[SECURITY.md](SECURITY.md) for security reporting, and
+[RELEASING.md](RELEASING.md) for TestPyPI-first Trusted Publishing and explicit
+production-release approval. GitHub and both package-index accounts must be
+configured separately before publication.
+
+## License
+
+[MIT](LICENSE).

belazywithreact-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+belazywithreact/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+belazywithreact/cli.py,sha256=-q89q0FCwCujxwB1cjJjTXjiQXFWnS--R51VQeOu9XM,4524
+belazywithreact/scaffold.py,sha256=wGweDMUbadOrY_s5U2roh1kJQ0fJVJT7WSsY8s0RkiU,13024
+belazywithreact/validators.py,sha256=KA5aeh4lLirko4GUSKpccjeGmR0BdZx0v61RwC3YeN8,2641
+belazywithreact-0.1.0.dist-info/METADATA,sha256=fzkXGxlG7lxWa_wiNh0mahoMeXK6LaS3pzc8weCrqpk,7842
+belazywithreact-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+belazywithreact-0.1.0.dist-info/entry_points.txt,sha256=HaDMASqg7QfnwAXp-m4S2khdLpg7NQRnDZuTT159c4E,60
+belazywithreact-0.1.0.dist-info/licenses/LICENSE,sha256=pQ--5-WB6kwYHgoSVgVOr5xEdyQzfy2g-fh8xBSL5so,1085
+belazywithreact-0.1.0.dist-info/RECORD,,

belazywithreact-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

belazywithreact-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+belazywithreact = belazywithreact.cli:app

belazywithreact-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 belazywithreact contributors
+
+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.