vidwit 1.0.0__py3-none-any.whl

vidwit/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

vidwit/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

vidwit/assembler.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+
+_WARNING_RE = re.compile(r"\[⚠[^\]]*\]")
+
+
+def assemble(chunks_dir: Path, video_name: str) -> str:
+    """Concatenate chunk_*.md into one witness document with TOC + warnings index."""
+    files = sorted(chunks_dir.glob("chunk_*.md"))
+    if not files:
+        raise FileNotFoundError(f"no chunks under {chunks_dir}")
+
+    bodies = [p.read_text(encoding="utf-8").rstrip() for p in files]
+    full_body = "\n\n".join(bodies)
+
+    warnings = sorted(set(_WARNING_RE.findall(full_body)))
+    toc = _build_toc(bodies)
+
+    header = [f"# vidwit — {video_name}", ""]
+    if warnings:
+        header += ["## Content warnings", ""]
+        header += [f"- {w}" for w in warnings]
+        header += [""]
+    if toc:
+        header += ["## Table of contents", ""]
+        header += toc
+        header += [""]
+    header += ["---", ""]
+    return "\n".join(header) + full_body + "\n"
+
+
+def _build_toc(bodies: list[str]) -> list[str]:
+    lines = []
+    for b in bodies:
+        for ln in b.splitlines():
+            m = re.match(r"^###\s+(.*)$", ln)
+            if m:
+                lines.append(f"- {m.group(1).strip()}")
+                break
+    return lines

vidwit/chunker.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True, frozen=True)
+class Window:
+    index: int
+    start: float  # seconds, inclusive
+    end: float    # seconds, half-open
+
+    @property
+    def label(self) -> str:
+        return f"chunk_{self.index:04d}"
+
+
+def windows(duration_s: float, window_s: float, overlap_s: float) -> list[Window]:
+    """Half-open windows [start, end) covering duration. Stride = window - overlap.
+
+    Adjacent windows overlap by overlap_s. Final window is clamped to duration.
+    """
+    if window_s <= 0:
+        raise ValueError("window_s must be > 0")
+    if not 0 <= overlap_s < window_s:
+        raise ValueError("overlap_s must satisfy 0 <= overlap < window")
+    stride = window_s - overlap_s
+    out: list[Window] = []
+    i = 0
+    start = 0.0
+    while start < duration_s:
+        end = min(start + window_s, duration_s)
+        out.append(Window(index=i, start=start, end=end))
+        if end >= duration_s:
+            break
+        start += stride
+        i += 1
+    return out

