create-jemo-app 0.1.0__tar.gz

create_jemo_app-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: create-jemo-app
+Version: 0.1.0
+Summary: A CLI tool to scaffold modern web projects with FastAPI, Django, Convex, Next.js, SvelteKit, or TanStack Start.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=14.3.2
+Requires-Dist: typer>=0.23.0
+
+# Jemo Admin CLI
+
+A powerful CLI tool to scaffold modern web projects with your favorite stack.
+
+## Supported Stacks
+
+**Backend:**
+- **FastAPI** (with Tortoise ORM & Aerich)
+- **Django**
+- **Convex** (Serverless)
+
+**Frontend:**
+- **Next.js**
+- **SvelteKit**
+- **TanStack Start**
+
+## Installation
+
+You can install `jemo-admin` using `pipx`:
+
+```bash
+pipx install .
+# Or from a git repo:
+# pipx install git+https://github.com/yourusername/create-jemo-app.git
+```
+
+## Usage
+
+Create a new project interactively:
+
+```bash
+jemo-admin create
+```
+
+Or specify the project name directly:
+
+```bash
+jemo-admin create my-awesome-app
+```
+
+Follow the interactive prompts to select your backend and frontend framework.
+
+## Requirements
+
+- **Python 3.12+**
+- **Bun** (for frontend package management)
+- **UV** (for Python package management)

create_jemo_app-0.1.0/README.md

@@ -0,0 +1,47 @@
+# Jemo Admin CLI
+
+A powerful CLI tool to scaffold modern web projects with your favorite stack.
+
+## Supported Stacks
+
+**Backend:**
+- **FastAPI** (with Tortoise ORM & Aerich)
+- **Django**
+- **Convex** (Serverless)
+
+**Frontend:**
+- **Next.js**
+- **SvelteKit**
+- **TanStack Start**
+
+## Installation
+
+You can install `jemo-admin` using `pipx`:
+
+```bash
+pipx install .
+# Or from a git repo:
+# pipx install git+https://github.com/yourusername/create-jemo-app.git
+```
+
+## Usage
+
+Create a new project interactively:
+
+```bash
+jemo-admin create
+```
+
+Or specify the project name directly:
+
+```bash
+jemo-admin create my-awesome-app
+```
+
+Follow the interactive prompts to select your backend and frontend framework.
+
+## Requirements
+
+- **Python 3.12+**
+- **Bun** (for frontend package management)
+- **UV** (for Python package management)

create_jemo_app-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "create-jemo-app"
+version = "0.1.0"
+description = "A CLI tool to scaffold modern web projects with FastAPI, Django, Convex, Next.js, SvelteKit, or TanStack Start."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "questionary>=2.1.1",
+    "rich>=14.3.2",
+    "typer>=0.23.0",
+]
+
+[project.scripts]
+jemo-admin = "jemo_admin.main:app"
+
+[tool.uv.workspace]
+members = [
+    "test/test-app/backend",
+    "test/my-jemo-app/backend",
+    "test/reproduce_error/backend",
+]

create_jemo_app-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

create_jemo_app-0.1.0/src/create_jemo_app.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: create-jemo-app
+Version: 0.1.0
+Summary: A CLI tool to scaffold modern web projects with FastAPI, Django, Convex, Next.js, SvelteKit, or TanStack Start.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=14.3.2
+Requires-Dist: typer>=0.23.0
+
+# Jemo Admin CLI
+
+A powerful CLI tool to scaffold modern web projects with your favorite stack.
+
+## Supported Stacks
+
+**Backend:**
+- **FastAPI** (with Tortoise ORM & Aerich)
+- **Django**
+- **Convex** (Serverless)
+
+**Frontend:**
+- **Next.js**
+- **SvelteKit**
+- **TanStack Start**
+
+## Installation
+
+You can install `jemo-admin` using `pipx`:
+
+```bash
+pipx install .
+# Or from a git repo:
+# pipx install git+https://github.com/yourusername/create-jemo-app.git
+```
+
+## Usage
+
+Create a new project interactively:
+
+```bash
+jemo-admin create
+```
+
+Or specify the project name directly:
+
+```bash
+jemo-admin create my-awesome-app
+```
+
+Follow the interactive prompts to select your backend and frontend framework.
+
+## Requirements
+
+- **Python 3.12+**
+- **Bun** (for frontend package management)
+- **UV** (for Python package management)

