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

lcode/__init__.py

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

lcode/agent.py

@@ -380,7 +380,8 @@ class Agent:
 
         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.last_request: dict | None = None  # what /again repeats (lcode.media.redo)
+        self.image_refs: list[str] = []  # images every next request follows (/use)
         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
@@ -697,7 +698,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()},
+            "media": {"results": self.media_results, "options": self.image_options.to_json(), "refs": self.image_refs},
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -751,6 +752,7 @@ class Agent:
         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.image_refs = [r for r in media.get("refs") or [] if isinstance(r, str)]
         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/cli.py

@@ -1107,9 +1107,13 @@ def cmd_media(args) -> None:
         f"ComfyUI at {server.url}" if running else (f"{install.path} (not running)" if install else "no ComfyUI found")
     )
     console.print(f"[dim]{hw.describe()} · {where} · image model: {cfg['image_model']}[/]\n")
-    for mode in ("image", "video"):
+    for mode in ("image", "video", "tool"):
         models = cat.for_mode(mode)
-        console.print(f"[bold]{mode.capitalize()} models[/]")
+        console.print(
+            "[bold]Tools for images[/] [dim](/upscale, /nobg)[/]"
+            if mode == "tool"
+            else f"[bold]{mode.capitalize()} models[/]"
+        )
         if not models:
             console.print(f"  [dim]{media.SOON[mode]}[/]\n")
             continue

lcode/comfy.py

@@ -336,8 +336,9 @@ def describe_rejection(r: requests.Response) -> str:
     lines = [str((data.get("error") or {}).get("message") or "ComfyUI refused the workflow")]
     for node, info in (data.get("node_errors") or {}).items():
         for err in info.get("errors", [])[:3]:
-            detail = err.get("details") or err.get("message") or ""
-            lines.append(f"{info.get('class_type', 'node')} ({node}): {detail}")
+            message, detail = err.get("message") or "", err.get("details") or ""
+            why = f"{message}: {detail}" if message and detail and detail not in message else (detail or message)
+            lines.append(f"{info.get('class_type', 'node')} ({node}): {why}")
     return "; ".join(lines)
 
 

lcode/edits.py

