meshapi-code 0.1.0__tar.gz → 0.2.0__tar.gz

{meshapi_code-0.1.0 → meshapi_code-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi-code
-Version: 0.1.0
+Version: 0.2.0
 Summary: Terminal chat for Mesh API — OpenAI-compatible LLM gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://docs.meshapi.ai

{meshapi_code-0.1.0 → meshapi_code-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "meshapi-code"
-version = "0.1.0"
+version = "0.2.0"
 description = "Terminal chat for Mesh API — OpenAI-compatible LLM gateway"
 readme = "README.md"
 license = { text = "MIT" }

meshapi_code-0.2.0/src/meshapi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{meshapi_code-0.1.0 → meshapi_code-0.2.0}/src/meshapi/cli.py

@@ -1,6 +1,7 @@
 """meshapi — terminal chat REPL for Mesh API."""
 import argparse
 import sys
+from pathlib import Path
 
 import httpx
 from prompt_toolkit import PromptSession
@@ -12,7 +13,7 @@ from . import __version__
 from .client import stream_chat
 from .commands import handle_command
 from .config import CONFIG_FILE, HISTORY_FILE, load_config
-from .render import console, fmt_usd, render_stream
+from .render import BRAND, BRAND_BG, BRAND_DIM, console, fmt_usd, pretty_cwd, render_stream
 
 
 def parse_args(argv=None) -> argparse.Namespace:
@@ -47,18 +48,29 @@ def main() -> None:
     session = PromptSession(history=FileHistory(str(HISTORY_FILE)))
     console.print(Panel.fit(
         f"meshapi {__version__}\n"
-        f"model: [bold cyan]{cfg['model']}[/bold cyan]\n"
-        f"route: [cyan]{cfg.get('route') or 'default'}[/cyan]\n"
+        f"cwd:   [{BRAND}]{pretty_cwd()}[/{BRAND}]\n"
+        f"model: [bold {BRAND}]{cfg['model']}[/bold {BRAND}]\n"
+        f"route: [{BRAND}]{cfg.get('route') or 'default'}[/{BRAND}]\n"
         "type /help for commands, /exit to quit",
-        border_style="cyan",
+        border_style=BRAND,
     ))
 
     while True:
         try:
+            console.rule(
+                title=f"[{BRAND_DIM}]{Path.cwd().name}[/{BRAND_DIM}]",
+                align="right",
+                style=BRAND_DIM,
+                characters="─",
+            )
             user_input = session.prompt(
-                "you > ",
-                style=Style.from_dict({"prompt": "ansicyan bold"}),
+                "› ",
+                style=Style.from_dict({
+                    "prompt": f"bold fg:{BRAND} bg:{BRAND_BG}",
+                    "": f"bg:{BRAND_BG}",
+                }),
             )
+            console.rule(style=BRAND_DIM, characters="─")
         except (KeyboardInterrupt, EOFError):
             console.print("\n[dim]bye[/dim]")
             break
@@ -83,19 +95,24 @@ def main() -> None:
                 except (TypeError, ValueError):
                     pass
             usage = meta.get("usage") or {}
-            tokens = (
-                f"{usage.get('prompt_tokens', '?')} → {usage.get('completion_tokens', '?')} tok"
-                if usage else ""
+            model = meta.get("model") or state["cfg"]["model"]
+            elapsed = meta.get("elapsed", 0.0)
+            prompt_t = usage.get("prompt_tokens", "?")
+            completion_t = usage.get("completion_tokens", "?")
+            cost_str = fmt_usd(cost) if cost is not None else "—"
+            console.rule(style=BRAND_DIM, characters="─")
+            console.print(
+                f"[dim]{model}  •  {prompt_t}→{completion_t} tok  •  {cost_str}  •  "
+                f"session {fmt_usd(state['session_cost'])}  •  {elapsed:.1f}s[/dim]"
             )
-            cost_line = f"[dim]{tokens}  •  {fmt_usd(cost)}  •  session {fmt_usd(state['session_cost'])}[/dim]"
-            console.print(cost_line)
         except httpx.HTTPStatusError as e:
+            console.rule(style="dim red", characters="─")
             console.print(f"[red]API error {e.response.status_code}: {e.response.text}[/red]")
             state["messages"].pop()
         except Exception as e:
+            console.rule(style="dim red", characters="─")
             console.print(f"[red]Error: {e}[/red]")
             state["messages"].pop()
-        console.print()
 
 
 if __name__ == "__main__":

{meshapi_code-0.1.0 → meshapi_code-0.2.0}/src/meshapi/client.py

@@ -24,6 +24,7 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
         payload["route"] = cfg["route"]
 
     last_meta: dict = {}
+    last_model: str = ""
     with httpx.stream("POST", url, json=payload, headers=headers, timeout=120) as r:
         r.raise_for_status()
         for line in r.iter_lines():
@@ -37,6 +38,9 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
             except json.JSONDecodeError:
                 continue
 
+            if obj.get("model"):
+                last_model = obj["model"]
+
             choices = obj.get("choices") or []
             if choices:
                 delta = choices[0].get("delta", {}).get("content")
@@ -48,5 +52,7 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
             if usage or cost:
                 last_meta = {"usage": usage, "cost": cost}
 
+    if last_model:
+        last_meta["model"] = last_model
     if last_meta:
         yield last_meta

meshapi_code-0.2.0/src/meshapi/render.py

@@ -0,0 +1,118 @@
+"""Rich-based markdown live rendering and shared formatters."""
+import os
+import time
+from pathlib import Path
+from typing import Iterable, Optional
+
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.spinner import Spinner
+from rich.text import Text
+
+console = Console()
+
+
+def _detect_theme() -> str:
+    """Returns 'dark' or 'light'. Override with MESHAPI_THEME=light|dark."""
+    forced = os.environ.get("MESHAPI_THEME", "").strip().lower()
+    if forced in ("light", "dark"):
+        return forced
+    # COLORFGBG is set by Konsole, urxvt, some VS Code configs. Format: "fg;bg".
+    parts = os.environ.get("COLORFGBG", "").strip().split(";")
+    if len(parts) >= 2:
+        try:
+            return "dark" if int(parts[-1]) < 8 else "light"
+        except ValueError:
+            pass
+    return "dark"  # most devs use dark; safe default
+
+
+# Brand palette — Mesh API purple, theme-adaptive
+BRAND = "#6f5af5"  # foreground brand, same on both themes
+if _detect_theme() == "dark":
+    BRAND_DIM = "#9d92e8"   # lighter dim — visible on dark bg
+    BRAND_BG = "#2d2454"    # darker, brand-tinted highlight against ~#000-#1e1e1e
+else:
+    BRAND_DIM = "#5a4ec4"   # darker dim — visible on light bg
+    BRAND_BG = "#ebe4fc"    # pale lavender highlight against white
+
+
+def fmt_usd(value) -> str:
+    """USD formatter matching dashboard `fmtUsd` (routersvc-client/src/lib/utils.ts).
+
+    Always 6 decimals; K/M abbreviations for large values. Never use raw f-string
+    rounding for money — `999.999833` would render `$1000.00`.
+    """
+    try:
+        n = float(value)
+    except (TypeError, ValueError):
+        return "$0.000000"
+    if abs(n) >= 1_000_000:
+        return f"${n / 1_000_000:.2f}M"
+    if abs(n) >= 1_000:
+        return f"${n / 1_000:.2f}K"
+    return f"${n:.6f}"
+
+
+def pretty_cwd() -> str:
+    """Show cwd as `~/relative` if under $HOME, else absolute."""
+    cwd = Path.cwd()
+    home = Path.home()
+    try:
+        return f"~/{cwd.relative_to(home)}"
+    except ValueError:
+        return str(cwd)
+
+
+class _StreamView:
+    """Renderable: meshing-around spinner + elapsed timer above streamed markdown."""
+
+    def __init__(self) -> None:
+        self.start = time.monotonic()
+        self.buf = ""
+        self.first_token_at: Optional[float] = None
+        self.done = False
+        self._spinner = Spinner("dots", style=BRAND)
+
+    def elapsed(self) -> float:
+        return time.monotonic() - self.start
+
+    def __rich_console__(self, console, options):
+        if self.done:
+            if self.buf:
+                yield Markdown(self.buf)
+            return
+        label = "meshing around" if not self.buf else "still meshing"
+        self._spinner.text = Text(f"{label}... {self.elapsed():.1f}s", style=BRAND_DIM)
+        if self.buf:
+            yield Markdown(self.buf)
+            yield self._spinner
+        else:
+            yield self._spinner
+
+
+def render_stream(events: Iterable) -> tuple[str, dict]:
+    """Live-render streamed content with a meshing-around spinner + timer.
+
+    Returns (full_text, metadata). Generator yields strings (content deltas)
+    and an optional final dict (usage + cost + model from the SSE tail).
+    `meta['elapsed']` and `meta['ttft']` (time-to-first-token) are added on
+    the way out.
+    """
+    view = _StreamView()
+    meta: dict = {}
+    with Live(view, console=console, refresh_per_second=12, auto_refresh=True) as live:
+        for event in events:
+            if isinstance(event, str):
+                if view.first_token_at is None:
+                    view.first_token_at = view.elapsed()
+                view.buf += event
+            elif isinstance(event, dict):
+                meta.update(event)
+        view.done = True
+        live.refresh()
+    meta["elapsed"] = view.elapsed()
+    if view.first_token_at is not None:
+        meta["ttft"] = view.first_token_at
+    return view.buf, meta

meshapi_code-0.1.0/src/meshapi/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

meshapi_code-0.1.0/src/meshapi/render.py

@@ -1,43 +0,0 @@
-"""Rich-based markdown live rendering and shared formatters."""
-from typing import Iterable
-
-from rich.console import Console
-from rich.live import Live
-from rich.markdown import Markdown
-
-console = Console()
-
-
-def fmt_usd(value) -> str:
-    """USD formatter matching dashboard `fmtUsd` (routersvc-client/src/lib/utils.ts).
-
-    Always 6 decimals; K/M abbreviations for large values. Never use raw f-string
-    rounding for money — `999.999833` would render `$1000.00`.
-    """
-    try:
-        n = float(value)
-    except (TypeError, ValueError):
-        return "$0.000000"
-    if abs(n) >= 1_000_000:
-        return f"${n / 1_000_000:.2f}M"
-    if abs(n) >= 1_000:
-        return f"${n / 1_000:.2f}K"
-    return f"${n:.6f}"
-
-
-def render_stream(events: Iterable) -> tuple[str, dict]:
-    """Live-render markdown content; return (full_text, metadata).
-
-    Generator yields strings (content deltas) and an optional final dict
-    (usage + cost from Mesh API's last SSE chunk).
-    """
-    buf = ""
-    meta: dict = {}
-    with Live(console=console, refresh_per_second=20) as live:
-        for event in events:
-            if isinstance(event, str):
-                buf += event
-                live.update(Markdown(buf))
-            elif isinstance(event, dict):
-                meta.update(event)
-    return buf, meta