create_jemo_app-0.1.0/src/create_jemo_app.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/create_jemo_app.egg-info/PKG-INFO
+src/create_jemo_app.egg-info/SOURCES.txt
+src/create_jemo_app.egg-info/dependency_links.txt
+src/create_jemo_app.egg-info/entry_points.txt
+src/create_jemo_app.egg-info/requires.txt
+src/create_jemo_app.egg-info/top_level.txt
+src/jemo_admin/main.py
+src/jemo_admin/generators/backend.py
+src/jemo_admin/generators/frontend.py
+src/jemo_admin/generators/vcs.py

create_jemo_app-0.1.0/src/create_jemo_app.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

create_jemo_app-0.1.0/src/create_jemo_app.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jemo-admin = jemo_admin.main:app

create_jemo_app-0.1.0/src/create_jemo_app.egg-info/requires.txt

@@ -0,0 +1,3 @@
+questionary>=2.1.1
+rich>=14.3.2
+typer>=0.23.0

create_jemo_app-0.1.0/src/create_jemo_app.egg-info/top_level.txt

@@ -0,0 +1 @@
+jemo_admin

create_jemo_app-0.1.0/src/jemo_admin/generators/backend.py

@@ -0,0 +1,163 @@
+from pathlib import Path
+import subprocess
+import shutil
+from rich.console import Console
+
+console = Console()
+
+
+def run_command(command, cwd=None, shell=False):
+    """Run a shell command."""
+    try:
+        # Capture output to show on error
+        subprocess.run(command, cwd=cwd, shell=shell, check=True, capture_output=False)
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Error executing command: {command}[/red]")
+        console.print(f"[red]Exit Code: {e.returncode}[/red]")
+        if e.stdout:
+            console.print(f"[red]Stdout: {e.stdout.decode()}[/red]")
+        if e.stderr:
+            console.print(f"[red]Stderr: {e.stderr.decode()}[/red]")
+        raise e
+
+
+def create_fastapi(project_dir: Path, separate_folders: bool = True):
+    """Scaffold a FastAPI project with Tortoise ORM and Aerich."""
+
+    backend_dir = project_dir / "backend"
+    if separate_folders:
+        backend_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        backend_dir = project_dir  # If not separate folders, use project dir directly (uncommon for backend+frontend combo)
+
+    console.print(
+        f"[bold cyan]Initializing FastAPI backend in {backend_dir}...[/bold cyan]"
+    )
+
+    # Initialize UV project
+    # Use --no-workspace to ensure we create a standalone project
+    run_command(["uv", "init", "--app", "--no-workspace"], cwd=backend_dir)
+
+    # Add dependencies
+    console.print(
+        "[bold]Adding dependencies: fastapi, uvicorn, tortoise-orm, aerich...[/bold]"
+    )
+    run_command(
+        ["uv", "add", "fastapi", "uvicorn", "tortoise-orm", "aerich"], cwd=backend_dir
+    )
+
+    # Create main.py
+    main_py_content = """
+from fastapi import FastAPI
+from tortoise import Tortoise
+from tortoise.contrib.fastapi import register_tortoise
+
+app = FastAPI(title="Jemo Admin API")
+
+@app.get("/")
+async def read_root():
+    return {"message": "Welcome to Jemo Admin FastAPI Backend with Tortoise ORM!"}
+
+# Database Configuration
+TORTOISE_ORM = {
+    "connections": {"default": "sqlite://db.sqlite3"},
+    "apps": {
+        "models": {
+            "models": ["aerich.models", "models"],  # Add your models here
+            "default_connection": "default",
+        },
+    },
+}
+
+register_tortoise(
+    app,
+    config=TORTOISE_ORM,
+    generate_schemas=True,
+    add_exception_handlers=True,
+)
+"""
+    (backend_dir / "main.py").write_text(main_py_content)
+
+    # Create models.py
+    models_py_content = """
+from tortoise import fields, models
+
+class User(models.Model):
+    id = fields.IntField(pk=True)
+    username = fields.CharField(max_length=50, unique=True)
+    email = fields.CharField(max_length=255, unique=True)
+    created_at = fields.DatetimeField(auto_now_add=True)
+
+    def __str__(self):
+        return self.username
+"""
+    (backend_dir / "models.py").write_text(models_py_content)
+
+    # Create tortoise_conf.py for Aerich
+    tortoise_conf_content = """
+TORTOISE_ORM = {
+    "connections": {"default": "sqlite://db.sqlite3"},
+    "apps": {
+        "models": {
+            "models": ["aerich.models", "models"],
+            "default_connection": "default",
+        },
+    },
+}
+"""
+    (backend_dir / "tortoise_conf.py").write_text(tortoise_conf_content)
+
+    console.print("[green]FastAPI backend setup complete![/green]")
+
+
+def create_django(project_dir: Path, separate_folders: bool = True):
+    """Scaffold a Django project."""
+
+    backend_dir = project_dir / "backend"
+    if separate_folders:
+        backend_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        backend_dir = project_dir
+
+    console.print(
+        f"[bold cyan]Initializing Django backend in {backend_dir}...[/bold cyan]"
+    )
+
+    # Initialize UV project
+    # Use --no-workspace to ensure we create a standalone project
+    run_command(["uv", "init", "--app", "--no-workspace"], cwd=backend_dir)
+
+    # Add Django
+    console.print("[bold]Adding dependencies: django...[/bold]")
+    run_command(["uv", "add", "django"], cwd=backend_dir)
+
+    # Create Django Project
+    # We use 'config' as the project name usually, or 'core'. Let's use 'config'.
+    console.print("[bold]Running django-admin startproject...[/bold]")
+    run_command(
+        ["uv", "run", "django-admin", "startproject", "config", "."], cwd=backend_dir
+    )
+
+    console.print("[green]Django backend setup complete![/green]")
+
+
+def create_convex_standalone(project_dir: Path):
+    """Initialize Convex in a standalone directory (rarely used without frontend)."""
+    console.print(f"[bold cyan]Initializing Convex in {project_dir}...[/bold cyan]")
+
+    project_dir.mkdir(parents=True, exist_ok=True)
+
+    # Check if npm/bun init is needed first
+    if not (project_dir / "package.json").exists():
+        run_command(["bun", "init", "-y"], cwd=project_dir)
+
+    run_command(["bun", "add", "convex"], cwd=project_dir)
+    run_command(
+        ["npx", "convex", "dev"], cwd=project_dir
+    )  # This is interactive usually!
+    # Wait, 'npx convex dev' is interactive and blocking. We probably shouldn't run it here.
+    # We should just install it and tell user to run it.
+
+    console.print(
+        "[green]Convex setup complete! Run 'npx convex dev' to start.[/green]"
+    )

create_jemo_app-0.1.0/src/jemo_admin/generators/frontend.py

@@ -0,0 +1,186 @@
+from pathlib import Path
+import subprocess
+import shutil
+from rich.console import Console
+
+console = Console()
+
+
+def run_command(command, cwd=None, capture_output=False):
+    """Run a shell command."""
+    try:
+        result = subprocess.run(
+            command, cwd=cwd, check=True, capture_output=capture_output, text=True
+        )
+        return result
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Error executing command: {' '.join(command)}[/red]")
+        if e.stderr:
+            console.print(f"[red]{e.stderr}[/red]")
+        raise e
+
+
+def add_dependency(package_manager, package, cwd, dev=False):
+    """Add a dependency."""
+    cmd = [package_manager, "add", "-d" if dev else "", package]
+    cmd = [c for c in cmd if c]
+    subprocess.run(cmd, cwd=cwd, check=True)
+
+
+def install_tailwind(project_dir: Path, framework: str):
+    """Install and configure Tailwind CSS."""
+    console.print(f"[bold]Setting up Tailwind CSS for {framework}...[/bold]")
+
+    if framework == "nextjs":
+        # Next.js with --yes already includes Tailwind by default
+        console.print(
+            "[green]Tailwind CSS already included with Next.js defaults[/green]"
+        )
+        return
+
+    # For other frameworks, install Tailwind v4 (zero config)
+    try:
+        # Install tailwindcss v4
+        run_command(
+            ["bun", "add", "-d", "tailwindcss"],
+            cwd=project_dir,
+        )
+
+        console.print("[green]Tailwind CSS v4 installed (zero config mode)[/green]")
+        console.print("[yellow]Note: Import Tailwind in your CSS file:[/yellow]")
+        console.print('  @import "tailwindcss";')
+    except Exception as e:
+        console.print(
+            f"[yellow]Warning: Could not auto-configure Tailwind. You may need to set it up manually.[/yellow]"
+        )
+
+
+def create_nextjs(
+    project_dir: Path, subfolder: str = "frontend", use_convex: bool = False
+):
+    """Scaffold a Next.js project with Tailwind CSS."""
+    target_dir = project_dir / subfolder if subfolder != "." else project_dir
+    console.print(f"[bold cyan]Initializing Next.js in {target_dir}...[/bold cyan]")
+
+    if not project_dir.exists():
+        project_dir.mkdir(parents=True)
+
+    # Use --yes for non-interactive mode with defaults (includes Tailwind)
+    cmd = ["bun", "create", "next-app", subfolder if subfolder != "." else ".", "--yes"]
+    try:
+        run_command(cmd, cwd=project_dir)
+    except Exception:
+        console.print("[red]Failed to create Next.js project[/red]")
+        return
+
+    if not target_dir.exists():
+        console.print(f"[red]Error: Directory {target_dir} was not created.[/red]")
+        return
+
+    # Tailwind is already included with --yes flag (default Next.js setup includes it)
+    console.print("[green]Next.js with Tailwind CSS created successfully![/green]")
+
+    if use_convex:
+        console.print("[bold]Adding Convex to Next.js...[/bold]")
+        add_dependency("bun", "convex", cwd=target_dir)
+        console.print(
+            "[yellow]Note: Run 'npx convex dev' in the frontend directory to configure Convex.[/yellow]"
+        )
+
+
+def create_sveltekit(
+    project_dir: Path, subfolder: str = "frontend", use_convex: bool = False
+):
+    """Scaffold a SvelteKit project with Tailwind CSS."""
+    target_dir = project_dir / subfolder if subfolder != "." else project_dir
+    console.print(f"[bold cyan]Initializing SvelteKit in {target_dir}...[/bold cyan]")
+
+    if not project_dir.exists():
+        project_dir.mkdir(parents=True)
+
+    # Use npx sv create with flags for non-interactive mode
+    folder_arg = subfolder if subfolder != "." else "."
+    cmd = [
+        "npx",
+        "sv",
+        "create",
+        folder_arg,
+        "--template",
+        "demo",  # Use demo template (includes more features)
+        "--types",
+        "ts",  # TypeScript
+        "--no-add-ons",  # Don't prompt for add-ons
+        "--install",
+        "bun",  # Use bun to install
+    ]
+
+    try:
+        run_command(cmd, cwd=project_dir)
+    except Exception:
+        console.print("[red]Failed to create SvelteKit project[/red]")
+        return
+
+    if not target_dir.exists():
+        console.print(
+            f"[red]Error: Directory {target_dir} was not created. Skipping subsequent steps.[/red]"
+        )
+        return
+
+    console.print("[bold]Installing dependencies...[/bold]")
+    run_command(["bun", "install"], cwd=target_dir)
+
+    # Add Tailwind CSS
+    install_tailwind(target_dir, "sveltekit")
+
+    if use_convex:
+        console.print("[bold]Adding Convex to SvelteKit...[/bold]")
+        add_dependency("bun", "convex", cwd=target_dir)
+        console.print(
+            "[yellow]Note: Run 'npx convex dev' in the frontend directory to configure Convex.[/yellow]"
+        )
+
+
+def create_tanstack(
+    project_dir: Path, subfolder: str = "frontend", use_convex: bool = False
+):
+    """Scaffold a TanStack Start project with Tailwind CSS."""
+    target_dir = project_dir / subfolder if subfolder != "." else project_dir
+    console.print(
+        f"[bold cyan]Initializing TanStack Start in {target_dir}...[/bold cyan]"
+    )
+
+    if not project_dir.exists():
+        project_dir.mkdir(parents=True)
+
+    # Use create subcommand (required for @tanstack/start v1)
+    folder_arg = subfolder if subfolder != "." else "."
+    cmd = [
+        "bun",
+        "create",
+        "@tanstack/start",
+        "create",  # Subcommand required
+        folder_arg,
+        "--package-manager",
+        "bun",
+        "--no-git",  # We'll handle git separately
+    ]
+
+    try:
+        run_command(cmd, cwd=project_dir)
+    except Exception:
+        console.print("[red]Failed to create TanStack Start project[/red]")
+        return
+
+    if not target_dir.exists():
+        console.print(f"[red]Error: Directory {target_dir} was not created.[/red]")
+        return
+
+    # Add Tailwind CSS
+    install_tailwind(target_dir, "tanstack")
+
+    if use_convex:
+        console.print("[bold]Adding Convex to TanStack Start...[/bold]")
+        add_dependency("bun", "convex", cwd=target_dir)
+        console.print(
+            "[yellow]Note: Run 'npx convex dev' in the frontend directory to configure Convex.[/yellow]"
+        )

