utim-cli 2.3.14__tar.gz → 2.3.16__tar.gz

{utim_cli-2.3.14 → utim_cli-2.3.16}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.3.16] - 2026-08-29
+
+### 🛠️ Minor Enhancements and Bug Fixes
+- Minor Enhancements and Bug Fixes
+
+## [2.3.15] - 2026-08-29
+
+### 🛠️ Minor Enhancements and Tool Call Bug Fixes
+- Minor enhancements and fixed tool call bugs
+
 ## [2.3.14] - 2026-08-28
 
 ### ⚡ Request Queue & Scaled Free Capacity

{utim_cli-2.3.14/utim_cli.egg-info → utim_cli-2.3.16}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.14"
+version = "2.3.16"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
@@ -97,7 +97,7 @@ include = ["utim*", "utim_cli*"]
 exclude = ["tests*", "landing*", "scripts*"]
 
 [tool.setuptools.package-data]
-utim_cli = ["mcp_registry.json", "_version.py", "utimmodel.txt", "models.txt", "server/docs_md/*.md"]
+utim_cli = ["mcp_registry.json", "_version.py", "utimmodel.txt", "models.txt", "server/docs_md/*.md", "builtin/**/*", "builtin/skills/**/*"]
 
 
 [tool.pytest.ini_options]

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim/__init__.py

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

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

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim_cli/_version.py

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

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim_cli/agent.py

@@ -168,6 +168,13 @@ class ReActAgent:
                     arguments[key] = val
             tool_name = actual_name
 
+        # Collapse duplicated tool names (e.g. 'read_fileread_file', 'read_file read_file',
+        # 'run_commandrun_command') produced by buggy model/proxy tool-call serialization.
+        import re as _re_dup
+        _dup_match = _re_dup.match(r'^([a-zA-Z_]\w*)[\s_]*\1$', tool_name)
+        if _dup_match:
+            tool_name = _dup_match.group(1)
+
         # Map common alias tool names to actual UTIM CLI tool names
         _TOOL_NAME_ALIASES = {
             "shell": "run_command",

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim_cli/bootstrap.py

@@ -74,10 +74,54 @@ def _sync_global_experience(api_key: str, current_folder: str):
         pass
 
 def _write_skills_and_agents():
-    """Create the empty skills/ directory inside ~/.utim/. Skills are built by the reflection engine."""
+    """Create the skills/ directory inside ~/.utim/ and auto-seed built-in guides."""
     try:
         skills_dir = UTIM_DIR / 'skills'
         skills_dir.mkdir(parents=True, exist_ok=True)
+        
+        guide_dir = skills_dir / 'utim-guide'
+        guide_dir.mkdir(parents=True, exist_ok=True)
+        guide_md = guide_dir / 'SKILL.md'
+        if not guide_md.exists():
+            guide_content = """---
+name: utim-guide
+description: Comprehensive reference for UTIM CLI features, keybindings, commands (/model, /rewind, /tools, /tasks, /mcp, /doctor), model switching, and session controls.
+---
+
+# UTIM CLI User Guide & Command Reference
+
+When users ask how to use, configure, or control UTIM CLI, or ask you to switch models or perform CLI operations, explain and reference these native commands:
+
+## 1. Model Switching & Configuration
+- **Switch Model**: Type `/model` or press `Ctrl+M` in the terminal to open the interactive model selector (browse catalog, switch to free/paid models, import BYOK OpenRouter/Anthropic/OpenAI keys, or connect custom OpenAI-compatible endpoints).
+- **Model Settings**: Type `/modelsettings` to customize max token limits, temperature, or context envelopes per model.
+- **API Keys / BYOK**: Type `/auth` or configure OpenRouter / custom provider keys via `/model`.
+
+## 2. Session & History Navigation
+- **Rollback & Rewind**: Type `/rewind` to open the interactive checkpoint rollback menu (rewinds conversation history and reverts filesystem changes).
+- **Undo / Redo**: Type `/undo` or `/redo` to quickly revert or reapply recent file modifications.
+- **Resume Sessions**: Type `/resume` to search and load past saved sessions.
+- **Clear / Fresh Session**: Type `/clear` or `/new` to start a clean new session.
+- **Context Compaction**: Type `/compact` to manually compact session context.
+
+## 3. Tool & Terminal Controls
+- **Tool Toggle Menu**: Type `/tools` to interactively enable or disable specific tools (e.g. `run_command`, `write_file`, `web_search`).
+- **Expand / Collapse Output**: Press `Ctrl+O` in the terminal to toggle expanding or collapsing tool execution details and `<think>` reasoning blocks.
+- **Abort / Cancel**: Press `Ctrl+C` to immediately cancel active model generation or tool execution.
+- **Background Tasks**: Type `/tasks` or `/bg` to list running background processes and timers. Use `/kill <id>` or `/stop <id>` to terminate them.
+
+## 4. MCP, Skills & Subagents
+- **Model Context Protocol (MCP)**: Type `/mcp` to manage MCP server connections, view active tools, or install new MCP servers.
+- **Skills & Subagents**: Type `/skills` to browse active skill playbooks, or `/subagents` / `/miniagents` to invoke specialized subagent workflows.
+- **Marketplace**: Type `/marketplace` to explore community tools and extensions.
+
+## 5. Account & Diagnostics
+- **Login / Logout**: Type `/login` or `/logout` to manage your UTIM Community account.
+- **Quota & Balance**: Type `/quota` to check remaining credits, `/usage` for model token breakdown, `/quotashare` to share quota, or `/redeem` to redeem shared access keys.
+- **Diagnostics**: Type `/doctor` to test environment health, API connectivity, and database integrity.
+- **Support Report**: Type `/report` to create a diagnostic support bundle.
+"""
+            guide_md.write_text(guide_content, encoding='utf-8')
     except Exception as e:
         from utim_cli.logger import log_error
         log_error("bootstrap", "Failed to create skills directory in ~/.utim/", e)
@@ -157,7 +201,9 @@ def scan_available_skills(force_reload: bool = False):
         disabled = []
 
     skills = {}
+    pkg_builtin_skills = Path(__file__).resolve().parent / "builtin" / "skills"
     paths_to_check = [
+        pkg_builtin_skills,
         Path('.agents/skills'),
         Path('.agentskills'),
         Path('.agents'),

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim_cli/brain.py

@@ -990,7 +990,7 @@ def get_brain_context_prompt(user_prompt: str = "") -> str:
             f"\n\n### BRAIN MEMORY DIRECTORY ###\n"
             f"Project brain directory: [brain](file:///{proj_url})\n"
             f"Global brain directory: [global_brain](file:///{root_url})\n"
-            f"If you need historical project details, architecture snapshots, or conventions, you can view the files in the brain directory.\n"
+            f"Note: The paths above are directories. To explore historical project memories, architecture snapshots, or conventions, call `list_directory('{proj_url}')` and `read_file` on the memory files inside it.\n"
         )
     except Exception:
         return ""

utim_cli-2.3.16/utim_cli/builtin/skills/utim-guide/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: utim-guide
+description: Comprehensive reference for UTIM CLI features, keybindings, commands (/model, /rewind, /tools, /tasks, /mcp, /doctor), model switching, and session controls.
+---
+
+# UTIM CLI User Guide & Command Reference
+
+When users ask how to use, configure, or control UTIM CLI, or ask you to switch models or perform CLI operations, explain and reference these native commands:
+
+## 1. Model Switching & Configuration
+- **Switch Model**: Type `/model` or press `Ctrl+M` in the terminal to open the interactive model selector (browse catalog, switch between free/paid models, import BYOK OpenRouter/Anthropic/OpenAI keys, or connect custom OpenAI-compatible endpoints).
+- **Model Settings**: Type `/modelsettings` to customize max token limits, temperature, or context envelopes per model.
+- **API Keys / BYOK**: Type `/auth` or configure OpenRouter / custom provider keys via `/model`.
+
+## 2. Session & History Navigation
+- **Rollback & Rewind**: Type `/rewind` to open the interactive checkpoint rollback menu (rewinds conversation history and reverts filesystem changes).
+- **Undo / Redo**: Type `/undo` or `/redo` to quickly revert or reapply recent file modifications.
+- **Resume Sessions**: Type `/resume` to search and load past saved sessions.
+- **Clear / Fresh Session**: Type `/clear` or `/new` to start a clean new session.
+- **Context Compaction**: Type `/compact` to manually compact session context.
+
+## 3. Tool & Terminal Controls
+- **Tool Toggle Menu**: Type `/tools` to interactively enable or disable specific tools (e.g. `run_command`, `write_file`, `web_search`).
+- **Expand / Collapse Output**: Press `Ctrl+O` in the terminal to toggle expanding or collapsing tool execution details and `<think>` reasoning blocks.
+- **Abort / Cancel**: Press `Ctrl+C` to immediately cancel active model generation or tool execution.
+- **Background Tasks**: Type `/tasks` or `/bg` to list running background processes and timers. Use `/kill <id>` or `/stop <id>` to terminate them.
+
+## 4. MCP, Skills & Subagents
+- **Model Context Protocol (MCP)**: Type `/mcp` to manage MCP server connections, view active tools, or install new MCP servers.
+- **Skills & Subagents**: Type `/skills` to browse active skill playbooks, or `/subagents` / `/miniagents` to invoke specialized subagent workflows.
+- **Marketplace**: Type `/marketplace` to explore community tools and extensions.
+
+## 5. Account & Diagnostics
+- **Login / Logout**: Type `/login` or `/logout` to manage your UTIM Community account.
+- **Quota & Balance**: Type `/quota` to check remaining credits, `/usage` for model token breakdown, `/quotashare` to share quota, or `/redeem` to redeem shared access keys.
+- **Diagnostics**: Type `/doctor` to test environment health, API connectivity, and database integrity.
+- **Support Report**: Type `/report` to create a diagnostic support bundle.

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim_cli/client_utils.py

@@ -678,7 +678,8 @@ def sanitize_messages_for_api(messages, model_id: Optional[str] = None):
                             fn["arguments"] = "{}"
                         elif not isinstance(args, str):
                             try:
-                                fn["arguments"] = json.dumps(args)
+                                clean_args = _sanitize_json(args)
+                                fn["arguments"] = json.dumps(clean_args, allow_nan=False)
                             except (TypeError, ValueError):
                                 fn["arguments"] = "{}"
                         c["function"] = fn
@@ -856,14 +857,171 @@ def parse_xml_tool_calls(content: str) -> tuple[str | None, list[dict]]:
             }
         })
         
