beautiful-python-cli 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 syrex1013
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,107 @@
-# Temporary Holding Version
+# beautiful-python-cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A comprehensive agent skill for crafting polished, accessible terminal user interfaces (TUIs) and CLI applications in Python using [Rich](https://github.com/Textualize/rich).
+
+Designed for modern AI coding assistants including Claude Code, Cursor, Gemini / Antigravity, Codex, Windsurf, and Pi.
+
+---
+
+## Capabilities
+
+- **Status & Spinners**: Indeterminate operation indicators with clean context manager lifecycle.
+- **Progress Bars**: Measurable multi-task, byte-transfer, and ETA progress bars.
+- **Live Dashboards & TUIs**: Real-time updating multi-pane layouts with responsive screen partitioning.
+- **Interactive Prompts**: Input validation, defaults, yes/no confirmations, and masked secret entries.
+- **Structured Output**: Stylized tables, summary panels, and tree structures with terminal width adaptability.
+- **Diagnostics & Tracebacks**: Production-safe stack trace formatting and syntax highlighting.
+- **Contract Adherence**: Full compliance with `NO_COLOR`, non-TTY environments, and pure machine-readable `--json` streams.
+
+---
+
+## Installation
+
+### Via `npx skills` (Recommended)
+
+Install directly into your AI coding assistant:
+
+```bash
+# Add to current project
+npx skills add syrex1013/beautiful-python-cli
+
+# Install globally across all agents
+npx skills add syrex1013/beautiful-python-cli -g
+```
+
+### Via Shell Installer
+
+Clone and run the universal installer:
+
+```bash
+git clone https://github.com/syrex1013/beautiful-python-cli.git
+cd beautiful-python-cli
+
+# Install for all supported agents
+./install.sh --all
+
+# Or target specific agents
+./install.sh --claude
+./install.sh --cursor
+./install.sh --antigravity
+./install.sh --codex
+./install.sh --windsurf
+```
+
+---
+
+## Directory Structure
+
+```text
+beautiful-python-cli/
+├── SKILL.md                          # Core agent skill instructions and routing
+├── package.json                      # npm / skills.sh package metadata
+├── LICENSE                           # MIT License
+├── requirements.txt                  # Python dependencies (rich)
+├── install.sh                        # Multi-agent installer script
+├── references/                       # In-depth architectural guides
+│   ├── rich-components.md            # Component selection and theme definitions
+│   ├── interaction-patterns.md       # Spinners, progress, and live updates
+│   ├── prompts-and-inputs.md         # Interactive prompt validation & secrets
+│   ├── tracebacks-and-debugging.md   # Error reporting and syntax highlighting
+│   ├── layouts-and-tui.md            # Screen partitioning & responsive grids
+│   ├── concurrent-progress.md        # Multi-threaded and async workers
+│   └── testing-and-accessibility.md  # Non-TTY handling, JSON purity, test suite
+├── examples/                         # Runnable implementation patterns
+│   ├── showcase.py                   # Tables, panels, status, and progress
+│   ├── live_dashboard.py             # Dynamic Live dashboard
+│   ├── interactive_prompts.py        # Prompts, choices, and confirmation
+│   ├── concurrent_progress.py        # ThreadPoolExecutor multi-bar progress
+│   └── tui_layout.py                 # Multi-pane terminal dashboard
+└── tests/
+    └── test_skill.py                 # Automated unit tests
+```
+
+---
+
+## Running the Examples
+
+```bash
+python3 -m pip install -r requirements.txt
+
+# Run the comprehensive showcase
+python3 examples/showcase.py
+
+# Run interactive wizard demonstration
+python3 examples/interactive_prompts.py --non-interactive
+
+# Run multi-threaded progress demo
+python3 examples/concurrent_progress.py --workers 4
+
+# Run real-time monitoring TUI
+python3 examples/tui_layout.py --seconds 3
+```
+
+---
+
+## License
+
+MIT © syrex1013

package/SKILL.md