create_jemo_app-0.1.0/src/jemo_admin/generators/vcs.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+import subprocess
+from rich.console import Console
+
+console = Console()
+
+
+def run_command(command, cwd=None):
+    """Run a shell command."""
+    try:
+        subprocess.run(command, cwd=cwd, check=True, stdout=subprocess.DEVNULL)
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]Error executing command: {' '.join(command)}[/red]")
+        # Don't raise, just warn for VCS
+        console.print(
+            f"[yellow]VCS initialization failed. You may need to install the tool or init manually.[/yellow]"
+        )
+
+
+def init_git(project_dir: Path):
+    """Initialize a Git repository."""
+    console.print(
+        f"[bold cyan]Initializing Git repository in {project_dir}...[/bold cyan]"
+    )
+    run_command(["git", "init"], cwd=project_dir)
+    # create .gitignore if it doesn't exist?
+    # Usually frameworks create their own .gitignores.
+    # We might want to stage files.
+    # run_command(["git", "add", "."], cwd=project_dir)
+    # console.print("[green]Git initialized.[/green]")
+
+
+def init_jj(project_dir: Path):
+    """Initialize a Jujutsu repository (git-backed)."""
+    console.print(
+        f"[bold cyan]Initializing Jujutsu (jj) repository in {project_dir}...[/bold cyan]"
+    )
+
+    # 'jj git init' creates a repo backed by git, which is most common for interop.
+    run_command(["jj", "git", "init"], cwd=project_dir)
+
+    console.print("[green]Jujutsu initialized.[/green]")