vidwit/cli.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from dataclasses import replace
+from pathlib import Path
+
+from . import __version__, config as cfg_mod, init_cmd, pipeline
+
+
+def main(argv: list[str] | None = None) -> int:
+    raw = sys.argv[1:] if argv is None else argv
+    if raw and raw[0] == "init":
+        return init_cmd.run(raw[1:])
+
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s | %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    cfg = _make_config(args)
+
+    inputs = _expand_inputs(args.inputs, cfg.video_exts)
+    if not inputs:
+        print("vidwit: no video inputs", file=sys.stderr)
+        return 2
+    if cfg.output_override is not None and len(inputs) > 1:
+        print(
+            f"vidwit: -o/--output works only with a single input video "
+            f"(got {len(inputs)}). Use --paths home:DIR to redirect a batch.",
+            file=sys.stderr,
+        )
+        return 2
+
+    rc = 0
+    for v in inputs:
+        try:
+            pipeline.run_one(v, cfg)
+        except FileExistsError as e:
+            print(f"vidwit: {e}", file=sys.stderr)
+            rc = 1
+        except Exception as e:
+            logging.exception("failed: %s", v)
+            print(f"vidwit: error on {v}: {e}", file=sys.stderr)
+            rc = 1
+    return rc
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="vidwit",
+        description="Multimodal video witness — emit exhaustive markdown next to each video.",
+        epilog="Run `vidwit init` to drop a starter vidwit.toml into the current "
+               "directory (or `vidwit init --user` for ~/.config/vidwit/).",
+    )
+    p.add_argument("inputs", nargs="+", help="video file(s) or directory(ies)")
+    p.add_argument("--config", type=Path, default=None,
+                   help="path to vidwit.toml (default: ./vidwit.toml or ~/.config/vidwit/vidwit.toml)")
+    p.add_argument("--fps", type=float, default=None, help="frame sampling rate (default 1.0)")
+    p.add_argument("--window", type=float, default=None, help="window length seconds (default 10.0)")
+    p.add_argument("--overlap", type=float, default=None, help="window overlap seconds (default 1.0)")
+    p.add_argument("--overwrite", action="store_true", help="replace existing .md")
+    p.add_argument(
+        "--no-resume", action="store_true",
+        help="force re-run; ignore cached transcript/frames/chunks in scratch dir",
+    )
+    p.add_argument("--keep-scratch", action="store_true", help="don't delete scratch dir on success")
+    p.add_argument("--jobs", type=int, default=None, help="threads for ffmpeg/whisper (default nproc)")
+    p.add_argument(
+        "--paths",
+        action="append",
+        default=[],
+        metavar="KEY:VAL",
+        help="yt-dlp style overrides: home:<dir> for final .md, temp:<dir> for scratch. Repeatable.",
+    )
+    p.add_argument("--ext", action="append", default=[], help="extra video extension (repeatable)")
+    p.add_argument("--default-speaker", default=None, help="label transcribed words with this name")
+    p.add_argument("--prompt", type=Path, default=None, help="path to system prompt markdown")
+    p.add_argument("--audio-language", default=None,
+                   help="ISO language hint for whisper (e.g. 'de'); skips auto-detect")
+    p.add_argument("--notes", default=None,
+                   help="free-text context forwarded to the LLM in every chunk")
+    p.add_argument("-o", "--output", type=Path, default=None,
+                   help="explicit output path (single-input only); relative or absolute")
+    p.add_argument("--frame-width", type=int, default=None,
+                   help="downscale frames to fit within this width (default 256)")
+    p.add_argument("--frame-height", type=int, default=None,
+                   help="downscale frames to fit within this height (default 144)")
+    p.add_argument(
+        "--max-tokens", type=int, default=None,
+        help="cumulative LLM token cap per video; abort and assemble what is "
+             "done when exceeded. None = no cap.",
+    )
+
+    llm = p.add_argument_group("LLM")
+    llm.add_argument("--llm", dest="llm_provider", default=None,
+                     choices=["dummy", "anthropic", "openai", "lmstudio"])
+    llm.add_argument("--model", dest="llm_model", default=None)
+    llm.add_argument("--base-url", dest="llm_base_url", default=None,
+                     help="OpenAI-compatible endpoint (e.g. http://localhost:1234/v1)")
+    llm.add_argument("--timeout", dest="llm_timeout", type=float, default=None,
+                     help="HTTP timeout for LLM requests in seconds (default 600)")
+    llm.add_argument(
+        "--extra-body", dest="llm_extra_body", action="append", default=[],
+        metavar="KEY=JSON",
+        help="extra field merged into the chat-completions request payload. "
+             "VALUE is parsed as JSON; falls back to string on parse failure. "
+             "Repeatable. Example: "
+             "--extra-body 'chat_template_kwargs={\"enable_thinking\":false}'",
+    )
+
+    p.add_argument("--whisper-model", default=None,
+                   help="whisper model name (tiny, base, small, medium, large-v3)")
+    p.add_argument("--whisper-device", default=None, choices=["auto", "cpu", "cuda"])
+
+    p.add_argument("-v", "--verbose", action="store_true")
+    p.add_argument("--version", action="version", version=f"vidwit {__version__}")
+    return p
+
+
+def _make_config(args: argparse.Namespace) -> cfg_mod.Config:
+    cfg = cfg_mod.Config()
+    config_path = args.config or cfg_mod.find_config_file()
+    if config_path is not None:
+        if args.config is not None and not config_path.exists():
+            raise SystemExit(f"vidwit: --config {config_path} not found")
+        cfg = cfg_mod.from_file(config_path, cfg)
+        logging.getLogger("vidwit").info("loaded config: %s", config_path)
+    cfg = cfg_mod.from_env(cfg)
+
+    if args.fps is not None: cfg = replace(cfg, fps=args.fps)
+    if args.window is not None: cfg = replace(cfg, window=args.window)
+    if args.overlap is not None: cfg = replace(cfg, overlap=args.overlap)
+    if args.overwrite: cfg = replace(cfg, overwrite=True)
+    if args.no_resume: cfg = replace(cfg, resume=False)
+    if args.keep_scratch: cfg = replace(cfg, keep_scratch=True)
+    if args.jobs is not None: cfg = replace(cfg, jobs=args.jobs)
+    if args.default_speaker: cfg = replace(cfg, default_speaker=args.default_speaker)
+    if args.prompt: cfg = replace(cfg, prompt_path=args.prompt)
+    if args.audio_language: cfg = replace(cfg, audio_language=args.audio_language)
+    if args.notes: cfg = replace(cfg, notes=args.notes)
+    if args.output: cfg = replace(cfg, output_override=args.output.expanduser())
+    if args.frame_width is not None: cfg = replace(cfg, frame_width=args.frame_width)
+    if args.frame_height is not None: cfg = replace(cfg, frame_height=args.frame_height)
+    if args.max_tokens is not None: cfg = replace(cfg, max_tokens=args.max_tokens)
+    if args.whisper_model: cfg = replace(cfg, whisper_model=args.whisper_model)
+    if args.whisper_device: cfg = replace(cfg, whisper_device=args.whisper_device)
+
+    if args.ext:
+        exts = tuple({*cfg.video_exts, *(_normalise_ext(e) for e in args.ext)})
+        cfg = replace(cfg, video_exts=exts)
+
+    home, temp = _parse_paths(args.paths)
+    if home: cfg = replace(cfg, paths_home=home)
+    if temp: cfg = replace(cfg, paths_temp=temp)
+
+    llm = cfg.llm
+    if args.llm_provider: llm = replace(llm, provider=args.llm_provider)
+    if args.llm_model: llm = replace(llm, model=args.llm_model)
+    if args.llm_base_url: llm = replace(llm, base_url=args.llm_base_url)
+    if args.llm_timeout is not None: llm = replace(llm, request_timeout=args.llm_timeout)
+    if args.llm_extra_body:
+        merged = {**llm.extra_body, **_parse_extra_body(args.llm_extra_body)}
+        llm = replace(llm, extra_body=merged)
+    cfg = replace(cfg, llm=llm)
+
+    return cfg
+
+
+def _parse_paths(items: list[str]) -> tuple[Path | None, Path | None]:
+    home = temp = None
+    for raw in items:
+        if ":" not in raw:
+            raise SystemExit(f"--paths expects KEY:VAL, got {raw!r}")
+        key, val = raw.split(":", 1)
+        key = key.strip().lower()
+        path = Path(val).expanduser()
+        if key == "home":
+            home = path
+        elif key == "temp":
+            temp = path
+        else:
+            raise SystemExit(f"--paths unknown key {key!r} (want home or temp)")
+    return home, temp
+
+
+def _parse_extra_body(items: list[str]) -> dict:
+    out: dict = {}
+    for raw in items:
+        if "=" not in raw:
+            raise SystemExit(f"--extra-body expects KEY=VALUE, got {raw!r}")
+        key, val = raw.split("=", 1)
+        key = key.strip()
+        try:
+            parsed = json.loads(val)
+        except json.JSONDecodeError:
+            parsed = val
+        out[key] = parsed
+    return out
+
+
+def _normalise_ext(ext: str) -> str:
+    ext = ext.strip().lower()
+    return ext if ext.startswith(".") else f".{ext}"
+
+
+def _expand_inputs(args: list[str], exts: tuple[str, ...]) -> list[Path]:
+    out: list[Path] = []
+    ext_set = {e.lower() for e in exts}
+    for raw in args:
+        p = Path(raw).expanduser()
+        if not p.exists():
+            print(f"vidwit: not found: {p}", file=sys.stderr)
+            continue
+        if p.is_dir():
+            for f in sorted(p.rglob("*")):
+                if f.is_file() and f.suffix.lower() in ext_set:
+                    out.append(f)
+        elif p.is_file():
+            out.append(p)
+    # Dedupe, keep order.
+    seen: set[Path] = set()
+    unique: list[Path] = []
+    for f in out:
+        r = f.resolve()
+        if r not in seen:
+            seen.add(r)
+            unique.append(f)
+    return unique
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