@@ -0,0 +1,178 @@
+---
+name: beautiful-python-cli
+description: Design, implement, or refactor Python command-line output into polished, accessible terminal UIs using Rich. Use when adding spinners, loading states, progress bars, concurrent tasks, interactive prompts, live dashboards, TUI layouts, real-time logs, colored status, tables, panels, themes, or terminal UX. Do not use for GUI/web interfaces or trivial one-off scripts that only need plain output.
+---
+
+# Beautiful Python CLI
+
+Build terminal interfaces that are useful first and visually polished second. Prefer clear information hierarchy, truthful status, restrained color, and reusable rendering code over decoration.
+
+## Instruction priority
+
+Follow the user's explicit requirements and the repository's established conventions first. This skill supplies defaults where the user or project has not specified a choice. Do not migrate CLI frameworks, redesign unrelated code, or add dependencies without a concrete reason.
+
+## Workflow
+
+1. **Inspect before changing**
+   - Read the relevant entry point, CLI framework, `pyproject.toml`/requirements, supported Python version, and nearby tests.
+   - Identify whether stdout is intended for humans, scripts, or both.
+   - Preserve existing commands, flags, exit codes, output contracts, and business logic.
+2. **Choose the smallest useful design**
+   - Use `rich` for rendering. Keep the project's existing `argparse`, Typer, Click, or other CLI framework; Typer is optional, not a requirement.
+   - Avoid adding `questionary`, `loguru`, or other dependencies when Rich or the existing stack is sufficient.
+   - If Rich is missing, explain the dependency and add it through the repository's existing dependency mechanism. Do not silently run a global `pip install`.
+3. **Centralize presentation**
+   - Create one shared `Console` (or a small UI module) and a reusable semantic theme.
+   - Keep UI/rendering separate from domain logic. Prefer functions such as `render_summary`, `render_findings_table`, `show_status`, and `make_progress`.
+   - Use stable style names (`success`, `warning`, `error`, `info`, `muted`, `accent`) instead of scattering raw ANSI escapes or color literals.
+4. **Match the indicator to the work**
+   - Use a spinner/status for work whose completion percentage is unknown.
+   - Use a progress bar only when real progress can be measured (items, bytes, stages, or completed tasks).
+   - Use a live dashboard only when continuously changing information materially helps the operator.
+   - Never invent percentages, ETAs, throughput, completion counts, or scan results.
+5. **Handle every output environment**
+   - Detect TTY/terminal capability; do not force ANSI color or animation by default.
+   - Support `NO_COLOR`, redirected output, CI logs, SSH terminals, and narrow terminal widths.
+   - Keep machine-readable output (especially JSON) clean. Send human diagnostics/progress to stderr when stdout is a data stream.
+   - Provide a plain or no-color mode when appropriate.
+6. **Verify the result**
+   - Run focused tests and the project's formatter/linter/type checker where available.
+   - Test a normal terminal, redirected/non-TTY output, narrow width, errors, and empty results.
+   - Confirm that progress and live displays stop cleanly on success, failure, and cancellation.
+
+## Visual system
+
+Use a restrained, consistent palette with semantic meaning:
+
+| Role | Suggested style | Meaning |
+|---|---|---|
+| Success | `green` / `bold green` | Completed, valid, healthy |
+| Warning | `yellow` / `bold yellow` | Degraded, partial, needs attention |
+| Error | `red` / `bold red` | Failed, invalid, blocked |
+| Info | `cyan` | Neutral operational information |
+| Accent | `bright_magenta` or `bright_blue` | Product identity or emphasis |
+| Muted | `dim` | Secondary metadata |
+
+Color must never be the only signal. Pair it with words (`OK`, `WARN`, `FAIL`), symbols, or explicit columns. Avoid rainbow output, excessive bolding, and large banners on every command. Respect user-specified brand colors and existing themes.
+
+## Required UI patterns
+
+### Startup and command header
+- Show a compact application name/version only when it adds context.
+- Keep banners short; avoid delaying useful output with decorative animations.
+- Display target, scope, configuration, or execution mode only when relevant and safe to disclose.
+- Never print credentials, tokens, cookies, private keys, or other secrets.
+
+### Spinners and loading states
+- Use `console.status("Connecting…", spinner="dots")` for a short, indeterminate operation.
+- Choose a spinner that renders reliably in common terminals; allow Rich to fall back when Unicode is unavailable.
+- Use `console.status` as a context manager so it stops on exceptions.
+- Do not show a spinner for instant operations or when output is non-interactive.
+- For multiple independent tasks, prefer a multi-task `Progress` display over nested spinners.
+
+### Progress bars
+- Use `rich.progress.Progress` with columns that answer useful questions:
+  - `SpinnerColumn` or `TextColumn` for task identity
+  - `BarColumn` for visual completion
+  - `TaskProgressColumn` or `MofNCompleteColumn` for actual progress
+  - `TimeElapsedColumn` and `TimeRemainingColumn` only when meaningful
+  - `DownloadColumn` and `TransferSpeedColumn` for byte transfers
+- Track real units: files, hosts, requests, records, bytes, or completed stages.
+- For unknown totals, use an indeterminate task; do not display a fabricated total.
+- For concurrent work, use separate named tasks and synchronized updates. Avoid interleaved `print()` calls from workers.
+- Use `transient=True` only when the progress display should disappear after completion; keep important final results visible.
+- Disable animated progress when `not console.is_terminal`.
+
+### Tables
+- Use `rich.table.Table` for structured results. Give columns concise names and meaningful alignment.
+- Right-align numbers; left-align names and descriptions; use `no_wrap` selectively.
+- Use sensible overflow (`fold`, `ellipsis`, or `crop`) and let Rich adapt to terminal width.
+- Include a useful empty-state message instead of rendering a blank table.
+- Sort or group results when that improves scanning; do not hide important fields just to make the table look tidy.
+- For security findings, distinguish severity, confidence, status, and evidence; do not imply severity from color alone.
+
+### Panels, summaries, and hierarchy
+- Use `Panel` for a cohesive summary, alert, or grouped section—not around every line.
+- Use `Rule` for major section boundaries and `Columns`/`Group` for compact related content.
+- Put the most actionable information first. Keep secondary metadata dim and concise.
+- Prefer one strong summary panel plus detailed tables over many nested boxes.
+
+### Live output and dashboards
+- Use `Live` with `Layout`, `Table`, `Group`, or a custom renderable for dashboards that update repeatedly.
+- Keep refresh rates modest (typically 4–10 updates/second); slower is usually sufficient for CLI monitoring.
+- Use `screen=True` only for intentional full-screen terminal applications. Prefer `screen=False` for ordinary CLI progress.
+- Use `console.log()` for timestamped messages while a live display is active; do not call built-in `print()` and corrupt the live region.
+- Keep the dashboard readable at narrow widths and provide a final static summary when it exits.
+- Ensure `Live` is stopped via a context manager, including on exceptions and Ctrl-C.
+
+### Interactive prompts and user input
+- Use `Prompt.ask` for text input with defaults and validation.
+- Use `Prompt.ask(..., choices=[...])` for constrained choices instead of freeform parsing.
+- Use `Confirm.ask` for yes/no decisions.
+- Use `Prompt.ask(..., password=True)` for secrets and tokens; never echo secrets back to stdout.
+- Check `sys.stdin.isatty()` and provide safe non-interactive defaults for CI/CD or automated pipelines.
+
+### Tracebacks and error diagnostics
+- Use `rich.traceback.install(show_locals=False, max_frames=5)` at the CLI boundary for readable error reports.
+- Suppress framework frames (`click`, `typer`, `asyncio`) to focus on user code.
+- Only enable `show_locals=True` when explicitly requested via `--debug` or `--verbose`.
+- Prefer actionable summary panels for anticipated errors over raw stack traces.
+
+### Layouts and multi-pane TUIs
+- Use `rich.layout.Layout` to partition terminal windows into headers, sidebars, main bodies, and footers.
+- Combine with `rich.live.Live` for real-time monitoring and surveillance TUIs.
+- Default to `screen=False` so command history remains accessible in scrollback.
+- Design responsive layouts that remain clean down to 80x24 terminal dimensions.
+
+### Logs and errors
+- Use `RichHandler` when integrating Python `logging`; configure it once at the application boundary.
+- Keep logs concise and structured. Use timestamps/levels when they help diagnosis, not as decoration.
+- Present expected operational errors as short actionable messages; expose tracebacks only in debug mode.
+- Preserve non-zero exit codes and send diagnostics to stderr.
+- Never swallow exceptions merely to keep the interface attractive.
+
+### Themes and output modes
+- Define a `Theme` once and pass it to the shared `Console`.
+- Use `Console(no_color=True)` or an explicit `--no-color` option when the project supports it; otherwise rely on terminal detection and `NO_COLOR`.
+- When supporting `--json`, `--quiet`, or `--plain`, make these modes real contracts:
+  - `--json`: valid JSON only on stdout; no banner, spinner, table, or progress text on stdout.
+  - `--quiet`: suppress decorative and routine output while preserving errors and requested machine output.
+  - `--plain`: readable text without box drawing or ANSI styling.
+- Do not hardcode terminal width. Use Rich's layout/wrapping behavior and test narrow widths.
+
+## Code quality rules
+
+- Prefer Rich renderables over hand-built ANSI escape sequences.
+- Use `console.print`, `console.log`, `console.status`, `Progress`, `Live`, `Table`, `Panel`, `Columns`, `Tree`, `Syntax`, and `JSON` where they fit.
+- Avoid global monkey-patching, shelling out to `clear`, and repeated terminal erasure.
+- Do not couple core operations to Rich objects; return data from core logic and render it at the CLI boundary.
+- Do not add decorative output that makes copy/paste, piping, or log parsing harder.
+- Use context managers for progress, status, live displays, and other resources.
+- Make cancellation and failure paths as polished and reliable as the success path.
+
+## Definition of done
+
+- The output communicates state, progress, results, and errors accurately.
+- Spinners are used only for indeterminate work; progress bars reflect real measurements.
+- Tables and panels remain readable at typical and narrow terminal widths.
+- Live updates do not corrupt logs or final output.
+- Redirected, CI, `NO_COLOR`, and JSON output remain usable.
+- Existing CLI behavior and exit semantics are preserved.
+- Tests or a reproducible manual verification cover the relevant output paths.
+
+## Supporting references
+
+Read only the reference needed for the task:
+- `references/rich-components.md` — Rich APIs, columns, tables, themes, and renderables.
+- `references/interaction-patterns.md` — spinners, progress, live dashboards, async/concurrency patterns.
+- `references/prompts-and-inputs.md` — interactive prompts, validation, secrets, and non-TTY guards.
+- `references/tracebacks-and-debugging.md` — exception formatting, syntax highlighting, and introspection.
+- `references/layouts-and-tui.md` — multi-pane screen partitioning and dynamic TUIs.
+- `references/concurrent-progress.md` — thread-safe and async multi-task progress bars.
+- `references/testing-and-accessibility.md` — TTY behavior, JSON/plain output, accessibility, and tests.
+- `references/activation-tests.md` — positive and negative prompts for checking skill routing.
+- `examples/showcase.py` — comprehensive panels, tables, and progress showcase.
+- `examples/live_dashboard.py` — dynamic Live dashboard updating in real-time.
+- `examples/interactive_prompts.py` — prompts, input validation, confirmation, and secret masking.
+- `examples/concurrent_progress.py` — multi-threaded background workers with simultaneous progress bars.
+- `examples/tui_layout.py` — multi-pane terminal layout for system monitoring.

package/examples/concurrent_progress.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""Demonstration of multi-threaded concurrent workers with Rich progress bars."""
+
+from __future__ import annotations
+
+import argparse
+import concurrent.futures
+import random
+import time
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TaskProgressColumn,
+    TextColumn,
+    TimeRemainingColumn,
+)
+from rich.table import Table
+from rich.theme import Theme
+
+THEME = Theme(
+    {
+        "success": "bold green",
+        "warning": "bold yellow",
+        "error": "bold red",
+        "info": "cyan",
+        "muted": "dim",
+        "accent": "bold cyan",
+    }
+)
+
+console = Console(theme=THEME)
+
+
+def simulate_worker(progress: Progress, task_id: TaskID, name: str, total_chunks: int) -> tuple[str, bool, int]:
+    chunks_done = 0
+    for chunk in range(total_chunks):
+        time.sleep(random.uniform(0.02, 0.06))
+        chunks_done += 1
+        progress.advance(task_id, advance=1)
+        if chunk == total_chunks // 2:
+            progress.update(task_id, description=f"[info]{name}[/info] [muted](halfway)[/muted]")
+    progress.update(task_id, description=f"[success]{name}[/success] [muted](done)[/muted]")
+    return name, True, chunks_done
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Demonstrate concurrent multi-task progress.")
+    parser.add_argument("--workers", type=int, default=4, help="Number of concurrent workers")
+    args = parser.parse_args()
+
+    console.print(
+        Panel(
+            f"[accent]Concurrent Processing Engine[/accent]\n"
+            f"[muted]Dispatching {args.workers} background worker threads...[/muted]",
+            border_style="cyan",
+        )
+    )
+
+    results: list[tuple[str, bool, int]] = []
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(bar_width=None),
+        TaskProgressColumn(),
+        TimeRemainingColumn(),
+        console=console,
+    ) as progress:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=args.workers) as executor:
+            task_map = {}
+            for i in range(args.workers):
+                worker_name = f"Worker #{i + 1}"
+                steps = random.randint(15, 25)
+                task_id = progress.add_task(f"[accent]{worker_name}[/accent]", total=steps)
+                future = executor.submit(simulate_worker, progress, task_id, worker_name, steps)
+                task_map[future] = worker_name
+
+            for future in concurrent.futures.as_completed(task_map):
+                results.append(future.result())
+
+    # Final summary table
+    table = Table(title="Worker Execution Summary", expand=True)
+    table.add_column("Worker", style="bold")
+    table.add_column("Status", justify="center")
+    table.add_column("Processed Chunks", justify="right")
+
+    for name, success, chunks in sorted(results):
+        status_text = "[success]COMPLETED[/success]" if success else "[error]FAILED[/error]"
+        table.add_row(name, status_text, str(chunks))
+
+    console.print(table)
+
+
+if __name__ == "__main__":
+    main()

package/examples/interactive_prompts.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Demonstration of interactive prompts, validation, and confirmation dialogs."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, IntPrompt, Prompt
+from rich.theme import Theme
+
+THEME = Theme(
+    {
+        "success": "bold green",
+        "warning": "bold yellow",
+        "error": "bold red",
+        "info": "cyan",
+        "muted": "dim",
+        "accent": "bold bright_magenta",
+    }
+)
+
+console = Console(theme=THEME)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Demonstrate Rich interactive prompts.")
+    parser.add_argument("--non-interactive", action="store_true", help="Run with simulated answers")
+    args = parser.parse_args()
+
+    console.print(
+        Panel(
+            "[accent]CLI Configuration Wizard[/accent]\n"
+            "[muted]Demonstrates Prompt, Confirm, IntPrompt, and secret masking.[/muted]",
+            border_style="magenta",
+        )
+    )
+
+    if args.non_interactive or not sys.stdin.isatty():
+        console.print("[info]Running in non-interactive mode. Using defaults.[/info]")
+        project = "my-awesome-app"
+        env = "staging"
+        port = 8080
+        proceed = True
+    else:
+        project = Prompt.ask("[bold]Project Name[/bold]", default="my-awesome-app", console=console)
+        env = Prompt.ask(
+            "[bold]Environment[/bold]",
+            choices=["development", "staging", "production"],
+            default="staging",
+            console=console,
+        )
+        port = IntPrompt.ask("[bold]Service Port[/bold]", default=8080, console=console)
+        _token = Prompt.ask("[bold]API Token (masked)[/bold]", password=True, console=console)
+        proceed = Confirm.ask("\nSave configuration and initialize?", default=True, console=console)
+
+    if proceed:
+        console.print(
+            Panel(
+                f"[success]Configuration saved![/success]\n\n"
+                f"• Project: [accent]{project}[/accent]\n"
+                f"• Environment: [info]{env}[/info]\n"
+                f"• Port: [muted]{port}[/muted]",
+                title="[success]Summary[/success]",
+                border_style="green",
+            )
+        )
+    else:
+        console.print("[warning]Setup aborted by user.[/warning]")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        console.print("\n[error]Operation cancelled.[/error]")
+        sys.exit(130)

package/examples/live_dashboard.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""A small Live dashboard example with a durable final summary."""
+
+from __future__ import annotations
+
+import argparse
+import random
+import time
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+from rich.theme import Theme
+
+THEME = Theme(
+    {
+        "success": "bold green",
+        "warning": "bold yellow",
+        "error": "bold red",
+        "muted": "dim",
+        "accent": "bold cyan",
+    }
+)
+
+
+@dataclass
+class Worker:
+    name: str
+    completed: int = 0
+    total: int = 12
+    state: str = "RUNNING"
+
+
+def render(workers: list[Worker]) -> Table:
+    table = Table(title="Live worker dashboard", expand=True)
+    table.add_column("Worker", style="accent")
+    table.add_column("State")
+    table.add_column("Completed", justify="right")
+    table.add_column("Progress", ratio=1)
+
+    for worker in workers:
+        if worker.state == "DONE":
+            state = "[success]DONE[/success]"
+        else:
+            state = "[warning]RUNNING[/warning]"
+        table.add_row(
+            worker.name,
+            state,
+            f"{worker.completed}/{worker.total}",
+            f"{worker.completed / worker.total:.0%}",
+        )
+    return table
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Demonstrate a Rich live dashboard.")
+    parser.add_argument("--seconds", type=float, default=4.0)
+    args = parser.parse_args()
+
+    console = Console(theme=THEME)
+    workers = [Worker("worker-01"), Worker("worker-02"), Worker("worker-03")]
+
+    if not console.is_terminal:
+        console.print("Live dashboard disabled: stdout is not an interactive terminal.")
+        return 0
+
+    deadline = time.monotonic() + max(0.2, args.seconds)
+    with Live(render(workers), console=console, refresh_per_second=4, screen=False) as live:
+        while time.monotonic() < deadline and any(w.completed < w.total for w in workers):
+            for worker in workers:
+                if worker.completed < worker.total and random.random() > 0.35:
+                    worker.completed += 1
+                    if worker.completed == worker.total:
+                        worker.state = "DONE"
+            live.update(render(workers), refresh=True)
+            time.sleep(0.25)
+
+    console.print(render(workers))
+    console.print("[success]Dashboard stopped; final state retained.[/success]")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())