lcode-cli 0.40.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.40.0"
+__version__ = "0.42.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

lcode/agent.py

@@ -308,6 +308,8 @@ class Settings:
     comfyui_url: str = "http://127.0.0.1:8188"
     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
@@ -374,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
@@ -678,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)
@@ -687,6 +696,8 @@ class Agent:
             "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "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,
@@ -735,6 +746,11 @@ class Agent:
         self.session_name = data.get("name", "")
         if data.get("mode") in ("code", "image", "video"):
             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

@@ -200,6 +200,8 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         comfyui_url=cfg["comfyui_url"],
         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

@@ -777,9 +777,10 @@ def exit_on_hangup() -> None:
 
 def comfyui_status(cfg: dict) -> tuple[str, bool | None]:
     """lcode doctor's ComfyUI line: running or found, and whether the image model is there."""
-    from lcode import comfy, media
+    from lcode import comfy
+    from lcode import media_catalog as catalog
 
-    workflow = comfy.load_workflow(media.IMAGE_WORKFLOW)
+    model = catalog.load().find(cfg.get("image_model") or "") or catalog.load().models[catalog.DEFAULT_IMAGE]
     server = comfy.Server(cfg["comfyui_url"])
     stats = server.stats()
     install = None if stats else comfy.find_install(cfg["comfyui_path"])
@@ -787,14 +788,13 @@ def comfyui_status(cfg: dict) -> tuple[str, bool | None]:
         return "not found: image mode offers to install it (or lcode config set comfyui_path <folder>)", None
     if stats:
         where = f"{(stats.get('system') or {}).get('comfyui_version', '?')} running at {server.url}"
-        installed = {folder: set(server.models(folder)) for folder in workflow.models}
     else:
         where = f"{install.path} (lcode starts it in image mode)"
-        installed = {folder: set(comfy.local_models(install, folder)) for folder in workflow.models}
-    missing = [f"{f}/{names[0]}" for f, names in workflow.models.items() if not installed[f] & set(names)]
+    _, missing = catalog.chosen_files(model, catalog.lister(server if stats else None, install))
     if missing:
-        return f"{where} · {workflow.name} not installed (missing {', '.join(missing)})", None
-    return f"{where} · image model: {workflow.name}", True
+        size = sum(f.gb for f in missing)
+        return f"{where} · {model.name} not installed: lcode media install {model.key} ({size:.1f} GB)", None
+    return f"{where} · image model: {model.name}", True
 
 
 def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
@@ -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)
@@ -909,6 +910,13 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     subs["setup"] = p
     subs["models"] = argparse.ArgumentParser(prog="lcode models", description="List models and how they fit here.")
     subs["doctor"] = argparse.ArgumentParser(prog="lcode doctor", description="Check the installation.")
+    p = argparse.ArgumentParser(
+        prog="lcode media", description="Image and video models: list them, with how they fit here, or install one."
+    )
+    p.add_argument("action", nargs="?", choices=["list", "install"], default="list")
+    p.add_argument("model", nargs="?", help="with install: a model key from the list, e.g. z-image-turbo")
+    p.add_argument("-y", "--yes", action="store_true", help="don't ask before downloading")
+    subs["media"] = p
     p = argparse.ArgumentParser(prog="lcode config", description="Show or change settings.")
     p.add_argument("action", nargs="?", choices=["show", "set", "unset", "path"], default="show")
     p.add_argument("key", nargs="?", choices=list(config.SETTINGS))
@@ -1065,6 +1073,55 @@ def cmd_index(args) -> None:
     )
 
 
