minitest-cli 0.36.0__tar.gz → 0.37.1__tar.gz

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/.env.example

@@ -16,6 +16,12 @@ MINITEST_API_URL=https://testing-service.dev.minitap.ai
 # Development
 MINITEST_APPS_MANAGER_URL=https://apps-manager.dev.minitap.ai
 
+# —— Conductor (minitest draft) ——
+# Production
+# MINITEST_CONDUCTOR_URL=https://conductor.app.minitap.ai
+# Development
+MINITEST_CONDUCTOR_URL=https://conductor.dev.minitap.ai
+
 # —— Integrations ——
 # Production
 # MINITEST_INTEGRATIONS_URL=https://integrations.minitap.ai

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: minitest-cli
-Version: 0.36.0
+Version: 0.37.1
 Summary: Minitest CLI – command-line interface for the Minitest testing platform
 Project-URL: Homepage, https://minitap.ai/
 Project-URL: Source, https://github.com/minitap-ai/minitest-cli
@@ -131,6 +131,29 @@ targets, or Edge. V1 supports one form factor per OS per run; run phone and
 tablet suites separately. Tablet results are labelled `iOS · Tablet` or
 `Android · Tablet`; phone labels stay unchanged.
 
+## Physical devices
+
+By default builds run on virtual devices (iOS Simulator, Android emulator). If
+physical devices are enabled for your workspace, upload a device build with
+`--physical` and select the physical lane when you start the run:
+
+```bash
+# iOS: an Ad Hoc or Development .ipa signed for Minitap's iPhones
+BUILD_ID=$(minitest --json --app <app-id> build upload ./MyApp.ipa --physical | jq -r .id)
+minitest --app <app-id> run all --ios-build "$BUILD_ID" --ios-physical
+
+# Android: the same works with --android-physical
+minitest --app <app-id> run start --tag smoke --android-build <android-build-id> --android-physical
+```
+
+- `build upload --physical` checks the build for physical devices instead of
+  virtual ones. A Simulator build is rejected (`ios.simulator_only_ipa`), and a
+  device build uploaded without `--physical` is rejected with a hint to add it.
+- `--ios-physical` / `--android-physical` need the matching `--ios-build` /
+  `--android-build`, and can't be combined with `--*-device-type`.
+- If physical devices aren't enabled for your workspace, the run is refused
+  with a message saying so.
+
 An iPhone-only build may run on iPad in compatibility mode; the server warns
 that the run does not establish native tablet-layout coverage. Unknown
 device-family metadata produces a different warning with the same coverage
@@ -145,6 +168,7 @@ app defaults.
 | `MINITEST_APP_ID`             | Default app ID                                             | No (can use `--app` flag)          |
 | `MINITEST_API_URL`            | testing-service base URL                                   | No (defaults to production)        |
 | `MINITEST_APPS_MANAGER_URL`   | apps-manager base URL (used by `minitest apps create`)     | No (defaults to production)        |
+| `MINITEST_CONDUCTOR_URL`      | Conductor base URL (used by `minitest draft`)              | No (defaults to production)        |
 | `MINITEST_INTEGRATIONS_URL`   | minihands-integrations base URL (used to list tenants)     | No (defaults to production)        |
 | `MINITEST_WEBAPP_URL`         | Minitest webapp base URL (used for review links)            | No (defaults to production)        |
 | `MINITEST_SUPABASE_URL`       | Supabase project URL used for OAuth login                  | No (defaults to production)        |
@@ -169,7 +193,8 @@ app defaults.
 | `minitest apps`  | List, inspect, and create apps; residential proxy and private network settings |
 | `minitest scenario` | Create, update, list and delete scenarios |
 | `minitest scenario-binding` | Bind test accounts, test files or app skills to scenarios |
