utim-cli 1.0.0__py3-none-any.whl

utim_cli/__init__.py

@@ -0,0 +1,40 @@
+# UTIM CLI Package
+import builtins, os, pathlib, urllib.parse, re
+
+def _make_file_uri(path: str) -> str:
+    p = pathlib.Path(path).resolve()
+    encoded = urllib.parse.quote(str(p).replace('\\', '/'))
+    return f"file:///{encoded}"
+
+def _maybe_path_to_uri(text: str) -> str:
+    # Detect absolute Windows paths (C:\... or /c/... )
+    if re.match(r"^[a-zA-Z]:[\\/].*", text) and os.path.exists(text):
+        return f"{text} ({_make_file_uri(text)})"
+    # Detect relative paths that exist in cwd
+    rel = os.path.abspath(text)
+    if os.path.exists(rel):
+        return f"{text} ({_make_file_uri(rel)})"
+    return text
+
+_orig_print = builtins.print
+
+def _utim_print(*args, **kwargs):
+    formatted = [_maybe_path_to_uri(str(a)) for a in args]
+    try:
+        _orig_print(*formatted, **kwargs)
+    except UnicodeEncodeError:
+        import sys
+        encoding = sys.stdout.encoding or 'cp1252'
+        safe_formatted = []
+        for item in formatted:
+            safe_item = item.encode(encoding, errors='backslashreplace').decode(encoding)
+            safe_formatted.append(safe_item)
+        try:
+            _orig_print(*safe_formatted, **kwargs)
+        except Exception:
+            # Absolute fallback to standard ASCII if everything else fails
+            ascii_formatted = [item.encode('ascii', errors='replace').decode('ascii') for item in formatted]
+            _orig_print(*ascii_formatted, **kwargs)
+
+# Override the global print for this package
+builtins.print = _utim_print

utim_cli/agent.py

