meridian-cli 0.0.25__py3-none-any.whl

meridian/__init__.py

@@ -0,0 +1,5 @@
+"""Meridian package root."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.0.25"

meridian/__main__.py

@@ -0,0 +1,6 @@
+"""python -m meridian entry point."""
+
+from meridian.cli.main import main
+
+if __name__ == "__main__":
+    main()

meridian/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI package for meridian."""
+
+from meridian.cli.main import app, main
+
+__all__ = ["app", "main"]

meridian/cli/app_cmd.py

@@ -0,0 +1,48 @@
+"""CLI command for the meridian app web UI server."""
+
+from __future__ import annotations
+
+import importlib
+import threading
+import time
+import webbrowser
+
+
+def run_app(
+    port: int = 8420,
+    no_browser: bool = False,
+    host: str = "127.0.0.1",
+) -> None:
+    """Start the Meridian app server."""
+
+    try:
+        importlib.import_module("fastapi")
+        uvicorn_module = importlib.import_module("uvicorn")
+    except ModuleNotFoundError:
+        print("Missing app dependencies. Install with: uv sync --extra app")
+        raise SystemExit(1) from None
+
+    from meridian.lib.app.server import create_app
+    from meridian.lib.ops.runtime import resolve_runtime_root_and_config, resolve_state_root
+    from meridian.lib.streaming.spawn_manager import SpawnManager
+
+    repo_root, _ = resolve_runtime_root_and_config(None)
+    state_root = resolve_state_root(repo_root)
+
+    manager = SpawnManager(state_root=state_root, repo_root=repo_root)
+    app = create_app(manager)
+
+    if not no_browser:
+        url = f"http://{host}:{port}"
+
+        def _open_browser() -> None:
+            time.sleep(1.5)
+            webbrowser.open(url)
+
+        threading.Thread(target=_open_browser, daemon=True).start()
+
+    print(f"Starting meridian app at http://{host}:{port}")
+    uvicorn_module.run(app, host=host, port=port, log_level="info")
+
+
+__all__ = ["run_app"]

meridian/cli/config_cmd.py

@@ -0,0 +1,41 @@
+"""CLI command handlers for config.* operations."""
+
+from collections.abc import Callable
+from functools import partial
+from typing import Any
+
+from cyclopts import App
+
+from meridian.cli.registration import register_manifest_cli_group
+from meridian.lib.ops.config import (
+    ConfigGetInput,
+    ConfigResetInput,
+    ConfigSetInput,
+    config_get_sync,
+    config_reset_sync,
+    config_set_sync,
+)
+
+Emitter = Callable[[Any], None]
+
+
+def _config_set(emit: Emitter, key: str, value: str) -> None:
+    emit(config_set_sync(ConfigSetInput(key=key, value=value)))
+
+
+def _config_get(emit: Emitter, key: str) -> None:
+    emit(config_get_sync(ConfigGetInput(key=key)))
+
+
+def _config_reset(emit: Emitter, key: str) -> None:
+    emit(config_reset_sync(ConfigResetInput(key=key)))
+
+
+def register_config_commands(app: App, emit: Emitter) -> tuple[set[str], dict[str, str]]:
+    handlers: dict[str, Callable[[], Callable[..., None]]] = {
+        # config.init and config.show are auto-generated (no required CLI args).
+        "config.set": lambda: partial(_config_set, emit),
+        "config.get": lambda: partial(_config_get, emit),
+        "config.reset": lambda: partial(_config_reset, emit),
+    }
+    return register_manifest_cli_group(app, group="config", handlers=handlers, emit=emit)

meridian/cli/doctor_cmd.py

@@ -0,0 +1,34 @@
+"""CLI command handler for standalone doctor operation."""
+
+from collections.abc import Callable
+from typing import Any
+
+from cyclopts import App
+
+from meridian.cli.registration import register_manifest_cli_group
+
+Emitter = Callable[[Any], None]
+
+
+def register_doctor_command(app: App, emit: Emitter) -> tuple[set[str], dict[str, str]]:
+    # doctor has no required CLI args — handler is auto-generated.
+    return register_manifest_cli_group(
+        app,
+        group="doctor",
+        command_help_epilogues={
+            "doctor": (
+                "Health check and auto-repair for meridian state.\n\n"
+                "Reconciles orphaned spawns (dead PIDs, stale heartbeats, missing\n"
+                "spawn directories), cleans stale session locks, and warns about\n"
+                "missing or malformed configuration.\n\n"
+                "Doctor is idempotent - re-running converges on the same result.\n"
+                "It is safe (and intended) to run after a crash, after a force-kill,\n"
+                "or any time `meridian spawn show` reports a status that doesn't match\n"
+                "reality.\n\n"
+                "Examples:\n\n"
+                "  meridian doctor                  # check and repair, JSON output\n\n"
+                "  meridian doctor --format text    # human-readable summary\n"
+            )
+        },
+        emit=emit,
+    )

meridian/cli/format_helpers.py

@@ -0,0 +1,35 @@
+"""Shared text formatting primitives for CLI output.
+
+Centralizes column alignment and key-value rendering so that all
+format_text() implementations produce consistent output.
+"""
+
+
+def tabular(rows: list[list[str]], sep: str = "  ") -> str:
+    """Align columns by max width per column.
+
+    >>> tabular([["r1", "done", "5.0s"], ["r20", "failed", "21.6s"]])
+    'r1   done    5.0s\\nr20  failed  21.6s'
+    """
+    if not rows:
+        return ""
+    col_count = max(len(row) for row in rows)
+    col_widths = [
+        max((len(row[col]) if col < len(row) else 0) for row in rows) for col in range(col_count)
+    ]
+    lines: list[str] = []
+    for row in rows:
+        cells = [
+            (row[col] if col < len(row) else "").ljust(col_widths[col]) for col in range(col_count)
+        ]
+        lines.append(sep.join(cells).rstrip())
+    return "\n".join(lines)
+
+
+def kv_block(pairs: list[tuple[str, str | None]]) -> str:
+    """Render key: value pairs, skipping None values.
+
+    >>> kv_block([("Spawn", "r1"), ("Status", "done"), ("Cost", None)])
+    'Spawn: r1\\nStatus: done'
+    """
+    return "\n".join(f"{k}: {v}" for k, v in pairs if v is not None)