@@ -0,0 +1,283 @@
+"""Image edits as changes to a ComfyUI workflow: reference images, inpainting through a mask, outpainting.
+
+A model that edits with reference latents (FLUX.2 klein) takes the images through its own text-to-image workflow:
+each image is scaled, encoded by the VAE and attached to both conditionings before the guider, and the instruction is
+the prompt. On top of that:
+
+- **Inpainting** keeps the original outside a mask: the edited picture is pasted into the original only where the
+  mask is white (with a soft edge).
+- **Outpainting** puts the image on a bigger canvas, lets the model fill the new border, and pastes the original back,
+  so it stays exactly as it was.
+"""
+
+from __future__ import annotations
+
+import re
+import struct
+from pathlib import Path
+
+BASE = 8000  # node ids lcode adds start here (the workflows' own are small numbers)
+SIZE_NODE = str(BASE + 9)
+IMAGE_TYPES = (".png", ".jpg", ".jpeg", ".webp", ".bmp")
+EXTEND_HINT = (
+    "Replace the blurry border around the sharp picture with sharp, detailed scenery that continues the picture "
+    "outward, matching its light, perspective and style. Keep the sharp middle exactly as it is. No frame, no bars."
+)
+
+
+class EditError(ValueError):
+    pass
+
+
+def node_of(graph: dict, class_type: str) -> str | None:
+    return next((nid for nid, node in graph.items() if node.get("class_type") == class_type), None)
+
+
+def save_node(graph: dict) -> str:
+    nid = node_of(graph, "SaveImage")
+    if nid is None:
+        raise EditError("the workflow saves no image")
+    return nid
+
+
+def load_images(graph: dict, names: list[str]) -> list[list]:
+    """LoadImage nodes for uploaded images; their IMAGE outputs."""
+    links = []
+    for k, name in enumerate(names):
+        nid = str(BASE + 100 + k)
+        graph[nid] = {"class_type": "LoadImage", "inputs": {"image": name}}
+        links.append([nid, 0])
+    return links
+
+
+def add_references(graph: dict, images: list[list], megapixels: float, size_from_first: bool) -> list:
+    """Attach the images as reference latents to the guider's positive and negative conditionings.
+
+    Each is scaled to `megapixels` first. With `size_from_first`, the picture made has the first image's size
+    (its width and height go to every node of the workflow that takes them). Returns the first scaled image.
+    """
+    guider = node_of(graph, "CFGGuider")
+    vae = node_of(graph, "VAELoader")
+    if guider is None or vae is None:
+        raise EditError("this workflow can't take reference images")
+    positive, negative = graph[guider]["inputs"]["positive"], graph[guider]["inputs"]["negative"]
+    first = None
+    for k, image in enumerate(images):
+        scale, encode, ref_pos, ref_neg = (str(BASE + 10 * (k + 1) + i) for i in range(4))
+        graph[scale] = {
+            "class_type": "ImageScaleToTotalPixels",
+            "inputs": {"image": image, "upscale_method": "lanczos", "megapixels": megapixels, "resolution_steps": 16},
+        }
+        graph[encode] = {"class_type": "VAEEncode", "inputs": {"pixels": [scale, 0], "vae": [vae, 0]}}
+        graph[ref_pos] = {"class_type": "ReferenceLatent", "inputs": {"conditioning": positive, "latent": [encode, 0]}}
+        graph[ref_neg] = {"class_type": "ReferenceLatent", "inputs": {"conditioning": negative, "latent": [encode, 0]}}
+        positive, negative = [ref_pos, 0], [ref_neg, 0]
+        first = first or [scale, 0]
+    graph[guider]["inputs"]["positive"], graph[guider]["inputs"]["negative"] = positive, negative
+    if size_from_first and first:
+        set_size(graph, first)
+    return first
+
+
+def set_size(graph: dict, image: list) -> None:
+    """The picture made takes `image`'s size: its width and height go to every workflow node that takes them."""
+    graph[SIZE_NODE] = {"class_type": "GetImageSize", "inputs": {"image": image}}
+    for nid, node in graph.items():
+        if nid.isdigit() and int(nid) >= BASE:
+            continue  # lcode's own nodes keep their sizes
+        inputs = node.get("inputs", {})
+        for key, out in (("width", 0), ("height", 1)):
+            if key in inputs and not isinstance(inputs[key], list):
+                inputs[key] = [SIZE_NODE, out]
+
+
+def scale_to(graph: dict, image: list, megapixels: float) -> list:
+    nid = str(BASE + 301)
+    graph[nid] = {
+        "class_type": "ImageScaleToTotalPixels",
+        "inputs": {"image": image, "upscale_method": "lanczos", "megapixels": megapixels, "resolution_steps": 16},
+    }
+    return [nid, 0]
+
+
+def mask_from_file(graph: dict, mask_name: str) -> list:
+    """The user's mask image (white: change), at the picture's size, with a soft edge."""
+    if SIZE_NODE not in graph:
+        raise EditError("inpainting needs the picture at the original's size")
+    load, to_image, scale, blur, to_mask = (str(BASE + 200 + i) for i in range(5))
+    graph[load] = {"class_type": "LoadImageMask", "inputs": {"image": mask_name, "channel": "red"}}
+    graph[to_image] = {"class_type": "MaskToImage", "inputs": {"mask": [load, 0]}}
+    graph[scale] = {
+        "class_type": "ImageScale",
+        "inputs": {"image": [to_image, 0], "upscale_method": "bilinear", "width": [SIZE_NODE, 0],
+                   "height": [SIZE_NODE, 1], "crop": "disabled"},
+    }  # fmt: skip
+    graph[blur] = {"class_type": "ImageBlur", "inputs": {"image": [scale, 0], "blur_radius": 8, "sigma": 4.0}}
+    graph[to_mask] = {"class_type": "ImageToMask", "inputs": {"image": [blur, 0], "channel": "red"}}
+    return [to_mask, 0]
+
+
+def mask_scaled(graph: dict, mask: list, megapixels: float) -> list:
+    """A mask brought to the same size as an image scaled to `megapixels` (outpainting's border)."""
+    to_image, scale, to_mask = (str(BASE + 310 + i) for i in range(3))
+    graph[to_image] = {"class_type": "MaskToImage", "inputs": {"mask": mask}}
+    graph[scale] = {
+        "class_type": "ImageScaleToTotalPixels",
+        "inputs": {"image": [to_image, 0], "upscale_method": "bilinear", "megapixels": megapixels,
+                   "resolution_steps": 16},
+    }  # fmt: skip
+    graph[to_mask] = {"class_type": "ImageToMask", "inputs": {"image": [scale, 0], "channel": "red"}}
+    return [to_mask, 0]
+
+
+def sample_inside(graph: dict, image: list, mask: list) -> None:
+    """Start from the image itself and let the sampler change only what the mask covers."""
+    sampler = node_of(graph, "SamplerCustomAdvanced") or node_of(graph, "KSampler")
+    vae = node_of(graph, "VAELoader")
+    if sampler is None or vae is None:
+        raise EditError("this workflow can't paint inside a mask")
+    encode, masked = str(BASE + 400), str(BASE + 401)
+    graph[encode] = {"class_type": "VAEEncode", "inputs": {"pixels": image, "vae": [vae, 0]}}
+    graph[masked] = {"class_type": "SetLatentNoiseMask", "inputs": {"samples": [encode, 0], "mask": mask}}
+    graph[sampler]["inputs"]["latent_image"] = [masked, 0]
+
+
+def paste(graph: dict, destination: list, source: list, mask: list) -> None:
+    """The saved picture becomes `destination` with `source` pasted where the mask is white."""
+    save = save_node(graph)
+    nid = str(BASE + 500)
+    graph[nid] = {
+        "class_type": "ImageCompositeMasked",
+        "inputs": {"destination": destination, "source": source, "x": 0, "y": 0, "resize_source": False,
+                   "mask": mask},
+    }  # fmt: skip
+    graph[save]["inputs"]["images"] = [nid, 0]
+
+
+def inpaint(graph: dict, original: list, mask_name: str) -> None:
+    """Change only where the mask image is white: sampled there from the original, then pasted into it."""
+    mask = mask_from_file(graph, mask_name)
+    sample_inside(graph, original, mask)
+    paste(graph, original, graph[save_node(graph)]["inputs"]["images"], mask)
+
+
+def pad_canvas(graph: dict, image: list, pads: tuple[int, int, int, int]) -> tuple[list, list]:
+    """Outpainting's canvas, bigger by `pads` (left, top, right, bottom); (canvas, mask of the new border).
+
+    The border starts as a blurred, stretched copy of the image rather than flat grey: a fast model keeps a little of
+    what it starts from, and grey would show.
+    """
+    pad, size, stretched, blurred, canvas = (str(BASE + 300 + i) for i in (0, 2, 3, 4, 5))
+    left, top, right, bottom = pads
+    graph[pad] = {
+        "class_type": "ImagePadForOutpaint",
+        "inputs": {"image": image, "left": left, "top": top, "right": right, "bottom": bottom, "feathering": 48},
+    }
+    graph[size] = {"class_type": "GetImageSize", "inputs": {"image": [pad, 0]}}
+    graph[stretched] = {
+        "class_type": "ImageScale",
+        "inputs": {"image": image, "upscale_method": "bilinear", "width": [size, 0], "height": [size, 1],
+                   "crop": "disabled"},
+    }  # fmt: skip
+    graph[blurred] = {"class_type": "ImageBlur", "inputs": {"image": [stretched, 0], "blur_radius": 31, "sigma": 10.0}}
+    graph[canvas] = {
+        "class_type": "ImageCompositeMasked",
+        "inputs": {"destination": [blurred, 0], "source": image, "x": left, "y": top, "resize_source": False},
+    }
+    return [canvas, 0], [pad, 1]
+
+
+def outpaint(graph: dict, canvas_scaled: list, border: list, megapixels: float) -> None:
+    """Fill only the new border, sampled around the original, and keep the original exactly as it was."""
+    mask = mask_scaled(graph, border, megapixels)
+    sample_inside(graph, canvas_scaled, mask)
+    invert = str(BASE + 501)
+    graph[invert] = {"class_type": "InvertMask", "inputs": {"mask": mask}}
+    paste(graph, graph[save_node(graph)]["inputs"]["images"], canvas_scaled, [invert, 0])
+
+
+# ----------------------------------------------------------------------------- sizes and arguments
+
+
+def image_size(path: Path) -> tuple[int, int]:
+    """Width and height from a PNG, JPEG or WebP file's header."""
+    data = path.read_bytes()[:65536]
+    if data.startswith(b"\x89PNG\r\n\x1a\n"):
+        return struct.unpack(">II", data[16:24])
+    if data[:2] == b"\xff\xd8":
+        i = 2
+        while i + 9 < len(data):
+            if data[i] != 0xFF:
+                i += 1
+                continue
+            marker = data[i + 1]
+            length = struct.unpack(">H", data[i + 2 : i + 4])[0]
+            if marker in (0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF):
+                h, w = struct.unpack(">HH", data[i + 5 : i + 9])
+                return w, h
+            i += 2 + length
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        kind = data[12:16]
+        if kind == b"VP8X":
+            return int.from_bytes(data[24:27], "little") + 1, int.from_bytes(data[27:30], "little") + 1
+        if kind == b"VP8 ":
+            w, h = struct.unpack("<HH", data[26:30])
+            return w & 0x3FFF, h & 0x3FFF
+        if kind == b"VP8L":
+            bits = int.from_bytes(data[21:25], "little")
+            return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
+    raise EditError(f"can't read the size of {path.name}: use a PNG, JPEG or WebP image")
+
+
+def pads_for_ratio(width: int, height: int, ratio: str) -> tuple[int, int, int, int]:
+    """Borders that bring the image to an aspect ratio (a:b), split evenly, in steps of 8 pixels."""
+    m = re.fullmatch(r"(\d{1,2}):(\d{1,2})", ratio)
+    if not m or not int(m.group(1)) or not int(m.group(2)):
+        raise EditError("the shape to extend to is a ratio, e.g. --ar 16:9")
+    a, b = int(m.group(1)), int(m.group(2))
+    if abs(width / height - a / b) < 0.01:
+        raise EditError(f"it's {a}:{b} already: choose another shape, or --left/--right/--top/--bottom pixels")
+    if width / height < a / b:  # wider
+        extra = round(height * a / b) - width
+        left = (extra // 2) // 8 * 8
+        return left, 0, (extra - left + 7) // 8 * 8, 0
+    extra = round(width * b / a) - height
+    top = (extra // 2) // 8 * 8
+    return 0, top, 0, (extra - top + 7) // 8 * 8
+
+
+EXTEND_FLAG = re.compile(r"--(left|top|right|bottom)\s+(\d+)")
+
+
+def parse_extend(text: str, width: int, height: int) -> tuple[tuple[int, int, int, int], str]:
+    """`/extend` arguments: --ar 16:9, or --left/--top/--right/--bottom pixels; the rest describes the new part."""
+    sides = {k: int(v) for k, v in EXTEND_FLAG.findall(text)}
+    text = EXTEND_FLAG.sub(" ", text)
+    ratio = re.search(r"--(?:ar|size)\s+(\S+)", text)
+    text = re.sub(r"--(?:ar|size)\s+\S+", " ", text)
+    if ratio and sides:
+        raise EditError("extend by a shape (--ar 16:9) or by sides (--left 256), not both")
+    if ratio:
+        from lcode.imageopts import SIZES
+
+        pads = pads_for_ratio(width, height, SIZES.get(ratio.group(1), ratio.group(1)))
+    elif sides:
+        pads = tuple((sides.get(k, 0) + 7) // 8 * 8 for k in ("left", "top", "right", "bottom"))
+        if any(p > 2048 for p in pads):
+            raise EditError("a side grows by at most 2048 pixels")
+    else:
+        pads = pads_for_ratio(width, height, "16:9" if width <= height * 16 / 9 - 1 else "1:1")
+    return pads, " ".join(text.split())
+
+
+REFERENCE = re.compile(r'(?:^|(?<=\s))@(#\d+|"[^"]+"|\S+)')
+
+
+def split_references(text: str) -> tuple[str, list[str]]:
+    """The prompt without its @references, and the references (#3, or file paths) in order."""
+    refs = [m.group(1).strip('"') for m in REFERENCE.finditer(text)]
+    return " ".join(REFERENCE.sub(" ", text).split()), refs
+
+
+def is_image(path: Path) -> bool:
+    return path.suffix.lower() in IMAGE_TYPES

lcode/media.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import os
 import random
+import re
 import shutil
 import subprocess
 import sys
@@ -20,7 +21,7 @@ from typing import TYPE_CHECKING
 import requests
 from rich.text import Text
 
-from lcode import comfy, imageopts, preview
+from lcode import comfy, edits, imageopts, preview
 from lcode import media_catalog as catalog
 
 if TYPE_CHECKING:
@@ -252,39 +253,107 @@ def thumbnail(server: comfy.Server, outputs: dict) -> bytes:
     return b""
 
 
+SIZE_FLAG = re.compile(r"(?:^|\s)--?(ar|aspect|size)\b")
+MASK_FLAG = re.compile(r'(?:^|\s)--mask\s+("[^"]+"|\S+)')
+
+
 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."""
+    """A typed request: its @references (images to edit or follow), --mask, and flags (--n 4 --ar 16:9 …, over
+    the session's /options), then the images."""
+    mask = None
+    m = MASK_FLAG.search(text)
+    if m:
+        mask = resolve(agent, m.group(1).strip('"'))
+        text = MASK_FLAG.sub(" ", text)
+    text, refs = edits.split_references(text)
     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)
+    sources = [resolve(agent, ref) for ref in refs] + [Path(p) for p in agent.image_refs if Path(p).exists()]
+    if mask and not sources:
+        raise MediaError("--mask needs the image it masks: @photo.png --mask mask.png make the sky purple")
+    job = {"kind": "edit" if sources else "image", "prompt": prompt, "options": options,
+           "sources": [str(p) for p in sources], "mask": str(mask) if mask else None, "pads": None,
+           "keep_shape": not SIZE_FLAG.search(text)}  # fmt: skip
+    return redo(agent, job, cancelled, ask)
 
 
-def make(
-    agent: Agent,
-    prompt: str,
-    options: imageopts.Options,
-    cancelled: Callable[[], bool] = lambda: False,
-    ask: Callable[[str], bool] | None = None,
+def redo(
+    agent: Agent, job: dict, 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.")
+    """Make what `job` describes (also what /again and /vary repeat): images, or edits of its sources."""
+    prompt, options = job["prompt"], job["options"]
+    if not prompt.strip() and job["kind"] in ("image", "edit") and not job.get("pads"):
+        raise MediaError("Describe the image you want." if job["kind"] == "image" else "Say what to change.")
     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)
+    agent.last_request = job
     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))
+        one = replace(options, seed=seed, n=1)
+        if job["kind"] == "image":
+            made.append(generate_image(agent, prompt, cancelled, ask, one, label))
+        else:
+            made.append(edit_image(agent, job, one, cancelled, ask, label))
     return made
 
 
+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."""
+    job = {"kind": "image", "prompt": prompt, "options": options, "sources": [], "mask": None, "pads": None}
+    return redo(agent, job, cancelled, ask)
+
+
+def resolve(agent: Agent, ref: str) -> Path:
+    """An image the user points at: #3 (a result) or a file path."""
+    ref = ref.strip()
+    if re.fullmatch(r"#?\d+", ref) and ref.startswith("#"):
+        return Path(result(agent, ref)["path"])
+    path = Path(ref).expanduser()
+    path = path if path.is_absolute() else agent.cwd / path
+    if not path.is_file():
+        raise MediaError(f"There's no image {ref}: give a file (@photo.png) or a result's number (@#3).")
+    if not edits.is_image(path):
+        raise MediaError(f"{ref} isn't an image lcode can use: PNG, JPEG, WebP or BMP.")
+    return path
+
+
+@dataclass
+class Plan:
+    """A job ready for ComfyUI: the graph, what to call it, and what goes in its JSON file."""
+
+    model: catalog.MediaModel
+    workflow: comfy.Workflow
+    graph: dict
+    meta: dict
+    prompt: str
+    seed: int
+    options: imageopts.Options
+    kind: str = "image"
+    sources: list[str] = field(default_factory=list)
+    job: dict = field(default_factory=dict)  # what made it, for /vary (prompt, sources, mask, pads)
+    stem: str = ""  # the file name without its extension, when not the time and the prompt
+
+
+def prepare(agent: Agent, ask, cancelled) -> comfy.Server:
+    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.")
+    return server
+
+
 def generate_image(
     agent: Agent,
     prompt: str,
@@ -298,13 +367,10 @@ def generate_image(
     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.")
+    server = prepare(agent, ask, cancelled)
     model = current(agent)
     files = ensure_installed(agent, model, server, ask)
     workflow = comfy.load_workflow(model.workflow)
-    free_gpu(agent)
     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)
@@ -316,15 +382,145 @@ def generate_image(
         values["negative"] = options.negative
     graph = comfy.fill(workflow.graph, values)
     add_thumbnail(graph, width, height)
+    meta = describe_job(model, workflow, prompt, text, seed, values, options, files)
+    return run_plan(agent, server, Plan(model, workflow, graph, meta, prompt, seed, options), cancelled, label)
+
+
+def edit_image(
+    agent: Agent,
+    job: dict,
+    options: imageopts.Options,
+    cancelled: Callable[[], bool] = lambda: False,
+    ask: Callable[[str], bool] | None = None,
+    label: str = "",
+) -> Made:
+    """An edit of the job's source images: by instruction, through a mask (inpainting), or on a bigger canvas
+    (outpainting). The first source sets the shape unless the request gave one."""
+    server = prepare(agent, ask, cancelled)
+    chosen = current(agent)
+    model = catalog.load().editor(chosen)
+    if model is None:
+        raise MediaError("None of lcode's image models edits pictures yet.")
+    if model.key != chosen.key:
+        agent.say(f"{chosen.name} doesn't edit pictures: {model.name} makes this one.")
+    files = ensure_installed(agent, model, server, ask)
+    workflow = comfy.load_workflow(model.workflow)
+    sources = [Path(p) for p in job["sources"]]
+    try:
+        names = [server.upload(p) for p in sources]
+        mask_name = server.upload(Path(job["mask"])) if job.get("mask") else None
+        first_w, first_h = edits.image_size(sources[0])
+    except (comfy.ComfyError, OSError, edits.EditError) as e:
+        raise MediaError(f"Couldn't hand the images to ComfyUI: {e}") from e
+    pads = job.get("pads")
+    if pads:
+        first_w, first_h = first_w + pads[0] + pads[2], first_h + pads[1] + pads[3]
+    seed = options.seed if options.seed is not None else random.randrange(2**32)
+    steps, megapixels = model.preset(options.quality)
+    keep_shape = bool(job.get("keep_shape", True) or job.get("mask") or pads)
+    ratio = f"{first_w}x{first_h}" if keep_shape else options.size
+    width, height = shape(ratio, megapixels)
+    instruction = job["prompt"] if not pads else f"{edits.EXTEND_HINT} {job['prompt']}".strip()
+    text = imageopts.styled(instruction, 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)
+    try:
+        links = edits.load_images(graph, names)
+        if pads:  # the original is the reference; the picture is the padded canvas, painted only in its border
+            canvas, border = edits.pad_canvas(graph, links[0], pads)
+            canvas = edits.add_references(graph, [canvas, *links[1:]], megapixels, size_from_first=True)
+            edits.outpaint(graph, canvas, border, megapixels)
+        else:
+            first = edits.add_references(graph, links, megapixels, size_from_first=keep_shape)
+            if mask_name:
+                edits.inpaint(graph, first, mask_name)
+    except edits.EditError as e:
+        raise MediaError(f"{model.name} can't do that edit: {e}") from e
+    add_thumbnail(graph, width, height)
+    meta = describe_job(model, workflow, job["prompt"], text, seed, values, options, files)
+    meta.update(
+        {"edit_of": [shown(agent, p) for p in sources], "mask": shown(agent, Path(job["mask"])) if job.get("mask")
+         else "", "extend": list(pads) if pads else []}
+    )  # fmt: skip
+    kind = "extend" if pads else ("inpaint" if job.get("mask") else "edit")
+    remembered = {k: job.get(k) for k in ("kind", "prompt", "sources", "mask", "pads", "keep_shape")}
+    plan = Plan(model, workflow, graph, meta, job["prompt"] or "extended", seed, options, kind, job["sources"],
+                remembered, f"{sources[0].stem}-extended" if pads else "")  # fmt: skip
+    return run_plan(agent, server, plan, cancelled, label)
+
+
+def apply_tool(
+    agent: Agent,
+    task: str,
+    source: Path,
+    scale: int = 2,
+    cancelled: Callable[[], bool] = lambda: False,
+    ask: Callable[[str], bool] | None = None,
+) -> Made:
+    """/upscale and /nobg: a tool model on one image (no seed, no prompt)."""
+    server = prepare(agent, ask, cancelled)
+    model = catalog.load().tool(task)
+    files = ensure_installed(agent, model, server, ask)
+    workflow = comfy.load_workflow(model.workflow)
+    try:
+        name = server.upload(source)
+        width, height = edits.image_size(source)
+    except (comfy.ComfyError, OSError, edits.EditError) as e:
+        raise MediaError(f"Couldn't hand the image to ComfyUI: {e}") from e
+    values = {**workflow.defaults, **files, "image": name}
+    if task == "upscale":
+        values["scale_by"] = scale / 4  # Real-ESRGAN makes 4 times the size; scaled back for 2
+        width, height = width * scale, height * scale
+    graph = comfy.fill(workflow.graph, values)
+    add_thumbnail(graph, width, height)
+    what = f"upscaled {scale}×" if task == "upscale" else "background removed"
+    prompt = f"{what}: {shown(agent, source)}"
     meta = {
+        "prompt": prompt,
+        "model": model.name,
+        "model_key": model.key,
+        "workflow": workflow.key,
+        "source": shown(agent, source),
+        "files": files,
+        "created": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
+    }
+    suffix = f"upscaled-{scale}x" if task == "upscale" else "nobg"
+    plan = Plan(model, workflow, graph, meta, prompt, 0, imageopts.Options(), task, [str(source)], {},
+                f"{source.stem}-{suffix}")  # fmt: skip
+    return run_plan(agent, server, plan, cancelled, "")
+
+
+def shape(size: str, megapixels: float) -> tuple[int, int]:
+    """Pixels for an edit: a ratio or a source's own pixels, brought to the quality's megapixels."""
+    m = edits.re.fullmatch(r"(\d+)x(\d+)", size)
+    if m:
+        w, h = int(m.group(1)), int(m.group(2))
+        return imageopts.dimensions(f"{w}:{h}" if w < 100 and h < 100 else ratio_of(w, h), megapixels)
+    return imageopts.dimensions(size, megapixels)
+
+
+def ratio_of(width: int, height: int) -> str:
+    """A ratio string close to width:height, with small numbers (for imageopts.dimensions)."""
+    from fractions import Fraction
+
+    f = Fraction(width, height).limit_denominator(32)
+    return f"{f.numerator}:{f.denominator}" if f.numerator < 100 else f"{round(width / height * 16)}:16"
+
+
+def describe_job(model, workflow, prompt, text, seed, values, options, files) -> dict:
+    return {
         "prompt": prompt,
         "model": model.name,
         "model_key": model.key,
         "workflow": workflow.key,
         "seed": seed,
-        "width": width,
-        "height": height,
-        "steps": values["steps"],
+        "width": values["width"],
+        "height": values["height"],
+        "steps": values.get("steps"),
         "quality": options.quality,
         "style": options.style,
         "negative": options.negative if model.negative else "",
@@ -332,18 +528,22 @@ def generate_image(
         "files": files,
         "created": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
     }
+
+
+def run_plan(agent: Agent, server: comfy.Server, plan: Plan, cancelled, label: str) -> Made:
+    """Queue the plan, follow it, save what it made, number it, show it."""
+    free_gpu(agent)
     out = folder(agent)
-    stem = f"{time.strftime('%Y%m%d-%H%M%S')}-{comfy.slug(prompt)}"
-    line = Line(
-        f"{model.name} ({label})" if label else model.name, "Esc or Ctrl+C cancels" if agent.interactive else ""
-    )
+    stem = plan.stem or f"{time.strftime('%Y%m%d-%H%M%S')}-{comfy.slug(plan.prompt)}"
+    hint = "Esc or Ctrl+C cancels" if agent.interactive else ""
+    line = Line(f"{plan.model.name} ({label})" if label else plan.model.name, hint)
     job = {"id": ""}
-    labels = {**workflow.labels, THUMB_NODES[0]: "making the preview", THUMB_NODES[1]: "making the preview"}
+    labels = {**plan.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":
             job["id"] = event.prompt_id
-            comfy.remember(event.prompt_id, server.url, out, stem, meta)
+            comfy.remember(event.prompt_id, server.url, out, stem, plan.meta)
         elif event.kind == "waiting":
             line.doing = f"waiting: {event.value} job(s) ahead in ComfyUI's queue"
         elif event.kind == "node":
@@ -354,7 +554,7 @@ def generate_image(
 
     try:
         with agent.console.status(line, spinner="dots"):
-            prompt_id, outputs = comfy.run(server, graph, on_event, cancelled)
+            prompt_id, outputs = comfy.run(server, plan.graph, on_event, cancelled)
     except (KeyboardInterrupt, comfy.Cancelled) as e:
         if job["id"]:
             if isinstance(e, KeyboardInterrupt):  # run() cancels it in ComfyUI itself for Esc
@@ -366,15 +566,21 @@ def generate_image(
             comfy.forget(job["id"])
         raise MediaError(str(e)) from e
     try:
-        saved = comfy.save(server, outputs, out, stem, {**meta, "comfyui_prompt_id": prompt_id})
+        saved = comfy.save(server, outputs, out, stem, {**plan.meta, "comfyui_prompt_id": prompt_id})
     except (comfy.ComfyError, OSError) as e:
         raise MediaError(f"ComfyUI made it, but lcode couldn't save it: {e}") from e
     comfy.forget(prompt_id)
     if not saved:
         raise MediaError("ComfyUI finished but returned no image.")
-    made = Made(saved, model.name, seed, width, height, time.monotonic() - line.started, prompt)
+    width, height = plan.meta.get("width") or 0, plan.meta.get("height") or 0
+    if plan.kind != "image":  # an edit's or a tool's size comes from its source: read what ComfyUI made
+        try:
+            width, height = edits.image_size(saved[0])
+        except (OSError, edits.EditError):
+            pass
+    made = Made(saved, plan.model.name, plan.seed, width, height, time.monotonic() - line.started, plan.prompt)
     made.thumbnail = thumbnail(server, outputs)
-    made.numbers = record(agent, made, meta, options)
+    made.numbers = record(agent, made, plan)
     show(agent, made)
     return made
 
@@ -382,7 +588,7 @@ def generate_image(
 # ----------------------------------------------------------------------------- results: numbered, shown, opened
 
 
-def record(agent: Agent, made: Made, meta: dict, options: imageopts.Options) -> list[int]:
+def record(agent: Agent, made: Made, plan: Plan) -> list[int]:
     """Number the images in the session's gallery, with what made them (for /gallery, /vary, /open)."""
     numbers = []
     for path in made.files:
@@ -396,9 +602,14 @@ def record(agent: Agent, made: Made, meta: dict, options: imageopts.Options) ->
                 "seed": made.seed,
                 "width": made.width,
                 "height": made.height,
-                "steps": meta["steps"],
+                "steps": plan.meta.get("steps"),
                 "seconds": round(made.seconds, 1),
-                "options": options.to_json(),
+                "options": plan.options.to_json(),
+                "kind": plan.kind,
+                "sources": plan.sources,
+                "mask": plan.meta.get("mask", ""),
+                "extend": plan.meta.get("extend", []),
+                "job": plan.job,
             }
         )
         numbers.append(number)
@@ -406,14 +617,13 @@ def record(agent: Agent, made: Made, meta: dict, options: imageopts.Options) ->
 
 
 def show(agent: Agent, made: Made) -> None:
+    seed = f" · seed {made.seed}" if made.seed else ""  # tools (upscaling, cut-outs) have 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 {made.seed} · {made.seconds:.1f} s", style="dim"
-            )
+            + Text(f"  {made.width}×{made.height} · {made.model}{seed} · {made.seconds:.1f} s", style="dim")
         )
     if made.files:
         show_preview(agent, made.files[0], made.thumbnail)

lcode/media.toml

@@ -8,7 +8,7 @@
 #   alternatives  other file names that do the same job: an installed one is used instead of downloading
 #
 # [models.<key>]  one model.
-#   mode          image or video
+#   mode          image, video, or tool (upscaling, background removal: used by image mode's commands)
 #   tasks         text-to-image, edit, inpaint, text-to-video, image-to-video, first-last-frame, reference-to-video, audio
 #   workflow      lcode's workflow for it (lcode/workflows/<workflow>.json)
 #   files         role -> file key; the workflow's $role placeholders get the file names
@@ -17,6 +17,8 @@
 #   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)
+#   edit          how it edits images: "reference-latent" (its text-to-image workflow, given the images as
+#                 reference latents on both conditionings); absent: it doesn't edit
 
 [files.flux-2-klein-4b-fp8]
 folder = "diffusion_models"
@@ -51,12 +53,25 @@ name = "ae.safetensors"
 url = "https://huggingface.co/Comfy-Org/z_image_turbo/resolve/main/split_files/vae/ae.safetensors"
 gb = 0.34
 
+[files.birefnet]
+folder = "background_removal"
+name = "birefnet.safetensors"
+url = "https://huggingface.co/Comfy-Org/BiRefNet/resolve/main/background_removal/birefnet.safetensors"
+gb = 0.44
+
+[files.realesrgan-x4]
+folder = "upscale_models"
+name = "RealESRGAN_x4plus.safetensors"
+url = "https://huggingface.co/Comfy-Org/Real-ESRGAN_repackaged/resolve/main/RealESRGAN_x4plus.safetensors"
+gb = 0.07
+
 [models.flux2-klein-4b]
 name = "FLUX.2 klein 4B"
 mode = "image"
 publisher = "Black Forest Labs"
 license = "Apache 2.0"
-tasks = ["text-to-image"]
+tasks = ["text-to-image", "edit", "references"]
+edit = "reference-latent"
 workflow = "flux2-klein-4b-t2i"
 files = { model = "flux-2-klein-4b-fp8", text_encoder = "qwen-3-4b", vae = "flux2-vae" }
 gpu_gb = 0.0
@@ -78,3 +93,23 @@ measured = "1024×1024: 17 s per image (1.9 s per step), 23 s for the first (RTX
 notes = "photorealistic, writes text well: 8 steps"
 quality = { fast = [6, 0.5], balanced = [8, 1.0], best = [9, 2.0] }
 negative = false
+
+[models.realesrgan-x4]
+name = "Real-ESRGAN x4"
+mode = "tool"
+publisher = "Xintao Wang et al."
+license = "BSD-3-Clause"
+tasks = ["upscale"]
+workflow = "upscale-esrgan"
+files = { model = "realesrgan-x4" }
+notes = "/upscale: 2× or 4× the pixels"
+
+[models.birefnet]
+name = "BiRefNet"
+mode = "tool"
+publisher = "ZhengPeng7"
+license = "MIT"
+tasks = ["remove-background"]
+workflow = "remove-background"
+files = { model = "birefnet" }
+notes = "/nobg: a transparent PNG"

lcode/media_catalog.py

@@ -69,6 +69,7 @@ class MediaModel:
     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
+    edit: str = ""  # how it edits images ("reference-latent"), or empty: it doesn't
 
     def preset(self, quality: str) -> tuple[int | None, float]:
         """(steps, megapixels) for a quality preset: None steps keeps the workflow's."""
@@ -110,6 +111,16 @@ class Catalog:
     def for_mode(self, mode: str) -> list[MediaModel]:
         return [m for m in self.models.values() if m.mode == mode]
 
+    def tool(self, task: str) -> MediaModel:
+        """The tool for a task (upscale, remove-background)."""
+        return next(m for m in self.models.values() if m.mode == "tool" and task in m.tasks)
+
+    def editor(self, preferred: MediaModel) -> MediaModel | None:
+        """A model that edits: the preferred one if it can, else the first image model that can."""
+        if preferred.edit:
+            return preferred
+        return next((m for m in self.for_mode("image") if m.edit), None)
+
     def find(self, wanted: str, mode: str | None = None) -> MediaModel | None:
         """A model by key or name (any case), or by its number in the mode's list."""
         candidates = self.for_mode(mode) if mode else list(self.models.values())
@@ -146,6 +157,7 @@ def load() -> Catalog:
             m.get("notes", ""),
             {name: (int(v[0]), float(v[1])) for name, v in (m.get("quality") or {}).items()},
             bool(m.get("negative", False)),
+            m.get("edit", ""),
         )
     return Catalog(files, models)
 

lcode/repl.py

@@ -84,6 +84,11 @@ COMMANDS = {
     "/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)",
+    "/edit": "Image mode: change an image by instruction, e.g. /edit 3 make the sky purple (@photo.png: references)",
+    "/use": "Image mode: images the next requests follow, e.g. /use 3 or /use photo.png (/use off)",
+    "/extend": "Image mode: outpaint an image to a shape or by sides, e.g. /extend 3 --ar 16:9 (or --left 256)",
+    "/upscale": "Image mode: 2 or 4 times the pixels, e.g. /upscale 3 4",
+    "/nobg": "Image mode: remove the background (a transparent PNG), e.g. /nobg 3",
     "/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",
@@ -1186,7 +1191,7 @@ 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"):
+    elif cmd in IMAGE_COMMANDS:
         image_command(agent, cmd, arg)
     elif cmd == "/permissions":
         if arg in PERMISSION_MODES:
@@ -1401,9 +1406,16 @@ def respond(agent: Agent, line: str) -> None:
     run_safely(agent, line)
 
 
+IMAGE_COMMANDS = ("/options", "/again", "/vary", "/gallery", "/open", "/edit", "/use", "/extend", "/upscale", "/nobg")
+NUMBER = re.compile(r"^#?(\d+)$")
+
+
 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
+    """Image mode's commands: /options, follow-ups on results (/again, /vary, /edit, /extend, /upscale, /nobg),
+    references (/use), /gallery and /open."""
+    from dataclasses import replace
+
+    from lcode import edits, imageopts
 
     c = agent.console
     if cmd == "/options":
@@ -1424,41 +1436,96 @@ def image_command(agent: Agent, cmd: str, arg: str) -> None:
     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.[/]")
+    if agent.settings.mode != "image" and cmd != "/open":
+        c.print(f"[yellow]{cmd} works in image mode: /mode image.[/]")
         return
+    first, _, rest = arg.strip().partition(" ")
+    number = first if NUMBER.match(first) else ""
+    rest = rest if number else arg.strip()
     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.[/]")
+        if cmd == "/use":
+            use_references(agent, arg.strip())
             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))}[/]")
+        if cmd == "/again":
+            if agent.last_request is None:
+                c.print("[yellow]Nothing to do again yet: describe an image first.[/]")
+                return
+            job = dict(agent.last_request)
+            _, job["options"] = imageopts.parse(arg, imageopts.replace_seed(job["options"]))
+            make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
+            return
+        entry = media.result(agent, f"#{NUMBER.match(number).group(1)}" if number else "")
+        source = Path(entry["path"])
+        if cmd == "/open":
+            problem = media.open_file(source)
+            c.print(f"[yellow]{escape(problem)}[/]" if problem else f"[dim]Opened #{entry['n']}.[/]")
             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)
+        if cmd == "/vary":
+            job = dict(entry.get("job") or {"kind": "image", "sources": [], "mask": None, "pads": None})
+            if entry.get("kind") in ("upscale", "remove-background") or job["kind"] not in ("image", "edit"):
+                c.print(f"[yellow]#{entry['n']} is {escape(entry['prompt'])}: /vary the image it came from.[/]")
+                return
+            job["prompt"] = entry["prompt"] if job["kind"] == "image" else job.get("prompt", entry["prompt"])
+            options = imageopts.replace_seed(imageopts.Options.from_json(entry.get("options") or {}), n=4)
+            _, job["options"] = imageopts.parse(rest, options)
+            c.print(f"[dim]Variations of #{entry['n']}: {escape(entry['prompt'])}[/]")
+            make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
+            return
+        if cmd == "/edit":
+            text, refs = edits.split_references(rest)
+            instruction, options = imageopts.parse(text, imageopts.replace_seed(agent.image_options))
+            if not instruction:
+                c.print("[yellow]Say what to change: /edit 3 make the sky purple[/]")
+                return
+            sources = [str(source)] + [str(media.resolve(agent, r)) for r in refs]
+            job = {"kind": "edit", "prompt": instruction, "options": options, "sources": sources, "mask": None,
+                   "pads": None, "keep_shape": "--ar" not in rest and "--size" not in rest}  # fmt: skip
+            make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
+            return
+        if cmd == "/extend":
+            width, height = edits.image_size(source)
+            pads, text = edits.parse_extend(rest, width, height)
+            text, options = imageopts.parse(text, imageopts.replace_seed(agent.image_options, n=1))
+            job = {"kind": "edit", "prompt": text, "options": replace(options, size="1:1"), "sources": [str(source)],
+                   "mask": None, "pads": pads, "keep_shape": True}  # fmt: skip
+            grown = f"{width + pads[0] + pads[2]}×{height + pads[1] + pads[3]}"
+            c.print(f"[dim]Extending #{entry['n']} from {width}×{height} to {grown} before scaling.[/]")
+            make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
+            return
+        if cmd == "/upscale":
+            scale = rest.strip().lower().rstrip("x×") or "2"
+            if scale not in ("2", "4"):
+                c.print("[yellow]/upscale makes 2 or 4 times the size: /upscale 3 4[/]")
+                return
+            make_image(
+                agent, run=lambda cancel, ask: media.apply_tool(agent, "upscale", source, int(scale), cancel, ask)
+            )
+            return
+        if cmd == "/nobg":
+            make_image(
+                agent, run=lambda cancel, ask: media.apply_tool(agent, "remove-background", source, 2, cancel, ask)
+            )
+            return
+    except (media.MediaError, edits.EditError, imageopts.OptionError) as e:
+        c.print(f"[yellow]{escape(str(e))}[/]")
+
+
+def use_references(agent: Agent, arg: str) -> None:
+    """/use 3 @photo.png: images every next request follows (as references) until /use off."""
+    c = agent.console
+    if arg in ("off", "none", "clear"):
+        agent.image_refs = []
+        c.print("[dim]No reference images now.[/]")
+        return
+    if arg:
+        refs = [r.lstrip("@") for r in arg.split()]
+        paths = [media.resolve(agent, f"#{NUMBER.match(r).group(1)}" if NUMBER.match(r) else r) for r in refs]
+        agent.image_refs = [str(p) for p in paths]
+    if not agent.image_refs:
+        c.print("[dim]No reference images. /use 3 (or /use photo.png) makes the next requests follow one.[/]")
+        return
+    shown = ", ".join(media.shown(agent, Path(p)) for p in agent.image_refs)
+    c.print(f"References for the next requests: [bold]{escape(shown)}[/] [dim](/use off stops)[/]")
 
 
 def gallery(agent: Agent, everything: bool = False) -> None:
@@ -1493,8 +1560,9 @@ def gallery(agent: Agent, everything: bool = False) -> None:
         )
 
 