@@ -0,0 +1,359 @@
+import os
+import json
+import sys
+import time
+from openai import OpenAI
+from .tools import UTIM_TOOLS, TOOL_FUNCTIONS
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.text import Text
+from rich.rule import Rule
+from rich.syntax import Syntax
+
+# ─── Tool display metadata ────────────────────────────────────────────────────
+# Color constants for consolidated 3-color palette
+PURPLE = "#cba6f7"
+BLUE = "#42bcf5"
+YELLOW = "#f9e2af"
+
+TOOL_META = {
+    "read_file":      {"icon": "📄", "verb": "ReadFile",      "color": BLUE},
+    "write_file":     {"icon": "✏️",  "verb": "WriteFile",     "color": YELLOW},
+    "edit_file":      {"icon": "✂️",  "verb": "EditFile",      "color": YELLOW},
+    "move_file":      {"icon": "📦",  "verb": "MoveFile",      "color": BLUE},
+    "delete_file":    {"icon": "🗑️ ", "verb": "DeleteFile",    "color": PURPLE},
+    "run_command":    {"icon": "⚡",  "verb": "RunCommand",    "color": YELLOW},
+    "list_directory": {"icon": "📁",  "verb": "ReadFolder",    "color": PURPLE},
+    "blender_create_object": {"icon": "🧊", "verb": "Create3D",   "color": PURPLE},
+}
+
+TIPS = [
+    "Tip: Copy the last response to your clipboard with /copy",
+    "Tip: Save your current conversation with /resume save <tag>",
+    "Tip: Clear conversation history with /clear",
+    "Tip: Check your credit balance with /balance",
+    "Tip: List available tools with /tools",
+    "Tip: Switch models with /model",
+]
+
+class ReActAgent:
+    """A standalone agent that can reason and execute tools with streaming."""
+
+    def __init__(self, name: str, model_id: str, system_prompt: str, console: Console = None):
+        self.name = name
+        self.model_id = model_id
+        self.console = console or Console()
+        self._tip_index = 0
+
+        api_key = os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENRouter_API_KEY")
+        if not api_key:
+            self.console.print("[dim]⚠  Warning: OPENROUTER_API_KEY is not set.[/dim]")
+
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=api_key or "sk-fake-key-for-init",
+        )
+        self.messages = [{"role": "system", "content": system_prompt}]
+        self.start_time = None
+
+    def add_user_message(self, message: str):
+        self.messages.append({"role": "user", "content": message})
+
+    def get_elapsed_time(self):
+        if self.start_time is None:
+            return "0s"
+        elapsed = int(time.time() - self.start_time)
+        return f"{elapsed // 60}m {elapsed % 60}s" if elapsed >= 60 else f"{elapsed}s"
+
+    def _next_tip(self):
+        tip = TIPS[self._tip_index % len(TIPS)]
+        self._tip_index += 1
+        return tip
+
+    def _render_tool_panel(self, func_name: str, args: dict, result: str):
+        """Render a rich panel for a completed tool call."""
+        meta = TOOL_META.get(func_name, {"icon": "●", "verb": func_name, "color": "white"})
+        icon   = meta["icon"]
+        verb   = meta["verb"]
+        color  = meta["color"]
+
+        # Header line
+        header = Text()
+        header.append("✓  ", style=f"bold {color}")
+        header.append(verb, style=f"bold {color}")
+
+        # Show the primary argument (filepath or command)
+        primary_arg = (
+            args.get("filepath")
+            or args.get("command")
+            or args.get("path")
+            or args.get("src")
+            or ""
+        )
+        if primary_arg:
+            header.append(f"  {primary_arg}", style="white")
+
+        # Body
+        body = Text()
+
+        if func_name == "write_file":
+            body.append(result, style="dim")
+
+        elif func_name == "edit_file":
+            body.append(result, style="dim")
+
+        elif func_name == "read_file":
+            lines = result.split("\n")
+            body.append(f"Read {len(lines)} lines", style="dim")
+
+        elif func_name == "run_command":
+            out = str(result).strip()
+            if len(out) > 300:
+                out = out[:300] + "\n[…truncated]"
+            body.append(out, style="dim")
+
+        elif func_name == "list_directory":
+            items = [l for l in str(result).split("\n") if l.strip()]
+            body.append(f"Listed {max(0, len(items)-1)} item(s).", style="dim")
+
+        elif func_name == "move_file":
+            body.append(result, style="dim")
+
+        elif func_name == "delete_file":
+            body.append(result, style="dim")
+
+        else:
+            out = str(result).strip()
+            if len(out) > 300:
+                out = out[:300] + "\n[…]"
+            body.append(out, style="dim")
+
+        content = header + "\n" + body
+
+        self.console.print(Panel(
+            content,
+            border_style=color,
+            expand=False,
+        ))
+
+    def _execute_tool_call(self, tool_call):
+        """Execute a single tool call by name."""
+        tool_name = tool_call["function"]["name"]
+        
+        # Clean corrupted tool name (e.g. from buggy OpenRouter proxy XML to tool-call translations)
+        # E.g. 'read_file filepath=".utim/UTIM.md" />'
+        arguments = {}
+        raw_args = tool_call["function"].get("arguments", "{}")
+        if raw_args:
+            try:
+                arguments = json.loads(raw_args)
+                if not isinstance(arguments, dict):
+                    arguments = {}
+            except Exception:
+                pass
+
+        tool_name_clean = tool_name.strip("<> ")
+        if tool_name_clean:
+            parts = tool_name_clean.split(None, 1)
+            actual_name = parts[0]
+            if len(parts) > 1:
+                attr_string = parts[1].rstrip("/> ")
+                import re
+                attrs = re.findall(r'(\w+)\s*=\s*(?:"([^"]*)"|\'([^\']*)\'|([^\s>]+))', attr_string)
+                for key, val1, val2, val3 in attrs:
+                    val = val1 or val2 or val3 or ""
+                    arguments[key] = val
+            tool_name = actual_name
+
+        # Update the tool_call dict back with the cleaned values
+        tool_call["function"]["name"] = tool_name
+        tool_call["function"]["arguments"] = json.dumps(arguments)
+
+        arguments = json.loads(tool_call["function"]["arguments"])
+
+        # Show the tool is running
+        meta = TOOL_META.get(tool_name, {"icon": "●", "verb": tool_name, "color": "white"})
+        self.console.print(f"  {meta['icon']}  {meta['verb']} running...", style=f"dim {meta['color']}")
+
+        if "__" in tool_name:
+            server_name, actual_tool_name = tool_name.split("__", 1)
+            try:
+                from utim_cli.mcp_client import mcp_manager
+                if server_name in mcp_manager.sessions:
+                    self.console.print(f"  🔌  Calling MCP tool {server_name} ➔ {actual_tool_name}...", style="dim #cba6f7")
+                    result = mcp_manager.call_tool(server_name, actual_tool_name, arguments)
+                    
+                    # Temporarily register metadata for render
+                    TOOL_META[tool_name] = {"icon": "🔌", "verb": f"Calling {server_name} ➔ {actual_tool_name}", "color": "#cba6f7"}
+                    self._render_tool_panel(tool_name, arguments, result)
+                    return str(result)
+            except Exception as e:
+                return f"Error executing MCP tool {tool_name}: {str(e)}"
+
+        if tool_name not in TOOL_FUNCTIONS:
+            return f"Unknown tool: {tool_name}"
+
+        try:
+            result = TOOL_FUNCTIONS[tool_name](**arguments)
+            self._render_tool_panel(tool_name, arguments, result)
+            return str(result)
+        except Exception as e:
+            return f"Error executing {tool_name}: {str(e)}"
+
+    def run(self, max_iterations: int = 500, show_tools: bool = True):
+        """Run the agent loop with streaming."""
+        self.start_time = time.time()
+
+        for i in range(max_iterations):
+            assistant_content = ""
+            tool_calls = []
+            current_tool_call = None
+
+            mcp_tools = []
+            try:
+                from utim_cli.mcp_client import mcp_manager
+                mcp_tools = mcp_manager.get_tools()
+            except Exception:
+                pass
+
+            # Filter disabled tools
+            from utim_cli.config import config
+            disabled = config.get("disabled_tools", [])
+            all_tools = [t for t in (UTIM_TOOLS + mcp_tools) if t["function"]["name"] not in disabled]
+
+            kwargs = {
+                "model": self.model_id,
+                "messages": self.messages,
+                "stream": True,
+            }
+            if all_tools:
+                kwargs["tools"] = all_tools
+
+            # Call the LLM with streaming
+            stream = self.client.chat.completions.create(**kwargs)
+
+            # Collect streaming chunks
+            for chunk in stream:
+                delta = chunk.choices[0].delta
+
+                if delta.content:
+                    assistant_content += delta.content
+
+                if delta.tool_calls:
+                    for tc in delta.tool_calls:
+                        tc_index = tc.index if tc.index is not None else 0
+                        if current_tool_call is None or tc_index != current_tool_call.get("index"):
+                            # Flush the previous buffered tool call (check index, not id)
+                            if current_tool_call is not None:
+                                tool_calls.append(current_tool_call)
+                            current_tool_call = {
+                                "index": tc_index,
+                                "id": tc.id or "",
+                                "type": tc.type or "function",
+                                "function": {
+                                    "name": tc.function.name if tc.function else "",
+                                    "arguments": tc.function.arguments if tc.function else "",
+                                },
+                            }
+                        else:
+                            # Same tool call — accumulate the argument chunks
+                            if tc.id and not current_tool_call["id"]:
+                                current_tool_call["id"] = tc.id
+                            if tc.function and tc.function.arguments:
+                                current_tool_call["function"]["arguments"] += tc.function.arguments
+
+            # Flush the last buffered tool call
+            if current_tool_call is not None:
+                tool_calls.append(current_tool_call)
+
+            # Print any text content generated by the assistant
+            if assistant_content.strip():
+                self.console.print()
+                self.console.print(Markdown(assistant_content))
+                # Only add a trailing newline if there are no tool calls following
+                if not tool_calls:
+                    self.console.print()
+
+            # If no tool calls, we are done
+            if not tool_calls:
+                break
+
+            # Save the assistant message with tool_calls
+            self.messages.append({
+                "role": "assistant",
+                "content": assistant_content if assistant_content else None,
+                "tool_calls": tool_calls,
+            })
+
+            # Execute each tool call
+            for tc in tool_calls:
+                result = self._execute_tool_call(tc)
+
+                # Add tool result to messages
+                self.messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc.get("id", ""),
+                    "content": result,
+                })
+        else:
+            self.console.print(f"\n[bold yellow]⚠ Agent paused after reaching maximum iterations ({max_iterations}).[/bold yellow]")
+            self.console.print("[dim]You can type 'continue' to resume the task.[/dim]\n")
+
+        elapsed = self.get_elapsed_time()
+        tip = self._next_tip()
+        self.console.print(Rule(f"[dim]⚙  {elapsed}  •  {tip}[/dim]"))
+
+    def list_tools(self):
+        """Display all available tools in a formatted table."""
+        self.console.print()
+        self.console.print(Rule("[bold accent]🔧 Available Tools[/bold accent]"))
+        self.console.print()
+
+        headers = ["Tool", "Description"]
+        all_tools = []
+        for tool_def in UTIM_TOOLS:
+            fn = tool_def["function"]
+            all_tools.append((fn["name"], fn["description"], "standard"))
+
+        try:
+            from utim_cli.mcp_client import mcp_manager
+            mcp_tools = mcp_manager.get_tools()
+            for t in mcp_tools:
+                fn = t["function"]
+                all_tools.append((fn["name"], fn["description"], "mcp"))
+        except Exception:
+            pass
+
+        if not all_tools:
+            return
+
+        # Load disabled tools config
+        from utim_cli.config import config
+        disabled = config.get("disabled_tools", [])
+
+        col_widths = [max(len(t[0]) for t in all_tools) + 2, 60]
+        
+        # Header
+        header_str = f"  {headers[0].ljust(col_widths[0])}  {headers[1]}"
+        self.console.print(f"[bold accent]{header_str}[/bold accent]")
+        self.console.print(Rule(style="dim"))
+        
+        for name, desc, t_type in all_tools:
+            is_disabled = name in disabled
+            status_tag = " [red][Disabled][/red]" if is_disabled else ""
+            desc_str = f"{status_tag} [dim]{desc}[/dim]" if is_disabled else f"[dim]{desc}[/dim]"
+            
+            if t_type == "mcp":
+                tool_str = f"  🔌  {name.ljust(col_widths[0] - 4)}  {desc_str}"
+                self.console.print(f"[#cba6f7]{tool_str}[/#cba6f7]")
+            else:
+                meta = TOOL_META.get(name, {"icon": "●", "color": "white"})
+                # Dim the icon and name color if disabled
+                color = "dim" if is_disabled else meta['color']
+                tool_str = f"  {meta['icon']}  {name.ljust(col_widths[0] - 4)}  {desc_str}"
+                self.console.print(f"[{color}]{tool_str}[/{color}]")
+
+        self.console.print()

