"""Doctor output primitives shared by every ``hermes_cli.doctor_*`` module.""" from __future__ import annotations import functools from contextlib import contextmanager from dataclasses import dataclass, field from hermes_cli.colors import Colors, color def _mark(glyph: str, col: str): return lambda text, detail="": print(f" {color(glyph, col)} {text}" + (f" {color(detail, Colors.DIM)}" if detail else "")) check_ok, check_warn, check_fail = _mark("✓", Colors.GREEN), _mark("⚠", Colors.YELLOW), _mark("✗", Colors.RED) def check_info(text: str): print(f" {color('→', Colors.CYAN)} {text}") def check_bool(cond, ok, bad, *, fail: bool = False): """``check_ok(*ok)`` when *cond* else ``check_warn(*bad)`` (``check_fail`` with fail=True); returns bool(cond). *ok* / *bad* are a text string or a ``(text, detail)`` tuple.""" args = ok if cond else bad (check_ok if cond else (check_fail if fail else check_warn))(*((args,) if isinstance(args, str) else args)) return bool(cond) def _section(title: str) -> None: """Print a doctor section banner: blank line + bold cyan ◆ title.""" print() print(color(f"◆ {title}", Colors.CYAN, Colors.BOLD)) def _fail_and_issue(text: str, detail: str, fix: str, issues: list[str]) -> None: """Emit a check_fail and append the corresponding fix instruction.""" check_fail(text, detail) issues.append(fix) @contextmanager def warn_on_error(text: str, detail: str = "({e})", report=check_warn): """Best-effort block: an exception prints ``report(text.format(e=e), detail.format(e=e))`` (nothing when *text* is ``""``) instead of propagating. ``{e}`` in either string is the exception.""" try: yield except Exception as e: if text: report(text.format(e=e), detail.format(e=e)) @dataclass class Finding: """What one doctor check contributed: auto-fixable issues, manual-only issues, fixes applied.""" issues: list = field(default_factory=list) manual_issues: list = field(default_factory=list) fixed: int = 0 def merge(self, other: Finding) -> None: self.issues.extend(other.issues) self.manual_issues.extend(other.manual_issues) self.fixed += other.fixed def doctor_check(on_error: str | None = None, detail: str = ""): """Turn ``fn(should_fix, f: Finding)`` into a ``(should_fix) -> Finding`` doctor check. *on_error* None: exceptions propagate (as they always did for that check). Otherwise the check is best-effort via :func:`warn_on_error` (``""`` = silent) and the partial Finding is still returned, so issues recorded before the crash survive.""" def deco(fn): @functools.wraps(fn) def check(should_fix: bool) -> Finding: f = Finding() if on_error is None: fn(should_fix, f) else: with warn_on_error(on_error, detail): fn(should_fix, f) return f return check return deco def ensure_dir(f: Finding, should_fix: bool, path, exists_msg: str, created_msg: str, missing_msg: str) -> None: """ok when *path* exists; with --fix create it (counts as fixed); else warn "(will be created on first use)".""" if path.exists(): check_ok(exists_msg) elif should_fix: path.mkdir(parents=True, exist_ok=True) check_ok(created_msg) f.fixed += 1 else: check_warn(missing_msg, "(will be created on first use)")