lcode-cli 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.20.0"
+__version__ = "0.22.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/cli.py

@@ -678,7 +678,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="lcode",
         description="A local-first terminal coding agent powered by open-weight models via Ollama.",
-        epilog="Subcommands: lcode setup | models | doctor | config | bench | mcp | index "
+        epilog="Subcommands: lcode setup | models | doctor | config | bench | mcp | index | update "
         "(lcode <subcommand> --help). "
         "Docs: https://nasser1941.github.io/lcode/",
     )
@@ -774,6 +774,15 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     from lcode.mcp.commands import build_parser as mcp_parser
 
     subs["mcp"] = mcp_parser()
+    p = argparse.ArgumentParser(
+        prog="lcode update",
+        description="Update lcode, and Ollama when it runs in Docker (to the newest version on Docker Hub, pinned "
+        "to its version tag).",
+    )
+    p.add_argument("what", nargs="?", choices=["lcode", "ollama"], help="only this one (default: both)")
+    p.add_argument("--check", action="store_true", help="only show which versions are out")
+    p.add_argument("-y", "--yes", action="store_true", help="don't ask before updating")
+    subs["update"] = p
     subs["acp"] = argparse.ArgumentParser(
         prog="lcode acp",
         description="Run as the agent inside an editor, over the Agent Client Protocol on stdin and stdout "
@@ -787,6 +796,12 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     return subs
 
 
+def cmd_update(args) -> None:
+    from lcode import update
+
+    sys.exit(update.command(console, args.what or "", check=args.check, yes=args.yes))
+
+
 def cmd_acp(args) -> None:
     from lcode import acp
 
@@ -863,6 +878,7 @@ COMMANDS = {
     "index": cmd_index,
     "action": cmd_action,
     "acp": cmd_acp,
+    "update": cmd_update,
 }
 
 

lcode/mcp/catalog.toml

@@ -281,3 +281,24 @@ secret = true
 var = "VALOHAI_HOST"
 prompt = "Valohai address (Enter for app.valohai.com; for a self-hosted installation, its URL)"
 optional = true
+
+[xai]
+name = "xAI Grok Imagine"
+description = "Generate and edit images, and generate videos and speech, with xAI's Grok Imagine and voice API (paid, in the cloud)"
+homepage = "https://nasser1941.github.io/lcode/mcp/#xai"
+requires = ["uvx"]
+setup = """Uses xAI's API: your prompts, and images you edit or animate, go to xAI, and every call is billed to your xAI
+account (an image $0.02-0.05, video $0.02-0.08 a second, speech per character). Create an API key at https://console.x.ai.
+Files are saved in generated/ in the project. lcode asks before each call; to stop asking for some tools, list them
+under "allow" for this server in mcp.json. xAI has no music generation."""
+
+[xai.server]
+command = "uvx"
+args = ["--isolated", "--python", "3.12", "--from", "lcode-cli", "lcode-mcp-xai"]
+env = { XAI_API_KEY = "${XAI_API_KEY}" }
+timeout = 900  # a video takes minutes
+
+[[xai.inputs]]
+var = "XAI_API_KEY"
+prompt = "xAI API key (create one at https://console.x.ai)"
+secret = true

lcode/servers/xai.py

@@ -0,0 +1,289 @@
+"""An MCP server for xAI's Grok Imagine and voice APIs: images, image edits, videos and speech.
+
+xAI has an HTTP API but no MCP server, so lcode ships this one. It needs an API key (XAI_API_KEY,
+from https://console.x.ai) and saves what it makes in the project, in `generated/` unless a path is
+given. The prompts, and any image it edits or animates, go to xAI, which bills per image, per
+second of video and per character of speech, and applies its own usage policies.
+
+Run: lcode-mcp-xai   (lcode mcp add xai sets it up)
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import mimetypes
+import os
+import re
+import time
+from pathlib import Path
+
+import requests
+
+from lcode import __version__
+from lcode.mcp.server import Server, ToolFailure
+
+API = "https://api.x.ai/v1"
+TIMEOUT = 120
+IMAGE_MODELS = ["grok-imagine-image-2.0", "grok-imagine-image-quality", "grok-imagine-image"]
+VIDEO_MODELS = ["grok-imagine-video-1.5", "grok-imagine-video-1.5-lite", "grok-imagine-video"]
+ASPECT_RATIOS = ["auto", "1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "2:1", "1:2", "21:9"]
+VOICES = ["eve", "ara", "leo", "rex", "sal", "luna", "iris", "orion", "helix", "zagan", "carina", "altair", "zenith",
+          "perseus", "helios", "lux", "kepler", "rigel", "cosmo", "celeste", "ursa", "sirius", "lumen", "castor",
+          "naksh", "atlas"]  # fmt: skip
+AUDIO_FORMATS = {"mp3": ".mp3", "wav": ".wav"}
+VIDEO_WAIT = 600  # seconds generate_video waits before handing back the request id
+POLL = 5
+
+
+class XAI:
+    def __init__(self, key: str, base: str = API, output: Path | None = None):
+        self.base = base.rstrip("/")
+        self.output = output or Path("generated")
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
+
+    def request(self, method: str, path: str, **kwargs) -> requests.Response:
+        try:
+            r = self.session.request(method, f"{self.base}{path}", timeout=TIMEOUT, **kwargs)
+        except requests.RequestException as e:
+            raise ToolFailure(f"can't reach xAI: {e}") from e
+        if r.status_code in (401, 403):
+            raise ToolFailure(
+                f"xAI refused the request ({r.status_code}): {_error(r)}. Check XAI_API_KEY (console.x.ai)."
+            )
+        if r.status_code == 429:
+            raise ToolFailure(f"xAI's rate limit or credit limit was reached: {_error(r)}")
+        if r.status_code >= 400:
+            raise ToolFailure(f"xAI error {r.status_code}: {_error(r)}")
+        return r
+
+    def post(self, path: str, body: dict) -> dict:
+        return self.request("POST", path, json=body).json()
+
+    def download(self, url: str) -> bytes:
+        try:
+            r = requests.get(url, timeout=TIMEOUT)
+            r.raise_for_status()
+        except requests.RequestException as e:
+            raise ToolFailure(f"couldn't download the result from xAI: {e}") from e
+        return r.content
+
+    def target(self, path: str, stem: str, suffix: str) -> Path:
+        """Where to save: the given path, or a new file in the output folder."""
+        if path:
+            target = Path(path).expanduser()
+            if not target.suffix:
+                target = target.with_suffix(suffix)
+        else:
+            name = re.sub(r"[^a-z0-9]+", "-", stem.lower()).strip("-")[:40] or "xai"
+            target = self.output / f"{name}-{time.strftime('%Y%m%d-%H%M%S')}{suffix}"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        n, unique = 2, target
+        while unique.exists():
+            unique = target.with_name(f"{target.stem}-{n}{target.suffix}")
+            n += 1
+        return unique
+
+
+def _error(r: requests.Response) -> str:
+    try:
+        data = r.json()
+    except ValueError:
+        return r.text[:300]
+    error = data.get("error") if isinstance(data, dict) else None
+    if isinstance(error, dict):
+        return str(error.get("message") or error)[:300]
+    return str(error or data)[:300]
+
+
+def data_url(path: str) -> str:
+    """A local image as a data: URL, for edits and image-to-video."""
+    file = Path(path).expanduser()
+    if not file.is_file():
+        raise ToolFailure(f"{path} doesn't exist")
+    mime = mimetypes.guess_type(file.name)[0] or "image/png"
+    if mime not in ("image/png", "image/jpeg", "image/webp"):
+        raise ToolFailure(f"{path} isn't a PNG, JPEG or WebP image")
+    return f"data:{mime};base64,{base64.b64encode(file.read_bytes()).decode()}"
+
+
+def image_suffix(data: bytes) -> str:
+    if data[:3] == b"\xff\xd8\xff":
+        return ".jpg"
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return ".webp"
+    return ".png"
+
+
+def save_images(api: XAI, reply: dict, prompt: str, path: str) -> list[Path]:
+    saved = []
+    items = reply.get("data") or []
+    if not items:
+        raise ToolFailure(f"xAI returned no image: {str(reply)[:300]}")
+    for i, item in enumerate(items):
+        data = base64.b64decode(item["b64_json"]) if item.get("b64_json") else api.download(item["url"])
+        many = path and len(items) > 1
+        target = api.target(f"{Path(path).with_suffix('')}-{i + 1}" if many else path, prompt, image_suffix(data))
+        target.write_bytes(data)
+        saved.append(target)
+    return saved
+
+
+def build(api: XAI) -> Server:
+    server = Server(
+        "xai",
+        __version__,
+        "xAI's Grok Imagine and voice: generate and edit images, generate videos (from text or a start image) "
+        "and speech. Results are saved as files in the project; each call costs money on the user's xAI account. "
+        "xAI has no music generation.",
+    )
+    path_arg = {"type": "string", "description": "Where to save it (default: a new file in generated/)"}
+
+    @server.tool(
+        "generate_image",
+        "Generate images from a description with Grok Imagine and save them. Costs $0.02–0.05 per image.",
+        {
+            "prompt": {"type": "string", "description": "What the image shows, in detail"},
+            "n": {"type": "integer", "description": "How many images, 1–10 (default 1)"},
+            "aspect_ratio": {"type": "string", "enum": ASPECT_RATIOS, "description": "Default auto"},
+            "resolution": {"type": "string", "enum": ["1k", "2k"], "description": "Default 1k"},
+            "model": {"type": "string", "enum": IMAGE_MODELS, "description": f"Default {IMAGE_MODELS[0]}"},
+            "path": path_arg,
+        },
+        ["prompt"],
+    )
+    def generate_image(prompt: str, n: int = 1, aspect_ratio: str = "auto", resolution: str = "1k",
+                       model: str = IMAGE_MODELS[0], path: str = "") -> str:  # fmt: skip
+        body = {"model": model, "prompt": prompt, "n": max(1, min(10, int(n))), "response_format": "b64_json"}
+        if aspect_ratio and aspect_ratio != "auto":
+            body["aspect_ratio"] = aspect_ratio
+        if resolution and resolution != "1k":
+            body["resolution"] = resolution
+        saved = save_images(api, api.post("/images/generations", body), prompt, path)
+        return f"Saved {len(saved)} image(s) from {model}:\n" + "\n".join(f"- {p}" for p in saved)
+
+    @server.tool(
+        "edit_image",
+        "Change an existing image (a local file) as described, with Grok Imagine, and save the result.",
+        {
+            "image": {"type": "string", "description": "Path of the image to edit (PNG, JPEG or WebP)"},
+            "prompt": {"type": "string", "description": "What to change"},
+            "model": {"type": "string", "enum": IMAGE_MODELS, "description": f"Default {IMAGE_MODELS[0]}"},
+            "path": path_arg,
+        },
+        ["image", "prompt"],
+    )
+    def edit_image(image: str, prompt: str, model: str = IMAGE_MODELS[0], path: str = "") -> str:
+        body = {"model": model, "prompt": prompt, "image": {"url": data_url(image), "type": "image_url"},
+                "response_format": "b64_json"}  # fmt: skip
+        saved = save_images(api, api.post("/images/edits", body), prompt, path)
+        return f"Saved the edited image: {saved[0]}"
+
+    def finish_video(request_id: str, prompt: str, path: str, wait: float) -> str:
+        deadline = time.monotonic() + wait
+        while True:
+            state = api.request("GET", f"/videos/{request_id}").json()
+            status = state.get("status")
+            if status == "done":
+                video = state.get("video") or {}
+                target = api.target(path, prompt or request_id, ".mp4")
+                target.write_bytes(api.download(video["url"]))
+                return f"Saved the video ({video.get('duration', '?')} s, {state.get('model', '')}): {target}"
+            if status in ("failed", "expired"):
+                raise ToolFailure(f"xAI couldn't make the video ({status}): {state.get('error') or state}")
+            if time.monotonic() > deadline:
+                return (
+                    f"The video isn't ready yet (request {request_id}). Check later with "
+                    f'video_status(request_id="{request_id}"), which downloads it when it\'s done.'
+                )
+            time.sleep(POLL)
+
+    @server.tool(
+        "generate_video",
+        "Generate a video with Grok Imagine, from a description and optionally a start image, and save it as "
+        "MP4. Takes a minute or more. Costs $0.02–0.08 per second of video.",
+        {
+            "prompt": {"type": "string", "description": "What happens in the video"},
+            "image": {"type": "string", "description": "A local image to start from (optional)"},
+            "duration": {"type": "integer", "description": "Seconds, 1–15 (default 8)"},
+            "aspect_ratio": {
+                "type": "string",
+                "enum": [r for r in ASPECT_RATIOS if r not in ("auto", "2:1", "1:2", "21:9")],
+            },
+            "resolution": {"type": "string", "enum": ["480p", "720p", "1080p"], "description": "Default 720p"},
+            "model": {"type": "string", "enum": VIDEO_MODELS, "description": f"Default {VIDEO_MODELS[0]}"},
+            "path": path_arg,
+        },
+        ["prompt"],
+    )
+    def generate_video(prompt: str, image: str = "", duration: int = 8, aspect_ratio: str = "16:9",
+                       resolution: str = "720p", model: str = VIDEO_MODELS[0], path: str = "") -> str:  # fmt: skip
+        body: dict = {"model": model, "prompt": prompt, "duration": max(1, min(15, int(duration))),
+                      "aspect_ratio": aspect_ratio, "resolution": resolution}  # fmt: skip
+        if image:
+            body["image"] = {"url": data_url(image)}
+        request_id = api.post("/videos/generations", body).get("request_id")
+        if not request_id:
+            raise ToolFailure("xAI didn't start the video")
+        return finish_video(str(request_id), prompt, path, VIDEO_WAIT)
+
+    @server.tool(
+        "video_status",
+        "Check a video that generate_video started and that wasn't ready yet; saves it when it's done.",
+        {"request_id": {"type": "string"}, "path": path_arg},
+        ["request_id"],
+    )
+    def video_status(request_id: str, path: str = "") -> str:
+        return finish_video(request_id, "", path, 0)
+
+    @server.tool(
+        "text_to_speech",
+        "Turn text into speech with an xAI voice and save it as an audio file. Billed per character.",
+        {
+            "text": {"type": "string", "description": "What to say (up to 60,000 characters)"},
+            "voice": {"type": "string", "enum": VOICES, "description": "Default eve"},
+            "language": {"type": "string", "description": "BCP-47 code such as en, de, fr, ja, or auto (default)"},
+            "format": {"type": "string", "enum": list(AUDIO_FORMATS), "description": "Default mp3"},
+            "speed": {"type": "number", "description": "1.0 is normal"},
+            "path": path_arg,
+        },
+        ["text"],
+    )
+    def text_to_speech(text: str, voice: str = "eve", language: str = "auto", format: str = "mp3",
+                       speed: float = 1.0, path: str = "") -> str:  # fmt: skip
+        codec = format if format in AUDIO_FORMATS else "mp3"
+        body = {"text": text, "voice_id": voice.lower(), "language": language or "auto",
+                "output_format": {"codec": codec}, "speed": float(speed or 1.0)}  # fmt: skip
+        r = api.request("POST", "/tts", json=body)
+        duration = ""
+        if "json" in r.headers.get("Content-Type", ""):
+            data = r.json()
+            audio = base64.b64decode(data.get("audio", ""))
+            duration = f", {data['duration']:.1f} s" if isinstance(data.get("duration"), (int, float)) else ""
+        else:
+            audio = r.content
+        if not audio:
+            raise ToolFailure("xAI returned no audio")
+        target = api.target(path, text[:40], AUDIO_FORMATS[codec])
+        target.write_bytes(audio)
+        return f"Saved the speech ({voice}{duration}): {target}"
+
+    return server
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="lcode-mcp-xai", description="MCP server for xAI's image, video and speech APIs (stdio)."
+    )
+    parser.add_argument("--output", default=os.environ.get("LCODE_XAI_OUTPUT", "generated"),
+                        help="folder for the files it makes (default: generated/ in the project)")  # fmt: skip
+    args = parser.parse_args(argv)
+    key = os.environ.get("XAI_API_KEY")
+    if not key:
+        parser.error("set XAI_API_KEY to an xAI API key (https://console.x.ai)")
+    build(XAI(key, os.environ.get("XAI_API_BASE", API), Path(args.output))).serve()
+
+
+if __name__ == "__main__":
+    main()

lcode/update.py

@@ -0,0 +1,557 @@
+"""`lcode update`: update lcode, and Ollama when it runs in Docker.
+
+lcode updates itself the way it was installed: uv tool, pipx, Homebrew, pip, or `git pull` for a
+checkout (an editable install).
+
+For Ollama in Docker, the newest version is looked up on Docker Hub, never taken from a local
+`latest` tag (which can be months old), and pulled by its version tag (`ollama/ollama:0.35.1`), so
+`docker ps` shows which version runs. Release candidates are skipped, and a ROCm image stays ROCm.
+- A container from Docker Compose gets the new tag in its compose file and is recreated with
+  `docker compose up`, so Compose keeps managing it.
+- Any other container is recreated with the same name, ports, volumes, environment, GPUs, network
+  and restart policy. The old one is kept until the new one answers with the new version, and is
+  put back if it doesn't.
+Ollama installed without Docker gets the command to update it, which lcode doesn't run itself.
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+import json
+import re
+import shutil
+import subprocess
+import sys
+import time
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from urllib.parse import urlsplit
+
+import requests
+
+from lcode import __version__
+
+IMAGE = "ollama/ollama"
+HUB_TAGS = "https://hub.docker.com/v2/namespaces/ollama/repositories/ollama/tags"
+PYPI = "https://pypi.org/pypi/lcode-cli/json"
+SEMVER = re.compile(r"\d+\.\d+\.\d+")
+START_TIMEOUT = 120  # seconds for a recreated container to answer
+NATIVE = {
+    "linux": "curl -fsSL https://ollama.com/install.sh | sh",
+    "darwin": "brew upgrade ollama   (or let the Ollama app update itself)",
+}
+
+
+class UpdateError(Exception):
+    pass
+
+
+def version_key(version: str) -> tuple[int, ...]:
+    return tuple(int(p) for p in re.findall(r"\d+", version)[:3])
+
+
+def run(argv: list[str], cwd: Path | None = None, timeout: float = 120) -> subprocess.CompletedProcess:
+    """A command whose output lcode reads (and tests replace)."""
+    try:
+        return subprocess.run(argv, cwd=cwd, capture_output=True, text=True, timeout=timeout)
+    except (OSError, subprocess.SubprocessError) as e:
+        raise UpdateError(f"{argv[0]} failed: {e}") from e
+
+
+def stream(argv: list[str], cwd: Path | None = None) -> int:
+    """A command the user watches (pulls, installs); returns its exit code."""
+    try:
+        return subprocess.call(argv, cwd=cwd)
+    except OSError as e:
+        raise UpdateError(f"{argv[0]} failed: {e}") from e
+
+
+def get_json(url: str, **params) -> dict:
+    try:
+        r = requests.get(url, params=params or None, timeout=20)
+        r.raise_for_status()
+        return r.json()
+    except (requests.RequestException, ValueError) as e:
+        raise UpdateError(f"couldn't read {url.split('?')[0]}: {e}") from e
+
+
+# ----------------------------------------------------------------------------- the newest versions
+
+
+def latest_lcode() -> str:
+    return str(get_json(PYPI)["info"]["version"])
+
+
+def latest_ollama(flavor: str = "") -> str:
+    """The newest released Ollama image tag on Docker Hub: "0.35.1", or "0.35.1-rocm" for flavor "rocm"."""
+    names: list[str] = []
+    url, params = HUB_TAGS, {"page_size": 100, "ordering": "last_updated"}
+    for _ in range(3):  # the newest tags come first; three pages reach well past them
+        page = get_json(url, **params)
+        names += [str(t.get("name", "")) for t in page.get("results") or []]
+        url, params = page.get("next"), {}
+        if not url:
+            break
+    suffix = f"-{flavor}" if flavor else ""
+    versions = [
+        n.removesuffix(suffix) for n in names if n.endswith(suffix) and SEMVER.fullmatch(n.removesuffix(suffix))
+    ]
+    if not versions:
+        raise UpdateError(f"Docker Hub lists no released {IMAGE} versions{f' for {flavor}' if flavor else ''}")
+    return max(versions, key=version_key) + suffix
+
+
+def image_flavor(image: str) -> str:
+    """The image variant to stay on: "rocm" for ollama/ollama:rocm or :0.35.1-rocm, else ""."""
+    tag = image.rsplit(":", 1)[1] if ":" in image.rsplit("/", 1)[-1] else "latest"
+    return "rocm" if tag == "rocm" or tag.endswith("-rocm") else ""
+
+
+# ----------------------------------------------------------------------------- lcode itself
+
+
+@dataclass
+class Install:
+    kind: str  # checkout, uv, pipx, brew, uvx, pip
+    command: list[str] | None = None  # what updates it
+    path: Path | None = None  # the checkout, for kind checkout
+
+    def describe(self) -> str:
+        return {
+            "checkout": f"a git checkout at {self.path}",
+            "uv": "uv tool",
+            "pipx": "pipx",
+            "brew": "Homebrew",
+            "uvx": "uvx",
+            "pip": "pip",
+        }[self.kind]
+
+
+def lcode_install(prefix: Path | None = None, direct_url: str | None = None) -> Install:
+    """How this lcode was installed."""
+    prefix = (prefix or Path(sys.prefix)).resolve()
+    if direct_url is None:
+        try:
+            direct_url = importlib.metadata.distribution("lcode-cli").read_text("direct_url.json") or ""
+        except importlib.metadata.PackageNotFoundError:
+            direct_url = ""
+    try:
+        origin = json.loads(direct_url) if direct_url else {}
+    except ValueError:
+        origin = {}
+    if (origin.get("dir_info") or {}).get("editable") and str(origin.get("url", "")).startswith("file://"):
+        return Install("checkout", path=Path(urlsplit(origin["url"]).path))
+    text = str(prefix)
+    if (prefix / "uv-receipt.toml").exists():
+        return Install("uv", ["uv", "tool", "upgrade", "lcode-cli"])
+    if "/Cellar/lcode/" in text:
+        return Install("brew", ["brew", "upgrade", "nasser1941/tap/lcode"])
+    if "pipx" in prefix.parts:
+        return Install("pipx", ["pipx", "upgrade", "lcode-cli"])
+    if "/uv/" in text and ("archive-v" in text or "/cache/" in text or "/.cache/" in text):
+        return Install("uvx")
+    return Install("pip", [sys.executable, "-m", "pip", "install", "--upgrade", "lcode-cli"])
+
+
+@dataclass
+class CheckoutState:
+    branch: str
+    dirty: bool
+    behind: int
+    upstream: str
+
+
+def checkout_state(path: Path) -> CheckoutState:
+    def git(*args: str) -> str:
+        r = run(["git", "-C", str(path), *args], timeout=120)
+        if r.returncode != 0:
+            raise UpdateError(f"git {args[0]} failed in {path}: {(r.stderr or r.stdout).strip()[:200]}")
+        return r.stdout.strip()
+
+    branch = git("rev-parse", "--abbrev-ref", "HEAD")
+    dirty = bool(git("status", "--porcelain", "--untracked-files=no"))
+    upstream = run(["git", "-C", str(path), "rev-parse", "--abbrev-ref", "@{upstream}"]).stdout.strip()
+    behind = 0
+    if upstream:
+        git("fetch", "-q")
+        behind = int(git("rev-list", "--count", "HEAD..@{upstream}") or 0)
+    return CheckoutState(branch, dirty, behind, upstream)
+
+
+def update_checkout(path: Path, install_receipt: bool) -> str:
+    """git pull a checkout lcode runs from; reinstall its environment when its dependencies changed."""
+    before = run(["git", "-C", str(path), "rev-parse", "HEAD"]).stdout.strip()
+    if stream(["git", "-C", str(path), "pull", "--ff-only"]) != 0:
+        raise UpdateError(f"git pull failed in {path}")
+    changed = run(["git", "-C", str(path), "diff", "--name-only", before, "HEAD"]).stdout.split()
+    reinstall = ["uv", "tool", "install", "--force", "--editable", str(path)]
+    if "pyproject.toml" in changed and install_receipt and stream(reinstall) != 0:
+        raise UpdateError("reinstalling lcode's environment failed: run  uv tool install --force --editable .")
+    count = run(["git", "-C", str(path), "rev-list", "--count", f"{before}..HEAD"]).stdout.strip() or "0"
+    return f"{count} new commit(s)"
+
+
+# ----------------------------------------------------------------------------- Ollama in Docker
+
+
+@dataclass
+class Container:
+    id: str
+    name: str
+    image: str  # as configured, e.g. ollama/ollama:latest
+    info: dict = field(repr=False)
+
+    @property
+    def compose(self) -> dict | None:
+        labels = (self.info.get("Config") or {}).get("Labels") or {}
+        project, service = labels.get("com.docker.compose.project"), labels.get("com.docker.compose.service")
+        if not project or not service:
+            return None
+        files = [f for f in str(labels.get("com.docker.compose.project.config_files", "")).split(",") if f]
+        return {"project": project, "service": service, "files": files,
+                "workdir": labels.get("com.docker.compose.project.working_dir", "")}  # fmt: skip
+
+
+def docker_available() -> bool:
+    return shutil.which("docker") is not None and run(["docker", "info", "--format", "{{.ID}}"]).returncode == 0
+
+
+def find_container(host: str) -> Container | None:
+    """The Ollama container that serves `host` (a local address), if Ollama runs in Docker."""
+    parts = urlsplit(host)
+    if parts.hostname not in ("localhost", "127.0.0.1", "::1", "0.0.0.0", None):
+        return None
+    port = str(parts.port or 11434)
+    ids = run(["docker", "ps", "-q"]).stdout.split()
+    if not ids:
+        return None
+    infos = json.loads(run(["docker", "inspect", *ids]).stdout or "[]")
+    found = []
+    for info in infos:
+        image = (info.get("Config") or {}).get("Image", "")
+        if not image.startswith(IMAGE):
+            continue
+        bindings = ((info.get("HostConfig") or {}).get("PortBindings") or {}).get("11434/tcp") or []
+        if any(str(b.get("HostPort")) == port for b in bindings):
+            found.append(Container(info["Id"][:12], info["Name"].lstrip("/"), image, info))
+    return found[0] if len(found) == 1 else None
+
+
+def set_compose_image(text: str, service: str, image: str) -> tuple[str, str]:
+    """The compose file with the service's image changed, and the image it had."""
+    lines = text.splitlines(keepends=True)
+    services = next((i for i, line in enumerate(lines) if re.match(r"services:\s*(#.*)?$", line)), None)
+    if services is None:
+        raise UpdateError("no services: section")
+    start = indent = None
+    for i in range(services + 1, len(lines)):
+        m = re.match(rf"(\s+)['\"]?{re.escape(service)}['\"]?:\s*(#.*)?$", lines[i])
+        if m:
+            start, indent = i, len(m.group(1))
+            break
+        if lines[i].strip() and not lines[i][0].isspace() and not lines[i].lstrip().startswith("#"):
+            break  # the next top-level key: services ended
+    if start is None or indent is None:
+        raise UpdateError(f"no service {service} in it")
+    for i in range(start + 1, len(lines)):
+        line = lines[i]
+        if line.strip() and not line.lstrip().startswith("#") and len(line) - len(line.lstrip()) <= indent:
+            break  # the next service
+        m = re.match(r"(\s+image:\s*)(['\"]?)([^'\"#\s]+)\2(\s*(#.*)?)$", line.rstrip("\n"))
+        if m:
+            if "${" in line:
+                raise UpdateError(f"the image comes from a variable ({m.group(3)}): set it to {image}")
+            newline = "\n" if line.endswith("\n") else ""
+            lines[i] = f"{m.group(1)}{m.group(2)}{image}{m.group(2)}{m.group(4)}{newline}"
+            return "".join(lines), m.group(3)
+    raise UpdateError(f"service {service} has no image: line (it may be built from a Dockerfile)")
+
+
+def run_args(info: dict, image_info: dict, image: str) -> list[str]:
+    """`docker run` arguments that recreate a container with another image and the same settings."""
+    config, host = info.get("Config") or {}, info.get("HostConfig") or {}
+    base = image_info.get("Config") or {}
+    args = ["docker", "run", "-d", "--name", info["Name"].lstrip("/")]
+    restart = host.get("RestartPolicy") or {}
+    if restart.get("Name") not in (None, "", "no"):
+        retries = restart.get("MaximumRetryCount") or 0
+        args += ["--restart", restart["Name"] + (f":{retries}" if restart["Name"] == "on-failure" and retries else "")]
+    for port, bindings in (host.get("PortBindings") or {}).items():
+        target = port.removesuffix("/tcp")
+        for b in bindings or []:
+            ip = b.get("HostIp") or ""
+            args += ["-p", f"{ip + ':' if ip else ''}{b.get('HostPort', '')}:{target}"]
+    for m in info.get("Mounts") or []:
+        source = m.get("Name") if m.get("Type") == "volume" else m.get("Source")
+        if source and m.get("Type") in ("volume", "bind"):
+            args += ["-v", f"{source}:{m['Destination']}" + ("" if m.get("RW", True) else ":ro")]
+    default_env = set(base.get("Env") or [])
+    for entry in config.get("Env") or []:
+        if entry not in default_env:  # only what was set for this container; the new image brings its own PATH
+            args += ["-e", entry]
+    for request in host.get("DeviceRequests") or []:
+        if ["gpu"] in (request.get("Capabilities") or []):
+            ids = request.get("DeviceIDs") or []
+            count = request.get("Count") or 0
+            args += ["--gpus", f"device={','.join(ids)}" if ids else ("all" if count == -1 else str(count))]
+    for device in host.get("Devices") or []:
+        args += ["--device", f"{device['PathOnHost']}:{device['PathInContainer']}"]
+    if host.get("Runtime") not in (None, "", "runc"):
+        args += ["--runtime", host["Runtime"]]
+    network = host.get("NetworkMode") or "default"
+    if network not in ("default", "bridge") and not network.startswith("container:"):
+        args += ["--network", network]
+        endpoint = ((info.get("NetworkSettings") or {}).get("Networks") or {}).get(network) or {}
+        name, short_id = info["Name"].lstrip("/"), info["Id"][:12]
+        for alias in endpoint.get("Aliases") or []:
+            if alias not in (name, short_id):
+                args += ["--network-alias", alias]
+    for host_entry in host.get("ExtraHosts") or []:
+        args += ["--add-host", host_entry]
+    base_labels = base.get("Labels") or {}
+    for key, value in (config.get("Labels") or {}).items():
+        if base_labels.get(key) != value:
+            args += ["--label", f"{key}={value}"]
+    entrypoint, cmd = config.get("Entrypoint") or [], config.get("Cmd") or []
+    if entrypoint and entrypoint != (base.get("Entrypoint") or []):
+        args += ["--entrypoint", entrypoint[0]]
+        cmd = [*entrypoint[1:], *cmd]
+    elif cmd == (base.get("Cmd") or []):
+        cmd = []
+    return [*args, image, *cmd]
+
+
+def wait_for_version(host: str, wanted: str, timeout: float = START_TIMEOUT) -> bool:
+    from lcode.ollama import Ollama, OllamaError
+
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            if Ollama(host).version() == wanted.removesuffix("-rocm"):
+                return True
+        except OllamaError:
+            pass
+        time.sleep(2)
+    return False
+
+
+def recreate(container: Container, image: str, host: str, say: Callable[[str], None]) -> None:
+    """Replace a plain container with one on `image`; put the old one back if that fails."""
+    image_info = json.loads(run(["docker", "image", "inspect", container.info["Image"]]).stdout or "[{}]")[0]
+    args = run_args(container.info, image_info, image)
+    backup = f"{container.name}-before-lcode-update"
+    for step in (["docker", "stop", container.name], ["docker", "rename", container.name, backup]):
+        r = run(step)
+        if r.returncode != 0:
+            raise UpdateError(f"{' '.join(step[:2])} failed: {(r.stderr or r.stdout).strip()}")
+    say(f"$ {' '.join(args)}")
+    started = run(args)
+    if started.returncode == 0 and wait_for_version(host, image.rsplit(":", 1)[1]):
+        run(["docker", "rm", backup])
+        return
+    problem = (started.stderr or started.stdout).strip() or "it didn't answer with the new version"
+    run(["docker", "rm", "-f", container.name])
+    run(["docker", "rename", backup, container.name])
+    run(["docker", "start", container.name])
+    raise UpdateError(f"the new container didn't start ({problem[:300]}); the old one is running again")
+
+
+def recreate_with_compose(container: Container, image: str, host: str, say: Callable[[str], None]) -> None:
+    command, project_dir = compose_up(container.compose or {})
+    say(f"$ {' '.join(command)}")
+    if stream(command, cwd=project_dir) != 0:
+        raise UpdateError("docker compose up failed")
+    if not wait_for_version(host, image.rsplit(":", 1)[1]):
+        raise UpdateError(f"Ollama didn't answer with version {image.rsplit(':', 1)[1]} after the restart")
+
+
+def compose_up(compose: dict) -> tuple[list[str], Path]:
+    """`docker compose up` for just the Ollama service of its project, and where to run it."""
+    files = [Path(f) for f in compose["files"]]
+    project_dir = Path(compose["workdir"]) if compose.get("workdir") else files[0].parent
+    command = ["docker", "compose", "-p", compose["project"], "--project-directory", str(project_dir)]
+    for f in files:
+        command += ["-f", str(f)]
+    return [*command, "up", "-d", "--no-deps", compose["service"]], project_dir
+
+
+def compose_change(container: Container, image: str) -> tuple[Path, str, str]:
+    """Which compose file defines the service's image, and its new text."""
+    compose = container.compose or {}
+    problems = []
+    for path in reversed([Path(f) for f in compose.get("files") or []]):  # later files override earlier ones
+        try:
+            text, old = set_compose_image(path.read_text(), compose["service"], image)
+            return path, text, old
+        except (OSError, UpdateError) as e:
+            problems.append(f"{path}: {e}")
+    raise UpdateError("couldn't find the image to change: " + "; ".join(problems))
+
+
+# ----------------------------------------------------------------------------- lcode update
+
+
+def command(console, what: str = "", check: bool = False, yes: bool = False) -> int:
+    """Update lcode and Ollama (or `what`: "lcode" or "ollama"). Returns the exit code."""
+    from rich.prompt import Confirm
+
+    def ask(question: str) -> bool:
+        if yes:
+            return True
+        if not sys.stdin.isatty():
+            console.print("[dim]Not asking without a terminal: run lcode update -y to go ahead.[/]")
+            return False
+        return Confirm.ask(question, default=True, console=console)
+
+    failed = False
+    for part, step in (("lcode", update_lcode), ("ollama", update_ollama)):
+        if what and what != part:
+            continue
+        try:
+            step(console, check, ask)
+        except UpdateError as e:
+            console.print(f"[red]✗ {escape(str(e))}[/]")
+            failed = True
+        console.print()
+    return 1 if failed else 0
+
+
+def escape(text: str) -> str:
+    from rich.markup import escape as rich_escape
+
+    return rich_escape(text)
+
+
+def update_lcode(console, check: bool, ask: Callable[[str], bool]) -> None:
+    install = lcode_install()
+    if install.kind == "checkout" and install.path is not None:
+        state = checkout_state(install.path)
+        where = f"lcode {__version__} · {install.describe()}, branch {state.branch}"
+        if not state.upstream:
+            console.print(f"{where}: no upstream branch to update from.")
+        elif not state.behind:
+            console.print(f"[green]✓[/] {where}: up to date with {state.upstream}.")
+        elif check:
+            console.print(f"{where}: {state.behind} new commit(s) on {state.upstream}.")
+        elif state.dirty or state.branch not in ("main", "master"):
+            why = "has uncommitted changes" if state.dirty else f"is on branch {state.branch}"
+            console.print(
+                f"{where}: {state.behind} new commit(s) on {state.upstream}, but the checkout {why}. Update it yourself with git pull."
+            )
+        elif ask(f"Pull {state.behind} new commit(s) into {install.path}?"):
+            receipt = (Path(sys.prefix) / "uv-receipt.toml").exists()
+            console.print(f"[green]✓[/] lcode updated: {update_checkout(install.path, receipt)}.")
+        return
+    latest = latest_lcode()
+    if version_key(latest) <= version_key(__version__):
+        console.print(f"[green]✓[/] lcode {__version__} is the newest version ({install.describe()}).")
+        return
+    if install.command is None:
+        console.print(
+            f"lcode {__version__} → {latest} is out. You run lcode with uvx: use  uvx --refresh --from lcode-cli lcode"
+        )
+        return
+    shown = " ".join(install.command)
+    if check:
+        console.print(f"lcode {__version__} → {latest} is out ({install.describe()}): {shown}")
+        return
+    if not ask(f"Update lcode {__version__} → {latest} with `{shown}`?"):
+        return
+    if stream(install.command) != 0:
+        raise UpdateError(f"{shown} failed")
+    console.print("[green]✓[/] lcode updated; the new version runs from the next `lcode`.")
+    if install.kind == "brew":
+        console.print(
+            "[dim]Homebrew's formula follows a release by up to a day: if it's still the old version, try again later.[/]"
+        )
+
+
+def update_ollama(console, check: bool, ask: Callable[[str], bool]) -> None:
+    from lcode import config
+    from lcode.hardware import detect
+    from lcode.ollama import Ollama, OllamaError
+
+    cfg = config.load()
+    if cfg["backend"] != "ollama":
+        console.print(f"lcode uses another model server (backend = {cfg['backend']}): update it there.")
+        return
+    host = cfg["ollama_host"]
+    try:
+        current = Ollama(host).version()
+    except OllamaError:
+        current = ""
+    container = find_container(host) if docker_available() else None
+    if container is None:
+        if not current:
+            raise UpdateError(f"Ollama doesn't answer at {host}: start it, then run lcode update again")
+        latest = latest_ollama()
+        local = urlsplit(host).hostname in ("localhost", "127.0.0.1", "::1", "0.0.0.0", None)
+        if version_key(latest) <= version_key(current):
+            console.print(f"[green]✓[/] Ollama {current} is the newest version.")
+        elif not local:
+            console.print(f"Ollama {current} → {latest} is out. It runs on {host}: update it on that machine.")
+        else:
+            hint = NATIVE.get(detect().os, NATIVE["linux"])
+            console.print(
+                f"Ollama {current} → {latest} is out. Ollama isn't in a Docker container here, so update it with:\n  {hint}"
+            )
+        return
+    latest = latest_ollama(image_flavor(container.image))
+    image = f"{IMAGE}:{latest}"
+    compose = container.compose
+    where = f"container {container.name}, image {container.image}" + (
+        f", Docker Compose project {compose['project']}" if compose else ""
+    )
+    console.print(f"Ollama {current or '?'} · {where}. Newest on Docker Hub: {latest}.")
+    if container.image == image and current == latest.removesuffix("-rocm"):
+        console.print(f"[green]✓[/] Ollama is up to date, on {image}.")
+        return
+    if current == latest.removesuffix("-rocm"):
+        console.print(
+            f"[dim]It already runs {current}, but as {container.image}: pinning it to {image} shows the version in docker ps.[/]"
+        )
+    change = compose_change(container, image) if compose else None
+    plan = [f"docker pull {image}"]
+    if change:
+        path, _, old = change
+        plan.append(f"in {path}, service {compose['service']}: image {old} → {image}")  # type: ignore[index]
+        plan.append(f"docker compose up -d --no-deps {compose['service']}")  # type: ignore[index]
+    else:
+        plan.append(
+            f"recreate container {container.name} on {image}, with the same name, ports, volumes, environment, GPUs, network and restart policy (the old one is kept until the new one answers)"
+        )
+    console.print("\n".join(f"  {i}. {escape(step)}" for i, step in enumerate(plan, 1)))
+    if check:
+        return
+    console.print("[dim]Ollama restarts: requests running now stop, and models load again on their next request.[/]")
+    if not ask("Update Ollama?"):
+        return
+    if stream(["docker", "pull", image]) != 0:
+        raise UpdateError(f"docker pull {image} failed")
+
+    def say(text: str) -> None:
+        console.print(f"[dim]{escape(text)}[/]")
+
+    if change:
+        path, text, _ = change
+        original = path.read_text()
+        path.write_text(text)
+        try:
+            recreate_with_compose(container, image, host, say)
+        except UpdateError:
+            path.write_text(original)
+            say(f"put {path} back the way it was")
+            command, workdir = compose_up(compose)  # type: ignore[arg-type]
+            stream(command, cwd=workdir)
+            raise
+    else:
+        recreate(container, image, host, say)
+    console.print(f"[green]✓[/] Ollama {current or '?'} → {latest.removesuffix('-rocm')}, running as {image}.")
+    old_image = container.info.get("Image", "")
+    if old_image and not run(["docker", "ps", "-aq", "--filter", f"ancestor={old_image}"]).stdout.strip():
+        size = run(["docker", "image", "inspect", old_image, "--format", "{{.Size}}"]).stdout.strip()
+        gb = f" ({int(size) / 1e9:.1f} GB)" if size.isdigit() else ""
+        console.print(
+            f"[dim]The previous image is still on disk{gb}. To remove it: docker image rm {old_image[7:19]}[/]"
+        )

{lcode_cli-0.20.0.dist-info → lcode_cli-0.22.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.20.0
+Version: 0.22.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/
@@ -116,7 +116,8 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   (`lcode mcp add atlassian`), image generation with ComfyUI, or any other MCP server. Browser sign-in (OAuth) is built in.
 - **Sees images.** Attach a screenshot or mockup with `@path` and lcode looks at it, using the
   vision part of your model. With ComfyUI (`lcode mcp add comfyui`) it can also generate and edit
-  images with local models such as FLUX, SDXL and Qwen-Image.
+  images with local models such as FLUX, SDXL and Qwen-Image, or, in the cloud, images, videos
+  and speech with xAI's Grok Imagine (`lcode mcp add xai`).
 - **Web search when needed.** Looks up the latest versions, docs and error messages with Ollama web
   search, Brave, Tavily or your own SearXNG, and reads pages as clean text.
 - **Private.** The model runs on your machine, lcode never uploads your files and has no telemetry.

{lcode_cli-0.20.0.dist-info → lcode_cli-0.22.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lcode/__init__.py,sha256=4WFGTgYgTZwsc2yTfp-j5FUCi0s6YN2WTQKRYUO9oeU,473
+lcode/__init__.py,sha256=s1wi6lDwnIt_wcDMaRuhH7baVfU3UfYMQ2ejuBf_W9E,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=kRD_uuDDdGXt7xwvXZ8OqePK1HprEV76wWAWkV_gcak,28987
 lcode/action.py,sha256=1r3abjheYFYQ-EUArvotls8pLmE3YjNMGHAy_iF0Z70,16198
@@ -9,7 +9,7 @@ lcode/bench.py,sha256=XVdk0hDxmRcjgROOCgwwOsExcUhIxgh0B2vnxtGnA3o,40742
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
-lcode/cli.py,sha256=zo2QTHrdxVaJwIjCEOsfR99byPqeCkKHE5p_Xh8kfb8,39471
+lcode/cli.py,sha256=ue5wsoFxraXXVu7X32S4tbKPLKYhgeI6zpK2i5nXXlU,40180
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/config.py,sha256=eDEvOAA1plsSjvihzHEwGjNVgvcz3Pb-AR5DY5JmXnM,10255
 lcode/context.py,sha256=qJymLE3eYeaF6qVOzlUwDURqlky__8cskl_6vXeU3AA,10701
@@ -34,12 +34,13 @@ lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/sessions.py,sha256=wOR-J0EHgJxLSPboKPHnvBcp5VTUYTj3tZWgpsa6-K4,4013
 lcode/subagents.py,sha256=rD7lnIioodirh8eVnXvRWdZx79J_rscPLssD2Gt7KIo,28914
 lcode/tools.py,sha256=pOdA4ihQHSs8yWUzfxhiLw3GajF5Dr1edxVX0Akr6CU,47257
+lcode/update.py,sha256=i92bnW252VneYh0vD6djxmXsDOa5MXP20bjlLZUue_c,25236
 lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
 lcode/mcp/auth.py,sha256=vyH3oolgIBNJLYabr2h5Soui99NTY1QxjQEgtczfF6A,16655
 lcode/mcp/catalog.py,sha256=I_O10N7cBl0ZW6O7x2kwKn89pvEXUXODUh8FsPXnB-E,3790
-lcode/mcp/catalog.toml,sha256=9uIcH8z2hAzaPzRNuVeSZs239uhIjroGNd76SkmK_NA,11662
+lcode/mcp/catalog.toml,sha256=N8MKyyS_FeCo-RbV3RVZ3ZODro2yk55yqUlymXsWdcQ,12641
 lcode/mcp/client.py,sha256=3Gen7zRvWehngXn_dAMOAdKqFkFkQZIQW96hQcW4N4k,7119
 lcode/mcp/commands.py,sha256=mnp0G-GW5ZsARi2tkHuT3hl883sBGFUVRAV3AapA5oU,16478
 lcode/mcp/config.py,sha256=Ej6WX2b_55a84H5WdAwSk9DzERKoq5ifUBQ9uDgSG_o,8780
@@ -51,8 +52,9 @@ lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
 lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
 lcode/servers/encord.py,sha256=WSauawL1UKYZCUAG1oalcKL_An3DVof-JM6xIgFyQSE,12769
 lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
-lcode_cli-0.20.0.dist-info/METADATA,sha256=x59SrZvhlqu_9PZpirJgYDSKny6D_yubs_cE9yFzDuo,12527
-lcode_cli-0.20.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.20.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
-lcode_cli-0.20.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.20.0.dist-info/RECORD,,
+lcode/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
+lcode_cli-0.22.0.dist-info/METADATA,sha256=3pd56TbC41-H0Ta-kGkl1jn461kw3OqcIOLp-2DZrJE,12620
+lcode_cli-0.22.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.22.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.22.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.22.0.dist-info/RECORD,,

{lcode_cli-0.20.0.dist-info → lcode_cli-0.22.0.dist-info}/entry_points.txt

@@ -2,3 +2,4 @@
 lcode = lcode.cli:main
 lcode-mcp-encord = lcode.servers.encord:main
 lcode-mcp-valohai = lcode.servers.valohai:main
+lcode-mcp-xai = lcode.servers.xai:main