utim_cli/auth.py

@@ -0,0 +1,208 @@
+"""
+UTIM CLI — Authentication
+
+Flow:
+  1. Open browser → Firebase auth page (hosted by the UTIM web app or
+     directly via firebaseui / identitytoolkit redirect)
+  2. After sign-in, Firebase redirects to localhost:31415/auth/callback
+     with ?token=<firebase_id_token>&email=<email>&uid=<uid>&name=<name>
+  3. CLI POSTs the Firebase ID token to the Railway server
+     POST https://utim-cli-production.up.railway.app/auth/firebase-login
+  4. Server verifies the token, provisions the user, returns api_key
+  5. CLI stores api_key in local config — used as X-API-Key forever after
+"""
+from __future__ import annotations
+
+import http.server
+import socketserver
+import threading
+import urllib.parse
+import webbrowser
+from typing import Optional
+
+import os
+import requests
+from rich.console import Console
+
+from .config import config
+
+# ── Constants ─────────────────────────────────────────────────────────────────
+
+PURPLE = "#cba6f7"
+BLUE   = "#42bcf5"
+YELLOW = "#f9e2af"
+
+# Production server — all auth calls go here
+SERVER_URL = os.environ.get("UTIM_SERVER_URL", "https://utim-cli-production.up.railway.app")
+WEB_URL = os.environ.get("UTIM_WEB_URL", "https://utim.dev")
+
+# Firebase project config (public — safe to embed in CLI)
+FIREBASE_PROJECT_ID  = "u-t-i-m-39c26"
+FIREBASE_API_KEY     = "AIzaSyAV-L3jY6dS3wXMMNGnYnPTX3IuqBFqK4E"
+FIREBASE_AUTH_DOMAIN = "u-t-i-m-39c26.firebaseapp.com"
+
+console = Console()
+
+# ── Callback HTTP handler ─────────────────────────────────────────────────────
+
+class _AuthCallbackHandler(http.server.BaseHTTPRequestHandler):
+    """Tiny local server that catches the Firebase redirect and closes itself."""
+
+    # Shared state written by do_GET, read by login()
+    received: dict = {}
+
+    def log_message(self, *args):  # silence stdlib HTTP logs
+        pass
+
+    def do_GET(self):
+        query  = urllib.parse.urlparse(self.path).query
+        params = urllib.parse.parse_qs(query)
+
+        token = params.get("token",  [None])[0]
+        email = params.get("email",  [None])[0]
+        uid   = params.get("uid",    [None])[0]
+        name  = params.get("name",   [None])[0]
+
+        if token and email:
+            _AuthCallbackHandler.received = {
+                "token": token,
+                "email": email,
+                "uid":   uid or "",
+                "name":  name or email.split("@")[0],
+            }
+            self._send_html(_SUCCESS_HTML)
+        else:
+            self._send_html(_FAILURE_HTML, status=400)
+
+        # Shut down the local server from a background thread
+        threading.Thread(target=self.server.shutdown, daemon=True).start()
+
+    def _send_html(self, body: str, status: int = 200):
+        encoded = body.encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+
+# ── Public login() function ───────────────────────────────────────────────────
+
+def login() -> None:
+    """
+    Open the browser for Firebase authentication and exchange the resulting
+    ID token for a UTIM API key from the production server.
+    """
+    _AuthCallbackHandler.received = {}
+    port = 31415
+
+    socketserver.TCPServer.allow_reuse_address = True
+    httpd = socketserver.TCPServer(("", port), _AuthCallbackHandler)
+
+    callback_url = f"http://localhost:{port}/auth/callback"
+
+    # Build the auth redirect URL pointing to our website auth page.
+    auth_url = (
+        f"{WEB_URL}/auth"
+        f"?callback={urllib.parse.quote(callback_url)}"
+    )
+
+    console.print(f"\n  [bold {PURPLE}]Opening browser for sign-in…[/bold {PURPLE}]")
+    console.print(f"  [dim]If the browser doesn't open, visit:[/dim]")
+    console.print(f"  [bold {BLUE}]{auth_url}[/bold {BLUE}]\n")
+    webbrowser.open(auth_url)
+
+    # Block until the callback arrives
+    httpd.serve_forever()
+    httpd.server_close()
+
+    data = _AuthCallbackHandler.received
+    if not data.get("token"):
+        console.print(f"  [bold red]✗ Authentication cancelled or failed.[/bold red]\n")
+        return
+
+    # Exchange Firebase ID token → UTIM API key
+    console.print(f"  [dim]Verifying with UTIM server…[/dim]")
+    try:
+        resp = requests.post(
+            f"{SERVER_URL}/auth/firebase-login",
+            json={"id_token": data["token"]},
+            timeout=15,
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+    except Exception as exc:
+        console.print(f"  [bold red]✗ Server error: {exc}[/bold red]\n")
+        return
+
+    # Persist credentials
+    config.set("token",    data["token"])
+    config.set("email",    payload["email"])
+    config.set("uid",      data["uid"])
+    config.set("name",     payload.get("display_name", data["name"]))
+    config.set("api_key",  payload["api_key"])
+
+    greeting = "Welcome! Your account has been created." if payload.get("is_new_user") else "Welcome back!"
+    console.print(
+        f"  [bold {YELLOW}]✓ {greeting}[/bold {YELLOW}]\n"
+        f"  [dim]Signed in as[/dim] [bold {BLUE}]{payload['email']}[/bold {BLUE}]\n"
+        f"  [dim]Credits:[/dim] [bold]{payload['credits']:,.0f} UTIM[/bold]\n"
+    )
+
+
+# ── HTML templates ────────────────────────────────────────────────────────────
+
+_SUCCESS_HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>UTIM CLI — Signed In</title>
+  <style>
+    *{box-sizing:border-box;margin:0;padding:0}
+    body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
+         background:#0d1117;color:#c9d1d9;display:flex;align-items:center;
+         justify-content:center;height:100vh}
+    .card{background:#161b22;border:1px solid #30363d;border-radius:12px;
+          padding:48px 40px;max-width:420px;text-align:center;
+          box-shadow:0 16px 48px rgba(0,0,0,0.6)}
+    .icon{color:#3fb950;margin-bottom:24px}
+    .icon svg{width:72px;height:72px}
+    h1{color:#58a6ff;font-size:1.5rem;margin-bottom:12px}
+    p{color:#8b949e;line-height:1.6;font-size:0.95rem}
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="icon">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor"
+           stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+        <polyline points="20 6 9 17 4 12"/>
+      </svg>
+    </div>
+    <h1>Signed in successfully!</h1>
+    <p>You're authenticated with UTIM CLI.<br>You can close this tab and return to your terminal.</p>
+  </div>
+</body>
+</html>"""
+
+_FAILURE_HTML = """<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>UTIM CLI — Auth Failed</title>
+  <style>
+    body{font-family:system-ui,sans-serif;background:#0d1117;color:#c9d1d9;
+         display:flex;align-items:center;justify-content:center;height:100vh}
+    .card{background:#161b22;border:1px solid #f85149;border-radius:12px;
+          padding:48px 40px;max-width:420px;text-align:center}
+    h1{color:#f85149;margin-bottom:12px}
+    p{color:#8b949e;line-height:1.6}
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>Authentication Failed</h1>
+    <p>Missing token or email. Please try signing in again.</p>
+  </div>
+</body>
+</html>"""