utim-cli 2.2.1__tar.gz → 2.2.2__tar.gz

{utim_cli-2.2.1 → utim_cli-2.2.2}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [2.2.2] - 2026-08-15
+
+### 🚀 Features & Enhancements
+- **Order History & Invoices**: Added comprehensive order history and tax invoice viewing with printable receipts on the pricing page.
+- **Automated Refund Request Workflow**: Policy-enforced refund claim submission system with automatic admin email alerts and user autoresponder (3-day money-back guarantee window).
+- **Zero-Flicker Configuration Dialogs**: Upgraded Tools, Model Settings, and Skills configuration dialogs to in-memory live toggling with single-commit on exit, eliminating screen flashes.
+- **TUI Dialog Polish**: Refined `/rewind`, `/undo`, `/quotashare`, and `/redeem` interactive dialog workflows.
+
 ## [2.2.1] - 2026-08-13
 
 ### 🛠️ Fixes & Minor Polish

{utim_cli-2.2.1/utim_cli.egg-info → utim_cli-2.2.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.2.1
+Version: 2.2.2
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
-License: MIT
+License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev
 Project-URL: Documentation, https://utim.dev/docs
 Project-URL: Changelog, https://github.com/emendai/utim/blob/main/CHANGELOG.md
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: Other/Proprietary License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console

{utim_cli-2.2.1 → utim_cli-2.2.2}/pyproject.toml

@@ -4,18 +4,18 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.2.1"
+version = "2.2.2"
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
 requires-python = ">=3.9"
-license = { text = "MIT" }
+license = { text = "Emend AI Proprietary EULA" }
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "License :: OSI Approved :: MIT License",
+    "License :: Other/Proprietary License",
     "Operating System :: OS Independent",
     "Development Status :: 5 - Production/Stable",
     "Environment :: Console",
@@ -103,4 +103,5 @@ markers = [
     "smoke: fast install validation tests (no live credentials required)",
     "slow: tests that make network calls or take more than 10 seconds",
     "integration: tests requiring live credentials or a running UTIM account",
+    "benchmark: UTIM benchmark suite — tests all 9 agent benchmark families",
 ]

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

{utim_cli-2.2.1 → utim_cli-2.2.2}/utim_cli/_version.py

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

{utim_cli-2.2.1 → utim_cli-2.2.2}/utim_cli/bootstrap.py

@@ -146,13 +146,15 @@ def scan_available_skills():
 
     skills = {}
     paths_to_check = [
+        Path('.agents/skills'),
+        Path('.agentskills'),
+        Path('.agents'),
+        Path('.utim/skills'),
+        Path('.utim/agentskills'),
         UTIM_DIR / 'skills',
         UTIM_DIR / 'agentskills',
         Path.home() / '.utim' / 'skills',
         Path.home() / '.utim' / 'agentskills',
-        Path('.utim/skills'),
-        Path('.utim/agentskills'),
-        Path('.agents/skills'),
     ]
     
     for base_dir in paths_to_check:
@@ -216,28 +218,156 @@ def scan_available_skills():
                     }
     return skills
 
+
+DOMAIN_INTENT_MAP = {
+    "terminal-ui-design": [
+        "tui", "rich", "console", "prompt_toolkit", "layout", "dialog", "menu",
+        "scrollbar", "terminal ui", "cli ui", "ansi", "color scheme", "quotashare", "redeem"
+    ],
+    "software-architecture": [
+        "architecture", "refactor", "modular", "decouple", "state management",
+        "router", "fastapi", "sqlite", "orm", "dependency injection", "package structure", "module design"
+    ],
+    "mcp-server-development": [
+        "mcp", "model context protocol", "mcp server", "stdio", "json-rpc", "jsonrpc",
+        "connection pool", "protocol wrapper", "tool handler", "tool server"
+    ],
+    "async-python": [
+        "async", "asyncio", "coroutine", "event loop", "threadsafe", "subprocess stream",
+        "deadlock", "lock", "thread", "concurrent", "non-blocking", "await", "to_thread"
+    ],
+    "llm-orchestration": [
+        "orchestrat", "llm loop", "prompt", "context prun", "compaction", "rag",
+        "token budget", "overclock", "memory retrieval", "react loop", "reflection", "system prompt",
+        "compression", "context envelope", "modelcontext"
+    ],
+    "cli-ux-patterns": [
+        "cli ux", "user confirmation", "dry-run", "undo", "scroll pollution",
+        "tty", "non-interactive", "cli prompt", "command line experience"
+    ],
+    "web-design-premium": [
+        "web design", "html", "css", "vite", "react", "frontend", "glassmorphism",
+        "landing page", "tailwind", "responsive", "hsl", "seo"
+    ],
+    "creative-scrollytelling": [
+        "scrollytelling", "kinetic", "split-door", "viewport animation", "kinetic sweep"
+    ],
+}
+
+
+def rank_relevant_skills(
+    query_text: str,
+    skills: dict = None,
+    min_score: float = 14.0,
+    max_results: int = 2,
+) -> list:
+    """
+    High-precision BM25 & Domain-Intent Skill Ranker.
+    
+    Prevents weak/random skill injection by evaluating:
+      1. Domain Intent Triggers: Matches architectural problem domains to canonical skills.
+      2. Exact Phrase & Slug Matching: High-weight bonus for exact multi-word / hyphenated concepts.
+      3. Inverse Document Frequency (IDF): Suppresses generic words ('python', 'code', 'data', 'user')
+         and elevates domain-specific technical terminology ('coroutine', 'prompt_toolkit', 'mcp').
+      4. Minimum Activation Threshold: Rejects any skill below min_score to prevent context pollution.
+    
+    Returns:
+        List of (skill_name, score) sorted in descending order of relevance.
+    """
+    import math
+    import re
+
+    if not query_text or not query_text.strip():
+        return []
+
+    if skills is None:
+        skills = scan_available_skills()
+    if not skills:
+        return []
+
+    query_lower = query_text.lower()
+    query_tokens = [w for w in re.split(r"[^\w\d\-]+", query_lower) if len(w) >= 3]
+    if not query_tokens:
+        return []
+
+    # 1. Compute document frequency across all skills to calculate IDF
+    total_docs = len(skills)
+    doc_freq = {}
+    for s_name, s_info in skills.items():
+        doc_words = set(s_info.get("keywords", []))
+        for w in s_info.get("name", "").lower().split():
+            if len(w) >= 3:
+                doc_words.add(w)
+        for w in doc_words:
+            doc_freq[w] = doc_freq.get(w, 0) + 1
+
+    def _idf(word: str) -> float:
+        df = doc_freq.get(word, 0)
+        # Suppress over-represented words across >= 12 skills
+        if df >= 12:
+            return 0.1
+        return max(0.2, math.log((total_docs - df + 0.5) / (df + 0.5) + 1.0))
+
+    scored_skills = []
+
+    for skill_name, skill_info in skills.items():
+        score = 0.0
+        s_name_lower = skill_name.lower()
+        s_title_lower = skill_info.get("name", "").lower()
+        s_desc_lower = skill_info.get("description", "").lower()
+
+        # Extract token sets to ensure exact word matches (prevent substring false-positives like 'tell' in 'scrollytelling')
+        s_name_tokens = set(re.split(r"[^\w\d]+", s_name_lower))
+        s_title_tokens = set(re.split(r"[^\w\d]+", s_title_lower))
+        s_desc_tokens = set(re.split(r"[^\w\d]+", s_desc_lower))
+
+        # ── Check 1: Domain Intent Mapping (Authoritative Trigger Boost) ──
+        for target_skill, triggers in DOMAIN_INTENT_MAP.items():
+            if target_skill in s_name_lower:
+                for trig in triggers:
+                    if re.search(r"\b" + re.escape(trig) + r"\b", query_lower):
+                        score += 35.0
+                        break
+
+        # ── Check 2: Exact Name / Hyphenated Slug Matching ───────────────
+        if re.search(r"\b" + re.escape(s_name_lower) + r"\b", query_lower):
+            score += 40.0
+        elif s_name_lower.replace("-", " ") in query_lower or s_name_lower.replace("_", " ") in query_lower:
+            score += 30.0
+
+        # ── Check 3: High-Entropy Keyword TF-IDF Matching ─────────────────
+        skill_kw = set(skill_info.get("keywords", []))
+        for tok in query_tokens:
+            if tok in skill_kw:
+                score += 8.0 * _idf(tok)
+            if tok in s_name_tokens or tok in s_title_tokens:
+                score += 6.0 * _idf(tok)
+            elif tok in s_desc_tokens:
+                score += 2.0 * _idf(tok)
+
+        # ── Check 4: Penalize Generic Auto-Learned Skills ────────────────
+        if any(prefix in s_name_lower for prefix in ["user-", "user_", "communication", "interaction", "conversation", "response-"]):
+            # Only allow if strongly and explicitly triggered
+            score *= 0.50
+
+        if score >= min_score:
+            scored_skills.append((skill_name, score))
+
+    scored_skills.sort(key=lambda x: x[1], reverse=True)
+    return scored_skills[:max_results]
+
+
 def get_rag_context(user_prompt: str = "") -> str:
