utim-cli 2.0.2__tar.gz → 2.0.4__tar.gz

{utim_cli-2.0.2 → utim_cli-2.0.4}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.0.4] - 2026-08-05
+
+### 🛠️ Fixes
+- **Fixed `Wrong color format 'dim'` crash in publish dialog**: Corrected style strings in `utim_cli/tui/publish_dialog.py` to use `class:dim fg:#hex` format instead of `dim fg:#hex`, preventing the `ValueError: Wrong color format 'dim'` crash when using prompt_toolkit 3.0.40+.
+
+## [2.0.3] - 2026-08-04
+
+### 🛠️ Fixes
+- **Fixed `Wrong color format 'dim'` crash in marketplace TUI**: `prompt_toolkit` does not accept the `dim` modifier as a free-floating token before a color, nor `class:dim` as a literal inline style. All `f"dim {_MUTED}"` / `f"dim {_FG}"` style strings in `utim_cli/tui/marketplace_dialog.py` have been rewritten to `f"fg:{_MUTED}"` / `f"fg:{_FG}"`, and the `[dim]…[/dim]` markup parser now drops the `dim` token instead of emitting the unsafe `class:dim` class string. `/marketplace` no longer crashes on Windows when rendering info/hint/status rows.
+
 ## [2.0.2] - 2026-08-04
 
 ### 🛠️ Fixes

{utim_cli-2.0.2/utim_cli.egg-info → utim_cli-2.0.4}/PKG-INFO

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

{utim_cli-2.0.2 → utim_cli-2.0.4}/pyproject.toml

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

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

{utim_cli-2.0.2 → utim_cli-2.0.4}/utim_cli/_version.py

@@ -11,4 +11,4 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.0.2"
+VERSION = "2.0.4"

{utim_cli-2.0.2 → utim_cli-2.0.4}/utim_cli/context_pruner.py

@@ -13,11 +13,12 @@ import json
 import hashlib
 from utim_cli.constants import DEFAULT_MODEL
 
-# Fallback models for compression operations - ordered by reliability and quality
+# Fallback models for compression operations - ordered by reliability and quality.
+# "openrouter/free" is the first fallback tried after the primary model.
 COMPRESSION_FALLBACK_MODELS = [
+    "openrouter/free",
     "poolside/laguna-xs-2.1:free",
     "cohere/north-mini-code:free",
-    "openrouter/free",
 ]
 
 # Track what content has already been summarized to prevent duplicate summarization

{utim_cli-2.0.2 → utim_cli-2.0.4}/utim_cli/orchestrator.py

@@ -1172,9 +1172,9 @@ class Orchestrator:
         except Exception:
             pass
 
-        # Load user-saved API key from local .utim/.env (written by the setup wizard / /auth)
+        # Load user-saved API key from global ~/.utim/.env (written by the setup wizard / /auth)
         import pathlib
-        _user_env = pathlib.Path(".utim").resolve() / ".env"
+        _user_env = pathlib.Path.home() / ".utim" / ".env"
         if _user_env.exists():
             try:
                 from dotenv import load_dotenv as _load_dotenv
@@ -1182,12 +1182,13 @@ class Orchestrator:
             except Exception:
                 pass
 
-        # Load user-saved API key from global ~/.utim/.env (written by the setup wizard / /auth)
-        _global_env = pathlib.Path.home() / ".utim" / ".env"
-        if _global_env.exists():
+        # Legacy fallback: also check cwd-relative .utim/.env (pre-global-install
+        # folders) so old installs keep working, but global ~/.utim always wins.
+        _legacy_env = pathlib.Path(".utim").resolve() / ".env"
+        if _legacy_env.exists():
             try:
                 from dotenv import load_dotenv as _load_dotenv
-                _load_dotenv(_global_env, override=False)  # override=False: env vars win
+                _load_dotenv(_legacy_env, override=False)  # override=False: env vars win
             except Exception:
                 pass
 

{utim_cli-2.0.2 → utim_cli-2.0.4}/utim_cli/reflection.py

@@ -1300,7 +1300,6 @@ def apply_skill_modifications(skill_modifications: Dict[str, Any], **kwargs):
 
         paths_to_write = [
             utim_base / folder_name / skill_name / "SKILL.md",
-            Path(f".utim/{folder_name}") / skill_name / "SKILL.md",
         ]
 
         for skill_path in paths_to_write:

{utim_cli-2.0.2 → utim_cli-2.0.4}/utim_cli/server/history.py

