utim-cli 2.3.26__tar.gz → 2.4.1__tar.gz

{utim_cli-2.3.26 → utim_cli-2.4.1}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [2.4.1] - 2026-09-18
+
+###  Bug Fixes
+- Fixed the `UnboundLocalError: rotator` crash when resolving failover providers.
+- Fixed an Admin UI bug that zeroed out free model upstream prices in the Model Pricing & Provisioning interface.
+
+## [2.4.0] - 2026-09-14
+
+### ✨ New Features & Enhancements
+- Added native file tools for binary documents (Excel/`.xlsx`, Word/`.docx`, PDF/`.pdf`).
+- Implemented `@mcp` sticky tags for automated daemon-like MCP server configuration without background processes.
+- Eliminated typing input latency and UI lag by migrating `os.path.exists` checks to async background threads.
+- Refactored Context Monitor with retro-active gap logic to instantly handle dynamic interval thresholds and sudden context bloat.
+
+### 🐛 Bug Fixes
+- Fixed the CSV sniffer crashing when writing markdown tables to binary files.
+- Fixed Windows path spacing errors during inline Python execution.
+- Fixed UI rendering bugs where multi-line markdown boxes wouldn't flush to screen until refreshed.
+
+
 ## [2.3.26] - 2026-09-08
 
 ### 🛡️ Zero Rate-Limit Failover & Low-Latency Key Rotation

{utim_cli-2.3.26/utim_cli.egg-info → utim_cli-2.4.1}/PKG-INFO

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

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

{utim_cli-2.3.26 → utim_cli-2.4.1}/utim/__init__.py

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

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

{utim_cli-2.3.26 → utim_cli-2.4.1}/utim_cli/_version.py

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

{utim_cli-2.3.26 → utim_cli-2.4.1}/utim_cli/agent.py

@@ -3,6 +3,7 @@ import json
 import sys
 import time
 from .tools import get_tools
+from .syntax_fix import attempt_syntax_repair
 from rich.console import Console
 from rich.live import Live
 from rich.spinner import Spinner
@@ -182,6 +183,25 @@ class ReActAgent:
             "cmd": "run_command",
             "execute_command": "run_command",
             "view_file": "read_file",
+            "write_to_file": "write_file",
+            "create_file": "write_file",
+            "save_file": "write_file",
+            "str_replace_editor": "edit_file",
+            "replace_file_content": "edit_file",
+            "modify_file": "edit_file",
+            "update_file": "edit_file",
+            "edit": "edit_file",
+            "list_dir": "list_directory",
+            "dir": "list_directory",
+            "ls": "list_directory",
+            "search": "grep_search",
+            "search_codebase": "grep_search",
+            "grep": "grep_search",
+            "find_files": "find_by_name",
+            "find_file": "find_by_name",
+            "websearch": "web_search",
+            "search_web": "web_search",
+            "crawl": "crawl_web",
         }
         if tool_name in _TOOL_NAME_ALIASES:
             tool_name = _TOOL_NAME_ALIASES[tool_name]
@@ -249,7 +269,11 @@ class ReActAgent:
             return f"Error: Tool '{tool_name}' not found."
             
         try:
-            result = tool_functions[tool_name](**arguments)
+            import inspect
+            sig = inspect.signature(tool_functions[tool_name])
+            has_var_kw = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values())
+            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
@@ -270,7 +294,20 @@ class ReActAgent:
             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="")
-            return f"Error executing {tool_name}: {str(e)}"
+
+            # Auto-repair: if the tool failed due to a syntax error in the
+            # generated code, attempt an "on the go" syntax fix before
+            # reporting the error.
+            error_msg = str(e)
+            repaired = None
+            try:
+                repaired = attempt_syntax_repair(error_msg, self.console)
+            except Exception:
+                repaired = None
+            if repaired:
+                return repaired
+
+            return f"Error executing {tool_name}: {error_msg}"
 
 
     def run(self, max_iterations: int = 500, show_tools: bool = True):
@@ -282,6 +319,7 @@ class ReActAgent:
             tool_calls = []
             current_tool_call = None
 
+            from utim_cli.client_utils import sanitize_tools_for_api, sanitize_messages_for_api, repair_and_normalize_tool_call
             utim_tools, tool_functions = get_tools()
             all_tools = utim_tools
 
@@ -291,11 +329,11 @@ class ReActAgent:
                 "stream": True,
             }
             if all_tools:
-                kwargs["tools"] = all_tools
+                kwargs["tools"] = sanitize_tools_for_api(all_tools, model_id=self.model_id)
 
             # Provider-safety pass: drop null/empty `tool_calls` keys from
             # history (strict providers 400 on `messages.N.tool_calls: null`).
