stup 0.1.0__py3-none-any.whl

app/__init__.py

@@ -0,0 +1,3 @@
+"""stup — Scaffold production-ready project structures in seconds."""
+
+__version__ = "0.1.0"

app/cli.py

@@ -0,0 +1,173 @@
+"""stup CLI — Main entry point."""
+
+import typer
+from rich.console import Console
+
+from app import __version__
+from app.commands import (
+    activate,
+    add,
+    api,
+    cli_cmd,
+    django_cmd,
+    docs,
+    lang_agent,
+    mean,
+    mern,
+    ml,
+    next_django,
+    notebook,
+    openai_agent,
+    react_fastapi,
+    saas,
+    scraper,
+    test_cmd,
+    uv,
+)
+
+console = Console()
+
+app = typer.Typer(
+    name="stup",
+    help="Scaffold production-ready project structures in seconds.",
+    add_completion=False,
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"[bold cyan]stup[/bold cyan] v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", "-v", help="Show version and exit.", callback=_version_callback, is_eager=True
+    ),
+) -> None:
+    """stup — Install once, scaffold forever."""
+
+
+# ── Foundation commands ──────────────────────────────────────────────
+
+@app.command()
+def uv_cmd() -> None:
+    """[bold cyan]Foundation[/bold cyan] · Bootstrap a complete uv Python project."""
+    uv.run_command()
+
+
+# Register as "uv" not "uv-cmd"
+uv_cmd.__name__ = "uv"  # type: ignore[attr-defined]
+uv_cmd = app.registered_commands[-1]
+uv_cmd.name = "uv"
+
+
+@app.command(name="activate")
+def activate_cmd() -> None:
+    """[bold cyan]Foundation[/bold cyan] · Smart cross-platform venv activator."""
+    activate.run_command()
+
+
+@app.command(name="add")
+def add_cmd(packages: list[str]) -> None:
+    """[bold cyan]Foundation[/bold cyan] · Add packages and sync requirements.txt."""
+    add.run_command(packages)
+
+
+# ── Template commands ────────────────────────────────────────────────
+
+@app.command(name="react-fastapi")
+def react_fastapi_cmd() -> None:
+    """[bold magenta]Full-stack[/bold magenta] · React + FastAPI with Docker Compose & CORS."""
+    react_fastapi.run_command()
+
+
+@app.command(name="notebook")
+def notebook_cmd() -> None:
+    """[bold green]Data Science[/bold green] · Jupyter notebooks with uv-managed deps."""
+    notebook.run_command()
+
+
+@app.command(name="mern")
+def mern_cmd() -> None:
+    """[bold magenta]Full-stack[/bold magenta] · MongoDB + Express + React + Node."""
+    mern.run_command()
+
+
+@app.command(name="mean")
+def mean_cmd() -> None:
+    """[bold magenta]Full-stack[/bold magenta] · MongoDB + Express + Angular + Node."""
+    mean.run_command()
+
+
+@app.command(name="django")
+def django_cmd_fn() -> None:
+    """[bold blue]Backend[/bold blue] · Django + DRF + Celery + Redis + PostgreSQL."""
+    django_cmd.run_command()
+
+
+@app.command(name="next-django")
+def next_django_cmd() -> None:
+    """[bold magenta]Full-stack[/bold magenta] · Next.js 14 + Django REST + JWT auth."""
+    next_django.run_command()
+
+
+@app.command(name="ml")
+def ml_cmd() -> None:
+    """[bold green]Data Science[/bold green] · ML project with experiment tracking & MLflow."""
+    ml.run_command()
+
+
+@app.command(name="lang-agent")
+def lang_agent_cmd() -> None:
+    """[bold yellow]AI[/bold yellow] · LangGraph agent with tool stubs & Ollama config."""
+    lang_agent.run_command()
+
+
+@app.command(name="openai-agent")
+def openai_agent_cmd() -> None:
+    """[bold yellow]AI[/bold yellow] · Modern OpenAI agent with function calling."""
+    openai_agent.run_command()
+
+
+@app.command(name="scraper")
+def scraper_cmd() -> None:
+    """[bold yellow]Automation[/bold yellow] · Playwright + BeautifulSoup scraping pipeline."""
+    scraper.run_command()
+
+
+@app.command(name="cli")
+def cli_cmd_fn() -> None:
+    """[bold blue]Package[/bold blue] · PyPI-ready CLI package with Typer + Rich."""
+    cli_cmd.run_command()
+
+
+@app.command(name="api")
+def api_cmd() -> None:
+    """[bold blue]Backend[/bold blue] · Minimal FastAPI microservice with auth middleware."""
+    api.run_command()
+
+
+@app.command(name="saas")
+def saas_cmd() -> None:
+    """[bold magenta]Full-stack[/bold magenta] · Full SaaS boilerplate with Stripe & Docker."""
+    saas.run_command()
+
+
+@app.command(name="docs")
+def docs_cmd() -> None:
+    """[bold dim]Addon[/bold dim] · Add MkDocs + Material theme to any project."""
+    docs.run_command()
+
+
+@app.command(name="test")
+def test_cmd_fn() -> None:
+    """[bold dim]Addon[/bold dim] · Scaffold a full pytest suite with coverage."""
+    test_cmd.run_command()
+
+
+if __name__ == "__main__":
+    app()

app/commands/__init__.py

@@ -0,0 +1 @@
+"""stup.commands — All CLI command implementations."""

app/commands/activate.py

@@ -0,0 +1,33 @@
+"""stup activate — Smart cross-platform venv activator."""
+
+from app.utils import (
+    console,
+    ensure_venv_exists,
+    get_activate_command,
+    is_windows,
+    print_banner,
+)
+
+
+def run_command() -> None:
+    """Print the correct venv activation command for the current platform."""
+    print_banner("activate", "Smart cross-platform venv activator")
+
+    ensure_venv_exists()
+
+    cmd = get_activate_command()
+
+    console.print()
+    if is_windows():
+        console.print("  [yellow]→[/yellow] Run this in PowerShell:")
+        console.print(f"    [bold white]{cmd}[/bold white]")
+        console.print()
+        console.print("  [dim]Or in CMD:[/dim]")
+        console.print(r"    [dim].venv\Scripts\activate.bat[/dim]")
+    else:
+        console.print("  [yellow]→[/yellow] Run this in your terminal:")
+        console.print(f"    [bold white]{cmd}[/bold white]")
+        console.print()
+        console.print("  [dim]Or use eval:[/dim]")
+        console.print("    [dim]eval $(stup activate)[/dim]")
+    console.print()

app/commands/add.py

@@ -0,0 +1,35 @@
+"""stup add — Thin wrapper over uv add that maintains requirements.txt."""
+
+import typer
+from app.utils import (
+    check_uv,
+    ensure_venv_exists,
+    print_banner,
+    print_done,
+    run,
+)
+
+def run_command(packages: list[str]) -> None:
+    """Add packages using uv and update requirements.txt."""
+    print_banner("add", f"Adding packages: {', '.join(packages)}")
+
+    check_uv()
+    ensure_venv_exists()
+
+    # Add packages
+    pkg_str = " ".join(packages)
+    run(f"uv add {pkg_str}")
+
+    # Update requirements.txt for compatibility (clean format)
+    run("uv export --format requirements-txt --no-hashes --no-emit-project --output-file requirements.txt --quiet")
+
+    # Post-process to remove all 'via' comments for a super clean look
+    req_file = "requirements.txt"
+    with open(req_file, "r") as f:
+        lines = f.readlines()
+    with open(req_file, "w") as f:
+        for line in lines:
+            if not line.strip().startswith("#"):
+                f.write(line)
+
+    print_done()

app/commands/api.py

@@ -0,0 +1,178 @@
+"""stup api — Minimal FastAPI microservice scaffold."""
+
+from app.utils import (
+    check_uv,
+    create_dirs,
+    ensure_venv_exists,
+    print_banner,
+    print_done,
+    run,
+    write_file,
+)
+
+# ── Templates ────────────────────────────────────────────────────────
+
+MAIN_PY = '''\
+"""FastAPI microservice entry point."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from routers import health, v1
+from middleware.auth import AuthMiddleware
+
+app = FastAPI(
+    title="My API",
+    version="0.1.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Custom auth middleware (optional — uncomment to enable)
+# app.add_middleware(AuthMiddleware)
+
+# Routers
+app.include_router(health.router, prefix="/health", tags=["Health"])
+app.include_router(v1.router, prefix="/api/v1", tags=["v1"])
+
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the API. Visit /docs for documentation."}
+'''
+
+HEALTH_ROUTER = '''\
+"""Health check router."""
+
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/")
+async def health_check():
+    return {"status": "ok"}
+
+
+@router.get("/ready")
+async def readiness():
+    return {"status": "ready"}
+'''
+
+V1_ROUTER = '''\
+"""API v1 router."""
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class Item(BaseModel):
+    name: str
+    description: str = ""
+    price: float
+
+
+# In-memory store (replace with database)
+items: list[Item] = []
+
+
+@router.get("/items")
+async def list_items():
+    return {"items": items}
+
+
+@router.post("/items")
+async def create_item(item: Item):
+    items.append(item)
+    return {"message": "Item created", "item": item}
+
+
+@router.get("/items/{item_id}")
+async def get_item(item_id: int):
+    if 0 <= item_id < len(items):
+        return {"item": items[item_id]}
+    return {"error": "Item not found"}
+'''
+
+MODELS_INIT = '''\
+"""Pydantic models / schemas."""
+
+from pydantic import BaseModel
+
+
+class HealthResponse(BaseModel):
+    status: str
+
+
+class ErrorResponse(BaseModel):
+    detail: str
+'''
+
+AUTH_MIDDLEWARE = '''\
+"""Authentication middleware stub."""
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+
+class AuthMiddleware(BaseHTTPMiddleware):
+    """Simple API key authentication middleware.
+
+    TODO: Replace with your preferred auth strategy (JWT, OAuth, etc.)
+    """
+
+    SKIP_PATHS = {"/", "/docs", "/redoc", "/openapi.json", "/health", "/health/ready"}
+
+    async def dispatch(self, request: Request, call_next):
+        if request.url.path in self.SKIP_PATHS:
+            return await call_next(request)
+
+        api_key = request.headers.get("X-API-Key")
+        if not api_key:
+            return JSONResponse(
+                status_code=401,
+                content={"detail": "Missing X-API-Key header"},
+            )
+
+        # TODO: Validate api_key against your store
+        # if not is_valid_key(api_key):
+        #     return JSONResponse(status_code=403, content={"detail": "Invalid API key"})
+
+        return await call_next(request)
+'''
+
+
+def run_command() -> None:
+    """Scaffold a minimal FastAPI microservice."""
+    print_banner("api", "Minimal FastAPI microservice with auth middleware")
+
+    check_uv()
+    ensure_venv_exists()
+
+    # Install dependencies
+    run("uv add fastapi uvicorn pydantic")
+
+    # Create directory structure
+    create_dirs("routers/v1", "routers/health", "models", "middleware")
+
+    # Create files
+    write_file("main.py", MAIN_PY)
+    write_file("routers/__init__.py", "")
+    write_file("routers/health/__init__.py", HEALTH_ROUTER)
+    write_file("routers/v1/__init__.py", V1_ROUTER)
+    write_file("models/__init__.py", MODELS_INIT)
+    write_file("middleware/__init__.py", "")
+    write_file("middleware/auth.py", AUTH_MIDDLEWARE)
+
+    print_done()