@@ -1,187 +1,187 @@
-from __future__ import annotations
-import json
-import os
-import uuid
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-
-from sqlalchemy import create_engine, event
-from sqlalchemy.orm import sessionmaker
-
-from .db import Base, Conversation, User
-
-# ── Local DB wiring ───────────────────────────────────────────────────────────
-# Always use .utim/utim_local.db in the CURRENT WORKING DIRECTORY.
-# This is the file bootstrap.py creates and backup.py backs up.
-# We do NOT use the DATABASE_URL from server/db.py — that points at the
-# production PostgreSQL server, which is unreachable from the local CLI.
-
-_local_engine = None
-
-def _get_local_engine():
-    """Return a SQLAlchemy engine connected to .utim/utim_local.db (cwd)."""
-    global _local_engine
-    if _local_engine is None:
-        utim_dir = Path(os.getcwd()) / ".utim"
-        utim_dir.mkdir(parents=True, exist_ok=True)
-        db_path = utim_dir / "utim_local.db"
-        url = f"sqlite:///{db_path}"
-        _local_engine = create_engine(url, connect_args={"check_same_thread": False})
-        # Ensure WAL mode for safe concurrent access from background threads
-        @event.listens_for(_local_engine, "connect")
-        def _set_wal(conn, _):
-            conn.execute("PRAGMA journal_mode=WAL")
-            conn.execute("PRAGMA synchronous=NORMAL")
-        # Create all tables if they don't exist yet (idempotent)
-        Base.metadata.create_all(bind=_local_engine)
-    return _local_engine
-
-def close_history_db():
-    """Close and dispose of the local SQLite database engine."""
-    global _local_engine
-    print(f"[DEBUG] close_history_db: _local_engine is {_local_engine}", flush=True)
-    if _local_engine is not None:
-        _local_engine.dispose()
-        _local_engine = None
-
-
-
-def _make_session():
-    engine = _get_local_engine()
-    return sessionmaker(autocommit=False, autoflush=False, bind=engine)()
-
-# Default local user for fully local / unauthenticated operation
-LOCAL_EMAIL = os.getenv("UTIM_EMAIL", "local@utim.dev")
-
-
-def _parse_json_field(value, default=None):
-    """Safely parse a DB field that may be a JSON string (SQLite Text) or already
-    a Python object (PostgreSQL JSONB). Returns `default` on any failure."""
-    if default is None:
-        default = []
-    if value is None:
-        return default
-    if isinstance(value, (list, dict)):
-        return value          # PostgreSQL JSONB already parsed
-    if isinstance(value, str):
-        try:
-            return json.loads(value)
-        except (json.JSONDecodeError, ValueError):
-            return default
-    return default
-
-
-def _to_json(value):
-    """Serialize a Python list/dict to a JSON string for SQLite Text storage.
-    If the value is already a string, return it as-is."""
-    if value is None:
-        return "[]"
-    if isinstance(value, str):
-        return value
-    return json.dumps(value, ensure_ascii=False)
-
-
-def get_or_create_user(db, email: str) -> User:
-    user = db.query(User).filter(User.email == email).first()
-    if not user:
-        user = User(email=email)
-        db.add(user)
-        db.commit()
-        db.refresh(user)
-    return user
-
-
-class HistoryManager:
-    def __init__(self):
-        pass
-
-    def get_session(self, session_id: str, email: str = None) -> Dict[str, Any] | None:
-        db = _make_session()
-        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
-        if not conv:
-            db.close()
-            return None
-        res = {
-            "session_id": conv.id,
-            "model_id": conv.model_id,
-            "messages": _parse_json_field(conv.messages),
-            "turn_history": _parse_json_field(conv.turn_history),
-            "redo_history": _parse_json_field(conv.redo_history),
-            "usage": {
-                "input_tokens": conv.token_usage_input,
-                "output_tokens": conv.token_usage_output
-            }
-        }
-        db.close()
-        return res
-
-    def create_session(self, model_id: str, email: str = None) -> str:
-        email = email or LOCAL_EMAIL
-        db = _make_session()
-        user = get_or_create_user(db, email)
-        session_id = str(uuid.uuid4())
-        new_conv = Conversation(
-            id=session_id,
-            user_id=user.id,
-            model_id=model_id,
-            messages=_to_json([]),
-            turn_history=_to_json([]),
-            redo_history=_to_json([])
-        )
-        db.add(new_conv)
-        db.commit()
-        db.close()
-        return session_id
-
-    def add_messages(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, first_user_msg: str = "", turn_history: List[Dict[str, Any]] = None, redo_history: List[Dict[str, Any]] = None):
-        email = email or LOCAL_EMAIL
-        db = _make_session()
-        user = get_or_create_user(db, email)
-
-        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
-        if conv:
-            # Dynamically update user association when credentials change
-            conv.user_id = user.id
-            conv.messages = _to_json(messages)
-            if turn_history is not None:
-                conv.turn_history = _to_json(turn_history)
-            if redo_history is not None:
-                conv.redo_history = _to_json(redo_history)
-                
-            # Update title from first user message if we have one
-            if first_user_msg and not conv.title:
-                conv.title = (first_user_msg[:80] + "\u2026" if len(first_user_msg) > 80 else first_user_msg)
-            
-            db.commit()
-        db.close()
-
-    def checkpoint(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, description: str = "auto"):
-        pass
-
-    def list_sessions(self, email: str = None):
-        db = _make_session()
-        conversations = db.query(Conversation).all()
-        sessions = []
-        for c in conversations:
-            msgs = _parse_json_field(c.messages)
-            has_user_msg = any(isinstance(m, dict) and m.get("role") == "user" for m in msgs)
-            if not has_user_msg:
-                continue
-            first_user = next(
-                (m.get("content", "") for m in msgs if isinstance(m, dict) and m.get("role") == "user"),
-                ""
-            )
-            if isinstance(first_user, list):
-                first_user = " ".join(p.get("text", "") for p in first_user if isinstance(p, dict))
-            title = c.title or (first_user[:70] + "\u2026" if len(first_user) > 70 else first_user) or c.id[:12]
-            sessions.append({
-                "session_id": c.id,
-                "model_id": c.model_id,
-                "message_count": len(msgs),
-                "title": title,
-                "created_at": c.created_at.isoformat() if hasattr(c, "created_at") and c.created_at else "",
-                "updated_at": c.updated_at.isoformat() if c.updated_at else "",
-            })
-        db.close()
-        sessions.sort(key=lambda s: s["updated_at"], reverse=True)
-        return sessions
+from __future__ import annotations
+import json
+import os
+import uuid
+from typing import List, Dict, Any, Optional
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import sessionmaker
+
+from .db import Base, Conversation, User
+
+# ── Local DB wiring ───────────────────────────────────────────────────────────
+# Always use .utim/utim_local.db in the CURRENT WORKING DIRECTORY.
+# This is the file bootstrap.py creates and backup.py backs up.
+# We do NOT use the DATABASE_URL from server/db.py — that points at the
+# production PostgreSQL server, which is unreachable from the local CLI.
+
+_local_engine = None
+
+def _get_local_engine():
+    """Return a SQLAlchemy engine connected to ~/.utim/utim_local.db (global home)."""
+    global _local_engine
+    if _local_engine is None:
+        from utim_cli.config import get_utim_dir
+        utim_dir = get_utim_dir()
+        utim_dir.mkdir(parents=True, exist_ok=True)
+        db_path = utim_dir / "utim_local.db"
+        url = f"sqlite:///{db_path}"
+        _local_engine = create_engine(url, connect_args={"check_same_thread": False})
+        # Ensure WAL mode for safe concurrent access from background threads
+        @event.listens_for(_local_engine, "connect")
+        def _set_wal(conn, _):
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA synchronous=NORMAL")
+        # Create all tables if they don't exist yet (idempotent)
+        Base.metadata.create_all(bind=_local_engine)
+    return _local_engine
+
+def close_history_db():
+    """Close and dispose of the local SQLite database engine."""
+    global _local_engine
+    print(f"[DEBUG] close_history_db: _local_engine is {_local_engine}", flush=True)
+    if _local_engine is not None:
+        _local_engine.dispose()
+        _local_engine = None
+
+
+
+def _make_session():
+    engine = _get_local_engine()
+    return sessionmaker(autocommit=False, autoflush=False, bind=engine)()
+
+# Default local user for fully local / unauthenticated operation
+LOCAL_EMAIL = os.getenv("UTIM_EMAIL", "local@utim.dev")
+
+
+def _parse_json_field(value, default=None):
+    """Safely parse a DB field that may be a JSON string (SQLite Text) or already
+    a Python object (PostgreSQL JSONB). Returns `default` on any failure."""
+    if default is None:
+        default = []
+    if value is None:
+        return default
+    if isinstance(value, (list, dict)):
+        return value          # PostgreSQL JSONB already parsed
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (json.JSONDecodeError, ValueError):
+            return default
+    return default
+
+
+def _to_json(value):
+    """Serialize a Python list/dict to a JSON string for SQLite Text storage.
+    If the value is already a string, return it as-is."""
+    if value is None:
+        return "[]"
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False)
+
+
+def get_or_create_user(db, email: str) -> User:
+    user = db.query(User).filter(User.email == email).first()
+    if not user:
+        user = User(email=email)
+        db.add(user)
+        db.commit()
+        db.refresh(user)
+    return user
+
+
+class HistoryManager:
+    def __init__(self):
+        pass
+
+    def get_session(self, session_id: str, email: str = None) -> Dict[str, Any] | None:
+        db = _make_session()
+        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
+        if not conv:
+            db.close()
+            return None
+        res = {
+            "session_id": conv.id,
+            "model_id": conv.model_id,
+            "messages": _parse_json_field(conv.messages),
+            "turn_history": _parse_json_field(conv.turn_history),
+            "redo_history": _parse_json_field(conv.redo_history),
+            "usage": {
+                "input_tokens": conv.token_usage_input,
+                "output_tokens": conv.token_usage_output
+            }
+        }
+        db.close()
+        return res
+
+    def create_session(self, model_id: str, email: str = None) -> str:
+        email = email or LOCAL_EMAIL
+        db = _make_session()
+        user = get_or_create_user(db, email)
+        session_id = str(uuid.uuid4())
+        new_conv = Conversation(
+            id=session_id,
+            user_id=user.id,
+            model_id=model_id,
+            messages=_to_json([]),
+            turn_history=_to_json([]),
+            redo_history=_to_json([])
+        )
+        db.add(new_conv)
+        db.commit()
+        db.close()
+        return session_id
+
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, first_user_msg: str = "", turn_history: List[Dict[str, Any]] = None, redo_history: List[Dict[str, Any]] = None):
+        email = email or LOCAL_EMAIL
+        db = _make_session()
+        user = get_or_create_user(db, email)
+
+        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
+        if conv:
+            # Dynamically update user association when credentials change
+            conv.user_id = user.id
+            conv.messages = _to_json(messages)
+            if turn_history is not None:
+                conv.turn_history = _to_json(turn_history)
+            if redo_history is not None:
+                conv.redo_history = _to_json(redo_history)
+                
+            # Update title from first user message if we have one
+            if first_user_msg and not conv.title:
+                conv.title = (first_user_msg[:80] + "\u2026" if len(first_user_msg) > 80 else first_user_msg)
+            
+            db.commit()
+        db.close()
+
+    def checkpoint(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, description: str = "auto"):
+        pass
+
+    def list_sessions(self, email: str = None):
+        db = _make_session()
+        conversations = db.query(Conversation).all()
+        sessions = []
+        for c in conversations:
+            msgs = _parse_json_field(c.messages)
+            has_user_msg = any(isinstance(m, dict) and m.get("role") == "user" for m in msgs)
+            if not has_user_msg:
+                continue
+            first_user = next(
+                (m.get("content", "") for m in msgs if isinstance(m, dict) and m.get("role") == "user"),
+                ""
+            )
+            if isinstance(first_user, list):
+                first_user = " ".join(p.get("text", "") for p in first_user if isinstance(p, dict))
+            title = c.title or (first_user[:70] + "\u2026" if len(first_user) > 70 else first_user) or c.id[:12]
+            sessions.append({
+                "session_id": c.id,
+                "model_id": c.model_id,
+                "message_count": len(msgs),
+                "title": title,
+                "created_at": c.created_at.isoformat() if hasattr(c, "created_at") and c.created_at else "",
+                "updated_at": c.updated_at.isoformat() if c.updated_at else "",
+            })
+        db.close()
+        sessions.sort(key=lambda s: s["updated_at"], reverse=True)
+        return sessions

