| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380 |
- """``hermes journey`` — what Hermes has learned, on a timeline."""
- from __future__ import annotations
- import argparse
- import shutil
- import sys
- import time
- from functools import lru_cache
- from typing import Any, Optional
- _TITLE_COLOR = "#E8C463"
- _CHARTED_SIGNAL_MIN_CONTRAST = 4.5
- def _build_payload() -> dict[str, Any]:
- from agent.learning_graph import build_learning_graph
- return build_learning_graph()
- @lru_cache(maxsize=1)
- def _primary_hex() -> str:
- """The active skin's primary color (mirrors the TUI theme primary)."""
- try:
- from hermes_cli.skin_engine import get_active_skin
- skin = get_active_skin()
- return skin.get_color("ui_primary", "") or skin.get_color("banner_title", "#FFD700")
- except Exception:
- return "#FFD700"
- @lru_cache(maxsize=1)
- def _palette() -> dict[str, str]:
- from agent.learning_graph_render import derive_palette
- return derive_palette(_primary_hex(), dark=True)
- def _fade(base: Optional[str], alpha: float) -> Optional[str]:
- from agent.learning_graph_render import hex_to_rgb, mix_rgb, rgb_to_hex
- if not base:
- return None
- if alpha >= 0.999:
- return base
- return rgb_to_hex(mix_rgb(hex_to_rgb(_palette()["bg"]), hex_to_rgb(base), alpha))
- def _resolve(style: str, alpha: float) -> Optional[str]:
- """Fade the style's base ink toward the background by ``alpha`` (rgba-over-bg)."""
- return _fade(_palette().get(style), alpha)
- def _relative_luminance(rgb: tuple[int, int, int]) -> float:
- def channel(value: int) -> float:
- n = value / 255
- return n / 12.92 if n <= 0.03928 else ((n + 0.055) / 1.055) ** 2.4
- red, green, blue = (channel(value) for value in rgb)
- return 0.2126 * red + 0.7152 * green + 0.0722 * blue
- def _contrast_ratio(foreground: tuple[int, int, int], background: tuple[int, int, int]) -> float:
- high, low = sorted((_relative_luminance(foreground), _relative_luminance(background)), reverse=True)
- return (high + 0.05) / (low + 0.05)
- def _ensure_contrast(color: Optional[str], background: str, minimum: float) -> Optional[str]:
- """Lift a foreground toward the readable pole until it clears ``minimum``."""
- if not color:
- return None
- from agent.learning_graph_render import hex_to_rgb, mix_rgb, rgb_to_hex
- foreground_rgb = hex_to_rgb(color)
- background_rgb = hex_to_rgb(background)
- if _contrast_ratio(foreground_rgb, background_rgb) >= minimum:
- return color
- pole = (0, 0, 0) if _relative_luminance(background_rgb) > 0.5 else (255, 255, 255)
- for step in range(1, 21):
- candidate = mix_rgb(foreground_rgb, pole, step * 0.05)
- if _contrast_ratio(candidate, background_rgb) >= minimum:
- return rgb_to_hex(candidate)
- return rgb_to_hex(pole)
- def _resolve_charted_signal(style: str, alpha: float) -> Optional[str]:
- """Keep age tinting without allowing explanatory labels to disappear."""
- return _ensure_contrast(_resolve(style, alpha), _palette()["bg"], _CHARTED_SIGNAL_MIN_CONTRAST)
- def _row_to_text(row: list, color: bool):
- from rich.text import Text
- text = Text()
- for run in row:
- chunk, style = run[0], run[1]
- alpha = run[2] if len(run) > 2 else 1.0
- override = run[3] if len(run) > 3 else None
- if not color:
- text.append(chunk)
- elif override:
- text.append(chunk, style=_fade(override, alpha))
- else:
- text.append(chunk, style=_resolve(style, alpha))
- return text
- def _term_size(width: Optional[int], height: Optional[int]) -> tuple[int, int]:
- size = shutil.get_terminal_size((90, 30))
- return max(40, width or size.columns), max(10, height or size.lines)
- def _frame_renderable(payload, *, cols, rows, reveal, color):
- from rich.console import Group
- from rich.text import Text
- from agent import learning_graph_render as render
- legend = render.build_legend(payload)
- categories = render.category_legend(payload)
- summary = render.build_summary(payload)
- axis = render.axis_labels(payload)
- # Lines are pad_left(2), so content must fit in cols-2.
- inner = max(24, cols - 2)
- # Reserve rows for title/legend/blank/axis/footer/labels + summary; field gets rest.
- field_rows = max(6, rows - 10 - len(summary))
- frame = render.render_graph(payload, cols=inner, rows=field_rows, reveal=reveal)
- count = len(payload.get("nodes", []))
- def st(style: Optional[str]) -> Optional[str]:
- return style if color else None
- title = Text()
- title.append("✦ Journey ", style=st(f"bold {_TITLE_COLOR}"))
- title.append("· learned skills & memories over time", style=st("grey62"))
- parts: list[Any] = [title]
- legend_line = Text(" ")
- for i, item in enumerate(legend):
- if i:
- legend_line.append(" ")
- legend_line.append(item["glyph"] + " ", style=_resolve(item["style"], 1.0) if color else None)
- legend_line.append(item["label"], style=st("grey62"))
- parts.append(legend_line)
- if categories:
- cat_line = Text(" ")
- for i, item in enumerate(categories):
- if i:
- cat_line.append(" ")
- cat_line.append(item["glyph"] + " ", style=_fade(item.get("color"), 1.0) if color else None)
- cat_line.append(item["label"], style=st("grey54"))
- parts.append(cat_line)
- parts.append(Text(""))
- for grow in frame["grid"]:
- line = _row_to_text(grow, color)
- line.pad_left(2)
- parts.append(line)
- # Date axis under the field (oldest → now), with the playhead date centered.
- axis_line = Text(" ")
- axis_line.append(axis["start"], style=st("grey54"))
- axis_line.append(" " * max(1, inner - len(axis["start"]) - len(axis["end"])))
- axis_line.append(axis["end"], style=st("grey54"))
- parts.append(axis_line)
- pct = round(reveal * 100)
- foot = Text(" ")
- foot.append("◷ ", style=st("grey54"))
- foot.append(frame["date"] or "—", style=st(_TITLE_COLOR))
- foot.append(f" {frame['visible']}/{count} revealed · {pct}%", style=st("grey54"))
- parts.append(foot)
- labels = frame.get("labels", [])
- if labels:
- parts.append(Text(""))
- parts.append(Text(" charted signals", style=st("grey62")))
- for item in labels[:6]:
- row = Text(" ")
- row.append(f"{item['key']} ", style=st("grey70"))
- signal_style = (
- _resolve_charted_signal(item["style"], float(item.get("alpha", 1.0))) if color else None
- )
- row.append(f"{item['glyph']} ", style=signal_style)
- row.append(str(item["label"]), style=signal_style)
- meta = str(item["meta"])
- row.append(f" {meta if len(meta) <= 32 else meta[:29] + '…'}", style=st("grey54"))
- parts.append(row)
- for line_text in summary:
- parts.append(Text(" " + line_text, style=st("grey62")))
- return Group(*parts)
- def _console(*, color: bool, width: Optional[int] = None, force: bool = False):
- """A Rich console. ``force`` emits truecolor ANSI even into a captured stream — the interactive CLI
- grabs that output and re-renders it through prompt_toolkit (raw escapes to a real terminal would
- otherwise be swallowed). Mirrors the ``ChatConsole`` idiom in ``cli.py``.
- """
- from rich.console import Console
- extra = {"force_terminal": True, "color_system": "truecolor"} if force else {}
- return Console(no_color=not color, width=width, **extra)
- def _cmd_show(args: argparse.Namespace) -> int:
- from rich.console import Console
- if getattr(args, "json", False):
- import json
- Console(no_color=bool(getattr(args, "no_color", False))).print_json(json.dumps(_build_payload()))
- return 0
- payload = _build_payload()
- color = not bool(getattr(args, "no_color", False))
- cols, rows = _term_size(getattr(args, "width", None), getattr(args, "height", None))
- console = _console(color=color, width=cols, force=bool(getattr(args, "force_color", False)))
- if not payload.get("nodes"):
- console.print(
- "[grey62]No learning yet — use Hermes a while and your learned skills and "
- "memories will start mapping out here.[/grey62]"
- )
- return 0
- if getattr(args, "play", False):
- return _play(console, payload, cols=cols, rows=rows, color=color, fps=getattr(args, "fps", 12))
- reveal = _clamp(float(getattr(args, "reveal", 1.0) or 1.0), 0.0, 1.0)
- console.print(_frame_renderable(payload, cols=cols, rows=rows, reveal=reveal, color=color))
- return 0
- def _play(console, payload, *, cols, rows, color, fps: int) -> int:
- from rich.live import Live
- frames = 42
- delay = 1.0 / max(1, min(60, fps))
- try:
- with Live(console=console, refresh_per_second=max(1, fps), screen=False) as live:
- for i in range(frames):
- reveal = i / (frames - 1)
- live.update(_frame_renderable(payload, cols=cols, rows=rows, reveal=reveal, color=color))
- time.sleep(delay)
- live.update(_frame_renderable(payload, cols=cols, rows=rows, reveal=1.0, color=color))
- except KeyboardInterrupt:
- console.print("[grey54]interrupted[/grey54]")
- return 130
- return 0
- def _clamp(v: float, lo: float, hi: float) -> float:
- return lo if v < lo else min(v, hi)
- # ── list / delete / edit ─────────────────────────────────────────────────────
- def _cmd_list(args: argparse.Namespace) -> int:
- from agent.learning_graph_render import format_date
- console = _console(color=not bool(getattr(args, "no_color", False)), force=bool(getattr(args, "force_color", False)))
- nodes = sorted(_build_payload().get("nodes", []), key=lambda n: n.get("timestamp") or 0)
- if not nodes:
- console.print("[grey62]No learning yet.[/grey62]")
- return 0
- for node in nodes:
- glyph = "◆" if node.get("kind") == "memory" else "●"
- date = format_date(node.get("timestamp"))
- console.print(f"[grey54]{node['id']}[/grey54] {glyph} {node.get('label', '')} [grey54]{date}[/grey54]")
- return 0
- def _lookup_node(node_id: str) -> Optional[dict]:
- """Resolve a node id via ``node_detail``; print the failure and return None when missing."""
- from agent.learning_mutations import node_detail
- detail = node_detail(node_id)
- if not detail.get("ok"):
- print(f" {detail.get('message', 'not found')}")
- return None
- return detail
- def _cmd_delete(args: argparse.Namespace) -> int:
- from agent.learning_mutations import delete_node
- detail = _lookup_node(args.node)
- if detail is None:
- return 1
- if not getattr(args, "yes", False):
- try:
- if input(f" Delete {detail['label']!r}? [y/N] ").strip().lower() not in ("y", "yes"):
- print(" aborted")
- return 1
- except (EOFError, KeyboardInterrupt):
- print("\n aborted")
- return 1
- res = delete_node(args.node)
- print(f" {res['message']}")
- return 0 if res.get("ok") else 1
- def _cmd_edit(args: argparse.Namespace) -> int:
- from agent.learning_mutations import edit_node
- detail = _lookup_node(args.node)
- if detail is None:
- return 1
- edited = _open_in_editor(detail["content"], suffix=".md" if detail["kind"] == "skill" else ".txt")
- if edited is None or edited.strip() == detail["content"].strip():
- print(" no changes")
- return 0
- res = edit_node(args.node, edited)
- print(f" {res['message']}")
- return 0 if res.get("ok") else 1
- def _open_in_editor(initial: str, *, suffix: str) -> Optional[str]:
- import os
- import subprocess
- import tempfile
- editor = os.environ.get("EDITOR") or os.environ.get("VISUAL") or "vi"
- with tempfile.NamedTemporaryFile("w", suffix=suffix, delete=False, encoding="utf-8") as fh:
- fh.write(initial)
- path = fh.name
- try:
- subprocess.call([*editor.split(), path])
- with open(path, encoding="utf-8-sig") as fh:
- return fh.read()
- except OSError as exc:
- print(f" editor failed: {exc}")
- return None
- finally:
- try:
- os.unlink(path)
- except OSError:
- pass
- def register_cli(parent: argparse.ArgumentParser) -> None:
- parent.add_argument(
- "--reveal", type=float, default=1.0, metavar="0..1",
- help="Render the timeline built up to this point (0=oldest, 1=now).",
- )
- parent.add_argument("--play", action="store_true", help="Animate the build-up over time (Ctrl-C to stop).")
- parent.add_argument("--fps", type=int, default=12, help="Animation frames per second for --play (default 12).")
- parent.add_argument("--width", type=int, default=None, help="Override render width in columns.")
- parent.add_argument("--height", type=int, default=None, help="Override render height in rows.")
- parent.add_argument("--no-color", action="store_true", help="Disable color output.")
- # Force ANSI even when stdout is captured — the interactive CLI re-renders it.
- parent.add_argument("--force-color", action="store_true", help=argparse.SUPPRESS)
- parent.add_argument("--json", action="store_true", help="Print the raw graph payload as JSON and exit.")
- parent.set_defaults(func=_cmd_show)
- sub = parent.add_subparsers(dest="journey_action")
- p_list = sub.add_parser("list", help="List node ids (for delete/edit).")
- p_list.add_argument("--no-color", action="store_true")
- p_list.add_argument("--force-color", action="store_true", help=argparse.SUPPRESS)
- p_list.set_defaults(func=_cmd_list)
- p_del = sub.add_parser("delete", help="Delete a learned skill (archived) or memory by node id.")
- p_del.add_argument("node", help="Node id (skill name, or a memory id exactly as `journey list` prints it).")
- p_del.add_argument("-y", "--yes", action="store_true", help="Skip the confirmation prompt.")
- p_del.set_defaults(func=_cmd_delete)
- p_edit = sub.add_parser("edit", help="Edit a learned skill or memory by node id in $EDITOR.")
- p_edit.add_argument("node", help="Node id (skill name, or a memory id exactly as `journey list` prints it).")
- p_edit.set_defaults(func=_cmd_edit)
- if __name__ == "__main__":
- _p = argparse.ArgumentParser(prog="hermes journey")
- register_cli(_p)
- _a = _p.parse_args()
- sys.exit(_a.func(_a))
|