-            kwargs["messages"] = sanitize_messages_for_api(kwargs.get("messages") or [], model_id=getattr(self, "model", None))
+            kwargs["messages"] = sanitize_messages_for_api(kwargs.get("messages") or [], model_id=self.model_id)
 
             # Call the LLM with streaming (retry once on transport errors so a
             # mid-stream failure doesn't silently kill the whole run)
@@ -365,6 +403,9 @@ class ReActAgent:
                 assistant_content = parsed_content or ""
                 tool_calls.extend(parsed_tool_calls)
 
+            # Repair and normalize all tool calls (names, IDs, types, arguments)
+            tool_calls = [repair_and_normalize_tool_call(tc) for tc in tool_calls if tc]
+
             # Print any text content generated by the assistant
             if assistant_content.strip():
                 self.console.print()
@@ -414,13 +455,14 @@ class ReActAgent:
             })
 
             # Execute each tool call
-            for tc in tool_calls:
+            for i, tc in enumerate(tool_calls):
                 result = self._execute_tool_call(tc)
 
-                # Add tool result to messages
+                # Add tool result to messages with guaranteed matching tool_call_id
+                tc_id = tc.get("id") or f"call_{i}_{int(time.time()*1000)}"
                 self.messages.append({
                     "role": "tool",
-                    "tool_call_id": tc.get("id", ""),
+                    "tool_call_id": tc_id,
                     "content": result,
                 })
         else:

utim_cli-2.4.1/utim_cli/architecture_indexer.py

