| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393 |
- """Shared print/translate helpers + session-info slash handlers (``cli_commands_mixin`` split).
- Moved verbatim from ``hermes_cli/cli_commands_mixin.py`` (file-line ratchet #68779): the
- lazy-binding contract carries over unchanged — ``cli.py``-internal symbols are imported at
- call time via ``from cli import ...``, so patch seams on the ``cli`` facade still intercept.
- ``cli_commands_mixin`` re-imports every helper moved here, so existing ``from
- cli_commands_mixin import _t`` style imports keep working.
- """
- from __future__ import annotations
- import argparse
- import importlib
- import io
- import shlex
- from contextlib import redirect_stdout
- from io import StringIO
- from agent.i18n import t
- def _cp(*lines: str) -> None:
- """``_cprint`` each line (lazy import: cli.py imports this module)."""
- from cli import _cprint
- for line in lines:
- _cprint(line)
- def _pr(*lines: str) -> None:
- """print() each line."""
- for line in lines:
- print(line)
- def _save(key: str, value) -> bool:
- """cli.save_config_value, resolved lazily (cli.py imports this module)."""
- from cli import save_config_value
- return save_config_value(key, value)
- def _dim(text: str) -> str:
- """Wrap ``text`` in the dim ANSI escape."""
- from cli import _DIM, _RST
- return f"{_DIM}{text}{_RST}"
- def _dim_line(text: str) -> str:
- """Two-space indented dim line (the standard slash-command hint shape)."""
- return " " + _dim(text)
- def _accent(text: str) -> str:
- """Wrap ``text`` in the skin accent ANSI escape."""
- from cli import _ACCENT, _RST
- return f"{_ACCENT}{text}{_RST}"
- def _accent_line(text: str) -> str:
- """Two-space indented accent line (the standard slash-command headline shape)."""
- return f" {_accent(text)}"
- def _t(key: str, **kwargs) -> str:
- """Catalog text for this module: ``cli.commands.<key>`` in the active language."""
- return t(f"cli.commands.{key}", **kwargs)
- def _tn(key: str, count: int, **kwargs) -> str:
- """Plural-aware ``_t``: ``<key>_one`` when ``count == 1``, else ``<key>_other``."""
- return _t(f"{key}_{'one' if count == 1 else 'other'}", count=count, **kwargs)
- def _gt(key: str, **kwargs) -> str:
- """A ``gateway.<key>`` catalog entry the CLI shares verbatim with the messaging gateway."""
- return t(f"gateway.{key}", **kwargs)
- def _lines(text: str, pad: str = " ") -> list:
- """Each line of a (possibly multi-line) catalog value prefixed with ``pad`` (blank lines kept)."""
- return [f"{pad}{line}" if line else "" for line in text.splitlines()]
- def _rollback_kept(result: dict) -> None:
- """The kept / not-removed path lines of a restore result (in-process CLI and gateway client alike)."""
- from hermes_cli.cli_commands_mixin import _summarize_paths
- if skipped := result.get("skipped_user_edits"):
- _pr(*_lines(_gt("rollback.kept_user_edits", files=_summarize_paths(skipped))))
- if oversize := result.get("skipped_oversize"):
- print(f" {_gt('rollback.kept_oversize', files=_summarize_paths(oversize))}")
- if failed := result.get("failed_deletes"):
- print(f" {_gt('rollback.failed_deletes', files=_summarize_paths(failed))}")
- def _probe(module: str, name: str, default, *args):
- """``<module>.<name>(*args)`` or ``default`` when the import or the call fails (optional
- subsystems: browser backends, async delegations, wake word, ...)."""
- try:
- return getattr(importlib.import_module(module), name)(*args)
- except Exception:
- return default
- class CLICommandsSessionToolsMixin:
- """``/stop``, ``/agents``, ``/journey``, ``/paste``, ``/copy``, ``/image``, ``/tools``,
- ``/profile`` handlers (moved from ``CLICommandsMixin``)."""
- # ---- /stop, /agents -------------------------------------------------------------------
- def _handle_stop_command(self):
- """Handle /stop — kill all running background processes and background (async) delegations.
- Typed while a turn runs it stops that turn first, as Ctrl+C does (the registry's
- ``busy_policy="interrupt_then_dispatch"``; the input loop dispatches it inline, on the UI
- thread). The interrupt is immediate; the background cleanup then runs on a worker thread,
- since ``kill_all`` waits out each process's stop grace period and would freeze input.
- See #14602.
- """
- if not getattr(self, "_agent_running", False):
- return _stop_background_work()
- if getattr(self, "agent", None):
- from agent.interrupt_compat import request_hard_interrupt
- _cp(f" {t('cli.tui.interrupting')}")
- request_hard_interrupt(self.agent)
- from agent.memory_provider import spawn_context_thread
- spawn_context_thread(_stop_background_work, name="cli-stop").start()
- def _handle_agents_command(self):
- """Handle /agents — show background processes and agent status. On the gateway both run there:
- the session's ``process.list`` and its usage's running-subagent count (no per-delegation rows)."""
- from hermes_cli.gateway_tools import process_registry as _registry, process_view
- from tools.process_registry import format_uptime_short
- process_registry, view = _registry(), process_view()
- if view is not None:
- view.refresh(force=True)
- processes = process_registry.list_sessions()
- running = [p for p in processes if p.get("status") == "running"]
- finished = [p for p in processes if p.get("status") != "running"]
- _cp(f" {_t('agents.running_processes', count=len(running))}")
- for p in running:
- up = format_uptime_short(p.get("uptime_seconds", 0))
- _cp(f" {p.get('session_id', '?')} · {up} · {p.get('command', '')[:80]}")
- if finished:
- _cp(f" {_t('agents.recently_finished', count=len(finished))}")
- if view is None:
- _print_local_delegations()
- elif n_async := view.active_delegations():
- _cp(f" {_t('agents.background_delegations', count=n_async)}")
- agent_running = getattr(self, "_agent_running", False)
- _cp(f" {_t('agents.agent_running') if agent_running else _t('agents.agent_idle')}")
- # ---- /journey, /paste, /copy, /image --------------------------------------------------
- def _handle_journey_command(self, cmd_original: str) -> None:
- """Handle /journey — the learning timeline (see `hermes journey`). Read-only views render
- Rich color that patch_stdout would swallow, so capture with forced ANSI and re-emit via
- ``_cprint``; ``delete``/``edit`` are interactive and keep real stdio."""
- from hermes_cli.journey import register_cli
- parser = argparse.ArgumentParser(prog="/journey", add_help=False)
- register_cli(parser)
- try:
- args = parser.parse_args(shlex.split(cmd_original)[1:])
- except SystemExit:
- return
- try:
- if getattr(args, "journey_action", None) in ("delete", "edit"):
- args.func(args)
- return
- args.force_color = True
- buf = io.StringIO()
- with redirect_stdout(buf):
- args.func(args)
- _cp(buf.getvalue().rstrip("\n"))
- except Exception as exc:
- _cp(f" {_t('journey.failed', error=exc)}")
- def _handle_paste_command(self):
- """Handle /paste — explicitly check clipboard for an image.
- This is the reliable fallback for terminals where BracketedPaste
- doesn't fire for image-only clipboard content (e.g., VSCode terminal,
- Windows Terminal with WSL2).
- """
- from hermes_cli.clipboard import has_clipboard_image
- if not has_clipboard_image():
- _cp(_dim_line(_t("paste.no_image")))
- elif self._try_attach_clipboard_image():
- _cp(f" {_t('paste.attached', index=len(self._attached_images))}")
- else:
- _cp(_dim_line(_t("paste.extract_failed")))
- def _handle_copy_command(self, cmd_original: str) -> None:
- """Handle /copy [number] — copy assistant output to clipboard."""
- from cli import _assistant_copy_text
- arg = _command_arg(cmd_original)
- assistant = [m for m in self.conversation_history if m.get("role") == "assistant"]
- if not assistant:
- return _cp(f" {_t('copy.nothing_yet')}")
- if arg:
- try:
- idx = int(arg) - 1
- except ValueError:
- return _cp(f" {_t('copy.usage')}")
- if idx < 0 or idx >= len(assistant):
- return _cp(f" {_t('copy.invalid_number', max=len(assistant))}")
- else: # latest response that has copyable text
- idx = next((i for i in range(len(assistant) - 1, -1, -1)
- if _assistant_copy_text(assistant[i].get("content"))), -1)
- if idx < 0:
- return _cp(f" {_t('copy.nothing_in_responses')}")
- text = _assistant_copy_text(assistant[idx].get("content"))
- if not text:
- return _cp(f" {_t('copy.nothing_in_response')}")
- try:
- from hermes_cli.clipboard import is_remote_shell_session, write_clipboard_text
- # Over SSH native tools write the REMOTE clipboard; OSC 52 reaches the user's terminal.
- # Locally, OSC 52 is the fallback when native tools are unavailable/fail (SSH/tmux).
- if is_remote_shell_session() or not write_clipboard_text(text):
- # Fixes #31528.
- self._write_osc52_clipboard(text)
- _cp(f" {_t('copy.copied_osc52', index=idx + 1)}")
- else:
- _cp(f" {_t('copy.copied', index=idx + 1)}")
- except Exception as e:
- _cp(f" {_t('copy.failed', error=e)}")
- def _handle_image_command(self, cmd_original: str):
- """Handle /image <path> — attach a local image file for the next prompt."""
- from cli import _DIM, _IMAGE_EXTENSIONS, _RST, _cprint, _resolve_attachment_path, _split_path_input
- raw_args = (cmd_original.split(None, 1)[1].strip() if " " in cmd_original else "")
- if not raw_args:
- hint = "/path/to/image.png"
- _cprint(f" {_DIM}{_t('image.usage', example=hint)}{_RST}")
- return
- path_token, _remainder = _split_path_input(raw_args)
- image_path = _resolve_attachment_path(path_token)
- if image_path is None:
- return _cp(_dim_line(_t("image.not_found", path=path_token)))
- if image_path.suffix.lower() not in _IMAGE_EXTENSIONS:
- return _cp(_dim_line(_t("image.unsupported", name=image_path.name)))
- self._attached_images.append(image_path)
- _cp(f" {_t('image.attached', name=image_path.name)}")
- if _remainder:
- _cprint(f" {_DIM}{_t('image.now_type_prompt', text=_remainder)}{_RST}")
- # ---- /tools, /profile -----------------------------------------------------------------
- def _handle_tools_command(self, cmd: str):
- """Handle /tools [list|disable|enable]. Bare shows the tool list; ``list`` shows per-toolset
- status; disable/enable save to config and reset the session so the new tool set takes
- effect cleanly (no prompt-cache breakage mid-conversation)."""
- parts = _shlex_args(cmd)
- subcommand = parts[0] if parts else ""
- if subcommand not in {"list", "disable", "enable"}:
- return self.show_tools()
- if subcommand == "list":
- return self._run_tools_config(tools_action="list", platform="cli")
- names = parts[1:]
- if not names:
- return _pr(_t("tools.usage", subcommand=subcommand),
- f" {_t('tools.example_toolset', subcommand=subcommand)}",
- f" {_t('tools.example_mcp', subcommand=subcommand)}")
- # Typing the command is consent. Do NOT use input() — it hangs in prompt_toolkit's loop.
- _cp(_accent(_t("tools.disabling" if subcommand == "disable" else "tools.enabling",
- names=", ".join(names))))
- self._run_tools_config(tools_action=subcommand, names=names, platform="cli")
- from hermes_cli.tools_config import _get_platform_tools
- from hermes_cli.config import load_config
- self.enabled_toolsets = sorted(_get_platform_tools(load_config(), "cli")) # plain data for session.create
- self.new_session()
- _cp(_dim(_t("tools.session_reset")))
- def _run_tools_config(self, **ns) -> None:
- """Run ``tools_disable_enable_command``. Inside the interactive TUI its ANSI print() output
- is captured (isatty=True so colors still render) and re-emitted through _cprint so
- patch_stdout's StdoutProxy doesn't garble the escapes; standalone/tests call straight through."""
- from argparse import Namespace
- from hermes_cli.tools_config import tools_disable_enable_command
- if getattr(self, "_app", None) is None:
- return tools_disable_enable_command(Namespace(**ns))
- buf = _TTYBuf()
- with redirect_stdout(buf):
- tools_disable_enable_command(Namespace(**ns))
- _cp(*buf.getvalue().splitlines())
- def _handle_autoprune_command(self, cmd: str):
- """/autoprune [on|off|later|status] — the low-disk auto-prune decision."""
- from hermes_cli.slash_exec import CommandContext, execute_command
- _say_block(execute_command("autoprune", CommandContext(surface="cli", args=cmd.partition(" ")[2])).text)
- def _handle_profile_command(self):
- """Display active profile name and home directory."""
- from hermes_cli.slash_exec import CommandContext, execute_command
- reply = execute_command("profile", CommandContext(surface="cli"))
- _say_block(f" {_t('profile.profile', profile=reply.data['profile'])}",
- f" {_t('profile.home', home=reply.data['home'])}")
- def _stop_background_work() -> None:
- """``/stop``'s cleanup: kill the background processes, then interrupt the background (async)
- delegations. Mid-turn it runs on a worker thread, so it prints through ``_cprint``: a plain
- print() from off the input loop is buried by the prompt_toolkit redraw."""
- from hermes_cli.gateway_tools import process_registry as _registry, process_view
- process_registry, view = _registry(), process_view()
- if view is not None:
- view.refresh(force=True)
- running = [p for p in process_registry.list_sessions() if p.get("status") == "running"]
- # Background subagents live in their own registry, not the process registry.
- n_async = view.active_delegations() if view is not None else _probe("tools.async_delegation", "active_count", 0)
- if not running and not n_async:
- return _cp(f" {_t('stop.none_running')}")
- if running:
- _cp(f" {_t('stop.stopping', count=len(running))}")
- _cp(f" {_t('stop.stopped', count=process_registry.kill_all(source='cli.stop'))}")
- if n_async:
- if view is not None:
- interrupted = view.interrupt_delegations() # the gateway interrupts this session's own
- else:
- from tools.async_delegation import interrupt_all
- interrupted = interrupt_all(reason='/stop')
- _cp(f" {_t('stop.interrupted_delegations', count=interrupted)}")
- def print_session_diff(cli, result: dict, stat_only: bool) -> None:
- """Render a ``CheckpointManager.session_diff`` result (``/diff session``): this process's agent's,
- or the gateway session's ``rollback.session_diff`` (``diff_lines``: its uncut body's line count)."""
- if not result.get("success"):
- return print(f" {result.get('error') or _t('shared.could_not_generate_diff')}")
- stat, diff = result.get("stat", ""), result.get("diff", "")
- if result.get("empty") or (not stat and not diff):
- return print(f" {_t('diff.no_session_changes')}")
- if stat:
- cli._print_diff_text(f"\n{stat}")
- if (diff or result.get("diff_lines")) and not stat_only: # a body cut to nothing still names its lines
- cli._print_diff_body(diff, _t("diff.stat_hint_session"), total=int(result.get("diff_lines") or 0))
- def _print_local_delegations() -> None:
- """This process's background (async) delegations — delegate_task(background=true)."""
- delegations = _probe("tools.async_delegation", "list_async_delegations", [])
- if not delegations:
- return
- running_d = [d for d in delegations if d.get("status") in ("running", "stalling")]
- _cp(f" {_t('agents.background_delegations', count=len(running_d))}")
- for d in delegations:
- status = d.get("status", "?")
- line = f" {d.get('delegation_id', '?')} · {status} · {(d.get('goal') or '')[:60]}"
- # Live-status detail for in-flight delegations.
- # See #51690.
- if status == "stalling":
- quiet = d.get("stalled_after_quiet_seconds")
- if quiet is not None:
- line += _t("agents.no_progress", seconds=f"{quiet:.0f}")
- elif status == "running":
- quiet = d.get("seconds_since_progress")
- if quiet is not None and quiet >= 60:
- line += _t("agents.quiet", seconds=f"{quiet:.0f}")
- _cp(line)
- for i, child in enumerate(d.get("children_activity") or []):
- if not isinstance(child, dict):
- continue
- tool = child.get("current_tool")
- doing = _t("agents.in_tool", tool=tool) if tool else _t("agents.between_turns")
- part = " " + _t("agents.child_line", index=i + 1,
- api_calls=child.get("api_calls", "?"), doing=doing)
- idle = child.get("seconds_since_activity")
- if idle is not None:
- part += _t("agents.last_activity", seconds=f"{idle:.0f}")
- _cp(part)
- class _TTYBuf(StringIO):
- """StringIO that claims to be a TTY so ``hermes_cli.colors.color()`` still emits ANSI escapes."""
- def isatty(self) -> bool:
- return True
- def _say_block(*lines: str) -> None:
- """print() the lines framed by a blank line above and below (the /browser output style)."""
- _pr("", *lines, "")
- def _command_arg(cmd: str, *, lower: bool = False) -> str:
- """Everything after the slash-command word, stripped (optionally lowercased)."""
- parts = (cmd or "").strip().split(None, 1)
- arg = parts[1].strip() if len(parts) > 1 else ""
- return arg.lower() if lower else arg
- def _shlex_args(cmd: str) -> list:
- """Tokens after the command word; falls back to whitespace split on unbalanced quotes."""
- try:
- return shlex.split(cmd)[1:] if cmd else []
- except ValueError:
- return (cmd or "").split()[1:]
|