hexastack-cli 0.0.0__py3-none-any.whl

hexastack_cli/testing/narrator.py

@@ -0,0 +1,192 @@
+"""Terminal session testing and feature demo narration engine for CLI applications."""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from typer.testing import CliRunner
+
+
+@dataclass
+class TerminalEvent:
+    """Represents a discrete timestamped event in a recorded terminal session."""
+
+    time_offset: float
+    event_type: str  # "input", "output", "step"
+    payload: str
+
+
+class CliNarrator:
+    """Orchestrates CLI command execution, human-like typing emulation, and session recording.
+
+    Notes/Architectural Intent:
+        Provides a unified interface for testing CLI tools that:
+        1. In standard test / CI mode: Runs instantly via in-memory CliRunner.
+        2. In demo mode (RECORD_DEMO=1): Generates WebVTT narration subtitles
+           and directly renders a fixed-window, auto-scrolling .webm video via Playwright.
+    """
+
+    def __init__(
+        self,
+        app: Any,
+        output_name: str | None = None,
+        output_dir: Path | None = None,
+        width: int = 100,
+        height: int = 24,
+    ) -> None:
+        """Initialize CLI narrator attached to a Typer or Click application.
+
+        Args:
+            app: Target Typer application instance.
+            output_name: Base filename (without extension) for saving recordings.
+            output_dir: Target output directory for generated demo artifacts.
+            width: Terminal column width.
+            height: Terminal row height.
+        """
+        self.app = app
+        self.output_name = output_name
+        self.output_dir = output_dir or Path("docs/assets/demos")
+        self.width = width
+        self.height = height
+        self.record_mode = os.environ.get("RECORD_DEMO") in ("1", "true", "True")
+        self.runner = CliRunner()
+        self.start_time: float = time.time()
+        self.events: list[TerminalEvent] = []
+        self.captions: list[tuple[float, float, str]] = []
+        self._current_step_start: float | None = None
+        self._current_step_text: str | None = None
+
+    def step(self, caption: str) -> None:
+        """Add a descriptive chapter step / subtitle narration for viewers.
+
+        Args:
+            caption: Subtitle narration text explaining the current terminal action.
+        """
+        now = time.time() - self.start_time
+
+        if self._current_step_start is not None and self._current_step_text is not None:
+            self.captions.append(
+                (self._current_step_start, now, self._current_step_text)
+            )
+
+        self._current_step_start = now
+        self._current_step_text = caption
+        self.events.append(
+            TerminalEvent(time_offset=now, event_type="step", payload=caption)
+        )
+
+    def run_command(
+        self,
+        args: list[str],
+        caption: str | None = None,
+        input_text: str | None = None,
+        type_delay: float = 0.05,
+    ) -> Any:
+        """Execute a CLI command with simulated typing cadence and output recording.
+
+        Args:
+            args: Command line arguments list (e.g. ["new", "web-api", "my-service"]).
+            caption: Optional narration step explaining this command.
+            input_text: Optional interactive stdin text to feed to the command.
+            type_delay: Seconds per keystroke when recording in demo mode.
+
+        Returns:
+            CliRunner invocation result.
+        """
+        if caption:
+            self.step(caption)
+
+        cmd_str = "hexastack " + " ".join(args)
+        cmd_start = time.time() - self.start_time
+
+        if self.record_mode:
+            # Simulate human keystroke cadence in event timeline
+            sim_time = cmd_start
+            for char in f"$ {cmd_str}\n":
+                sim_time += type_delay
+                self.events.append(
+                    TerminalEvent(
+                        time_offset=sim_time, event_type="input", payload=char
+                    )
+                )
+
+        # Execute command synchronously
+        result = self.runner.invoke(self.app, args, input=input_text)
+        out_time = time.time() - self.start_time
+
+        self.events.append(
+            TerminalEvent(
+                time_offset=out_time, event_type="output", payload=result.output
+            )
+        )
+
+        return result
+
+    def finish(self) -> dict[str, Path]:
+        """Finalize recording and export .webm and .vtt subtitle artifacts.
+
+        Returns:
+            Dictionary containing written artifact paths.
+        """
+        if not self.record_mode:
+            return {}
+
+        now = time.time() - self.start_time
+        if self._current_step_start is not None and self._current_step_text is not None:
+            self.captions.append(
+                (self._current_step_start, now, self._current_step_text)
+            )
+
+        out_dir = self.output_dir
+        out_dir.mkdir(parents=True, exist_ok=True)
+        base_name = self.output_name or "cli-demo"
+        artifacts: dict[str, Path] = {}
+
+        # 1. Export WebVTT (.vtt) synchronized narration subtitles
+        vtt_lines = ["WEBVTT", ""]
+        for idx, (start_s, end_s, text) in enumerate(self.captions, start=1):
+            vtt_lines.append(str(idx))
+            vtt_lines.append(
+                f"{self._format_vtt_time(start_s)} --> {self._format_vtt_time(end_s)}"
+            )
+            vtt_lines.append(text)
+            vtt_lines.append("")
+
+        vtt_path = out_dir / f"{base_name}.vtt"
+        vtt_path.write_text("\n".join(vtt_lines), encoding="utf-8")
+        artifacts["vtt"] = vtt_path
+
+        # 2. Render directly to .webm video via Playwright Rich Terminal
+        try:
+            from hexastack_cli.testing.terminal import render_cli_demo_video
+
+            video_path = out_dir / f"{base_name}.webm"
+            render_cli_demo_video(
+                events=self.events,
+                output_path=video_path,
+                title=f"Hexastack CLI — {base_name}",
+            )
+            artifacts["webm"] = video_path
+        except Exception:
+            pass
+
+        return artifacts
+
+    @staticmethod
+    def _format_vtt_time(seconds: float) -> str:
+        """Format seconds into WebVTT timestamp (HH:MM:SS.mmm)."""
+        hrs = int(seconds // 3600)
+        mins = int((seconds % 3600) // 60)
+        secs = int(seconds % 60)
+        millis = int(round((seconds - int(seconds)) * 1000))
+        return f"{hrs:02d}:{mins:02d}:{secs:02d}.{millis:03d}"
+
+
+__all__ = [
+    "CliNarrator",
+    "TerminalEvent",
+]

hexastack_cli/testing/terminal.py

@@ -0,0 +1,298 @@
+"""Rich HTML Terminal view and Playwright video renderer for CLI demo recordings."""
+
+from __future__ import annotations
+
+import html
+import re
+import shutil
+from pathlib import Path
+
+from hexastack_cli.testing.narrator import TerminalEvent
+from hexastack_core.domain.exceptions import MissingDependencyError
+
+TERMINAL_HTML_TEMPLATE = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>{title}</title>
+    <style>
+        * {{ box-sizing: border-box; margin: 0; padding: 0; }}
+        body {{
+            background: #0d1117;
+            color: #e6edf3;
+            font-family: 'JetBrains Mono', 'Fira Code', 'Cascadia Code', Menlo, Monaco, 'Courier New', monospace;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+            overflow: hidden;
+            padding: 40px;
+        }}
+        .window {{
+            background: #161b22;
+            border-radius: 12px;
+            box-shadow: 0 20px 50px rgba(0,0,0,0.6), 0 0 0 1px rgba(255,255,255,0.1);
+            width: 1080px;
+            height: 560px;
+            max-height: 560px;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }}
+        .titlebar {{
+            background: #21262d;
+            padding: 12px 16px;
+            display: flex;
+            align-items: center;
+            border-bottom: 1px solid rgba(255,255,255,0.08);
+            flex-shrink: 0;
+        }}
+        .dots {{
+            display: flex;
+            gap: 8px;
+        }}
+        .dot {{
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+        }}
+        .dot-red {{ background: #ff5f56; }}
+        .dot-yellow {{ background: #ffbd2e; }}
+        .dot-green {{ background: #27c93f; }}
+        .title {{
+            flex: 1;
+            text-align: center;
+            color: #8b949e;
+            font-size: 13px;
+            font-weight: 500;
+            margin-right: 48px;
+        }}
+        .content {{
+            padding: 24px;
+            font-size: 15px;
+            line-height: 1.6;
+            flex: 1;
+            overflow-y: auto;
+            white-space: pre-wrap;
+            word-break: break-word;
+            scroll-behavior: smooth;
+        }}
+        .content::-webkit-scrollbar {{
+            display: none;
+        }}
+        .content {{
+            -ms-overflow-style: none;
+            scrollbar-width: none;
+        }}
+        .prompt {{ color: #7ee787; font-weight: bold; }}
+        .command {{ color: #79c0ff; font-weight: bold; }}
+        .step-banner {{
+            position: fixed;
+            bottom: 32px;
+            left: 50%;
+            transform: translateX(-50%);
+            background: rgba(15, 23, 42, 0.92);
+            color: #ffffff;
+            padding: 12px 24px;
+            border-radius: 8px;
+            font-size: 17px;
+            font-family: system-ui, -apple-system, sans-serif;
+            font-weight: 500;
+            box-shadow: 0 10px 25px rgba(0,0,0,0.5);
+            border: 1px solid rgba(255,255,255,0.15);
+            backdrop-filter: blur(8px);
+            z-index: 9999;
+            transition: opacity 0.2s ease-in-out;
+            text-align: center;
+            max-width: 80%;
+        }}
+        .cursor {{
+            display: inline-block;
+            width: 8px;
+            height: 16px;
+            background: #58a6ff;
+            vertical-align: text-bottom;
+            animation: blink 1s step-end infinite;
+        }}
+        @keyframes blink {{ 50% {{ opacity: 0; }} }}
+    </style>
+</head>
+<body>
+    <div class="window">
+        <div class="titlebar">
+            <div class="dots">
+                <div class="dot dot-red"></div>
+                <div class="dot dot-yellow"></div>
+                <div class="dot dot-green"></div>
+            </div>
+            <div class="title">{title} — bash</div>
+        </div>
+        <div class="content" id="terminal-content"><span class="cursor"></span></div>
+    </div>
+    <div class="step-banner" id="banner" style="display: none;"></div>
+</body>
+</html>
+"""
+
+
+def _strip_ansi(text: str) -> str:
+    """Remove ANSI color and escape sequences from text."""
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+    return ansi_escape.sub("", text)
+
+
+def render_cli_demo_video(
+    events: list[TerminalEvent],
+    output_path: Path,
+    title: str = "Hexastack CLI",
+    width: int = 1280,
+    height: int = 720,
+) -> tuple[Path, Path]:
+    """Render a sequence of TerminalEvents into synchronized .webm video and .vtt subtitle track.
+
+    Args:
+        events: Chronological sequence of input, output, and step narrative events.
+        output_path: Destination Path for .webm video file.
+        title: Window title text for terminal banner.
+        width: Video frame width in pixels.
+        height: Video frame height in pixels.
+
+    Returns:
+        Tuple of (video_path, vtt_path).
+
+    Raises:
+        MissingDependencyError: If `playwright` is not installed.
+    """
+    try:
+        from playwright.sync_api import sync_playwright
+    except ImportError as e:
+        raise MissingDependencyError(
+            "Playwright is required to record CLI demos into .webm video. "
+            "Install with 'pip install hexastack-cli[testing]' or 'pip install playwright'."
+        ) from e
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    temp_dir = output_path.parent / ".temp_video"
+    temp_dir.mkdir(parents=True, exist_ok=True)
+
+    html_content = TERMINAL_HTML_TEMPLATE.format(title=html.escape(title))
+    vtt_captions: list[tuple[float, float, str]] = []
+    current_step_start: float | None = None
+    current_step_text: str | None = None
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=True)
+        context = browser.new_context(
+            viewport={"width": width, "height": height},
+            record_video_dir=str(temp_dir),
+            record_video_size={"width": width, "height": height},
+        )
+        page = context.new_page()
+        page.set_content(html_content)
+        page.wait_for_timeout(500)
+        start_playback_time = 0.5
+
+        current_time = start_playback_time
+
+        for ev in events:
+            if ev.event_type == "step":
+                if current_step_start is not None and current_step_text is not None:
+                    vtt_captions.append(
+                        (current_step_start, current_time, current_step_text)
+                    )
+
+                current_step_start = current_time
+                current_step_text = ev.payload
+
+                safe_text = html.escape(ev.payload).replace("'", "\\'")
+                page.evaluate(
+                    f"""(() => {{
+                        const banner = document.getElementById('banner');
+                        if (banner) {{
+                            banner.innerText = '{safe_text}';
+                            banner.style.display = 'block';
+                        }}
+                    }})();"""
+                )
+                page.wait_for_timeout(600)
+                current_time += 0.6
+
+            elif ev.event_type == "input":
+                char_str = html.escape(ev.payload)
+                if char_str == "\n":
+                    char_str = "<br/>"
+                page.evaluate(
+                    f"""(() => {{
+                        const terminal = document.getElementById('terminal-content');
+                        const cursor = terminal.querySelector('.cursor');
+                        const span = document.createElement('span');
+                        span.className = 'command';
+                        span.innerHTML = '{char_str}';
+                        terminal.insertBefore(span, cursor);
+                        terminal.scrollTop = terminal.scrollHeight;
+                    }})();"""
+                )
+                page.wait_for_timeout(35)
+                current_time += 0.035
+
+            elif ev.event_type == "output":
+                clean_text = _strip_ansi(ev.payload)
+                escaped_output = html.escape(clean_text).replace("\n", "<br/>")
+                page.evaluate(
+                    f"""(() => {{
+                        const terminal = document.getElementById('terminal-content');
+                        const cursor = terminal.querySelector('.cursor');
+                        const div = document.createElement('div');
+                        div.style.color = '#c9d1d9';
+                        div.style.margin = '4px 0 12px 0';
+                        div.innerHTML = '{escaped_output}';
+                        terminal.insertBefore(div, cursor);
+                        terminal.scrollTop = terminal.scrollHeight;
+                    }})();"""
+                )
+                page.wait_for_timeout(1000)
+                current_time += 1.0
+
+        if current_step_start is not None and current_step_text is not None:
+            vtt_captions.append(
+                (current_step_start, current_time + 1.5, current_step_text)
+            )
+
+        page.wait_for_timeout(1500)
+        video = page.video
+        page.close()
+        context.close()
+        browser.close()
+
+        if video:
+            video_src = Path(video.path())
+            shutil.copy2(video_src, output_path)
+
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+    # Export synchronized WebVTT subtitles with true video timestamps
+    vtt_lines = ["WEBVTT", ""]
+    for idx, (start_s, end_s, text) in enumerate(vtt_captions, start=1):
+        vtt_lines.append(str(idx))
+        vtt_lines.append(f"{_format_vtt_time(start_s)} --> {_format_vtt_time(end_s)}")
+        vtt_lines.append(text)
+        vtt_lines.append("")
+
+    vtt_path = output_path.with_suffix(".vtt")
+    vtt_path.write_text("\n".join(vtt_lines), encoding="utf-8")
+
+    return output_path, vtt_path
+
+
+def _format_vtt_time(seconds: float) -> str:
+    """Format seconds into WebVTT timestamp (HH:MM:SS.mmm)."""
+    hrs = int(seconds // 3600)
+    mins = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    millis = int(round((seconds - int(seconds)) * 1000))
+    return f"{hrs:02d}:{mins:02d}:{secs:02d}.{millis:03d}"
+
+
+__all__ = [
+    "render_cli_demo_video",
+]

hexastack_cli-0.0.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.3
+Name: hexastack-cli
+Version: 0.0.0
+Summary: Hexastack CLI presentation adapter with Typer and Rich
+Author: Richard West
+Author-email: Richard West <dopplereffect.us@gmail.com>
+Requires-Dist: hexastack-core
+Requires-Dist: hexastack-cqrs
+Requires-Dist: rich>=13.8.0
+Requires-Dist: typer>=0.27.1
+Requires-Dist: playwright>=1.49.0 ; extra == 'testing'
+Requires-Python: >=3.13
+Provides-Extra: testing
+Description-Content-Type: text/markdown
+
+# hexastack-cli
+
+> Typer and Rich presentation adapter for Hexastack: nested commands, aliases, piped outputs, and CQRS dispatching.
+
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+
+---
+
+## 1. Overview & Capabilities
+
+`hexastack-cli` turns Hexastack CQRS commands and queries into intuitive, modern CLI applications:
+
+- **Nested Command Hierarchies**: Nest subcommands naturally (`app user create`, `app db migrate`) using `@cli_group`.
+- **Command Aliases**: Register multiple aliases for the same action (`app user new == app user create`).
+- **Feature Flag Gating**: Gate CLI commands dynamically with `@feature_flag_command(...)` and `@cli_command(..., feature_flag=...)`.
+- **Rich Formatted & CI-Friendly Output**: Beautiful tables, panels, and spinners for interactive terminals; clean text/JSON streaming for CI/CD pipelines.
+- **Direct CQRS Dispatching**: Declaratively expose domain commands (`@cli_command`) and queries (`@cli_query`) with automatic parameter parsing and validation.
+
+---
+
+## 2. Package Anatomy & Key Components
+
+```
+hexastack_cli/
+├── domain/          # CliContext, OutputFormat enum
+├── adapters/        # create_cli_app, Rich presenters, Typer command runners
+└── infra/           # CliBootstrapper (order=30), @cli_command, @cli_query, @cli_group, @feature_flag_command
+```
+
+### Key Exports
+
+| Category | Exports |
+|---|---|
+| **Application Factory** | `create_cli_app`, `CliBootstrapper` (order=30) |
+| **Decorators** | `@cli_command`, `@cli_query`, `@cli_group`, `@feature_flag_command` |
+| **Presenters** | `RichTerminalPresenter`, `ConsolePresenter`, `TablePresenter`, `JsonPresenter` |
+| **Testing & Demo Narration** | `CliNarrator`, `TerminalEvent` |
+
+---
+
+## 3. Monorepo & Sibling Relationships
+
+```mermaid
+graph TD
+    subgraph UserInvocation ["CLI Invocations"]
+        INV["Terminal Commands & Scripts"]
+    end
+
+    subgraph CliLayer ["hexastack-cli"]
+        TYPER["Typer Application (Nested Groups & Aliases)"]
+        RICH["Rich Presenters (Tables, Panels, JSON)"]
+        SCAN["CLI Decorator Scanner (@cli_command, @cli_query)"]
+    end
+
+    subgraph CQRSExecution ["hexastack-cqrs"]
+        CBUS["CommandBusPort"]
+        QBUS["QueryBusPort"]
+    end
+
+    subgraph Kernel ["hexastack-core"]
+        DI["rodi.Container"]
+    end
+
+    INV --> TYPER
+    TYPER --> SCAN
+    SCAN -->|dispatches to| CBUS
+    SCAN -->|dispatches to| QBUS
+    SCAN --> RICH
+
+    TYPER -. resolves buses from DI .-> DI
+```
+
+### Explicit Dependencies (Direct)
+- `hexastack-core`: Core kernel, DI container, and ports.
+- `hexastack-cqrs`: `CommandBusPort` and `QueryBusPort` for message dispatching.
+- `typer>=0.27.1`: CLI command parser and shell completion.
+- `rich>=15.0.0`: Terminal formatting, tables, and colors.
+
+### Implied / Behavioral Relationships (DI-Mediated)
+- **CQRS Integration**: Dispatches CLI argument payloads directly into the application's command and query buses.
+- **Umbrella CLI**: Consumed by the `hexastack` umbrella package to power diagnostic commands (`hexastack info`, `hexastack inspect registry`, `hexastack demo ping`).
+
+---
+
+## 4. Installation
+
+```bash
+# Standalone install
+pip install hexastack-cli
+
+# Via umbrella package
+pip install "hexastack[cli]"
+```
+
+---
+
+## 5. Quickstart Example
+
+```python
+from dataclasses import dataclass
+from hexastack_core.infra.bootstrap import bootstrap
+from hexastack_cqrs.domain.query import Query
+from hexastack_cqrs.infra.decorators import query_handler
+from hexastack_cli.infra.decorators import cli_query, cli_group
+
+
+@dataclass(frozen=True)
+class CheckStatusQuery(Query):
+    service_name: str
+
+
+@query_handler(CheckStatusQuery)
+class CheckStatusHandler:
+    def __call__(self, qry: CheckStatusQuery) -> dict:
+        return {"service": qry.service_name, "status": "ONLINE"}
+
+
+# Expose query as a CLI command
+cli_query("status", aliases=["st", "health"], help="Check status of a service")(
+    CheckStatusQuery
+)
+
+runtime = bootstrap(packages_to_scan=[__name__])
+cli_app = runtime.get("cli_app")
+```

hexastack_cli-0.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+hexastack_cli/__init__.py,sha256=BxoY0Y5o6VtjzlPkspHmgZYaPuFAKVmA5hwnpg93CMk,86
+hexastack_cli/adapters/__init__.py,sha256=JzoxVVKhUjuRmAJO5MK0mrwLwTKXl9xO7zLfohk22Cw,342
+hexastack_cli/adapters/app.py,sha256=BuS5pjqlg3Fv_6K90TFvADXtwfDfVSak8R-2oIzKJPg,2576
+hexastack_cli/adapters/presenter.py,sha256=3TRwSSxLgEhFVvcDRu5VogHoC-kVAgdHDEAD3p4u9vo,4419
+hexastack_cli/adapters/routing.py,sha256=v02J5KpyqYuAEdjG38Gr-pxLxloWQle3oa-DZnObbLk,13394
+hexastack_cli/infra/__init__.py,sha256=m4BGkzq6_9zbmhBn3Qwvxtp56J7-i1haflleg5vauKA,628
+hexastack_cli/infra/autodiscovery.py,sha256=Mr-YLrEaf38_zQcOgjVJlDtLbX7bt-bjQODbxW5X0ng,6848
+hexastack_cli/infra/bootstrap.py,sha256=99tD1hdnNWRDyLNwQJ9ogBdJgpGIV9OPzDFVde_d_Q4,2475
+hexastack_cli/infra/config.py,sha256=e79HN42O_fnBvsHEKhsET5deWHAZrPJPABmMQrO9940,1235
+hexastack_cli/infra/decorators.py,sha256=fmU2Svga9GdaoOyVZLXOrUCCtbdmVbLq0gISrwcph30,7167
+hexastack_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hexastack_cli/testing/__init__.py,sha256=zB7VmUX7T0Hpuyv9O1Qfj4PkgfuE06DLklnahkWl1LQ,295
+hexastack_cli/testing/narrator.py,sha256=dXInuCxPzUFSyo0o0ME9x9xRYsRvBHdNbMv3OCOanS8,6542
+hexastack_cli/testing/terminal.py,sha256=QOHhLtRw6bk27gKji5DDNQKCb0sUxwVMpSxIEXpU0EE,10248
+hexastack_cli-0.0.0.dist-info/WHEEL,sha256=EmLkUISDECbcUx3FMCYOqokNOJqNp2r0d4mJzjErvvs,80
+hexastack_cli-0.0.0.dist-info/entry_points.txt,sha256=LPpUygBzbXJ0_5IXxaesAbJjJ5Vmp8wQQOtgfbY5Yj8,79
+hexastack_cli-0.0.0.dist-info/METADATA,sha256=Id59pQZbPtZ_Ya4igL7J1vSjOqR26y_JnJR3Jz1kEqg,4529
+hexastack_cli-0.0.0.dist-info/RECORD,,

hexastack_cli-0.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.3
+Root-Is-Purelib: true
+Tag: py3-none-any

hexastack_cli-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[hexastack.bootstrappers]
+cli = hexastack_cli.infra.bootstrap:CliBootstrapper
+