vidwit/config.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+
+
+DEFAULT_VIDEO_EXTS = (".mp4", ".mkv", ".mov", ".webm", ".avi")
+
+CONFIG_FILENAME = "vidwit.toml"
+
+
+@dataclass(slots=True)
+class LLMConfig:
+    provider: str = "dummy"  # "anthropic" | "openai" | "lmstudio" | "dummy"
+    model: str = ""
+    base_url: str | None = None
+    api_key: str | None = None
+    max_output_tokens: int = 2048
+    request_timeout: float = 600.0          # seconds; bumped for slow local models
+    extra_body: dict = field(default_factory=dict)  # merged into chat-completions payload
+
+
+@dataclass(slots=True)
+class Config:
+    fps: float = 1.0
+    window: float = 10.0
+    overlap: float = 1.0
+    overwrite: bool = False
+    resume: bool = True  # reuse cached transcript/frames/chunks from scratch dir
+    keep_scratch: bool = False
+    jobs: int = field(default_factory=lambda: max(1, os.cpu_count() or 1))
+    paths_home: Path | None = None  # final .md output dir override
+    paths_temp: Path | None = None  # scratch dir override
+    video_exts: tuple[str, ...] = DEFAULT_VIDEO_EXTS
+    default_speaker: str | None = None
+    prompt_path: Path | None = None
+    whisper_model: str = "small"
+    whisper_device: str = "auto"  # "auto" | "cpu" | "cuda"
+    audio_language: str | None = None  # ISO code, e.g. "de"; forces whisper language
+    notes: str | None = None           # free-text forwarded to LLM capture metadata
+    output_override: Path | None = None  # explicit -o/--output path; single-input only
+    frame_width: int = 256             # downscale frames to fit within W x H (aspect preserved)
+    frame_height: int = 144
+    max_tokens: int | None = None      # cumulative LLM token cap per video; abort + assemble when exceeded
+    llm: LLMConfig = field(default_factory=LLMConfig)
+
+
+def from_env(base: Config | None = None) -> Config:
+    cfg = base or Config()
+    env = os.environ
+    return replace(
+        cfg,
+        whisper_model=env.get("VIDWIT_WHISPER_MODEL", cfg.whisper_model),
+        whisper_device=env.get("VIDWIT_WHISPER_DEVICE", cfg.whisper_device),
+        llm=LLMConfig(
+            provider=env.get("VIDWIT_LLM_PROVIDER", cfg.llm.provider),
+            model=env.get("VIDWIT_LLM_MODEL", cfg.llm.model),
+            base_url=env.get("VIDWIT_LLM_BASE_URL", cfg.llm.base_url),
+            api_key=env.get(
+                "VIDWIT_LLM_API_KEY",
+                env.get("ANTHROPIC_API_KEY") or env.get("OPENAI_API_KEY") or cfg.llm.api_key,
+            ),
+            max_output_tokens=int(
+                env.get("VIDWIT_LLM_MAX_OUTPUT_TOKENS", cfg.llm.max_output_tokens)
+            ),
+        ),
+    )
+
+
+def from_file(path: Path, base: Config | None = None) -> Config:
+    """Load TOML config. Unknown keys ignored. Empty/missing file → base unchanged."""
+    cfg = base or Config()
+    if not path.exists():
+        return cfg
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+
+    defaults = data.get("defaults", {}) or {}
+    cfg = replace(
+        cfg,
+        fps=float(defaults.get("fps", cfg.fps)),
+        window=float(defaults.get("window", cfg.window)),
+        overlap=float(defaults.get("overlap", cfg.overlap)),
+        jobs=int(defaults.get("jobs", cfg.jobs)),
+        default_speaker=defaults.get("default_speaker", cfg.default_speaker),
+        prompt_path=Path(defaults["prompt"]).expanduser() if "prompt" in defaults else cfg.prompt_path,
+        frame_width=int(defaults.get("frame_width", cfg.frame_width)),
+        frame_height=int(defaults.get("frame_height", cfg.frame_height)),
+        max_tokens=defaults.get("max_tokens", cfg.max_tokens),
+    )
+
+    whisper = data.get("whisper", {}) or {}
+    cfg = replace(
+        cfg,
+        whisper_model=whisper.get("model", cfg.whisper_model),
+        whisper_device=whisper.get("device", cfg.whisper_device),
+    )
+
+    video = data.get("video", {}) or {}
+    cfg = replace(
+        cfg,
+        audio_language=video.get("audio_language", cfg.audio_language),
+        notes=video.get("notes", cfg.notes),
+    )
+
+    llm_data = data.get("llm", {}) or {}
+    eb = llm_data.get("extra_body") or {}
+    cfg = replace(
+        cfg,
+        llm=LLMConfig(
+            provider=llm_data.get("provider", cfg.llm.provider),
+            model=llm_data.get("model", cfg.llm.model),
+            base_url=llm_data.get("base_url", cfg.llm.base_url),
+            api_key=llm_data.get("api_key", cfg.llm.api_key),
+            max_output_tokens=int(llm_data.get("max_output_tokens", cfg.llm.max_output_tokens)),
+            request_timeout=float(llm_data.get("request_timeout", cfg.llm.request_timeout)),
+            extra_body=dict(eb) if isinstance(eb, dict) else {},
+        ),
+    )
+
+    paths = data.get("paths", {}) or {}
+    cfg = replace(
+        cfg,
+        paths_home=Path(paths["home"]).expanduser() if "home" in paths else cfg.paths_home,
+        paths_temp=Path(paths["temp"]).expanduser() if "temp" in paths else cfg.paths_temp,
+    )
+    return cfg
+
+
+def find_config_file() -> Path | None:
+    """Search standard locations for a vidwit.toml. First hit wins."""
+    cwd = Path.cwd() / CONFIG_FILENAME
+    xdg = Path(os.environ.get("XDG_CONFIG_HOME") or (Path.home() / ".config"))
+    home = xdg / "vidwit" / CONFIG_FILENAME
+    for cand in (cwd, home):
+        if cand.is_file():
+            return cand
+    return None