-    parts.append(content[last_idx:])
-    cleaned_content = "".join(parts).strip()
-    if not cleaned_content:
-        cleaned_content = None
-        
     return cleaned_content, tool_calls
 
 
+def merge_tool_call_delta(entry: dict, tc_delta: Any) -> None:
+    """
+    Safely accumulates an incoming streaming tool call delta chunk into the target entry.
+    Prevents duplicate tool names (e.g. 'read_fileread_file') and duplicate cumulative
+    argument buffers (which produce invalid concatenated JSON).
+    """
+    if not entry or not isinstance(entry, dict):
+        return
+
+    if "function" not in entry or not isinstance(entry["function"], dict):
+        entry["function"] = {"name": "", "arguments": ""}
+
+    # 1. Tool Call ID
+    tc_id = tc_delta.get("id") if isinstance(tc_delta, dict) else getattr(tc_delta, "id", None)
+    if tc_id and not entry.get("id"):
+        entry["id"] = tc_id
+
+    # 2. Function object
+    fn = tc_delta.get("function") if isinstance(tc_delta, dict) else getattr(tc_delta, "function", None)
+    if not fn:
+        return
+
+    incoming_name = fn.get("name") if isinstance(fn, dict) else getattr(fn, "name", None)
+    incoming_args = fn.get("arguments") if isinstance(fn, dict) else getattr(fn, "arguments", None)
+
+    # Function Name:
+    if incoming_name:
+        curr_name = entry["function"].get("name", "")
+        if not curr_name:
+            entry["function"]["name"] = str(incoming_name)
+        elif curr_name == incoming_name:
+            pass  # Provider resent the exact same complete tool name; do not duplicate
+        elif incoming_name.startswith(curr_name):
+            entry["function"]["name"] = str(incoming_name)  # Provider sent full/longer name
+        elif curr_name.startswith(incoming_name):
+            pass  # Existing name is already more complete
+        else:
+            # Genuine chunk continuation
+            entry["function"]["name"] += str(incoming_name)
+
+    # Function Arguments:
+    if incoming_args is not None:
+        incoming_args_str = str(incoming_args)
+        curr_args = entry["function"].get("arguments", "")
+        if not curr_args:
+            entry["function"]["arguments"] = incoming_args_str
+        elif curr_args == incoming_args_str:
+            pass  # Provider resent the same arguments buffer
+        elif incoming_args_str.startswith(curr_args):
+            # Provider sent cumulative buffer instead of delta
+            entry["function"]["arguments"] = incoming_args_str
+        else:
+            # Standard delta chunk
+            entry["function"]["arguments"] += incoming_args_str
+
+
+def repair_and_normalize_tool_call(tc: dict) -> dict:
+    """
+    Sanitizes, de-duplicates and repairs tool call names and JSON arguments.
+    Fixes doubled tool names ('read_fileread_file' -> 'read_file'), alias names,
+    concatenated JSON objects, unclosed braces, and attribute-style strings.
+    """
+    if not tc or not isinstance(tc, dict):
+        return tc
+
+    import re, json
+
+    KNOWN_TOOLS = {
+        "read_file", "write_file", "edit_file", "delete_file", "move_file",
+        "run_command", "list_directory", "get_background_output", "send_background_input",
+        "stop_background_process", "list_background_processes", "web_search",
+        "plan_project", "manage_todos", "generate_image", "grep_search", "view_file", "search"
+    }
+    ALIASES = {
+        "view_file": "read_file",
+        "search": "grep_search",
+        "search_codebase": "grep_search",
+        "bash": "run_command",
+        "cmd": "run_command",
+        "shell": "run_command",
+        "execute_command": "run_command",
+    }
+
+    fn = tc.get("function")
+    if not fn or not isinstance(fn, dict):
+        return tc
+
+    raw_name = str(fn.get("name", "")).strip()
+    raw_args = fn.get("arguments", "{}")
+
+    # 1. Clean and normalize tool name
+    for known in KNOWN_TOOLS:
+        if raw_name.startswith(known):
+            raw_name = known
+            break
+        if raw_name == known + known:
+            raw_name = known
+            break
+
+    if raw_name in ALIASES:
+        raw_name = ALIASES[raw_name]
+
+    fn["name"] = raw_name
+
+    # 2. Repair and validate arguments JSON
+    if isinstance(raw_args, dict):
+        fn["arguments"] = json.dumps(raw_args)
+        return tc
+
+    raw_args_str = str(raw_args).strip()
+    if not raw_args_str or raw_args_str in ("{}", "null", "None"):
+        fn["arguments"] = "{}"
+        return tc
+
+    # Try standard JSON parsing
+    try:
+        parsed = json.loads(raw_args_str)
+        if isinstance(parsed, dict):
+            fn["arguments"] = json.dumps(parsed)
+            return tc
+    except json.JSONDecodeError:
+        pass
+
+    # Recovery 1: Check for concatenated JSON objects (e.g. {"filepath": "foo.py"}{"filepath": "foo.py"})
+    match = re.search(r'(\{[\s\S]*?\})(?:\{|$)', raw_args_str)
+    if match:
+        try:
+            parsed = json.loads(match.group(1))
+            if isinstance(parsed, dict):
+                fn["arguments"] = json.dumps(parsed)
+                return tc
+        except json.JSONDecodeError:
+            pass
+
+    # Recovery 2: XML / key="value" attribute string fallback
+    attrs = re.findall(
+        r'(\w+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|\'((?:[^\'\\]|\\.)*)\'|(\S+))',
+        raw_args_str,
+    )
+    if attrs:
+        recovered = {}
+        for key, v1, v2, v3 in attrs:
+            val = v1 or v2 or v3 or ""
+            val = val.replace('\\"', '"').replace("\\'", "'").replace("\\n", "\n").replace("\\t", "\t")
+            recovered[key] = val
+        if recovered:
+            fn["arguments"] = json.dumps(recovered)
+            return tc
+
+    # Recovery 3: Missing trailing closing brace (e.g. {"filepath": "foo.py" )
+    if raw_args_str.startswith("{") and not raw_args_str.endswith("}"):
+        try:
+            parsed = json.loads(raw_args_str + "}")
+            if isinstance(parsed, dict):
+                fn["arguments"] = json.dumps(parsed)
+                return tc
+        except json.JSONDecodeError:
+            pass
+
+    return tc
+
+
 # ── Process-level session-usage runtime sentinel ────────────────────────────
 _RUNTIME_SESSION_KEY: str = ""
 

