utim-cli 2.5.5__tar.gz → 2.6.0__tar.gz

{utim_cli-2.5.5 → utim_cli-2.6.0}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [2.6.0] - 2026-11-03
+
+### ✨ New Theme
+- **Fresh UI Theme**: A brand-new visual theme for the CLI and website, with refreshed colours, cleaner spacing, and a sharper overall look.
+- **UI Enhancements**: Polish across menus, panels, and prompts for a more consistent and modern feel.
+
+### 🐛 Fixes
+- **Bug Fixes**: A round of stability and reliability fixes across the app.
+
 ## [2.5.5] - 2026-10-29
 
 ### 🐛 Fixes

{utim_cli-2.5.5/utim_cli.egg-info → utim_cli-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.5.5
+Version: 2.6.0
 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.5.5 → utim_cli-2.6.0}/pyproject.toml

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

{utim_cli-2.5.5 → utim_cli-2.6.0}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.5.5"
+    __version__ = "2.6.0"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.5.5 → utim_cli-2.6.0}/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.5.5"
+    __version__ = "2.6.0"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.5.5 → utim_cli-2.6.0}/utim_cli/_version.py

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

{utim_cli-2.5.5 → utim_cli-2.6.0}/utim_cli/agent.py

@@ -228,6 +228,42 @@ class ReActAgent:
         self.console.print(_pre)
         pre_plain = f"{meta['verb']}({primary_arg}) (ctrl+o to expand)" if primary_arg else f"{meta['verb']} (ctrl+o to expand)"
         self._last_running_indicator_len = len(pre_plain)
+        # Remember that a provisional line is on screen, and the paint
+        # generation at the moment we wrote it. _erase_running_line() uses
+        # both: a blind CSI-1F erase is only safe while nothing has painted
+        # since, otherwise it corrupts the screen or leaves a duplicate header
+        # (the "Verb(x) · running" + "Verb(x)" double print).
+        self._running_line_live = True
+        try:
+            from utim_cli.state import STATE as _STG
+            self._running_line_paint_gen = _STG.get("_paint_gen", 0)
+        except Exception:
+            self._running_line_paint_gen = None
+
+        def _erase_running_line() -> None:
+            """Guarded replacement for the blind CSI-1F erase loops below."""
+            if not getattr(self, "_running_line_live", False):
+                return
+            self._running_line_live = False
+            try:
+                from utim_cli.state import STATE as _ST
+                if _ST.get("_paint_gen", 0) != getattr(self, "_running_line_paint_gen", None):
+                    # Something repainted while the tool ran; the cursor is no
+                    # longer under our header. Do not blind-erase.
+                    return
+            except Exception:
+                pass
+            try:
+                width = self.console.size.width
+            except Exception:
+                width = 80
+            import math
+            num_lines = math.ceil(
+                getattr(self, "_last_running_indicator_len", 0) / max(1, width)
+            )
+            num_lines = max(0, min(num_lines, 5))   # never wipe more than 5 rows
+            for _ in range(num_lines):
+                self.console.print("\033[F\033[K", end="")
 
         if "__" in tool_name:
             server_name, actual_tool_name = tool_name.split("__", 1)
@@ -240,25 +276,11 @@ class ReActAgent:
                     # Temporarily register metadata for render
                     TOOL_META[tool_name] = {"icon": "", "verb": f"Calling {server_name} ➔ {actual_tool_name}", "color": "#cba6f7"}
                     # Erase the running line first
-                    try:
-                        width = self.console.size.width
-                    except Exception:
-                        width = 80
-                    import math
-                    num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-                    for _ in range(num_lines):
-                        self.console.print("\033[F\033[K", end="")
+                    _erase_running_line()
                     self._render_tool_panel(tool_name, arguments, result)
                     return str(result)
             except Exception as e:
-                try:
-                    width = self.console.size.width
-                except Exception:
-                    width = 80
-                import math
-                num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-                for _ in range(num_lines):
-                    self.console.print("\033[F\033[K", end="")
+                _erase_running_line()
                 return f"Error executing MCP tool {tool_name}: {str(e)}"
 
         utim_tools, tool_functions = get_tools()