vidwit/ffmpeg_io.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+class FFmpegMissingError(RuntimeError):
+    pass
+
+
+def require_ffmpeg() -> None:
+    if shutil.which("ffmpeg") is None or shutil.which("ffprobe") is None:
+        raise FFmpegMissingError("ffmpeg + ffprobe required on PATH")
+
+
+@dataclass(slots=True, frozen=True)
+class VideoInfo:
+    path: Path
+    duration_s: float
+    width: int
+    height: int
+    has_audio: bool
+
+
+def probe(path: Path) -> VideoInfo:
+    require_ffmpeg()
+    out = subprocess.run(
+        [
+            "ffprobe", "-v", "error",
+            "-print_format", "json",
+            "-show_format",
+            "-show_streams",
+            str(path),
+        ],
+        check=True, capture_output=True, text=True,
+    ).stdout
+    data = json.loads(out)
+    duration = float(data.get("format", {}).get("duration", 0.0))
+    width = height = 0
+    has_audio = False
+    for s in data.get("streams", []):
+        if s.get("codec_type") == "video" and width == 0:
+            width = int(s.get("width", 0))
+            height = int(s.get("height", 0))
+        if s.get("codec_type") == "audio":
+            has_audio = True
+    return VideoInfo(path=path, duration_s=duration, width=width, height=height, has_audio=has_audio)
+
+
+def extract_audio(src: Path, dst: Path, sample_rate: int = 16000, threads: int = 0) -> Path:
+    """Extract mono PCM WAV at sample_rate; whisper expects 16k mono."""
+    require_ffmpeg()
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [
+            "ffmpeg", "-v", "error", "-y",
+            "-i", str(src),
+            "-vn", "-ac", "1", "-ar", str(sample_rate),
+            "-c:a", "pcm_s16le",
+            "-threads", str(threads),
+            str(dst),
+        ],
+        check=True,
+    )
+    return dst
+
+
+def extract_frames(
+    src: Path,
+    dst_dir: Path,
+    fps: float,
+    threads: int = 0,
+    quality: int = 4,
+    max_width: int | None = None,
+    max_height: int | None = None,
+) -> list[Path]:
+    """Extract frames at given fps as JPEG. Returns paths sorted by index.
+
+    If max_width and max_height are set, frames are downscaled to fit within
+    that box while preserving aspect ratio (no padding). 0 / None disables.
+    """
+    require_ffmpeg()
+    dst_dir.mkdir(parents=True, exist_ok=True)
+    pattern = dst_dir / "f_%08d.jpg"
+    vf = f"fps={fps}"
+    if max_width and max_height:
+        vf += f",scale={max_width}:{max_height}:force_original_aspect_ratio=decrease"
+    subprocess.run(
+        [
+            "ffmpeg", "-v", "error", "-y",
+            "-i", str(src),
+            "-vf", vf,
+            "-q:v", str(quality),
+            "-threads", str(threads),
+            str(pattern),
+        ],
+        check=True,
+    )
+    return sorted(dst_dir.glob("f_*.jpg"))

