development-engine-vector 0.3.0__py3-none-any.whl

dev/__init__.py

@@ -0,0 +1,3 @@
+"""dev — Development Engine Vector."""
+
+__version__ = "0.3.0"

dev/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m dev` execution."""
+from dev.cli.cli import cli
+
+if __name__ == "__main__":
+    cli()

dev/cli/cli.py

@@ -0,0 +1,674 @@
+#!/usr/bin/env python3
+"""dev.cli.cli — thin click interface for the Development Engine Vector."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+
+from dev.kernel.config import DevConfig
+from dev.kernel.paths import ensure_dirs
+from dev.kernel.pmf_kernel import (
+    PMFKernel, PMFKernelError,
+    install_launchd, uninstall_launchd, plist_path,
+    wait_for_port_and_open_browser,
+)
+from dev.utils import green, header, error, info, success
+from dev.workflow.changelog import ChangelogManager
+from dev.workflow.preflight import PreflightChecks
+from dev.workflow.release import ReleaseOrchestrator
+from dev.workflow.versioning import VersionManager
+
+
+def resolve_project_dir(project):
+    if project:
+        return Path(project).resolve()
+    return Path.cwd().resolve()
+
+
+def load_config(ctx, project_dir):
+    config_path = ctx.obj.get("config") if ctx.obj else None
+    return DevConfig(project_dir, config_path)
+
+
+@click.group()
+@click.option("--config", type=click.Path(dir_okay=False, exists=True), default=None,
+              help="Path to a dev-cli TOML config file.")
+@click.version_option(package_name="development-engine-vector", prog_name="dev")
+@click.pass_context
+def cli(ctx, config):
+    """Developer workflow coordination CLI."""
+    ensure_dirs()
+    ctx.ensure_object(dict)
+    ctx.obj["config"] = config
+
+
+@cli.command("pf")
+@click.option("--project", default=".", help="Project root path")
+@click.option("--full", is_flag=True, help="Run the full set of preflight checks.")
+@click.option("--report", default=None, help="Write a JSON report to this file.")
+@click.pass_context
+def pf(ctx, project, full, report):
+    """Run release preflight checks for a project."""
+    project_dir = resolve_project_dir(project)
+    header(f"Preflight checks for {project_dir}")
+    checks = PreflightChecks(project_dir)
+    checks.run_all(full=full, report_path=report)
+
+
+@cli.command("preflight")
+@click.option("--project", default=".", help="Project root path")
+@click.option("--full", is_flag=True, help="Run the full set of preflight checks.")
+@click.option("--report", default=None, help="Write a JSON report to this file.")
+@click.pass_context
+def preflight(ctx, project, full, report):
+    """Alias for dev pf."""
+    ctx.invoke(pf, project=project, full=full, report=report)
+
+
+@cli.group()
+def version():
+    """Version management commands."""
+    pass
+
+
+@version.command("show")
+@click.option("--project", default=".", help="Project root path")
+def version_show(project):
+    """Show the current version."""
+    project_dir = resolve_project_dir(project)
+    vm = VersionManager(project_dir)
+    print(green(vm.read()))
+
+
+@version.command("bump")
+@click.option("--level", type=click.Choice(["major", "minor", "patch"]),
+              default="patch", show_default=True)
+@click.option("--project", default=".", help="Project root path")
+def version_bump(level, project):
+    """Bump the project version."""
+    project_dir = resolve_project_dir(project)
+    vm = VersionManager(project_dir)
+    old_version = vm.read()
+    new_version = vm.bump(level)
+    vm.write(new_version)
+    info(f"Bumped version {old_version} → {new_version}")
+
+
+@version.command("sync")
+@click.option("--project", default=".", help="Project root path")
+def version_sync(project):
+    """Sync version into project files."""
+    project_dir = resolve_project_dir(project)
+    vm = VersionManager(project_dir)
+    ver = vm.read()
+    targets = vm.get_sync_targets()
+    vm.sync_to_files(ver, targets)
+    success(f"Synced {ver} to project files.")
+
+
+@cli.command("build")
+@click.option("--project", default=".", help="Project root path")
+def build(project):
+    """Build source and wheel distributions for a project."""
+    project_dir = resolve_project_dir(project)
+    header(f"Build {project_dir}")
+    try:
+        subprocess.run(
+            ["python", "-m", "build", "--sdist", "--wheel"],
+            cwd=project_dir,
+            check=True,
+        )
+        success("Build complete.")
+    except subprocess.CalledProcessError as exc:
+        error(f"Build failed: {exc}")
+
+
+@cli.command("release")
+@click.option("--project", default=".", help="Project root path")
+@click.option("--bump", type=click.Choice(["major", "minor", "patch"]),
+              default=None, help="Version bump level")
+@click.option("--version", default=None, help="Custom version to release")
+@click.option("--skip-build/--no-skip-build", default=None, help="Skip or run build step")
+@click.option("--skip-publish/--no-skip-publish", default=None, help="Skip or run publish step")
+@click.option("--dry-run/--no-dry-run", default=None, help="Run release without committing or publishing")
+@click.pass_context
+def release(ctx, project, bump, version, skip_build, skip_publish, dry_run):
+    """Run the full release workflow."""
+    project_dir = resolve_project_dir(project)
+    config = load_config(ctx, project_dir)
+
+    bump = bump or config.get("release", "default_bump", "patch")
+    skip_build = skip_build if skip_build is not None else config.get_bool("release", "skip_build", False)
+    skip_publish = skip_publish if skip_publish is not None else config.get_bool("release", "skip_publish", False)
+    dry_run = dry_run if dry_run is not None else config.get_bool("release", "dry_run", False)
+
+    orch = ReleaseOrchestrator(project_dir)
+    orch.full_release(level=bump, version=version, skip_build=skip_build,
+                      skip_publish=skip_publish, dry_run=dry_run)
+
+
+@cli.command("sync")
+@click.option("--project", default=".", help="Project root path")
+@click.option("--install-editable/--no-install-editable", default=None,
+              help="Install or skip editable project install")
+@click.option("--install-dependencies/--no-install-dependencies", default=None,
+              help="Install or skip requirements.txt")
+@click.option("--install-dev/--no-install-dev", default=None,
+              help="Install or skip dev-requirements.txt")
+@click.pass_context
+def sync(ctx, project, install_editable, install_dependencies, install_dev):
+    """Bootstrap or sync project dependencies."""
+    project_dir = resolve_project_dir(project)
+    config = load_config(ctx, project_dir)
+
+    install_editable = install_editable if install_editable is not None else config.get_bool("bootstrap", "install_editable", True)
+    install_dependencies = install_dependencies if install_dependencies is not None else config.get_bool("bootstrap", "install_dependencies", True)
+    install_dev = install_dev if install_dev is not None else config.get_bool("bootstrap", "install_dev_dependencies", False)
+
+    orch = ReleaseOrchestrator(project_dir)
+    orch.bootstrap(install_editable=install_editable,
+                   install_dependencies=install_dependencies,
+                   install_dev_dependencies=install_dev)
+
+
+@cli.command("check")
+@click.option("--project", default=".", help="Project root path")
+@click.option("--compile/--no-compile", "compile_check", default=None,
+              help="Run or skip Python compile check")
+@click.option("--tests/--no-tests", default=None, help="Run or skip pytest")
+@click.option("--lint/--no-lint", default=None, help="Run or skip lint checks")
+@click.pass_context
+def check(ctx, project, compile_check, tests, lint):
+    """Run project health checks."""
+    project_dir = resolve_project_dir(project)
+    config = load_config(ctx, project_dir)
+
+    compile_check = compile_check if compile_check is not None else config.get_bool("check", "compile", True)
+    tests = tests if tests is not None else config.get_bool("check", "tests", False)
+    lint = lint if lint is not None else config.get_bool("check", "lint", False)
+
+    orch = ReleaseOrchestrator(project_dir)
+    orch.preflight()
+    if compile_check:
+        orch.run_compile()
+    if lint:
+        orch.run_lint()
+    if tests:
+        orch.run_tests()
+    success("Health checks complete")
+
+
+@cli.group()
+def config():
+    """Show or initialize dev-cli configuration."""
+    pass
+
+
+@config.command("show")
+@click.option("--project", default=".", help="Project root path")
+@click.pass_context
+def config_show(ctx, project):
+    """Show current config."""
+    project_dir = resolve_project_dir(project)
+    cfg = load_config(ctx, project_dir)
+
+    if cfg.config_path is None:
+        info("No dev-cli config found.")
+        return
+
+    info(f"Config file: {cfg.config_path}")
+    print(json.dumps(cfg.data, indent=2))
+
+
+@cli.command("workflow")
+@click.argument("name")
+@click.option("--project", default=".", help="Project root path")
+def workflow(name, project):
+    """Run a custom saved workflow."""
+    project_dir = resolve_project_dir(project)
+    known = {
+        "release": ["release"],
+        "build": ["build"],
+        "preflight": ["preflight"],
+        "bootstrap": ["sync"],
+        "check": ["check"],
+    }
+    if name not in known:
+        error(f"Unknown workflow: {name}")
+
+    command = [sys.executable, str(Path(__file__).resolve())] + known[name]
+    info(f"Running workflow: {name}")
+    subprocess.run(command, cwd=project_dir, check=True)
+
+
+@cli.command("changelog")
+@click.option("--project", default=".", help="Project root path")
+@click.option("--version", default=None, help="Version header to read")
+def changelog(project, version):
+    """Inspect changelog entries."""
+    project_dir = resolve_project_dir(project)
+    cm = ChangelogManager(project_dir)
+    if version:
+        entries = cm.extract_entries(version)
+        print(entries)
+    else:
+        print(cm.read())
+
+
+@cli.command("selfcheck")
+def selfcheck():
+    """Run engine selfcheck diagnostics."""
+    from dev.kernel.selfcheck import run_all
+    result = run_all()
+    for c in result["checks"]:
+        status = green("PASS") if c["passed"] else "\033[31mFAIL\033[0m"
+        print(f"  [{status}] {c['name']}: {c['message']}")
+        if c.get("details"):
+            print(f"         {c['details']}")
+    print()
+    print(f"  {result['passed']} passed, {result['failed']} failed")
+
+
+_kernel = PMFKernel()
+
+
+# ── helper ────────────────────────────────────────────────────────────────────
+
+
+def _bold(s):
+    return f"\033[1m{s}\033[0m"
+
+
+def _dim(s):
+    return f"\033[2m{s}\033[0m"
+
+
+def _yellow(s):
+    return f"\033[33m{s}\033[0m"
+
+
+def _red(s):
+    return f"\033[31m{s}\033[0m"
+
+
+def _hr():
+    return "─" * 52
+
+
+def _pmf_warn_if_not_installed():
+    if not plist_path().exists():
+        click.echo(_yellow("  ⚠  LaunchAgent not installed — run `dev pmf install` to auto-start on login."))
+
+
+# ── ui group ─────────────────────────────────────────────────────────────────
+
+@cli.group()
+def ui():
+    """Manage the embedded web UI (port 9001)."""
+    pass
+
+
+@ui.command("start")
+@click.option("--host", default="127.0.0.1", show_default=True, help="Host to bind")
+@click.option("--port", default=9001, show_default=True, help="Port for the web UI")
+@click.option("--no-browser", "no_browser", is_flag=True, default=False,
+              help="Don't open browser automatically")
+def ui_start(host, port, no_browser):
+    """Start the web UI via PMF."""
+    _pmf_warn_if_not_installed()
+    try:
+        result = _kernel.start_service("ui", options={"host": host, "port": port})
+        click.echo(green(f"  Started {result['label']}  pid={result['pid']}"))
+        if not no_browser:
+            url = f"http://{host}:{port}"
+            click.echo(_dim("  Opening browser when server is ready..."))
+            wait_for_port_and_open_browser(url, host, port)
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+@ui.command("stop")
+def ui_stop():
+    """Stop the web UI."""
+    try:
+        result = _kernel.stop_service("ui")
+        click.echo(green(f"  Stopped {result['label']}"))
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+@ui.command("status")
+def ui_status():
+    """Show web UI status."""
+    svc = _kernel.service_status("ui")
+    status_str = green(svc["status"]) if svc["status"] == "running" else _yellow(svc["status"])
+    click.echo()
+    click.echo(_bold(f"  {svc['label']}"))
+    click.echo(f"  Status:  {status_str}")
+    click.echo(f"  PID:     {svc['pid'] or '—'}")
+    click.echo(f"  Started: {svc['started_at'] or '—'}")
+    click.echo(f"  Log:     {svc['log_file'] or '—'}")
+    click.echo()
+
+
+@ui.command("restart")
+@click.option("--host", default="127.0.0.1", show_default=True)
+@click.option("--port", default=9001, show_default=True)
+@click.option("--no-browser", "no_browser", is_flag=True, default=False)
+def ui_restart(host, port, no_browser):
+    """Restart the web UI."""
+    try:
+        result = _kernel.restart_service("ui", options={"host": host, "port": port})
+        click.echo(green(f"  Restarted {result['label']}  pid={result['pid']}"))
+        if not no_browser:
+            url = f"http://{host}:{port}"
+            click.echo(_dim("  Opening browser when server is ready..."))
+            wait_for_port_and_open_browser(url, host, port)
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+# ── pmf group ─────────────────────────────────────────────────────────────────
+
+@cli.group()
+def pmf():
+    """Manage the embedded PMF kernel and dev services."""
+    pass
+
+
+@pmf.command("services")
+def pmf_services():
+    """List PMF services and runtime status."""
+    rows = _kernel.services()
+    click.echo()
+    click.echo(_bold("  PMF Runtime Services"))
+    click.echo(_hr())
+    for svc in rows:
+        status_str = green(svc["status"]) if svc["status"] == "running" else _yellow(svc["status"])
+        click.echo(f"  {_bold(svc['label']):<20} {status_str:<10} pid={svc['pid'] or '—'}")
+        click.echo(f"      {svc['description']}")
+    click.echo()
+
+
+@pmf.command("status")
+@click.argument("service_id", required=False)
+def pmf_status(service_id):
+    """Show PMF runtime status for one or all services."""
+    if service_id:
+        try:
+            svc = _kernel.service_status(service_id)
+            click.echo()
+            click.echo(_bold(f"  {svc['label']}"))
+            click.echo(f"  Status:  {svc['status']}")
+            click.echo(f"  PID:     {svc['pid'] or '—'}")
+            click.echo(f"  Started: {svc['started_at'] or '—'}")
+            click.echo(f"  Log:     {svc['log_file'] or '—'}")
+            click.echo()
+        except PMFKernelError as exc:
+            click.echo(_red(f"  {exc}"))
+    else:
+        ctx = click.get_current_context()
+        ctx.invoke(pmf_services)
+
+
+@pmf.command("start")
+@click.argument("service_id")
+@click.option("--host", default="127.0.0.1", help="Host override for UI service")
+@click.option("--port", default=9001, help="Port override for UI service")
+@click.option("--no-browser", "no_browser", is_flag=True, default=False)
+def pmf_start(service_id, host, port, no_browser):
+    """Start a PMF-managed service."""
+    options = {"host": host, "port": port} if service_id == "ui" else None
+    try:
+        result = _kernel.start_service(service_id, options=options)
+        click.echo(green(f"  Started {result['label']}  pid={result['pid']}"))
+        if service_id == "ui" and not no_browser:
+            url = f"http://{host}:{port}"
+            click.echo(_dim("  Opening browser when server is ready..."))
+            wait_for_port_and_open_browser(url, host, port)
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+@pmf.command("stop")
+@click.argument("service_id")
+def pmf_stop(service_id):
+    """Stop a PMF-managed service."""
+    try:
+        result = _kernel.stop_service(service_id)
+        click.echo(green(f"  Stopped {result['label']}"))
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+@pmf.command("restart")
+@click.argument("service_id")
+def pmf_restart(service_id):
+    """Restart a PMF-managed service."""
+    try:
+        result = _kernel.restart_service(service_id)
+        click.echo(green(f"  Restarted {result['label']}  pid={result['pid']}"))
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+@pmf.command("logs")
+@click.argument("service_id")
+@click.option("--tail", default=50, show_default=True, help="Lines to tail")
+def pmf_logs(service_id, tail):
+    """Display the last lines from a PMF service log."""
+    try:
+        output = _kernel.tail_log(service_id, lines=tail)
+        click.echo(output)
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+
+
+@pmf.command("up")
+@click.option("--host", default="127.0.0.1", show_default=True)
+@click.option("--port", default=9001, show_default=True)
+@click.option("--no-browser", "no_browser", is_flag=True, default=False)
+def pmf_up(host, port, no_browser):
+    """Start all dev services (web UI). Called automatically by launchd on login."""
+    url = f"http://{host}:{port}"
+    click.echo(_bold("  Development Engine Vector — starting services"))
+    click.echo(_hr())
+
+    try:
+        result = _kernel.start_service("ui", options={"host": host, "port": port})
+        click.echo(green(f"  Web UI       started  pid={result['pid']}  →  {url}"))
+        if not no_browser:
+            click.echo(_dim("  Opening browser when server is ready..."))
+            wait_for_port_and_open_browser(url, host, port)
+    except PMFKernelError as exc:
+        click.echo(_yellow(f"  Web UI       {exc}"))
+
+    click.echo()
+
+
+@pmf.command("install")
+def pmf_install():
+    """Install dev as a macOS launchd LaunchAgent (auto-start on login)."""
+    from dev.kernel.paths import DEV_HOME as _dev_home
+    click.echo()
+    click.echo(_bold("  Installing dev LaunchAgent"))
+    click.echo(_hr())
+    try:
+        target = install_launchd(_dev_home)
+        click.echo(green(f"  Plist:   {target}"))
+        click.echo(green("  Label:   com.gocosmix.dev"))
+        click.echo(green("  Loaded:  yes — dev will start automatically on next login"))
+        click.echo()
+        click.echo(_dim("  To start services now without logging out:"))
+        click.echo(_dim("    dev pmf up"))
+        click.echo()
+    except PMFKernelError as exc:
+        click.echo(_red(f"  {exc}"))
+        click.echo(_yellow("  Make sure `dev` is on PATH: export PATH=\"$HOME/Library/Python/3.9/bin:$PATH\""))
+        click.echo()
+
+
+@pmf.command("uninstall")
+def pmf_uninstall():
+    """Remove the dev launchd LaunchAgent."""
+    target = plist_path()
+    if not target.exists():
+        click.echo(_yellow("  No LaunchAgent plist found — nothing to uninstall."))
+        return
+    uninstall_launchd()
+    click.echo(green(f"  Removed: {target}"))
+    click.echo(green("  dev will no longer start automatically on login."))
+
+
+# ── setup ─────────────────────────────────────────────────────────────────────
+
+@cli.command("setup")
+@click.option("--no-browser", "no_browser", is_flag=True, default=False,
+              help="Don't open browser when the web UI starts")
+def setup(no_browser):
+    """
+    Full onboarding in three steps: init → pmf install → up.
+
+    \b
+    Run this once after `pip install dev-cli`.
+    If `dev` isn't on PATH yet, use the fallback:
+
+        python3 -m dev setup
+
+    \b
+    What each step does:
+      1. Init    — create ~/Library/goCosmix/tools/dev/, patch PATH
+      2. Install — register a macOS LaunchAgent so dev starts on every login
+      3. Up      — start the web UI via PMF, open browser
+
+    All processes are managed by the PMF kernel. The LaunchAgent calls
+    `dev pmf up` on every login — no manual interaction needed after setup.
+    """
+    import os as _os
+    import shutil as _shutil
+    from dev.kernel.paths import (
+        DEV_HOME, DATA_DIR, RUN_DIR, LOG_DIR,
+        CONFIG_DIR, PMF_DIR, PMF_LOG_DIR,
+        GOCOSMIX_HOME, GOCOSMIX_APPS, GOCOSMIX_TOOLS, GOCOSMIX_SYSTEM,
+    )
+
+    W = 52
+    BAR = "═" * W
+    bar = "─" * W
+    host, port = "127.0.0.1", 9001
+    url = f"http://{host}:{port}"
+
+    click.echo()
+    click.echo(_bold(BAR))
+    click.echo(_bold("  Development Engine Vector — setup"))
+    click.echo(_bold(BAR))
+    click.echo()
+    click.echo(_dim("  Three steps to a fully operational dev installation:"))
+    click.echo(_dim(f"    1. Init    — create {DEV_HOME}"))
+    click.echo(_dim("    2. Install — register macOS LaunchAgent (auto-start on login)"))
+    click.echo(_dim("    3. Up      — start web UI via PMF, open browser"))
+    click.echo()
+
+    # ── Step 1: Init ─────────────────────────────────────────────
+    click.echo(_bold(bar))
+    click.echo(_bold("  Step 1/3 — Init"))
+    click.echo(_bold(bar))
+    click.echo()
+
+    dirs = [GOCOSMIX_HOME, GOCOSMIX_APPS, GOCOSMIX_TOOLS, GOCOSMIX_SYSTEM,
+            DATA_DIR, RUN_DIR, LOG_DIR, CONFIG_DIR, PMF_DIR, PMF_LOG_DIR]
+    for d in dirs:
+        existed = d.exists()
+        d.mkdir(parents=True, exist_ok=True)
+        marker = green("✓") if existed else green("+")
+        click.echo(f"    {marker}  {d}")
+
+    click.echo()
+    click.echo(f"    {green('✓')}  DEV_HOME: {DEV_HOME}")
+    click.echo()
+
+    # PATH patch
+    dev_bin = _shutil.which("dev")
+    dev_bin_dir = None
+    if dev_bin:
+        dev_bin_dir = str(Path(dev_bin).parent)
+    else:
+        py_bin_dir = Path(sys.executable).parent
+        candidate = py_bin_dir / "dev"
+        if candidate.exists():
+            dev_bin_dir = str(py_bin_dir)
+
+    if dev_bin_dir and dev_bin_dir not in _os.environ.get("PATH", "").split(":"):
+        export_line = f'export PATH="{dev_bin_dir}:$PATH"'
+        zprofile = Path.home() / ".zprofile"
+        existing = zprofile.read_text() if zprofile.exists() else ""
+        if export_line not in existing:
+            with open(zprofile, "a") as f:
+                f.write(f"\n# goCosmix — added by dev setup\n{export_line}\n")
+            click.echo(f"    {green('+')}  PATH updated in ~/.zprofile")
+            click.echo(_yellow("         Run `source ~/.zprofile` or open a new terminal to activate."))
+        click.echo(f"    {green('✓')}  dev binary: {dev_bin_dir}/dev")
+    elif dev_bin:
+        click.echo(f"    {green('✓')}  dev binary on PATH: {dev_bin}")
+
+    click.echo()
+
+    # ── Step 2: PMF install ──────────────────────────────────────
+    click.echo(_bold(bar))
+    click.echo(_bold("  Step 2/3 — PMF install"))
+    click.echo(_bold(bar))
+    click.echo()
+    click.echo(_dim("  The LaunchAgent registers dev with macOS launchd. On every login,"))
+    click.echo(_dim("  launchd calls `dev pmf up` — starts the web UI via PMF kernel."))
+    click.echo(_dim("  No terminal required after this."))
+    click.echo()
+
+    pmf_ok = False
+    try:
+        target = install_launchd(DEV_HOME)
+        click.echo(f"    {green('✓')}  LaunchAgent: {target}")
+        click.echo(f"    {green('✓')}  Loaded — dev starts automatically on every login")
+        pmf_ok = True
+    except PMFKernelError as exc:
+        click.echo(f"    {_yellow('⚠')}  LaunchAgent registration failed: {exc}")
+        click.echo(_yellow("         Fix PATH then run `dev pmf install` to retry."))
+    click.echo()
+
+    # ── Step 3: Up ───────────────────────────────────────────────
+    click.echo(_bold(bar))
+    click.echo(_bold("  Step 3/3 — Up"))
+    click.echo(_bold(bar))
+    click.echo()
+    click.echo(_dim(f"  Starting web UI on {url}"))
+    click.echo()
+
+    try:
+        result = _kernel.start_service("ui", options={"host": host, "port": port})
+        click.echo(f"    {green('✓')}  Web UI started  pid={result['pid']}  →  {url}")
+        if not no_browser:
+            click.echo(_dim("  Opening browser when server is ready..."))
+            wait_for_port_and_open_browser(url, host, port)
+    except PMFKernelError as exc:
+        click.echo(f"    {_yellow('⚠')}  Web UI: {exc}")
+        click.echo(_dim("         Try `dev ui start` once PMF is installed."))
+
+    click.echo()
+    click.echo(_bold(BAR))
+    click.echo(_bold("  Setup complete"))
+    click.echo(_bold(BAR))
+    click.echo()
+    if pmf_ok:
+        click.echo(_dim("  dev will start automatically on your next login."))
+    click.echo(_dim(f"  Dashboard: {url}"))
+    click.echo()
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()