meshapi-code 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

meshapi/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.1"
+__version__ = "0.3.0"

meshapi/cli.py

@@ -1,11 +1,14 @@
 """meshapi — terminal chat REPL for Mesh API."""
 import argparse
+import json
 import sys
 from pathlib import Path
 
 import httpx
 from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import FileHistory
+from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.styles import Style
 from rich.text import Text
 
@@ -13,7 +16,11 @@ 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
+from .permissions import HINTS, LABELS, Mode, from_str, next_mode
+from .render import (
+    BRAND, BRAND_BG, BRAND_BG_FG, BRAND_DIM, console, fmt_usd, pretty_cwd, render_stream,
+)
+from .tools import TOOLS, build_system_prompt, execute as exec_tool, summarize_call
 
 # ANSI Shadow figlet font
 MESH_LOGO_LINES = [
@@ -27,15 +34,96 @@ 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")
+    p.add_argument(
+        "--mode",
+        choices=[m.value for m in Mode],
+        default="ask",
+        help="Tool permission mode (default: ask). Cycle in-session with shift+tab.",
+    )
     return p.parse_args(argv)
 
 
+def render_banner(cfg: dict) -> None:
+    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()
+    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()
+
+
+def confirm_tool_call(name: str, args: dict) -> bool:
+    """ASK-mode prompt for a single tool call. Returns True if approved."""
+    summary = summarize_call(name, args)
+    console.print(f"[bold {BRAND}]⚙ approve tool call?[/bold {BRAND}]  [dim]{summary}[/dim]")
+    if name == "write_file":
+        preview = (args.get("content") or "")[:300]
+        console.print(f"[dim]──[/dim]\n{preview}{'…' if len(args.get('content') or '') > 300 else ''}\n[dim]──[/dim]")
+    elif name == "run_bash":
+        console.print(f"[dim]$ {args.get('command')}[/dim]")
+    try:
+        ans = console.input("[bold]y[/bold] (yes) / [bold]n[/bold] (no)  › ").strip().lower()
+    except (KeyboardInterrupt, EOFError):
+        return False
+    return ans in ("y", "yes")
+
+
+def handle_tool_calls(tool_calls: list, mode: Mode, state: dict) -> None:
+    """Append assistant tool_calls message + tool result messages to state."""
+    state["messages"].append({
+        "role": "assistant",
+        "content": None,
+        "tool_calls": [
+            {
+                "id": tc["id"],
+                "type": "function",
+                "function": {"name": tc["name"], "arguments": tc["arguments"]},
+            }
+            for tc in tool_calls
+        ],
+    })
+    for tc in tool_calls:
+        try:
+            args = json.loads(tc["arguments"]) if tc["arguments"] else {}
+        except json.JSONDecodeError:
+            args = {}
+        approved = mode == Mode.BYPASS or confirm_tool_call(tc["name"], args)
+        if approved:
+            console.print(f"[{BRAND_DIM}]⚙ {summarize_call(tc['name'], args)}[/{BRAND_DIM}]")
+            result = exec_tool(tc["name"], args)
+            preview = result[:200].replace("\n", " ")
+            tail = "…" if len(result) > 200 else ""
+            console.print(f"[dim]  → {preview}{tail}[/dim]")
+        else:
+            result = "User denied this tool call."
+            console.print(f"[dim]  → denied by user[/dim]")
+        state["messages"].append({
+            "role": "tool",
+            "tool_call_id": tc["id"],
+            "content": result,
+        })
+
+
 def main() -> None:
     args = parse_args()
     cfg = load_config()
@@ -53,34 +141,35 @@ def main() -> None:
 
     state = {
         "cfg": cfg,
-        "messages": [{"role": "system", "content": cfg["system"]}],
+        "messages": [{"role": "system", "content": build_system_prompt(cfg)}],
         "session_cost": 0.0,
+        "mode": from_str(args.mode),
     }
 
-    session = PromptSession(history=FileHistory(str(HISTORY_FILE)))
+    kb = KeyBindings()
 
-    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}]"),
-    ]
+    @kb.add("s-tab")  # Shift+Tab
+    def _(event):
+        state["mode"] = next_mode(state["mode"])
+        event.app.invalidate()
 
