codemaster-cli 2.2.0__py3-none-any.whl

vibe/cli/textual_ui/windowing/__init__.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from vibe.cli.textual_ui.windowing.history import (
+    build_history_widgets,
+    non_system_history_messages,
+)
+from vibe.cli.textual_ui.windowing.history_windowing import (
+    create_resume_plan,
+    should_resume_history,
+    sync_backfill_state,
+)
+from vibe.cli.textual_ui.windowing.state import (
+    HISTORY_RESUME_TAIL_MESSAGES,
+    LOAD_MORE_BATCH_SIZE,
+    HistoryLoadMoreManager,
+    SessionWindowing,
+)
+
+__all__ = [
+    "HISTORY_RESUME_TAIL_MESSAGES",
+    "LOAD_MORE_BATCH_SIZE",
+    "HistoryLoadMoreManager",
+    "SessionWindowing",
+    "build_history_widgets",
+    "create_resume_plan",
+    "non_system_history_messages",
+    "should_resume_history",
+    "sync_backfill_state",
+]

vibe/cli/textual_ui/windowing/history.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from weakref import WeakKeyDictionary
+
+from textual.widget import Widget
+
+from vibe.cli.textual_ui.widgets.messages import (
+    AssistantMessage,
+    ReasoningMessage,
+    UserMessage,
+)
+from vibe.cli.textual_ui.widgets.tools import ToolCallMessage, ToolResultMessage
+from vibe.core.types import LLMMessage, Role
+
+
+def non_system_history_messages(messages: list[LLMMessage]) -> list[LLMMessage]:
+    return [msg for msg in messages if msg.role != Role.system]
+
+
+def build_tool_call_map(messages: list[LLMMessage]) -> dict[str, str]:
+    tool_call_map: dict[str, str] = {}
+    for msg in messages:
+        if msg.role != Role.assistant or not msg.tool_calls:
+            continue
+        for tool_call in msg.tool_calls:
+            if tool_call.id:
+                tool_call_map[tool_call.id] = tool_call.function.name or "unknown"
+    return tool_call_map
+
+
+def build_history_widgets(
+    batch: list[LLMMessage],
+    tool_call_map: dict[str, str],
+    *,
+    start_index: int,
+    tools_collapsed: bool,
+    history_widget_indices: WeakKeyDictionary[Widget, int],
+) -> list[Widget]:
+    widgets: list[Widget] = []
+
+    for offset, msg in enumerate(batch):
+        history_index = start_index + offset
+        match msg.role:
+            case Role.user:
+                if msg.content:
+                    widget = UserMessage(msg.content)
+                    widgets.append(widget)
+                    history_widget_indices[widget] = history_index
+
+            case Role.assistant:
+                if msg.content:
+                    assistant_widget = AssistantMessage(msg.content)
+                    widgets.append(assistant_widget)
+                    history_widget_indices[assistant_widget] = history_index
+
+                if msg.tool_calls:
+                    for tool_call in msg.tool_calls:
+                        tool_name = tool_call.function.name or "unknown"
+                        if tool_call.id:
+                            tool_call_map[tool_call.id] = tool_name
+                        widget = ToolCallMessage(tool_name=tool_name)
+                        widgets.append(widget)
+                        history_widget_indices[widget] = history_index
+
+            case Role.tool:
+                tool_name = msg.name or tool_call_map.get(
+                    msg.tool_call_id or "", "tool"
+                )
+                widget = ToolResultMessage(
+                    tool_name=tool_name, content=msg.content, collapsed=tools_collapsed
+                )
+                widgets.append(widget)
+                history_widget_indices[widget] = history_index
+
+    return widgets
+
+
+def split_history_tail(
+    history_messages: list[LLMMessage], tail_size: int
+) -> tuple[list[LLMMessage], list[LLMMessage], int]:
+    tail_messages = history_messages[-tail_size:]
+    backfill_messages = history_messages[:-tail_size]
+    tail_start_index = len(history_messages) - len(tail_messages)
+    return tail_messages, backfill_messages, tail_start_index
+
+
+def visible_history_indices(
+    children: list[Widget], history_widget_indices: WeakKeyDictionary[Widget, int]
+) -> list[int]:
+    return [
+        idx
+        for child in children
+        if (idx := history_widget_indices.get(child)) is not None
+    ]
+
+
+def visible_history_widgets_count(children: list[Widget]) -> int:
+    history_widget_types = (
+        UserMessage,
+        AssistantMessage,
+        ReasoningMessage,
+        ToolCallMessage,
+        ToolResultMessage,
+    )
+    return sum(isinstance(child, history_widget_types) for child in children)

vibe/cli/textual_ui/windowing/history_windowing.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from weakref import WeakKeyDictionary
+
+from textual.widget import Widget
+
+from vibe.cli.textual_ui.widgets.messages import WhatsNewMessage
+from vibe.cli.textual_ui.windowing.history import (
+    build_tool_call_map,
+    split_history_tail,
+    visible_history_indices,
+    visible_history_widgets_count,
+)
+from vibe.cli.textual_ui.windowing.state import SessionWindowing
+from vibe.core.types import LLMMessage
+
+
+@dataclass(frozen=True)
+class HistoryResumePlan:
+    tool_call_map: dict[str, str]
+    tail_messages: list[LLMMessage]
+    backfill_messages: list[LLMMessage]
+    tail_start_index: int
+
+    @property
+    def has_backfill(self) -> bool:
+        return bool(self.backfill_messages)
+
+
+def should_resume_history(messages_children: list[Widget]) -> bool:
+    allowed_pre_existing_types = (WhatsNewMessage,)
+    return all(
+        isinstance(child, allowed_pre_existing_types) for child in messages_children
+    )
+
+
+def create_resume_plan(
+    history_messages: list[LLMMessage], tail_size: int
+) -> HistoryResumePlan | None:
+    if not history_messages:
+        return None
+    tail_messages, backfill_messages, tail_start_index = split_history_tail(
+        history_messages, tail_size
+    )
+    return HistoryResumePlan(
+        tool_call_map=build_tool_call_map(history_messages),
+        tail_messages=tail_messages,
+        backfill_messages=backfill_messages,
+        tail_start_index=tail_start_index,
+    )
+
+
+def sync_backfill_state(
+    *,
+    history_messages: list[LLMMessage],
+    messages_children: list[Widget],
+    history_widget_indices: WeakKeyDictionary[Widget, int],
+    windowing: SessionWindowing,
+) -> tuple[bool, dict[str, str] | None]:
+    if not history_messages:
+        windowing.reset()
+        return False, None
+    visible_indices = visible_history_indices(messages_children, history_widget_indices)
+    visible_history_widgets = visible_history_widgets_count(messages_children)
+    has_backfill = windowing.recompute_backfill(
+        history_messages,
+        visible_indices=visible_indices,
+        visible_history_widgets_count=visible_history_widgets,
+    )
+    return has_backfill, build_tool_call_map(history_messages)

vibe/cli/textual_ui/windowing/state.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from textual.widget import Widget
+
+from vibe.cli.textual_ui.widgets.load_more import HistoryLoadMoreMessage
+from vibe.core.types import LLMMessage
+
+HISTORY_RESUME_TAIL_MESSAGES = 20
+LOAD_MORE_BATCH_SIZE = 10
+
+
+@dataclass(frozen=True)
+class LoadMoreBatch:
+    start_index: int
+    messages: list[LLMMessage]
+
+
+class SessionWindowing:
+    def __init__(self, load_more_batch_size: int) -> None:
+        self.load_more_batch_size = load_more_batch_size
+        self._backfill_messages: list[LLMMessage] = []
+        self._backfill_cursor = 0
+
+    @property
+    def remaining(self) -> int:
+        return self._backfill_cursor
+
+    @property
+    def has_backfill(self) -> bool:
+        return self._backfill_cursor > 0
+
+    def reset(self) -> None:
+        self._backfill_messages = []
+        self._backfill_cursor = 0
+
+    def set_backfill(self, backfill_messages: list[LLMMessage]) -> None:
+        self._backfill_messages = backfill_messages
+        self._backfill_cursor = len(backfill_messages)
+
+    def next_load_more_batch(self) -> LoadMoreBatch | None:
+        if self._backfill_cursor == 0:
+            return None
+        start_index = max(self._backfill_cursor - self.load_more_batch_size, 0)
+        batch = self._backfill_messages[start_index : self._backfill_cursor]
+        self._backfill_cursor = start_index
+        if not batch:
+            return None
+        return LoadMoreBatch(start_index=start_index, messages=batch)
+
+    def recompute_backfill(
+        self,
+        history_messages: list[LLMMessage],
+        visible_indices: list[int],
+        visible_history_widgets_count: int,
+    ) -> bool:
+        if not history_messages:
+            self._backfill_messages = []
+            self._backfill_cursor = 0
+            return False
+        if visible_indices:
+            backfill_end = min(visible_indices)
+        else:
+            backfill_end = max(len(history_messages) - visible_history_widgets_count, 0)
+        self._backfill_messages = history_messages[:backfill_end]
+        self._backfill_cursor = len(self._backfill_messages)
+        return self._backfill_cursor > 0
+
+
+class HistoryLoadMoreManager:
+    def __init__(self) -> None:
+        self.widget: HistoryLoadMoreMessage | None = None
+
+    async def show(self, messages_area: Widget, remaining: int) -> None:
+        if self.widget is None:
+            widget = HistoryLoadMoreMessage()
+            await messages_area.mount(widget, before=0)
+            self.widget = widget
+        self.set_remaining(remaining)
+
+    async def hide(self) -> None:
+        if self.widget is None:
+            return
+        if self.widget.parent:
+            await self.widget.remove()
+        self.widget = None
+
+    async def set_visible(
+        self, messages_area: Widget, *, visible: bool, remaining: int
+    ) -> None:
+        if visible:
+            await self.show(messages_area, remaining)
+            return
+        await self.hide()
+
+    def set_enabled(self, enabled: bool) -> None:
+        if self.widget is None:
+            return
+        self.widget.set_enabled(enabled)
+
+    def set_remaining(self, remaining: int) -> None:
+        if self.widget is None:
+            return
+        self.widget.set_remaining(remaining)

vibe/cli/update_notifier/__init__.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from vibe.cli.update_notifier.adapters.filesystem_update_cache_repository import (
+    FileSystemUpdateCacheRepository,
+)
+from vibe.cli.update_notifier.adapters.github_update_gateway import GitHubUpdateGateway
+from vibe.cli.update_notifier.adapters.pypi_update_gateway import PyPIUpdateGateway
+from vibe.cli.update_notifier.ports.update_cache_repository import (
+    UpdateCache,
+    UpdateCacheRepository,
+)
+from vibe.cli.update_notifier.ports.update_gateway import (
+    DEFAULT_GATEWAY_MESSAGES,
+    Update,
+    UpdateGateway,
+    UpdateGatewayCause,
+    UpdateGatewayError,
+)
+from vibe.cli.update_notifier.update import (
+    UpdateAvailability,
+    UpdateError,
+    get_update_if_available,
+)
+from vibe.cli.update_notifier.whats_new import (
+    load_whats_new_content,
+    mark_version_as_seen,
+    should_show_whats_new,
+)
+
+__all__ = [
+    "DEFAULT_GATEWAY_MESSAGES",
+    "FileSystemUpdateCacheRepository",
+    "GitHubUpdateGateway",
+    "PyPIUpdateGateway",
+    "Update",
+    "UpdateAvailability",
+    "UpdateCache",
+    "UpdateCacheRepository",
+    "UpdateError",
+    "UpdateGateway",
+    "UpdateGatewayCause",
+    "UpdateGatewayError",
+    "get_update_if_available",
+    "load_whats_new_content",
+    "mark_version_as_seen",
+    "should_show_whats_new",
+]

vibe/cli/update_notifier/adapters/filesystem_update_cache_repository.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+from vibe.cli.update_notifier.ports.update_cache_repository import (
+    UpdateCache,
+    UpdateCacheRepository,
+)
+from vibe.core.paths.global_paths import VIBE_HOME
+
+
+class FileSystemUpdateCacheRepository(UpdateCacheRepository):
+    def __init__(self, base_path: Path | str | None = None) -> None:
+        self._base_path = Path(base_path) if base_path is not None else VIBE_HOME.path
+        self._cache_file = self._base_path / "update_cache.json"
+
+    async def get(self) -> UpdateCache | None:
+        try:
+            content = await asyncio.to_thread(self._cache_file.read_text)
+        except OSError:
+            return None
+
+        try:
+            data = json.loads(content)
+            latest_version = data.get("latest_version")
+            stored_at_timestamp = data.get("stored_at_timestamp")
+            seen_whats_new_version = data.get("seen_whats_new_version")
+        except (TypeError, json.JSONDecodeError):
+            return None
+
+        if not isinstance(latest_version, str) or not isinstance(
+            stored_at_timestamp, int
+        ):
+            return None
+
+        if (
+            not isinstance(seen_whats_new_version, str)
+            and seen_whats_new_version is not None
+        ):
+            seen_whats_new_version = None
+
+        return UpdateCache(
+            latest_version=latest_version,
+            stored_at_timestamp=stored_at_timestamp,
+            seen_whats_new_version=seen_whats_new_version,
+        )
+
+    async def set(self, update_cache: UpdateCache) -> None:
+        try:
+            payload = json.dumps({
+                "latest_version": update_cache.latest_version,
+                "stored_at_timestamp": update_cache.stored_at_timestamp,
+                "seen_whats_new_version": update_cache.seen_whats_new_version,
+            })
+            await asyncio.to_thread(self._cache_file.write_text, payload)
+        except OSError:
+            return None

vibe/cli/update_notifier/adapters/github_update_gateway.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import httpx
+
+from vibe.cli.update_notifier.ports.update_gateway import (
+    Update,
+    UpdateGateway,
+    UpdateGatewayCause,
+    UpdateGatewayError,
+)
+
+
+class GitHubUpdateGateway(UpdateGateway):
+    def __init__(
+        self,
+        owner: str,
+        repository: str,
+        *,
+        token: str | None = None,
+        client: httpx.AsyncClient | None = None,
+        timeout: float = 5.0,
+        base_url: str = "https://api.github.com",
+    ) -> None:
+        self._owner = owner
+        self._repository = repository
+        self._token = token
+        self._client = client
+        self._timeout = timeout
+        self._base_url = base_url.rstrip("/")
+
+    async def fetch_update(self) -> Update | None:
+        headers = {
+            "Accept": "application/vnd.github+json",
+            "User-Agent": "mistral-vibe-update-notifier",
+        }
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+
+        request_path = f"/repos/{self._owner}/{self._repository}/releases"
+
+        try:
+            if self._client is not None:
+                response = await self._client.get(
+                    f"{self._base_url}{request_path}",
+                    headers=headers,
+                    timeout=self._timeout,
+                )
+            else:
+                async with httpx.AsyncClient(
+                    base_url=self._base_url, timeout=self._timeout
+                ) as client:
+                    response = await client.get(request_path, headers=headers)
+        except httpx.RequestError as exc:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.REQUEST_FAILED) from exc
+
+        rate_limit_remaining = response.headers.get("X-RateLimit-Remaining")
+        if response.status_code == httpx.codes.TOO_MANY_REQUESTS or (
+            rate_limit_remaining is not None and rate_limit_remaining == "0"
+        ):
+            raise UpdateGatewayError(cause=UpdateGatewayCause.TOO_MANY_REQUESTS)
+
+        if response.status_code == httpx.codes.FORBIDDEN:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.FORBIDDEN)
+
+        if response.status_code == httpx.codes.NOT_FOUND:
+            raise UpdateGatewayError(
+                cause=UpdateGatewayCause.NOT_FOUND,
+                message="Unable to fetch the GitHub releases. Did you export a GITHUB_TOKEN environment variable?",
+            )
+
+        if response.is_error:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.ERROR_RESPONSE)
+
+        try:
+            data = response.json()
+        except ValueError as exc:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.INVALID_RESPONSE) from exc
+
+        if not data:
+            return None
+
+        # pick the most recently published non-prerelease and non-draft release
+        # github "list releases" API most likely returns ordered results, but this is not guaranteed
+        for release in sorted(
+            data, key=lambda x: x.get("published_at") or "", reverse=True
+        ):
+            if release.get("prerelease") or release.get("draft"):
+                continue
+            if version := _extract_version(release.get("tag_name")):
+                return Update(latest_version=version)
+
+        return None
+
+
+def _extract_version(tag_name: str | None) -> str | None:
+    if not tag_name:
+        return None
+    tag = tag_name.strip()
+    if not tag:
+        return None
+    return tag[1:] if tag.startswith(("v", "V")) else tag