{utim_cli-2.0.2 → utim_cli-2.0.4}/utim_cli/tools.py

@@ -2699,7 +2699,8 @@ def manage_memory(action: str, key: str = "", content: str = "",
     """
     import os, json, pathlib, time as _time
     from utim_cli.state import STATE
-    mem_file = pathlib.Path(".utim").resolve() / "memory.json"
+    from utim_cli.config import get_utim_dir
+    mem_file = get_utim_dir() / "memory.json"
     os.makedirs(mem_file.parent, exist_ok=True)
 
     memories: dict = {}
@@ -4707,10 +4708,11 @@ def store_experience(category: str, content: str, priority: int = None, subagent
     import json
     from datetime import datetime
     from pathlib import Path
+    from utim_cli.config import get_utim_dir
     
     try:
-        # Ensure .utim directory exists
-        utim_dir = Path('.utim')
+        # Ensure .utim directory exists (global ~/.utim, resolves per-user profile)
+        utim_dir = get_utim_dir()
         utim_dir.mkdir(exist_ok=True)
         exp_file = utim_dir / 'experiences.json'
         
@@ -4776,9 +4778,10 @@ def recall_experience(query: str, limit: int = 5, subagent: str = None) -> str:
         from pathlib import Path
         import json
         from utim_cli.state import STATE
+        from utim_cli.config import get_utim_dir
         
         results_str = []
-        utim_dir = Path('.utim')
+        utim_dir = get_utim_dir()
         exp_file = utim_dir / 'experiences.json'
         
         # Search experiences from experiences.json