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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi-code
-Version: 0.1.0
+Version: 0.2.1
 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.1}/pyproject.toml

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

meshapi_code-0.2.1/src/meshapi/__init__.py

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

meshapi_code-0.2.1/src/meshapi/cli.py

@@ -0,0 +1,146 @@
+"""meshapi — terminal chat REPL for Mesh API."""
+import argparse
+import sys
+from pathlib import Path
+
+import httpx
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.styles import Style
+from rich.text import Text
+
+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 BRAND, BRAND_BG, BRAND_BG_FG, BRAND_DIM, console, fmt_usd, pretty_cwd, render_stream
+
+# ANSI Shadow figlet font
+MESH_LOGO_LINES = [
+    "███╗   ███╗███████╗███████╗██╗  ██╗",
+    "████╗ ████║██╔════╝██╔════╝██║  ██║",
+    "██╔████╔██║█████╗  ███████╗███████║",
+    "██║╚██╔╝██║██╔══╝  ╚════██║██╔══██║",
+    "██║ ╚═╝ ██║███████╗███████║██║  ██║",
+    "╚═╝     ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝",
+]
+LOGO_WIDTH = 35  # chars per line
+LOGO_GUTTER = 3  # spaces between logo and info column
+
+
+def parse_args(argv=None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="meshapi", description="Terminal chat for Mesh API")
+    p.add_argument("--version", action="version", version=f"meshapi {__version__}")
+    p.add_argument("--model", help="Override model for this session (e.g. openai/gpt-4o-mini)")
+    p.add_argument("--route", choices=["cheapest", "fastest", "balanced"], help="Routing mode")
+    return p.parse_args(argv)
+
+
+def main() -> None:
+    args = parse_args()
+    cfg = load_config()
+    if args.model:
+        cfg["model"] = args.model
+    if args.route:
+        cfg["route"] = args.route
+
+    if not cfg["api_key"]:
+        console.print(
+            "[red]No API key found. Set MESHAPI_API_KEY env var or edit "
+            f"{CONFIG_FILE}[/red]"
+        )
+        sys.exit(1)
+
+    state = {
+        "cfg": cfg,
+        "messages": [{"role": "system", "content": cfg["system"]}],
+        "session_cost": 0.0,
+    }
+
+    session = PromptSession(history=FileHistory(str(HISTORY_FILE)))
+
+    info_per_line: list = [
+        None,
+        None,
+        Text.from_markup(f"[bold {BRAND}]✦  meshapi {__version__}[/bold {BRAND}]"),
+        Text.from_markup(f"cwd:   [{BRAND}]{pretty_cwd()}[/{BRAND}]"),
+        Text.from_markup(f"model: [bold {BRAND}]{cfg['model']}[/bold {BRAND}]"),
+        Text.from_markup(f"route: [{BRAND}]{cfg.get('route') or 'default'}[/{BRAND}]"),
+    ]
+
+    console.print()  # top gap so banner doesn't crowd the shell prompt
+    for i, logo_line in enumerate(MESH_LOGO_LINES):
+        line = Text()
+        line.append(logo_line, style=BRAND)
+        info = info_per_line[i] if i < len(info_per_line) else None
+        if info is not None:
+            pad = max(0, LOGO_WIDTH - len(logo_line))
+            line.append(" " * (pad + LOGO_GUTTER))
+            line.append(info)
+        console.print(line)
+    console.print()
+    console.print("type /help for commands, /exit to quit", style=BRAND_DIM)
+    console.print()  # bottom gap before the first prompt rule
+
+    while True:
+        try:
+            console.rule(
+                title=f"[{BRAND_DIM}]{Path.cwd().name}[/{BRAND_DIM}]",
+                align="right",
+                style=BRAND_DIM,
+                characters="─",
+            )
+            user_input = session.prompt(
+                "› ",
+                style=Style.from_dict({
+                    "prompt": f"bold fg:{BRAND} bg:{BRAND_BG}",
+                    "": f"fg:{BRAND_BG_FG} bg:{BRAND_BG}",
+                }),
+            )
+            console.rule(style=BRAND_DIM, characters="─")
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[dim]bye[/dim]")
+            break
+
+        if not user_input.strip():
+            continue
+        if user_input.startswith("/"):
+            if not handle_command(user_input, state):
+                break
+            continue
+
+        state["messages"].append({"role": "user", "content": user_input})
+        console.print()
+        try:
+            reply, meta = render_stream(stream_chat(state["messages"], state["cfg"]))
+            state["messages"].append({"role": "assistant", "content": reply})
+
+            cost = meta.get("cost")
+            if cost is not None:
+                try:
+                    state["session_cost"] += float(cost)
+                except (TypeError, ValueError):
+                    pass
+            usage = meta.get("usage") or {}
+            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]"
+            )
+        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()
+
+
+if __name__ == "__main__":
+    main()