vibe/cli/update_notifier/adapters/pypi_update_gateway.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import httpx
+from packaging.utils import parse_sdist_filename, parse_wheel_filename
+from packaging.version import InvalidVersion, Version
+
+from vibe.cli.update_notifier.ports.update_gateway import (
+    Update,
+    UpdateGateway,
+    UpdateGatewayCause,
+    UpdateGatewayError,
+)
+
+_STATUS_CAUSES: dict[int, UpdateGatewayCause] = {
+    httpx.codes.NOT_FOUND: UpdateGatewayCause.NOT_FOUND,
+    httpx.codes.FORBIDDEN: UpdateGatewayCause.FORBIDDEN,
+    httpx.codes.TOO_MANY_REQUESTS: UpdateGatewayCause.TOO_MANY_REQUESTS,
+}
+
+
+class PyPIUpdateGateway(UpdateGateway):
+    def __init__(
+        self,
+        project_name: str,
+        *,
+        client: httpx.AsyncClient | None = None,
+        timeout: float = 5.0,
+        base_url: str = "https://pypi.org",
+    ) -> None:
+        self._project_name = project_name
+        self._client = client
+        self._timeout = timeout
+        self._base_url = base_url.rstrip("/")
+
+    async def fetch_update(self) -> Update | None:
+        response = await self._fetch()
+        self._raise_gateway_error_if_any(response)
+
+        try:
+            data = response.json()
+        except ValueError as exc:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.INVALID_RESPONSE) from exc
+
+        versions = data.get("versions") or []
+        files = data.get("files") or []
+
+        non_yanked_versions: set[Version] = set()
+        for file in files:
+            if not isinstance(file, dict) or file.get("yanked") is True:
+                continue
+            filename = file.get("filename")
+            if not isinstance(filename, str):
+                continue
+            parsed_version = _parse_filename_version(filename)
+            if parsed_version is not None:
+                non_yanked_versions.add(parsed_version)
+
+        valid_versions: list[Version] = []
+        for raw_version in versions:
+            try:
+                valid_versions.append(Version(str(raw_version)))
+            except InvalidVersion:
+                continue
+
+        for version in sorted(valid_versions, reverse=True):
+            if version in non_yanked_versions:
+                return Update(latest_version=str(version))
+
+        return None
+
+    async def _fetch(self) -> httpx.Response:
+        headers = {"Accept": "application/vnd.pypi.simple.v1+json"}
+        request_path = f"/simple/{self._project_name}/"
+
+        try:
+            if self._client is not None:
+                return await self._client.get(
+                    f"{self._base_url}{request_path}",
+                    headers=headers,
+                    timeout=self._timeout,
+                )
+
+            async with httpx.AsyncClient(
+                base_url=self._base_url, timeout=self._timeout
+            ) as client:
+                return await client.get(request_path, headers=headers)
+        except httpx.RequestError as exc:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.REQUEST_FAILED) from exc
+
+    def _raise_gateway_error_if_any(self, response: httpx.Response) -> None:
+        if response.status_code in _STATUS_CAUSES:
+            raise UpdateGatewayError(cause=_STATUS_CAUSES[response.status_code])
+
+        if response.is_error:
+            raise UpdateGatewayError(cause=UpdateGatewayCause.ERROR_RESPONSE)
+
+
+def _parse_filename_version(filename: str) -> Version | None:
+    try:
+        _, version, *_ = parse_wheel_filename(filename)
+        return Version(str(version))
+    except Exception:
+        try:
+            _, sdist_version = parse_sdist_filename(filename)
+            return Version(str(sdist_version))
+        except Exception:
+            return None

vibe/cli/update_notifier/ports/update_cache_repository.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True, slots=True)
+class UpdateCache:
+    latest_version: str
+    stored_at_timestamp: int
+    seen_whats_new_version: str | None = None
+
+
+class UpdateCacheRepository(Protocol):
+    async def get(self) -> UpdateCache | None: ...
+    async def set(self, update_cache: UpdateCache) -> None: ...

vibe/cli/update_notifier/ports/update_gateway.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum, auto
+from typing import Protocol
+
+
+@dataclass(frozen=True, slots=True)
+class Update:
+    latest_version: str
+
+
+class UpdateGatewayCause(StrEnum):
+    @staticmethod
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list[str]
+    ) -> str:
+        return name.lower()
+
+    TOO_MANY_REQUESTS = auto()
+    FORBIDDEN = auto()
+    NOT_FOUND = auto()
+    REQUEST_FAILED = auto()
+    ERROR_RESPONSE = auto()
+    INVALID_RESPONSE = auto()
+    UNKNOWN = auto()
+
+
+DEFAULT_GATEWAY_MESSAGES: dict[UpdateGatewayCause, str] = {
+    UpdateGatewayCause.TOO_MANY_REQUESTS: "Rate limit exceeded while checking for updates.",
+    UpdateGatewayCause.FORBIDDEN: "Request was forbidden while checking for updates.",
+    UpdateGatewayCause.NOT_FOUND: "Unable to fetch the releases. Please check your permissions.",
+    UpdateGatewayCause.REQUEST_FAILED: "Network error while checking for updates.",
+    UpdateGatewayCause.ERROR_RESPONSE: "Unexpected response received while checking for updates.",
+    UpdateGatewayCause.INVALID_RESPONSE: "Received an invalid response while checking for updates.",
+    UpdateGatewayCause.UNKNOWN: "Unable to determine whether an update is available.",
+}
+
+
+class UpdateGatewayError(Exception):
+    def __init__(
+        self, *, cause: UpdateGatewayCause, message: str | None = None
+    ) -> None:
+        self.cause = cause
+        self.user_message = message
+        detail = message or DEFAULT_GATEWAY_MESSAGES.get(
+            cause, DEFAULT_GATEWAY_MESSAGES[UpdateGatewayCause.UNKNOWN]
+        )
+        super().__init__(detail)
+
+
+class UpdateGateway(Protocol):
+    async def fetch_update(self) -> Update | None: ...