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

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

@@ -6,6 +6,21 @@ 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
@@ -954,7 +969,8 @@ 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.43.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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.43.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.43.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.43.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.43.0 → lcode_cli-0.44.0}/docs/modes.md

@@ -6,7 +6,7 @@ lcode makes three kinds of things, each in its own mode with its own models:
 |---|---|---|
 | **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, edits of your images (references, inpainting, outpainting), upscales and cut-outs | 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 |
+| **video** | Video clips from a description or a start image | A video model, run by ComfyUI on your GPU |
 
 ```text
 ❯ /mode image
@@ -137,7 +137,39 @@ image ❯ /nobg 2
   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.
 
-## ComfyUI
+## 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.
 
@@ -234,10 +266,8 @@ themselves:
 
 ## Coming next
 
-Video mode doesn't generate yet: a request there says what's coming instead of going anywhere.
-
-- **#153, #154 Video mode:** with video models in the catalog, 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.43.0 → lcode_cli-0.44.0}/docs/quickstart.md

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

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

@@ -83,6 +83,7 @@ reasoning is on.
 | `/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.43.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.43.0"
+__version__ = "0.44.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.43.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"
@@ -698,6 +699,7 @@ class Agent:
             "model": self.settings.model,
             "mode": self.settings.mode,
             "image_model": self.settings.image_model,
+            "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,
@@ -749,6 +751,8 @@ 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 {})