@@ -0,0 +1,251 @@
+import os
+import re
+import json
+import hashlib
+from pathlib import Path
+import ast
+
+def get_project_hash(project_path: str) -> str:
+    return hashlib.sha256(os.path.abspath(project_path).encode('utf-8')).hexdigest()[:12]
+
+def _ignore_dir(dname: str) -> bool:
+    ignored = {'.git', 'node_modules', 'venv', '.venv', '__pycache__', 'dist', 'build', '.next', '.utim'}
+    return dname in ignored
+
+def index_python_file(filepath: Path) -> dict:
+    try:
+        content = filepath.read_text(encoding='utf-8', errors='ignore')
+        tree = ast.parse(content)
+        imports = []
+        symbols = []
+        lines = content.split('\n')
+        
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names: imports.append(alias.name)
+            elif isinstance(node, ast.ImportFrom):
+                if node.module: imports.append(node.module)
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                docstring = ast.get_docstring(node)
+                args = [a.arg for a in node.args.args]
+                sig = f"({', '.join(args)})"
+                start = max(0, node.lineno - 1)
+                end = min(len(lines), start + 6)
+                snippet = "\n".join(lines[start:end])
+                if len(lines) > end: snippet += "\n    # ..."
+                symbols.append({"type": "function", "name": node.name, "line": node.lineno, "docstring": docstring, "signature": sig, "snippet": snippet})
+            elif isinstance(node, ast.ClassDef):
+                docstring = ast.get_docstring(node)
+                start = max(0, node.lineno - 1)
+                end = min(len(lines), start + 5)
+                snippet = "\n".join(lines[start:end])
+                if len(lines) > end: snippet += "\n    # ..."
+                symbols.append({"type": "class", "name": node.name, "line": node.lineno, "docstring": docstring, "snippet": snippet})
+        return {"imports": list(set(imports)), "symbols": symbols}
+    except Exception:
+        return {"imports": [], "symbols": []}
+
+def index_js_ts_file(filepath: Path) -> dict:
+    try:
+        content = filepath.read_text(encoding='utf-8', errors='ignore')
+        imports = re.findall(r'import\s+.*?from\s+[\'"](.*?)[\'"]', content)
+        symbols = []
+        lines = content.split('\n')
+        for i, line in enumerate(lines):
+            match = re.search(r'(?:export\s+)?(?:const|let|var|function|class)\s+([a-zA-Z0-9_]+)', line)
+            if match:
+                name = match.group(1)
+                snippet = "\n".join(lines[i:min(len(lines), i+6)])
+                if len(lines) > i+6: snippet += "\n    // ..."
+                symbols.append({"type": "export", "name": name, "line": i+1, "snippet": snippet, "signature": ""})
+        return {"imports": list(set(imports)), "symbols": symbols}
+    except Exception:
+        return {"imports": [], "symbols": []}
+
+def index_generic_file(filepath: Path) -> dict:
+    try:
+        content = filepath.read_text(encoding='utf-8', errors='ignore')
+        symbols = []
+        lines = content.split('\n')
+        for i, line in enumerate(lines):
+            s_line = line.strip()
+            name = None
+            
+            # 1. Standard OOP / Procedural / DevOps / Smart Contracts
+            m1 = re.search(r'^(?:public |private |protected |export |func |fn |class |struct |interface |def |sub |function |contract |resource |module )\s*([a-zA-Z0-9_]+)\s*(?:\{|\(|:|"|\')', s_line)
+            # 2. SQL Data Definition
+            m2 = re.search(r'^CREATE\s+(?:TABLE|PROCEDURE|VIEW|FUNCTION|TRIGGER)\s+([a-zA-Z0-9_]+)', s_line, re.IGNORECASE)
+            # 3. Bash / Shell scripts
+            m3 = re.search(r'^([a-zA-Z0-9_]+)\s*\(\)\s*\{', s_line)
+            # 4. Lisp / Clojure / Scheme
+            m4 = re.search(r'^\(\s*def[a-zA-Z0-9_]*\s+([a-zA-Z0-9_\-]+)', s_line)
+
+            if m1: name = m1.group(1)
+            elif m2: name = m2.group(1)
+            elif m3: name = m3.group(1)
+            elif m4: name = m4.group(1)
+
+            if name and len(name) > 2 and name not in ("if", "for", "while", "switch", "catch", "return", "else", "elif"):
+                snippet = "\n".join(lines[i:min(len(lines), i+6)])
+                if len(lines) > i+6: snippet += "\n    // ..."
+                symbols.append({"type": "symbol", "name": name, "line": i+1, "snippet": snippet, "signature": ""})
+        return {"imports": [], "symbols": symbols}
+    except Exception:
+        return {"imports": [], "symbols": []}
+
+def architecture_lock(project_path: str = ".") -> str:
+    import uuid
+    from utim_cli.brain import get_current_resolved_project
+    abs_path = os.path.abspath(project_path)
+    if not os.path.isdir(abs_path):
+        return f"Error: Project path '{abs_path}' does not exist or is not a directory."
+
+    proj_id, proj_dir = get_current_resolved_project()
+    arch_hash = uuid.uuid4().hex[:8]
+    arch_dir = proj_dir / f"arch_{arch_hash}"
+    arch_dir.mkdir(parents=True, exist_ok=True)
+    brain_file = arch_dir / "00_architecture_map.json"
+
+    inventory = []
+    project_type = []
+    
+    # Generic stack identification heuristics
+    if (Path(abs_path) / "package.json").exists(): project_type.append("Node.js")
+    if (Path(abs_path) / "requirements.txt").exists() or (Path(abs_path) / "pyproject.toml").exists(): project_type.append("Python")
+    if (Path(abs_path) / "go.mod").exists(): project_type.append("Go")
+    if (Path(abs_path) / "Cargo.toml").exists(): project_type.append("Rust")
+    if (Path(abs_path) / "composer.json").exists(): project_type.append("PHP")
+    if (Path(abs_path) / "Gemfile").exists(): project_type.append("Ruby")
+    
+    # Known binaries to skip indexing completely
+    BINARY_EXTS = {
+        ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".mp4", ".mp3", ".wav",
+        ".zip", ".tar", ".gz", ".rar", ".7z", ".exe", ".dll", ".so", ".dylib",
+        ".bin", ".dat", ".db", ".sqlite", ".pyc", ".class", ".o", ".a", ".lib",
+        ".pdf", ".doc", ".docx", ".xls", ".xlsx"
+    }
+
+    for root, dirs, files in os.walk(abs_path):
+        dirs[:] = [d for d in dirs if not _ignore_dir(d)]
+        for f in files:
+            if f.startswith('.'): continue
+            fpath = Path(root) / f
+            rel_path = str(fpath.relative_to(abs_path)).replace('\\', '/')
+            
+            file_data = {
+                "file": rel_path,
+                "size": fpath.stat().st_size if fpath.exists() else 0,
+                "extension": fpath.suffix,
+                "relationships": []
+            }
+            
+            # Universal Language Routing
+            if fpath.suffix == ".py":
+                data = index_python_file(fpath)
+            elif fpath.suffix in (".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"):
+                data = index_js_ts_file(fpath)
+            elif fpath.suffix.lower() not in BINARY_EXTS:
+                data = index_generic_file(fpath)
+            else:
+                data = {"imports": [], "symbols": []}
+                
+            file_data["imports"] = data["imports"]
+            file_data["symbols"] = data["symbols"]
+            inventory.append(file_data)
+
+    nodes = []
+    edges = []
+    nodes.append({"id": "PROJECT_ROOT", "type": "project", "path": abs_path})
+
+    def get_cluster_name(file_path: str) -> str:
+        parts = file_path.replace('\\', '/').split('/')
+        ignore_dirs = {'src', 'lib', 'app', 'main', 'bin', 'scripts', 'tests', 'test', 'public', 'assets', 'static', 'dist', 'build'}
+        
+        # 1. Find the most meaningful parent directory
+        for part in reversed(parts[:-1]):
+            clean_part = part.lower().strip()
+            if clean_part and clean_part not in ignore_dirs:
+                return clean_part
+        
+        # 2. Fallback to filename if it's unique
+        filename = parts[-1].split('.')[0].lower()
+        if filename not in {'index', 'main', 'app', 'core'}:
+            return filename
+            
+        return "core"
+
+    clusters = {}
+
+    for item in inventory:
+        file_id = item["file"]
+        nodes.append({"id": file_id, "type": "file", "extension": item.get("extension"), "size": item.get("size")})
+        edges.append({"source": "PROJECT_ROOT", "target": file_id, "relation": "contains"})
+        
+        for imp in item.get("imports", []):
+            nodes.append({"id": imp, "type": "module"})
+            edges.append({"source": file_id, "target": imp, "relation": "imports"})
+            
+        cluster_name = get_cluster_name(file_id)
+        if cluster_name not in clusters:
+            clusters[cluster_name] = []
+            
+        try:
+            content = (Path(abs_path) / file_id).read_text(encoding='utf-8', errors='ignore')
+            content_lower = content.lower()
+            file_lower = file_id.lower()
+            if "if __name__ ==" in content or "int main(" in content or "func main(" in content or "app.listen" in content_lower:
+                clusters[cluster_name].append(f"### File: `{file_id}` (Entrypoint/Server)\n*This file contains application startup or core routing.*\n")
+        except:
+            pass
+
+        for sym in item.get("symbols", []):
+            sym_id = f"{file_id}::{sym['name']}"
+            nodes.append({"id": sym_id, "type": sym["type"], "name": sym["name"], "line": sym.get("line")})
+            edges.append({"source": file_id, "target": sym_id, "relation": "defines"})
+
+            name = sym.get("name", "")
+            doc = sym.get("docstring") or ""
+            snippet = sym.get("snippet") or ""
+            sig = sym.get("signature", "")
+            
+            md_block = f"### `{name}{sig}` in `{file_id}`\n"
+            if doc: md_block += f"**Docstring:** {doc}\n"
+            md_block += f"```text\n{snippet}\n```\n"
+            clusters[cluster_name].append(md_block)
+
+    # Dynamically generate markdown files based on organic clusters
+    generated_mds = []
+    for cname, blocks in clusters.items():
+        if not blocks: continue
+        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname)
+        md_content = f"# 🧩 Architecture Component: {cname.title()}\n\n" + "\n".join(blocks)
+        md_filename = f"component_{safe_cname}.md"
+        (arch_dir / md_filename).write_text(md_content, encoding="utf-8")
+        generated_mds.append(md_filename)
+
+    conventions = [
+        "## Innate Project Architecture Rules",
+        "- **Organic Component Isolation**: The project is structured organically. Do not bloat central routers or core files.",
+        "- **Multifile Designs**: When adding large new features, ALWAYS create new standalone component files based on the existing directory structure.",
+        "- **MANDATORY ARCHITECTURE REVIEW**: You MUST use `read_file` on the relevant domain files below BEFORE exploring the source code manually. They contain the exact structural blueprints you need.",
+        f"- **Available Domain Files**: {', '.join([f'[file:///{str(arch_dir.absolute() / m).replace(chr(92), "/")}]' for m in generated_mds])}"
+    ]
+    (arch_dir / "conventions_summary.txt").write_text("\n".join(conventions), encoding="utf-8")
+
+    unique_nodes = {n["id"]: n for n in nodes}.values()
+
+    graph_data = {
+        "project_path": abs_path,
+        "project_type": project_type,
+        "total_files": len(inventory),
+        "nodes": list(unique_nodes),
+        "edges": edges,
+        "capabilities": ["Project orientation", "Graph traversal", "Symbol resolution"]
+    }
+    
+    with open(brain_file, 'w', encoding='utf-8') as bf:
+        json.dump(graph_data, bf, indent=2)
+
+    return (f"Architecture lock successfully generated at: {arch_dir}\n"
+            f"Generated 00_architecture_map.json and detailed Markdown component files.\n"
+            f"Indexed {len(inventory)} files. Identified stack: {', '.join(project_type) or 'Unknown'}.")