feat(cli): add interactive extension multiselect

packages/create-awesome-python-app/src/create_awesome_python_app/catalog.py

@@ -39,6 +39,18 @@ class TemplateChoice:
  search: str
 
 
+@dataclass(frozen=True)
+class ExtensionChoice:
+ """Interactive extension choice grouped by catalog category."""
+
+ title: str
+ value: str
+ search: str
+ category_slug: str
+ category_name: str
+ category_order: int
+
+
 class CatalogResolutionError(ValueError):
  """Raised when a template or extension slug is not in the catalog."""
 
@@ -113,6 +125,32 @@ def _search_text(template: dict[str, Any], category_name: str) -> str:
  return " ".join(str(token) for token in tokens if token).lower()
 
 
+def _catalog_category_order(data: dict[str, Any]) -> dict[str, int]:
+ return {
+ str(category.get("slug", "")): index
+ for index, category in enumerate(data.get("categories", []))
+ }
+
+
+def _entry_type_values(entry: dict[str, Any]) -> list[str]:
+ raw_type = entry.get("type", [])
+ if isinstance(raw_type, str):
+ return [raw_type]
+ if isinstance(raw_type, list):
+ return [str(item) for item in raw_type]
+ return []
+
+
+def find_template_by_url(
+ data: dict[str, Any], template_url: str
+) -> dict[str, Any] | None:
+ """Return the catalog template entry for a resolved template URL."""
+ for template in data.get("templates", []):
+ if isinstance(template, dict) and template.get("url") == template_url:
+ return template
+ return None
+
+
 def build_template_choices(data: dict[str, Any]) -> list[TemplateChoice]:
  """Build CNA-style searchable template choices for interactive mode."""
  categories = _category_map(data)
@@ -165,6 +203,67 @@ def build_template_choices(data: dict[str, Any]) -> list[TemplateChoice]:
  return choices
 
 
+def build_extension_choices(
+ data: dict[str, Any], template_url: str
+) -> list[ExtensionChoice]:
+ """Build CNA-style extension choices compatible with the selected template."""
+ categories = _category_map(data)
+ category_order = _catalog_category_order(data)
+ template = find_template_by_url(data, template_url)
+ template_types = _entry_type_values(template or {})
+ if not template_types:
+ template_types = ["custom"]
+
+ choices: list[ExtensionChoice] = []
+ for extension in data.get("extensions", data.get("addons", [])):
+ if not isinstance(extension, dict):
+ continue
+ extension_types = _entry_type_values(extension)
+ if not any(
+ ext_type in template_types or ext_type == "all"
+ for ext_type in extension_types
+ ):
+ continue
+ extension_url = str(extension.get("url", ""))
+ if not extension_url:
+ continue
+ category_slug = str(extension.get("category", "custom"))
+ category_name = categories.get(category_slug, category_slug)
+ labels = extension.get("labels", [])
+ label_suffix = ""
+ if isinstance(labels, list) and labels:
+ label_suffix = " · " + ", ".join(str(label) for label in labels[:3])
+ description = str(extension.get("description", "")).strip()
+ description_suffix = f" — {description}" if description else ""
+ slug = str(extension.get("slug", ""))
+ title = f"{extension.get('name', slug)} ({slug}){label_suffix}"
+ choices.append(
+ ExtensionChoice(
+ title=f"{title}{description_suffix}",
+ value=extension_url,
+ search=_search_text(extension, category_name),
+ category_slug=category_slug,
+ category_name=category_name,
+ category_order=category_order.get(category_slug, len(category_order)),
+ )
+ )
+
+ return sorted(
+ choices,
+ key=lambda choice: (choice.category_order, choice.title.lower()),
+ )
+
+
+def group_extension_choices(
+ choices: list[ExtensionChoice],
+) -> dict[str, list[ExtensionChoice]]:
+ """Group extension choices by category while preserving sorted order."""
+ grouped: dict[str, list[ExtensionChoice]] = {}
+ for choice in choices:
+ grouped.setdefault(choice.category_slug, []).append(choice)
+ return grouped
+
+
 DEFAULT_CATALOG_URL = "https://raw.githubusercontent.com/Create-Python-App/cpa-templates/main/templates.json"
 CACHE_TTL_SECONDS = 3600
 FETCH_TIMEOUT_SECONDS = 10

packages/create-awesome-python-app/src/create_awesome_python_app/cli.py

