(Gje1jdZddlmZddlmZmZmZmZmZdZ dZ d d Z d!d Z d"dZ d#dZd$dZd%dZdS)&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)AnyDictListOptionalTupledraw_argsstrreturnTuple[bool, int, Optional[str]]c|pd}|s dtdfS|}|dr.|t dd}|t dd}|}|r@|ddkr4t}t |dkrt |d }d |dfS|r5|dd vr+t |dkrd t |d dfS|rM|dd r2d t |dd d d dfSdt|pdfS)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)r textloweredtokenskeeps A/home/rurouni/.hermes/hermes-agent/hermes_cli/partial_compress.pyparse_partial_compress_argsr 7sz4 N ! ! # #D .'--jjllG,''%#h--//*CMMOO$ ]]__F &)v%%  v;;!  q **DT43&)///CKK14D4D\&),,d22 D&)&&y11D\&)//#q"9"9!"<==tCC #T\T 11Tuple[str, bool, bool]cd}d}g}|pdD];}|}|dvrd}|dkrd}&||>7J ..r!historyList[Dict[str, Any]]partialbool keep_lastint focus_topic Optional[str] approx_tokensDict[str, Any]ct|}t|}g}|}|r(t||\}}|sd}t|g}}ddt|d|d|ddg} |r*| d|d t|d n|r| d |r| d |d | dt|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_counttotalr/lines)rlist"split_history_for_partial_compressr%) r-r/r1r3r5r<headtaileffective_partialr=s rsummarize_compress_previewrCs{ LLE ==D!#D+7KK d + % g$D ' =#d)) = = = = < = = = E     2) 2 2D  2 2 2        0   6 4k444555 LLDEEE$ii$ii$   r!valuec t|}n#ttf$r tcYSwxYw|dkrdS|tkrtS|S)z9Parse a keep-count token, clamping to [1, MAX_KEEP_LAST].r)r2 TypeError ValueErrorr MAX_KEEP_LAST)rDns rrrsd! JJ z "!!!    !1uuq= Hs --1Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]c|dkrd}t|}|dkrggfSg}t|dz ddD]K}||ddkr*||t||krnL|st |gfS|d}|d|}||d}|st |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%r>)r-r1rI user_startsidxboundaryr@rAs rr?r?s*1}}  G AAvv2v  KQUB## 3<  F # #v - -   s # # #;9,, !G}}b  2H 9H9 D 899 D !G}}b  :r!compressed_headrAcR|st|S|st|St|}t|}|d}|d}|d}|d}||kr|dvr|d}|d} t|tr>t| tr)t |} |d| | d<| |d<|dd}n"|d krd nd } || 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). rLrrM)rN assistantcontentz rNrNrVr)rMrW)r>rP isinstancer dictr%) rTrAr@restlastfirst last_role first_role last_content first_contentmerged bridge_roles rrejoin_compressed_head_and_tailrc sK, %O$$$ Dzz  D ::D 8D GE  I6""JJ90E#E#E xx **  ),, lC ( ( >Z s-K-K >$ZZF#/ D D] D DF9 DH8DD *4v)=)=++6K KK<< = = = $;r!N)r r r r)r r r r") r-r.r/r0r1r2r3r4r5r2r r6)rDr r r2)r-r.r1r2r rJ)rTr.rAr.r r.)__doc__ __future__rtypingrrrrrrrHr r,rCrr?rcr!rrhs''R#"""""33333333333333 52525252p////D4444n     5555p777777r!