utim-cli 2.3.0__tar.gz → 2.3.2__tar.gz

{utim_cli-2.3.0 → utim_cli-2.3.2}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [2.3.2] - 2026-08-20
+
+### 🚀 Performance & Fixes
+- Token usage optimization and bug fixes
+
+## [2.3.1] - 2026-08-19
+
+### 🛠️ Fixes & Enhancements
+- Major bug fixes in agent loop and enhancements
+
 ## [2.3.0] - 2026-08-18
 
 ### 🚀 Features & Enhancements

{utim_cli-2.3.0/utim_cli.egg-info → utim_cli-2.3.2}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.0"
+version = "2.3.2"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
@@ -93,7 +93,7 @@ utimlite = "utim_cli.utim:main_cli_entry"
 
 
 [tool.setuptools.packages.find]
-include = ["utim_cli*"]
+include = ["utim*", "utim_cli*"]
 exclude = ["tests*", "landing*", "scripts*"]
 
 [tool.setuptools.package-data]
@@ -101,6 +101,7 @@ utim_cli = ["mcp_registry.json", "_version.py", "utimmodel.txt", "models.txt", "
 
 
 [tool.pytest.ini_options]
+addopts = "-m 'not benchmark and not slow and not integration' --ignore=tests/test_benchmark.py --ignore=tests/bench_agent.py"
 markers = [
     "smoke: fast install validation tests (no live credentials required)",
     "slow: tests that make network calls or take more than 10 seconds",

utim_cli-2.3.2/utim/__init__.py

@@ -0,0 +1,76 @@
+"""
+UTIM Developer SDK
+------------------
+Unified autonomous coding agent SDK.
+
+Quickstart:
+    import utim
+
+    session = utim.Session()
+    async for event in session.send_message("Explain this codebase"):
+        if event.type == utim.EventType.TOKEN:
+            print(event.text, end="", flush=True)
+"""
+try:
+    from utim_cli._version import VERSION as __version__
+except ImportError:
+    __version__ = "2.3.0"
+
+# Developer-friendly core classes (similar to `import genai` / `import openai`)
+from utim_cli.sdk.session import UtimSession as Session
+from utim_cli.sdk.config import UtimConfig as Config
+from utim_cli.sdk.context import IDEContext, Diagnostic
+from utim_cli.sdk.events import (
+    AgentEvent,
+    UtimEventType as EventType,
+    TokenStreamEvent,
+    ThoughtStreamEvent,
+    ToolCallStartEvent,
+    ToolCallEndEvent,
+    FileEditEvent,
+    CommandExecEvent,
+    ConfirmationRequestEvent,
+    PlanUpdateEvent,
+    SubagentEvent,
+    TurnEndEvent,
+)
+from utim_cli.sdk.handlers import (
+    ConfirmationHandler,
+    AutoApprovalHandler,
+    CallbackApprovalHandler,
+)
+from utim_cli.sdk.sidecar import UtimSidecarServer as SidecarServer
+
+# Backwards compatible alias names
+UtimSession = Session
+UtimConfig = Config
+UtimEventType = EventType
+UtimSidecarServer = SidecarServer
+
+__all__ = [
+    "__version__",
+    "Session",
+    "Config",
+    "IDEContext",
+    "Diagnostic",
+    "EventType",
+    "AgentEvent",
+    "TokenStreamEvent",
+    "ThoughtStreamEvent",
+    "ToolCallStartEvent",
+    "ToolCallEndEvent",
+    "FileEditEvent",
+    "CommandExecEvent",
+    "ConfirmationRequestEvent",
+    "PlanUpdateEvent",
+    "SubagentEvent",
+    "TurnEndEvent",
+    "ConfirmationHandler",
+    "AutoApprovalHandler",
+    "CallbackApprovalHandler",
+    "SidecarServer",
+    "UtimSession",
+    "UtimConfig",
+    "UtimEventType",
+    "UtimSidecarServer",
+]

{utim_cli-2.3.0 → utim_cli-2.3.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.3.0"
+    __version__ = "2.3.2"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.0 → utim_cli-2.3.2}/utim_cli/_version.py

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

{utim_cli-2.3.0 → utim_cli-2.3.2}/utim_cli/orchestrator.py

@@ -186,14 +186,15 @@ _utim_dir_posix = get_utim_dir().as_posix()
 # System Prompt
 SYSTEM_PROMPT = f"""You are UTIM AI, a high-agency senior software engineer operating autonomously inside a CLI. You focus purely on the technical project or task at hand.
 
-### CORE DIRECTIVES:
-1. **Explore & Route**: A project architecture snapshot is injected below — use it immediately instead of calling list_directory. For localized tasks (single-file edits, styling): go straight to the file. For system-wide tasks: use the snapshot to plan without extra listings.
-2. **Execute Immediately & Autonomous Agency**: Do not wait for permissions or ask conversational filler questions (e.g. 'Would you like me to explain my approach before I proceed?'). Invoke tools or provide direct analysis immediately. No preamble, no placeholder stubs.
-3. **Architectural & Project Planning**: Proactively invoke `plan_project` (with `plan_part` set to 'design', 'architecture', 'security', 'database', 'testing', 'deployment', or 'features') for non-trivial tasks, new features, or architectural builds to establish expert specifications before implementing. Verify code changes with `run_command` (build/test).
-4. **Manifesto Reference**: Safety and coding standards are in {_utim_dir_posix}/UTIM.md. Read only when specific guidance is needed.
-5. **Output**: Concise, professional, warm. Summarize changes + test results at the end. Propose improvements only — don't fix unsolicited issues.
-6. **Tool Calling**: Use native function-calling only. No raw JSON, no <think> tags, no tool markup in text.
-7. **Premium Web Design**: Style UIs per `{_utim_dir_posix}/DESIGN.md` (HSL colors, glassmorphism, animations).
+### SYSTEM DIRECTIVES:
+1. **Direct High-Leverage Execution**: Take the cleanest, fastest, and most cost-effective path to solve the task with high precision and quality. Avoid unnecessary exploratory loops.
+2. **Targeted Search & Scoped Reading**: Use `grep_search` for exact symbols/errors and `read_file` with `start_line`/`end_line` or `symbol_name`. Never read entire un-sliced large files or perform redundant directory listings when paths are known.
+3. **Architectural & Feature Planning**: Proactively invoke `plan_project` (with `plan_part` set to 'design', 'architecture', 'features', 'database', 'security', or 'testing') for new features, system designs, and complex multi-file refactors to establish clear specifications before implementing. For localized/simple edits or direct bug fixes, execute code changes directly.
+4. **Think-Create-Verify**: Execute tools directly without conversational preambles or boilerplate. Verify your changes with `run_command` (tests, build, execution check) to guarantee quality.
+5. **Manifesto Reference**: Safety and coding standards are in {_utim_dir_posix}/UTIM.md. Read only when specific guidance is needed.
+6. **Output**: Concise, professional, direct. Summarize changes + test results clearly without repeating whole files in text.
+7. **Tool Calling**: Use native function-calling only. No raw JSON, no <think> tags, no tool markup in text.
+8. **Premium Web Design**: Style UIs per `{_utim_dir_posix}/DESIGN.md` (HSL colors, glassmorphism, animations).
 
 """
 
@@ -265,14 +266,15 @@ SYSTEM_PROMPT = SYSTEM_PROMPT + _detect_environment()
 
 COMPRESSED_SYSTEM_PROMPT = f"""You are UTIM AI, a high-agency senior CLI software engineer.
 
-### CORE DIRECTIVES:
-1. **Explore & Route**: Project snapshot is injected — use it immediately. No redundant list_directory calls.
-2. **Execute Immediately**: Invoke tool calls directly. No preamble, no announcing steps.
-3. **Think-Create-Verify**: Call tools directly. Verify with run_command, not by re-reading files.
-4. **Manifesto**: Safety and coding standards are in {_utim_dir_posix}/UTIM.md.
-5. **Output**: Concise, professional, warm.
-6. **Tool Calling**: Use native function-calling. No raw JSON, `<think>` tags, or raw tool markup.
-7. **Premium Web Design**: Style UIs per `{_utim_dir_posix}/DESIGN.md` (HSL colors, glassmorphism, animations).
+### SYSTEM DIRECTIVES (COMPRESSED):
+1. **Direct Execution (High-Leverage)**: Take the shortest, most cost-effective path to completion without reducing quality. Inspect target code directly -> apply precision edits -> verify.
+2. **Targeted Search & Scoped Reading**: Use `grep_search` and `read_file` with line ranges/symbols. Do not read entire large files or re-scan directories when the file path is known.
+3. **Strategic Planning**: Invoke `plan_project` for new features, complex refactors, and architectural designs before implementing. For localized/simple edits, modify code directly.
+4. **Think-Create-Verify**: Call tools directly. Verify with run_command, not by re-reading files.
+5. **Manifesto**: Safety and coding standards are in {_utim_dir_posix}/UTIM.md.
+6. **Output**: Concise, professional, warm.
+7. **Tool Calling**: Use native function-calling. No raw JSON, `<think>` tags, or raw tool markup.
+8. **Premium Web Design**: Style UIs per `{_utim_dir_posix}/DESIGN.md` (HSL colors, glassmorphism, animations).
 """
 
 def _detect_environment_compressed() -> str:
@@ -817,28 +819,28 @@ def _get_dynamic_directives(is_compressed: bool, messages: Optional[List[Dict]]
         return "### TOOL STATUS: ALL TOOLS DISABLED\nAll tools are disabled. You may only respond in text."
 
     if is_compressed:
-        # Short, token-efficient directives for steady-state turns. The full
-        # version is only injected on iteration 0 (first turn).
+        # Short, token-efficient directives for consecutive intermediate turns.
         directives = [
-            "### CORE DIRECTIVES:",
-            "1. **Targeted Search**: Use `grep_search` for symbols/errors; `read_file` with symbol_name or line ranges — no un-sliced large reads.",
-            "2. **Images**: If the prompt includes an image path (.png/.jpg/.jpeg), `read_file` it immediately on Turn 1 with that exact path.",
-            "3. **Planning**: Invoke `plan_project` for non-trivial tasks/new features/refactors before implementing.",
-            "4. **Think-Create-Verify**: Execute tools directly. Verify edits with `run_command` (build/test/verify). Prefer Standard Library in standalone scripts for zero-dependency portability.",
-            "5. **Background Tasks & Reactive Awakening**: You can run multiple background commands concurrently (`run_command` with `is_background=True`) or set timers with `schedule`. After launching, conclude your turn; no need to check or loop bg task u will be notified on completion.",
-            "6. **Output**: Native function-calling only — no raw JSON, <think> tags, or tool markup in text. Finish with a concise summary.",
+            "### SYSTEM DIRECTIVES (COMPRESSED):",
+            "1. **Direct High-Leverage Execution**: Take the shortest, cleanest, and most cost-effective path to completion without reducing quality. Inspect target code directly -> apply precision edits -> verify.",
+            "2. **Targeted Search & Scoped Reading**: Use `grep_search` and `read_file` with line ranges/symbols. Do not read entire large files or re-scan directories when the file path is known.",
+            "3. **Strategic Planning**: Invoke `plan_project` for new features, complex refactors, and architectural designs before implementing. For localized/simple edits, modify code directly.",
+            "4. **Images**: If prompt includes an image path, `read_file` it immediately on Turn 1 with that exact path.",
+            "5. **Think-Create-Verify**: Execute tools directly. Verify edits with `run_command` (build/test/verify). Prefer Standard Library in standalone scripts for zero-dependency portability.",
+            "6. **Background Tasks**: Run long background commands with `is_background=True` or `schedule` timer and conclude your turn. Multiple background tasks run concurrently.",
+            "7. **Output**: Native function-calling only — no raw JSON or <think> tags. Finish with a concise, direct summary.",
         ]
     else:
         directives = [
-            "### CORE DIRECTIVES:",
-            "1. **Targeted Search**: Use `grep_search` to locate exact symbol definitions, imports, or error text across codebase files.",
-            "2. **Scoped File Reading**: Use `read_file` with `symbol_name` or line ranges (`start_line`/`end_line`) to inspect target function/class definitions. Avoid reading un-sliced large files.",
-            "3. **Images & Screenshots**: If the prompt includes an image or screenshot path (.png, .jpg, .jpeg, etc.), execute `read_file` immediately on Turn 1 with that exact path. Absolute file paths anywhere on the system are valid — do not question file locations.",
-            "4. **Project & Feature Planning**: Proactively invoke `plan_project` (with `plan_part` set to 'design', 'architecture', 'security', 'database', 'testing', 'deployment', or 'features') for non-trivial tasks, new features, system refactors, or new application builds before implementing.",
-            "5. **Think-Create-Verify**: Execute tools directly without conversational preambles or text planning. Never conclude a coding task without verifying your changes: run build, execute tests, or check outputs with `run_command`. In standalone verification scripts, prefer Python standard library modules or handle third-party imports gracefully.",
-            "6. **Background Tasks, Timers & Reactive Awakening**: When starting long-running commands, tests, or servers (`run_command` with `is_background=True`), or setting timers with `schedule`, conclude your turn. No need to check or loop bg task u will be notified on completion. Multiple concurrent background tasks can run simultaneously.",
-            "7. **Execution**: Invoke native function-calling schemas directly. Never output raw JSON, <think> tags, or conversational text before tool calls.",
-            "8. **Output & Autonomous Agency**: Be concise, professional, and clear. Do not ask conversational filler questions like 'Would you like me to explain my approach before I proceed?'. Analyze the request, execute necessary actions, and summarize results directly.",
+            "### SYSTEM DIRECTIVES:",
+            "1. **Direct High-Leverage Execution**: Take the fastest, cleanest, and most cost-effective path to solve the task with high precision and quality. Avoid unnecessary multi-step exploration, speculative refactors, or excessive tool looping. Inspect target -> apply surgical edits -> verify.",
+            "2. **Targeted Search & Scoped Reading**: Use `grep_search` for exact symbols/errors and `read_file` with `start_line`/`end_line` or `symbol_name`. Avoid reading un-sliced large files or calling redundant directory listings.",
+            "3. **Architectural & Feature Planning**: Proactively invoke `plan_project` (with `plan_part` set to 'design', 'architecture', 'features', 'database', 'security', or 'testing') for new features, system designs, and complex multi-file refactors to establish clear specifications before implementing. For localized/simple edits or direct bug fixes, execute code changes directly.",
+            "4. **Images & Screenshots**: If the prompt includes an image or screenshot path (.png, .jpg, .jpeg, etc.), execute `read_file` immediately on Turn 1 with that exact path. Absolute file paths anywhere on the system are valid.",
+            "5. **Think-Create-Verify**: Execute tools directly without conversational preambles or boilerplate. Verify your changes with `run_command` (build, tests, linter, or execution checks). In verification scripts, prefer Python standard library modules.",
+            "6. **Background Tasks, Timers & Reactive Awakening**: When starting long-running commands, tests, or servers, run with `is_background=True` or set timers with `schedule`, and conclude your turn. You will be automatically awakened when complete.",
+            "7. **Execution & Tool Calling**: Invoke native function-calling schemas directly. Never output raw JSON, <think> tags, or conversational text before tool calls.",
+            "8. **Output & Autonomous Agency**: Be concise, professional, and clear. Do not ask conversational filler questions. Deliver high quality with minimum token waste.",
         ]
 
 
@@ -2168,6 +2170,12 @@ class Orchestrator:
                                                 pass
                                         continue
                                     elif t == "content_delta":
+                                        try:
+                                            from utim_cli.state import STATE
+                                            if STATE.get("thinking_topic"):
+                                                STATE["thinking_topic"] = ""
+                                        except Exception:
+                                            pass
                                         # If we were in a thinking block, close it now
                                         if native_reasoning:
                                             native_reasoning = False
@@ -2302,6 +2310,12 @@ class Orchestrator:
                                             
                                         if chunk_text is not None and chunk_text != "":
                                             last_content_time = time.time()  # real data arrived
+                                            try:
+                                                from utim_cli.state import STATE
+                                                if STATE.get("thinking_topic") and not in_think:
+                                                    STATE["thinking_topic"] = ""
+                                            except Exception:
+                                                pass
                                             if native_reasoning:
                                                 native_reasoning = False
                                                 in_think = False
@@ -3272,8 +3286,21 @@ class Orchestrator:
         term_width = self.console.width if (self.console and self.console.width) else shutil.get_terminal_size((80, 24)).columns
         max_wrap_w = max(30, term_width - 8)
 
+        def _is_internal_info_line(l_text: str) -> bool:
+            s = l_text.strip()
+            return (
+                s.startswith("ℹ")
+                or s.startswith("🛈")
+                or "The agent can now safely conclude" in s
+                or "You will automatically receive a [Notification]" in s
+                or "Subagent communication tool" in s
+                or "The agent can now safely conclude its turn" in s
+            )
+
         wrapped_body_lines = []
         for bl in body_lines:
+            if _is_internal_info_line(bl.plain):
+                continue
             plain = bl.plain
             is_tree = plain.startswith(TREE)
             is_pipe = plain.startswith(PIPE)
@@ -4004,10 +4031,11 @@ class Orchestrator:
                 result = f"Error executing tool {func_name}: {e}\n{traceback.format_exc()}"
 
             
-            # Restore the indicator to evaluating logic
+            # Clear thinking topic so prompt_toolkit doesn't show a stuck indicator while rendering
             try:
                 if getattr(self, "_subagent_depth", 0) == 0:
-                    STATE["thinking_topic"] = "Evaluating tool results..."
+                    from utim_cli.state import STATE
+                    STATE["thinking_topic"] = ""
             except Exception:
                 pass
         except Exception as exc:
@@ -5540,6 +5568,20 @@ class Orchestrator:
                 self._persist_messages()
                 break
 
+            # ── Inject any pending background task / system notifications directly into model context ──
+            try:
+                from utim_cli.state import STATE
+                pending_events = STATE.pop("pending_system_events", None)
+                if pending_events:
+                    combined_events = "\n\n".join(str(ev) for ev in pending_events if ev)
+                    if combined_events:
+                        self.messages.append({
+                            "role": "user",
+                            "content": combined_events
+                        })
+            except Exception:
+                pass
+
             # ── Resilient LLM call with per-iteration retry ────────────────────
             # We allow up to 3 transient-error retries per iteration before
             # giving up for real.  This prevents a single network blip from
@@ -6764,3 +6806,9 @@ class Orchestrator:
         # Clear the @subagent tag override so the next turn uses the default system prompt
         self.active_tag = None
         self.active_tag_system_prompt = None
+
+        try:
+            from utim_cli.state import STATE
+            STATE["thinking_topic"] = ""
+        except Exception:
+            pass

utim_cli-2.3.2/utim_cli/plugins/__init__.py

@@ -0,0 +1,10 @@
+"""UTIM CLI Plugin System.
+
+A modular extension framework for packaging, installing, and managing
+skills, MCP servers, custom tools, rules, and lifecycle hooks.
+"""
+
+from utim_cli.plugins.schema import Plugin, PluginManifest
+from utim_cli.plugins.manager import PluginManager, get_plugin_manager
+
+__all__ = ["Plugin", "PluginManifest", "PluginManager", "get_plugin_manager"]