kimi-cli 0.35__py3-none-any.whl → 0.52__py3-none-any.whl

kimi_cli/ui/shell/prompt.py

@@ -1,19 +1,27 @@
 import asyncio
+import base64
 import contextlib
 import getpass
 import json
 import os
 import re
 import time
+from collections import deque
 from collections.abc import Callable
+from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
 from hashlib import md5
+from io import BytesIO
 from pathlib import Path
 from typing import override
 
+from kosong.message import ContentPart, ImageURLPart, TextPart
+from PIL import Image, ImageGrab
 from prompt_toolkit import PromptSession
 from prompt_toolkit.application.current import get_app_or_none
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
 from prompt_toolkit.completion import (
     Completer,
     Completion,
@@ -23,17 +31,25 @@ from prompt_toolkit.completion import (
     merge_completers,
 )
 from prompt_toolkit.document import Document
-from prompt_toolkit.filters import Always, Never, has_completions
+from prompt_toolkit.filters import Condition, has_completions
 from prompt_toolkit.formatted_text import FormattedText
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from prompt_toolkit.patch_stdout import patch_stdout
 from pydantic import BaseModel, ValidationError
 
+from kimi_cli.llm import ModelCapability
 from kimi_cli.share import get_share_dir
 from kimi_cli.soul import StatusSnapshot
+from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.metacmd import get_meta_commands
+from kimi_cli.utils.clipboard import is_clipboard_available
 from kimi_cli.utils.logging import logger
+from kimi_cli.utils.string import random_string
+
+PROMPT_SYMBOL = "✨"
+PROMPT_SYMBOL_SHELL = "$"
+PROMPT_SYMBOL_THINKING = "💫"
 
 
 class MetaCommandCompleter(Completer):
@@ -299,7 +315,26 @@ class FileMentionCompleter(Completer):
         mention_doc = Document(text=fragment, cursor_position=len(fragment))
         self._fragment_hint = fragment
         try:
-            yield from self._fuzzy.get_completions(mention_doc, complete_event)
+            # First, ask the fuzzy completer for candidates.
+            candidates = list(self._fuzzy.get_completions(mention_doc, complete_event))
+
+            # re-rank: prefer basename matches
+            frag_lower = fragment.lower()
+
+            def _rank(c: Completion) -> tuple:
+                path = c.text
+                base = path.rstrip("/").split("/")[-1].lower()
+                if base.startswith(frag_lower):
+                    cat = 0
+                elif frag_lower in base:
+                    cat = 1
+                else:
+                    cat = 2
+                # preserve original FuzzyCompleter's order in the same category
+                return (cat,)
+
+            candidates.sort(key=_rank)
+            yield from candidates
         finally:
             self._fragment_hint = None
 
@@ -359,7 +394,11 @@ class PromptMode(Enum):
 
 class UserInput(BaseModel):
     mode: PromptMode
+    thinking: bool
     command: str
+    """The plain text representation of the user input."""
+    content: list[ContentPart]
+    """The rich content parts."""
 
     def __str__(self) -> str:
         return self.command
@@ -369,23 +408,78 @@ class UserInput(BaseModel):
 
 
 _REFRESH_INTERVAL = 1.0
-_toast_queue: asyncio.Queue[tuple[str, float]] = asyncio.Queue()
 
 
-def toast(message: str, duration: float = 5.0) -> None:
+@dataclass(slots=True)
+class _ToastEntry:
+    topic: str | None
+    """There can be only one toast of each non-None topic in the queue."""
+    message: str
+    duration: float
+
+
+_toast_queue = deque[_ToastEntry]()
+"""The queue of toasts to show, including the one currently being shown (the first one)."""
+
+
+def toast(
+    message: str,
+    duration: float = 5.0,
+    topic: str | None = None,
+    immediate: bool = False,
+) -> None:
     duration = max(duration, _REFRESH_INTERVAL)
-    _toast_queue.put_nowait((message, duration))
+    entry = _ToastEntry(topic=topic, message=message, duration=duration)
+    if topic is not None:
+        # Remove existing toasts with the same topic
+        for existing in list(_toast_queue):
+            if existing.topic == topic:
+                _toast_queue.remove(existing)
+    if immediate:
+        _toast_queue.appendleft(entry)
+    else:
+        _toast_queue.append(entry)
+
+
+def _current_toast() -> _ToastEntry | None:
+    if not _toast_queue:
+        return None
+    return _toast_queue[0]
+
+
+def _toast_thinking(thinking: bool) -> None:
+    toast(
+        f"thinking {'on' if thinking else 'off'}, tab to toggle",
+        duration=3.0,
+        topic="thinking",
+        immediate=True,
+    )
+
+
+_ATTACHMENT_PLACEHOLDER_RE = re.compile(
+    r"\[(?P<type>image):(?P<id>[a-zA-Z0-9_\-\.]+)(?:,(?P<width>\d+)x(?P<height>\d+))?\]"
+)
 
 
 class CustomPromptSession:
-    def __init__(self, status_provider: Callable[[], StatusSnapshot]):
+    def __init__(
+        self,
+        *,
+        status_provider: Callable[[], StatusSnapshot],
+        model_capabilities: set[ModelCapability],
+        initial_thinking: bool,
+    ) -> None:
         history_dir = get_share_dir() / "user-history"
         history_dir.mkdir(parents=True, exist_ok=True)
-        work_dir_id = md5(str(Path.cwd()).encode()).hexdigest()
+        work_dir_id = md5(str(Path.cwd()).encode(encoding="utf-8")).hexdigest()
         self._history_file = (history_dir / work_dir_id).with_suffix(".jsonl")
         self._status_provider = status_provider
+        self._model_capabilities = model_capabilities
         self._last_history_content: str | None = None
         self._mode: PromptMode = PromptMode.AGENT
+        self._thinking = initial_thinking
+        self._attachment_parts: dict[str, ContentPart] = {}
+        """Mapping from attachment id to ContentPart."""
 
         history_entries = _load_history_entries(self._history_file)
         history = InMemoryHistory()
@@ -407,6 +501,7 @@ class CustomPromptSession:
 
         # Build key bindings
         _kb = KeyBindings()
+        shortcut_hints: list[str] = []
 
         @_kb.add("enter", filter=has_completions)
         def _accept_completion(event: KeyPressEvent) -> None:
@@ -419,30 +514,81 @@ class CustomPromptSession:
                     completion = buff.complete_state.completions[0]
                 buff.apply_completion(completion)
 
-        @_kb.add("c-k", eager=True)
-        def _toggle_mode(event: KeyPressEvent) -> None:
+        @_kb.add("c-x", eager=True)
+        def _switch_mode(event: KeyPressEvent) -> None:
             self._mode = self._mode.toggle()
             # Apply mode-specific settings
             self._apply_mode(event)
             # Redraw UI
             event.app.invalidate()
 
+        shortcut_hints.append("ctrl-x: switch mode")
+
+        @_kb.add("escape", "enter", eager=True)
+        @_kb.add("c-j", eager=True)
+        def _insert_newline(event: KeyPressEvent) -> None:
+            """Insert a newline when Alt-Enter or Ctrl-J is pressed."""
+            event.current_buffer.insert_text("\n")
+
+        shortcut_hints.append("ctrl-j: newline")
+
+        if is_clipboard_available():
+
+            @_kb.add("c-v", eager=True)
+            def _paste(event: KeyPressEvent) -> None:
+                if self._try_paste_image(event):
+                    return
+                clipboard_data = event.app.clipboard.get_data()
+                event.current_buffer.paste_clipboard_data(clipboard_data)
+
+            shortcut_hints.append("ctrl-v: paste")
+            clipboard = PyperclipClipboard()
+        else:
+            clipboard = None
+
+        @Condition
+        def is_agent_mode() -> bool:
+            return self._mode == PromptMode.AGENT
+
+        _toast_thinking(self._thinking)
+
+        @_kb.add("tab", filter=~has_completions & is_agent_mode, eager=True)
+        def _switch_thinking(event: KeyPressEvent) -> None:
+            """Toggle thinking mode when Tab is pressed and no completions are shown."""
+            if "thinking" not in self._model_capabilities:
+                console.print(
+                    "[yellow]Thinking mode is not supported by the selected LLM model[/yellow]"
+                )
+                return
+            self._thinking = not self._thinking
+            _toast_thinking(self._thinking)
+            event.app.invalidate()
+
+        self._shortcut_hints = shortcut_hints
         self._session = PromptSession(
             message=self._render_message,
-            prompt_continuation=FormattedText([("fg:#4d4d4d", "... ")]),
+            # prompt_continuation=FormattedText([("fg:#4d4d4d", "... ")]),
             completer=self._agent_mode_completer,
-            complete_while_typing=True,
+            complete_while_typing=Condition(lambda: self._mode == PromptMode.AGENT),
             key_bindings=_kb,
+            clipboard=clipboard,
             history=history,
             bottom_toolbar=self._render_bottom_toolbar,
         )
 
+        # Allow completion to be triggered when the text is changed,
+        # such as when backspace is used to delete text.
+        @self._session.default_buffer.on_text_changed.add_handler
+        def trigger_complete(buffer: Buffer) -> None:
+            if buffer.complete_while_typing():
+                buffer.start_completion()
+
         self._status_refresh_task: asyncio.Task | None = None
-        self._current_toast: str | None = None
-        self._current_toast_duration: float = 0.0
 
     def _render_message(self) -> FormattedText:
-        symbol = "✨" if self._mode == PromptMode.AGENT else "$"
+        symbol = PROMPT_SYMBOL if self._mode == PromptMode.AGENT else PROMPT_SYMBOL_SHELL
+        if self._mode == PromptMode.AGENT and self._thinking:
+            symbol = PROMPT_SYMBOL_THINKING
         return FormattedText([("bold", f"{getpass.getuser()}{symbol} ")])
 
     def _apply_mode(self, event: KeyPressEvent | None = None) -> None:
@@ -459,11 +605,9 @@ class CustomPromptSession:
                     buff.cancel_completion()
             if buff is not None:
                 buff.completer = DummyCompleter()
-                buff.complete_while_typing = Never()
         else:
             if buff is not None:
                 buff.completer = self._agent_mode_completer
-                buff.complete_while_typing = Always()
 
     def __enter__(self) -> "CustomPromptSession":
         if self._status_refresh_task is not None and not self._status_refresh_task.done():
@@ -495,12 +639,85 @@ class CustomPromptSession:
         if self._status_refresh_task is not None and not self._status_refresh_task.done():
             self._status_refresh_task.cancel()
         self._status_refresh_task = None
+        self._attachment_parts.clear()
+
+    def _try_paste_image(self, event: KeyPressEvent) -> bool:
+        """Try to paste an image from the clipboard. Return True if successful."""
+        # Try get image from clipboard
+        image = ImageGrab.grabclipboard()
+        if isinstance(image, list):
+            for item in image:
+                try:
+                    with Image.open(item) as img:
+                        image = img.copy()
+                    break
+                except Exception:
+                    continue
+            else:
+                image = None
+
+        if image is None:
+            return False
+
+        if "image_in" not in self._model_capabilities:
+            console.print("[yellow]Image input is not supported by the selected LLM model[/yellow]")
+            return False
+
+        attachment_id = f"{random_string(8)}.png"
+        png_bytes = BytesIO()
+        image.save(png_bytes, format="PNG")
+        png_base64 = base64.b64encode(png_bytes.getvalue()).decode("ascii")
+        image_part = ImageURLPart(
+            image_url=ImageURLPart.ImageURL(
+                url=f"data:image/png;base64,{png_base64}", id=attachment_id
+            )
+        )
+        self._attachment_parts[attachment_id] = image_part
+        logger.debug(
+            "Pasted image from clipboard: {attachment_id}, {image_size}",
+            attachment_id=attachment_id,
+            image_size=image.size,
+        )
+
+        placeholder = f"[image:{attachment_id},{image.width}x{image.height}]"
+        event.current_buffer.insert_text(placeholder)
+        event.app.invalidate()
+        return True
 
     async def prompt(self) -> UserInput:
-        with patch_stdout():
+        with patch_stdout(raw=True):
             command = str(await self._session.prompt_async()).strip()
+            command = command.replace("\x00", "")  # just in case null bytes are somehow inserted
         self._append_history_entry(command)
-        return UserInput(mode=self._mode, command=command)
+
+        # Parse rich content parts
+        content: list[ContentPart] = []
+        remaining_command = command
+        while match := _ATTACHMENT_PLACEHOLDER_RE.search(remaining_command):
+            start, end = match.span()
+            if start > 0:
+                content.append(TextPart(text=remaining_command[:start]))
+            attachment_id = match.group("id")
+            part = self._attachment_parts.get(attachment_id)
+            if part is not None:
+                content.append(part)
+            else:
+                logger.warning(
+                    "Attachment placeholder found but no matching attachment part: {placeholder}",
+                    placeholder=match.group(0),
+                )
+                content.append(TextPart(text=match.group(0)))
+            remaining_command = remaining_command[end:]
+
+        if remaining_command.strip():
+            content.append(TextPart(text=remaining_command.strip()))
+
+        return UserInput(
+            mode=self._mode,
+            thinking=self._thinking,
+            content=content,
+            command=command,
+        )
 
     def _append_history_entry(self, text: str) -> None:
         entry = _HistoryEntry(content=text.strip())
@@ -535,21 +752,24 @@ class CustomPromptSession:
         columns -= len(now_text) + 2
 
         mode = str(self._mode).lower()
+        if self._mode == PromptMode.AGENT and self._thinking:
+            mode += " (thinking)"
         fragments.extend([("", f"{mode}"), ("", " " * 2)])
         columns -= len(mode) + 2
 
         status = self._status_provider()
         status_text = self._format_status(status)
 
-        if self._current_toast is not None:
-            fragments.extend([("", self._current_toast), ("", " " * 2)])
-            columns -= len(self._current_toast) + 2
-            self._current_toast_duration -= _REFRESH_INTERVAL
-            if self._current_toast_duration <= 0.0:
-                self._current_toast = None
+        current_toast = _current_toast()
+        if current_toast is not None:
+            fragments.extend([("", current_toast.message), ("", " " * 2)])
+            columns -= len(current_toast.message) + 2
+            current_toast.duration -= _REFRESH_INTERVAL
+            if current_toast.duration <= 0.0:
+                _toast_queue.popleft()
         else:
             shortcuts = [
-                "ctrl-k: toggle mode",
+                *self._shortcut_hints,
                 "ctrl-d: exit",
             ]
             for shortcut in shortcuts:
@@ -559,9 +779,6 @@ class CustomPromptSession:
                 else:
                     break
 
-        if self._current_toast is None and not _toast_queue.empty():
-            self._current_toast, self._current_toast_duration = _toast_queue.get_nowait()
-
         padding = max(1, columns - len(status_text))
         fragments.append(("", " " * padding))
         fragments.append(("", status_text))

kimi_cli/ui/shell/replay.py

@@ -0,0 +1,104 @@
+import asyncio
+import contextlib
+import getpass
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from kosong.message import Message, TextPart
+from kosong.tooling import ToolError, ToolOk
+
+from kimi_cli.soul import StatusSnapshot
+from kimi_cli.ui.shell.console import console
+from kimi_cli.ui.shell.prompt import PROMPT_SYMBOL
+from kimi_cli.ui.shell.visualize import visualize
+from kimi_cli.utils.message import message_extract_text, message_stringify
+from kimi_cli.wire import Wire
+from kimi_cli.wire.message import ContentPart, StepBegin, ToolCall, ToolResult
+
+MAX_REPLAY_RUNS = 5
+
+type _ReplayEvent = StepBegin | ToolCall | ContentPart | ToolResult
+
+
+@dataclass(slots=True)
+class _ReplayRun:
+    user_message: Message
+    events: list[_ReplayEvent]
+    n_steps: int = 0
+
+
+async def replay_recent_history(history: Sequence[Message]) -> None:
+    """
+    Replay the most recent user-initiated runs from the provided message history.
+    """
+    start_idx = _find_replay_start(history)
+    if start_idx is None:
+        return
+
+    runs = _build_replay_runs(history[start_idx:])
+    if not runs:
+        return
+
+    for run in runs:
+        wire = Wire()
+        console.print(f"{getpass.getuser()}{PROMPT_SYMBOL} {message_stringify(run.user_message)}")
+        ui_task = asyncio.create_task(
+            visualize(wire.ui_side, initial_status=StatusSnapshot(context_usage=0.0))
+        )
+        for event in run.events:
+            wire.soul_side.send(event)
+            await asyncio.sleep(0)  # yield to UI loop
+        wire.shutdown()
+        with contextlib.suppress(asyncio.QueueShutDown):
+            await ui_task
+
+
+def _is_user_message(message: Message) -> bool:
+    # FIXME: should consider non-text tool call results which are sent as user messages
+    if message.role != "user":
+        return False
+    return not message_extract_text(message).startswith("<system>CHECKPOINT")
+
+
+def _find_replay_start(history: Sequence[Message]) -> int | None:
+    indices = [idx for idx, message in enumerate(history) if _is_user_message(message)]
+    if not indices:
+        return None
+    # only replay last MAX_REPLAY_RUNS messages
+    return indices[max(0, len(indices) - MAX_REPLAY_RUNS)]
+
+
+def _build_replay_runs(history: Sequence[Message]) -> list[_ReplayRun]:
+    runs: list[_ReplayRun] = []
+    current_run: _ReplayRun | None = None
+    for message in history:
+        if _is_user_message(message):
+            # start a new run
+            if current_run is not None:
+                runs.append(current_run)
+            current_run = _ReplayRun(user_message=message, events=[])
+        elif message.role == "assistant":
+            if current_run is None:
+                continue
+            current_run.n_steps += 1
+            current_run.events.append(StepBegin(n=current_run.n_steps))
+            if isinstance(message.content, str):
+                current_run.events.append(TextPart(text=message.content))
+            else:
+                current_run.events.extend(message.content)
+            current_run.events.extend(message.tool_calls or [])
+        elif message.role == "tool":
+            if current_run is None:
+                continue
+            assert message.tool_call_id is not None
+            if isinstance(message.content, list) and any(
+                isinstance(part, TextPart) and part.text.startswith("<system>ERROR")
+                for part in message.content
+            ):
+                result = ToolError(message="", output="", brief="")
+            else:
+                result = ToolOk(output=message.content)
+            current_run.events.append(ToolResult(tool_call_id=message.tool_call_id, result=result))
+    if current_run is not None:
+        runs.append(current_run)
+    return runs

kimi_cli/ui/shell/setup.py

@@ -7,9 +7,9 @@ from prompt_toolkit.shortcuts.choice_input import ChoiceInput
 from pydantic import SecretStr
 
 from kimi_cli.config import LLMModel, LLMProvider, MoonshotSearchConfig, load_config, save_config
-from kimi_cli.soul.kimisoul import KimiSoul
 from kimi_cli.ui.shell.console import console
 from kimi_cli.ui.shell.metacmd import meta_command
+from kimi_cli.utils.aiohttp import new_client_session
 
 if TYPE_CHECKING:
     from kimi_cli.ui.shell import ShellApp
@@ -20,36 +20,34 @@ class _Platform(NamedTuple):
     name: str
     base_url: str
     search_url: str | None = None
-    allowed_models: list[str] | None = None
+    allowed_prefixes: list[str] | None = None
 
 
 _PLATFORMS = [
     _Platform(
-        id="kimi-coding",
-        name="Kimi Coding Plan",
+        id="kimi-for-coding",
+        name="Kimi For Coding",
         base_url="https://api.kimi.com/coding/v1",
         search_url="https://api.kimi.com/coding/v1/search",
     ),
     _Platform(
         id="moonshot-cn",
-        name="Moonshot AI 开放平台",
+        name="Moonshot AI 开放平台 (moonshot.cn)",
         base_url="https://api.moonshot.cn/v1",
-        allowed_models=["kimi-k2-turbo-preview", "kimi-k2-0905-preview", "kimi-k2-0711-preview"],
+        allowed_prefixes=["kimi-k2-"],
     ),
     _Platform(
         id="moonshot-ai",
-        name="Moonshot AI Open Platform",
+        name="Moonshot AI Open Platform (moonshot.ai)",
         base_url="https://api.moonshot.ai/v1",
-        allowed_models=["kimi-k2-turbo-preview", "kimi-k2-0905-preview", "kimi-k2-0711-preview"],
+        allowed_prefixes=["kimi-k2-"],
     ),
 ]
 
 
-@meta_command(kimi_soul_only=True)
+@meta_command
 async def setup(app: "ShellApp", args: list[str]):
     """Setup Kimi CLI"""
-    assert isinstance(app.soul, KimiSoul)
-
     result = await _setup()
     if not result:
         # error message already printed
@@ -79,7 +77,7 @@ async def setup(app: "ShellApp", args: list[str]):
     await asyncio.sleep(1)
     console.clear()
 
-    from kimi_cli import Reload
+    from kimi_cli.cli import Reload
 
     raise Reload
 
@@ -112,7 +110,7 @@ async def _setup() -> _SetupResult | None:
     models_url = f"{platform.base_url}/models"
     try:
         async with (
-            aiohttp.ClientSession() as session,
+            new_client_session() as session,
             session.get(
                 models_url,
                 headers={
@@ -129,11 +127,13 @@ async def _setup() -> _SetupResult | None:
     model_dict = {model["id"]: model for model in resp_json["data"]}
 
     # select the model
-    if platform.allowed_models is None:
-        model_ids = [model["id"] for model in resp_json["data"]]
-    else:
-        id_set = set(model["id"] for model in resp_json["data"])
-        model_ids = [model_id for model_id in platform.allowed_models if model_id in id_set]
+    model_ids: list[str] = [model["id"] for model in resp_json["data"]]
+    if platform.allowed_prefixes is not None:
+        model_ids = [
+            model_id
+            for model_id in model_ids
+            if model_id.startswith(tuple(platform.allowed_prefixes))
+        ]
 
     if not model_ids:
         console.print("[red]No models available for the selected platform[/red]")
@@ -187,6 +187,6 @@ async def _prompt_text(prompt: str, *, is_password: bool = False) -> str | None:
 @meta_command
 def reload(app: "ShellApp", args: list[str]):
     """Reload configuration"""
-    from kimi_cli import Reload
+    from kimi_cli.cli import Reload
 
     raise Reload

kimi_cli/ui/shell/update.py

@@ -11,7 +11,9 @@ from pathlib import Path
 
 import aiohttp
 
+from kimi_cli.share import get_share_dir
 from kimi_cli.ui.shell.console import console
+from kimi_cli.utils.aiohttp import new_client_session
 from kimi_cli.utils.logging import logger
 
 BASE_URL = "https://cdn.kimi.com/binaries/kimi-cli"
@@ -30,7 +32,7 @@ class UpdateResult(Enum):
 _UPDATE_LOCK = asyncio.Lock()
 
 
-def _semver_tuple(version: str) -> tuple[int, int, int]:
+def semver_tuple(version: str) -> tuple[int, int, int]:
     v = version.strip()
     if v.startswith("v"):
         v = v[1:]
@@ -79,8 +81,11 @@ async def do_update(*, print: bool = True, check_only: bool = False) -> UpdateRe
         return await _do_update(print=print, check_only=check_only)
 
 
+LATEST_VERSION_FILE = get_share_dir() / "latest_version.txt"
+
+
 async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
-    from kimi_cli import __version__ as current_version
+    from kimi_cli.constant import VERSION as current_version
 
     def _print(message: str) -> None:
         if print:
@@ -91,7 +96,7 @@ async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
         _print("[red]Failed to detect target platform.[/red]")
         return UpdateResult.UNSUPPORTED
 
-    async with aiohttp.ClientSession() as session:
+    async with new_client_session() as session:
         logger.info("Checking for updates...")
         _print("Checking for updates...")
         latest_version = await _get_latest_version(session)
@@ -100,9 +105,10 @@ async def _do_update(*, print: bool, check_only: bool) -> UpdateResult:
             return UpdateResult.FAILED
 
         logger.debug("Latest version: {latest_version}", latest_version=latest_version)
+        LATEST_VERSION_FILE.write_text(latest_version, encoding="utf-8")
 
-        cur_t = _semver_tuple(current_version)
-        lat_t = _semver_tuple(latest_version)
+        cur_t = semver_tuple(current_version)
+        lat_t = semver_tuple(latest_version)
 
         if cur_t >= lat_t:
             logger.debug("Already up to date: {current_version}", current_version=current_version)