-    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
+    def bottom_toolbar():
+        m = state["mode"]
+        color = "ansired" if m == Mode.BYPASS else "ansiyellow" if m == Mode.NONE else "ansigreen"
+        return FormattedText([
+            ("", "  mode: "),
+            (f"bold {color}", LABELS[m]),
+            ("", f"   {HINTS[m]}   "),
+            ("ansibrightblack", "shift+tab to cycle"),
+        ])
+
+    session = PromptSession(
+        history=FileHistory(str(HISTORY_FILE)),
+        key_bindings=kb,
+        bottom_toolbar=bottom_toolbar,
+    )
+
+    render_banner(cfg)
 
     while True:
         try:
@@ -95,6 +184,7 @@ def main() -> None:
                 style=Style.from_dict({
                     "prompt": f"bold fg:{BRAND} bg:{BRAND_BG}",
                     "": f"fg:{BRAND_BG_FG} bg:{BRAND_BG}",
+                    "bottom-toolbar": f"fg:{BRAND_BG_FG} bg:{BRAND_BG}",
                 }),
             )
             console.rule(style=BRAND_DIM, characters="─")
@@ -111,26 +201,44 @@ def main() -> None:
 
         state["messages"].append({"role": "user", "content": user_input})
         console.print()
+
+        # Tool-calling loop: keep streaming until model returns text without tool_calls.
+        agg_cost = 0.0
+        last_model = state["cfg"]["model"]
+        last_usage: dict = {}
+        last_elapsed = 0.0
         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 "—"
+            for _hop in range(8):  # safety cap
+                tools_arg = TOOLS if state["mode"] != Mode.NONE else None
+                reply, meta = render_stream(
+                    stream_chat(state["messages"], state["cfg"], tools=tools_arg)
+                )
+                cost = meta.get("cost")
+                if cost is not None:
+                    try:
+                        agg_cost += float(cost)
+                    except (TypeError, ValueError):
+                        pass
+                last_model = meta.get("model") or last_model
+                last_usage = meta.get("usage") or last_usage
+                last_elapsed += meta.get("elapsed", 0.0)
+
+                tool_calls = meta.get("tool_calls") or []
+                if not tool_calls:
+                    state["messages"].append({"role": "assistant", "content": reply})
+                    break
+
+                # Model called tools — execute and loop.
+                handle_tool_calls(tool_calls, state["mode"], state)
+
+            state["session_cost"] += agg_cost
+            prompt_t = last_usage.get("prompt_tokens", "?")
+            completion_t = last_usage.get("completion_tokens", "?")
+            cost_str = fmt_usd(agg_cost) if agg_cost 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]"
+                f"[dim]{last_model}  •  {prompt_t}→{completion_t} tok  •  {cost_str}  •  "
+                f"session {fmt_usd(state['session_cost'])}  •  {last_elapsed:.1f}s[/dim]"
             )
         except httpx.HTTPStatusError as e:
             console.rule(style="dim red", characters="─")

meshapi/client.py

@@ -1,14 +1,21 @@
 """Streaming OpenAI-compatible HTTP client for Mesh API."""
 import json
-from typing import Iterable
+from typing import Iterable, Optional
 
 import httpx
 
 
-def stream_chat(messages: list, cfg: dict) -> Iterable:
-    """Yield content deltas, then a final {'usage':..., 'cost':...} dict.
+def stream_chat(
+    messages: list,
+    cfg: dict,
+    tools: Optional[list] = None,
+) -> Iterable:
+    """Yield content deltas, then a final dict with usage/cost/model/tool_calls.
 
-    Mesh API is OpenAI-compatible but adds `cost` to the final SSE chunk.
+    Mesh API is OpenAI-compatible:
+      - `cost` arrives in the final SSE chunk alongside `usage`.
+      - `tool_calls` arrive as deltas indexed by position; we accumulate them
+        and surface as the meta dict's `tool_calls` field.
     """
     url = f"{cfg['base_url']}/chat/completions"
     headers = {
@@ -22,9 +29,14 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
     }
     if cfg.get("route"):
         payload["route"] = cfg["route"]
+    if tools:
+        payload["tools"] = tools
+        payload["tool_choice"] = "auto"
 
     last_meta: dict = {}
     last_model: str = ""
+    tool_calls_accum: dict = {}  # index -> {id, name, arguments}
+
     with httpx.stream("POST", url, json=payload, headers=headers, timeout=120) as r:
         r.raise_for_status()
         for line in r.iter_lines():
@@ -43,9 +55,24 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
 
             choices = obj.get("choices") or []
             if choices:
-                delta = choices[0].get("delta", {}).get("content")
-                if delta:
-                    yield delta
+                delta = choices[0].get("delta", {})
+
+                content = delta.get("content")
+                if content:
+                    yield content
+
+                for tc in delta.get("tool_calls") or []:
+                    idx = tc.get("index", 0)
+                    bucket = tool_calls_accum.setdefault(
+                        idx, {"id": "", "name": "", "arguments": ""}
+                    )
+                    if tc.get("id"):
+                        bucket["id"] = tc["id"]
+                    fn = tc.get("function") or {}
+                    if fn.get("name"):
+                        bucket["name"] = fn["name"]
+                    if fn.get("arguments"):
+                        bucket["arguments"] += fn["arguments"]
 
             usage = obj.get("usage")
             cost = obj.get("cost")
@@ -54,5 +81,7 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
 
     if last_model:
         last_meta["model"] = last_model
+    if tool_calls_accum:
+        last_meta["tool_calls"] = [tool_calls_accum[i] for i in sorted(tool_calls_accum)]
     if last_meta:
         yield last_meta

meshapi/commands.py

@@ -4,7 +4,9 @@ from pathlib import Path
 from rich.panel import Panel
 
 from .config import save_config
+from .permissions import LABELS, Mode, from_str
 from .render import console, fmt_usd
+from .tools import build_system_prompt
 
 ROUTES = {"cheapest", "fastest", "balanced"}
 
@@ -19,7 +21,7 @@ def handle_command(cmd: str, state: dict) -> bool:
         return False
 
     if name == "/clear":
-        state["messages"] = [{"role": "system", "content": state["cfg"]["system"]}]
+        state["messages"] = [{"role": "system", "content": build_system_prompt(state["cfg"])}]
         state["session_cost"] = 0.0
         console.print("[dim]Conversation cleared.[/dim]")
 
@@ -56,7 +58,7 @@ def handle_command(cmd: str, state: dict) -> bool:
     elif name == "/system":
         if arg:
             state["cfg"]["system"] = arg
-            state["messages"] = [{"role": "system", "content": arg}]
+            state["messages"] = [{"role": "system", "content": build_system_prompt(state["cfg"])}]
             console.print("[dim]System prompt updated and conversation reset.[/dim]")
         else:
             console.print(f"[dim]{state['cfg']['system']}[/dim]")
@@ -64,12 +66,24 @@ def handle_command(cmd: str, state: dict) -> bool:
     elif name == "/cost":
         console.print(f"[dim]Session spend: {fmt_usd(state.get('session_cost', 0))}[/dim]")
 
+    elif name == "/mode":
+        if not arg:
+            cur = state.get("mode", Mode.ASK)
+            console.print(f"[dim]Current mode: {LABELS[cur]} ({cur.value})[/dim]")
+        else:
+            try:
+                state["mode"] = from_str(arg)
+                console.print(f"[dim]Mode set to {LABELS[state['mode']]}[/dim]")
+            except ValueError as e:
+                console.print(f"[red]{e}[/red]")
+
     elif name == "/help":
         console.print(Panel.fit(
             "/exit             end session\n"
             "/clear            reset conversation\n"
             "/model <name>     switch model (e.g. anthropic/claude-sonnet-4.5)\n"
             "/route <mode>     cheapest|fastest|balanced|default\n"
+            "/mode <perm>      ask|bypass|none  (or shift+tab to cycle)\n"
             "/file <path>      add file to context\n"
             "/system <txt>     set system prompt\n"
             "/cost             show session spend\n"

meshapi/permissions.py

@@ -0,0 +1,35 @@
+"""Permission modes for tool calls — cycle with Shift+Tab."""
+from enum import Enum
+
+
+class Mode(Enum):
+    ASK = "ask"        # prompt for each tool call (default — safest)
+    BYPASS = "bypass"  # auto-execute without asking (fast — like `--yolo`)
+    NONE = "none"      # don't expose tools to the model at all (read-only chat)
+
+
+ORDER = [Mode.ASK, Mode.BYPASS, Mode.NONE]
+
+LABELS = {
+    Mode.ASK: "approve each",
+    Mode.BYPASS: "bypass perms",
+    Mode.NONE: "no access",
+}
+
+HINTS = {
+    Mode.ASK: "model can request file/shell ops; you confirm each one",
+    Mode.BYPASS: "model executes file/shell ops automatically — be careful",
+    Mode.NONE: "chat only — model has no filesystem or shell access",
+}
+
+
+def next_mode(m: Mode) -> Mode:
+    return ORDER[(ORDER.index(m) + 1) % len(ORDER)]
+
+
+def from_str(s: str) -> Mode:
+    s = s.strip().lower()
+    for m in Mode:
+        if m.value == s:
+            return m
+    raise ValueError(f"unknown mode: {s} (try {', '.join(m.value for m in Mode)})")

meshapi/tools.py

@@ -0,0 +1,129 @@
+"""Tool definitions sent to the model + local executors."""
+import subprocess
+from pathlib import Path
+
+
+def build_system_prompt(cfg: dict) -> str:
+    """Append working-dir + tool guidance to the user's base system prompt.
+
+    Naming tools in prose (read_file/write_file/run_bash) makes Anthropic
+    models drop into XML tool-use mode and emit `<function_calls>` as
+    text — keep this section deliberately tool-name-free.
+    """
+    base = cfg.get("system") or ""
+    cwd = str(Path.cwd())
+    return (
+        f"{base}\n\n"
+        f"Working directory: {cwd}\n"
+        "Resolve any relative path the user gives against this working "
+        "directory. When you create or edit files without an explicit "
+        "absolute path, place them inside this working directory. Use "
+        "the available tools to inspect and modify the filesystem and "
+        "run shell commands — do not ask the user to run commands."
+    )
+
+# OpenAI-compatible tool spec — Mesh API forwards these to the underlying provider.
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read a file from the user's filesystem and return its contents.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the file (absolute, or relative to the cwd)",
+                    }
+                },
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Create or overwrite a file with the given content. Parent directories are created if missing.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path to write"},
+                    "content": {"type": "string", "description": "Full file contents"},
+                },
+                "required": ["path", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_bash",
+            "description": "Run a shell command (zsh/bash) and return combined stdout+stderr plus exit code. Times out at 60s.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "The shell command to run"}
+                },
+                "required": ["command"],
+            },
+        },
+    },
+]
+
+OUTPUT_LIMIT = 8000
+
+
+def execute(name: str, arguments: dict) -> str:
+    """Run a tool locally and return a string result for the model."""
+    if name == "read_file":
+        try:
+            return Path(arguments["path"]).expanduser().read_text()
+        except Exception as e:
+            return f"Error: {e}"
+
+    if name == "write_file":
+        try:
+            p = Path(arguments["path"]).expanduser()
+            p.parent.mkdir(parents=True, exist_ok=True)
+            content = arguments["content"]
+            p.write_text(content)
+            return f"OK — wrote {len(content)} chars to {p}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    if name == "run_bash":
+        try:
+            r = subprocess.run(
+                arguments["command"],
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=60,
+                cwd=str(Path.cwd()),
+            )
+            out = (r.stdout or "") + (r.stderr or "")
+            tail = "...[truncated]" if len(out) > OUTPUT_LIMIT else ""
+            return f"{out[:OUTPUT_LIMIT]}{tail}\n[exit {r.returncode}]"
+        except subprocess.TimeoutExpired:
+            return "Error: command timed out after 60s"
+        except Exception as e:
+            return f"Error: {e}"
+
+    return f"Error: unknown tool `{name}`"
+
+
+def summarize_call(name: str, arguments: dict) -> str:
+    """One-line summary used in the approval prompt and progress log."""
+    if name == "read_file":
+        return f"read_file: {arguments.get('path')}"
+    if name == "write_file":
+        n = len(arguments.get("content", ""))
+        return f"write_file: {arguments.get('path')} ({n} chars)"
+    if name == "run_bash":
+        cmd = arguments.get("command", "")
+        if len(cmd) > 200:
+            cmd = cmd[:200] + "…"
+        return f"run_bash: {cmd}"
+    return f"{name}({arguments})"

{meshapi_code-0.2.1.dist-info → meshapi_code-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi-code
-Version: 0.2.1
+Version: 0.3.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.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+meshapi/__init__.py,sha256=VrXpHDu3erkzwl_WXrqINBm9xWkcyUy53IQOj042dOs,22
+meshapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+meshapi/cli.py,sha256=d1-WSXTUiwKUbFhn6sOzUe_Gb9I8CxbsMdFXVX_k_YU,9777
+meshapi/client.py,sha256=-kkPKMsl98wX_N0X6Rr8GNygJH4HSlrWloiWlhQuwgU,2824
+meshapi/commands.py,sha256=fc_qnTa_oZgn5CRQ7GrpUm1Zclmat4McLdEV5YX5Wvg,3662
+meshapi/config.py,sha256=DcqOjZtAufuSDg2vDs0lsBynRjThL_8znLOl_Y2_PN4,1159
+meshapi/permissions.py,sha256=NOZy7DyP05HyuIoYYO3-YT_U0wnU4wg_syfxDqh3Oz8,1016
+meshapi/render.py,sha256=z7ggnk8BqwcGK3tJm5PunEnROiVQmDWAD4hvJeg9gF4,4251
+meshapi/tools.py,sha256=BIy_kJrIuY0RXDfTSOo8MrcjuIKR7LR8PYl36JONY-g,4578
+meshapi_code-0.3.0.dist-info/METADATA,sha256=o97mwuZc8kd0v5NkYfZ-pZpafUwmFoxwHX1HmmsX8Wg,3765
+meshapi_code-0.3.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+meshapi_code-0.3.0.dist-info/entry_points.txt,sha256=ZCXZ_SgrhWIQEHSjAXz0pUlyGbIQKZ68vp_Cg1Y0rME,45
+meshapi_code-0.3.0.dist-info/licenses/LICENSE,sha256=oALrQSPnF5cbhoBcSv6uDDsPUGl7q5Y2AL-dJ--wzt8,1065
+meshapi_code-0.3.0.dist-info/RECORD,,

meshapi_code-0.2.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-meshapi/__init__.py,sha256=HfjVOrpTnmZ-xVFCYSVmX50EXaBQeJteUHG-PD6iQs8,22
-meshapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
-meshapi/cli.py,sha256=fsdAVM9dPjlJZ_ECMWSoiWGN04HhfF0ZBk76CaOljMQ,5758
-meshapi/client.py,sha256=ZJ9ecsMjE8T0UlksacNwoIEKznsOa4W2bbnSMjIGI6E,1708
-meshapi/commands.py,sha256=0ZiIh9n94f6ix-hH3u4v3gW7N8sLSWsPv9sdDPEUbg0,3040
-meshapi/config.py,sha256=DcqOjZtAufuSDg2vDs0lsBynRjThL_8znLOl_Y2_PN4,1159
-meshapi/render.py,sha256=z7ggnk8BqwcGK3tJm5PunEnROiVQmDWAD4hvJeg9gF4,4251
-meshapi_code-0.2.1.dist-info/METADATA,sha256=jIqW6c1RvKtiABmU_7Aj2qSvFldn_4FEAqn-FbT82VM,3765
-meshapi_code-0.2.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-meshapi_code-0.2.1.dist-info/entry_points.txt,sha256=ZCXZ_SgrhWIQEHSjAXz0pUlyGbIQKZ68vp_Cg1Y0rME,45
-meshapi_code-0.2.1.dist-info/licenses/LICENSE,sha256=oALrQSPnF5cbhoBcSv6uDDsPUGl7q5Y2AL-dJ--wzt8,1065
-meshapi_code-0.2.1.dist-info/RECORD,,