@@ -104,6 +104,7 @@ def scaffold(
  pass # passed to core
 
  want_interactive = interactive if interactive is not None else (not _in_ci())
+ interactive_catalog: dict[str, object] | None = None
  if want_interactive and not template:
  try:
  import questionary
@@ -114,8 +115,8 @@ def scaffold(
  get_catalog_data,
  )
 
-catalog = get_catalog_data()
- template_choices = build_template_choices(catalog)
+interactive_catalog = get_catalog_data()
+ template_choices = build_template_choices(interactive_catalog)
  choice_by_title = {
  choice.title: choice.value for choice in template_choices
  }
@@ -158,6 +159,58 @@ def scaffold(
  console.print(f"[red]{err}[/red]")
  raise typer.Exit(2) from err
 
+ if want_interactive and not addons:
+ try:
+ import questionary
+ from questionary import Choice
+
+ from create_awesome_python_app.catalog import (
+ build_extension_choices,
+ get_catalog_data,
+ group_extension_choices,
+ )
+
+ interactive_catalog = interactive_catalog or get_catalog_data()
+ extension_choices = build_extension_choices(interactive_catalog, template)
+ grouped_extensions = group_extension_choices(extension_choices)
+ if grouped_extensions:
+ category_choices = [
+ Choice(
+ title=(
+ f"{choices[0].category_name} "
+ f"({len(choices)} extension"
+ f"{'s' if len(choices) != 1 else ''})"
+ ),
+ value=category_slug,
+ )
+ for category_slug, choices in grouped_extensions.items()
+ ]
+ selected_categories = questionary.checkbox(
+ "Which kinds of extensions do you need?",
+ choices=category_choices,
+ qmark="?",
+ pointer=">",
+ ).ask()
+ selected_addons: list[str] = []
+ for category_slug in selected_categories or []:
+ choices = grouped_extensions.get(str(category_slug), [])
+ if not choices:
+ continue
+ picked = questionary.checkbox(
+ f"{choices[0].category_name} extensions",
+ choices=[
+ Choice(title=choice.title, value=choice.value)
+ for choice in choices
+ ],
+ qmark="?",
+ pointer=">",
+ ).ask()
+ selected_addons.extend(str(item) for item in picked or [])
+ addons = selected_addons
+ except ImportError:
+ console.print("[red]questionary not available[/red]")
+ raise typer.Exit(1) from None
+
  if pin and "://" in template and "ref=" not in template:
  sep = "&" if "?" in template else "?"
  template = f"{template}{sep}ref={pin}"

packages/create-awesome-python-app/tests/test_catalog_resolve.py

@@ -6,7 +6,9 @@
 from create_awesome_python_app.catalog import (
  CUSTOM_TEMPLATE_SENTINEL,
  CatalogResolutionError,
+ build_extension_choices,
  build_template_choices,
+ group_extension_choices,
  is_url_like,
  resolve_catalog_spec,
  resolve_catalog_specs,
@@ -101,3 +103,96 @@ def test_build_template_choices_are_searchable() -> None:
  assert "backend" in first.search
  assert "uv" in first.search
  assert choices[-1].value == CUSTOM_TEMPLATE_SENTINEL
+
+
+def test_build_extension_choices_filters_by_template_type() -> None:
+ catalog = {
+ "categories": [
+ {"slug": "ci", "name": "CI"},
+ {"slug": "data", "name": "Data"},
+ ],
+ "templates": [
+ {
+ "slug": "fastapi-starter",
+ "name": "FastAPI Starter",
+ "url": "file:///templates/fastapi",
+ "type": "fastapi-backend",
+ "category": "backend-applications",
+ }
+ ],
+ "extensions": [
+ {
+ "slug": "github-setup",
+ "name": "GitHub Setup",
+ "description": "Actions and Dependabot",
+ "url": "file:///extensions/github",
+ "type": ["fastapi-backend"],
+ "category": "ci",
+ "labels": ["GitHub", "CI"],
+ },
+ {
+ "slug": "all-projects",
+ "name": "All Projects",
+ "url": "file:///extensions/all",
+ "type": ["all"],
+ "category": "data",
+ },
+ {
+ "slug": "django-only",
+ "name": "Django Only",
+ "url": "file:///extensions/django",
+ "type": ["django"],
+ "category": "ci",
+ },
+ ],
+ }
+
+ choices = build_extension_choices(catalog, "file:///templates/fastapi")
+
+ assert [choice.value for choice in choices] == [
+ "file:///extensions/github",
+ "file:///extensions/all",
+ ]
+ assert "dependabot" in choices[0].search
+ assert "github" in choices[0].title.lower()
+
+
+def test_group_extension_choices_preserves_category_order() -> None:
+ catalog = {
+ "categories": [
+ {"slug": "ci", "name": "CI"},
+ {"slug": "data", "name": "Data"},
+ ],
+ "templates": [
+ {
+ "slug": "fastapi-starter",
+ "name": "FastAPI Starter",
+ "url": "file:///templates/fastapi",
+ "type": "fastapi-backend",
+ "category": "backend-applications",
+ }
+ ],
+ "extensions": [
+ {
+ "slug": "postgres",
+ "name": "Postgres",
+ "url": "file:///extensions/postgres",
+ "type": ["fastapi-backend"],
+ "category": "data",
+ },
+ {
+ "slug": "github",
+ "name": "GitHub",
+ "url": "file:///extensions/github",
+ "type": ["fastapi-backend"],
+ "category": "ci",
+ },
+ ],
+ }
+
+ grouped = group_extension_choices(
+ build_extension_choices(catalog, "file:///templates/fastapi")
+ )
+
+ assert list(grouped) == ["ci", "data"]
+ assert grouped["ci"][0].value == "file:///extensions/github"

packages/create-awesome-python-app/tests/test_interactive.py

@@ -1,6 +1,11 @@
+import json
 import os
+from pathlib import Path
 
-from create_awesome_python_app.cli import _in_ci
+from create_awesome_python_app.cli import _in_ci, app
+from typer.testing import CliRunner
+
+runner = CliRunner()
 
 
 def test_in_ci_env(monkeypatch) -> None:
@@ -9,3 +14,81 @@ def test_in_ci_env(monkeypatch) -> None:
  monkeypatch.delenv("CI", raising=False)
  # may still be true in this environment; function checks CI only
  os.environ.pop("CI", None)
+
+
+def test_interactive_extension_selection_passes_addon_urls(
+ tmp_path: Path, monkeypatch
+) -> None:
+ catalog = {
+ "categories": [{"slug": "tooling", "name": "Tooling"}],
+ "templates": [
+ {
+ "slug": "fastapi-starter",
+ "name": "FastAPI Starter",
+ "url": "file:///templates/fastapi",
+ "type": "fastapi-backend",
+ "category": "backend-applications",
+ }
+ ],
+ "extensions": [
+ {
+ "slug": "github-setup",
+ "name": "GitHub Setup",
+ "url": "file:///extensions/github",
+ "type": ["fastapi-backend"],
+ "category": "tooling",
+ }
+ ],
+ }
+ catalog_file = tmp_path / "templates.json"
+ catalog_file.write_text(json.dumps(catalog), encoding="utf-8")
+ monkeypatch.setenv("CPA_CATALOG_URL", f"file://{catalog_file}")
+ monkeypatch.setenv("CPA_NO_CATALOG_CACHE", "1")
+
+ answers = [["tooling"], ["file:///extensions/github"]]
+
+ class FakePrompt:
+ def __init__(self, answer):
+ self.answer = answer
+
+ def ask(self):
+ return self.answer
+
+ def fake_checkbox(*_args, **_kwargs):
+ return FakePrompt(answers.pop(0))
+
+ captured: dict[str, object] = {}
+
+ async def fake_create_python_app(project_directory, options, *_args, **_kwargs):
+ captured["project_directory"] = project_directory
+ captured["options"] = options
+
+ async def fake_check_for_latest_version(_package_name):
+ return None
+
+ monkeypatch.setattr("questionary.checkbox", fake_checkbox)
+ monkeypatch.setattr(
+ "create_awesome_python_app.cli.create_python_app",
+ fake_create_python_app,
+ )
+ monkeypatch.setattr(
+ "create_awesome_python_app.cli.check_for_latest_version",
+ fake_check_for_latest_version,
+ )
+
+ result = runner.invoke(
+ app,
+ [
+ "--template",
+ "fastapi-starter",
+ "--interactive",
+ "--no-install",
+ "api",
+ ],
+ )
+
+ assert result.exit_code == 0, result.stdout + result.stderr
+ assert captured["project_directory"] == "api"
+ options = captured["options"]
+ assert isinstance(options, dict)
+ assert options["addons"] == ["file:///extensions/github"]