jemo-admin 0.1.4__tar.gz

jemo_admin-0.1.4/.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+  id-token: write  # Required for trusted publishing
+
+jobs:
+  release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/jemo-admin
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        run: uv publish
+
+      - name: Get version from tag
+        id: get_version
+        run: echo "VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          name: Release ${{ steps.get_version.outputs.VERSION }}
+          draft: false
+          prerelease: false
+          files: |
+            dist/*.whl
+            dist/*.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

jemo_admin-0.1.4/.github/workflows/store.yml

@@ -0,0 +1,28 @@
+name : put on pypi
+on : 
+ push : 
+   branches : 
+     - main
+jobs:
+  publish:
+    name: Build and publish to PyPI
+    runs-on: ubuntu-latest
+    # Required for Trusted Publishing
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish package
+        run: uv publish --token ${{ secrets.PYPI_TOKEN }} 

jemo_admin-0.1.4/.gitignore

@@ -0,0 +1 @@
+.env 

jemo_admin-0.1.4/.python-version

@@ -0,0 +1 @@
+3.12

jemo_admin-0.1.4/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: jemo-admin
+Version: 0.1.4
+Summary: A CLI tool to scaffold modern web projects with FastAPI, Django, Convex, Next.js, SvelteKit, or TanStack Start.
+Project-URL: Homepage, https://github.com/jemo/jemo-admin
+Project-URL: Repository, https://github.com/jemo/jemo-admin
+Project-URL: Issues, https://github.com/jemo/jemo-admin/issues
+Requires-Python: >=3.12
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=14.3.2
+Requires-Dist: typer>=0.23.0
+Description-Content-Type: text/markdown
+
+# 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/Jemo69/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)
+Note : it does not work on Windows.

jemo_admin-0.1.4/README.md

@@ -0,0 +1,48 @@
+# 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/Jemo69/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)
+Note : it does not work on Windows.

jemo_admin-0.1.4/build/lib/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]"
+    )

jemo_admin-0.1.4/build/lib/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]"
+        )

jemo_admin-0.1.4/build/lib/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]")