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

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/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/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.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/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/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/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/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/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/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)

lcode/repl.py

@@ -89,6 +89,8 @@ COMMANDS = {
     "/extend": "Image mode: outpaint an image to a shape or by sides, e.g. /extend 3 --ar 16:9 (or --left 256)",
     "/upscale": "Image mode: 2 or 4 times the pixels, e.g. /upscale 3 4",
     "/nobg": "Image mode: remove the background (a transparent PNG), e.g. /nobg 3",
+    "/animate": "Image mode: make a video starting from an image, e.g. /animate 3 the waves roll in (video mode)",
+    "/play": "Play a video in your player, e.g. /play 4 (default: the last)",
     "/cd": "Change the working directory",
     "/todos": "Show the current todo list",
     "/status": "The task sheet: your requests, the plan and notes, files changed, the last check",
@@ -230,7 +232,7 @@ def model_lines(agent: Agent) -> str:
     if s.mode == "image":
         return f"[dim]model[/]    {escape(media.current(agent).name)} [dim]· ComfyUI · {escape(s.media_dir)}[/]\n"
     if s.mode == "video":
-        return "[dim]model[/]    [dim]video models come with video generation (#153)[/]\n"
+        return f"[dim]model[/]    {escape(media.current(agent).name)} [dim]· ComfyUI · {escape(s.media_dir)}[/]\n"
     server = f" [dim]· {escape(agent.ollama.describe())}[/]" if backends.is_openai(agent.ollama) else ""
     return f"[dim]model[/]    {escape(s.model)}{server}\n[dim]context[/]  {format_tokens(s.context)} tokens\n"
 
@@ -931,13 +933,13 @@ def media_model_command(agent: Agent, arg: str, hardware: Hardware) -> None:
     if model is None:
         c.print(f"[red]There's no {s.mode} model {escape(arg)!r}: choose 1 to {len(choices)}, or a name.[/]")
         return
-    s.image_model = model.key
-    c.print(f"[green]Image model: {escape(model.name)}.[/]")
+    setattr(s, f"{s.mode}_model", model.key)
+    c.print(f"[green]{s.mode.capitalize()} model: {escape(model.name)}.[/]")
     if installed is not None:
         _, missing = catalog.chosen_files(model, installed)
         if missing:
             size = sum(f.gb for f in missing)
-            c.print(f"[dim]Not installed yet: {size:.1f} GB download with your next image (you're asked first).[/]")
+            c.print(f"[dim]Not installed yet: {size:.1f} GB download with your next {s.mode} (you're asked first).[/]")
 
 
 def switch_model(agent: Agent, wanted: str, hardware: Hardware) -> None:
@@ -1347,10 +1349,7 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
         if info:
             resume_session(agent, info)
     session_start(agent)
-    if prompt and agent.settings.mode == "video":
-        agent.console.print(f"[yellow]{escape(modes.ready(agent))}[/]")
-        prompt = None
-    if prompt and agent.settings.mode == "image":
+    if prompt and agent.settings.mode in ("image", "video"):
         respond(agent, prompt)
         return
     if prompt:
@@ -1367,7 +1366,7 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
     if agent.settings.mode == "code":
         preload(agent, session)
     else:
-        warming = media.warm(agent) if agent.settings.mode == "image" else None
+        warming = media.warm(agent)
         if warming:
             agent.say(warming)
         agent.console.print(f"[yellow]{escape(modes.ready(agent))}[/]")
@@ -1396,17 +1395,18 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
 
 def respond(agent: Agent, line: str) -> None:
     """What a typed request does: the coding agent works on it, or image and video mode take it."""
-    if agent.settings.mode == "image":  # no coding model involved
+    if agent.settings.mode in ("image", "video"):  # no coding model involved
         make_image(agent, line)
         return
-    if agent.settings.mode != "code":
-        agent.console.print(f"[yellow]{escape(modes.ready(agent))}[/]")
-        return
     agent.console.print(Rule(style="dim"))
     run_safely(agent, line)
 
 
-IMAGE_COMMANDS = ("/options", "/again", "/vary", "/gallery", "/open", "/edit", "/use", "/extend", "/upscale", "/nobg")
+IMAGE_COMMANDS = (
+    "/options", "/again", "/vary", "/gallery", "/open", "/play", "/edit", "/use", "/extend", "/upscale", "/nobg",
+    "/animate",
+)  # fmt: skip
+VIDEO_TOO = ("/options", "/again", "/vary", "/gallery", "/open", "/play", "/use")  # what video mode shares
 NUMBER = re.compile(r"^#?(\d+)$")
 
 
@@ -1418,9 +1418,10 @@ def image_command(agent: Agent, cmd: str, arg: str) -> None:
     from lcode import edits, imageopts
 
     c = agent.console
+    video = agent.settings.mode == "video"
     if cmd == "/options":
         if not arg.strip():
-            c.print(f"Image options: [bold]{escape(agent.image_options.describe())}[/]")
+            c.print(f"Options: [bold]{escape(agent.image_options.describe(video))}[/]")
             c.print(
                 '[dim]Set them with /options n=4 ar=16:9 seed=42 quality=best style=photo no="text"; '
                 f"styles: {', '.join(imageopts.STYLES)}. Flags in a request (--n 4) win for that request.[/]"
@@ -1431,13 +1432,14 @@ def image_command(agent: Agent, cmd: str, arg: str) -> None:
         except imageopts.OptionError as e:
             c.print(f"[red]{escape(str(e))}[/]")
             return
-        c.print(f"Image options: [bold]{escape(agent.image_options.describe())}[/]")
+        c.print(f"Options: [bold]{escape(agent.image_options.describe(video))}[/]")
         return
     if cmd == "/gallery":
         gallery(agent, everything=arg.strip() == "all")
         return
-    if agent.settings.mode != "image" and cmd != "/open":
-        c.print(f"[yellow]{cmd} works in image mode: /mode image.[/]")
+    if cmd not in ("/open", "/play") and not (agent.settings.mode == "image" or (video and cmd in VIDEO_TOO)):
+        where = "image or video mode" if cmd in VIDEO_TOO else "image mode"
+        c.print(f"[yellow]{cmd} works in {where}: /mode {'image' if where == 'image mode' else 'video'}.[/]")
         return
     first, _, rest = arg.strip().partition(" ")
     number = first if NUMBER.match(first) else ""
@@ -1456,13 +1458,13 @@ def image_command(agent: Agent, cmd: str, arg: str) -> None:
             return
         entry = media.result(agent, f"#{NUMBER.match(number).group(1)}" if number else "")
         source = Path(entry["path"])
-        if cmd == "/open":
+        if cmd in ("/open", "/play"):
             problem = media.open_file(source)
             c.print(f"[yellow]{escape(problem)}[/]" if problem else f"[dim]Opened #{entry['n']}.[/]")
             return
         if cmd == "/vary":
             job = dict(entry.get("job") or {"kind": "image", "sources": [], "mask": None, "pads": None})
-            if entry.get("kind") in ("upscale", "remove-background") or job["kind"] not in ("image", "edit"):
+            if entry.get("kind") in ("upscale", "remove-background") or job["kind"] not in ("image", "edit", "video"):
                 c.print(f"[yellow]#{entry['n']} is {escape(entry['prompt'])}: /vary the image it came from.[/]")
                 return
             job["prompt"] = entry["prompt"] if job["kind"] == "image" else job.get("prompt", entry["prompt"])
@@ -1471,6 +1473,17 @@ def image_command(agent: Agent, cmd: str, arg: str) -> None:
             c.print(f"[dim]Variations of #{entry['n']}: {escape(entry['prompt'])}[/]")
             make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
             return
+        if cmd == "/animate":
+            if not edits.is_image(source):
+                c.print(f"[yellow]#{entry['n']} isn't a picture: /animate takes an image.[/]")
+                return
+            for line in modes.switch(agent, "video"):
+                c.print(f"[dim]{escape(line)}[/]")
+            text, options = imageopts.parse(rest, imageopts.replace_seed(agent.image_options, n=1))
+            job = {"kind": "video", "prompt": text or entry["prompt"], "options": options, "sources": [str(source)],
+                   "mask": None, "pads": None, "keep_shape": "--ar" not in rest and "--size" not in rest}  # fmt: skip
+            make_image(agent, run=lambda cancel, ask: media.redo(agent, job, cancel, ask))
+            return
         if cmd == "/edit":
             text, refs = edits.split_references(rest)
             instruction, options = imageopts.parse(text, imageopts.replace_seed(agent.image_options))
@@ -1571,6 +1584,7 @@ def make_image(agent: Agent, prompt: str = "", options=None, run=None) -> None:
         answer = steering.ask(f"  {question} [y/N] ") if reading else input(f"  {question} [y/N] ")
         return answer.strip().lower() in ("y", "yes")
 
+    started = time.monotonic()
     try:
         asking = ask if agent.interactive else None
         if run is not None:
@@ -1593,6 +1607,7 @@ def make_image(agent: Agent, prompt: str = "", options=None, run=None) -> None:
             agent.unsent = typed
             agent.console.print(Text("✎ What you typed is in the prompt below.", style="cyan"))
         agent.save()  # the gallery and options carry over when the session is resumed
+        agent.finished(prompt or "image or video", time.monotonic() - started)  # a long render: notify
 
 
 def preload(agent: Agent, session: PromptSession | None = None) -> None:

lcode/workflows/wan22-ti2v-5b.json

@@ -0,0 +1,152 @@
+{
+  "source": "ComfyUI's template video_wan2_2_5B_ti2v, in API format",
+  "negative_note": "Wan's own default negative prompt (Chinese): oversaturated, overexposed, static, blurry details, subtitles, worst quality, extra fingers, deformed limbs, cluttered background, walking backwards…",
+  "defaults": {
+    "width": 1280,
+    "height": 704,
+    "length": 121,
+    "fps": 24,
+    "steps": 20,
+    "negative": "色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走"
+  },
+  "labels": {
+    "1": "loading the model",
+    "2": "loading the text encoder",
+    "3": "loading the VAE",
+    "5": "reading the prompt",
+    "6": "reading the prompt",
+    "7": "preparing the frames",
+    "8": "drawing the frames",
+    "9": "decoding the frames",
+    "10": "making the video",
+    "11": "saving"
+  },
+  "graph": {
+    "1": {
+      "class_type": "UNETLoader",
+      "inputs": {
+        "unet_name": "$model",
+        "weight_dtype": "default"
+      }
+    },
+    "2": {
+      "class_type": "CLIPLoader",
+      "inputs": {
+        "clip_name": "$text_encoder",
+        "type": "wan",
+        "device": "default"
+      }
+    },
+    "3": {
+      "class_type": "VAELoader",
+      "inputs": {
+        "vae_name": "$vae"
+      }
+    },
+    "4": {
+      "class_type": "ModelSamplingSD3",
+      "inputs": {
+        "model": [
+          "1",
+          0
+        ],
+        "shift": 8
+      }
+    },
+    "5": {
+      "class_type": "CLIPTextEncode",
+      "inputs": {
+        "text": "$prompt",
+        "clip": [
+          "2",
+          0
+        ]
+      }
+    },
+    "6": {
+      "class_type": "CLIPTextEncode",
+      "inputs": {
+        "text": "$negative",
+        "clip": [
+          "2",
+          0
+        ]
+      }
+    },
+    "7": {
+      "class_type": "Wan22ImageToVideoLatent",
+      "inputs": {
+        "vae": [
+          "3",
+          0
+        ],
+        "width": "$width",
+        "height": "$height",
+        "length": "$length",
+        "batch_size": 1
+      }
+    },
+    "8": {
+      "class_type": "KSampler",
+      "inputs": {
+        "model": [
+          "4",
+          0
+        ],
+        "seed": "$seed",
+        "steps": "$steps",
+        "cfg": 5,
+        "sampler_name": "uni_pc",
+        "scheduler": "simple",
+        "positive": [
+          "5",
+          0
+        ],
+        "negative": [
+          "6",
+          0
+        ],
+        "latent_image": [
+          "7",
+          0
+        ],
+        "denoise": 1
+      }
+    },
+    "9": {
+      "class_type": "VAEDecode",
+      "inputs": {
+        "samples": [
+          "8",
+          0
+        ],
+        "vae": [
+          "3",
+          0
+        ]
+      }
+    },
+    "10": {
+      "class_type": "CreateVideo",
+      "inputs": {
+        "images": [
+          "9",
+          0
+        ],
+        "fps": "$fps"
+      }
+    },
+    "11": {
+      "class_type": "SaveVideo",
+      "inputs": {
+        "video": [
+          "10",
+          0
+        ],
+        "filename_prefix": "lcode/video",
+        "format": "mp4",
+        "codec": "auto"
+      }
+    }
+  }
+}

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

@@ -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.dist-info → lcode_cli-0.44.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-lcode/__init__.py,sha256=SlAe74M7eoZyKxBXWVe_w72XGAaCfPj29sJG6lAuiSc,473
+lcode/__init__.py,sha256=RsG17qPpn7di8jUUOV-g7wyfYOlPM9AIXTiqeUvvG8Y,473
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/acp.py,sha256=d97VV3sbqXdWKhPQQNbYRaDTm8WrUk0mGbDLiOyX7jE,29058
 lcode/action.py,sha256=wuT5F9EJCdEligPeytzmEi8FpahWBhXer528tpuTj_k,16711
-lcode/agent.py,sha256=RVf_gQLwkIYxItYduWB2O0aZu8osKvsRxOBL3UN8ANA,88729
-lcode/api.py,sha256=efsUuIZneUc6Ar6KWerKAoMlMFOlSUtLX4_quplr3t8,17664
+lcode/agent.py,sha256=i2Ks-VSzmBKtq1L0B3yrqsjKKHToxJAH2t3miC5qNWE,88955
+lcode/api.py,sha256=DkAWgcoPk5rwp_NPrnV5RbAnA8QKrvDwpaJzTPAfxxA,17704
 lcode/backends.py,sha256=343alwyDZin-bEhb5-Es4f8ek1oBQUzEvV6RFWR1VZo,21160
 lcode/bench.py,sha256=HxeUfy9Kv_0Rug1HAlDLyHYfYd9dw2bMgbXsvUy9nd4,43096
 lcode/bench_backend.py,sha256=X2fo-zRX92Xp3KMxSsFlWioc2vRupBTtowj5kLME8mw,14287
@@ -11,12 +11,12 @@ lcode/bench_runtime.py,sha256=EjzNgIvUkdbT8cbSy1TpmlyeIk6e-ipjlDFpM7Dnqx0,6835
 lcode/catalog.py,sha256=pZ1azX9OH2r4JE2c6E5OfwywpgS39-W2oXzoCHJhmtM,4141
 lcode/checkpoints.py,sha256=eqPtmPe44-aweWqc2H21ROogwzIt3NpvcUobsaCHoGY,18354
 lcode/checks.py,sha256=haYYIPhadKavGYEhh8YWAaWrPMcfzrpT2i6638f4xjQ,12933
-lcode/cli.py,sha256=ZVafS8V-82SuEldT6VlAcqKEuBabA-HCi8Tk_0IP9Pc,51516
+lcode/cli.py,sha256=gmbgWdKxLeBg-9uANbZKV9aIeafudcRfFXGE8BQK0oQ,51230
 lcode/clipboard.py,sha256=nTSdJyCXPdtjH947RjvB3QvRqnL5HZsS9KB8EkC42cc,5138
 lcode/cloud.py,sha256=q5Dl5GuqWvKzBCIso-eh6yomvEOsnQ0LW8ZgaAGwBxc,2131
 lcode/codesearch.py,sha256=Io8leN1nb_Y-Dvlm9xaGtwUWYXX-ooswuznJV6dGU1s,10766
 lcode/comfy.py,sha256=_pbLVQS_1clsa7awPrxQ7xIOwp5XzyMHPDAagomEswc,26614
-lcode/config.py,sha256=F7CRPdlqW6i9CSapqeU83ClOHOsf-Mxx1sWGXRYI1ac,13861
+lcode/config.py,sha256=cOPG7SqsTEiPwPan_0ILtdLY1m8Qbk6WGyMrWZf5iz4,13989
 lcode/context.py,sha256=wgK16ZcNNnq4ngHx0EmtyKHDFTImciGEmtC5NP8tKJQ,20435
 lcode/edits.py,sha256=iYXSbKv4ZfxP12B1ov6-CLEWvR_tWFUdHRQbER3O8d0,13340
 lcode/escalate.py,sha256=f-_6_moPaHi2kLuJw2JtkzvTkCl6DoBQgYBOCYLhunM,15120
@@ -25,17 +25,17 @@ lcode/frontmatter.py,sha256=Bx0n4vLPhp7ZCWx-g7xqzqNy5VoKBxyeeikh5UFB_gA,2441
 lcode/gitflow.py,sha256=6j_nnCBZXkX1qhTI7K4CyZ5D0NAZLpH96weFEo64AkQ,27913
 lcode/hardware.py,sha256=2VbknZCxTZJwJUD8YWdQ7ryEQo_LcjtoOBOHOU9Y0fw,3085
 lcode/hooks.py,sha256=K0itOiAuH4rxndJ9gne_uCrqby6oWAzFPRrfB3tCq-E,9324
-lcode/imageopts.py,sha256=CQBvuEE-aK5C0wFqgTp1jxcpw-bOU2DJZpBYuqyA88I,7791
+lcode/imageopts.py,sha256=msg8Y3OoP6sg1j3L_0K_WhtwdkV2fQl4_IUMq0QsoCE,8610
 lcode/jobs.py,sha256=P1P3FqI6EqL4LgdMX9YGZwCW0Bh5BRXFA_FnQxpHNjE,5618
 lcode/limits.py,sha256=oJzVQoMyTZ0_Fkpu5t3qxrf9v7Hv9S8U8BRQR5M1aKA,1237
 lcode/lsp.py,sha256=NtSW7xapv7fg2HAQLuYK1nwIqT7nG0LK1hiTpOmla_4,26086
 lcode/matching.py,sha256=2N3_qwKJ5gd8el2m_y_egKkFM9rsF1eUhYJcRCVIp98,14015
-lcode/media.py,sha256=F8jRT8J2GkUVUxEMbK4DT6sykxE4JXnKOQ-7Ntl0RgY,28984
-lcode/media.toml,sha256=QSv1QmeR9XukBBnmTtAxAZKp2-EguIGJmbar4rDM-is,4715
-lcode/media_catalog.py,sha256=geAt3B4mOxTydXFFaYA0wBO9512_115eBPAjAWTUIj4,14331
+lcode/media.py,sha256=MZ4ZSuehInueDRvyYCm1BXRePM5IWk5NE23VGw37C8c,33647
+lcode/media.toml,sha256=gEVwlSLYWOFsYaLj_3J6crY5J6weHYKaqgITtHXs2q4,6010
+lcode/media_catalog.py,sha256=ABHlhvZEAZmei1YzNs70_1kyaS0h0TEzbLZWLISNCkk,14363
 lcode/memory.py,sha256=WZEHTp-lVxAwS-yyLQR2xB3TMZ9sejmX2Ivg7T-tl3w,21949
 lcode/models.toml,sha256=lt2G64zzo_Ryxv2ISRSNZoVD_JqCqYqsM01n8WoXGs8,4098
-lcode/modes.py,sha256=Ke_mEeYF_SskbVUXMpJMeV5d5fFEQ-Vb-MKp4SIvT0Y,4990
+lcode/modes.py,sha256=MG2OuwGxzbPxzP5ax_pdPPxMsjEd5Lv4kCQbCoFKaNo,5095
 lcode/notify.py,sha256=uieDeXe7XwuVHjOk4tqVyZEW_85XWkoWQmFOWEf77oc,1538
 lcode/ollama.py,sha256=xFHU2XW47ANJ34-1aeSMQVj28GhqcWiFi6zASH9FiYY,8053
 lcode/permissions.py,sha256=q7CjDsc_Xrblw7t3_BbxA5LUjxFSswGs1RiJmtMi0po,12288
@@ -43,7 +43,7 @@ lcode/planning.py,sha256=Q2upaoZPnXDMQT2F-ETxX1lk_wDntTzhSKNVYIQSoQA,6540
 lcode/preview.py,sha256=ATzEs6yaI1__bfo2_juWznrTDXUD4QTc_aQMPRCytgA,6253
 lcode/render.py,sha256=gMvf4W3qkLUJ4Vot3az_hP_zRDAItJC9pP-68dHFkfA,1375
 lcode/repeats.py,sha256=OTrPdb6BKArDLQEgHaXmJZ-tIFsY_1bk4P0wzzANKLY,5964
-lcode/repl.py,sha256=OkJ6ClINTE2P3JNKTP1ulu-bTNCtfro12f4w6kM069g,71932
+lcode/repl.py,sha256=VLbVvjGtukGUXOP-Wuj29KbGcLiDnD57CoDexW3dUFU,73153
 lcode/repomap.py,sha256=1GRJgEUjBl9XHSXsF7tSGXBCEgsY-3CzwMohaTudZ_M,13969
 lcode/residency.py,sha256=B9pwqG6yx5aQD2M5xyQ-bMnYmhD7fv3wCVw_X6VIeAo,7012
 lcode/review.py,sha256=0QBIS-R1B2b3zqx5TcC1qZptpKBbrDhYvMKSNCaDAUo,4686
@@ -78,9 +78,10 @@ lcode/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lcode/workflows/flux2-klein-4b-t2i.json,sha256=yGrYDT8pG2bns9DS1JavhlX5fwhDgIKfAwrHrRCyE8k,1788
 lcode/workflows/remove-background.json,sha256=iMNaXqlkcWN-mCQWezD3NUbW94cHN3JcPYsSUsfOl64,794
 lcode/workflows/upscale-esrgan.json,sha256=quDmTnncvycggskgvw6zvfNsub7mS0WY3a4J99fWeXc,745
+lcode/workflows/wan22-ti2v-5b.json,sha256=RcTehoC2pNizzlb7Ed3keJ56DiE7V5lhXmsvR2Y0smQ,3371
 lcode/workflows/z-image-turbo-t2i.json,sha256=sHsL7xnnuULOuWGYlQrDl4jOTySdAmb2T82c_cChv0s,1585
-lcode_cli-0.43.0.dist-info/METADATA,sha256=FjFitYxjlbB2iFty4gVvGqNJKSoys9npCyZubZmm5i4,13386
-lcode_cli-0.43.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.43.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
-lcode_cli-0.43.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.43.0.dist-info/RECORD,,
+lcode_cli-0.44.0.dist-info/METADATA,sha256=bRKpVWXONhz8JdV7UgzC7HdXXCvNHiKaet245hR8-4Q,13469
+lcode_cli-0.44.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.44.0.dist-info/entry_points.txt,sha256=Hxsn_itbnbgft3U0FwxWdmEt0yoAV2LB-nJDnL9WT20,172
+lcode_cli-0.44.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.44.0.dist-info/RECORD,,