app/commands/cli_cmd.py

@@ -0,0 +1,137 @@
+"""stup cli — PyPI-ready CLI package with Typer + Rich."""
+
+import os
+
+from app.utils import (
+    check_uv,
+    create_dirs,
+    ensure_venv_exists,
+    print_banner,
+    print_done,
+    run,
+    write_file,
+)
+
+# ── Templates ────────────────────────────────────────────────────────
+
+
+def _get_templates(project_name: str) -> dict[str, str]:
+    """Return template files with project name substituted."""
+    return {
+        "init": f'''\
+"""{project_name} — A CLI tool built with Typer + Rich."""
+
+__version__ = "0.1.0"
+''',
+        "main": f'''\
+"""Entry point for {project_name} CLI."""
+
+import typer
+from rich.console import Console
+from {project_name} import __version__
+from {project_name}.commands import hello
+
+console = Console()
+
+app = typer.Typer(
+    name="{project_name}",
+    help="🚀 {project_name} CLI",
+    add_completion=False,
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"[bold cyan]{project_name}[/bold cyan] v{{__version__}}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False, "--version", "-v", help="Show version.", callback=_version_callback, is_eager=True
+    ),
+) -> None:
+    pass
+
+
+@app.command()
+def greet(name: str = typer.Argument("World", help="Name to greet.")) -> None:
+    """Say hello to someone."""
+    hello.greet(name)
+
+
+if __name__ == "__main__":
+    app()
+''',
+        "hello": '''\
+"""Hello command implementation."""
+
+from rich.console import Console
+
+console = Console()
+
+
+def greet(name: str) -> None:
+    """Print a greeting."""
+    console.print(f"[bold green]Hello, {name}![/bold green] 👋")
+''',
+        "commands_init": '''\
+"""CLI commands package."""
+''',
+    }
+
+
+def run_command() -> None:
+    """Scaffold a PyPI-ready CLI package."""
+    print_banner("cli", "PyPI-ready CLI package with Typer + Rich")
+
+    check_uv()
+    ensure_venv_exists()
+
+    # Use current directory name as project name
+    project_name = os.path.basename(os.getcwd()).replace("-", "_").replace(" ", "_").lower()
+
+    # Install CLI dependencies
+    run("uv add typer rich")
+
+    templates = _get_templates(project_name)
+
+    # Create package structure
+    create_dirs(f"src/{project_name}/commands")
+
+    write_file(f"src/{project_name}/__init__.py", templates["init"])
+    write_file(f"src/{project_name}/__main__.py", templates["main"])
+    write_file(f"src/{project_name}/commands/__init__.py", templates["commands_init"])
+    write_file(f"src/{project_name}/commands/hello.py", templates["hello"])
+
+    # Create README
+    readme = f"""\
+# {project_name}
+
+A CLI tool built with [Typer](https://typer.tiangolo.com/) + [Rich](https://rich.readthedocs.io/).
+
+## Installation
+
+```bash
+pip install {project_name}
+```
+
+## Usage
+
+```bash
+{project_name} --help
+{project_name} greet "World"
+```
+
+## Development
+
+```bash
+uv pip install -e .
+```
+"""
+    write_file("README.md", readme)
+
+    print_done()