@@ -275,25 +297,11 @@ class ReActAgent:
             filtered_args = dict(arguments) if has_var_kw else {k: v for k, v in arguments.items() if k in sig.parameters}
             result = tool_functions[tool_name](**filtered_args)
             # Erase the running line first
-            try:
-                width = self.console.size.width
-            except Exception:
-                width = 80
-            import math
-            num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-            for _ in range(num_lines):
-                self.console.print("\033[F\033[K", end="")
+            _erase_running_line()
             self._render_tool_panel(tool_name, arguments, result)
             return str(result)
         except Exception as e:
-            try:
-                width = self.console.size.width
-            except Exception:
-                width = 80
-            import math
-            num_lines = math.ceil(getattr(self, "_last_running_indicator_len", 40) / max(1, width))
-            for _ in range(num_lines):
-                self.console.print("\033[F\033[K", end="")
+            _erase_running_line()
 
             # Auto-repair: if the tool failed due to a syntax error in the
             # generated code, attempt an "on the go" syntax fix before

{utim_cli-2.5.5 → utim_cli-2.6.0}/utim_cli/client_utils.py

@@ -6,6 +6,8 @@ import hashlib
 import uuid
 import math
 import threading
+import time
+import time
 from typing import Optional, List, Dict, Any, Union, Tuple
 import requests
 from utim_cli.config import config
@@ -1928,8 +1930,7 @@ def get_session_usage(session_id: str = "") -> dict:
     return _read_all_usage().get(eff_id, empty)
 
 
-def update_session_usage(
-    usage_type: str,
+def update_session_usage(    usage_type: str,
     input_tokens: int = 0,
     output_tokens: int = 0,
     credits_used: float = 0.0,
@@ -1973,9 +1974,154 @@ def update_session_usage(
         entry["tools_credits"]       = entry.get("tools_credits",       0.0) + credits_used
 
     all_sessions[eff_id] = entry
+    # Stamp the write time so `get_monthly_usage` can bucket this session into
+    # the correct calendar month later (sessions without a stamp are skipped).
+    try:
+        entry["updated_at"] = time.time()
+    except Exception:
+        pass
     _write_all_usage(all_sessions)
 
 
+def _sum_sessions(all_sessions, include_sid=None, month_filter=None):
+    """Shared aggregation core for monthly / lifetime usage rollups.
+
+    Parameters
+    ----------
+    include_sid   : session id that is *always* counted regardless of date
+                    (the live session is by definition current).
+    month_filter  : (year, month) tuple, or None to count every session.
+
+    Returns
+    -------
+    dict with input_tokens, output_tokens, total_tokens, credits,
+    sessions_counted, sessions_skipped.
+
+    Sessions lacking any timestamp are counted only when `month_filter` is None
+    (lifetime), because there is no month to mis-attribute them to.
+    """
+    import datetime as _dt
+
+    out = {
+        "input_tokens": 0,
+        "output_tokens": 0,
+        "total_tokens": 0,
+        "credits": 0.0,
+        "sessions_counted": 0,
+        "sessions_skipped": 0,
+    }
+
+    for sid, entry in (all_sessions or {}).items():
+        if not isinstance(entry, dict):
+            continue
+
+        in_tok = int(entry.get("main_agent_input_tokens", 0) or 0) + int(
+            entry.get("tools_input_tokens", 0) or 0
+        )
+        out_tok = int(entry.get("main_agent_output_tokens", 0) or 0) + int(
+            entry.get("tools_output_tokens", 0) or 0
+        )
+        cred = float(entry.get("main_agent_credits", 0.0) or 0.0) + float(
+            entry.get("tools_credits", 0.0) or 0.0
+        )
+
+        if month_filter is None:
+            # Lifetime: no attribution problem, everything counts.
+            counts = True
+        elif include_sid is not None and sid == include_sid:
+            counts = True
+        else:
+            ts = entry.get("updated_at") or entry.get("created_at")
+            if not ts:
+                counts = False
+            else:
+                try:
+                    stamp = _dt.datetime.fromtimestamp(float(ts))
+                    counts = (stamp.year, stamp.month) == month_filter
+                except (TypeError, ValueError, OSError):
+                    counts = False
+
+        if not counts:
+            out["sessions_skipped"] += 1
+            continue
+
+        out["input_tokens"] += in_tok
+        out["output_tokens"] += out_tok
+        out["credits"] += cred
+        out["sessions_counted"] += 1
+
+    out["total_tokens"] = out["input_tokens"] + out["output_tokens"]
+    return out
+
+
+def get_total_usage() -> dict:
+    """Lifetime token usage across every session on disk."""
+    try:
+        return _sum_sessions(_read_all_usage(), include_sid=None, month_filter=None)
+    except Exception:
+        return {
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "total_tokens": 0,
+            "credits": 0.0,
+            "sessions_counted": 0,
+            "sessions_skipped": 0,
+        }
+
+
+def get_monthly_usage(year: int = 0, month: int = 0, now: float = None) -> dict:
+    """Aggregate token usage across every session that falls in a calendar month.
+
+    Session entries do not carry their own timestamps (the on-disk format is a
+    flat token tally per session id), so attributable data is limited. Two
+    sources are combined:
+
+      1. The *current* session, which is always attributable to the current
+         month and is counted in full.
+      2. Any per-session `updated_at` epoch stamp, when present, which lets
+         older sessions be bucketed by their actual month.
+
+    Sessions with no timestamp are deliberately **excluded** rather than
+    guessed at, so the number never silently inflates.
+
+    Parameters
+    ----------
+    year, month : target month (defaults to the current local month)
+    now         : injectable clock (epoch seconds) for tests
+
+    Returns
+    -------
+    dict with keys:
+        input_tokens, output_tokens, total_tokens, credits,
+        sessions_counted, sessions_skipped, year, month
+    """
+    import datetime as _dt
+
+    ref = _dt.datetime.fromtimestamp(now if now is not None else time.time())
+    tgt_year = year or ref.year
+    tgt_month = month or ref.month
+
+    try:
+        result = _sum_sessions(
+            _read_all_usage(),
+            include_sid=_resolve_session_id(""),
+            month_filter=(tgt_year, tgt_month),
+        )
+    except Exception:
+        result = {
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "total_tokens": 0,
+            "credits": 0.0,
+            "sessions_counted": 0,
+            "sessions_skipped": 0,
+        }
+
+    result["year"] = tgt_year
+    result["month"] = tgt_month
+    return result
+
+
 def request_server_compression(
     messages,
     max_tokens: int = 1500,

{utim_cli-2.5.5 → utim_cli-2.6.0}/utim_cli/config.py

@@ -739,3 +739,232 @@ class Config:
 config = Config()
 # Convenience constant for direct access
 BLENDER_PATH = config.blender_path
+
+
+# ── Tool-call theme preference ────────────────────────────────────────────────
+# Stored under the ``ui`` key as ``{"tool_theme": "<name>"}`` so future UI
+# preferences can share the namespace without colliding with agent settings.
+_TOOL_THEME_KEY = "ui"
+_TOOL_THEME_FIELD = "tool_theme"
+
+
+def get_tool_theme() -> str:
+    """Return the user's saved tool-call theme name (defaults to 'default')."""
+    try:
+        ui = config.get(_TOOL_THEME_KEY, {}) or {}
+        name = ui.get(_TOOL_THEME_FIELD)
+        if isinstance(name, str) and name.strip():
+            return name.strip().lower()
+    except Exception as e:
+        logger.warning(f"Could not read tool theme preference: {e}")
+    return "default"
+
+
+def set_tool_theme(name: str) -> bool:
+    """Persist the tool-call theme name. Returns True on success."""
+    try:
+        ui = dict(config.get(_TOOL_THEME_KEY, {}) or {})
+        ui[_TOOL_THEME_FIELD] = str(name).strip().lower()
+        config.set(_TOOL_THEME_KEY, ui)
+        return True
+    except Exception as e:
+        logger.error(f"Could not save tool theme preference: {e}")
+        return False
+
+
+# ── Two-axis theme composition (palette × design) ─────────────────────────────
+# A single `tool_theme` name was a dead end: users had to pick a bundle that
+# coupled a colour scheme to a layout, so "I want the box design but in Nord"
+# was impossible without a fresh theme instance for every combination.
+#
+# The composed look is now stored as TWO independent preferences:
+#   palette : which colour scheme (default / nord / gruvbox / dracula / ...)
+#   design  : which structural layout (tree / box / rule / bar / bracket / ...)
+#
+# Resolution order for a theme *name*:
+#   1. explicit composed palette/design pair, if either is set
+#   2. the legacy single `tool_theme` name (pre-composition configs)
+#   3. "default"
+# The legacy field is never deleted, so downgrading loses nothing.
+_PALETTE_FIELD = "tool_palette"
+_DESIGN_FIELD = "tool_design"
+
+
+def _ui_get(field_name: str) -> str:
+    try:
+        ui = config.get(_TOOL_THEME_KEY, {}) or {}
+        val = ui.get(field_name)
+        if isinstance(val, str) and val.strip():
+            return val.strip().lower()
+    except Exception as e:
+        logger.warning(f"Could not read ui.{field_name}: {e}")
+    return ""
+
+
+def _ui_set(**fields) -> bool:
+    try:
+        ui = dict(config.get(_TOOL_THEME_KEY, {}) or {})
+        for k, v in fields.items():
+            if v is None:
+                ui.pop(k, None)
+            else:
+                ui[k] = str(v).strip().lower()
+        config.set(_TOOL_THEME_KEY, ui)
+        return True
+    except Exception as e:
+        logger.error(f"Could not save UI preference: {e}")
+        return False
+
+
+def get_tool_palette() -> str:
+    """Colour-scheme half of the composed theme ('' when unset)."""
+    return _ui_get(_PALETTE_FIELD)
+
+
+def get_tool_design() -> str:
+    """Layout/CAD half of the composed theme ('' when unset)."""
+    return _ui_get(_DESIGN_FIELD)
+
+
+def set_tool_palette(name: str) -> bool:
+    """Persist the palette half only — leaves the design untouched."""
+    return _ui_set(**{_PALETTE_FIELD: name})
+
+
+def set_tool_design(name: str) -> bool:
+    """Persist the design half only — leaves the palette untouched."""
+    return _ui_set(**{_DESIGN_FIELD: name})
+
+
+def set_composed_theme(palette: str = None, design: str = None) -> bool:
+    """Persist palette and/or design in a single write.
+
+    ``None`` means "leave as-is" rather than "clear" — the dialog writes both
+    halves together so a half-configured state never lands on disk.
+    """
+    fields = {}
+    if palette is not None:
+        fields[_PALETTE_FIELD] = palette
+    if design is not None:
+        fields[_DESIGN_FIELD] = design
+    # Keep the legacy field pointing at the composed name for older code paths
+    # and for a readable config file.
+    if palette or design:
+        try:
+            from utim_cli.tui import tool_themes as _tt
+
+            fields[_TOOL_THEME_FIELD] = _tt.compose_name(
+                palette or get_tool_palette(), design or get_tool_design()
+            )
+        except Exception:
+            pass
+    return _ui_set(**fields)
+
+
+def clear_composed_theme() -> bool:
+    """Forget both halves, falling back to the legacy / default theme."""
+    return _ui_set(**{_PALETTE_FIELD: None, _DESIGN_FIELD: None})
+
+
+# ── Two-axis appearance: palette × design ────────────────────────────────────
+#
+# A palette answers "what colours?", a design answers "what shape?". Keeping
+# them independent means N palettes × M designs = N*M looks, instead of N*M
+# hand-written themes. Both are stored next to ``tool_theme`` in the same ``ui``
+# namespace so an older UTIM that only understands ``tool_theme`` still reads a
+# valid name and degrades gracefully.
+#
+# ``tool_theme`` keeps its legacy meaning: the *fully resolved* combination.
+# When the user equips a palette in the picker we write both keys, so config
+# stays self-describing for anyone inspecting it by hand.
+
+_TOOL_PALETTE_FIELD = "tool_palette"
+_TOOL_DESIGN_FIELD = "tool_design"
+
+
+def get_tool_palette() -> str:
+    """Return the saved palette name, or '' if the user never picked one.
+
+    '' means "derive it from the legacy ``tool_theme`` value", which is how a
+    user who only ever ran ``/theme nord`` ends up with palette=nord and the
+    current design intact.
+    """
+    try:
+        ui = config.get(_TOOL_THEME_KEY, {}) or {}
+        name = ui.get(_TOOL_PALETTE_FIELD)
+        if isinstance(name, str) and name.strip():
+            return name.strip().lower()
+    except Exception as e:
+        logger.warning(f"Could not read tool palette preference: {e}")
+    return ""
+
+
+def set_tool_palette(name: str) -> bool:
+    """Persist the palette choice (client-side only, cheap to write)."""
+    try:
+        ui = dict(config.get(_TOOL_THEME_KEY, {}) or {})
+        ui[_TOOL_PALETTE_FIELD] = str(name).strip().lower()
+        config.set(_TOOL_THEME_KEY, ui)
+        return True
+    except Exception as e:
+        logger.error(f"Could not save tool palette preference: {e}")
+        return False
+
+
+def get_tool_design() -> str:
+    """Return the saved design (layout) name, or '' if never picked."""
+    try:
+        ui = config.get(_TOOL_THEME_KEY, {}) or {}
+        name = ui.get(_TOOL_DESIGN_FIELD)
+        if isinstance(name, str) and name.strip():
+            return name.strip().lower()
+    except Exception as e:
+        logger.warning(f"Could not read tool design preference: {e}")
+    return ""
+
+
+def set_tool_design(name: str) -> bool:
+    """Persist the design (layout) choice."""
+    try:
+        ui = dict(config.get(_TOOL_THEME_KEY, {}) or {})
+        ui[_TOOL_DESIGN_FIELD] = str(name).strip().lower()
+        config.set(_TOOL_THEME_KEY, ui)
+        return True
+    except Exception as e:
+        logger.error(f"Could not save tool design preference: {e}")
+        return False
+
+
+def get_tool_appearance() -> dict:
+    """One read for the resolver: {'palette', 'design', 'legacy', 'theme'}."""
+    return {
+        "palette": get_tool_palette(),
+        "design": get_tool_design(),
+        "legacy": get_tool_theme(),
+    }
+
+
+def set_tool_appearance(palette: str | None = None,
+                        design: str | None = None) -> bool:
+    """Persist either or both axes in a single write (one disk hit).
+
+    ``tool_theme`` is rewritten to the resolved combination so the config file
+    remains self-describing and older readers keep working.
+    """
+    try:
+        ui = dict(config.get(_TOOL_THEME_KEY, {}) or {})
+        if palette is not None:
+            ui[_TOOL_PALETTE_FIELD] = str(palette).strip().lower()
+        if design is not None:
+            ui[_TOOL_DESIGN_FIELD] = str(design).strip().lower()
+        p = ui.get(_TOOL_PALETTE_FIELD) or ""
+        d = ui.get(_TOOL_DESIGN_FIELD) or ""
+        if p and d and d != "tree":
+            ui[_TOOL_THEME_FIELD] = f"{p}+{d}"
+        elif p:
+            ui[_TOOL_THEME_FIELD] = p
+        config.set(_TOOL_THEME_KEY, ui)
+        return True
+    except Exception as e:
+        logger.error(f"Could not save tool appearance: {e}")
+        return False