{utim_cli-2.3.14 → utim_cli-2.3.16}/utim_cli/config.py

@@ -230,15 +230,7 @@ def get_all_utim_dirs() -> List[pathlib.Path]:
     if "pytest" in sys.argv[0] or "py.test" in sys.argv[0] or "PYTEST_CURRENT_TEST" in os.environ:
         _add(pathlib.Path('.utim'))
 
-    # 3. Current workspace / project directories
-    try:
-        cwd = pathlib.Path.cwd()
-        _add(cwd / ".utim")
-        _add(cwd / ".agents")
-    except Exception:
-        pass
-
-    # 4. Standard User Home variants (handles Windows username differences, Git Bash, MSYS, Cygwin)
+    # 3. Standard User Home variants (handles Windows username differences, Linux /home/<user>, macOS /Users/<user>, Git Bash, MSYS, Cygwin)
     user_home_paths = []
     if os.environ.get("USERPROFILE"):
         user_home_paths.append(pathlib.Path(os.environ["USERPROFILE"]))
@@ -263,20 +255,28 @@ def get_all_utim_dirs() -> List[pathlib.Path]:
         _add(h / ".utim")
         _add(h / ".agents")
 
+    # 4. Current workspace / project directories
+    try:
+        cwd = pathlib.Path.cwd()
+        _add(cwd / ".utim")
+        _add(cwd / ".agents")
+    except Exception:
+        pass
+
     return candidates
 
 
 def get_utim_dir() -> pathlib.Path:
-    """Return the centralized .utim directory path.
-    Prioritizes explicit environment variables, existing .utim directories,
-    and falls back cleanly to the primary user profile directory.
+    """Return the centralized, authoritative .utim directory path for the current user.
+    Dynamically resolves across all OS environments (Windows, macOS, Linux, Termux)
+    and user profiles.
     """
     import sys
     if "pytest" in sys.argv[0] or "py.test" in sys.argv[0] or "PYTEST_CURRENT_TEST" in os.environ:
-        return pathlib.Path('.utim')
+        return pathlib.Path('.utim').resolve()
 
-    # Check explicit env var
-    for env_var in ("UTIM_HOME", "UTIM_DIR", "UTIM_PATH"):
+    # 1. Check explicit environment variables
+    for env_var in ("UTIM_HOME", "UTIM_DIR", "UTIM_PATH", "AGY_HOME", "ANTIGRAVITY_HOME"):
         val = os.environ.get(env_var)
         if val:
             try:
@@ -286,26 +286,32 @@ def get_utim_dir() -> pathlib.Path:
             except Exception:
                 pass
 
-    # Check existing .utim directories from all candidate paths
-    all_dirs = get_all_utim_dirs()
-    for d in all_dirs:
-        if d.exists() and d.is_dir() and d.name == ".utim":
-            return d
-
-    # Default fallback to primary user home
+    # 2. Dynamic Primary User Home directory (~/.utim)
     try:
         if os.environ.get("USERPROFILE"):
-            fallback = pathlib.Path(os.environ["USERPROFILE"]) / ".utim"
+            home_utim = pathlib.Path(os.environ["USERPROFILE"]) / ".utim"
+        elif os.environ.get("HOME"):
+            home_utim = pathlib.Path(os.environ["HOME"]) / ".utim"
+        elif os.environ.get("HOMEDRIVE") and os.environ.get("HOMEPATH"):
+            home_utim = pathlib.Path(os.environ["HOMEDRIVE"] + os.environ["HOMEPATH"]) / ".utim"
         else:
-            fallback = pathlib.Path.home() / ".utim"
+            home_utim = pathlib.Path.home() / ".utim"
     except Exception:
-        fallback = pathlib.Path(os.path.expanduser("~")) / ".utim"
+        home_utim = pathlib.Path(os.path.expanduser("~")) / ".utim"
 
     try:
-        fallback.mkdir(parents=True, exist_ok=True)
+        home_utim.mkdir(parents=True, exist_ok=True)
+        return home_utim
     except Exception:
         pass
-    return fallback
+
+    # 3. Candidate fallback if user home is read-only or inaccessible
+    all_dirs = get_all_utim_dirs()
+    for d in all_dirs:
+        if d.exists() and d.is_dir() and d.name == ".utim":
+            return d
+
+    return home_utim
 
 
 class Config: