utim-cli 1.47.4__tar.gz → 1.47.7__tar.gz

{utim_cli-1.47.4 → utim_cli-1.47.7}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [1.47.7] - 2026-07-20
+
+### Added
+- **Android Termux Pure-Python Architecture**: Implemented pure-Python line-delimited JSON-RPC stdio client fallback (`PurePythonMCPSession`) for Model Context Protocol (MCP) servers, enabling 100% feature parity on Android Termux without requiring Rust compilation or `pydantic-core`.
+- **Web Support Assistant Disclaimer & Installation Flow**: Added glassmorphism notice bar and 4-step installation visual guide on landing website to distinguish web support chat from local CLI agent.
+- **Enhanced Cognitive Reflection Pipeline**: Replaced single-turn random skill creation with a 5-request interaction buffering engine. Analyzes full interaction trajectories across turns (detecting silent tool calling and file format assumption complaints like image PDFs vs text PDFs), with strict usefulness filtering to prevent storing junk data.
+- **RAG-Based Skill Creation & Intelligent Hold-Back Architecture**: Implemented RAG skill synthesis over ChromaDB Vector Memory. Enforces a minimum threshold ($\ge 3$ accumulated experiences across sessions), an LLM usability/cohesion evaluation (`is_sufficiently_usable`), and cooldown stride tracking to hold back skill creation until technical patterns are mature and genuinely usable.
+
+### Fixed
+- **Device Sign-In Unauthenticated Flow**: Fixed device authorization flow on `https://utim.dev/activate?code=XXXX-XXXX`. Auto-redirects unauthenticated users to `/auth` with a countdown while preserving the device code, bouncing them back to `/activate` automatically after sign-in to complete terminal authorization without broken loops.
+
+## [1.47.6] - 2026-07-19
+
+### Added
+- **Asynchronous Local LLM Setup**: Moved the local Qwen model downloading and setup pipeline into a background daemon thread, allowing UTIM to run completions instantly via Cloud API during initial setup/installation without blocking user queries.
+
+## [1.47.5] - 2026-07-19
+
+### Optimized
+- **Instant startup / rules summarization**: Prioritized Cloud API completion calls (via UTIM completions server or direct OpenRouter) over local Qwen LLM execution in `summarize_experiences_with_model`. This completely eliminates the 1m 49s latency caused by importing PyTorch/Transformers and loading the 0.5B model from scratch, falling back to local execution only in offline mode.
+
 ## [1.47.4] - 2026-07-19
 
 ### Fixed

{utim_cli-1.47.4/utim_cli.egg-info → utim_cli-1.47.7}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "1.47.4"
+version = "1.47.7"
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -79,7 +79,7 @@ legacy-agent = [
 ]
 
 [project.scripts]
-utim = "utim_cli.utim:app"
+utim = "utim_cli.utim:main_cli_entry"
 
 [tool.setuptools.packages.find]
 include = ["utim_cli*"]

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

{utim_cli-1.47.4 → utim_cli-1.47.7}/utim_cli/_version.py

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

{utim_cli-1.47.4 → utim_cli-1.47.7}/utim_cli/bootstrap.py

@@ -4,6 +4,7 @@ Auto-creates the .utim folder structure, custom skills, and local database on fi
 """
 
 import os
+from pathlib import Path
 from utim_cli.config import get_utim_dir
 
 UTIM_DIR = get_utim_dir()

utim_cli-1.47.7/utim_cli/mcp_client.py

@@ -0,0 +1,343 @@
+import os
+import json
+import asyncio
+import threading
+from typing import Dict, List, Any, Optional
+
+try:
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    HAS_MCP_LIB = True
+except ImportError:
+    HAS_MCP_LIB = False
+
+# =========================================================================
+# Pure-Python Stdio MCP Client Fallback (Zero C/Rust/pydantic-core dependency)
+# =========================================================================
+class PurePythonMCPTool:
+    def __init__(self, name: str, description: str, inputSchema: dict):
+        self.name = name
+        self.description = description
+        self.inputSchema = inputSchema
+
+class PurePythonMCPContent:
+    def __init__(self, text: str):
+        self.text = text
+
+class PurePythonMCPResult:
+    def __init__(self, content: list, isError: bool = False):
+        self.content = content
+        self.isError = isError
+
+class PurePythonMCPSession:
+    """Pure-Python line-delimited JSON-RPC stdio client for MCP servers."""
+    def __init__(self, command: str, args: list, env: dict):
+        self.command = command
+        self.args = args
+        self.env = env
+        self.proc = None
+        self._req_id = 0
+
+    def _next_id(self):
+        self._req_id += 1
+        return self._req_id
+
+    async def start(self):
+        import sys
+        import shutil
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        wrapper_path = os.path.join(current_dir, "mcp_clean_wrapper.py")
+        resolved_command = shutil.which(self.command) or self.command
+
+        cmd_list = [sys.executable, "-u", wrapper_path, resolved_command] + self.args
+        self.proc = await asyncio.create_subprocess_exec(
+            *cmd_list,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=self.env
+        )
+
+    async def _send_request(self, method: str, params: dict) -> dict:
+        if not self.proc or not self.proc.stdin:
+            raise RuntimeError("MCP process stdin not open")
+        req_id = self._next_id()
+        payload = json.dumps({
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "method": method,
+            "params": params
+        }) + "\n"
+        self.proc.stdin.write(payload.encode("utf-8"))
+        await self.proc.stdin.drain()
+
+        while True:
+            line = await self.proc.stdout.readline()
+            if not line:
+                raise RuntimeError("MCP server process output ended unexpectedly.")
+            line_str = line.decode("utf-8", errors="ignore").strip()
+            if not line_str:
+                continue
+            try:
+                msg = json.loads(line_str)
+                if msg.get("id") == req_id:
+                    if "error" in msg:
+                        err_msg = msg["error"].get("message", "MCP RPC Error")
+                        raise RuntimeError(err_msg)
+                    return msg.get("result", {})
+            except json.JSONDecodeError:
+                continue
+
+    async def _send_notification(self, method: str, params: dict):
+        if not self.proc or not self.proc.stdin:
+            return
+        payload = json.dumps({
+            "jsonrpc": "2.0",
+            "method": method,
+            "params": params
+        }) + "\n"
+        self.proc.stdin.write(payload.encode("utf-8"))
+        await self.proc.stdin.drain()
+
+    async def initialize(self):
+        await self._send_request("initialize", {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {"name": "utim", "version": "1.0"}
+        })
+        await self._send_notification("notifications/initialized", {})
+
+    async def list_tools(self):
+        res = await self._send_request("tools/list", {})
+        raw_tools = res.get("tools", [])
+        tools = []
+        for t in raw_tools:
+            tools.append(PurePythonMCPTool(
+                name=t.get("name", ""),
+                description=t.get("description", ""),
+                inputSchema=t.get("inputSchema", {})
+            ))
+        class ToolListResult:
+            def __init__(self, t_list):
+                self.tools = t_list
+        return ToolListResult(tools)
+
+    async def call_tool(self, name: str, arguments: dict):
+        res = await self._send_request("tools/call", {
+            "name": name,
+            "arguments": arguments
+        })
+        is_error = res.get("isError", False)
+        raw_content = res.get("content", [])
+        contents = []
+        for c in raw_content:
+            if isinstance(c, dict) and "text" in c:
+                contents.append(PurePythonMCPContent(c["text"]))
+            elif isinstance(c, str):
+                contents.append(PurePythonMCPContent(c))
+        if not contents:
+            contents.append(PurePythonMCPContent(json.dumps(res)))
+        return PurePythonMCPResult(contents, isError=is_error)
+
+    async def close(self):
+        if self.proc:
+            try:
+                self.proc.terminate()
+                await self.proc.wait()
+            except Exception:
+                pass
+
+
+class MCPManager:
+    def __init__(self):
+        self.sessions: Dict[str, Any] = {}
+        self._exit_stacks = {}
+        self._tool_to_server: Dict[str, str] = {}
+        self._started = False
+        self.cached_tools: List[Dict[str, Any]] = []
+        self.server_tools: Dict[str, List[str]] = {}  # server_name -> list of tool names
+        self._loop = None
+        self._thread = None
+
+    def start_loop(self):
+        if self._loop is None:
+            self._loop = asyncio.new_event_loop()
+            self._thread = threading.Thread(target=self._run_loop, daemon=True)
+            self._thread.start()
+
+    def _run_loop(self):
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_forever()
+
+    def run_coro(self, coro):
+        self.start_loop()
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return future.result()
+
+    def start(self):
+        if self._started:
+            return
+        
+        from utim_cli.config import get_utim_dir
+        config_path = os.path.abspath(os.path.join(get_utim_dir(), "mcp.json"))
+        if not os.path.exists(config_path):
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            with open(config_path, "w") as f:
+                json.dump({"mcpServers": {}}, f, indent=2)
+
+        self.start_loop()
+        self.run_coro(self._start_async())
+
+    async def _start_async(self):
+        from utim_cli.config import get_utim_dir
+        config_path = os.path.abspath(os.path.join(get_utim_dir(), "mcp.json"))
+        if not os.path.exists(config_path):
+            os.makedirs(os.path.dirname(config_path), exist_ok=True)
+            with open(config_path, "w") as f:
+                json.dump({"mcpServers": {}}, f, indent=2)
+            self._started = True
+            return
+
+        try:
+            with open(config_path, "r") as f:
+                config = json.load(f)
+        except Exception:
+            self._started = True
+            return
+
+        servers = config.get("mcpServers") or {}
+        if not isinstance(servers, dict):
+            servers = {}
+        
+        for name, srv_config in servers.items():
+            command = srv_config.get("command")
+            args = srv_config.get("args", [])
+            env = srv_config.get("env", {})
+            
+            if not command:
+                continue
+
+            cleaned_args = []
+            for arg in args:
+                if isinstance(arg, str):
+                    if (arg.startswith('"') and arg.endswith('"')) or (arg.startswith("'") and arg.endswith("'")):
+                        arg = arg[1:-1]
+                cleaned_args.append(arg)
+
+            try:
+                merged_env = os.environ.copy()
+                merged_env.update(env)
+
+                if HAS_MCP_LIB:
+                    import sys
+                    import shutil
+                    current_dir = os.path.dirname(os.path.abspath(__file__))
+                    wrapper_path = os.path.join(current_dir, "mcp_clean_wrapper.py")
+                    resolved_command = shutil.which(command) or command
+                    
+                    server_params = StdioServerParameters(
+                        command=sys.executable,
+                        args=["-u", wrapper_path, resolved_command] + cleaned_args,
+                        env=merged_env
+                    )
+                    
+                    from contextlib import AsyncExitStack
+                    stack = AsyncExitStack()
+                    self._exit_stacks[name] = stack
+                    
+                    read, write = await stack.enter_async_context(stdio_client(server_params))
+                    session = await stack.enter_async_context(ClientSession(read, write))
+                    await asyncio.wait_for(session.initialize(), timeout=60.0)
+                    self.sessions[name] = session
+                else:
+                    # Pure-Python stdio client fallback (Android Termux / minimal installs)
+                    session = PurePythonMCPSession(command, cleaned_args, merged_env)
+                    await session.start()
+                    await asyncio.wait_for(session.initialize(), timeout=60.0)
+                    self.sessions[name] = session
+                
+                # Retrieve tools from the server and cache them
+                try:
+                    res = await session.list_tools()
+                    self.server_tools[name] = []
+                    for t in res.tools:
+                        full_name = f"{name}__{t.name}"
+                        self._tool_to_server[full_name] = name
+                        self.server_tools[name].append(t.name)
+                        
+                        self.cached_tools.append({
+                            "type": "function",
+                            "function": {
+                                "name": full_name,
+                                "description": f"[{name}] {t.description}",
+                                "parameters": t.inputSchema
+                            }
+                        })
+                except Exception as e:
+                    print(f"Error fetching tools from MCP server {name}: {e}")
+                    
+            except Exception as e:
+                print(f"Error starting MCP server {name}: {e}")
+                
+        self._started = True
+
+    def get_tools(self) -> List[Dict[str, Any]]:
+        """Synchronously returns the cached list of MCP tools."""
+        return self.cached_tools
+
+    def get_notification_context(self) -> str:
+        """Returns the context notification string for connected MCP servers."""
+        from utim_cli.config import config
+        disabled = config.get("disabled_tools") or []
+        if not isinstance(disabled, list):
+            disabled = []
+        notifications = []
+        for server_name, tool_names in self.server_tools.items():
+            enabled_tool_names = [t for t in tool_names if f"{server_name}__{t}" not in disabled]
+            if enabled_tool_names:
+                tools_str = ", ".join(enabled_tool_names)
+                notifications.append(f"this mcp server {server_name} is connected and a new set of tools are available for u: {tools_str}")
+        return "\n".join(notifications)
+
+    def call_tool(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> str:
+        """Synchronously routes tool call execution to the background thread."""
+        return self.run_coro(self._call_tool_async(server_name, tool_name, arguments))
+
+    async def _call_tool_async(self, server_name: str, tool_name: str, arguments: Dict[str, Any]) -> str:
+        if server_name not in self.sessions:
+            return f"Error: MCP server '{server_name}' not running."
+            
+        session = self.sessions[server_name]
+        try:
+            res = await session.call_tool(tool_name, arguments)
+            if getattr(res, "isError", False):
+                return f"Error from {server_name}: " + "\n".join(c.text for c in res.content)
+            return "\n".join(c.text for c in res.content)
+        except Exception as e:
+            return f"Error calling {tool_name} on {server_name}: {str(e)}"
+
+    def restart(self):
+        """Synchronously restarts and reloads all MCP sessions."""
+        self.run_coro(self._restart_async())
+
+    async def _restart_async(self):
+        for name, stack in list(self._exit_stacks.items()):
+            try:
+                await stack.aclose()
+            except Exception:
+                pass
+        for name, session in list(self.sessions.items()):
+            if hasattr(session, "close"):
+                try:
+                    await session.close()
+                except Exception:
+                    pass
+        self.sessions.clear()
+        self._exit_stacks.clear()
+        self._tool_to_server.clear()
+        self.cached_tools.clear()
+        self.server_tools.clear()
+        self._started = False
+        await self._start_async()
+
+mcp_manager = MCPManager()

{utim_cli-1.47.4 → utim_cli-1.47.7}/utim_cli/orchestrator.py

@@ -350,6 +350,42 @@ def compress_experience(text: str) -> str:
 
 _qwen_model = None
 _qwen_tokenizer = None
+_qwen_downloading = False
+
+def _trigger_qwen_download_bg():
+    """Trigger background download and caching of Qwen local model if not already loaded or downloading."""
+    global _qwen_model, _qwen_tokenizer, _qwen_downloading
+    if _qwen_model is None and not _qwen_downloading:
+        import sys
+        if "pytest" in sys.modules:
+            return
+        
+        _qwen_downloading = True
+        import threading
+        
+        def download_model_bg():
+            global _qwen_model, _qwen_tokenizer, _qwen_downloading
+            try:
+                import torch
+                from transformers import AutoModelForCausalLM, AutoTokenizer
+                model_id = "Qwen/Qwen2.5-0.5B-Instruct"
+                tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True, local_files_only=False)
+                mod = AutoModelForCausalLM.from_pretrained(
+                    model_id,
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                    device_map="auto",
+                    trust_remote_code=True,
+                    local_files_only=False
+                )
+                _qwen_tokenizer = tok
+                _qwen_model = mod
+            except Exception:
+                pass
+            finally:
+                _qwen_downloading = False
+                
+        t = threading.Thread(target=download_model_bg, daemon=True)
+        t.start()
 
 def summarize_experiences_with_model(experiences: list[dict], existing_cache: str = "") -> str:
     """Summarize list of experiences into a clean list of rules under 2000 tokens using local Qwen model first, falling back to LLM API."""
@@ -409,25 +445,40 @@ def summarize_experiences_with_model(experiences: list[dict], existing_cache: st
             "Output ONLY the clean markdown list of rules (do not include introductory or concluding text):"
         )
 
-    # 1. Attempt local execution using Qwen2.5-0.5B-Instruct
-    try:
-        import sys
-        if "pytest" not in sys.modules:
-            global _qwen_model, _qwen_tokenizer
+    # Proactively trigger Qwen local model download in a background thread if needed
+    _trigger_qwen_download_bg()
+
+    # 1. Attempt Cloud API completions (via UTIM completions server or direct OpenRouter)
+    import os
+    api_key = config.get("api_key")
+    llm_key = os.environ.get("OPENROUTER_API_KEY") or os.environ.get("UTIM_API_KEY")
+    
+    if api_key or llm_key:
+        from utim_cli.reflection import REFLECTION_MODELS
+        from utim_cli.client_utils import proxy_openrouter_request
+        
+        for model in REFLECTION_MODELS:
+            try:
+                resp = proxy_openrouter_request({
+                    "model": model,
+                    "messages": [
+                        {"role": "system", "content": "You are a context compressor. Output rules list directly."},
+                        {"role": "user", "content": prompt}
+                    ],
+                    "max_tokens": 1000
+                })
+                if resp.status_code == 200:
+                    content = resp.json()["choices"][0]["message"]["content"].strip()
+                    if content:
+                        return content
+            except Exception:
+                continue
+
+    # 2. Fallback to local execution using Qwen2.5-0.5B-Instruct if background loader has completed
+    global _qwen_model, _qwen_tokenizer
+    if _qwen_model is not None:
+        try:
             import torch
-            from transformers import AutoModelForCausalLM, AutoTokenizer
-            
-            model_id = "Qwen/Qwen2.5-0.5B-Instruct"
-            
-            if _qwen_model is None:
-                _qwen_tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
-                _qwen_model = AutoModelForCausalLM.from_pretrained(
-                    model_id,
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                    device_map="auto",
-                    trust_remote_code=True
-                )
-                
             messages = [
                 {"role": "system", "content": "You are a context compressor. Output rules list directly."},
                 {"role": "user", "content": prompt}
@@ -454,36 +505,9 @@ def summarize_experiences_with_model(experiences: list[dict], existing_cache: st
             response = _qwen_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
             if response:
                 return response
-                
-    except Exception:
-        pass
-
-    # 2. Fallback to OpenRouter Cloud API
-    import os
-    llm_key = os.environ.get("OPENROUTER_API_KEY") or os.environ.get("UTIM_API_KEY")
-    if not llm_key:
-        return existing_cache or "\n".join(raw_texts[:15])
-        
-    from utim_cli.reflection import REFLECTION_MODELS
-    from utim_cli.client_utils import proxy_openrouter_request
-    
-    for model in REFLECTION_MODELS:
-        try:
-            resp = proxy_openrouter_request({
-                "model": model,
-                "messages": [
-                    {"role": "system", "content": "You are a context compressor. Output rules list directly."},
-                    {"role": "user", "content": prompt}
-                ],
-                "max_tokens": 1000
-            })
-            if resp.status_code == 200:
-                content = resp.json()["choices"][0]["message"]["content"].strip()
-                if content:
-                    return content
         except Exception:
-            continue
-            
+            pass
+
     return existing_cache or "\n".join(raw_texts[:15])
 
 def update_experience_summary_cache(user_prompt: str) -> str: