lcode-cli 0.42.0__tar.gz → 0.44.0__tar.gz

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/CHANGELOG.md

@@ -6,6 +6,35 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.44.0] - 2026-10-24
+
+### Added
+
+- **Video mode makes videos** (#153). Describe a clip, or start it from a picture (`@photo.png`),
+  and Wan 2.2 TI2V 5B makes it on your GPU. See [Video mode](https://nasser1941.github.io/lcode/modes/#video-mode).
+  - **Options:** `--seconds` (1 to 8, 5 by default, 24 fps) plus the image options. Quality
+    presets: 864×480 in 12 or 20 steps, or 1280×704 in 30. A 5-second clip takes 100 to 150 s on a
+    12 GB laptop GPU. Clips are 16:9 (9:16 from an upright start image) unless you give a shape.
+  - **Results:** an MP4 with its settings in a JSON file next to it, in the session's gallery; the
+    first frame shows in the terminal, `/play` opens it, and `/vary`/`/again` make new clips.
+  - **`/animate 3`** in image mode makes a clip from image #3. `lcode media` lists video models, and
+    `/models` in video mode picks one (the `video_model` setting).
+  - With `notify` on, a long render ends with a desktop notification.
+
+## [0.43.0] - 2026-10-24
+
+### Added
+
+- **Image mode edits pictures** (#152). See [Editing](https://nasser1941.github.io/lcode/modes/#editing).
+  - **Edit by instruction** (`/edit 3 make the sky purple`, or `@photo.png make the sky purple`)
+    and **references** (`@photo.png @#3 put the mug from image 1 on the table in image 2`), with
+    FLUX.2 klein 4B. `/use 3` makes every next request follow an image until `/use off`.
+  - **Inpainting** (`--mask mask.png`: only the white part changes) and **outpainting** (`/extend 3
+    --ar 16:9`, or by sides: only the new border is painted, the original stays as it was).
+  - **`/upscale 3`** (Real-ESRGAN, 2× or 4×) and **`/nobg 3`** (BiRefNet, a transparent PNG), installed
+    on first use. `/vary` on an edit makes new edits of the same images.
+  - ComfyUI's reasons for refusing a workflow now include its explanation, not just the input's name.
+
 ## [0.42.0] - 2026-10-24
 
 ### Added
@@ -940,7 +969,9 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.42.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.44.0...HEAD
+[0.44.0]: https://github.com/nasser1941/lcode/compare/v0.43.0...v0.44.0
+[0.43.0]: https://github.com/nasser1941/lcode/compare/v0.42.0...v0.43.0
 [0.42.0]: https://github.com/nasser1941/lcode/compare/v0.41.0...v0.42.0
 [0.41.0]: https://github.com/nasser1941/lcode/compare/v0.40.0...v0.41.0
 [0.40.0]: https://github.com/nasser1941/lcode/compare/v0.39.0...v0.40.0

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.42.0
+Version: 0.44.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/
@@ -107,8 +107,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   `lcode --worktree` runs parallel sessions on one repository.
 - **In your editor.** Zed, JetBrains IDEs, Neovim and other editors that speak the Agent Client
   Protocol run lcode with `lcode acp`, with diffs and approvals in the editor.
-- **Image mode.** `/mode image`, describe a picture, and FLUX.2 klein 4B makes it on your GPU in
-  seconds through ComfyUI, which lcode starts, follows and stops itself. Video mode is next
+- **Image and video modes.** `/mode image`, describe a picture, and FLUX.2 klein 4B makes it on your
+  GPU in seconds; edit it, extend it, upscale it or cut it out. `/mode video` makes clips with
+  Wan 2.2, from a description or a start image. lcode drives ComfyUI itself
   ([modes](https://nasser1941.github.io/lcode/modes/)).
 - **Automation.** `lcode -p --output json` for scripts and CI, a Python API (`from lcode import
   Session`), and a GitHub Action that answers `@lcode` in issues and pull requests on your own

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/README.md

@@ -71,8 +71,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   `lcode --worktree` runs parallel sessions on one repository.
 - **In your editor.** Zed, JetBrains IDEs, Neovim and other editors that speak the Agent Client
   Protocol run lcode with `lcode acp`, with diffs and approvals in the editor.
-- **Image mode.** `/mode image`, describe a picture, and FLUX.2 klein 4B makes it on your GPU in
-  seconds through ComfyUI, which lcode starts, follows and stops itself. Video mode is next
+- **Image and video modes.** `/mode image`, describe a picture, and FLUX.2 klein 4B makes it on your
+  GPU in seconds; edit it, extend it, upscale it or cut it out. `/mode video` makes clips with
+  Wan 2.2, from a description or a start image. lcode drives ComfyUI itself
   ([modes](https://nasser1941.github.io/lcode/modes/)).
 - **Automation.** `lcode -p --output json` for scripts and CI, a Python API (`from lcode import
   Session`), and a GitHub Action that answers `@lcode` in issues and pull requests on your own

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/docs/configuration.md

@@ -28,6 +28,7 @@ lcode config path                      # print the file location
 | `comfyui_path` | (found) | Your ComfyUI folder, if lcode doesn't find it; lcode starts it when needed ([ComfyUI](modes.md#comfyui)) |
 | `media_dir` | `.lcode/media` | Where images and videos go: a folder in the project, or an absolute path |
 | `preview` | `auto` | Images in the terminal: `auto`, `kitty`, `iterm`, `blocks` (colour text) or `off` ([results](modes.md#results)) |
+| `video_model` | `wan22-ti2v-5b` | The model video mode uses: a key from `lcode media` ([video mode](modes.md#video-mode)) |
 | `image_model` | `flux2-klein-4b` | The model image mode uses: a key from `lcode media` ([image models](modes.md#image-models)) |
 | `think` | `true` | Let the model reason before answering |
 | `web` | `on` | Web search and page fetching: `on`, `ask` (before each search/website) or `off` |

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/docs/modes.md

@@ -5,8 +5,8 @@ lcode makes three kinds of things, each in its own mode with its own models:
 | Mode | What it makes | The model doing the work |
 |---|---|---|
 | **code** (default) | Code: it reads, writes, runs and checks your project | A coding language model in Ollama (or another server) |
-| **image** | Images from a description and reference images | An image model, run by ComfyUI on your GPU |
-| **video** | Videos from a description, a start image or references | A video model, run by ComfyUI on your GPU |
+| **image** | Images from a description, edits of your images (references, inpainting, outpainting), upscales and cut-outs | An image model, run by ComfyUI on your GPU |
+| **video** | Video clips from a description or a start image | A video model, run by ComfyUI on your GPU |
 
 ```text
 ❯ /mode image
@@ -81,6 +81,8 @@ alone shows them.
 - **Sessions:** the gallery and `/options` are saved with the session, so `lcode -c` or `/resume`
   brings them back. An image session is listed under its first prompt.
 
+### While it works
+
 - **Progress:** the status line says what ComfyUI is doing (loading the model, reading the
   prompt, drawing, decoding), the step, the time left and the time so far. If other jobs are ahead
   in ComfyUI's queue, it says how many.
@@ -99,7 +101,75 @@ alone shows them.
 - **No Ollama needed:** `lcode --mode image` starts even when Ollama isn't running or the coding
   model isn't installed; `/mode code` then says what's missing.
 
-## ComfyUI
+### Editing
+
+FLUX.2 klein 4B edits pictures as well as making them: it takes images as references and an
+instruction as the prompt. When the chosen model can't edit (Z-Image Turbo), lcode hands edits to
+FLUX.2 klein and says so.
+
+```text
+image ❯ /edit 1 make the mug matte black with a small gold star
+◆ #2 .lcode/media/20261024-100504-make-the-mug-matte-black-with-a-small-go.png  1024×1024 · FLUX.2 klein 4B · seed 1798225303 · 6.1 s
+image ❯ /extend 1 --ar 16:9
+Extending #1 from 1024×1024 to 1824×1024 before scaling.
+◆ #4 .lcode/media/…-extended.png  1360×768 · FLUX.2 klein 4B · seed 2994584653 · 6.4 s
+image ❯ /nobg 2
+◆ #6 .lcode/media/…-nobg.png  1024×1024 · BiRefNet · 0.7 s
+```
+
+| What | How | What happens |
+|---|---|---|
+| **Edit by instruction** | `/edit 3 make the sky purple` (the last image without a number), or `@photo.png make the sky purple` | The image goes in as a reference, the instruction is the prompt. The result keeps the image's shape unless you give one (`--ar`). |
+| **References** | `@photo.png @#3 put the mug from image 1 on the table in image 2`, or `/edit 3 … @style.png` | Several images, in order ("image 1", "image 2" in the instruction): a subject, a style, a place. `@"a file with spaces.png"` works too. |
+| **Keep following an image** | `/use 3` (or `/use photo.png`), then plain requests; `/use off` | Every request is an edit of those images until you stop it: handy for one subject in many scenes. |
+| **Inpaint** | `@photo.png --mask mask.png make the sky purple` | Only where the mask image is white changes (with a soft edge); the rest stays exactly as it was. |
+| **Outpaint** | `/extend 3 --ar 16:9`, or `/extend 3 --left 256 --top 128`, plus words about the new part | The canvas grows, the model paints only the new border, and the original is pasted back as it was. |
+| **Upscale** | `/upscale 3` (2×) or `/upscale 3 4` | Real-ESRGAN, a few seconds: a 1024×1024 image becomes 2048×2048. |
+| **Remove the background** | `/nobg 3` | BiRefNet cuts out the subject: a PNG with a transparent background. |
+
+- **Follow-ups work on edits too:** `/vary` on an edit makes new edits of the same images with the
+  same instruction, and `/again` repeats the last request, edit or not.
+- **The tools install on first use,** after you agree: Real-ESRGAN (0.07 GB) and BiRefNet (0.44 GB).
+  `lcode media` lists them under "Tools for images".
+- **Text in images:** FLUX.2 klein and Z-Image Turbo write short text you put in quotes
+  (`a café sign that says "OPEN"`).
+- **Measured** on the RTX 4080 Laptop GPU (12 GB): an edit takes 5 to 7 s, two references 10 s,
+  inpainting and outpainting 6 to 12 s, a 2× upscale 6 s, and a background cut-out under a second
+  once the tools are loaded.
+
+## Video mode
+
+Video mode works like image mode: what you type describes a clip, and **Wan 2.2 TI2V 5B** makes it on
+your GPU. Start it from a picture with `@photo.png` (or `@#3`, an image from this session), and the
+clip begins with that frame. From image mode, `/animate 3 the waves roll in` switches to video mode
+and animates image #3.
+
+```text
+video ❯ waves rolling onto a beach at sunset --seconds 5
+◆ #1 .lcode/media/20261024-….mp4  864×480 · Wan 2.2 TI2V 5B · seed 1234 · …
+video ❯ /play
+```
+
+- **Options:** the image options work here too (`--n`, `--ar`, `--seed`, `--quality`, `--style`,
+  `--no`, and `/options`), plus `--seconds` (1 to 8; 5 by default, at 24 frames per second).
+  Clips are 16:9, or 9:16 from an upright start picture (cropped to it), unless you give a shape:
+  Wan 2.2 knows those two shapes best, and a square or small clip can break up into streaks.
+- **Quality:** `fast` makes 864×480 in 12 steps, `balanced` (the default) 864×480 in 20 steps, and
+  `best` the model's own 1280×704 in 30 steps. Smaller than 864×480 breaks this model up into
+  streaks, so lcode doesn't go lower.
+- **Camera moves:** describe them as shots ("slow zoom in", "dolly shot along the shore", "pan
+  left"). "The camera moves in" can put a camera in the picture.
+- **Negative prompt:** Wan uses one. lcode passes Wan's own default (it avoids static, blurry,
+  over-exposed clips) unless you give `--no "…"`.
+- **Results:** an MP4 with a JSON file next to it (prompt, seed, size, frames, fps, start image),
+  numbered in the session's gallery with the images. The first frame shows in the terminal.
+  `/play 4` opens a clip in your player, and `/vary` and `/again` make new clips from the same
+  description and start image.
+- **Measured** on the RTX 4080 Laptop GPU (12 GB), a 5-second clip (121 frames): `fast` 100 s,
+  `balanced` 150 s (the same from a start image), `best` 10.5 minutes.
+- **Long renders:** progress shows the step and the time left. With `notify` on, lcode sends a
+  desktop notification when a clip that took longer than `notify_after` seconds is done.
+
 
 ComfyUI runs the image and video models; lcode drives it through its API.
 
@@ -196,13 +266,8 @@ themselves:
 
 ## Coming next
 
-Video mode doesn't generate yet: a request there says what's coming instead of going anywhere.
-
-- **#150 Media model catalog** (image models done; video models come with video generation).
-- **#151, #152 Image mode:** generating, variations, sizes and seeds, a gallery, editing,
-  references, inpainting, upscaling.
-- **#153, #154 Video mode:** from text or a start image, first and last frames, several
-  references, camera moves, longer clips, sound.
+- **#154 More video:** first and last frames, several references, camera moves, longer clips,
+  sound, and more video models in the catalog.
 - **#155 Movies:** storyboards with a consistent cast, shots stitched into one film.
 - **#156 Prompt assistant:** a small local model for prompts and follow-ups.
 - **#157 Cloud generation**, with costs shown (Grok Imagine first).

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.42.0 — local coding agent           │
+│ lcode v0.44.0 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/docs/usage.md

@@ -82,6 +82,8 @@ reasoning is on.
 | `/verbose` | Toggle showing the reasoning text |
 | `/mode [code\|image\|video]` | Switch what lcode makes: [code, images or videos](modes.md) |
 | `/options`, `/again`, `/vary N`, `/gallery`, `/open N` | Image mode: [options for the session, follow-ups on results](modes.md#results) |
+| `/edit N`, `/use N`, `/extend N`, `/upscale N`, `/nobg N` | Image mode: [edit, follow, outpaint, upscale, cut out](modes.md#editing) |
+| `/animate N`, `/play N` | [Video mode](modes.md#video-mode): animate image N; play a clip |
 | `/permissions [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
 | `/cd DIR` | Change the working directory |
 | `/todos` | Show the model's task list |

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/src/lcode/__init__.py

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

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/src/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)
+    video_model: str = "wan22-ti2v-5b"  # and video mode's
     preview: str = "auto"  # images in the terminal: auto, kitty, iterm, blocks or off (lcode.preview)
     num_batch: int | None = None
     keep_alive: str = "30m"
@@ -380,7 +381,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 +699,8 @@ 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()},
+            "video_model": self.settings.video_model,
+            "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,
@@ -748,9 +751,12 @@ 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"]
+        if isinstance(data.get("video_model"), str):
+            self.settings.video_model = data["video_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.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-0.42.0 → lcode_cli-0.44.0}/src/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"],
+        video_model=cfg["video_model"],
         preview=cfg["preview"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],

{lcode_cli-0.42.0 → lcode_cli-0.44.0}/src/lcode/cli.py

@@ -801,16 +801,8 @@ def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
     """`lcode --mode image -p "…"`: make the image, say where it went (or, with --output json, a result object)."""
     import json
 
-    from lcode import api, media, modes
+    from lcode import api, media
 
-    if agent.settings.mode == "video":
-        message = modes.COMING["video"]
-        if quiet:
-            print(json.dumps({"type": "result", "status": "error", "error": message}), flush=True)
-        else:
-            out.print(f"[yellow]{escape(message)}[/]")
-        api.close_agent(agent)
-        sys.exit(2)
     try:
         made = media.request(agent, prompt)
     except (media.MediaError, KeyboardInterrupt) as e:
@@ -825,7 +817,7 @@ def media_request(agent, prompt: str, out: Console, quiet: bool) -> None:
         result = {
             "type": "result",
             "status": "success",
-            "mode": "image",
+            "mode": agent.settings.mode,
             "files": [str(path) for one in made for path in one.files],
             "model": made[0].model,
             "seed": made[0].seed,
@@ -1106,10 +1098,14 @@ def cmd_media(args) -> None:
     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"):
+    console.print(f"[dim]{hw.describe()} · {where} · image: {cfg['image_model']} · video: {cfg['video_model']}[/]\n")
+    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_cli-0.42.0 → lcode_cli-0.44.0}/src/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_cli-0.42.0 → lcode_cli-0.44.0}/src/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`"),
+    "video_model": ("wan22-ti2v-5b", str, "the model video 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"),
@@ -217,12 +218,12 @@ def coerce(key: str, value: object) -> object:
 
         if value not in PROTOCOLS:
             raise ConfigError(f"preview must be one of {', '.join(PROTOCOLS)}")
-    if key == "image_model":
+    if key in ("image_model", "video_model"):
         from lcode import media_catalog
 
-        keys = [m.key for m in media_catalog.load().for_mode("image")]
+        keys = [m.key for m in media_catalog.load().for_mode(key.removesuffix("_model"))]
         if value not in keys:
-            raise ConfigError(f"image_model must be one of {', '.join(keys)} (see lcode media)")
+            raise ConfigError(f"{key} 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")