dh-cli 0.5.1__tar.gz → 0.5.2__tar.gz

{dh_cli-0.5.1 → dh_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dh-cli
-Version: 0.5.1
+Version: 0.5.2
 Summary: Dayhoff Labs developer CLI
 Author-email: Dayhoff Labs <dev@dayhofflabs.com>
 License: # PolyForm Noncommercial License 1.0.0

{dh_cli-0.5.1 → dh_cli-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dh-cli"
-version = "0.5.1"
+version = "0.5.2"
 description = "Dayhoff Labs developer CLI"
 requires-python = ">=3.11"
 readme = "README.md"

{dh_cli-0.5.1 → dh_cli-0.5.2}/src/dh_cli/engines_studios/engine_commands.py

@@ -547,126 +547,113 @@ def list_engines(env: Optional[str]):
             click.echo("No engines found\n")
             return
 
-        # Calculate dynamic width for Name column (longest name + 2 for padding)
-        max_name_len = max((len(engine.get("name", "unknown")) for engine in engines), default=4)
-        name_width = max(max_name_len + 2, len("Name") + 2)
-
-        # Fixed widths for other columns
-        state_width = 12
-        user_width = 12
-        type_width = 12
-        disk_width = 6
-        uptime_width = 8
-
-        # Table top border
-        click.echo(
-            "╭"
-            + "─" * (name_width + 1)
-            + "┬"
-            + "─" * (uptime_width + 1)
-            + "┬"
-            + "─" * (state_width + 1)
-            + "┬"
-            + "─" * (user_width + 1)
-            + "┬"
-            + "─" * (type_width + 1)
-            + "┬"
-            + "─" * (disk_width + 1)
-            + "╮"
-        )
+        # Sort: running engines first (alphabetical), then the rest (alphabetical)
+        def sort_key(e):
+            is_running = 0 if e.get("state") == "running" else 1
+            return (is_running, e.get("name", "").lower())
 
-        # Table header
-        click.echo(
-            f"│ {'Name':<{name_width}}│ {'Uptime':>{uptime_width}}│ {'State':<{state_width}}│ {'User':<{user_width}}│ {'Type':<{type_width}}│ {'Disk':>{disk_width}}│"
-        )
+        engines.sort(key=sort_key)
 
-        # Header separator
-        click.echo(
-            "├"
-            + "─" * (name_width + 1)
-            + "┼"
-            + "─" * (uptime_width + 1)
-            + "┼"
-            + "─" * (state_width + 1)
-            + "┼"
-            + "─" * (user_width + 1)
-            + "┼"
-            + "─" * (type_width + 1)
-            + "┼"
-            + "─" * (disk_width + 1)
-            + "┤"
-        )
+        # Pre-compute uptime text and uptime_seconds for each engine
+        from datetime import datetime
 
-        # Table rows
+        uptime_data = []
         for engine in engines:
-            name = engine.get("name", "unknown")
             state = engine.get("state", "unknown")
-            user = engine.get("user", "unknown")
-            engine_type = engine.get("engine_type", "unknown")
+            launch_time = engine.get("launch_time")
+            if state == "running" and launch_time:
+                text = format_time_ago(launch_time).removesuffix(" ago")
+                try:
+                    dt = datetime.fromisoformat(launch_time.replace("Z", "+00:00"))
+                    secs = (datetime.now(dt.tzinfo) - dt).total_seconds()
+                except Exception:
+                    secs = 0
+            else:
+                text = "-"
+                secs = 0
+            uptime_data.append((text, secs))
 
-            # Truncate if needed
-            if len(name) > name_width - 1:
-                name = name[: name_width - 1]
-            if len(user) > user_width - 1:
-                user = user[: user_width - 1]
-            if len(engine_type) > type_width - 1:
-                engine_type = engine_type[: type_width - 1]
+        # Pre-compute disk text for each engine
+        disk_data = []
+        for engine in engines:
+            pct = engine.get("boot_disk_usage_pct")
+            disk_data.append(f"{pct}%" if pct is not None else "-")
+
+        # Dynamic column widths: fit the longest value or header, plus padding
+        def col_width(header, values):
+            longest = max((len(v) for v in values), default=0)
+            return max(longest, len(header)) + 1
+
+        names = [engine.get("name", "unknown") for engine in engines]
+        states = [engine.get("state", "unknown") for engine in engines]
+        users = [engine.get("user", "unknown") for engine in engines]
+        types = [engine.get("engine_type", "unknown") for engine in engines]
+        uptimes = [ud[0] for ud in uptime_data]
+        disks = [d for d in disk_data]
+
+        nw = col_width("Name", names)
+        sw = col_width("State", states)
+        uw = col_width("User", users)
+        tw = col_width("Type", types)
+        utw = col_width("Uptime", uptimes)
+        dw = col_width("Disk", disks)
+
+        cols = [nw, sw, uw, tw, utw, dw]
+        headers = ["Name", "State", "User", "Type", "Uptime", "Disk"]
+        aligns = ["<", "<", "<", "<", ">", ">"]
+
+        def border(left, mid, right):
+            return left + mid.join("─" * (w + 1) for w in cols) + right
+
+        click.echo(border("╭", "┬", "╮"))
+        click.echo(
+            "│"
+            + "│".join(f" {h:{a}{w}}" for h, a, w in zip(headers, aligns, cols))
+            + "│"
+        )
+        click.echo(border("├", "┼", "┤"))
+
+        for i, engine in enumerate(engines):
+            name = names[i]
+            state = states[i]
+            user = users[i]
+            etype = types[i]
+            uptime_text, uptime_secs = uptime_data[i]
+            disk_text = disk_data[i]
 
-            # Color the name (blue)
-            name_display = f"\033[34m{name:<{name_width}}\033[0m"
+            name_d = f"\033[34m{name:<{nw}}\033[0m"
 
-            # Color the state
             if state == "running":
-                state_display = f"\033[32m{state:<{state_width}}\033[0m"  # Green
-            elif state in ["starting", "stopping", "pending"]:
-                state_display = f"\033[33m{state:<{state_width}}\033[0m"  # Yellow
+                state_d = f"\033[32m{state:<{sw}}\033[0m"
+            elif state in ("starting", "stopping", "pending"):
+                state_d = f"\033[33m{state:<{sw}}\033[0m"
             elif state == "stopped":
-                state_display = f"\033[90m{state:<{state_width}}\033[0m"  # Grey (dim)
+                state_d = f"\033[90m{state:<{sw}}\033[0m"
             else:
-                state_display = f"{state:<{state_width}}"  # No color for other states
+                state_d = f"{state:<{sw}}"
 
-            # Compute uptime for running engines from launch_time
-            launch_time = engine.get("launch_time")
-            if state == "running" and launch_time:
-                uptime_text = format_time_ago(launch_time).removesuffix(" ago")
-                uptime_display = f"\033[32m{uptime_text:>{uptime_width}}\033[0m"
+            if uptime_text == "-":
+                uptime_d = f"\033[90m{uptime_text:>{utw}}\033[0m"
+            elif uptime_secs >= 86400:
+                uptime_d = f"\033[33m{uptime_text:>{utw}}\033[0m"
             else:
-                uptime_display = f"\033[90m{'-':>{uptime_width}}\033[0m"
-
-            # Color the disk usage
-            usage_pct = engine.get("boot_disk_usage_pct")
-            if usage_pct is not None:
-                disk_text = f"{usage_pct}%"
-                if usage_pct >= 90:
-                    disk_display = f"\033[31m{disk_text:>{disk_width}}\033[0m"
-                elif usage_pct >= 70:
-                    disk_display = f"\033[33m{disk_text:>{disk_width}}\033[0m"
-                else:
-                    disk_display = f"\033[32m{disk_text:>{disk_width}}\033[0m"
+                uptime_d = f"\033[32m{uptime_text:>{utw}}\033[0m"
+
+            pct = engine.get("boot_disk_usage_pct")
+            if disk_text == "-":
+                disk_d = f"\033[90m{disk_text:>{dw}}\033[0m"
+            elif pct >= 90:
+                disk_d = f"\033[31m{disk_text:>{dw}}\033[0m"
+            elif pct >= 70:
+                disk_d = f"\033[33m{disk_text:>{dw}}\033[0m"
             else:
-                disk_display = f"\033[90m{'-':>{disk_width}}\033[0m"
+                disk_d = f"\033[32m{disk_text:>{dw}}\033[0m"
 
             click.echo(
-                f"│ {name_display}│ {uptime_display}│ {state_display}│ {user:<{user_width}}│ {engine_type:<{type_width}}│ {disk_display}│"
+                f"│ {name_d}│ {state_d}│ {user:<{uw}}│ {etype:<{tw}}│ {uptime_d}│ {disk_d}│"
             )
 
-        # Table bottom border
-        click.echo(
-            "╰"
-            + "─" * (name_width + 1)
-            + "┴"
-            + "─" * (uptime_width + 1)
-            + "┴"
-            + "─" * (state_width + 1)
-            + "┴"
-            + "─" * (user_width + 1)
-            + "┴"
-            + "─" * (type_width + 1)
-            + "┴"
-            + "─" * (disk_width + 1)
-            + "╯"
-        )
-
+        click.echo(border("╰", "┴", "╯"))
         click.echo(f"Total: {len(engines)}\n")
 
     except Exception as e: