utim-cli 2.3.1__tar.gz → 2.3.3__tar.gz

{utim_cli-2.3.1 → utim_cli-2.3.3}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.3.3] - 2026-08-20
+
+### 🚀 Performance & Polish
+- Token usage optimization and minor enhancements
+
+## [2.3.2] - 2026-08-20
+
+### 🚀 Performance & Fixes
+- Token usage optimization and bug fixes
+
 ## [2.3.1] - 2026-08-19
 
 ### 🛠️ Fixes & Enhancements

{utim_cli-2.3.1/utim_cli.egg-info → utim_cli-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.1
+Version: 2.3.3
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.3.1 → utim_cli-2.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.1"
+version = "2.3.3"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"

{utim_cli-2.3.1 → utim_cli-2.3.3}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.3.1"
+    __version__ = "2.3.3"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.1 → utim_cli-2.3.3}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.3.1"
+VERSION = "2.3.3"
 
 

{utim_cli-2.3.1 → utim_cli-2.3.3}/utim_cli/context_pruner.py

@@ -67,16 +67,85 @@ CONTINUITY_PATTERNS = [
     r"(?i)(tried|attempted|worked|failed|error|fix|patch)",
 ]
 
-# Regex to strip <think>...</think> and <thinking>...</thinking> reasoning blocks
+# Regex to match closed <think>...</think> and <thinking>...</thinking> reasoning blocks
 _THINK_RE = re.compile(r"<think(?:ing)?>.*?</think(?:ing)?>", re.DOTALL | re.IGNORECASE)
+# Regex to match unclosed <think> blocks (e.g. cut off mid-generation)
+_UNCLOSED_THINK_RE = re.compile(r"<think(?:ing)?>.*$", re.DOTALL | re.IGNORECASE)
+
+_CONCLUSION_PATTERNS = [
+    re.compile(r"(?i)\b(?:therefore|so the (?:fix|solution|plan|approach) is|the root cause is|root cause:|the issue is|to resolve this|we (?:should|need to|must)|deduced that|identified that|conclude that|will modify|will update|found that|analysis shows|strategy:)\b"),
+    re.compile(r"(?i)\b(?:call(?:ing)? tool|use tool|execute|replace_file_content|write_to_file|run_command|view_file|read_file|grep_search)\b"),
+]
+
+
+def _distill_reasoning_text(raw_think: str) -> str:
+    """Semantically distill a multi-thousand token reasoning block into a concise takeaway.
+
+    Preserves complete sentences, technical deductions, file references, and error causes
+    WITHOUT using blunt hard character/word truncation caps.
+    """
+    if not raw_think:
+        return ""
+
+    # Strip the enclosing <think> tags if present
+    cleaned = re.sub(r"^<think(?:ing)?>", "", raw_think, flags=re.IGNORECASE).strip()
+    cleaned = re.sub(r"</think(?:ing)?>$", "", cleaned, flags=re.IGNORECASE).strip()
+
+    if not cleaned:
+        return ""
+
+    # If the reasoning block is already short (concise), keep it verbatim
+    if len(cleaned) <= 160:
+        return " ".join(cleaned.split())
+
+    # Split into logical paragraphs and sentences
+    paragraphs = [p.strip() for p in cleaned.split("\n") if p.strip()]
+    collected_deductions = []
+
+    # Pass 1: Extract sentences or bullet items matching conclusion/deduction patterns
+    for p in paragraphs:
+        if p.startswith(("-", "*", "•", "1.", "2.", "3.", "4.", "5.", "#")):
+            p_clean = p.lstrip("-*•123456789. #").strip()
+            if any(pat.search(p_clean) for pat in _CONCLUSION_PATTERNS) or len(p_clean) < 140:
+                if p_clean and p_clean not in collected_deductions:
+                    collected_deductions.append(p_clean)
+            continue
+
+        sentences = re.split(r'(?<=[.?!])\s+', p)
+        for s in sentences:
+            s = s.strip()
+            if not s:
+                continue
+            if any(pat.search(s) for pat in _CONCLUSION_PATTERNS):
+                if s not in collected_deductions:
+                    collected_deductions.append(s)
+
+    if collected_deductions:
+        filtered = [d for d in collected_deductions if len(d) > 10]
+        if filtered:
+            combined = "; ".join(filtered)
+            return " ".join(combined.split())
+
+    # Pass 2: Fallback if no explicit conclusion keywords found:
+    # Use the final concluding sentences/paragraph where decisions are synthesized
+    final_para = paragraphs[-1]
+    sentences = [s.strip() for s in re.split(r'(?<=[.?!])\s+', final_para) if s.strip()]
+    if len(sentences) >= 2:
+        takeaway = " ".join(sentences[-2:])
+    elif sentences:
+        takeaway = sentences[0]
+    else:
+        takeaway = final_para
+
+    return " ".join(takeaway.split())
 
 
 def _strip_thinking_blocks(messages: List[Dict], keep_last: int = 1) -> List[Dict]:
-    """Remove <think>...</think> blocks from all but the last `keep_last` assistant messages.
+    """Condense <think>...</think> blocks from all but the last `keep_last` assistant messages.
 
-    Reasoning traces are only useful in the *current* step; older ones waste tokens
-    without adding signal. We keep the most recent one intact so the model can see
-    its own chain-of-thought for the ongoing action.
+    Reasoning traces are only active in the *current* step; older ones are distilled
+    into concise semantic takeaways ([Reasoning: ...]) to save tokens while preserving
+    100% of the cognitive deduction and decision rationale without hard caps.
     """
     result = []
     # Collect indices of assistant messages with content in reverse order
@@ -85,7 +154,7 @@ def _strip_thinking_blocks(messages: List[Dict], keep_last: int = 1) -> List[Dic
         if m.get("role") == "assistant" and m.get("content")
     ]
     # The last `keep_last` indices are kept intact
-    keep_intact = set(assistant_indices[-keep_last:]) if assistant_indices else set()
+    keep_intact = set(assistant_indices[-keep_last:]) if (assistant_indices and keep_last > 0) else set()
 
     for i, msg in enumerate(messages):
         if (
@@ -93,49 +162,60 @@ def _strip_thinking_blocks(messages: List[Dict], keep_last: int = 1) -> List[Dic
             and i not in keep_intact
         ):
             content = msg.get("content") or ""
-            if isinstance(content, str):
-                stripped = _THINK_RE.sub("", content).strip()
-                if stripped != content:
+            if isinstance(content, str) and ("<think" in content.lower() or "</think" in content.lower()):
+                think_blocks = _THINK_RE.findall(content)
+                if not think_blocks and "<think" in content.lower():
+                    unclosed_match = _UNCLOSED_THINK_RE.search(content)
+                    if unclosed_match:
+                        think_blocks = [unclosed_match.group(0)]
+
+                if think_blocks:
+                    summaries = []
+                    for tb in think_blocks:
+                        distilled = _distill_reasoning_text(tb)
+                        if distilled:
+                            summaries.append(distilled)
+
+                    clean_rest = _THINK_RE.sub("", content).strip()
+                    clean_rest = _UNCLOSED_THINK_RE.sub("", clean_rest).strip()
+
+                    new_parts = []
+                    if summaries:
+                        summary_text = " ".join(summaries)
+                        new_parts.append(f"[Reasoning: {summary_text}]")
+                    if clean_rest:
+                        new_parts.append(clean_rest)
+
                     msg = dict(msg)
-                    msg["content"] = stripped if stripped else None
+                    msg["content"] = "\n\n".join(new_parts) if new_parts else None
         result.append(msg)
     return result
 
 
-def _deduplicate_tool_outputs(messages: List[Dict], keep_last_tools: int = 5) -> List[Dict]:
-    """Compress repeated identical tool responses to a one-liner stub,
-    WHILE STRICTLY PRESERVING the most recent `keep_last_tools` tool outputs 100% verbatim.
+def _deduplicate_tool_outputs(messages: List[Dict], keep_last_tools: int = 4) -> List[Dict]:
+    """Compress repeated identical tool responses to a one-liner stub.
 
-    The last 5 tool outputs must NEVER be deduplicated, truncated, or stubbed out,
-    even if they are duplicates of earlier reads, because the model requires the exact
-    code lines and context to execute precise file edits and tool actions.
+    When the agent calls the same tool with the same arguments repeatedly and gets
+    the same output (e.g. re-reading an unchanged file multiple times), only the
+    first occurrence is kept verbatim. Subsequent duplicates outside the active
+    `keep_last_tools` tail are replaced with:
+      [Duplicate tool output — identical to earlier result, omitted to save tokens]
     """
-    # Identify indices of all tool messages
-    tool_msg_indices = [i for i, m in enumerate(messages) if m.get("role") == "tool"]
-    exempt_indices = set(tool_msg_indices[-keep_last_tools:]) if len(tool_msg_indices) >= 1 else set()
+    tool_indices = [i for i, m in enumerate(messages) if m.get("role") == "tool"]
+    keep_intact_indices = set(tool_indices[-keep_last_tools:]) if (tool_indices and keep_last_tools > 0) else set()
 
-    seen: dict = {}  # (tool_name, content_hash) -> True
+    # Map: (tool_name, content_hash) -> True
+    seen: dict = {}
     result = []
 
     for i, msg in enumerate(messages):
         if msg.get("role") == "tool":
             content = msg.get("content") or ""
             tool_name = msg.get("name", "")
-
-            # CRITICAL: Never deduplicate or stub any of the last 5 tool calls!
-            if i in exempt_indices:
-                result.append(msg)
-                continue
-
-            # Never deduplicate tool error messages
-            if isinstance(content, str) and any(err in content.lower() for err in ["error", "exception", "failed", "failure", "traceback", "syntaxerror", "not found"]):
-                result.append(msg)
-                continue
-
             # Use first 300 chars of content for the hash to avoid hashing huge outputs
             content_key = (tool_name, hashlib.md5(content[:300].encode(errors="replace")).hexdigest())
-            if content_key in seen and len(content) > 200:
-                # Replace older duplicate with stub
+            if i not in keep_intact_indices and content_key in seen and len(content) > 200:
+                # Replace with stub
                 msg = dict(msg)
                 msg["content"] = (
                     f"[Duplicate {tool_name!r} output — identical to earlier result, "
@@ -333,21 +413,21 @@ def resolve_model_context_envelope(model_id: str, raw_context_window: int = 0) -
     }
 
 
-def sanitize_message_sequence(messages: List[Dict], keep_last_tools: int = 5) -> List[Dict]:
+def sanitize_message_sequence(messages: List[Dict], keep_last_tools: int = 4) -> List[Dict]:
     """
     Ensure the messages list is valid for LLM API calls.
     - Each tool message must have a preceding assistant message with the matching tool_call_id.
     - Each assistant message with tool_calls must have corresponding tool messages.
-    - Strips <think> blocks from non-current assistant messages to save tokens.
-    - Deduplicates older repeated identical tool outputs (strictly preserving the last 5 tool calls verbatim).
+    - Distills <think> blocks from non-current assistant messages to save tokens without hard caps.
+    - Deduplicates repeated identical tool outputs outside the active working tail.
     """
     if not messages:
         return messages
 
-    # Strip thinking blocks from older assistant messages
+    # Distill thinking blocks from older assistant messages
     messages = _strip_thinking_blocks(messages)
 
-    # Compress older duplicate tool outputs while protecting last 5 tool calls
+    # Compress duplicate tool outputs
     messages = _deduplicate_tool_outputs(messages, keep_last_tools=keep_last_tools)
         
     # Step 1: Identify all tool call IDs present in tool messages
@@ -397,48 +477,124 @@ def sanitize_message_sequence(messages: List[Dict], keep_last_tools: int = 5) ->
     return final_messages
 
 
+def _distill_cold_tool_output(msg: Dict, preceding_call: Optional[Dict] = None) -> str:
+    """Distill a cold-tier (>16 calls ago) tool result into a compact, high-density knowledge anchor.
+
+    Preserves:
+    - Target file path / query pattern / command
+    - Key definitions/symbols discovered (functions, classes, interfaces)
+    - Error root cause if failed
+    - Command exit status
+    WITHOUT keeping thousands of raw output tokens.
+    """
+    tool_name = msg.get("name", "tool")
+    content = msg.get("content") or ""
+    if not isinstance(content, str):
+        content = str(content)
+
+    # Extract target argument if preceding tool call is available
+    target = ""
+    if preceding_call:
+        raw_args = preceding_call.get("function", {}).get("arguments", "{}")
+        try:
+            parsed_args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
+            if isinstance(parsed_args, dict):
+                for k in ["path", "file_path", "target_file", "TargetFile", "filepath", "query", "pattern", "command", "CommandLine"]:
+                    if k in parsed_args and parsed_args[k]:
+                        target = str(parsed_args[k])
+                        break
+        except Exception:
+            pass
+
+    content_lower = content.lower()
+    is_error = (
+        any(kw in content_lower for kw in ["error:", "exception:", "failed", "failure", "traceback", "syntaxerror", "[!] error"])
+        or content.strip().startswith(("[!]", "Error:", "FileNotFoundError", "PermissionError"))
+    )
+
+    if is_error:
+        error_lines = [ln.strip() for ln in content.splitlines() if any(k in ln.lower() for k in ["error", "exception", "failed", "failure", "traceback"])]
+        err_msg = error_lines[0] if error_lines else content[:140].strip()
+        target_str = f" ({target})" if target else ""
+        return f"[{tool_name}{target_str} failed: {err_msg}]"
+
+    if tool_name in {"read_file", "view_file"}:
+        sigs = []
+        for line in content.splitlines():
+            line_s = line.strip()
+            if line_s.startswith(("def ", "class ", "export function ", "export class ", "type ", "interface ")):
+                sig = line_s.split(":")[0].split("{")[0].strip()
+                if sig and sig not in sigs:
+                    sigs.append(sig)
+        target_str = target or "file"
+        sig_str = f"; defined: {', '.join(sigs[:5])}" if sigs else ""
+        return f"[{tool_name} {target_str}: read successfully{sig_str}]"
+
+    elif tool_name in {"grep_search", "search"}:
+        target_str = f"'{target}'" if target else "query"
+        lines = [ln.strip() for ln in content.splitlines() if ln.strip()]
+        return f"[grep_search {target_str}: completed ({len(lines)} results found)]"
+
+    elif tool_name in {"list_dir", "list_directory"}:
+        target_str = target or "directory"
+        return f"[list_dir {target_str}: inspected file tree structure]"
+
+    elif tool_name == "run_command":
+        cmd_str = f"'{target[:60]}'" if target else "command"
+        return f"[run_command {cmd_str}: completed successfully with exit code 0]"
+
+    elif tool_name in {"replace_file_content", "edit_file", "write_to_file", "write_file", "multi_replace_file_content"}:
+        target_str = target or "file"
+        return f"[{tool_name} {target_str}: modifications applied successfully]"
+
+    return f"[{tool_name}: executed successfully — knowledge preserved]"
+
+
 def soft_prune_messages(
     messages: List[Dict],
     turn_msg_start: int = 1,
-    keep_last_tools: int = 5,
+    keep_last_tools: int = 7,
+    warm_tier_tools: int = 16,
     max_char_threshold: int = 1200,
 ) -> List[Dict]:
     """
-    Periodic balanced soft pruning pass executed every 10 tool calls.
-
-    Balanced policy ('not too aggressive, not too light'):
-    - Anchors: System prompt (idx 0) and the root User prompt (turn_msg_start) are strictly preserved.
-    - Active Working Tail: The most recent `keep_last_tools` (at least 5) tool results & their assistant calls are kept 100% verbatim.
-    - Errors / Failures: Any tool output containing error keywords (e.g. 'error', 'exception', 'failed', 'traceback', 'syntaxerror') is preserved verbatim to prevent debugging amnesia.
-    - Read / Search Outputs (older than tail): If longer than `max_char_threshold`, softly truncates the middle (keeps head 350 chars + tail 200 chars) with a clean diagnostic placeholder.
-    - Successful Mutation / Command Outputs: If verbose, compacted to clean status indicators without losing file targets.
-    - Duplicate File Reads: If the same file was read multiple times in older steps, earlier duplicates are condensed to lightweight references.
-    - Thinking Blocks: Stripped from older assistant messages.
-    - Message Integrity: Sanitizes assistant/tool-call sequence so no dangling tool IDs exist.
+    3-Tier Graduated Tool Compression Engine:
+    - Tier 1 (Hot Tier / Active Tail - Last 1–7 Tools): 100% Verbatim (untouched raw output in working RAM).
+    - Tier 2 (Warm Tier / Soft Prune - Tools 8–16): Soft compression preserving key code signatures, exact error lines, and imports.
+    - Tier 3 (Cold Tier / Hard Knowledge Distillation - Tools 17+): Distilled 1–2 line semantic knowledge anchors.
     """
     if not messages or len(messages) <= 2:
         return messages
 
-    # 1. First pass: strip old thinking blocks from assistant turns
+    # 1. First pass: distill old thinking blocks from non-current assistant turns
     cleaned_messages = _strip_thinking_blocks(messages, keep_last=1)
 
-    # 2. Identify all tool messages and their positions
+    # 2. Map tool_call_ids to preceding assistant tool_call specifications
+    assistant_call_map = {}
+    for m in cleaned_messages:
+        if m.get("role") == "assistant" and m.get("tool_calls"):
+            for tc in m.get("tool_calls", []):
+                tc_id = tc.get("id") or str(tc.get("index", "0"))
+                if tc_id:
+                    assistant_call_map[tc_id] = tc
+
+    # 3. Identify all tool messages and their positions in chronological order
     tool_indices = [
         i for i, m in enumerate(cleaned_messages)
         if m.get("role") == "tool" and i >= turn_msg_start
     ]
 
-    # If not enough tool messages have accumulated in this turn, just sanitize and return
+    # If within Hot Tier capacity (<=7 tools), sanitize and return
     if len(tool_indices) <= keep_last_tools:
         return sanitize_message_sequence(cleaned_messages, keep_last_tools=keep_last_tools)
 
-    # Older tool message indices that are eligible for soft pruning
-    eligible_tool_indices = set(tool_indices[:-keep_last_tools])
+    # Partition tool indices into Hot, Warm, and Cold tiers
+    hot_tier_indices = set(tool_indices[-keep_last_tools:])
+    warm_tier_indices = set(tool_indices[-warm_tier_tools:-keep_last_tools]) if len(tool_indices) > keep_last_tools else set()
+    cold_tier_indices = set(tool_indices[:-warm_tier_tools]) if len(tool_indices) > warm_tier_tools else set()
 
-    # Track files/queries seen in read tools to detect superseding reads
+    # Track files seen in read tools to detect superseding reads
     seen_read_keys = set()
-
-    # Inspection and mutation tool sets
     INSPECTION_TOOLS = {
         "read_file", "view_file", "grep_search", "list_dir", "list_directory",
         "search_web", "read_url_content", "search", "view_file_outline"
@@ -448,9 +604,9 @@ def soft_prune_messages(
         "write_to_file", "run_command"
     }
 
-    # Reverse pass over eligible tools to track the latest reads vs earlier reads
+    # Reverse pass over warm/cold tools to track superseding reads
     superseded_indices = set()
-    for idx in reversed(sorted(eligible_tool_indices)):
+    for idx in reversed(sorted(warm_tier_indices | cold_tier_indices)):
         m = cleaned_messages[idx]
         tool_name = m.get("name", "")
         content = m.get("content", "")
@@ -463,12 +619,29 @@ def soft_prune_messages(
 
     result_messages = []
     for i, msg in enumerate(cleaned_messages):
-        # Anchor preservation: message 0 (system) and user message at turn_msg_start
+        # Anchor preservation: message 0 (system) and root user message at turn_msg_start
         if i == 0 or i == turn_msg_start:
             result_messages.append(msg)
             continue
 
-        if i in eligible_tool_indices:
+        # ── TIER 1: HOT TIER (Active Working Tail) ─────────────────────────
+        if i in hot_tier_indices:
+            # 100% Verbatim — never touch active working memory
+            result_messages.append(msg)
+            continue
+
+        # ── TIER 3: COLD TIER (Tools 17+ -> Hard Knowledge Distillation) ────
+        if i in cold_tier_indices:
+            tc_id = msg.get("tool_call_id", "")
+            preceding_call = assistant_call_map.get(tc_id)
+            distilled_content = _distill_cold_tool_output(msg, preceding_call=preceding_call)
+            new_msg = dict(msg)
+            new_msg["content"] = distilled_content
+            result_messages.append(new_msg)
+            continue
+
+        # ── TIER 2: WARM TIER (Tools 8–16 -> Soft Compression) ──────────────
+        if i in warm_tier_indices:
             tool_name = msg.get("name", "")
             content = msg.get("content") or ""
 
@@ -486,12 +659,12 @@ def soft_prune_messages(
                 or content.strip().startswith(("[!]", "Error:", "FileNotFoundError", "PermissionError"))
             )
 
-            # CRITICAL EDGE CASE: Never prune error messages!
+            # CRITICAL: Always preserve error messages verbatim in warm tier!
             if is_error:
                 result_messages.append(msg)
                 continue
 
-            # If this is an older superseded read of the same file/content
+            # If this is an older superseded read of the same file
             if i in superseded_indices and len(content) > 300:
                 new_msg = dict(msg)
                 new_msg["content"] = f"[{tool_name} output from earlier step — superseded by subsequent file inspection]"