`gje1dZddlmZddlmZmZmZmZmZdZ dZ d dZ ddZ ddZ dd Z dd Z dd Zy )uBoundary-aware partial compression — "summarize up to here". Inspired by Claude Code's Rewind menu "Summarize up to here" action (v2.1.139–v2.1.142, Week 20, May 2026): https://code.claude.com/docs/en/whats-new/2026-w20 Hermes already has ``/compress`` (full-history compaction) and an automatic token-budget tail-protection heuristic inside ``ContextCompressor``. What was missing is *user-chosen* boundary control: "fold everything before this point into a summary, but keep my most recent N exchanges exactly as they are." That is the value of the Claude Code feature — the user decides the compression boundary instead of leaving it to the token-budget heuristic. This module owns the pure, side-effect-free split logic so both the CLI (``cli.py::_manual_compress``) and the gateway (``gateway/run.py::_handle_compress_command``) share one implementation. The slash-command surfaces handle compression of the *head* via the existing ``_compress_context`` pipeline (preserving all the session-rotation / lock / memory-notify machinery) and then re-append the verbatim *tail* returned here. Design notes / invariants honored: * **Role alternation.** The compressed head ends with summary/handoff content (assistant- or user-role, possibly a trailing todo snapshot). The verbatim tail must begin with a ``user`` message so the rejoined history keeps the user↔assistant alternation that providers validate. :func:`split_history_for_partial_compress` snaps the tail boundary backwards to the nearest ``user`` turn so the rejoin is always legal. * **No silent context mutation.** This is a manual, user-invoked action. It rotates the session exactly like ``/compress`` does (via the caller), so the prompt-cache reset is explicit and expected, not silent. * **Conservative defaults.** ``keep_last`` counts *exchanges* (a user turn plus its following assistant/tool turns), defaulting to 2. The split never compresses if doing so would leave nothing in the head. ) annotations)AnyDictListOptionalTupledc|xsdj}|s dtdfS|j}|jdr|t dd}|t dd}|j }|r/|ddk(r't}t |dk\rt |d }d |dfS|r&|dd vrt |dk\rd t |d dfS|r8|djd r$d t |dj d d d dfSdt|xsdfS)uParse the argument string after ``/compress``. Recognizes the boundary-aware forms: * ``here`` → partial compress, keep ``DEFAULT_KEEP_LAST`` * ``here 4`` → partial compress, keep 4 exchanges * ``--keep 4`` → partial compress, keep 4 exchanges * ``up to here`` → alias for ``here`` (matches Claude Code's menu label "Summarize up to here") Anything else is treated as a focus topic for the existing full ``/compress `` behavior. Returns ``(partial, keep_last, focus_topic)``: * ``partial`` — True when a boundary-aware form was requested. * ``keep_last`` — exchanges to preserve verbatim (only meaningful when ``partial`` is True). * ``focus_topic`` — focus string for full compression, or None. Always None when ``partial`` is True (the two modes are exclusive; a focused partial compress is not a documented Claude Code behavior and would muddy the UX). FNz up to herezup to rherer T)z--keepz-kz--keep==)stripDEFAULT_KEEP_LASTlower startswithlensplit _coerce_keep)raw_argstextloweredtokenskeeps N/root/.hermes/venv/lib/python3.12/site-packages/hermes_cli/partial_compress.pyparse_partial_compress_argsr7s)4 N ! ! #D '--jjlG,'#h-/*CMO$ ]]_F&)v%  v;! q *DT4&)//CK14D\&),d22 &)&&y1\&)//#q"9!"<=tCC #T\T 11cd}d}g}|xsdjD]2}|j}|dvrd}|dk(rd}"|j|4dj|||fS)uStrip ``--preview``/``--dry-run``/``--aggressive`` flags from the argument string after ``/compress`` (or its ``/compact`` alias). Flags may appear anywhere and coexist with the positional forms (``here [N]``, ``--keep N``, or a focus topic); the returned remainder is what :func:`parse_partial_compress_args` should see. Returns ``(remaining_args, preview, aggressive_requested)``: * ``preview`` — True when ``--preview`` or ``--dry-run`` was given. The caller must report what WOULD be compressed (message counts, token estimate, boundary) and make **no changes**. * ``aggressive_requested`` — True when ``--aggressive`` was given. The current surfaces do not implement an LLM-free hard-truncate path (it would need its own transcript-persistence branch outside the guarded ``_compress_context`` rotation machinery), so callers surface a "not supported" note instead of silently treating the flag as a focus topic. Fr )z --previewz --dry-runz--dryrunTz --aggressive )rrappendjoin)rpreview aggressivekepttoklows rextract_compress_flagsr(osx(GJDB%%'iik 8 8G N "J KK  88D>7J ..rct|}t|}g}|}|r t||\}}|sd}t|g}}ddt|d|d|ddg} |r"| jd|d t|d n|r| jd |r| jd |d | jdt|t|||| dS)uBuild the ``/compress --preview`` report — pure, no side effects. Shared by the CLI (``cli.py::_manual_compress``) and the gateway (``gateway/slash_commands.py::_handle_compress_command``) so both surfaces report the same numbers the real run would use. Returns a dict with ``head_count``/``tail_count``/``lines`` where ``lines`` is a ready-to-print list of report strings. FuPreview — no changes made.zWould compress z of z message(s) (~,z tokens currently in context).zBoundary: keeping the last z exchange(s) (z message(s)) verbatim.uRBoundary: 'here' split would keep everything — falling back to full compression.zFocus topic: ""z1Run the command again without --preview to apply.) head_count tail_counttotalpartiallines)rlist"split_history_for_partial_compressr!) historyr/ keep_last focus_topic approx_tokensr.headtaileffective_partialr0s rsummarize_compress_previewr:s  LE =D!#D7K d % g$D ' #d)D0 1 ; = E  ))5D {0 2    0  ~k]!45 LLDE$i$i$  rc~ t|}|dkry|tkDrtS|S#ttf$r tcYSwxYw)z9Parse a keep-count token, clamping to [1, MAX_KEEP_LAST].r)int TypeError ValueErrorr MAX_KEEP_LAST)valuens rrrsK! J 1u= H z "!  !s $<<c:|dkrd}t|}|dk(rggfSg}t|dz ddD];}||jddk(s|j|t||k\s;n|s t |gfS|d}|d|}||d}|s t |gfS||fS)uOSplit ``history`` into ``(head, tail)`` for partial compression. ``head`` is the earlier portion that will be summarized; ``tail`` is the most recent ``keep_last`` exchanges, preserved verbatim. An *exchange* is counted by ``user``-role messages: keeping N exchanges means keeping everything from the Nth-most-recent ``user`` message onward. This guarantees the tail starts on a ``user`` turn, so when the caller rejoins ``compressed_head + tail`` the user↔assistant alternation stays valid (the compressed head's trailing content is followed by a fresh user turn). Returns ``(head, tail)``. If the split would leave the head empty (not enough history to compress meaningfully), returns ``(history, [])`` — signaling the caller to fall back to full compression or report "nothing to do". rrroleuserN)rrangegetr!r1)r3r4rA user_startsidxboundaryr7r8s rr2r2s*1}  G AAv2v  KQUB# 3<  F #v -   s #;9,  G}b  2H 9H D 89 D G}b  :rc|s t|S|s t|St|}t|}|d}|d}|jd}|jd}||k(r|dvr|jd}|jd} t|tr4t| tr$t |} |d| | d<| |d<|dd}||zS|d k(rd nd } |j | d d ||zS) u0Concatenate a compressed head with the verbatim tail, defending the seam against an illegal user→user / assistant→assistant adjacency. In normal operation the compressed head ends with the head's own protected verbatim tail (the ``ContextCompressor`` always preserves a recent window), which terminates on an ``assistant``/``tool`` turn — so ``assistant → user`` at the seam is already valid. But the head compressor's exact output shape is not contractually guaranteed (a plugin context engine could return something that ends on a ``user`` turn, or a degenerate single-summary message). Rather than trust the seam, this helper inspects the boundary and, if the last head message and the first tail message share a ``user``/``assistant`` role, folds the tail's first message content onto the head's last message so the rejoined list never violates provider role-alternation rules. ``tool`` messages are left alone — consecutive ``tool`` entries are the one legal repetition (parallel tool results). rCrrD)rE assistantcontentz rNrErLr )rDrM)r1rG isinstancestrdictr!) compressed_headr8r7restlastfirst last_role first_role last_content first_contentmerged bridge_roles rrejoin_compressed_head_and_tailr[ s , O$$ Dz  D :D 8D GE I6"JJ90E#E xx *  ), lC (Z s-K$ZF#/.]O DF9 DH8D $;*4v)=+6K KK< = $;rN)rrOreturnzTuple[bool, int, Optional[str]])rrOr\zTuple[str, bool, bool]) r3List[Dict[str, Any]]r/boolr4r<r5z Optional[str]r6r<r\zDict[str, Any])r@rOr\r<)r3r]r4r<r\z1Tuple[List[Dict[str, Any]], List[Dict[str, Any]]])rQr]r8r]r\r])__doc__ __future__rtypingrrrrrrr?rr(r:rr2r[rrrcs'R#33 5252$52p/D4 !4 44 4  4  4n  5 !5575p7)7 77r