-def make_image(agent: Agent, prompt: str, options=None) -> None:
-    """Image mode: ComfyUI makes the images; Esc or Ctrl+C cancels them there too."""
+def make_image(agent: Agent, prompt: str = "", options=None, run=None) -> None:
+    """Image mode: ComfyUI makes the images (a request, or `run(cancelled, ask)`); 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
@@ -1505,7 +1573,9 @@ def make_image(agent: Agent, prompt: str, options=None) -> None:
 
     try:
         asking = ask if agent.interactive else None
-        if options is None:
+        if run is not None:
+            run(lambda: steering.pause, asking)
+        elif 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)

lcode/workflows/remove-background.json

@@ -0,0 +1,13 @@
+{
+  "source": "ComfyUI's template utility_birefnet_remove_background, in API format",
+  "defaults": {},
+  "labels": {"1": "loading the image", "2": "loading BiRefNet", "3": "finding the subject", "5": "cutting it out", "6": "saving"},
+  "graph": {
+    "1": {"class_type": "LoadImage", "inputs": {"image": "$image"}},
+    "2": {"class_type": "LoadBackgroundRemovalModel", "inputs": {"bg_removal_name": "$model"}},
+    "3": {"class_type": "RemoveBackground", "inputs": {"bg_removal_model": ["2", 0], "image": ["1", 0]}},
+    "4": {"class_type": "InvertMask", "inputs": {"mask": ["3", 0]}},
+    "5": {"class_type": "JoinImageWithAlpha", "inputs": {"image": ["1", 0], "alpha": ["4", 0]}},
+    "6": {"class_type": "SaveImage", "inputs": {"images": ["5", 0], "filename_prefix": "lcode/image"}}
+  }
+}

lcode/workflows/upscale-esrgan.json

@@ -0,0 +1,12 @@
+{
+  "source": "ComfyUI's template utility-gan_upscaler (for images), in API format",
+  "defaults": {"scale_by": 0.5},
+  "labels": {"1": "loading the image", "2": "loading the upscaler", "3": "upscaling", "4": "resizing", "5": "saving"},
+  "graph": {
+    "1": {"class_type": "LoadImage", "inputs": {"image": "$image"}},
+    "2": {"class_type": "UpscaleModelLoader", "inputs": {"model_name": "$model"}},
+    "3": {"class_type": "ImageUpscaleWithModel", "inputs": {"upscale_model": ["2", 0], "image": ["1", 0]}},
+    "4": {"class_type": "ImageScaleBy", "inputs": {"image": ["3", 0], "upscale_method": "lanczos", "scale_by": "$scale_by"}},
+    "5": {"class_type": "SaveImage", "inputs": {"images": ["4", 0], "filename_prefix": "lcode/image"}}
+  }
+}

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.42.0
+Version: 0.43.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.42.0.dist-info → lcode_cli-0.43.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-lcode/__init__.py,sha256=v3apJPFRjkc0xQqftHToQJR2cWw-oucwV0aezidZmyA,473
+lcode/__init__.py,sha256=SlAe74M7eoZyKxBXWVe_w72XGAaCfPj29sJG6lAuiSc,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=DmKlZ86NPzicwc_pXDEJ3_vgRwri2XknFq9M01f2Sgk,88527
+lcode/agent.py,sha256=RVf_gQLwkIYxItYduWB2O0aZu8osKvsRxOBL3UN8ANA,88729
 lcode/api.py,sha256=efsUuIZneUc6Ar6KWerKAoMlMFOlSUtLX4_quplr3t8,17664
 lcode/backends.py,sha256=343alwyDZin-bEhb5-Es4f8ek1oBQUzEvV6RFWR1VZo,21160
 lcode/bench.py,sha256=HxeUfy9Kv_0Rug1HAlDLyHYfYd9dw2bMgbXsvUy9nd4,43096
@@ -11,13 +11,14 @@ 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=3HPENwGw8rufYAgfmCHVK4R3gkEU2uDfgUyF1gnadzw,51385
+lcode/cli.py,sha256=ZVafS8V-82SuEldT6VlAcqKEuBabA-HCi8Tk_0IP9Pc,51516
 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=SpIoY9fSvtm1TVtHTkUZ5W59RG55vtMncI-bRogqGBY,26490
+lcode/comfy.py,sha256=_pbLVQS_1clsa7awPrxQ7xIOwp5XzyMHPDAagomEswc,26614
 lcode/config.py,sha256=F7CRPdlqW6i9CSapqeU83ClOHOsf-Mxx1sWGXRYI1ac,13861
 lcode/context.py,sha256=wgK16ZcNNnq4ngHx0EmtyKHDFTImciGEmtC5NP8tKJQ,20435
+lcode/edits.py,sha256=iYXSbKv4ZfxP12B1ov6-CLEWvR_tWFUdHRQbER3O8d0,13340
 lcode/escalate.py,sha256=f-_6_moPaHi2kLuJw2JtkzvTkCl6DoBQgYBOCYLhunM,15120
 lcode/extensions.py,sha256=W0HFDl0BvROzr7i_qtabHdIbacBgP5o5qIJLzoM2oNE,16806
 lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
@@ -29,9 +30,9 @@ 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=FHvghSTDsJxXhhpivdlpHrm4FyLEH7HeG2StHPo7bj0,19012
-lcode/media.toml,sha256=Lv82r8YIA8CFEybXYV3qHtKGYJDk9hCflVXBG_xlfe0,3545
-lcode/media_catalog.py,sha256=y7kR4hzLW6b4tRQjk7b1_Oqq7zc5SWEG7Wux7pksCXI,13716
+lcode/media.py,sha256=F8jRT8J2GkUVUxEMbK4DT6sykxE4JXnKOQ-7Ntl0RgY,28984
+lcode/media.toml,sha256=QSv1QmeR9XukBBnmTtAxAZKp2-EguIGJmbar4rDM-is,4715
+lcode/media_catalog.py,sha256=geAt3B4mOxTydXFFaYA0wBO9512_115eBPAjAWTUIj4,14331
 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
@@ -42,7 +43,7 @@ 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=c_XpqiOfQjnQ6Ng1Zff3yqBOb5QJrlzQxDnHo6P_2d4,67500
+lcode/repl.py,sha256=OkJ6ClINTE2P3JNKTP1ulu-bTNCtfro12f4w6kM069g,71932
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=B9pwqG6yx5aQD2M5xyQ-bMnYmhD7fv3wCVw_X6VIeAo,7012
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
@@ -75,9 +76,11 @@ lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,1443
 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/remove-background.json,sha256=iMNaXqlkcWN-mCQWezD3NUbW94cHN3JcPYsSUsfOl64,794
+lcode/workflows/upscale-esrgan.json,sha256=quDmTnncvycggskgvw6zvfNsub7mS0WY3a4J99fWeXc,745
 lcode/workflows/z-image-turbo-t2i.json,sha256=sHsL7xnnuULOuWGYlQrDl4jOTySdAmb2T82c_cChv0s,1585
-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,,
+lcode_cli-0.43.0.dist-info/METADATA,sha256=FjFitYxjlbB2iFty4gVvGqNJKSoys9npCyZubZmm5i4,13386
+lcode_cli-0.43.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.43.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.43.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.43.0.dist-info/RECORD,,