actual fixes this time

Author: igorbenav

.github/workflows/type-checking.yml

@@ -26,7 +26,7 @@ jobs:
           SECRET_KEY: test-secret-key-for-testing-only
 
       - name: Mypy (cli)
-        run: cd cli && uv run --no-sync mypy --no-namespace-packages src/cli
+        run: cd cli && uv run --no-sync mypy -p cli
         env:
           ENVIRONMENT: local
           SECRET_KEY: test-secret-key-for-testing-only

.gitignore

@@ -14,8 +14,8 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
-lib64/
+/lib/
+/lib64/
 parts/
 sdist/
 var/

backend/pyproject.toml

@@ -42,8 +42,7 @@ dev = [
     "pytest-asyncio>=0.25.3",
     "pytest-mock>=3.14.0",
     "types-python-jose>=3.4.0.20250224",
-    "testcontainers>=4.10.0",
-    "testcontainers-postgres>=0.0.1rc1",
+    "testcontainers[postgres]>=4.10.0",
     "pytest-xdist[psutil]>=3.8.0",
 ]
 

cli/src/cli/lib/__init__.py

@@ -0,0 +1,70 @@
+"""Locate the user's project on disk and read context from it.
+
+The CLI is shipped inside ``backend/src/cli`` of the boilerplate, but
+when invoked it operates on whichever directory the user is in. These
+helpers resolve the repo root, the backend directory, and read values
+from the project's ``.env`` files without importing the application.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ProjectContext:
+    """Resolved paths the CLI needs to operate on the user's repo."""
+
+    repo_root: Path
+    backend_dir: Path
+
+    @property
+    def env_file(self) -> Path:
+        return self.backend_dir / ".env"
+
+    @property
+    def env_example(self) -> Path:
+        return self.backend_dir / ".env.example"
+
+    @property
+    def compose_file(self) -> Path:
+        return self.repo_root / "docker-compose.yml"
+
+
+def discover_project(start: Path | None = None) -> ProjectContext:
+    """Walk up from ``start`` looking for a ``backend/pyproject.toml`` marker.
+
+    Falls back to the current working directory if no marker is found —
+    the caller is responsible for deciding whether that's acceptable.
+    """
+    current = (start or Path.cwd()).resolve()
+    for candidate in [current, *current.parents]:
+        if (candidate / "backend" / "pyproject.toml").is_file():
+            return ProjectContext(repo_root=candidate, backend_dir=candidate / "backend")
+        if (candidate / "pyproject.toml").is_file() and candidate.name == "backend":
+            return ProjectContext(repo_root=candidate.parent, backend_dir=candidate)
+    return ProjectContext(repo_root=current, backend_dir=current / "backend")
+
+
+def read_env_value(env_path: Path, key: str) -> str | None:
+    """Read a single value from a ``.env``-style file.
+
+    Returns ``None`` if the file is missing or the key isn't set. Quotes
+    around the value (single or double) are stripped. Lines beginning
+    with ``#`` are skipped.
+    """
+    if not env_path.is_file():
+        return None
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        name, _, value = line.partition("=")
+        if name.strip() != key:
+            continue
+        value = value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+            value = value[1:-1]
+        return value
+    return None

cli/src/cli/lib/project.py

@@ -0,0 +1,32 @@
+"""Consistent prompt helpers used across the CLI.
+
+Centralizes ``--yes`` (assume-yes) and ``--quiet`` handling so individual
+commands don't each invent their own.
+"""
+
+from __future__ import annotations
+
+import typer
+
+
+def confirm_overwrite(path: str, *, assume_yes: bool) -> bool:
+    """Confirm overwriting an existing file. Returns True to proceed."""
+    if assume_yes:
+        return True
+    return typer.confirm(f"{path} already exists. Overwrite?", default=False)
+
+
+def info(message: str) -> None:
+    typer.echo(message)
+
+
+def success(message: str) -> None:
+    typer.secho(message, fg=typer.colors.GREEN)
+
+
+def warn(message: str) -> None:
+    typer.secho(message, fg=typer.colors.YELLOW)
+
+
+def error(message: str) -> None:
+    typer.secho(message, fg=typer.colors.RED, err=True)

cli/src/cli/lib/prompts.py

@@ -0,0 +1,33 @@
+"""Jinja-based template rendering for in-tree features and plugins.
+
+A feature points at a directory containing Jinja templates. ``Renderer``
+loads them with a sandboxed environment, applies the supplied context,
+and writes the result to disk.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+
+class Renderer:
+    """Render Jinja templates from a feature's templates directory."""
+
+    def __init__(self, templates_root: Path) -> None:
+        if not templates_root.is_dir():
+            raise FileNotFoundError(f"Templates directory does not exist: {templates_root}")
+        self.templates_root = templates_root
+        self.env = Environment(
+            loader=FileSystemLoader(str(templates_root)),
+            keep_trailing_newline=True,
+            undefined=StrictUndefined,
+            autoescape=False,
+        )
+
+    def render(self, template_path: str, context: dict[str, Any]) -> str:
+        """Render ``template_path`` (relative to ``templates_root``) with ``context``."""
+        template = self.env.get_template(template_path)
+        return template.render(**context)