{meshapi_code-0.1.0 → meshapi_code-0.2.1}/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.1/src/meshapi/render.py

@@ -0,0 +1,121 @@
+"""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
+if _detect_theme() == "dark":
+    BRAND = "#8b78f7"       # bumped lighter on dark — official #6f5af5 reads dim on dark wine/black
+    BRAND_DIM = "#aea3f0"   # lighter dim — clearly visible on dark backgrounds
+    BRAND_BG = "#372d73"    # mid-dark purple — clearly visible without being loud
+    BRAND_BG_FG = "#f5f0ff" # near-white with slight purple tint for input text
+else:
+    BRAND = "#6f5af5"       # official brand color — strong contrast on white
+    BRAND_DIM = "#5a4ec4"   # darker dim — visible on light bg
+    BRAND_BG = "#ebe4fc"    # pale lavender highlight against white
+    BRAND_BG_FG = "#2c2540" # near-black with purple tint for input text on light theme
+
+
+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/cli.py

@@ -1,102 +0,0 @@
-"""meshapi — terminal chat REPL for Mesh API."""
-import argparse
-import sys
-
-import httpx
-from prompt_toolkit import PromptSession
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.styles import Style
-from rich.panel import Panel
-
-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
-
-
-def parse_args(argv=None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(prog="meshapi", description="Terminal chat for Mesh API")
-    p.add_argument("--version", action="version", version=f"meshapi {__version__}")
-    p.add_argument("--model", help="Override model for this session (e.g. openai/gpt-4o-mini)")
-    p.add_argument("--route", choices=["cheapest", "fastest", "balanced"], help="Routing mode")
-    return p.parse_args(argv)
-
-
-def main() -> None:
-    args = parse_args()
-    cfg = load_config()
-    if args.model:
-        cfg["model"] = args.model
-    if args.route:
-        cfg["route"] = args.route
-
-    if not cfg["api_key"]:
-        console.print(
-            "[red]No API key found. Set MESHAPI_API_KEY env var or edit "
-            f"{CONFIG_FILE}[/red]"
-        )
-        sys.exit(1)
-
-    state = {
-        "cfg": cfg,
-        "messages": [{"role": "system", "content": cfg["system"]}],
-        "session_cost": 0.0,
-    }
-
-    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"
-        "type /help for commands, /exit to quit",
-        border_style="cyan",
-    ))
-
-    while True:
-        try:
-            user_input = session.prompt(
-                "you > ",
-                style=Style.from_dict({"prompt": "ansicyan bold"}),
-            )
-        except (KeyboardInterrupt, EOFError):
-            console.print("\n[dim]bye[/dim]")
-            break
-
-        if not user_input.strip():
-            continue
-        if user_input.startswith("/"):
-            if not handle_command(user_input, state):
-                break
-            continue
-
-        state["messages"].append({"role": "user", "content": user_input})
-        console.print()
-        try:
-            reply, meta = render_stream(stream_chat(state["messages"], state["cfg"]))
-            state["messages"].append({"role": "assistant", "content": reply})
-
-            cost = meta.get("cost")
-            if cost is not None:
-                try:
-                    state["session_cost"] += float(cost)
-                except (TypeError, ValueError):
-                    pass
-            usage = meta.get("usage") or {}
-            tokens = (
-                f"{usage.get('prompt_tokens', '?')} → {usage.get('completion_tokens', '?')} tok"
-                if usage else ""
-            )
-            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.print(f"[red]API error {e.response.status_code}: {e.response.text}[/red]")
-            state["messages"].pop()
-        except Exception as e:
-            console.print(f"[red]Error: {e}[/red]")
-            state["messages"].pop()
-        console.print()
-
-
-if __name__ == "__main__":
-    main()

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