{lcode_cli-0.43.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.43.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,7 +1098,7 @@ 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")
+    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(

{lcode_cli-0.43.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")

{lcode_cli-0.43.0 → lcode_cli-0.44.0}/src/lcode/imageopts.py

@@ -13,6 +13,7 @@ from dataclasses import asdict, dataclass, replace
 
 QUALITIES = ("fast", "balanced", "best")
 MAX_COUNT = 8
+MAX_SECONDS = 8  # video: longer clips need more memory than a laptop GPU has, and models drift
 SIZES = {  # names for aspect ratios
     "square": "1:1",
     "portrait": "3:4",
@@ -46,6 +47,8 @@ ALIASES = {
     "no": "negative",
     "negative": "negative",
     "style": "style",
+    "seconds": "seconds",
+    "duration": "seconds",
 }
 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})$")
@@ -64,10 +67,13 @@ class Options:
     quality: str = "balanced"
     negative: str = ""
     style: str = ""
+    seconds: float = 5.0  # video only
 
-    def describe(self) -> str:
+    def describe(self, video: bool = False) -> 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 video:
+            parts.append(f"seconds={self.seconds:g}")
         if self.style:
             parts.append(f"style={self.style}")
         if self.negative:
@@ -92,7 +98,7 @@ def set_values(options: Options, values: dict[str, object]) -> 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")
+            raise OptionError(f"unknown option {raw_key!r}: use n, ar (or size), seed, quality, style, no or seconds")
         value = str(raw).strip() if raw is not None else ""
         if key == "n":
             if not value.isdigit() or not 1 <= int(value) <= MAX_COUNT:
@@ -120,6 +126,14 @@ def set_values(options: Options, values: dict[str, object]) -> Options:
                 raise OptionError(f"style is one of {', '.join(STYLES)} (or none)")
         elif key == "negative":
             out.negative = "" if value.lower() in ("none", "off") else value
+        elif key == "seconds":
+            try:
+                seconds = float(value.rstrip("s"))
+            except ValueError:
+                seconds = 0
+            if not 1 <= seconds <= MAX_SECONDS:
+                raise OptionError(f"seconds is how long a video is: 1 to {MAX_SECONDS}")
+            out.seconds = seconds
     return out
 
 
@@ -203,5 +217,10 @@ def replace_seed(options: Options, n: int | None = None) -> Options:
     return replace(options, seed=None, n=n or options.n)
 
 
+def frames(seconds: float, fps: int) -> int:
+    """Frames for a clip: a multiple of 4 plus 1, as video models that compress time 4 to 1 need."""
+    return max(1, round(seconds * fps / 4)) * 4 + 1
+
+
 def styled(prompt: str, style: str) -> str:
     return f"{prompt}, {STYLES[style]}" if style else prompt

{lcode_cli-0.43.0 → lcode_cli-0.44.0}/src/lcode/media.py

@@ -27,7 +27,7 @@ from lcode import media_catalog as catalog
 if TYPE_CHECKING:
     from lcode.agent import Agent
 
-SOON = {"video": "Video models come with video generation (#153)."}
+SOON: dict[str, str] = {}
 IGNORED = "# lcode's images and videos: not part of the project unless you add them\n*\n"
 
 
@@ -44,9 +44,11 @@ def installed_lister(agent: Agent) -> catalog.Installed | None:
     return catalog.lister(install=install) if install else None
 
 
-def current(agent: Agent) -> catalog.MediaModel:
-    """The image model the agent uses (the image_model setting, or /model in image mode)."""
+def current(agent: Agent, mode: str | None = None) -> catalog.MediaModel:
+    """The model the agent uses in image or video mode (image_model, video_model, or /model there)."""
     cat = catalog.load()
+    if (mode or agent.settings.mode) == "video":
+        return cat.find(agent.settings.video_model) or cat.models[catalog.DEFAULT_VIDEO]
     return cat.find(agent.settings.image_model) or cat.models[catalog.DEFAULT_IMAGE]
 
 
@@ -61,6 +63,7 @@ class Made:
     prompt: str = ""
     numbers: list[int] = field(default_factory=list)  # in the session's gallery
     thumbnail: bytes = b""  # a small PNG, for the half-block preview
+    poster: bytes = b""  # a video's first frame, for terminals that show pictures
 
 
 # ----------------------------------------------------------------------------- ComfyUI, started and stopped
@@ -227,25 +230,36 @@ def ensure_installed(
 
 
 THUMB_NODES = ("9001", "9002")  # the thumbnail lcode adds to a workflow, for the half-block preview
+POSTER_NODES = ("9003", "9004")  # a video's first frame, picked and kept (not saved) for the preview
 
 
 def add_thumbnail(graph: dict, width: int, height: int) -> None:
-    """Have ComfyUI also make a small copy of the image (not saved, a preview), for the half-block preview."""
+    """Have ComfyUI also make a small copy of the image, or of a video's first frame (not saved, a preview)."""
     save = next((nid for nid, node in graph.items() if node.get("class_type") == "SaveImage"), None)
-    if save is None:
+    video = next((nid for nid, node in graph.items() if node.get("class_type") == "CreateVideo"), None)
+    if save is not None:
+        frames = graph[save]["inputs"]["images"]
+    elif video is not None:
+        first, keep = POSTER_NODES
+        graph[first] = {
+            "class_type": "ImageFromBatch",
+            "inputs": {"image": graph[video]["inputs"]["images"], "batch_index": 0, "length": 1},
+        }
+        graph[keep] = {"class_type": "PreviewImage", "inputs": {"images": [first, 0]}}
+        frames = [first, 0]
+    else:
         return
     tw, th = preview.thumbnail_size(width, height)
     scale, show = THUMB_NODES
     graph[scale] = {
         "class_type": "ImageScale",
-        "inputs": {"image": graph[save]["inputs"]["images"], "upscale_method": "area", "width": tw, "height": th,
-                   "crop": "disabled"},
-    }  # fmt: skip
+        "inputs": {"image": frames, "upscale_method": "area", "width": tw, "height": th, "crop": "disabled"},
+    }
     graph[show] = {"class_type": "PreviewImage", "inputs": {"images": [scale, 0]}}
 
 
-def thumbnail(server: comfy.Server, outputs: dict) -> bytes:
-    for item in (outputs.get(THUMB_NODES[1]) or {}).get("images", []):
+def thumbnail(server: comfy.Server, outputs: dict, node: str = THUMB_NODES[1]) -> bytes:
+    for item in (outputs.get(node) or {}).get("images", []):
         try:
             return server.fetch(item)
         except (comfy.ComfyError, OSError, requests.RequestException):
@@ -275,6 +289,12 @@ def request(
     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")
+    if agent.settings.mode == "video":
+        if mask:
+            raise MediaError("Video mode doesn't take a mask: @photo.png starts a video from a picture.")
+        job = {"kind": "video", "prompt": prompt, "options": options, "sources": [str(p) for p in sources[:1]],
+               "mask": None, "pads": None, "keep_shape": not SIZE_FLAG.search(text)}  # fmt: skip
+        return redo(agent, job, cancelled, ask)
     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
@@ -286,9 +306,10 @@ def redo(
 ) -> list[Made]:
     """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 not prompt.strip() and job["kind"] in ("image", "edit", "video") and not job.get("pads"):
+        what = {"image": "Describe the image you want.", "edit": "Say what to change."}
+        raise MediaError(what.get(job["kind"], "Describe the video you want."))
+    model = current(agent, "video" if job["kind"] == "video" else "image")
     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 = job
@@ -299,6 +320,8 @@ def redo(
         one = replace(options, seed=seed, n=1)
         if job["kind"] == "image":
             made.append(generate_image(agent, prompt, cancelled, ask, one, label))
+        elif job["kind"] == "video":
+            made.append(generate_video(agent, job, one, cancelled, ask, label))
         else:
             made.append(edit_image(agent, job, one, cancelled, ask, label))
     return made
@@ -368,7 +391,7 @@ def generate_image(
         raise MediaError("Describe the image you want.")
     options = options or imageopts.Options()
     server = prepare(agent, ask, cancelled)
-    model = current(agent)
+    model = current(agent, "image")
     files = ensure_installed(agent, model, server, ask)
     workflow = comfy.load_workflow(model.workflow)
     seed = options.seed if options.seed is not None else random.randrange(2**32)
@@ -397,7 +420,7 @@ def edit_image(
     """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)
+    chosen = current(agent, "image")
     model = catalog.load().editor(chosen)
     if model is None:
         raise MediaError("None of lcode's image models edits pictures yet.")
@@ -453,6 +476,62 @@ def edit_image(
     return run_plan(agent, server, plan, cancelled, label)
 
 
+def generate_video(
+    agent: Agent,
+    job: dict,
+    options: imageopts.Options,
+    cancelled: Callable[[], bool] = lambda: False,
+    ask: Callable[[str], bool] | None = None,
+    label: str = "",
+) -> Made:
+    """One video: from the prompt, or starting from the job's image. Its shape is 16:9, or 9:16 for an upright start
+    image (the shapes video models know best; the image is cropped to it), unless the request gives one."""
+    prompt = job["prompt"].strip()
+    server = prepare(agent, ask, cancelled)
+    model = current(agent, "video")
+    files = ensure_installed(agent, model, server, ask)
+    workflow = comfy.load_workflow(model.workflow)
+    start = Path(job["sources"][0]) if job.get("sources") else None
+    seed = options.seed if options.seed is not None else random.randrange(2**32)
+    steps, megapixels = model.preset(options.quality)
+    ratio = options.size
+    if job.get("keep_shape", True) and options.size == imageopts.Options().size:  # no shape asked for
+        ratio = "16:9"
+        if start is not None:
+            try:
+                w, h = edits.image_size(start)
+                ratio = "9:16" if h > w else "16:9"  # a square or odd shape breaks up; this crops it
+            except (OSError, edits.EditError):
+                pass
+    width, height = imageopts.dimensions(imageopts.SIZES.get(ratio, ratio), megapixels, multiple=32)
+    fps = int(workflow.defaults.get("fps", 24))
+    text = imageopts.styled(prompt, options.style)
+    values = {**workflow.defaults, **files, "prompt": text, "seed": seed, "width": width, "height": height,
+              "length": imageopts.frames(options.seconds, fps), "fps": fps}  # fmt: skip
+    if steps:
+        values["steps"] = steps
+    if options.negative:
+        values["negative"] = options.negative
+    graph = comfy.fill(workflow.graph, values)
+    if start is not None:
+        try:
+            name = server.upload(start)
+        except (comfy.ComfyError, OSError) as e:
+            raise MediaError(f"Couldn't hand the image to ComfyUI: {e}") from e
+        latent = edits.node_of(graph, "Wan22ImageToVideoLatent")
+        if latent is None:
+            raise MediaError(f"{model.name} can't start from an image.")
+        graph["8100"] = {"class_type": "LoadImage", "inputs": {"image": name}}
+        graph[latent]["inputs"]["start_image"] = ["8100", 0]
+    add_thumbnail(graph, width, height)
+    meta = describe_job(model, workflow, prompt, text, seed, values, options, files)
+    meta.update({"seconds": round((values["length"] - 1) / fps, 2), "fps": fps, "frames": values["length"],
+                 "start_image": shown(agent, start) if start else ""})  # fmt: skip
+    remembered = {k: job.get(k) for k in ("kind", "prompt", "sources", "mask", "pads", "keep_shape")}
+    plan = Plan(model, workflow, graph, meta, prompt, seed, options, "video", job.get("sources") or [], remembered)
+    return run_plan(agent, server, plan, cancelled, label)
+
+
 def apply_tool(
     agent: Agent,
     task: str,
@@ -580,6 +659,8 @@ def run_plan(agent: Agent, server: comfy.Server, plan: Plan, cancelled, label: s
             pass
     made = Made(saved, plan.model.name, plan.seed, width, height, time.monotonic() - line.started, plan.prompt)
     made.thumbnail = thumbnail(server, outputs)
+    if plan.kind == "video":
+        made.poster = thumbnail(server, outputs, POSTER_NODES[1])
     made.numbers = record(agent, made, plan)
     show(agent, made)
     return made
@@ -626,18 +707,21 @@ def show(agent: Agent, made: Made) -> None:
             + 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)
+        show_preview(agent, made.files[0], made.thumbnail, made.poster)
 
 
-def show_preview(agent: Agent, path: Path, thumb: bytes = b"") -> None:
-    """The image in the terminal: itself where the terminal can show pictures, else a half-block preview."""
+def show_preview(agent: Agent, path: Path, thumb: bytes = b"", poster: bytes = b"") -> None:
+    """The image (or a video's first frame) in the terminal: itself where the terminal can show pictures, else a
+    half-block preview."""
     setting = agent.settings.preview
     how = preview.protocol(setting)
     if how == "off" or (setting == "auto" and not agent.console.is_terminal):
         return
     try:
         if how in ("kitty", "iterm"):
-            data = path.read_bytes()
+            data = path.read_bytes() if edits.is_image(path) else poster
+            if not data:
+                return
             sequence = preview.kitty(data) if how == "kitty" else preview.iterm(data)
             agent.console.file.write(sequence)
             agent.console.file.flush()

{lcode_cli-0.43.0 → lcode_cli-0.44.0}/src/lcode/media.toml

@@ -113,3 +113,36 @@ tasks = ["remove-background"]
 workflow = "remove-background"
 files = { model = "birefnet" }
 notes = "/nobg: a transparent PNG"
+
+[files.wan22-ti2v-5b]
+folder = "diffusion_models"
+name = "wan2.2_ti2v_5B_fp16.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/diffusion_models/wan2.2_ti2v_5B_fp16.safetensors"
+gb = 10.00
+
+[files.umt5-xxl-fp8]
+folder = "text_encoders"
+name = "umt5_xxl_fp8_e4m3fn_scaled.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/resolve/main/split_files/text_encoders/umt5_xxl_fp8_e4m3fn_scaled.safetensors"
+gb = 6.74
+alternatives = ["umt5_xxl_fp16.safetensors"]
+
+[files.wan22-vae]
+folder = "vae"
+name = "wan2.2_vae.safetensors"
+url = "https://huggingface.co/Comfy-Org/Wan_2.2_ComfyUI_Repackaged/resolve/main/split_files/vae/wan2.2_vae.safetensors"
+gb = 1.41
+
+[models.wan22-ti2v-5b]
+name = "Wan 2.2 TI2V 5B"
+mode = "video"
+publisher = "Wan-AI (Alibaba)"
+license = "Apache 2.0"
+tasks = ["text-to-video", "image-to-video"]
+workflow = "wan22-ti2v-5b"
+files = { model = "wan22-ti2v-5b", text_encoder = "umt5-xxl-fp8", vae = "wan22-vae" }
+gpu_gb = 0.0
+measured = "5 s clip: 100 s fast, 150 s balanced (864×480), 10.5 min best (1280×704) on an RTX 4080 Laptop, 12 GB"
+notes = "5 s at 24 fps, up to 1280×704; text or a start image"
+quality = { fast = [12, 0.4], balanced = [20, 0.4], best = [30, 0.859] }
+negative = true

{lcode_cli-0.43.0 → lcode_cli-0.44.0}/src/lcode/media_catalog.py

@@ -29,6 +29,7 @@ else:  # pragma: no cover
     import tomli as tomllib
 
 DEFAULT_IMAGE = "flux2-klein-4b"
+DEFAULT_VIDEO = "wan22-ti2v-5b"
 DISK_MARGIN_GB = 2.0  # left free after a download
 GPU_MARGIN_GIB = 0.5
 WORKING_GB = 1.5  # activations and buffers on top of the largest file, for models not measured yet

{lcode_cli-0.43.0 → lcode_cli-0.44.0}/src/lcode/modes.py

@@ -27,23 +27,23 @@ TITLES = {"code": "local coding agent", "image": "local image generation", "vide
 MEDIA_SERVERS = frozenset({"comfyui", "xai"})  # the MCP catalog's image and video servers
 MEDIA_COMMANDS = ("comfy-mcp", "lcode-mcp-xai")  # the same servers, under any name
 NOTED_FILE = "media-servers-noted"
-COMING = {
-    "video": (
-        "Video mode doesn't generate yet: the video models (#150) and video generation (#153) come next. "
-        "/mode image makes images now; /mode code switches back."
-    ),
-}
+COMING: dict[str, str] = {}
 
 
 def ready(agent: Agent) -> str:
     """What to do in the agent's mode, said on entering it."""
-    if agent.settings.mode == "image":
-        from lcode import media
+    from lcode import media
 
+    if agent.settings.mode == "image":
         return (
             f"Describe an image and press Enter: {media.current(agent).name} makes it on your GPU, into "
             f"{agent.settings.media_dir}. /mode code switches back."
         )
+    if agent.settings.mode == "video":
+        return (
+            f"Describe a video and press Enter (@photo.png starts it from a picture): {media.current(agent).name} "
+            f"makes it on your GPU, into {agent.settings.media_dir}. /mode code switches back."
+        )
     return COMING.get(agent.settings.mode, "")
 
 
@@ -113,7 +113,7 @@ def switch(agent: Agent, new: str) -> list[str]:
     if new == "code" and agent.no_coding_model:
         reason = agent.no_coding_model.strip().splitlines()[0]
         lines.append(f"lcode started without its coding model ({reason}). Fix that, then restart lcode.")
-    if new == "image":
+    if new in ("image", "video"):
         from lcode import media
 
         warming = media.warm(agent)