vidwit/init_cmd.py

@@ -0,0 +1,71 @@
+"""`vidwit init` — drop the bundled sample config (and optional prompt)
+into the current directory or `~/.config/vidwit/` so a fresh
+`pip install vidwit` user can start configuring without cloning the repo.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from importlib.resources import files
+from pathlib import Path
+
+
+def run(argv: list[str]) -> int:
+    p = argparse.ArgumentParser(
+        prog="vidwit init",
+        description="Write a starter vidwit.toml (and optionally a prompt template) "
+                    "to the current directory or ~/.config/vidwit/.",
+    )
+    p.add_argument(
+        "--user", action="store_true",
+        help="write to ~/.config/vidwit/ instead of the current directory",
+    )
+    p.add_argument(
+        "--prompt", action="store_true",
+        help="also drop vidwit_prompt.md alongside vidwit.toml",
+    )
+    p.add_argument(
+        "--force", "-f", action="store_true",
+        help="overwrite existing files",
+    )
+    args = p.parse_args(argv)
+
+    if args.user:
+        xdg = Path(os.environ.get("XDG_CONFIG_HOME") or (Path.home() / ".config"))
+        target_dir = xdg / "vidwit"
+    else:
+        target_dir = Path.cwd()
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    written: list[Path] = []
+    skipped: list[Path] = []
+
+    items = [("vidwit.toml", "vidwit.toml")]
+    if args.prompt:
+        items.append(("vidwit_prompt.md", "vidwit_prompt.md"))
+
+    templates = files("vidwit.templates")
+    for src_name, dst_name in items:
+        dst = target_dir / dst_name
+        if dst.exists() and not args.force:
+            skipped.append(dst)
+            continue
+        dst.write_text(templates.joinpath(src_name).read_text(encoding="utf-8"),
+                       encoding="utf-8")
+        written.append(dst)
+
+    for f in written:
+        print(f"wrote {f}")
+    for f in skipped:
+        print(f"exists, skipped {f} (use --force to overwrite)", file=sys.stderr)
+
+    if skipped and not written:
+        return 1
+
+    if written:
+        toml = next((f for f in written if f.name == "vidwit.toml"), None)
+        if toml is not None:
+            print()
+            print(f"Next: edit {toml} and set [llm] api_key.")
+    return 0