-    """Get RAG context string for system prompt injection by matching user_prompt keywords to skills."""
+    """Get RAG context string for system prompt injection by matching user_prompt using rank_relevant_skills."""
     try:
         from utim_cli.state import STATE
         STATE["injected_contexts"] = []
         
         skills = scan_available_skills()
-        matched_skills = []
-        user_prompt_lower = user_prompt.lower()
+        ranked = rank_relevant_skills(user_prompt, skills=skills, min_score=14.0, max_results=2)
         
-        for skill_name, skill_info in skills.items():
-            matched = False
-            if any(kw in user_prompt_lower for kw in skill_info["keywords"]):
-                matched = True
-            if not matched:
-                if skill_name.replace("-", " ") in user_prompt_lower or skill_name in user_prompt_lower:
-                    matched = True
-            if matched:
-                matched_skills.append(skill_name)
-                
-        # If no keywords matched, default to AGENTS.md
-        if not matched_skills:
+        # If no skills passed threshold, default to AGENTS.md
+        if not ranked:
             agents_path = UTIM_DIR / 'AGENTS.md'
             if not agents_path.exists():
                 from pathlib import Path
@@ -250,7 +380,7 @@ def get_rag_context(user_prompt: str = "") -> str:
             return ""
             
         context = ""
-        for skill_name in matched_skills[:2]: # Load top 2 matched skills
+        for skill_name, score in ranked:
             skill_info = skills[skill_name]
             content = skill_info["content"]
             if content.startswith('---'):
@@ -258,7 +388,7 @@ def get_rag_context(user_prompt: str = "") -> str:
                 if len(parts) >= 3:
                     content = parts[2].strip()
             STATE["injected_contexts"].append(content)
-            context += f"\n### RELEVANT CORE SKILL: {skill_name.upper()} ###\n{content[:1500]}\n"
+            context += f"\n### RELEVANT CORE SKILL: {skill_name.upper()} (Relevance: {score:.1f}) ###\n{content[:1500]}\n"
             
         return context
     except Exception as e:
@@ -283,11 +413,13 @@ def get_subagent_rag_context(subagent_name: str, query: str = "") -> str:
         if skill_name in skills:
             skill_path = skills[skill_name]["path"]
         else:
-            skill_path = UTIM_DIR / 'skills' / skill_name / 'SKILL.md'
+            skill_path = Path('.agents/skills') / skill_name / 'SKILL.md'
             if not skill_path.exists():
-                skill_path = UTIM_DIR / 'agentskills' / skill_name / 'SKILL.md'
+                skill_path = Path('.agentskills') / skill_name / 'SKILL.md'
             if not skill_path.exists():
-                skill_path = Path('.agents/skills') / skill_name / 'SKILL.md'
+                skill_path = UTIM_DIR / 'skills' / skill_name / 'SKILL.md'
+            if not skill_path.exists():
+                skill_path = UTIM_DIR / 'agentskills' / skill_name / 'SKILL.md'
         if not skill_path.exists():
             return ""
             

{utim_cli-2.2.1 → utim_cli-2.2.2}/utim_cli/client_utils.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import json
 import math

{utim_cli-2.2.1 → utim_cli-2.2.2}/utim_cli/config.py

@@ -494,7 +494,8 @@ class Config:
         return [
             "cohere/north-mini-code:free",
             "openrouter/free",
-            "inclusionai/ling-3.0-flash:free",
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "google/gemini-2.5-flash:free",
         ]