lcode-cli 0.38.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

lcode/__init__.py

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

lcode/agent.py

@@ -304,6 +304,10 @@ class Progress:
 class Settings:
     model: str  # Ollama model name to call
     context: int
+    mode: str = "code"  # what lcode makes: code, image or video (lcode.modes)
+    comfyui_url: str = "http://127.0.0.1:8188"
+    comfyui_path: str | None = None  # a ComfyUI install lcode doesn't find by itself (lcode.comfy)
+    media_dir: str = ".lcode/media"  # where image and video mode save their files (lcode.media)
     num_batch: int | None = None
     keep_alive: str = "30m"
     think: bool = True
@@ -368,6 +372,8 @@ class Agent:
         self.session_name = ""
         self.session_title = ""
         self.interactive = True  # False for `lcode -p`: no end-of-session questions
+        self.comfy_process = None  # the ComfyUI lcode started for image and video mode, stopped when it exits
+        self.no_coding_model = ""  # why there's no coding model, when lcode started in image or video mode without
         self.reflected = 0  # messages before this index were already checked for notes to remember
         self._memory: memory_notes.Memory | None = None
         self._agent_types: tuple[Path, dict[str, subagents.AgentType], list[str]] | None = None
@@ -680,6 +686,7 @@ class Agent:
         data = {
             "cwd": str(self.workspace),  # where `lcode -c` there finds it, wherever the shell moved
             "model": self.settings.model,
+            "mode": self.settings.mode,
             "name": self.session_name,
             "title": self.session_title,
             "messages": self.messages,
@@ -726,6 +733,8 @@ class Agent:
         self.session_id = info.id
         self.checkpoints.load(info.id, data.get("checkpoints") or [])
         self.session_name = data.get("name", "")
+        if data.get("mode") in ("code", "image", "video"):
+            self.settings.mode = data["mode"]  # a session belongs to the mode it was made in
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
         self.tools.todos = list(data.get("todos") or [])

lcode/api.py

@@ -15,6 +15,7 @@ A session is one conversation: each `run` continues it. `stream` yields the same
 
 from __future__ import annotations
 
+import contextlib
 import io
 import queue
 import threading
@@ -54,6 +55,7 @@ class Options:
     model: str | None = None
     context: int | str | None = None
     permission_mode: str | None = None  # ask, plan, auto-edit or yolo
+    mode: str | None = None  # code, image or video
     allowed_tools: list[str] | None = None  # only these tools (default: all)
     max_steps: int | None = None  # model steps per request
     think: bool | None = None
@@ -129,6 +131,24 @@ def switch(wanted: bool | None, configured: str, default_on: str) -> str:
     return configured if configured != "off" else default_on
 
 
+def coding_model(ollama, options: Options, cfg: dict, requested: int | None, hw: Hardware, console: Console):
+    """The coding model to use, its catalog entry and the context window; SetupError when there's none."""
+    from lcode import cli
+
+    check_server(ollama, hw)
+    try:
+        model, spec = cli.resolve_model(ollama, options.model or cfg["model"])
+    except cli.NotInstalled as e:
+        first_run = not options.model and cfg["model"] == config.DEFAULT_MODEL and not config.CONFIG_PATH.exists()
+        if first_run and not backends.is_openai(ollama):
+            raise SetupError("lcode isn't set up yet. Run:  lcode setup") from e
+        raise SetupError(str(e)) from e
+    context, note = cli.choose_context(ollama, model, spec, requested, hw)
+    if note:
+        console.print(f"[yellow]Context {config.format_tokens(context)}: {note}[/]")
+    return model, spec, context
+
+
 def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | None = None) -> Agent:
     """An agent set up the way `lcode` sets up a session: model, context, hooks, language servers, MCP."""
     from lcode import catalog, cli, extensions, hooks
@@ -152,17 +172,14 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
     except OllamaError as e:
         raise SetupError(str(e)) from e
     hw = hw or detect()
-    check_server(ollama, hw)
+    no_coding_model = ""  # why, when image or video mode starts without one
     try:
-        model, spec = cli.resolve_model(ollama, options.model or cfg["model"])
-    except cli.NotInstalled as e:
-        first_run = not options.model and cfg["model"] == config.DEFAULT_MODEL and not config.CONFIG_PATH.exists()
-        if first_run and not backends.is_openai(ollama):
-            raise SetupError("lcode isn't set up yet. Run:  lcode setup") from e
-        raise SetupError(str(e)) from e
-    context, note = cli.choose_context(ollama, model, spec, requested, hw)
-    if note:
-        console.print(f"[yellow]Context {config.format_tokens(context)}: {note}[/]")
+        model, spec, context = coding_model(ollama, options, cfg, requested, hw, console)
+    except SetupError as e:
+        if (options.mode or cfg["mode"]) == "code":
+            raise
+        # Image and video mode don't need the coding model: start without it, and say so on /mode code.
+        model, spec, context, no_coding_model = options.model or cfg["model"], None, requested or 32768, str(e)
     num_batch = cfg["num_batch"]
     if num_batch is None and spec and spec.num_batch:
         if model == spec.local_name:
@@ -179,6 +196,10 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         think=cfg["think"] if options.think is None else options.think,
         show_thinking=options.show_thinking,
         permission_mode=options.permission_mode or cfg["permission_mode"],
+        mode=options.mode or cfg["mode"],
+        comfyui_url=cfg["comfyui_url"],
+        comfyui_path=cfg["comfyui_path"],
+        media_dir=cfg["media_dir"],
         web=switch(options.web, cfg["web"], "on"),
         search_backend=cfg["search_backend"],
         searxng_url=cfg["searxng_url"],
@@ -208,6 +229,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.hardware = hw
+    agent.no_coding_model = no_coding_model
     agent.autosave = True
     agent.interactive = options.interactive
     if options.max_steps:
@@ -247,15 +269,25 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
 
 
 def close_agent(agent: Agent) -> None:
+    """Stop what lcode started (background jobs, servers, the sandbox, ComfyUI), then say so: the terminal may be
+    gone already (closed), and saying it then fails."""
+    from lcode import media
+
+    said = []
     stopped = agent.jobs.stop_all()
     if stopped:
-        agent.console.print(f"[dim]Stopped {stopped} background job(s).[/]")
+        said.append(f"Stopped {stopped} background job(s).")
+    if media.stop_engine(agent):
+        said.append("Stopped ComfyUI.")
     if agent.lsp is not None:
         agent.lsp.close()
     if agent.mcp:
         agent.mcp.close()
     if agent.sandbox:
         agent.sandbox.stop()
+    for line in said:
+        with contextlib.suppress(OSError):
+            agent.console.print(f"[dim]{line}[/]")
 
 
 # ----------------------------------------------------------------------------- running

lcode/cli.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import argparse
+import contextlib
 import platform
 import re
 import shutil
+import signal
 import sys
 import tempfile
 import time
@@ -466,6 +468,7 @@ def cmd_doctor(args) -> None:
     except ValueError as e:
         line("MCP", str(e), False)
         ok = False
+    line("ComfyUI", *comfyui_status(cfg))
     if cfg["sandbox"] == "off":
         line("Sandbox", "off (lcode config set sandbox docker)", True)
     else:
@@ -714,6 +717,7 @@ def cmd_chat(args) -> None:
         model=args.model,
         context=args.context,
         permission_mode=mode,
+        mode=args.mode,
         allowed_tools=tools,
         max_steps=args.max_steps,
         think=False if args.no_think else None,
@@ -732,7 +736,10 @@ def cmd_chat(args) -> None:
             print(json.dumps({"type": "result", "status": "error", "error": str(e)}), flush=True)
             sys.exit(1)
         fail(str(e))
+    exit_on_hangup()
     exit_code = 0
+    if args.prompt and agent.settings.mode != "code":
+        media_request(agent, args.prompt, out, quiet)  # makes the image or video, then exits
     if args.escalate and args.prompt:
         agent.escalate_approved = True  # the flag is the user's OK for this run
     try:
@@ -754,6 +761,83 @@ def cmd_chat(args) -> None:
         sys.exit(exit_code)
 
 
+def exit_on_hangup() -> None:
+    """A closed terminal (SIGHUP) or a plain kill (SIGTERM) ends lcode the usual way: it saves the session and stops
+    what it started (ComfyUI, MCP servers, background jobs) instead of leaving them running."""
+
+    def leave(signum, frame):
+        raise SystemExit(128 + signum)
+
+    for name in ("SIGHUP", "SIGTERM"):
+        sig = getattr(signal, name, None)
+        if sig is not None:
+            with contextlib.suppress(ValueError, OSError):  # only the main thread can
+                signal.signal(sig, leave)
+
+
+def comfyui_status(cfg: dict) -> tuple[str, bool | None]:
+    """lcode doctor's ComfyUI line: running or found, and whether the image model is there."""
+    from lcode import comfy, media
+
+    workflow = comfy.load_workflow(media.IMAGE_WORKFLOW)
+    server = comfy.Server(cfg["comfyui_url"])
+    stats = server.stats()
+    install = None if stats else comfy.find_install(cfg["comfyui_path"])
+    if not stats and install is None:
+        return "not found: image mode offers to install it (or lcode config set comfyui_path <folder>)", None
+    if stats:
+        where = f"{(stats.get('system') or {}).get('comfyui_version', '?')} running at {server.url}"
+        installed = {folder: set(server.models(folder)) for folder in workflow.models}
+    else:
+        where = f"{install.path} (lcode starts it in image mode)"
+        installed = {folder: set(comfy.local_models(install, folder)) for folder in workflow.models}
+    missing = [f"{f}/{names[0]}" for f, names in workflow.models.items() if not installed[f] & set(names)]
+    if missing:
+        return f"{where} · {workflow.name} not installed (missing {', '.join(missing)})", None
+    return f"{where} · image model: {workflow.name}", True
+
+
+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
+
+    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.generate_image(agent, prompt)
+    except (media.MediaError, KeyboardInterrupt) as e:
+        message = str(e) or "Cancelled."
+        if quiet:
+            print(json.dumps({"type": "result", "status": "error", "error": message}), flush=True)
+        else:
+            out.print(f"[red]{escape(message)}[/]")
+        api.close_agent(agent)
+        sys.exit(1)
+    if quiet:
+        result = {
+            "type": "result",
+            "status": "success",
+            "mode": "image",
+            "files": [str(path) for path in made.files],
+            "model": made.model,
+            "seed": made.seed,
+            "width": made.width,
+            "height": made.height,
+            "seconds": round(made.seconds, 1),
+        }
+        print(json.dumps(result, ensure_ascii=False), flush=True)
+    api.close_agent(agent)
+    sys.exit(0)
+
+
 def compact_tokens(value: str) -> int:
     """`--compact-at`: a token count such as 64k, or 0."""
     try:
@@ -798,6 +882,7 @@ def build_parser() -> argparse.ArgumentParser:
         help="work in a git worktree of its own, on branch NAME (new, or continue one); removed if nothing changed",
     )
     parser.add_argument("--plan", action="store_true", help="start in plan mode: agree on a plan before any change")
+    parser.add_argument("--mode", choices=config.WORK_MODES, help="what lcode makes: code (default), image or video")
     parser.add_argument("--auto-edit", action="store_true", help="apply file edits without asking")
     parser.add_argument("--yolo", action="store_true", help="never ask for permission (edits and commands)")
     parser.add_argument(