-| `minitest draft` | Drafts — branches of the test suite |
+| `minitest draft` | Ask Mini for a suite change, follow it, check and merge it (drafts in the webapp) |
+| `minitest df` | Low-level suite branches Mini writes (draft features) |
 | `minitest test-profile` | Test profiles (Test accounts in the webapp) |
 | `minitest tags`  | List, create, update and delete scenario tags |
 | `minitest app-skill` | App skills (Skills in the webapp): procedures Mini loads to arrange test state |
@@ -190,7 +215,7 @@ stderr and leave `--json` stdout unchanged. Switch to the new names.
 | `minitest user-story` | `minitest scenario` |
 | `minitest user-story-binding` | `minitest scenario-binding` |
 | `minitest scenario-binding set-skills` | `minitest scenario-binding set-app-skills` |
-| `minitest df` | `minitest draft` |
+| `minitest draft show/apply/delete` (v0.34–v0.36) | `minitest df show/apply/delete` |
 | `minitest flow-types` | `minitest tags` |
 | `run from-commit --user-story` / `-u` | `run from-commit --scenario` / `-s` |
 | `batch list --user-story-id` | `batch list --scenario` |

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/README.md

@@ -98,6 +98,29 @@ targets, or Edge. V1 supports one form factor per OS per run; run phone and
 tablet suites separately. Tablet results are labelled `iOS · Tablet` or
 `Android · Tablet`; phone labels stay unchanged.
 
+## Physical devices
+
+By default builds run on virtual devices (iOS Simulator, Android emulator). If
+physical devices are enabled for your workspace, upload a device build with
+`--physical` and select the physical lane when you start the run:
+
+```bash
+# iOS: an Ad Hoc or Development .ipa signed for Minitap's iPhones
+BUILD_ID=$(minitest --json --app <app-id> build upload ./MyApp.ipa --physical | jq -r .id)
+minitest --app <app-id> run all --ios-build "$BUILD_ID" --ios-physical
+
+# Android: the same works with --android-physical
+minitest --app <app-id> run start --tag smoke --android-build <android-build-id> --android-physical
+```
+
+- `build upload --physical` checks the build for physical devices instead of
+  virtual ones. A Simulator build is rejected (`ios.simulator_only_ipa`), and a
+  device build uploaded without `--physical` is rejected with a hint to add it.
+- `--ios-physical` / `--android-physical` need the matching `--ios-build` /
+  `--android-build`, and can't be combined with `--*-device-type`.
+- If physical devices aren't enabled for your workspace, the run is refused
+  with a message saying so.
+
 An iPhone-only build may run on iPad in compatibility mode; the server warns
 that the run does not establish native tablet-layout coverage. Unknown
 device-family metadata produces a different warning with the same coverage
@@ -112,6 +135,7 @@ app defaults.
 | `MINITEST_APP_ID`             | Default app ID                                             | No (can use `--app` flag)          |
 | `MINITEST_API_URL`            | testing-service base URL                                   | No (defaults to production)        |
 | `MINITEST_APPS_MANAGER_URL`   | apps-manager base URL (used by `minitest apps create`)     | No (defaults to production)        |
+| `MINITEST_CONDUCTOR_URL`      | Conductor base URL (used by `minitest draft`)              | No (defaults to production)        |
 | `MINITEST_INTEGRATIONS_URL`   | minihands-integrations base URL (used to list tenants)     | No (defaults to production)        |
 | `MINITEST_WEBAPP_URL`         | Minitest webapp base URL (used for review links)            | No (defaults to production)        |
 | `MINITEST_SUPABASE_URL`       | Supabase project URL used for OAuth login                  | No (defaults to production)        |
@@ -136,7 +160,8 @@ app defaults.
 | `minitest apps`  | List, inspect, and create apps; residential proxy and private network settings |
 | `minitest scenario` | Create, update, list and delete scenarios |
 | `minitest scenario-binding` | Bind test accounts, test files or app skills to scenarios |
