mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-18 11:56:11 +03:00
f0f9f9ebf6
Each legacy store call and direct store-file open in the CLI and cli.py moves to the interface operation that carries it. The lost-and-found and schema-history modules go: session recovery uses the backend's store admin for them, and their tests move with it, as does the CLI's sqlite3 resolution row in the resolution allowlist. The gateway label reader reads nothing when its interface handle cannot open. The legacy orphan-sweep test goes for its backend copy, and the legacy tests that imported the removed CLI modules follow the names to their new homes.
169 lines
7.2 KiB
Python
169 lines
7.2 KiB
Python
"""Shared session-listing helpers for CLI and gateway slash surfaces."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import shlex
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from utils import is_truthy_value
|
|
|
|
_LIST_WORDS = {"list", "ls", "browse"}
|
|
_SEARCH_WORDS = {"search", "find"}
|
|
SUBAGENT_SOURCE = "subagent"
|
|
|
|
|
|
def show_subagent_sessions(hermes_home: str | Path) -> bool:
|
|
"""``sessions.show_subagents`` from *hermes_home*'s own config.yaml. One ``serve`` lists many
|
|
profiles' stores, so the store's home decides, never the process ``HERMES_HOME``. False when
|
|
the config cannot be read (the listing keeps its default shape)."""
|
|
from hermes_cli.config import load_config_readonly
|
|
from hermes_constants import reset_hermes_home_override, set_hermes_home_override
|
|
|
|
token = set_hermes_home_override(str(hermes_home))
|
|
try:
|
|
sessions_cfg = load_config_readonly().get("sessions") or {}
|
|
except Exception:
|
|
return False
|
|
finally:
|
|
reset_hermes_home_override(token)
|
|
return isinstance(sessions_cfg, dict) and is_truthy_value(sessions_cfg.get("show_subagents"))
|
|
|
|
|
|
def subagent_listing_scope(
|
|
hermes_home: str | Path, *, source: str | None = None, sources: list[str] | None = None,
|
|
exclude_sources: list[str] | None = None,
|
|
) -> tuple[bool, list[str] | None]:
|
|
"""``(include_subagents, exclude_sources)`` for one human-facing session list (#97202).
|
|
|
|
With ``sessions.show_subagents`` on, delegate runs join a list that is not scoped to named
|
|
sources and either has no exclusions or excludes the ``subagent`` source itself (the desktop
|
|
recents shape); that exclusion is dropped so the runs actually land. A slice that excludes
|
|
other sources without ``subagent`` (the per-platform messaging lists) keeps its shape.
|
|
"""
|
|
excluded = list(exclude_sources or [])
|
|
if source or sources or (excluded and SUBAGENT_SOURCE not in excluded):
|
|
return False, exclude_sources
|
|
if not show_subagent_sessions(hermes_home):
|
|
return False, exclude_sources
|
|
return True, [s for s in excluded if s != SUBAGENT_SOURCE] or None
|
|
|
|
|
|
def parse_session_listing_args(raw_args: str) -> tuple[bool, bool, str, str | None]:
|
|
"""Parse `/sessions`-style args into ``(include_all_sources, include_unnamed, target, search_query)``.
|
|
|
|
``all`` widens source scope, ``full`` keeps unnamed sessions, ``search``/``find`` makes the rest
|
|
a query (``None`` = not requested, ``""`` = requested with no terms). Flags are honored only
|
|
before the first positional word so titles containing "all" aren't misparsed; anything else is
|
|
a target so `/sessions <id-or-title>` can delegate to `/resume`.
|
|
"""
|
|
parts = shlex.split(raw_args or "")
|
|
flags = {"all": False, "full": False}
|
|
target_parts: list[str] = []
|
|
for i, part in enumerate(parts):
|
|
lower = part.strip().lower()
|
|
if not target_parts:
|
|
if lower in _LIST_WORDS:
|
|
continue
|
|
if lower in {"all", "--all", "full", "--full"}:
|
|
flags[lower.lstrip("-")] = True
|
|
continue
|
|
if lower in _SEARCH_WORDS:
|
|
return flags["all"], flags["full"], "", " ".join(parts[i + 1:]).strip()
|
|
target_parts.append(part)
|
|
return flags["all"], flags["full"], " ".join(target_parts).strip(), None
|
|
|
|
|
|
def query_session_listing(
|
|
session_db: Any,
|
|
*,
|
|
source: str | None,
|
|
session_key: str | None = None,
|
|
current_session_id: str | None = None,
|
|
include_current_session: bool = False,
|
|
include_all_sources: bool = False,
|
|
include_unnamed: bool = False,
|
|
search_query: str | None = None,
|
|
limit: int = 10,
|
|
exclude_sources: list[str] | None = None,
|
|
persistence: Any = None,
|
|
) -> list[dict[str, Any]]:
|
|
"""Return session rows for interactive listing surfaces (shared CLI/gateway policy).
|
|
|
|
Source-scoped unless global is requested; unnamed hidden unless a full listing is asked for;
|
|
current session hidden unless requested (then marked ``is_current_session``); ``session_key``
|
|
restricts gateway callers to one lane before the DB limit applies. With ``search_query`` rows
|
|
are filtered by title/id in SQL, ordered by recent activity, and unnamed sessions stay visible
|
|
since an id match may be the only handle. Rows are read through ``persistence`` (a storage
|
|
interface handle) when given, else through ``session_db``.
|
|
"""
|
|
search = (search_query or "").strip()
|
|
if persistence is not None:
|
|
from persistence.conversation.sessions import SessionOrder, SessionQuery, SessionWindow
|
|
scoped = None if include_all_sources else source
|
|
entries = persistence.sessions.list_sessions(SessionQuery(
|
|
sources=(scoped,) if scoped else None,
|
|
session_key=session_key,
|
|
exclude_sources=tuple(exclude_sources or ()),
|
|
search_text=search or None,
|
|
order=SessionOrder.LAST_ACTIVE if search else SessionOrder.STARTED_AT,
|
|
), SessionWindow(limit=max(limit * 4, limit)))
|
|
rows = [entry.as_list_row() for entry in entries]
|
|
else:
|
|
rows = session_db.list_sessions_rich(
|
|
source=None if include_all_sources else source,
|
|
session_key=session_key,
|
|
exclude_sources=exclude_sources,
|
|
limit=max(limit * 4, limit),
|
|
search_query=search or None,
|
|
order_by_last_active=bool(search),
|
|
)
|
|
result: list[dict[str, Any]] = []
|
|
for row in rows:
|
|
is_current = bool(current_session_id and row.get("id") == current_session_id)
|
|
if (is_current and not include_current_session) or (
|
|
not include_unnamed and not row.get("title") and not search and not is_current
|
|
):
|
|
continue
|
|
result.append({**row, "is_current_session": True} if is_current else row)
|
|
if len(result) >= limit:
|
|
break
|
|
return result
|
|
|
|
|
|
def format_gateway_session_listing(
|
|
rows: list[dict[str, Any]],
|
|
*,
|
|
include_source: bool = False,
|
|
title: str = "Sessions",
|
|
notice: str | None = None,
|
|
) -> str:
|
|
"""Render a compact Markdown-ish session list for gateway messengers.
|
|
|
|
``notice`` adds an explanatory line above the footer — e.g. when a requested scope widening
|
|
(``all``) was declined, so the caller isn't left guessing why sessions are missing.
|
|
"""
|
|
if not rows:
|
|
return "\n".join([
|
|
"No sessions found.\n"
|
|
"Use `/title My Session` to name this chat, or `/sessions full` "
|
|
"to include unnamed sessions.",
|
|
*([notice] if notice else []),
|
|
])
|
|
lines = [f"📋 **{title}**", ""]
|
|
for idx, row in enumerate(rows, start=1):
|
|
current_part = " (current)" if row.get("is_current_session") else ""
|
|
preview = str(row.get("preview") or "")[:40]
|
|
source = str(row.get("source") or "")
|
|
source_part = f" `{source}`" if include_source and source else ""
|
|
preview_part = f" — _{preview}_" if preview else ""
|
|
lines.append(
|
|
f"{idx}. **{row.get('title') or '—'}**{current_part}{source_part}"
|
|
f" — `{row.get('id') or ''}`{preview_part}"
|
|
)
|
|
return "\n".join([
|
|
*lines, "", *([notice] if notice else []),
|
|
"Resume: `/resume <session id>` or `/resume <number>` from `/resume`.",
|
|
"More: `/sessions all`, `/sessions full`, `/sessions search <query>`.",
|
|
])
|