lcode-cli 0.41.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -309,6 +309,7 @@ class Settings:
     comfyui_path: str | None = None  # a ComfyUI install lcode doesn't find by itself (lcode.comfy)
     media_dir: str = ".lcode/media"  # where image and video mode save their files (lcode.media)
     image_model: str = "flux2-klein-4b"  # the media catalog's model image mode uses (lcode.media_catalog)
+    preview: str = "auto"  # images in the terminal: auto, kitty, iterm, blocks or off (lcode.preview)
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -375,6 +376,11 @@ class Agent:
         self.interactive = True  # False for `lcode -p`: no end-of-session questions
         self.comfy_process = None  # the ComfyUI lcode started for image and video mode, stopped when it exits
         self.no_coding_model = ""  # why there's no coding model, when lcode started in image or video mode without
+        from lcode.imageopts import Options as ImageOptions
+
+        self.image_options = ImageOptions()  # image mode's defaults for this session (/options)
+        self.media_results: list[dict] = []  # the session's images, numbered (/gallery, /vary, /open)
+        self.last_request: tuple[str, ImageOptions] | None = None  # for /again
         self.reflected = 0  # messages before this index were already checked for notes to remember
         self._memory: memory_notes.Memory | None = None
         self._agent_types: tuple[Path, dict[str, subagents.AgentType], list[str]] | None = None
@@ -679,8 +685,10 @@ class Agent:
         return any(m.get("role") == "user" for m in self.messages)
 
     def save(self) -> None:
-        if not (self.has_conversation() or self.session_name):
+        if not (self.has_conversation() or self.session_name or self.media_results):
             return  # nothing worth resuming
+        if not self.session_title and not self.has_conversation() and self.media_results:
+            self.session_title = " ".join(self.media_results[0]["prompt"].split())[:60]  # an image session
         self.session_title = self.session_title or sessions.title_from(self.messages)
         f = self.session_file()
         f.parent.mkdir(parents=True, exist_ok=True)
@@ -689,6 +697,7 @@ class Agent:
             "model": self.settings.model,
             "mode": self.settings.mode,
             "image_model": self.settings.image_model,
+            "media": {"results": self.media_results, "options": self.image_options.to_json()},
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -739,6 +748,9 @@ class Agent:
             self.settings.mode = data["mode"]  # a session belongs to the mode it was made in
         if isinstance(data.get("image_model"), str):
             self.settings.image_model = data["image_model"]
+        media = data.get("media") or {}
+        self.media_results = [r for r in media.get("results") or [] if isinstance(r, dict) and "path" in r]
+        self.image_options = type(self.image_options).from_json(media.get("options") or {})
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
         self.tools.todos = list(data.get("todos") or [])

lcode/api.py

@@ -201,6 +201,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         comfyui_path=cfg["comfyui_path"],
         media_dir=cfg["media_dir"],
         image_model=cfg["image_model"],
+        preview=cfg["preview"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],
         searxng_url=cfg["searxng_url"],

lcode/cli.py

@@ -812,7 +812,7 @@ def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
         api.close_agent(agent)
         sys.exit(2)
     try:
-        made = media.generate_image(agent, prompt)
+        made = media.request(agent, prompt)
     except (media.MediaError, KeyboardInterrupt) as e:
         message = str(e) or "Cancelled."
         if quiet:
@@ -826,12 +826,13 @@ def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
             "type": "result",
             "status": "success",
             "mode": "image",
-            "files": [str(path) for path in made.files],
-            "model": made.model,
-            "seed": made.seed,
-            "width": made.width,
-            "height": made.height,
-            "seconds": round(made.seconds, 1),
+            "files": [str(path) for one in made for path in one.files],
+            "model": made[0].model,
+            "seed": made[0].seed,
+            "seeds": [one.seed for one in made],
+            "width": made[0].width,
+            "height": made[0].height,
+            "seconds": round(sum(one.seconds for one in made), 1),
         }
         print(json.dumps(result, ensure_ascii=False), flush=True)
     api.close_agent(agent)

lcode/comfy.py

@@ -560,13 +560,15 @@ def describe_history_error(entry: dict) -> str:
 
 
 def save(server: Server, outputs: dict, folder: Path, stem: str, meta: dict) -> list[Path]:
-    """Fetch the job's files into `folder`: stem-1.png, … with stem-1.json next to each."""
+    """Fetch the job's files into `folder`: stem.png (stem-2.png if that's taken), or stem-1.png, … for several,
+    each with its settings in a .json next to it."""
     folder.mkdir(parents=True, exist_ok=True)
     items = [item for node in outputs.values() for kind in OUTPUT_KINDS for item in node.get(kind, [])]
+    items = [it for it in items if it.get("type", "output") == "output"]
     saved = []
-    for i, item in enumerate((it for it in items if it.get("type", "output") == "output"), 1):
+    for i, item in enumerate(items, 1):
         ext = Path(item["filename"]).suffix or ".png"
-        path = unique(folder / f"{stem}-{i}{ext}")
+        path = unique(folder / (f"{stem}{ext}" if len(items) == 1 else f"{stem}-{i}{ext}"))
         data = server.fetch(item)
         if ext.lower() == ".png":
             data = with_text(data, "lcode", json.dumps(meta, ensure_ascii=False))

lcode/config.py

@@ -46,6 +46,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "comfyui_path": (None, str, "your ComfyUI folder, if lcode doesn't find it (lcode starts it when needed)"),
     "media_dir": (".lcode/media", str, "where images and videos go: a folder in the project, or an absolute path"),
     "image_model": ("flux2-klein-4b", str, "the model image mode uses: a key from `lcode media`"),
+    "preview": ("auto", str, "images in the terminal: auto | kitty | iterm | blocks (colour text) | off"),
     "think": (True, bool, "let the model reason before answering (slower, better)"),
     "web": ("on", str, "web search and page fetching for the model: on | ask | off"),
     "search_backend": ("auto", str, "auto | ollama | brave | tavily | searxng (keys come from environment variables)"),
@@ -211,6 +212,11 @@ def coerce(key: str, value: object) -> object:
         raise ConfigError(f"permission_mode must be one of {', '.join(PERMISSION_MODES)}")
     if key == "mode" and value not in WORK_MODES:
         raise ConfigError(f"mode must be one of {', '.join(WORK_MODES)}")
+    if key == "preview":
+        from lcode.preview import PROTOCOLS
+
+        if value not in PROTOCOLS:
+            raise ConfigError(f"preview must be one of {', '.join(PROTOCOLS)}")
     if key == "image_model":
         from lcode import media_catalog
 

lcode/imageopts.py

@@ -0,0 +1,207 @@
+"""Image options: how many, what shape, which seed, how good, what to avoid, which style.
+
+They're typed in the request (`a red fox --n 4 --ar 16:9 --seed 42 --quality best --style photo --no "people"`), or
+set for the session with `/options n=4 ar=16:9`. Flags in a request win over the session's options for that request.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import shlex
+from dataclasses import asdict, dataclass, replace
+
+QUALITIES = ("fast", "balanced", "best")
+MAX_COUNT = 8
+SIZES = {  # names for aspect ratios
+    "square": "1:1",
+    "portrait": "3:4",
+    "landscape": "4:3",
+    "wide": "16:9",
+    "tall": "9:16",
+    "photo": "3:2",
+    "cinema": "21:9",
+}
+STYLES = {
+    "photo": "professional photograph, natural light, sharp focus, 35mm lens",
+    "cinematic": "cinematic film still, dramatic lighting, shallow depth of field, color graded",
+    "anime": "anime illustration, clean line art, vibrant cel shading",
+    "watercolor": "watercolor painting, soft washes, visible paper texture",
+    "oil": "oil painting, visible brush strokes, rich colors",
+    "pixel": "pixel art, 16-bit, crisp pixels, limited palette",
+    "3d": "3D render, soft global illumination, studio lighting",
+    "sketch": "pencil sketch, graphite, cross-hatching, on paper",
+    "comic": "comic book art, bold ink outlines, halftone shading",
+    "flat": "flat vector illustration, minimal, bold shapes",
+}
+ALIASES = {
+    "n": "n",
+    "count": "n",
+    "ar": "size",
+    "aspect": "size",
+    "size": "size",
+    "seed": "seed",
+    "quality": "quality",
+    "q": "quality",
+    "no": "negative",
+    "negative": "negative",
+    "style": "style",
+}
+FLAG = re.compile(r"(?:^|\s)--?(" + "|".join(sorted(ALIASES, key=len, reverse=True)) + r")\b(?=[\s=]|$)")
+DIMENSIONS = re.compile(r"^(\d{2,4})\s*[x×]\s*(\d{2,4})$")
+RATIO = re.compile(r"^(\d{1,2})\s*:\s*(\d{1,2})$")
+
+
+class OptionError(ValueError):
+    pass
+
+
+@dataclass
+class Options:
+    n: int = 1
+    size: str = "1:1"  # an aspect ratio (16:9), a name (wide) or pixels (1344x768)
+    seed: int | None = None  # None: a new random seed for each image
+    quality: str = "balanced"
+    negative: str = ""
+    style: str = ""
+
+    def describe(self) -> str:
+        seed = "random" if self.seed is None else str(self.seed)
+        parts = [f"n={self.n}", f"size={self.size}", f"seed={seed}", f"quality={self.quality}"]
+        if self.style:
+            parts.append(f"style={self.style}")
+        if self.negative:
+            parts.append(f"no={self.negative!r}")
+        return " ".join(parts)
+
+    def to_json(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_json(cls, data: dict) -> Options:
+        known = {k: v for k, v in (data or {}).items() if k in cls.__dataclass_fields__}
+        try:
+            return set_values(cls(), known)
+        except OptionError:
+            return cls()
+
+
+def set_values(options: Options, values: dict[str, object]) -> Options:
+    """A copy of `options` with `values` (by name or alias) applied. Raises OptionError saying what's wrong."""
+    out = replace(options)
+    for raw_key, raw in values.items():
+        key = ALIASES.get(str(raw_key).lower().lstrip("-"))
+        if key is None:
+            raise OptionError(f"unknown option {raw_key!r}: use n, ar (or size), seed, quality, style or no")
+        value = str(raw).strip() if raw is not None else ""
+        if key == "n":
+            if not value.isdigit() or not 1 <= int(value) <= MAX_COUNT:
+                raise OptionError(f"n is how many images: 1 to {MAX_COUNT}")
+            out.n = int(value)
+        elif key == "size":
+            out.size = check_size(value)
+        elif key == "seed":
+            if value.lower() in ("random", "none", ""):
+                out.seed = None
+            elif value.isdigit() and int(value) < 2**63:
+                out.seed = int(value)
+            else:
+                raise OptionError("seed is a whole number, or random")
+        elif key == "quality":
+            if value.lower() not in QUALITIES:
+                raise OptionError(f"quality is {', '.join(QUALITIES)}")
+            out.quality = value.lower()
+        elif key == "style":
+            if value.lower() in ("none", "off", ""):
+                out.style = ""
+            elif value.lower() in STYLES:
+                out.style = value.lower()
+            else:
+                raise OptionError(f"style is one of {', '.join(STYLES)} (or none)")
+        elif key == "negative":
+            out.negative = "" if value.lower() in ("none", "off") else value
+    return out
+
+
+def check_size(value: str) -> str:
+    v = value.lower().replace(" ", "")
+    if v in SIZES:
+        return v
+    if RATIO.match(v):
+        w, h = (int(x) for x in RATIO.match(v).groups())
+        if w and h and 1 / 4 <= w / h <= 4:
+            return f"{w}:{h}"
+    m = DIMENSIONS.match(v)
+    if m:
+        w, h = (int(x) for x in m.groups())
+        if 256 <= w <= 2048 and 256 <= h <= 2048:
+            return f"{w}x{h}"
+        raise OptionError("a size in pixels is 256 to 2048 on each side, e.g. 1344x768")
+    raise OptionError(f"size is a ratio (16:9), pixels (1344x768) or one of {', '.join(SIZES)}")
+
+
+def parse(text: str, defaults: Options) -> tuple[str, Options]:
+    """The prompt without its flags, and the options for this request. Raises OptionError."""
+    matches = list(FLAG.finditer(text))
+    if not matches:
+        return text.strip(), defaults
+    prompt = text[: matches[0].start()]
+    values: dict[str, str] = {}
+    for i, m in enumerate(matches):
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        rest = text[m.end() : end].strip().lstrip("=").strip()
+        try:
+            words = shlex.split(rest)
+        except ValueError:
+            words = rest.split()
+        key = ALIASES[m.group(1).lower()]
+        if key == "negative":
+            values[key] = " ".join(words)
+        else:
+            if not words:
+                raise OptionError(f"--{m.group(1)} needs a value")
+            values[key] = words[0]
+            if len(words) > 1:  # words after a flag's value belong to the prompt
+                prompt += " " + " ".join(words[1:])
+    return prompt.strip(), set_values(defaults, values)
+
+
+def parse_assignments(text: str) -> dict[str, str]:
+    """`n=4 ar=16:9 no="blurry, text"` -> {"n": "4", "ar": "16:9", "no": "blurry, text"}."""
+    try:
+        words = shlex.split(text)
+    except ValueError as e:
+        raise OptionError(f"can't read {text!r}: {e}") from e
+    out = {}
+    for word in words:
+        key, sep, value = word.partition("=")
+        if not sep:
+            raise OptionError(f"write options as name=value, e.g. n=4 ar=16:9 (not {word!r})")
+        out[key] = value
+    return out
+
+
+def dimensions(size: str, megapixels: float, multiple: int = 16) -> tuple[int, int]:
+    """Width and height in pixels: from a ratio and the quality's megapixels, or exact pixels as given."""
+    m = DIMENSIONS.match(size)
+    if m:
+        w, h = (int(x) for x in m.groups())
+        return round_to(w, multiple), round_to(h, multiple)
+    ratio = SIZES.get(size, size)
+    w, h = (int(x) for x in ratio.split(":"))
+    area = megapixels * 1024 * 1024
+    width = math.sqrt(area * w / h)
+    return round_to(width, multiple), round_to(width * h / w, multiple)
+
+
+def round_to(value: float, multiple: int) -> int:
+    return max(multiple, round(value / multiple) * multiple)
+
+
+def replace_seed(options: Options, n: int | None = None) -> Options:
+    """The options with a random seed again (for /again and /vary), and optionally another count."""
+    return replace(options, seed=None, n=n or options.n)
+
+
+def styled(prompt: str, style: str) -> str:
+    return f"{prompt}, {STYLES[style]}" if style else prompt

lcode/media.py

@@ -6,16 +6,21 @@ sizes, variations and a gallery come with #151, video with #153.
 
 from __future__ import annotations
 
+import os
 import random
+import shutil
+import subprocess
+import sys
 import time
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field, replace
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+import requests
 from rich.text import Text
 
-from lcode import comfy
+from lcode import comfy, imageopts, preview
 from lcode import media_catalog as catalog
 
 if TYPE_CHECKING:
@@ -52,6 +57,9 @@ class Made:
     width: int
     height: int
     seconds: float
+    prompt: str = ""
+    numbers: list[int] = field(default_factory=list)  # in the session's gallery
+    thumbnail: bytes = b""  # a small PNG, for the half-block preview
 
 
 # ----------------------------------------------------------------------------- ComfyUI, started and stopped
@@ -217,13 +225,79 @@ def ensure_installed(
     return files
 
 
+THUMB_NODES = ("9001", "9002")  # the thumbnail lcode adds to a workflow, for the half-block preview
+
+
+def add_thumbnail(graph: dict, width: int, height: int) -> None:
+    """Have ComfyUI also make a small copy of the image (not saved, a preview), for the half-block preview."""
+    save = next((nid for nid, node in graph.items() if node.get("class_type") == "SaveImage"), None)
+    if save is None:
+        return
+    tw, th = preview.thumbnail_size(width, height)
+    scale, show = THUMB_NODES
+    graph[scale] = {
+        "class_type": "ImageScale",
+        "inputs": {"image": graph[save]["inputs"]["images"], "upscale_method": "area", "width": tw, "height": th,
+                   "crop": "disabled"},
+    }  # fmt: skip
+    graph[show] = {"class_type": "PreviewImage", "inputs": {"images": [scale, 0]}}
+
+
+def thumbnail(server: comfy.Server, outputs: dict) -> bytes:
+    for item in (outputs.get(THUMB_NODES[1]) or {}).get("images", []):
+        try:
+            return server.fetch(item)
+        except (comfy.ComfyError, OSError, requests.RequestException):
+            return b""
+    return b""
+
+
+def request(
+    agent: Agent, text: str, cancelled: Callable[[], bool] = lambda: False, ask: Callable[[str], bool] | None = None
+) -> list[Made]:
+    """A typed request: the prompt and its flags (--n 4 --ar 16:9 …, over the session's /options), then the images."""
+    try:
+        prompt, options = imageopts.parse(text, agent.image_options)
+    except imageopts.OptionError as e:
+        raise MediaError(str(e)) from e
+    return make(agent, prompt, options, cancelled, ask)
+
+
+def make(
+    agent: Agent,
+    prompt: str,
+    options: imageopts.Options,
+    cancelled: Callable[[], bool] = lambda: False,
+    ask: Callable[[str], bool] | None = None,
+) -> list[Made]:
+    """`options.n` images of the prompt; a fixed seed counts up from image to image."""
+    if not prompt.strip():
+        raise MediaError("Describe the image you want.")
+    model = current(agent)
+    if options.negative and not model.negative:
+        agent.say(f"{model.name} doesn't use a negative prompt: describe what you want instead (--no is ignored).")
+    agent.last_request = (prompt, options)
+    made = []
+    for i in range(options.n):
+        seed = None if options.seed is None else options.seed + i
+        label = f"{i + 1} of {options.n}" if options.n > 1 else ""
+        made.append(generate_image(agent, prompt, cancelled, ask, replace(options, seed=seed, n=1), label))
+    return made
+
+
 def generate_image(
-    agent: Agent, prompt: str, cancelled: Callable[[], bool] = lambda: False, ask: Callable[[str], bool] | None = None
+    agent: Agent,
+    prompt: str,
+    cancelled: Callable[[], bool] = lambda: False,
+    ask: Callable[[str], bool] | None = None,
+    options: imageopts.Options | None = None,
+    label: str = "",
 ) -> Made:
-    """One image from the prompt, saved in the media folder. Raises MediaError with what to do."""
+    """One image from the prompt, saved in the media folder and numbered. Raises MediaError with what to do."""
     prompt = prompt.strip()
     if not prompt:
         raise MediaError("Describe the image you want.")
+    options = options or imageopts.Options()
     server = engine(agent, ask, cancelled)
     for path in comfy.collect(server):
         agent.say(f"Saved {shown(agent, path)}: it finished while lcode wasn't watching.")
@@ -231,25 +305,40 @@ def generate_image(
     files = ensure_installed(agent, model, server, ask)
     workflow = comfy.load_workflow(model.workflow)
     free_gpu(agent)
-    seed = random.randrange(2**32)
-    values = {**workflow.defaults, **files, "prompt": prompt, "seed": seed}
+    seed = options.seed if options.seed is not None else random.randrange(2**32)
+    steps, megapixels = model.preset(options.quality)
+    width, height = imageopts.dimensions(options.size, megapixels)
+    text = imageopts.styled(prompt, options.style)
+    values = {**workflow.defaults, **files, "prompt": text, "seed": seed, "width": width, "height": height}
+    if steps:
+        values["steps"] = steps
+    if model.negative:
+        values["negative"] = options.negative
     graph = comfy.fill(workflow.graph, values)
+    add_thumbnail(graph, width, height)
     meta = {
         "prompt": prompt,
         "model": model.name,
         "model_key": model.key,
         "workflow": workflow.key,
         "seed": seed,
-        "width": values["width"],
-        "height": values["height"],
+        "width": width,
+        "height": height,
         "steps": values["steps"],
+        "quality": options.quality,
+        "style": options.style,
+        "negative": options.negative if model.negative else "",
+        "full_prompt": text,
         "files": files,
         "created": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
     }
     out = folder(agent)
     stem = f"{time.strftime('%Y%m%d-%H%M%S')}-{comfy.slug(prompt)}"
-    line = Line(model.name, "Esc or Ctrl+C cancels" if agent.interactive else "")
+    line = Line(
+        f"{model.name} ({label})" if label else model.name, "Esc or Ctrl+C cancels" if agent.interactive else ""
+    )
     job = {"id": ""}
+    labels = {**workflow.labels, THUMB_NODES[0]: "making the preview", THUMB_NODES[1]: "making the preview"}
 
     def on_event(event: comfy.Event) -> None:
         if event.kind == "queued":
@@ -258,9 +347,9 @@ def generate_image(
         elif event.kind == "waiting":
             line.doing = f"waiting: {event.value} job(s) ahead in ComfyUI's queue"
         elif event.kind == "node":
-            line.doing, line.step = workflow.labels.get(event.node, "working"), None
+            line.doing, line.step = labels.get(event.node, "working"), None
         elif event.kind == "progress" and event.total:
-            line.doing = workflow.labels.get(event.node, line.doing)
+            line.doing = labels.get(event.node, line.doing)
             line.progress(event.value, event.total)
 
     try:
@@ -283,11 +372,102 @@ def generate_image(
     comfy.forget(prompt_id)
     if not saved:
         raise MediaError("ComfyUI finished but returned no image.")
-    made = Made(saved, model.name, seed, values["width"], values["height"], time.monotonic() - line.started)
-    for path in saved:
+    made = Made(saved, model.name, seed, width, height, time.monotonic() - line.started, prompt)
+    made.thumbnail = thumbnail(server, outputs)
+    made.numbers = record(agent, made, meta, options)
+    show(agent, made)
+    return made
+
+
+# ----------------------------------------------------------------------------- results: numbered, shown, opened
+
+
+def record(agent: Agent, made: Made, meta: dict, options: imageopts.Options) -> list[int]:
+    """Number the images in the session's gallery, with what made them (for /gallery, /vary, /open)."""
+    numbers = []
+    for path in made.files:
+        number = len(agent.media_results) + 1
+        agent.media_results.append(
+            {
+                "n": number,
+                "path": str(path),
+                "prompt": made.prompt,
+                "model": made.model,
+                "seed": made.seed,
+                "width": made.width,
+                "height": made.height,
+                "steps": meta["steps"],
+                "seconds": round(made.seconds, 1),
+                "options": options.to_json(),
+            }
+        )
+        numbers.append(number)
+    return numbers
+
+
+def show(agent: Agent, made: Made) -> None:
+    for path, number in zip(made.files, made.numbers or [0] * len(made.files), strict=False):
         agent.console.print(
             Text("◆ ", style="green")
+            + Text(f"#{number} " if number else "", style="bold green")
             + Text(shown(agent, path), style="bold")
-            + Text(f"  {made.width}×{made.height} · {made.model} · seed {seed} · {made.seconds:.1f} s", style="dim")
+            + Text(
+                f"  {made.width}×{made.height} · {made.model} · seed {made.seed} · {made.seconds:.1f} s", style="dim"
+            )
         )
-    return made
+    if made.files:
+        show_preview(agent, made.files[0], made.thumbnail)
+
+
+def show_preview(agent: Agent, path: Path, thumb: bytes = b"") -> None:
+    """The image in the terminal: itself where the terminal can show pictures, else a half-block preview."""
+    setting = agent.settings.preview
+    how = preview.protocol(setting)
+    if how == "off" or (setting == "auto" and not agent.console.is_terminal):
+        return
+    try:
+        if how in ("kitty", "iterm"):
+            data = path.read_bytes()
+            sequence = preview.kitty(data) if how == "kitty" else preview.iterm(data)
+            agent.console.file.write(sequence)
+            agent.console.file.flush()
+        elif thumb:
+            agent.console.print(preview.blocks(thumb))
+    except (OSError, preview.PngError):
+        pass
+
+
+def result(agent: Agent, which: str) -> dict:
+    """A gallery entry by its number (#3 or 3), or the last one."""
+    if not agent.media_results:
+        raise MediaError("No images in this session yet.")
+    key = which.strip().lstrip("#")
+    if not key:
+        return agent.media_results[-1]
+    if not key.isdigit() or not 1 <= int(key) <= len(agent.media_results):
+        raise MediaError(f"There's no image #{key}: this session has #1 to #{len(agent.media_results)} (/gallery).")
+    return agent.media_results[int(key) - 1]
+
+
+def open_file(path: Path) -> str:
+    """Open a file in the system's viewer. An error message, or empty."""
+    if not path.exists():
+        return f"{path} isn't there any more."
+    if sys.platform == "darwin":
+        command = ["open", str(path)]
+    elif sys.platform.startswith("win"):
+        os.startfile(str(path))  # type: ignore[attr-defined]
+        return ""
+    else:
+        opener = shutil.which("xdg-open") or shutil.which("gio")
+        if not opener:
+            return "No program to open it with (xdg-open isn't installed): open the file yourself."
+        command = [opener, str(path)] if opener.endswith("xdg-open") else [opener, "open", str(path)]
+    try:
+        subprocess.Popen(
+            command, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )  # fmt: skip
+    except OSError as e:
+        return f"Couldn't open it: {e}"
+    return ""

lcode/media.toml

@@ -15,6 +15,8 @@
 #   gpu_gb        GPU memory it needs, when known better than lcode's estimate (the largest file + 1.5 GB); ComfyUI
 #                 fills whatever is free with cached models, so nvidia-smi's peak doesn't tell
 #   measured      what it did on real hardware; models without it haven't been run yet
+#   quality       per preset (fast, balanced, best): [steps, megapixels]
+#   negative      whether it uses a negative prompt (distilled models don't)
 
 [files.flux-2-klein-4b-fp8]
 folder = "diffusion_models"
@@ -60,6 +62,8 @@ files = { model = "flux-2-klein-4b-fp8", text_encoder = "qwen-3-4b", vae = "flux
 gpu_gb = 0.0
 measured = "1024×1024: 3.5 s per image, 14 s for the first with ComfyUI starting (RTX 4080 Laptop, 12 GB)"
 notes = "fast and small: 4 steps"
+quality = { fast = [4, 0.5], balanced = [4, 1.0], best = [4, 2.0] }
+negative = false
 
 [models.z-image-turbo]
 name = "Z-Image Turbo"
@@ -72,3 +76,5 @@ files = { model = "z-image-turbo-int8", text_encoder = "qwen-3-4b", vae = "flux-
 gpu_gb = 0.0
 measured = "1024×1024: 17 s per image (1.9 s per step), 23 s for the first (RTX 4080 Laptop, 12 GB)"
 notes = "photorealistic, writes text well: 8 steps"
+quality = { fast = [6, 0.5], balanced = [8, 1.0], best = [9, 2.0] }
+negative = false

lcode/media_catalog.py

@@ -67,6 +67,13 @@ class MediaModel:
     gpu_gb: float = 0.0  # measured peak GPU memory; 0 when not measured yet
     measured: str = ""
     notes: str = ""
+    quality: dict[str, tuple[int, float]] = field(default_factory=dict, hash=False)  # preset -> (steps, megapixels)
+    negative: bool = False  # whether it uses a negative prompt
+
+    def preset(self, quality: str) -> tuple[int | None, float]:
+        """(steps, megapixels) for a quality preset: None steps keeps the workflow's."""
+        steps, megapixels = self.quality.get(quality) or self.quality.get("balanced") or (None, 1.0)
+        return (int(steps) if steps else None), float(megapixels)
 
     @property
     def size_gb(self) -> float:
@@ -137,6 +144,8 @@ def load() -> Catalog:
             float(m.get("gpu_gb", 0.0)),
             m.get("measured", ""),
             m.get("notes", ""),
+            {name: (int(v[0]), float(v[1])) for name, v in (m.get("quality") or {}).items()},
+            bool(m.get("negative", False)),
         )
     return Catalog(files, models)
 

lcode/preview.py

@@ -0,0 +1,152 @@
+"""Show an image in the terminal: the picture itself where the terminal can (kitty's graphics protocol, iTerm2's
+inline images), otherwise a small colour preview drawn with half blocks.
+
+The half-block preview comes from a thumbnail ComfyUI makes along with the image (a few dozen pixels wide), decoded
+here: lcode needs no imaging library for it. A PNG decoder for 8-bit, non-interlaced images is all that takes.
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+import struct
+import zlib
+from collections.abc import Mapping
+
+from rich.text import Text
+
+PROTOCOLS = ("auto", "kitty", "iterm", "blocks", "off")
+COLUMNS = 40  # how wide a preview is, in terminal columns
+THUMB_WIDTH = 64  # pixels: the thumbnail ComfyUI makes for half-block previews
+KITTY_CHUNK = 4096
+
+
+def protocol(setting: str = "auto", env: Mapping[str, str] = os.environ) -> str:
+    """kitty, iterm, blocks or off: what this terminal can show (or what the `preview` setting says)."""
+    if setting != "auto":
+        return setting
+    if env.get("TMUX") or env.get("TERM", "").startswith("screen"):
+        return "blocks"  # multiplexers need passthrough for images: keep to text
+    if env.get("KITTY_WINDOW_ID") or env.get("TERM") == "xterm-kitty" or env.get("TERM_PROGRAM") == "ghostty":
+        return "kitty"
+    if env.get("TERM_PROGRAM") in ("iTerm.app", "WezTerm") or env.get("LC_TERMINAL") == "iTerm2":
+        return "iterm"
+    return "blocks"
+
+
+def kitty(png: bytes, columns: int = COLUMNS) -> str:
+    """The escape sequences that show a PNG in kitty (and Ghostty), `columns` wide."""
+    data = base64.b64encode(png).decode()
+    chunks = [data[i : i + KITTY_CHUNK] for i in range(0, len(data), KITTY_CHUNK)] or [""]
+    out = []
+    for i, chunk in enumerate(chunks):
+        more = 1 if i < len(chunks) - 1 else 0
+        head = f"a=T,f=100,c={columns},q=2,m={more}" if i == 0 else f"m={more}"
+        out.append(f"\x1b_G{head};{chunk}\x1b\\")
+    return "".join(out) + "\n"
+
+
+def iterm(png: bytes, columns: int = COLUMNS) -> str:
+    """The escape sequence that shows an image in iTerm2 (and WezTerm), `columns` wide."""
+    data = base64.b64encode(png).decode()
+    return f"\x1b]1337;File=inline=1;size={len(png)};width={columns};preserveAspectRatio=1:{data}\x07\n"
+
+
+# ----------------------------------------------------------------------------- PNG, decoded
+
+
+class PngError(ValueError):
+    pass
+
+
+def decode_png(data: bytes) -> tuple[int, int, list[list[tuple[int, int, int]]]]:
+    """(width, height, rows of RGB pixels) of an 8-bit, non-interlaced PNG (grey, RGB, palette, with alpha)."""
+    if not data.startswith(b"\x89PNG\r\n\x1a\n"):
+        raise PngError("not a PNG")
+    i, idat, palette = 8, [], b""
+    width = height = depth = color = interlace = 0
+    while i + 8 <= len(data):
+        (n,) = struct.unpack(">I", data[i : i + 4])
+        kind, body = data[i + 4 : i + 8], data[i + 8 : i + 8 + n]
+        if kind == b"IHDR":
+            width, height, depth, color, _, _, interlace = struct.unpack(">IIBBBBB", body)
+        elif kind == b"PLTE":
+            palette = body
+        elif kind == b"IDAT":
+            idat.append(body)
+        elif kind == b"IEND":
+            break
+        i += 12 + n
+    if depth != 8 or interlace or color not in (0, 2, 3, 4, 6):
+        raise PngError(f"unsupported PNG (bit depth {depth}, colour type {color}, interlace {interlace})")
+    channels = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4}[color]
+    raw = zlib.decompress(b"".join(idat))
+    stride = width * channels
+    rows, previous = [], bytearray(stride)
+    for y in range(height):
+        start = y * (stride + 1)
+        kind, line = raw[start], bytearray(raw[start + 1 : start + 1 + stride])
+        unfilter(kind, line, previous, channels)
+        rows.append(pixels(line, color, channels, palette))
+        previous = line
+    return width, height, rows
+
+
+def unfilter(kind: int, line: bytearray, previous: bytearray, bpp: int) -> None:
+    if kind == 0:
+        return
+    for x in range(len(line)):
+        left = line[x - bpp] if x >= bpp else 0
+        up = previous[x]
+        if kind == 1:
+            line[x] = (line[x] + left) & 0xFF
+        elif kind == 2:
+            line[x] = (line[x] + up) & 0xFF
+        elif kind == 3:
+            line[x] = (line[x] + (left + up) // 2) & 0xFF
+        elif kind == 4:
+            corner = previous[x - bpp] if x >= bpp else 0
+            p = left + up - corner
+            pa, pb, pc = abs(p - left), abs(p - up), abs(p - corner)
+            line[x] = (line[x] + (left if pa <= pb and pa <= pc else up if pb <= pc else corner)) & 0xFF
+        else:
+            raise PngError(f"unknown PNG filter {kind}")
+
+
+def pixels(line: bytearray, color: int, channels: int, palette: bytes) -> list[tuple[int, int, int]]:
+    out = []
+    for x in range(0, len(line), channels):
+        if color in (0, 4):
+            out.append((line[x], line[x], line[x]))
+        elif color == 3:
+            j = line[x] * 3
+            out.append(tuple(palette[j : j + 3]) if j + 3 <= len(palette) else (0, 0, 0))
+        else:
+            out.append((line[x], line[x + 1], line[x + 2]))
+    return out
+
+
+def blocks(png: bytes, columns: int = COLUMNS) -> Text:
+    """A colour preview `columns` wide: each character shows two pixels, one above the other (▀)."""
+    width, height, rows = decode_png(png)
+    columns = max(1, min(columns, width))
+    lines = max(1, round(height * columns / width / 2))
+    text = Text()
+    for row in range(lines):
+        for col in range(columns):
+            x = min(width - 1, col * width // columns)
+            top = rows[min(height - 1, (2 * row) * height // (2 * lines))][x]
+            bottom = rows[min(height - 1, (2 * row + 1) * height // (2 * lines))][x]
+            text.append("▀", style=f"{hex_color(top)} on {hex_color(bottom)}")
+        if row < lines - 1:
+            text.append("\n")
+    return text
+
+
+def hex_color(rgb: tuple[int, int, int]) -> str:
+    return "#{:02x}{:02x}{:02x}".format(*rgb)
+
+
+def thumbnail_size(width: int, height: int, thumb: int = THUMB_WIDTH) -> tuple[int, int]:
+    """The thumbnail ComfyUI makes for the half-block preview: `thumb` pixels wide, the image's shape."""
+    return thumb, max(2, round(thumb * height / width))

lcode/repl.py

@@ -79,6 +79,11 @@ COMMANDS = {
     "/plan": "Plan before changing anything: /plan <request>, or /plan to show the approved plan",
     "/mode": "What lcode makes: code, image or video, e.g. /mode image",
     "/permissions": "Permission mode: ask | plan | auto-edit | yolo (Shift+Tab cycles)",
+    "/options": "Image mode's options for this session, e.g. /options n=4 ar=16:9 quality=best style=photo",
+    "/again": "Image mode: the last request again, with new seeds (flags work: /again --n 4)",
+    "/vary": "Image mode: variations of an image, new seeds, e.g. /vary 3 (default: the last; --n 2)",
+    "/gallery": "Image mode: this session's images with their settings (/gallery all: every image here)",
+    "/open": "Open an image in your viewer, e.g. /open 3 (default: the last)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
     "/status": "The task sheet: your requests, the plan and notes, files changed, the last check",
@@ -1181,6 +1186,8 @@ def handle_command(agent: Agent, line: str, hardware: Hardware) -> bool:
         run_safely(agent, arg)
     elif cmd == "/mode":
         mode_command(agent, arg.strip().lower())
+    elif cmd in ("/options", "/again", "/vary", "/gallery", "/open"):
+        image_command(agent, cmd, arg)
     elif cmd == "/permissions":
         if arg in PERMISSION_MODES:
             agent.perms.mode = arg
@@ -1394,8 +1401,100 @@ def respond(agent: Agent, line: str) -> None:
     run_safely(agent, line)
 
 
-def make_image(agent: Agent, prompt: str) -> None:
-    """Image mode: ComfyUI makes the image; Esc or Ctrl+C cancels it there too."""
+def image_command(agent: Agent, cmd: str, arg: str) -> None:
+    """/options, /again, /vary, /gallery and /open: image mode's follow-ups on its results."""
+    from lcode import imageopts
+
+    c = agent.console
+    if cmd == "/options":
+        if not arg.strip():
+            c.print(f"Image options: [bold]{escape(agent.image_options.describe())}[/]")
+            c.print(
+                '[dim]Set them with /options n=4 ar=16:9 seed=42 quality=best style=photo no="text"; '
+                f"styles: {', '.join(imageopts.STYLES)}. Flags in a request (--n 4) win for that request.[/]"
+            )
+            return
+        try:
+            agent.image_options = imageopts.set_values(agent.image_options, imageopts.parse_assignments(arg))
+        except imageopts.OptionError as e:
+            c.print(f"[red]{escape(str(e))}[/]")
+            return
+        c.print(f"Image options: [bold]{escape(agent.image_options.describe())}[/]")
+        return
+    if cmd == "/gallery":
+        gallery(agent, everything=arg.strip() == "all")
+        return
+    if cmd == "/open":
+        try:
+            entry = media.result(agent, arg)
+        except media.MediaError as e:
+            c.print(f"[yellow]{escape(str(e))}[/]")
+            return
+        problem = media.open_file(Path(entry["path"]))
+        c.print(f"[yellow]{escape(problem)}[/]" if problem else f"[dim]Opened #{entry['n']}.[/]")
+        return
+    if agent.settings.mode != "image":
+        c.print("[yellow]/again and /vary work in image mode: /mode image.[/]")
+        return
+    try:
+        number, _ = imageopts.parse(arg, imageopts.Options())  # what isn't a flag: the image's number
+    except imageopts.OptionError as e:
+        c.print(f"[red]{escape(str(e))}[/]")
+        return
+    if cmd == "/again":
+        if agent.last_request is None:
+            c.print("[yellow]Nothing to do again yet: describe an image first.[/]")
+            return
+        prompt, options = agent.last_request
+        options = imageopts.replace_seed(options)
+    else:
+        try:
+            entry = media.result(agent, number)
+        except media.MediaError as e:
+            c.print(f"[yellow]{escape(str(e))}[/]")
+            return
+        prompt = entry["prompt"]
+        options = imageopts.Options.from_json(entry.get("options") or {})
+        options = imageopts.replace_seed(options, n=4)
+        c.print(f"[dim]Variations of #{entry['n']}: {escape(prompt)}[/]")
+    _, options = imageopts.parse(arg, options)  # flags given here win
+    make_image(agent, prompt, options)
+
+
+def gallery(agent: Agent, everything: bool = False) -> None:
+    """The session's images (or every image in the media folder), with what made them."""
+    import json as json_module
+
+    c = agent.console
+    if everything:
+        folder = media.folder(agent)
+        entries = []
+        for sidecar in sorted(folder.glob("*.json"), reverse=True)[:50]:
+            try:
+                meta = json_module.loads(sidecar.read_text())
+            except (OSError, ValueError):
+                continue
+            entries.append({"path": str(sidecar.with_name(meta.get("file", sidecar.stem + ".png"))), **meta})
+        if not entries:
+            c.print(f"[dim]No images in {media.shown(agent, folder)} yet.[/]")
+            return
+        c.print(f"[bold]{len(entries)} latest image(s) in {escape(media.shown(agent, folder))}[/]")
+    else:
+        entries = agent.media_results
+        if not entries:
+            c.print("[dim]No images in this session yet: describe one. /gallery all lists every image here.[/]")
+            return
+    for entry in entries:
+        number = f"#{entry['n']:<3}" if "n" in entry else "    "
+        c.print(
+            f"  [bold green]{number}[/] {escape(media.shown(agent, Path(entry['path'])))}\n"
+            f"       [dim]{escape(entry.get('prompt', ''))} · {entry.get('width')}×{entry.get('height')} · "
+            f"{escape(str(entry.get('model', '')))} · seed {entry.get('seed')}[/]"
+        )
+
+
+def make_image(agent: Agent, prompt: str, options=None) -> None:
+    """Image mode: ComfyUI makes the images; Esc or Ctrl+C cancels them there too."""
     steering = Steering()
     reader = KeyReader(steering)
     reading = agent.interactive and reader.start()  # Esc sets steering.pause: here it cancels
@@ -1405,7 +1504,11 @@ def make_image(agent: Agent, prompt: str) -> None:
         return answer.strip().lower() in ("y", "yes")
 
     try:
-        media.generate_image(agent, prompt, cancelled=lambda: steering.pause, ask=ask if agent.interactive else None)
+        asking = ask if agent.interactive else None
+        if options is None:
+            media.request(agent, prompt, cancelled=lambda: steering.pause, ask=asking)
+        else:
+            media.make(agent, prompt, options, cancelled=lambda: steering.pause, ask=asking)
     except media.MediaError as e:
         agent.console.print(f"[yellow]{escape(str(e))}[/]")
     except KeyboardInterrupt:  # while ComfyUI was starting: nothing queued yet
@@ -1419,6 +1522,7 @@ def make_image(agent: Agent, prompt: str) -> None:
         if typed:
             agent.unsent = typed
             agent.console.print(Text("✎ What you typed is in the prompt below.", style="cyan"))
+        agent.save()  # the gallery and options carry over when the session is resumed
 
 
 def preload(agent: Agent, session: PromptSession | None = None) -> None:

lcode/sessions.py

@@ -24,7 +24,7 @@ class SessionInfo:
     title: str  # the first request, shortened
     model: str
     updated: float  # modification time of the session file
-    turns: int  # number of requests from the user
+    turns: int  # number of requests from the user (and images made, in image mode)
 
     @property
     def label(self) -> str:
@@ -69,7 +69,7 @@ def read_info(path: Path) -> SessionInfo | None:
         title=data.get("title") or title_from(messages),
         model=data.get("model", ""),
         updated=updated,
-        turns=sum(1 for m in messages if m.get("role") == "user"),
+        turns=sum(1 for m in messages if m.get("role") == "user") + len((data.get("media") or {}).get("results") or []),
     )
 
 

{lcode_cli-0.41.0.dist-info → lcode_cli-0.42.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.41.0
+Version: 0.42.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/

{lcode_cli-0.41.0.dist-info → lcode_cli-0.42.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lcode/__init__.py,sha256=cP-2ftJ2hz9SKhg5hKS4FosPfEa3qxeHu6hAb4URJQ8,473
+lcode/__init__.py,sha256=v3apJPFRjkc0xQqftHToQJR2cWw-oucwV0aezidZmyA,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=-RZXqheMdbwjRkwMPGBnj_kkRfrAUYkqOLMc888gXgo,87528
-lcode/api.py,sha256=jQmx-ddJC6MoNcRcaWoERs2Ci6KYzBto9GxdVBE7JkU,17632
+lcode/agent.py,sha256=DmKlZ86NPzicwc_pXDEJ3_vgRwri2XknFq9M01f2Sgk,88527
+lcode/api.py,sha256=efsUuIZneUc6Ar6KWerKAoMlMFOlSUtLX4_quplr3t8,17664
 lcode/backends.py,sha256=343alwyDZin-bEhb5-Es4f8ek1oBQUzEvV6RFWR1VZo,21160
 lcode/bench.py,sha256=HxeUfy9Kv_0Rug1HAlDLyHYfYd9dw2bMgbXsvUy9nd4,43096
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
@@ -11,12 +11,12 @@ lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/checks.py,sha256=haYYIPhadKavGYEhh8YWAaWrPMcfzrpT2i6638f4xjQ,12933
-lcode/cli.py,sha256=WuQW4Ao_TbJ0HKFOaFtJnyjvv-lwGYRg_tb0vI-zIg0,51296
+lcode/cli.py,sha256=3HPENwGw8rufYAgfmCHVK4R3gkEU2uDfgUyF1gnadzw,51385
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/cloud.py,sha256=q5Dl5GuqWvKzBCIso-eh6yomvEOsnQ0LW8ZgaAGwBxc,2131
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
-lcode/comfy.py,sha256=tCXSWH9Lk0MsU6031-a6LSOTNSZ1h9G3ZvFwh3d_LPo,26357
-lcode/config.py,sha256=EwMp3h0kHoLqHJc1sGCsXYjzj79gpg2HgMhGz1Ol1q0,13569
+lcode/comfy.py,sha256=SpIoY9fSvtm1TVtHTkUZ5W59RG55vtMncI-bRogqGBY,26490
+lcode/config.py,sha256=F7CRPdlqW6i9CSapqeU83ClOHOsf-Mxx1sWGXRYI1ac,13861
 lcode/context.py,sha256=wgK16ZcNNnq4ngHx0EmtyKHDFTImciGEmtC5NP8tKJQ,20435
 lcode/escalate.py,sha256=f-_6_moPaHi2kLuJw2JtkzvTkCl6DoBQgYBOCYLhunM,15120
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
@@ -24,13 +24,14 @@ lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/hooks.py,sha256=K0itOiAuH4rxndJ9gne_uCrqby6oWAzFPRrfB3tCq-E,9324
+lcode/imageopts.py,sha256=CQBvuEE-aK5C0wFqgTp1jxcpw-bOU2DJZpBYuqyA88I,7791
 lcode/jobs.py,sha256=P1P3FqI6EqL4LgdMX9YGZwCW0Bh5BRXFA_FnQxpHNjE,5618
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
 lcode/lsp.py,sha256=NtSW7xapv7fg2HAQLuYK1nwIqT7nG0LK1hiTpOmla_4,26086
 lcode/matching.py,sha256=2N3_qwKJ5gd8el2m_y_egKkFM9rsF1eUhYJcRCVIp98,14015
-lcode/media.py,sha256=laRxRuBPGoOK1e2W6cjNHySps8OO9N6UiauuAtGmlyk,11870
-lcode/media.toml,sha256=8vqFwqE8ECizDkUlnWGLfhcx94vEG1WfRCpJPHTi3UQ,3225
-lcode/media_catalog.py,sha256=rtJPS3S7ZgJjaY3HIRerhf4ciqzXt4BsOikoQavzPAI,13076
+lcode/media.py,sha256=FHvghSTDsJxXhhpivdlpHrm4FyLEH7HeG2StHPo7bj0,19012
+lcode/media.toml,sha256=Lv82r8YIA8CFEybXYV3qHtKGYJDk9hCflVXBG_xlfe0,3545
+lcode/media_catalog.py,sha256=y7kR4hzLW6b4tRQjk7b1_Oqq7zc5SWEG7Wux7pksCXI,13716
 lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
 lcode/modes.py,sha256=Ke_mEeYF_SskbVUXMpJMeV5d5fFEQ-Vb-MKp4SIvT0Y,4990
@@ -38,16 +39,17 @@ lcode/notify.py,sha256=uieDeXe7XwuVHjOk4tqVyZEW_85XWkoWQmFOWEf77oc,1538
 lcode/ollama.py,sha256=xFHU2XW47ANJ34-1aeSMQVj28GhqcWiFi6zASH9FiYY,8053
 lcode/permissions.py,sha256=q7CjDsc_Xrblw7t3_BbxA5LUjxFSswGs1RiJmtMi0po,12288
 lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
+lcode/preview.py,sha256=ATzEs6yaI1__bfo2_juWznrTDXUD4QTc_aQMPRCytgA,6253
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=OTrPdb6BKArDLQEgHaXmJZ-tIFsY_1bk4P0wzzANKLY,5964
-lcode/repl.py,sha256=Jjs45rvONRX2F3hx9Q-o3WkcepC_rKIqOE9okdlhNe8,62649
+lcode/repl.py,sha256=c_XpqiOfQjnQ6Ng1Zff3yqBOb5QJrlzQxDnHo6P_2d4,67500
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=B9pwqG6yx5aQD2M5xyQ-bMnYmhD7fv3wCVw_X6VIeAo,7012
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
 lcode/sandbox.py,sha256=u_pkrVRXhCGhh-wFDPwuZ3jGG7UeXxXRAeBNsm37ZvE,8608
 lcode/screenshots.py,sha256=pmrw_tp8eXzNyCZa5uot5rTgsxqsi3AdmkGn-XF9saY,57056
 lcode/secretscan.py,sha256=6Euvfk2gCtK7lZbuQD84zgWuSECi6OnSw8V5rFu1tfU,13575
-lcode/sessions.py,sha256=ojkpP453JyIll8_iFeJgW4BG4Zz2FKMRsLiij6spiTo,4185
+lcode/sessions.py,sha256=ri3MZXGzkbMyVmMm9sZlYc0HWh56ORnRVch2mA9N16w,4272
 lcode/steer.py,sha256=0vaqLxgRKgC0yGp8xoQfV1f9VEOzH3U4rCIb74eFnZ8,12127
 lcode/subagents.py,sha256=thR2ZzFZ1DeoAf0Ctr_oeKjYajhvd3uRs2kGdw6LlJM,29349
 lcode/tools.py,sha256=lpCIlaabydbmutaXWuOZWS4X-Z_7aIsyNUQdHJzkSC4,68902
@@ -74,8 +76,8 @@ lcode/servers/xai.py,sha256=h2emAvHSnkuB9WmJInlynsDhvxJwNVD2AHFX7vqMXNc,13627
 lcode/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lcode/workflows/flux2-klein-4b-t2i.json,sha256=yGrYDT8pG2bns9DS1JavhlX5fwhDgIKfAwrHrRCyE8k,1788
 lcode/workflows/z-image-turbo-t2i.json,sha256=sHsL7xnnuULOuWGYlQrDl4jOTySdAmb2T82c_cChv0s,1585
-lcode_cli-0.41.0.dist-info/METADATA,sha256=MitknSeSrdiXm2qjDMKu5eT_xBdeAcFIqxT9oEfvwhM,13386
-lcode_cli-0.41.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.41.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.41.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.41.0.dist-info/RECORD,,
+lcode_cli-0.42.0.dist-info/METADATA,sha256=k7PWFqR8Oqms3gNa4-HR6NMUUVSsfS2eupoJvVdPO0w,13386
+lcode_cli-0.42.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.42.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.42.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.42.0.dist-info/RECORD,,