-| `minitest draft` | Drafts — branches of the test suite |
+| `minitest draft` | Ask Mini for a suite change, follow it, check and merge it (drafts in the webapp) |
+| `minitest df` | Low-level suite branches Mini writes (draft features) |
 | `minitest test-profile` | Test profiles (Test accounts in the webapp) |
 | `minitest tags`  | List, create, update and delete scenario tags |
 | `minitest app-skill` | App skills (Skills in the webapp): procedures Mini loads to arrange test state |
@@ -157,7 +182,7 @@ stderr and leave `--json` stdout unchanged. Switch to the new names.
 | `minitest user-story` | `minitest scenario` |
 | `minitest user-story-binding` | `minitest scenario-binding` |
 | `minitest scenario-binding set-skills` | `minitest scenario-binding set-app-skills` |
-| `minitest df` | `minitest draft` |
+| `minitest draft show/apply/delete` (v0.34–v0.36) | `minitest df show/apply/delete` |
 | `minitest flow-types` | `minitest tags` |
 | `run from-commit --user-story` / `-u` | `run from-commit --scenario` / `-s` |
 | `batch list --user-story-id` | `batch list --scenario` |

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "minitest-cli"
-version = "0.36.0"
+version = "0.37.1"
 description = "Minitest CLI – command-line interface for the Minitest testing platform"
 readme = "README.md"
 license = "MIT"
