"""Skills configuration for Hermes Agent. `hermes skills` enters this module.""" from typing import List, Optional, Set from hermes_cli.config import cfg_get, load_config, save_config from hermes_cli.colors import Colors, color from hermes_cli.platforms import PLATFORMS as _PLATFORMS # {key: label} view of the messaging platforms (``PLATFORMS.items()`` / ``.get(key)`` below). PLATFORMS = {k: info.label for k, info in _PLATFORMS.items() if k != "api_server"} def _normalize_skill_names(values) -> set[str]: """Config value -> set of skill names (mirrors ``agent.skill_utils._normalize_string_set``): ``None`` (YAML null) is empty and a bare scalar is a single-item list, NOT its characters. See #13026. """ if values is None: return set() if isinstance(values, str): values = [values] try: return {str(v).strip() for v in values if str(v).strip()} except TypeError: return set() def get_disabled_skills(config: dict, platform: Optional[str] = None) -> set[str]: """Disabled skill names: the global list unioned with the platform list when given (globally disabled stays disabled everywhere; mirrors ``agent.skill_utils.get_disabled_skill_names``).""" skills_cfg = config.get("skills") or {} if not isinstance(skills_cfg, dict): return set() from agent.skill_utils import ESSENTIAL_SKILLS disabled = _normalize_skill_names(skills_cfg.get("disabled")) if platform is not None: platform_disabled = cfg_get(skills_cfg, "platform_disabled", platform) if platform_disabled is not None: disabled = disabled | _normalize_skill_names(platform_disabled) return disabled - ESSENTIAL_SKILLS def save_disabled_skills(config: dict, disabled: set[str], platform: Optional[str] = None): """Persist disabled skill names to config; essential skills (e.g. ``hermes-agent``) are silently dropped — they cannot be disabled from any surface.""" from agent.skill_utils import ESSENTIAL_SKILLS disabled = set(disabled) - ESSENTIAL_SKILLS config.setdefault("skills", {}) if platform is None: config["skills"]["disabled"] = sorted(disabled) else: config["skills"].setdefault("platform_disabled", {}) config["skills"]["platform_disabled"][platform] = sorted(disabled) save_config(config) def _list_all_skills() -> list[dict]: """Return all installed skills (ignoring disabled state).""" try: from tools.skills_tool import find_all_skills return find_all_skills(skip_disabled=True) except Exception: return [] def _get_categories(skills: list[dict]) -> list[str]: """Return sorted unique category names (None -> 'uncategorized').""" return sorted({s["category"] or "uncategorized" for s in skills}) def _select_platform() -> Optional[str]: """Ask which platform to configure; None means global.""" options = [("global", "All platforms (global default)")] + list(PLATFORMS.items()) print() print(color(" Configure skills for:", Colors.BOLD)) for i, (key, label) in enumerate(options, 1): print(f" {i}. {label}") print() try: raw = input(color(" Select [1]: ", Colors.YELLOW)).strip() except (KeyboardInterrupt, EOFError): return None try: idx = int(raw) - 1 # empty input -> ValueError -> global except ValueError: return None if 0 <= idx < len(options) and options[idx][0] != "global": return options[idx][0] return None def _toggle_by_category(skills: list[dict], disabled: set[str]) -> set[str]: """Toggle all skills in a category at once.""" from hermes_cli.curses_ui import curses_checklist categories = _get_categories(skills) cat_skills = [{s["name"] for s in skills if (s["category"] or "uncategorized") == cat} for cat in categories] cat_labels = [f"{cat} ({len(names)} skills)" for cat, names in zip(categories, cat_skills)] # A category is "enabled" (checked) when NOT all its skills are disabled pre_selected = {i for i, names in enumerate(cat_skills) if not all(s in disabled for s in names)} chosen = curses_checklist("Categories — toggle entire categories", cat_labels, pre_selected, cancel_returns=pre_selected) new_disabled = set(disabled) for i, names in enumerate(cat_skills): if i in chosen: new_disabled -= names # category enabled → remove from disabled else: new_disabled |= names # category disabled → add to disabled return new_disabled def skills_command(args=None): """Entry point for `hermes skills`.""" from hermes_cli.curses_ui import curses_checklist config = load_config() skills = _list_all_skills() if not skills: print(color(" No skills installed.", Colors.DIM)) return platform = _select_platform() platform_label = PLATFORMS.get(platform, "All platforms") if platform else "All platforms" print() print(color(f" Configure for: {platform_label}", Colors.DIM)) print() print(" 1. Toggle individual skills") print(" 2. Toggle by category") print() try: mode = input(color(" Select [1]: ", Colors.YELLOW)).strip() or "1" except (KeyboardInterrupt, EOFError): return disabled = get_disabled_skills(config, platform) if mode == "2": new_disabled = _toggle_by_category(skills, disabled) else: labels = [f"{s['name']} ({s['category'] or 'uncategorized'}) — {s['description'][:55]}" for s in skills] # "selected" = enabled (not disabled) — matches the [✓] convention pre_selected = {i for i, s in enumerate(skills) if s["name"] not in disabled} chosen = curses_checklist(f"Skills for {platform_label}", labels, pre_selected, cancel_returns=pre_selected) new_disabled = {skills[i]["name"] for i in range(len(skills)) if i not in chosen} if new_disabled == disabled: print(color(" No changes.", Colors.DIM)) return save_disabled_skills(config, new_disabled, platform) enabled_count = len(skills) - len(new_disabled) print(color(f"✓ Saved: {enabled_count} enabled, {len(new_disabled)} disabled ({platform_label}).", Colors.GREEN))