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

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

@@ -6,6 +6,34 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.45.0] - 2026-10-24
+
+### Added
+
+- **Video mode: first and last frames, camera moves, longer clips** (#154, part 1). See
+  [Video mode](https://nasser1941.github.io/lcode/modes/#video-mode).
+  - **`@start.png @end.png …`** makes a clip from one picture to the other (Wan 2.2 Fun InP 5B).
+  - **`--camera pan-left`** and twelve other moves (pan, tilt, zoom, dolly, rotate), from a
+    description or a start picture (Wan 2.1 Fun Camera 1.3B, 16 fps).
+  - **`/extend 4 --seconds 3 …`** in video mode continues a clip from its last frame into one
+    longer clip.
+  - lcode picks the model a job needs, installs it when you agree, and says so.
+
+## [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 +982,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.43.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.45.0...HEAD
+[0.45.0]: https://github.com/nasser1941/lcode/compare/v0.44.0...v0.45.0
+[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.45.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.43.0
+Version: 0.45.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.45.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.45.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.45.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,51 @@ 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.
+- **First and last frame:** two pictures, `@start.png @end.png the flower opens`, make a clip that
+  goes from the first to the last. Wan 2.2 Fun InP 5B makes these (a 3 s clip in 62 s at `fast`;
+  `fast` can change abruptly halfway, `balanced` moves more smoothly).
+- **Camera moves:** `--camera pan-left` (also `pan-right`, `pan-up`, `pan-down`, `tilt-up`,
+  `tilt-down`, `zoom-in`, `zoom-out`, `dolly-in`, `dolly-out`, `rotate-left`, `rotate-right`,
+  `static`), from a description or a start picture. Wan 2.1 Fun Camera 1.3B makes these, at 832×480
+  and 16 frames per second: a 3 s move takes about 2 minutes.
+- **Extend a clip:** `/extend 4 --seconds 3 it flies away` continues clip #4 from its last frame
+  and joins the new part after it, as one longer clip (`…-extended.mp4`; 3 s more in about a
+  minute at `fast`).
+- **Which model:** the one you chose (`/models`) makes ordinary clips. For first and last frames or a
+  camera move, lcode uses the model that can, installs it when you agree, and says so.
+- **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 +278,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:** several reference images, smoother and bigger clips (frame interpolation,
+  upscaling), restyling a video, and sound.
 - **#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.45.0}/docs/quickstart.md

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

{lcode_cli-0.43.0 → lcode_cli-0.45.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.45.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.45.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.43.0 → lcode_cli-0.45.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.45.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.45.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.45.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.45.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",
@@ -34,6 +35,21 @@ STYLES = {
     "comic": "comic book art, bold ink outlines, halftone shading",
     "flat": "flat vector illustration, minimal, bold shapes",
 }
+CAMERA = {  # video: --camera name -> the camera model's pose
+    "static": "Static",
+    "pan-left": "Pan Left",
+    "pan-right": "Pan Right",
+    "pan-up": "Pan Up",
+    "pan-down": "Pan Down",
+    "tilt-up": "Pan Up",
+    "tilt-down": "Pan Down",
+    "zoom-in": "Zoom In",
+    "zoom-out": "Zoom Out",
+    "dolly-in": "Zoom In",
+    "dolly-out": "Zoom Out",
+    "rotate-left": "Anti Clockwise (ACW)",
+    "rotate-right": "ClockWise (CW)",
+}
 ALIASES = {
     "n": "n",
     "count": "n",
@@ -46,6 +62,9 @@ ALIASES = {
     "no": "negative",
     "negative": "negative",
     "style": "style",
+    "seconds": "seconds",
+    "duration": "seconds",
+    "camera": "camera",
 }
 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 +83,16 @@ class Options:
     quality: str = "balanced"
     negative: str = ""
     style: str = ""
+    seconds: float = 5.0  # video only
+    camera: str = ""  # video only: a move from CAMERA, made by a camera-control model
 
-    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.camera:
+                parts.append(f"camera={self.camera}")
         if self.style:
             parts.append(f"style={self.style}")
         if self.negative:
@@ -92,7 +117,9 @@ 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, seconds or camera"
+            )
         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 +147,21 @@ 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 == "camera":
+            if value.lower() in ("none", "off", ""):
+                out.camera = ""
+            elif value.lower() in CAMERA:
+                out.camera = value.lower()
+            else:
+                raise OptionError(f"camera is one of {', '.join(CAMERA)} (or none)")
+        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 +245,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