@@ -128,6 +128,9 @@ python_functions = [
 python_classes = [
     "Test*"
 ]
+markers = [
+    "real_app_lookup: resolve --app names through the API instead of the test shortcut",
+]
 addopts = [
     "-v",
     "--tb=short",

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/src/minitest_cli/api/client.py

@@ -39,9 +39,16 @@ class ApiClient:
             response = await client.get("/api/v1/apps")
     """
 
-    def __init__(self, settings: Settings, *, token_override: str | None = None) -> None:
+    def __init__(
+        self,
+        settings: Settings,
+        *,
+        token_override: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
         self._settings = settings
         self._token_override = token_override
+        self._base_url = base_url or settings.api_url
         self._client: httpx.AsyncClient | None = None
 
     async def __aenter__(self) -> "ApiClient":
@@ -53,7 +60,7 @@ class ApiClient:
         if self._settings.cause is not None:
             headers[CAUSE_HEADER] = self._settings.cause
         self._client = httpx.AsyncClient(
-            base_url=self._settings.api_url,
+            base_url=self._base_url,
             headers=headers,
             auth=_BearerAuth(self._settings, self._token_override),
             timeout=DEFAULT_TIMEOUT,

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/_response_errors.py

@@ -24,6 +24,11 @@ BUILD_INVALID_ERROR_CODE = "build_invalid"
 # rollout: both).
 _SPLIT_APKS_BACKEND_UNSUPPORTED_MARKER = "not yet supported on this execution backend"
 
+# Rejection codes that mean "right build, wrong kind of device": the hint
+# points at the upload flag that matches the build.
+_DEVICE_BUILD_CODES = {"ios.device_only_ipa", "ios.device_only_sdk", "ios.no_simulator_slice"}
+_SIMULATOR_BUILD_CODES = {"ios.simulator_only_ipa"}
+
 # Generic FastAPI ``loc`` prefixes that add noise to a field path (they're
 # implied by "this is a validation error" and repeat across every field).
 _LOC_PREFIXES_TO_DROP = {"body", "query", "path"}
@@ -86,14 +91,16 @@ def extract_detail(resp: httpx.Response) -> str:
         return resp.text
 
 
-def handle_response_error(resp: httpx.Response, *, resource: str = "Build") -> None:
+def handle_response_error(
+    resp: httpx.Response, *, resource: str = "Build", physical: bool = False
+) -> None:
     """Check response status; exit with proper code on errors."""
     if resp.status_code == 404:
         print_error(f"{resource} not found: {extract_detail(resp)}")
         raise typer.Exit(code=EXIT_NOT_FOUND)
     if resp.status_code == 422 and _try_handle_split_apks_backend_unsupported(resp):
         raise typer.Exit(code=EXIT_BUILD_INVALID)
-    if resp.status_code == 422 and _try_handle_build_invalid(resp):
+    if resp.status_code == 422 and _try_handle_build_invalid(resp, physical=physical):
         raise typer.Exit(code=EXIT_BUILD_INVALID)
     if resp.status_code >= 400:
         print_error(f"API error ({resp.status_code}): {extract_detail(resp)}")
@@ -122,7 +129,7 @@ def _try_handle_split_apks_backend_unsupported(resp: httpx.Response) -> bool:
     return True
 
 
-def _try_handle_build_invalid(resp: httpx.Response) -> bool:
+def _try_handle_build_invalid(resp: httpx.Response, *, physical: bool = False) -> bool:
     """If response is a build-invalid error, render issues and return True."""
     try:
         body = resp.json()
@@ -130,17 +137,32 @@ def _try_handle_build_invalid(resp: httpx.Response) -> bool:
         return False
     if not isinstance(body, dict) or body.get("error_code") != BUILD_INVALID_ERROR_CODE:
         return False
-    issues = body.get("issues") or []
-    print_error("Build rejected: failed validation for virtual-device execution.")
+    issues = [issue for issue in body.get("issues") or [] if isinstance(issue, dict)]
+    devices = "physical-device" if physical else "virtual-device"
+    print_error(f"Build rejected: failed validation for {devices} execution.")
     for issue in issues:
-        if not isinstance(issue, dict):
-            continue
         code = issue.get("code", "unknown")
         message = issue.get("message", "")
         err_console.print(f"  [red]✖[/red] {code}: {message}")
+    _print_device_kind_hint({str(issue.get("code")) for issue in issues}, physical=physical)
     return True
 
 
+def _print_device_kind_hint(codes: set[str], *, physical: bool) -> None:
+    if not physical and codes & _DEVICE_BUILD_CODES:
+        err_console.print(
+            "  [yellow]Hint:[/yellow] this is a device build. To run it on physical iPhones,"
+            " upload it with [bold]minitest build upload <file> --physical[/bold];"
+            " for virtual devices, build for the iOS Simulator instead."
+        )
+    elif physical and codes & _SIMULATOR_BUILD_CODES:
+        err_console.print(
+            "  [yellow]Hint:[/yellow] this is a Simulator build. Upload it without"
+            " [bold]--physical[/bold] to run it on virtual devices, or export a device"
+            " build (Ad Hoc or Development) for physical iPhones."
+        )
+
+
 def print_validation_warnings(warnings: list[dict] | None) -> None:
     """Print non-fatal validation warnings to stderr."""
     if not warnings:

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/apps.py

@@ -30,6 +30,7 @@ from minitest_cli.utils.output import (
     print_table,
 )
 
+EXIT_GENERAL_ERROR = 1
 EXIT_NETWORK_ERROR = 3
 
 app = typer.Typer(name="apps", help="App management.")
@@ -70,6 +71,9 @@ def list_apps() -> None:
                         detail = body.get("detail") or body.get("message") or detail
                 except Exception:  # noqa: BLE001
                     pass
+                if resp.status_code in (401, 403):
+                    print_error(f"Authentication failed ({resp.status_code}): {detail}")
+                    raise typer.Exit(code=EXIT_GENERAL_ERROR)
                 print_error(f"API error ({resp.status_code}): {detail}")
                 raise typer.Exit(code=EXIT_NETWORK_ERROR)
             return AppListResponse.model_validate(resp.json())

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/batch_helpers.py

@@ -2,11 +2,16 @@
 
 from typing import Any
 
+import httpx
+import typer
+
 from minitest_cli.api.client import BATCH_CREATE_TIMEOUT, ApiClient
 from minitest_cli.commands.run_display import _derive_run_status
+from minitest_cli.commands._response_errors import EXIT_NETWORK_ERROR, extract_detail
 from minitest_cli.commands.run_helpers import handle_response_error
 from minitest_cli.commands.batch_warnings import print_compatibility_warnings
 from minitest_cli.models.batch import BatchResponse, CreateBatchRequest
+from minitest_cli.utils.output import err_console, print_error
 
 
 def batches_base_path(app_id: str) -> str:
@@ -21,12 +26,29 @@ async def post_batch(client: ApiClient, app_id: str, body: CreateBatchRequest) -
         json=body.model_dump(by_alias=True, exclude_none=True),
         timeout=BATCH_CREATE_TIMEOUT,
     )
+    if resp.status_code == 403 and _requests_physical(body):
+        _exit_physical_forbidden(resp)
     handle_response_error(resp, resource="Batch")
     batch = BatchResponse.model_validate(resp.json())
     print_compatibility_warnings(batch)
     return batch
 
 
+def _requests_physical(body: CreateBatchRequest) -> bool:
+    return any(target.backend == "physical" for target in body.targets or [])
+
+
+def _exit_physical_forbidden(resp: httpx.Response) -> None:
+    """A physical lane the workspace is not entitled to: say so, and how to proceed."""
+    print_error(extract_detail(resp))
+    err_console.print(
+        "  [yellow]Fix:[/yellow] ask Minitap to enable physical devices for this workspace,"
+        " or drop [bold]--ios-physical[/bold] / [bold]--android-physical[/bold]"
+        " to run on virtual devices."
+    )
+    raise typer.Exit(code=EXIT_NETWORK_ERROR)
+
+
 def batch_summary_payload(batch: BatchResponse) -> dict[str, Any]:
     """Serialise a batch to a compact JSON payload for --json output (camelCase)."""
     return {

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/build.py

@@ -42,8 +42,8 @@ def upload(
         Path,
         typer.Argument(
             help=(
-                "Path to the build file (.apk, .apks, or .ipa). Must be a Simulator"
-                " build for iOS or an emulator-compatible Android build."
+                "Path to the build file (.apk, .apks, .ipa or .app.zip). A Simulator build"
+                " for iOS or an emulator-compatible Android build, unless --physical."
             ),
             exists=True,
             readable=True,
@@ -53,17 +53,34 @@ def upload(
         Platform | None,
         typer.Option(help="Target platform. Auto-detected from file extension."),
     ] = None,
+    physical: Annotated[
+        bool,
+        typer.Option(
+            "--physical",
+            help=(
+                "Upload a build for physical devices: a signed iOS device .ipa (Ad Hoc or"
+                " Development) or an Android .apk for real phones."
+            ),
+        ),
+    ] = False,
 ) -> None:
-    """Upload a build file (.apk or .apks for Android, .ipa for iOS).
+    """Upload a build file (.apk or .apks for Android, .ipa or .app.zip for iOS).
 
-    Builds must be compatible with virtual devices:
+    By default builds are checked for virtual devices:
 
     \b
-    - iOS: provide a Simulator build (.ipa built for the iOS Simulator, not a physical device).
+    - iOS: provide a Simulator build (.ipa or .app.zip built for the iOS Simulator).
     - Android: provide an emulator-compatible .apk or .apks archive.
+
+    With --physical, builds are checked for physical devices instead: an iOS
+    device .ipa signed for Minitap's iPhones, or an Android .apk. Start runs on
+    them with --ios-physical / --android-physical.
     """
     settings, app_id, json_mode = resolve_app()
     resolved_platform = platform.value if platform else detect_platform(file)
+    form = {"platform": resolved_platform}
+    if physical:
+        form["backend"] = "physical"
 
     async def _run() -> BuildResponse:
         async with ApiClient(settings) as client:
@@ -74,9 +91,9 @@ def upload(
                 resp = await client.upload_file(
                     f"{base_path(app_id)}/build",
                     files={"file": (file.name, f, "application/octet-stream")},
-                    data={"platform": resolved_platform},
+                    data=form,
                 )
-        handle_response_error(resp)
+        handle_response_error(resp, physical=physical)
         return BuildResponse.model_validate(resp.json())
 
     result = run_api_call(_run())
@@ -86,7 +103,8 @@ def upload(
         output(result_dict, json_mode=True)
     else:
         print_validation_warnings(result.validation_warnings)
-        print_success(f"Build uploaded: {file.name} ({resolved_platform})")
+        devices = ", physical devices" if physical else ""
+        print_success(f"Build uploaded: {file.name} ({resolved_platform}{devices})")
         output(result_dict, json_mode=False)
 
 

{minitest_cli-0.36.0 → minitest_cli-0.37.1}/src/minitest_cli/commands/build_helpers.py

@@ -76,6 +76,7 @@ PLATFORM_EXTENSIONS: dict[str, Platform] = {
     ".ipa": Platform.ios,
     ".apk": Platform.android,
     ".apks": Platform.android,
+    ".app.zip": Platform.ios,
 }
 
 
@@ -97,7 +98,8 @@ class BuildKindFilter(StrEnum):
 
 def detect_platform(file_path: Path) -> str:
     """Auto-detect platform from file extension."""
-    suffix = file_path.suffix.lower()
+    name = file_path.name.lower()
+    suffix = ".app.zip" if name.endswith(".app.zip") else file_path.suffix.lower()
     platform = PLATFORM_EXTENSIONS.get(suffix)
     if platform is None:
         print_error(

minitest_cli-0.37.1/src/minitest_cli/commands/draft.py

@@ -0,0 +1,111 @@
+"""`minitest draft`: ask Mini for a suite change and drive it to merge.
+
+A draft is the workbench the webapp shows under Drafts: a branch of the suite plus
+Mini's conversation about it. Mini is the only author of the branch; never `df apply`
+into a draft's branch yourself.
+"""
+
+from typing import Annotated
+
+import typer
+
+from minitest_cli.commands import (
+    draft_asks,
+    draft_conversation,
+    draft_create,
+    draft_legacy,
+    draft_lifecycle,
+    draft_pr,
+    draft_update,
+)
+from minitest_cli.commands.draft_helpers import (
+    DRAFTS_PATH,
+    call,
+    draft_path,
+    resolve_target,
+    run_conductor,
+)
+from minitest_cli.commands.draft_render import (
+    DRAFT_TABLE_HEADERS,
+    draft_row,
+    show_draft,
+)
+from minitest_cli.commands.draft_watch import WatchUntil, watch
+from minitest_cli.utils.output import (
+    print_info,
+    print_json,
+    print_table,
+)
+
+app = typer.Typer(
+    name="draft",
+    help="Ask Mini for a suite change, follow the conversation, and check/merge the result.",
+    no_args_is_help=True,
+)
+EXIT_WATCH_TIMEOUT = 1
+
+
+@app.command(name="list")
+def list_drafts(
+    history: Annotated[
+        bool, typer.Option("--history", help="List merged and discarded drafts instead.")
+    ] = False,
+) -> None:
+    """List the active app's drafts (open ones by default)."""
+    target = resolve_target()
+    params = {"appId": target.app_id, "scope": "history" if history else "open"}
+    body = call(target, "GET", DRAFTS_PATH, retry=True, params=params)
+    drafts = body.get("drafts", [])
+    if target.json_mode:
+        print_json(drafts)
+        return
+    if not drafts:
+        print_info("No drafts found.")
+        return
+    print_table(
+        DRAFT_TABLE_HEADERS, [draft_row(d) for d in drafts], title=f"Drafts ({len(drafts)})"
+    )
+
+
+@app.command(name="get")
+def get_draft(
+    draft_id: Annotated[str, typer.Argument(help="Draft ID.")],
+    watch_flag: Annotated[
+        bool, typer.Option("--watch", help="Poll until the draft is stable, then print it.")
+    ] = False,
+    until: Annotated[
+        WatchUntil,
+        typer.Option(
+            "--until",
+            help="idle: Mini has nothing queued. settled: also no check or draft build running.",
+        ),
+    ] = WatchUntil.IDLE,
+    interval: Annotated[
+        float, typer.Option("--interval", min=1.0, help="Seconds between polls.")
+    ] = 5.0,
+    timeout: Annotated[
+        float, typer.Option("--timeout", min=1.0, help="Give up after this many seconds (exit 1).")
+    ] = 900.0,
+) -> None:
+    """Show a draft: state, Mini's status, scenarios and open asks."""
+    target = resolve_target()
+    path = draft_path(draft_id)
+    if not watch_flag:
+        show_draft(call(target, "GET", path, retry=True), json_mode=target.json_mode)
+        return
+    draft, stable = run_conductor(
+        watch(target, path, until=until, interval=interval, timeout=timeout)
+    )
+    show_draft(draft, json_mode=target.json_mode)
+    if not stable:
+        print_info(f"Still not {until.value} after {timeout:.0f}s; run the same command again.")
+        raise typer.Exit(code=EXIT_WATCH_TIMEOUT)
+
+
+draft_create.register(app)
+draft_update.register(app)
+draft_conversation.register(app)
+draft_lifecycle.register(app)
+draft_pr.register(app)
+app.add_typer(draft_asks.app)
+draft_legacy.register(app)

minitest_cli-0.37.1/src/minitest_cli/commands/draft_asks.py

@@ -0,0 +1,148 @@
+"""`minitest draft ask list|answer|decline`: answer what Mini asked on a draft.
+
+Secret fields (``secret: true`` in an ask's answerFields) are only read from a file or
+stdin (``--field-file KEY=PATH``, ``-`` for stdin) — never from the command line, where
+shells and process lists keep them — and are never printed back.
+"""
+
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+
+from minitest_cli.commands.draft_helpers import (
+    EXIT_GENERAL_ERROR,
+    EXIT_NOT_FOUND,
+    DraftTarget,
+    call,
+    draft_path,
+    resolve_target,
+)
+from minitest_cli.commands.draft_render import (
+    ASK_TABLE_HEADERS,
+    ask_fields,
+    read_file,
+    read_text,
+    show_draft,
+)
+from minitest_cli.commands.run_helpers import ensure_uuid
+from minitest_cli.utils.output import (
+    print_error,
+    print_info,
+    print_json,
+    print_success,
+    print_table,
+)
+
+app = typer.Typer(
+    name="ask", help="Read and answer Mini's questions on a draft.", no_args_is_help=True
+)
+DraftIdArg = Annotated[str, typer.Argument(help="Draft ID.")]
+AskIdArg = Annotated[str, typer.Argument(help="Ask ID (from `draft ask list`).")]
+
+
+def _open_asks(target: DraftTarget, draft_id: str) -> list[dict[str, Any]]:
+    return call(target, "GET", draft_path(draft_id), retry=True).get("asks") or []
+
+
+def _find_ask(target: DraftTarget, draft_id: str, ask_id: str) -> dict[str, Any]:
+    ensure_uuid(ask_id, kind="ask id")
+    for ask in _open_asks(target, draft_id):
+        if ask.get("id") == ask_id:
+            return ask
+    print_error(f"No open ask {ask_id} on draft {draft_id}; see `minitest draft ask list`.")
+    raise typer.Exit(code=EXIT_NOT_FOUND)
+
+
+def _pair(raw: str, flag: str) -> tuple[str, str]:
+    key, sep, value = raw.partition("=")
+    if not sep or not key:
+        print_error(f"{flag} expects KEY=VALUE.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    return key, value
+
+
+def _fields(ask: dict[str, Any], inline: list[str], files: list[str]) -> dict[str, str]:
+    known = {f["key"]: f for f in ask.get("answerFields") or []}
+    values: dict[str, str] = {}
+    for raw in inline:
+        key, value = _pair(raw, "--field")
+        if known.get(key, {}).get("secret"):
+            print_error(f"'{key}' is secret: pass it with --field-file {key}=PATH (- = stdin).")
+            raise typer.Exit(code=EXIT_GENERAL_ERROR)
+        values[key] = value
+    if sum(1 for raw in files if _pair(raw, "--field-file")[1] == "-") > 1:
+        print_error("Only one --field-file can read stdin.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    for raw in files:
+        key, path = _pair(raw, "--field-file")
+        values[key] = read_file(Path(path)).removesuffix("\n")
+    unknown = sorted(set(values) - set(known))
+    if unknown:
+        print_error(f"Unknown field(s) {', '.join(unknown)}; this ask takes: {ask_fields(ask)}.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    return values
+
+
+@app.command(name="list")
+def list_asks(draft_id: DraftIdArg) -> None:
+    """List Mini's open questions on a draft, with the fields each answer takes."""
+    target = resolve_target()
+    asks = _open_asks(target, draft_id)
+    if target.json_mode:
+        print_json(asks)
+        return
+    if not asks:
+        print_info("Mini is not asking anything.")
+        return
+    rows = [[a["id"], a.get("askType", "-"), a["question"], ask_fields(a)] for a in asks]
+    print_table(ASK_TABLE_HEADERS, rows)
+
+
+@app.command(name="answer")
+def answer_ask(
+    draft_id: DraftIdArg,
+    ask_id: AskIdArg,
+    answer: Annotated[str | None, typer.Option("--answer", help="Free-text answer.")] = None,
+    answer_file: Annotated[
+        Path | None, typer.Option("--answer-file", help="Read the answer from a file (- = stdin).")
+    ] = None,
+    field: Annotated[
+        list[str] | None, typer.Option("--field", help="KEY=VALUE for a non-secret field.")
+    ] = None,
+    field_file: Annotated[
+        list[str] | None,
+        typer.Option("--field-file", help="KEY=PATH, value read from a file (- = stdin)."),
+    ] = None,
+) -> None:
+    """Answer an ask; Mini resumes the draft with it. Turns auto-merge off."""
+    text = read_text(answer, answer_file, flag="answer", required=False)
+    target = resolve_target()
+    ask = _find_ask(target, draft_id, ask_id)
+    values = _fields(ask, field or [], field_file or [])
+    if text is None and not values:
+        print_error("Pass --answer/--answer-file, or the ask's fields with --field/--field-file.")
+        raise typer.Exit(code=EXIT_GENERAL_ERROR)
+    body: dict[str, object] = {}
+    if text is not None:
+        body["answer"] = text
+    if values:
+        body["fields"] = values
+    draft = call(target, "POST", draft_path(draft_id, f"/asks/{ask_id}/answer"), json=body)
+    print_success("Answered; Mini picks it up next.")
+    show_draft(draft, json_mode=target.json_mode)
+
+
+@app.command(name="decline")
+def decline_ask(
+    draft_id: DraftIdArg,
+    ask_id: AskIdArg,
+    reason: Annotated[str | None, typer.Option("--reason", help="Why, so Mini can adapt.")] = None,
+) -> None:
+    """Decline an ask; Mini carries on without it."""
+    target = resolve_target()
+    ensure_uuid(ask_id, kind="ask id")
+    body = {"reason": reason} if reason else None
+    draft = call(target, "POST", draft_path(draft_id, f"/asks/{ask_id}/decline"), json=body)
+    print_success("Declined.")
+    show_draft(draft, json_mode=target.json_mode)