create_jemo_app-0.1.0/src/jemo_admin/main.py

@@ -0,0 +1,194 @@
+import typer
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from pathlib import Path
+import subprocess
+import shutil
+import sys
+import os
+
+app = typer.Typer(
+    help="CLI tool to scaffold modern web projects.", add_completion=False
+)
+console = Console()
+
+
+@app.callback()
+def main():
+    """
+    Jemo Admin CLI to scaffold modern web projects.
+    """
+    pass
+
+
+@app.command()
+def info():
+    """
+    Show information about the CLI.
+    """
+    console.print(Panel.fit("Jemo Admin CLI v0.1.0", border_style="cyan"))
+    console.print("Powered by [bold]Typer[/bold] and [bold]Rich[/bold].")
+
+
+@app.command()
+def create(
+    project_name: str = typer.Argument(
+        None, help="The name of the project directory (optional)."
+    ),
+):
+    """
+    Create a new project with your choice of backend and frontend.
+    """
+    console.print(
+        Panel.fit(
+            "Welcome to [bold cyan]jemo-admin[/bold cyan]! Let's build something great.",
+            border_style="cyan",
+        )
+    )
+
+    # 1. Project Name / Directory
+    if not project_name:
+        project_name = questionary.text(
+            "What is your project name?", default="my-jemo-app"
+        ).ask()
+
+    if not project_name:
+        console.print("[red]Project name is required![/red]")
+        raise typer.Exit(code=1)
+
+    # Resolve project directory
+    project_dir = Path.cwd() / project_name
+
+    if project_dir.exists() and any(project_dir.iterdir()):
+        overwrite = questionary.confirm(
+            f"Directory '{project_name}' is not empty. Do you want to continue (files may be overwritten)?"
+        ).ask()
+        if not overwrite:
+            console.print("[yellow]Aborted.[/yellow]")
+            raise typer.Exit(code=0)
+
+    # 2. Select Backend
+    backend_choice = questionary.select(
+        "Select your backend framework:",
+        choices=[
+            "FastAPI (Tortoise ORM + Aerich)",
+            "Django",
+            "Convex (Serverless)",
+            "None (Frontend Only)",
+        ],
+    ).ask()
+
+    # 3. Select Frontend
+    frontend_choice = questionary.select(
+        "Select your frontend framework:",
+        choices=["Next.js", "SvelteKit", "TanStack Start", "None (Backend Only)"],
+    ).ask()
+
+    # 4. Select Version Control
+    vcs_choice = questionary.select(
+        "Select your Version Control System:",
+        choices=["Git", "Jujutsu (jj)", "None"],
+    ).ask()
+
+    if not backend_choice or not frontend_choice or not vcs_choice:
+        # Handle cancellation (Ctrl+C)
+        console.print("[yellow]Operation cancelled.[/yellow]")
+        raise typer.Exit(code=0)
+
+    if "None" in backend_choice and "None" in frontend_choice:
+        console.print("[red]You must select at least a backend or a frontend![/red]")
+        raise typer.Exit(code=1)
+
+    # Confirm Plan
+    console.print(f"\n[bold green]Plan:[/bold green]")
+    console.print(f"  Project: [cyan]{project_name}[/cyan]")
+    console.print(f"  Backend: [cyan]{backend_choice}[/cyan]")
+    console.print(f"  Frontend: [cyan]{frontend_choice}[/cyan]")
+    console.print(f"  VCS:     [cyan]{vcs_choice}[/cyan]")
+
+    if not questionary.confirm("Does this look correct?").ask():
+        console.print("[yellow]Aborted.[/yellow]")
+        raise typer.Exit(code=0)
+
+    # Create Project Directory
+    if not project_dir.exists():
+        project_dir.mkdir(parents=True)
+
+    console.print("\n[bold]Scaffolding project...[/bold]")
+
+    # Import generators here to avoid circular imports or issues before structure is ready
+    from jemo_admin.generators import backend as backend_gen
+    from jemo_admin.generators import frontend as frontend_gen
+    from jemo_admin.generators import vcs as vcs_gen
+
+    # Determine types
+    is_convex = "Convex" in backend_choice
+    is_fastapi = "FastAPI" in backend_choice
+    is_django = "Django" in backend_choice
+
+    # Backend Generation
+    if is_fastapi:
+        backend_gen.create_fastapi(project_dir)
+    elif is_django:
+        backend_gen.create_django(project_dir)
+    elif is_convex and "None" in frontend_choice:
+        # Standalone Convex (rare but possible)
+        backend_gen.create_convex_standalone(project_dir)
+
+    # Frontend Generation
+    frontend_subfolder = "frontend" if (is_fastapi or is_django) else "."
+
+    if "Next.js" in frontend_choice:
+        frontend_gen.create_nextjs(
+            project_dir, subfolder=frontend_subfolder, use_convex=is_convex
+        )
+    elif "SvelteKit" in frontend_choice:
+        frontend_gen.create_sveltekit(
+            project_dir, subfolder=frontend_subfolder, use_convex=is_convex
+        )
+    elif "TanStack" in frontend_choice:
+        frontend_gen.create_tanstack(
+            project_dir, subfolder=frontend_subfolder, use_convex=is_convex
+        )
+
+    # VCS Initialization
+    if "Git" in vcs_choice:
+        vcs_gen.init_git(project_dir)
+    elif "Jujutsu" in vcs_choice:
+        vcs_gen.init_jj(project_dir)
+
+    console.print(f"\n[bold green]Successfully created {project_name}![/bold green]")
+    console.print("\n[bold]To get started:[/bold]")
+    console.print(f"  cd {project_name}")
+
+    if is_fastapi:
+        console.print("\n  [bold cyan]Backend (FastAPI):[/bold cyan]")
+        console.print("  cd backend")
+        console.print("  uv run aerich init -t tortoise_conf.TORTOISE_ORM")
+        console.print("  uv run aerich init-db")
+        console.print("  uv run uvicorn main:app --reload")
+    elif is_django:
+        console.print("\n  [bold cyan]Backend (Django):[/bold cyan]")
+        console.print("  cd backend")
+        console.print("  uv run python manage.py migrate")
+        console.print("  uv run python manage.py runserver")
+
+    if "None" not in frontend_choice:
+        console.print("\n  [bold cyan]Frontend:[/bold cyan]")
+        if is_fastapi or is_django:
+            console.print("  cd ../frontend")
+        # If single folder (Convex/None backend), we are already in root (or just cd into it initially)
+
+        console.print("  bun install")
+        if is_convex:
+            console.print("  npx convex dev")
+        console.print("  bun dev")
+
+
+if __name__ == "__main__":
+    try:
+        app()
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Operation cancelled by user.[/yellow]")
+        sys.exit(0)