+def cmd_media(args) -> None:
+    """lcode media [list] | install <model>: the media catalog, what's installed in ComfyUI, downloads."""
+    from rich.prompt import Confirm
+
+    from lcode import comfy, media
+    from lcode import media_catalog as catalog
+
+    try:
+        cfg = config.load()
+    except ConfigError as e:
+        fail(str(e))
+    cat, hw = catalog.load(), detect()
+    server = comfy.Server(cfg["comfyui_url"])
+    install = comfy.find_install(cfg["comfyui_path"])
+    running = server.stats() is not None
+    installed = catalog.lister(server if running else None, install) if running or install else None
+    if args.action == "install":
+        model = cat.find(args.model or "")
+        if model is None:
+            fail(f"no media model {args.model!r}: lcode media lists them")
+        if not running and install is None:
+            fail(f"lcode needs ComfyUI to install models into. {comfy.install_hint()}")
+        ask = None if args.yes else (lambda q: Confirm.ask(q, default=True, console=console))
+        try:
+            saved = catalog.install(model, server if running else None, install, console, ask)
+        except catalog.CatalogError as e:
+            fail(str(e))
+        how = f" ({len(saved)} file(s) downloaded)." if saved else "."
+        console.print(f"[green]{model.name} is installed[/]{how}")
+        return
+    where = (
+        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"):
+        models = cat.for_mode(mode)
+        console.print(f"[bold]{mode.capitalize()} models[/]")
+        if not models:
+            console.print(f"  [dim]{media.SOON[mode]}[/]\n")
+            continue
+        for m in models:
+            line = escape(catalog.describe(m, hw, installed))
+            console.print(f"  [bold]{m.key:<16}[/] {escape(m.name)} [dim]· {line}[/]")
+            if m.measured:
+                console.print(f"  {'':<16} [dim]{escape(m.measured)}[/]")
+        console.print()
+    console.print("[dim]Install one: lcode media install <model> · choose in image mode: /model <model>[/]")
+
+
 def cmd_mcp(args) -> None:
     from lcode.mcp.commands import run
 
@@ -1075,6 +1132,7 @@ COMMANDS = {
     "setup": cmd_setup,
     "models": cmd_models,
     "doctor": cmd_doctor,
+    "media": cmd_media,
     "config": cmd_config,
     "bench": cmd_bench,
     "mcp": cmd_mcp,

lcode/comfy.py

@@ -254,6 +254,14 @@ class Server:
         except (requests.RequestException, ValueError):
             return []
 
+    def folder_paths(self) -> dict[str, list[str]]:
+        """Where ComfyUI keeps each kind of model (its own folders and extra_model_paths.yaml's)."""
+        try:
+            r = requests.get(self.url + "/internal/folder_paths", timeout=10)
+            return r.json() if r.status_code == 200 else {}
+        except (requests.RequestException, ValueError):
+            return {}
+
     def upload(self, path: Path) -> str:
         """Upload an input image; the name to use in a workflow."""
         with path.open("rb") as f:
@@ -420,32 +428,18 @@ class Events:
 
 @dataclass
 class Workflow:
+    """A graph in ComfyUI's API format with `$name` placeholders: the model's files (by role, from media.toml),
+    the prompt, the seed and the settings in `defaults`."""
+
     key: str
-    name: str
-    task: str
-    models: dict[str, list[str]]  # ComfyUI folder -> file names it can use, preferred first
-    defaults: dict
     graph: dict
+    defaults: dict = field(default_factory=dict)
     labels: dict[str, str] = field(default_factory=dict)  # node id -> what it does, for progress
 
 
 def load_workflow(key: str) -> Workflow:
     data = json.loads(resources.files("lcode.workflows").joinpath(f"{key}.json").read_text())
-    return Workflow(key, data["name"], data["task"], data["models"], data.get("defaults", {}), data["graph"],
-                    data.get("labels", {}))  # fmt: skip
-
-
-def choose_files(server: Server, workflow: Workflow) -> tuple[dict[str, str], list[str]]:
-    """For each model the workflow needs, the installed file to use; and the folders where none is installed."""
-    chosen, missing = {}, []
-    for folder, names in workflow.models.items():
-        installed = set(server.models(folder))
-        found = next((n for n in names if n in installed), None)
-        if found:
-            chosen[folder] = found
-        else:
-            missing.append(f"{folder}/{names[0]}")
-    return chosen, missing
+    return Workflow(key, data["graph"], data.get("defaults", {}), data.get("labels", {}))
 
 
 PLACEHOLDER = re.compile(r"^\$([a-z_]+)$")
@@ -566,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

@@ -45,6 +45,8 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "comfyui_url": ("http://127.0.0.1:8188", str, "ComfyUI, for image and video mode"),
     "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)"),
@@ -210,6 +212,17 @@ 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
+
+        keys = [m.key for m in media_catalog.load().for_mode("image")]
+        if value not in keys:
+            raise ConfigError(f"image_model must be one of {', '.join(keys)} (see lcode media)")
     if typ is bool and isinstance(value, str):
         if value.lower() not in ("true", "false", "1", "0", "yes", "no", "on", "off"):
             raise ConfigError(f"{key} must be true or false")

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