dirigent-cli 0.9.4__tar.gz → 0.10.0__tar.gz

{dirigent_cli-0.9.4 → dirigent_cli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirigent-cli
-Version: 0.9.4
+Version: 0.10.0
 Summary: The dirigent command line interface (dirigent / dg).
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
@@ -14,6 +14,7 @@ Requires-Dist: httpx2>=2.12.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=15.0.0
+Requires-Dist: textual>=8.0
 Requires-Dist: tomli-w>=1.2.0
 Requires-Dist: typer>=0.27.2
 Requires-Dist: uvicorn>=0.52.4

{dirigent_cli-0.9.4 → dirigent_cli-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-cli"
-version = "0.9.4"
+version = "0.10.0"
 description = "The dirigent command line interface (dirigent / dg)."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,6 +17,7 @@ dependencies = [
     "python-dotenv>=1.1.0",
     "pyyaml>=6.0.3",
     "rich>=15.0.0",
+    "textual>=8.0",
     "tomli-w>=1.2.0",
     "typer>=0.27.2",
     "uvicorn>=0.52.4",

{dirigent_cli-0.9.4 → dirigent_cli-0.10.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-cli"
-version = "0.9.4"
+version = "0.10.0"
 description = "The dirigent command line interface (dirigent / dg)."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -17,6 +17,7 @@ dependencies = [
     "python-dotenv>=1.1.0",
     "pyyaml>=6.0.3",
     "rich>=15.0.0",
+    "textual>=8.0",
     "tomli-w>=1.2.0",
     "typer>=0.27.2",
     "uvicorn>=0.52.4",

{dirigent_cli-0.9.4 → dirigent_cli-0.10.0}/src/dirigent_cli/commands.py

@@ -57,9 +57,9 @@ from dirigent_cli.output import (
 )
 from dirigent_cli.params import ParamError, build_params
 from dirigent_cli.project import (
-    COMPOSE_TEMPLATE_NAME,
+    InitChoices,
     ProjectError,
-    check_template,
+    check_choices,
     find_project,
     scaffold,
     write_token_env,
@@ -479,22 +479,32 @@ def _trigger_targets(dg: Session, wanted: set[str]) -> dict[str, TriggerTarget]:
 def init_command(
     ctx: typer.Context,
     directory: Annotated[Path, typer.Argument(help="Where to create the instance and project.")] = Path(),
-    template: Annotated[str, typer.Option(help="Which template to scaffold: basic, ci or compose.")] = "basic",
-    documents_only: Annotated[
-        bool,
-        typer.Option("--documents-only", help="Scaffold the documents and initialise no instance."),
+    template: Annotated[
+        str | None,
+        typer.Option(help="Where it runs: local (dg dev on SQLite), compose (a container stack) or documents."),
+    ] = None,
+    service: Annotated[
+        list[str] | None,
+        typer.Option("--service", help="A service the stack carries: s3, docker, kafka or rabbitmq. Repeatable."),
+    ] = None,
+    workflow: Annotated[
+        bool, typer.Option("--workflow", help="Write a GitHub workflow that applies on merge.")
     ] = False,
+    pack: Annotated[
+        list[str] | None, typer.Option("--pack", help="A pack to add, such as dirigent-dhis2. Repeatable.")
+    ] = None,
     admin: Annotated[str, typer.Option(help="The first admin account's username.")] = "admin",
-    password: Annotated[str | None, typer.Option(help="Its password; prompted for when omitted.")] = None,
+    password: Annotated[str | None, typer.Option(help="Its password; asked for when omitted.")] = None,
 ) -> None:
     """Initialise a uv project and the instance it addresses, ready for `dg dev`.
 
-    Writes the documents and a `pyproject.toml` pinning the running dirigent, so `uv sync`
-    builds the project's environment and `uv run dg` is the runtime it was scaffolded on.
-    Then creates the state directory, migrates the schema, creates the first admin and mints
-    it a token. `--documents-only` stops after the documents. `--template compose` writes the
-    documents and a container stack instead, and initialises nothing locally: the instance is
-    the containers.
+    At a terminal, with no --template, one form asks everything: where the project runs, the
+    stack's services, packs, and the first admin. The flags answer the same questions for a
+    script. `--template local` writes the documents and a `pyproject.toml` pinning the running
+    dirigent, then creates the state directory, migrates the schema, creates the first admin
+    and mints it a token, kept in `.env`. `--template compose` writes the documents and a
+    container stack instead, and initialises nothing locally: the instance is the containers.
+    `--template documents` writes the documents alone, against an instance somebody else runs.
     """
     import asyncio
 
@@ -505,34 +515,55 @@ def init_command(
     if not state.chosen:
         configure(output="console")
     root = directory.resolve()
-    # Refusing and asking both happen before anything is written, so a run that cannot
-    # finish has not half-created a project, and nobody is asked for a password to satisfy
-    # a command that was going to fail anyway.
-    try:
-        check_template(template)
-    except ProjectError as error:
-        _init_fail(str(error))
-    stack = template == COMPOSE_TEMPLATE_NAME
-    if stack and documents_only:
-        _init_fail("--documents-only does not apply to the compose template, which writes no instance to skip")
-    if stack and admin != "admin":
-        _init_fail("--admin does not apply to the compose template; the stack's first admin is named admin")
-    if not documents_only and not stack:
+    version = cli_version()
+    unasked = template is None and service is None and pack is None and not workflow
+    asked = unasked and sys.stdin.isatty() and sys.stdout.isatty()
+    # Refusing happens before anything is written or asked for, so a run that cannot finish
+    # has not half-created a project, and nobody fills a form for a command that was going
+    # to fail anyway.
+    if template in (None, "local"):
         _refuse_an_existing_instance(root)
-    secret = (
-        ""
-        if documents_only
-        else (password or os.environ.get(BOOTSTRAP_PASSWORD_ENV) or _prompt_for_a_password(stack=stack))
-    )
-    if not documents_only and len(secret) < MIN_PASSWORD_LENGTH:
+    if asked:
+        from dirigent_cli.init_form import run_form
+
+        chosen = run_form(
+            root, version=version, admin=admin, password=password or os.environ.get(BOOTSTRAP_PASSWORD_ENV, "")
+        )
+        if chosen is None:
+            _init_fail("cancelled; nothing was written")
+        choices = chosen
+    else:
+        choices = InitChoices(
+            template=template or "local",
+            services=tuple(service) if service is not None else InitChoices().services,
+            workflow=workflow,
+            packs=tuple(pack or ()),
+            admin=admin,
+            password=password or os.environ.get(BOOTSTRAP_PASSWORD_ENV) or "",
+        )
+        try:
+            check_choices(choices)
+        except ProjectError as error:
+            _init_fail(str(error))
+        if choices.stack and admin != "admin":
+            _init_fail("--admin does not apply to the compose template; the stack's first admin is named admin")
+        if choices.template != "documents" and not choices.password:
+            choices = choices.model_copy(update={"password": _prompt_for_a_password(stack=choices.stack)})
+    if choices.template != "documents" and len(choices.password) < MIN_PASSWORD_LENGTH:
         _init_fail(str(WeakPassword()))
-    version = cli_version()
     try:
-        made = scaffold(directory, template=template, version=version, password=secret)
+        made = scaffold(directory, choices, version=version)
     except ProjectError as error:
         _init_fail(str(error))
     left = [_within(path, directory) for path in made.skipped]
-    if documents_only or stack:
+    described = {
+        "template": choices.template,
+        "version": version,
+        **({"services": list(choices.services)} if choices.stack else {}),
+        **({"workflow": True} if choices.workflow else {}),
+        **({"packs": list(choices.packs)} if choices.packs else {}),
+    }
+    if not choices.instance:
         starting = [
             "uv sync",
             "docker compose up -d",
@@ -541,30 +572,28 @@ def init_command(
         emit_fact(
             "project.scaffolded",
             message="scaffolded",
-            template=template,
             directory=str(directory),
-            version=version,
             files=[_within(path, directory) for path in made.files],
+            **described,
             **({"skipped": left} if left else {}),
-            **({"next": starting} if stack else {}),
+            **({"next": starting} if choices.stack else {}),
         )
         return
     settings = instance_settings(root)
     migrated = migrations.head_revision(settings) or "none"
     migrations.upgrade("head", settings)
-    token = asyncio.run(first_admin(settings, admin, secret))
+    token = asyncio.run(first_admin(settings, choices.admin, choices.password))
     env_file = write_token_env(root, token)
     emit_fact(
         "instance.initialised",
         message="initialised",
-        template=template,
         directory=str(root),
         state=STATE_DIR,
         schema=migrated,
-        admin=admin,
+        admin=choices.admin,
         token=token,
-        version=version,
         files=[_within(path, root) for path in [*made.files, env_file]],
+        **described,
         **({"skipped": [_within(path, root) for path in made.skipped]} if made.skipped else {}),
     )
 
@@ -586,14 +615,19 @@ def instance_settings(root: Path) -> Settings:
     )
 
 
-def _init_fail(message: str, *, problems: Sequence[str] = ()) -> NoReturn:
-    """Refuse an init: a record where records were asked for, plain sentences otherwise."""
+def _init_fail(message: str, *, ways: Sequence[tuple[str, str]] = ()) -> NoReturn:
+    """Refuse an init: a record where records were asked for, plain sentences otherwise.
+
+    Each way out is a command and what it does; the record carries them as one sentence
+    each, and the rendering sets the commands in a column of their own.
+    """
     if json_mode():
-        refuse(message, problems=problems)
+        refuse(message, problems=[f"{command} {what}" for command, what in ways])
     else:
-        error_console.print(message, highlight=False, markup=False)
-        for problem in problems:
-            error_console.print(f"  {problem}", highlight=False, markup=False)
+        error_console.print(f"[red]{escape(message)}[/]", highlight=False)
+        width = max((len(command) for command, _ in ways), default=0)
+        for command, what in ways:
+            error_console.print(f"  [bold]{escape(command).ljust(width)}[/]  [dim]{escape(what)}[/]", highlight=False)
     raise typer.Exit(code=1)
 
 
@@ -606,11 +640,11 @@ def _refuse_an_existing_instance(root: Path) -> None:
     existing = instance_settings(root).sqlite_path
     if existing is not None and existing.exists():
         _init_fail(
-            f"{existing} already exists, so this directory holds an instance already",
-            problems=[
-                "dg dev starts it",
-                "dg db upgrade brings its schema forward",
-                "dg init --documents-only scaffolds documents beside it",
+            f"this directory holds an instance already: {existing}",
+            ways=[
+                ("dg dev", "starts it"),
+                ("dg db upgrade", "brings its schema forward"),
+                ("dg init --template documents", "scaffolds documents beside it"),
             ],
         )
 

dirigent_cli-0.10.0/src/dirigent_cli/init_form.py

@@ -0,0 +1,253 @@
+"""The ``dg init`` form: one Textual screen instead of a run of flags and prompts.
+
+Everything is visible at once and revised before anything is written: where the project
+runs, which services the stack carries, which packs come along, and the first admin. The
+form returns the choices and the caller scaffolds, so quitting leaves no half-made project.
+Nothing here touches the disk.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import cast
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.theme import Theme
+from textual.widgets import Button, Checkbox, Input, Label, RadioButton, RadioSet, SelectionList
+
+from dirigent_cli.project import (
+    DEFAULT_SERVICES,
+    PACKS,
+    SERVICE_EXAMPLES,
+    SERVICES,
+    InitChoices,
+)
+
+MIN_PASSWORD_LENGTH = 8
+
+#: The web UI's dark palette, so the form is the same product as the screen behind the door:
+#: the amber accent on the near-black ground, with the same surfaces, inks and status colours.
+DIRIGENT_THEME = Theme(
+    name="dirigent",
+    primary="#e9b452",
+    secondary="#00a7e2",
+    accent="#e9b452",
+    foreground="#eaeff5",
+    background="#070a0f",
+    surface="#10151c",
+    panel="#191f26",
+    success="#5cb85c",
+    warning="#f9b64f",
+    error="#ed5350",
+    dark=True,
+    variables={
+        "input-cursor-background": "#e9b452",
+        "input-cursor-foreground": "#0a0e12",
+        "input-selection-background": "#e9b45240",
+        "block-cursor-background": "#e9b452",
+        "block-cursor-foreground": "#0a0e12",
+        "border": "#323941",
+        "border-blurred": "#191f26",
+        "footer-background": "#10151c",
+        "button-color-foreground": "#0a0e12",
+    },
+)
+
+#: The three places a project runs, in the order the form lists them.
+KINDS = (
+    ("local", "Local: one process on SQLite", "dg dev; one person, one machine"),
+    ("compose", "A container stack", "compose: PostgreSQL, workers, the published image"),
+    ("documents", "Documents only", "against an instance somebody else runs"),
+)
+
+
+class InitForm(App[InitChoices | None]):
+    """The scaffolding form: kind, services, packs, workflow, admin, on one screen."""
+
+    TITLE = "dg init"
+
+    CSS = """
+    Screen { padding: 1 2; }
+    #body { height: 1fr; }
+    Label { width: 1fr; }
+    .section { color: $text-muted; margin-top: 1; }
+    .hint { color: $text-muted; }
+    SelectionList > .selection-list--button { color: $surface; background: $surface; }
+    SelectionList > .selection-list--button-selected { color: $success; background: $surface; }
+    SelectionList > .selection-list--button-highlighted { color: $surface; background: $surface; }
+    SelectionList > .selection-list--button-selected-highlighted { color: $success; background: $surface; }
+    Checkbox > .toggle--button { color: $surface; background: $surface; }
+    Checkbox.-on > .toggle--button { color: $success; background: $surface; }
+    #kind { height: auto; }
+    #services, #packs { height: auto; border: round $border; }
+    #admin-block { height: auto; }
+    #admin-row { height: auto; }
+    #admin-row Input { width: 1fr; margin-right: 2; }
+    #problem { color: $error; height: auto; }
+    #files { color: $text-muted; height: auto; margin-top: 1; }
+    #actions { height: auto; margin-top: 1; }
+    #actions Button { margin-right: 2; }
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+        Binding("ctrl+s", "create", "Create", show=True, priority=True),
+    ]
+
+    def __init__(self, directory: Path, *, version: str, admin: str = "admin", password: str = "") -> None:
+        """Open on a directory, the runtime it will pin, and whatever the flags already said."""
+        super().__init__()
+        self.register_theme(DIRIGENT_THEME)
+        self.theme = "dirigent"
+        self._directory = directory
+        self._version = version
+        self._admin = admin
+        self._password = password
+
+    def compose(self) -> ComposeResult:
+        """Lay the whole form out on one screen."""
+        yield Label(f"New dirigent project: {self._directory.name}")
+        yield Label(
+            f"The documents, the runtime it pins ({self._version}) and its instance, all in this directory.",
+            classes="hint",
+        )
+        with VerticalScroll(id="body"):
+            yield Label("Where it runs", classes="section")
+            with RadioSet(id="kind"):
+                for index, (code, title, what) in enumerate(KINDS):
+                    yield RadioButton(f"{title}  [dim]{what}[/]", value=index == 0, id=f"kind-{code}")
+
+            yield Label("Services in the stack  (space toggles)", classes="section", id="services-label")
+            yield SelectionList[str](
+                *(
+                    (f"{service.title}  [dim]{service.what}[/]", service.code, service.code in DEFAULT_SERVICES)
+                    for service in SERVICES
+                ),
+                id="services",
+            )
+
+            yield Label("Packs  (space toggles; pinned at this version)", classes="section")
+            yield SelectionList[str](*((f"{pack.name}  [dim]{pack.what}[/]", pack.name) for pack in PACKS), id="packs")
+
+            yield Checkbox("A GitHub workflow that applies the project on merge", id="workflow")
+
+            with Vertical(id="admin-block"):
+                yield Label("First admin", classes="section")
+                with Horizontal(id="admin-row"):
+                    yield Input(value=self._admin, placeholder="username", id="admin")
+                    yield Input(value=self._password, placeholder="password", password=True, id="password")
+                    yield Input(value=self._password, placeholder="confirm", password=True, id="confirm")
+                yield Label(f"At least {MIN_PASSWORD_LENGTH} characters, typed twice.", classes="hint")
+
+            yield Label("", id="problem")
+            yield Label("", id="files")
+        with Horizontal(id="actions"):
+            yield Button("Create project", variant="primary", id="create")
+            yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        """Open on the kind, and say what the defaults will write."""
+        self.query_one("#kind", RadioSet).focus()
+        self._follow_kind()
+
+    @property
+    def kind(self) -> str:
+        """The place the project runs, as the radio set has it."""
+        pressed = self.query_one("#kind", RadioSet).pressed_button
+        return pressed.id.removeprefix("kind-") if pressed is not None and pressed.id else "local"
+
+    def _follow_kind(self) -> None:
+        """Show the services for the stack alone, and the admin for the two kinds that make one."""
+        kind = self.kind
+        stack = kind == "compose"
+        self.query_one("#services-label").display = stack
+        self.query_one("#services").display = stack
+        self.query_one("#admin-block").display = kind != "documents"
+        self._refresh_files()
+
+    def on_radio_set_changed(self, _event: RadioSet.Changed) -> None:
+        """A kind decides which sections apply."""
+        self._follow_kind()
+
+    def on_selection_list_selected_changed(self, _event: SelectionList.SelectedChanged[str]) -> None:
+        """A toggle changes what is written."""
+        self._refresh_files()
+
+    def on_checkbox_changed(self, _event: Checkbox.Changed) -> None:
+        """The workflow box changes what is written."""
+        self._refresh_files()
+
+    def _collect(self) -> InitChoices:
+        """Read the form into choices, as they stand."""
+        # query_one's type argument is a runtime isinstance check, so it cannot take a
+        # subscripted generic: the widgets are fetched untyped and narrowed here.
+        services = cast("SelectionList[str]", self.query_one("#services"))
+        packs = cast("SelectionList[str]", self.query_one("#packs"))
+        picked_services: list[str] = list(services.selected)
+        picked_packs: list[str] = list(packs.selected)
+        kind = self.kind
+        chosen_services = tuple(code for code in (s.code for s in SERVICES) if code in picked_services)
+        return InitChoices(
+            template=kind,
+            services=chosen_services if kind == "compose" else DEFAULT_SERVICES,
+            workflow=self.query_one("#workflow", Checkbox).value,
+            packs=tuple(name for name in (p.name for p in PACKS) if name in picked_packs),
+            admin=self.query_one("#admin", Input).value.strip() or "admin",
+            password=self.query_one("#password", Input).value,
+        )
+
+    def _refresh_files(self) -> None:
+        """Say what Create will write, so the file list after the fact is not the first sight of it."""
+        choices = self._collect()
+        files = [
+            "dirigent.yaml",
+            "pipelines/hello-world.yaml",
+            ".dirigent/profiles.yaml",
+            "pyproject.toml",
+            "README.md",
+        ]
+        if choices.stack:
+            files += [f"pipelines/{SERVICE_EXAMPLES[code][0]}" for code in choices.services]
+            files += ["compose.yaml", "Dockerfile", ".env"]
+        elif choices.instance:
+            files += [".env", ".dirigent/state/"]
+        if choices.workflow:
+            files.append(".github/workflows/dirigent.yml")
+        self.query_one("#files", Label).update("Will write: " + ", ".join(files))
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """The two buttons are the two bindings."""
+        if event.button.id == "create":
+            self.action_create()
+        else:
+            self.action_cancel()
+
+    def action_cancel(self) -> None:
+        """Leave with nothing, so nothing is written."""
+        self.exit(None)
+
+    def action_create(self) -> None:
+        """Refuse an admin the instance could not be made with, else hand the choices back."""
+        choices = self._collect()
+        problem = self.query_one("#problem", Label)
+        if choices.template != "documents":
+            confirm = self.query_one("#confirm", Input).value
+            if choices.stack and choices.admin != "admin":
+                problem.update("The stack's first admin is named admin.")
+                return
+            if len(choices.password) < MIN_PASSWORD_LENGTH:
+                problem.update(f"A password must be at least {MIN_PASSWORD_LENGTH} characters.")
+                self.query_one("#password", Input).focus()
+                return
+            if confirm != choices.password:
+                problem.update("The two passwords differ.")
+                self.query_one("#confirm", Input).focus()
+                return
+        self.exit(choices)
+
+
+def run_form(directory: Path, *, version: str, admin: str = "admin", password: str = "") -> InitChoices | None:
+    """Run the form, returning the choices, or None when the person quit."""
+    return InitForm(directory, version=version, admin=admin, password=password).run()