devsper 2.1.6__py3-none-any.whl

devsper/tui/task_detail_screen.py

@@ -0,0 +1,55 @@
+"""
+Task detail overlay: full description, result, tools, duration, retry count, error.
+"""
+
+from textual.app import ComposeResult
+from textual.containers import Container, ScrollableContainer
+from textual.screen import ModalScreen
+from textual.widgets import Button, Static
+
+
+class TaskDetailScreen(ModalScreen[None]):
+    """Shows full task details. Receives task dict with task_id, description, result, status, error, role, etc."""
+
+    BINDINGS = [("escape", "dismiss_screen")]
+
+    def __init__(self, task: dict, app_ref: object) -> None:
+        super().__init__()
+        self._task = task
+        self._app_ref = app_ref
+
+    def compose(self) -> ComposeResult:
+        t = self._task
+        task_id = t.get("task_id", "?")
+        desc = (t.get("description") or "(no description)").replace("\n", " ")
+        result = (t.get("result") or "(no result)")[:8000]
+        status = t.get("status", "?")
+        error = t.get("error") or ""
+        role = t.get("role") or "—"
+        runtime = t.get("runtime") or "—"
+        tools_used = t.get("tools_used") or []
+        tools_str = ", ".join(tools_used) if tools_used else "—"
+        retry = t.get("retry_count", 0)
+        lines = [
+            f"[bold]Task ID:[/] {task_id}",
+            f"[bold]Description:[/] {desc}",
+            f"[bold]Role:[/] {role}  [bold]Status:[/] {status}  [bold]Runtime:[/] {runtime}",
+            f"[bold]Retry count:[/] {retry}",
+            f"[bold]Tools used:[/] {tools_str}",
+            "",
+            "[bold]Result:[/]",
+            result,
+        ]
+        if error:
+            lines.extend(["", "[bold red]Error:[/]", error])
+        content = "\n".join(lines)
+        with Container(id="task-detail-container"):
+            yield ScrollableContainer(Static(content, id="task-detail-content"))
+            yield Button("Close", variant="primary", id="task-detail-close")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "task-detail-close":
+            self.dismiss(None)
+
+    def action_dismiss_screen(self) -> None:
+        self.dismiss(None)

devsper/tui/task_view.py

@@ -0,0 +1,103 @@
+"""
+Task panel: task_id, status, runtime, worker agent.
+
+Data can come from last scheduler or from event stream (task_started, task_completed).
+Arrow-key selection and Enter opens task detail overlay.
+"""
+
+from textual.widgets import Static, ListView, ListItem, Label
+from textual.reactive import reactive
+from textual.message import Message
+
+
+class TaskView(Static):
+    """Displays list of tasks with status; select with arrows, Enter for detail."""
+
+    tasks_data: reactive[list[dict]] = reactive(list)
+
+    class TaskSelected(Message):
+        """Emitted when user presses Enter on a selected task."""
+        def __init__(self, task: dict) -> None:
+            self.task = task
+            super().__init__()
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._tasks: list[dict] = []
+        self._list_view: ListView | None = None
+
+    def compose(self):
+        from textual.containers import VerticalScroll
+        with VerticalScroll():
+            self._list_view = ListView(id="task-list-view")
+            yield self._list_view
+
+    def set_tasks(self, tasks: list[dict]) -> None:
+        """Update tasks. Each dict: task_id, status, runtime (str), worker (str), and optionally description, result, error."""
+        self._tasks = tasks
+        self.tasks_data = tasks
+        self._refresh_list()
+
+    def add_or_update_task(
+        self, task_id: str, status: str, runtime: str = "-", worker: str = "agent"
+    ) -> None:
+        """Add or update a single task (e.g. from events)."""
+        for t in self._tasks:
+            if t.get("task_id") == task_id:
+                t["status"] = status
+                t["runtime"] = runtime
+                t["worker"] = worker
+                self.tasks_data = list(self._tasks)
+                self._refresh_list()
+                return
+        self._tasks.append(
+            {
+                "task_id": task_id,
+                "status": status,
+                "runtime": runtime,
+                "worker": worker,
+            }
+        )
+        self.tasks_data = list(self._tasks)
+        self._refresh_list()
+
+    def watch_tasks_data(self, data: list[dict]) -> None:
+        self._tasks = data
+        self._refresh_list()
+
+    def _refresh_list(self) -> None:
+        try:
+            lv = self.query_one("#task-list-view", ListView)
+        except Exception:
+            return
+        try:
+            lv.clear_children()
+        except Exception:
+            pass
+        if not self._tasks:
+            return
+        for t in self._tasks:
+            tid = t.get("task_id", "?")
+            status = t.get("status", "pending")
+            desc = (t.get("description") or tid)[:50]
+            item = ListItem(Label(f"{tid}  {status}  {desc}"), id=f"task-{tid}")
+            lv.append(item)
+
+    def get_selected_task(self) -> dict | None:
+        """Return the currently selected task dict, or None."""
+        try:
+            lv = self.query_one("#task-list-view", ListView)
+            idx = lv.index
+            if idx is not None and 0 <= idx < len(self._tasks):
+                return self._tasks[idx]
+        except Exception:
+            pass
+        return None
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        idx = getattr(event.list_view, "index", None)
+        if idx is not None and 0 <= idx < len(self._tasks):
+            self.post_message(self.TaskSelected(self._tasks[idx]))
+
+    def on_mount(self) -> None:
+        self._refresh_list()

devsper/types/event.py

@@ -0,0 +1,97 @@
+import json
+from datetime import datetime, timezone
+from enum import Enum
+from pydantic import BaseModel, model_validator
+
+from devsper.types.exceptions import EventSerializationError
+
+
+class events(Enum):
+    SWARM_STARTED = "swarm_started"
+    SWARM_FINISHED = "swarm_finished"
+    TASK_CREATED = "task_created"
+    TASK_STARTED = "task_started"
+    TASK_COMPLETED = "task_completed"
+    TASK_FAILED = "task_failed"
+    TASK_CACHE_HIT = "task_cache_hit"  # v1.6: payload task_id, similarity, original_description
+    TASK_CACHE_MISS = "task_cache_miss"  # v1.6: payload task_id
+    TASK_MODEL_SELECTED = "task_model_selected"  # v1.6: payload task_id, tier, model
+    AGENT_STARTED = "agent_started"
+    AGENT_FINISHED = "agent_finished"
+    PLANNER_STARTED = "planner_started"
+    PLANNER_FINISHED = "planner_finished"
+    EXECUTOR_STARTED = "executor_started"
+    EXECUTOR_FINISHED = "executor_finished"
+    TOOL_CALLED = "tool_called"
+    REASONING_NODE_ADDED = "reasoning_node_added"
+    USER_INJECTION = "user_injection"
+    # v1.7
+    TASK_CRITIQUED = "task_critiqued"
+    AGENT_BROADCAST = "agent_broadcast"
+    PREFETCH_HIT = "prefetch_hit"
+    PREFETCH_MISS = "prefetch_miss"
+    TASK_STRUCTURED_OUTPUT_CORRECTED = "task_structured_output_corrected"
+    # v1.8
+    PLANNER_KG_CONTEXT_INJECTED = "planner_kg_context_injected"
+    KNOWLEDGE_EXTRACTED = "knowledge_extracted"
+    MEMORY_CONSOLIDATED = "memory_consolidated"
+    # v2.0
+    PROVIDER_FALLBACK = "provider_fallback"
+    # v2.1
+    TASK_REJECTED_BY_HUMAN = "task_rejected_by_human"
+
+class Event(BaseModel):
+    timestamp: datetime
+    type: events
+    payload: dict
+
+    @model_validator(mode="after")
+    def _payload_must_be_json_safe(self) -> "Event":
+        try:
+            json.dumps(self.payload)
+        except TypeError as e:
+            raise EventSerializationError(f"Event payload not JSON-safe: {e}") from e
+        return self
+
+    def to_dict(self) -> dict:
+        ts = self.timestamp
+        if hasattr(ts, "isoformat"):
+            ts_str = ts.isoformat()
+        else:
+            ts_str = str(ts)
+        type_val = self.type.value if hasattr(self.type, "value") else str(self.type)
+        return {
+            "timestamp": ts_str,
+            "type": type_val,
+            "payload": self.payload,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Event":
+        ts = data.get("timestamp", "")
+        if isinstance(ts, str):
+            try:
+                if ts.endswith("Z"):
+                    ts = ts.replace("Z", "+00:00")
+                dt = datetime.fromisoformat(ts)
+            except ValueError:
+                dt = datetime.now(timezone.utc)
+        else:
+            dt = datetime.now(timezone.utc)
+        type_val = data.get("type", "swarm_started")
+        try:
+            event_type = events(type_val) if isinstance(type_val, str) else events.SWARM_STARTED
+        except ValueError:
+            event_type = events.SWARM_STARTED
+        return cls(
+            timestamp=dt,
+            type=event_type,
+            payload=dict(data.get("payload", {})),
+        )
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, raw: str) -> "Event":
+        return cls.from_dict(json.loads(raw))

devsper/types/exceptions.py

@@ -0,0 +1,21 @@
+"""Exceptions for devsper types and bus."""
+
+
+class EventSerializationError(Exception):
+    """Raised when an event payload is not JSON-serializable."""
+
+
+class TaskNotFoundError(Exception):
+    """Raised when a task ID is not found in the scheduler."""
+
+
+class BusConnectionError(Exception):
+    """Raised when the message bus backend cannot connect (e.g. Redis unreachable)."""
+
+
+class CheckpointNotFoundError(Exception):
+    """Raised when a checkpoint file for a run_id is not found."""
+
+
+class MCPToolError(Exception):
+    """Raised when an MCP tools/call returns an error or invalid response."""

devsper/types/swarm.py

@@ -0,0 +1,41 @@
+from typing import Literal, get_args
+from pydantic import BaseModel, Field
+
+ModelName = Literal[
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5-20251001",
+    "claude-opus-4-20250514",
+    "claude-sonnet-4-20250514",
+    "claude-sonnet-3-7-20250219",
+    "claude-haiku-3-5-20241022",
+    "gpt-5.4",
+    "gpt-5.4-pro",
+    "gpt-5.2",
+    "gpt-5.1",
+    "gpt-4.1",
+    "gpt-4.1-mini",
+    "gpt-4.1-nano",
+    "gpt-4o",
+    "o3",
+    "o3-pro",
+    "o4-mini",
+    "gemini-3.1-pro-preview",
+    "gemini-3.1-flash-lite-preview",
+    "gemini-3-flash",
+    "gemini-2.5-pro",
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-lite",
+]
+
+available_models: list[str] = list(get_args(ModelName))
+
+DEFAULT_WORKER_MODEL: ModelName = "claude-haiku-4-5-20251001"
+DEFAULT_PLANNER_MODEL: ModelName = "claude-opus-4-6"
+
+
+class Swarm(BaseModel):
+    worker_count: int
+    worker_model: ModelName = DEFAULT_WORKER_MODEL
+    planner_model: ModelName = DEFAULT_PLANNER_MODEL
+    models: list[str] = Field(default_factory=lambda: list(get_args(ModelName)))

devsper/types/task.py

@@ -0,0 +1,80 @@
+import hashlib
+import json
+from enum import Enum
+from pydantic import BaseModel
+
+
+class TaskStatus(Enum):
+    PENDING = 0
+    RUNNING = 1
+    COMPLETED = 2
+    FAILED = -1
+
+
+class Task(BaseModel):
+    id: str
+    description: str
+    dependencies: list[str] = []
+    status: TaskStatus = TaskStatus.PENDING
+    result: str | None = None
+    error: str | None = None  # v1.9: error message when failed
+    speculative: bool = False
+    role: str | None = None  # Optional agent role: research, code, analysis, critic
+    retry_count: int = 0  # v1.7: critic retries
+
+    def to_dict(self) -> dict:
+        """Return all fields as JSON-safe dict."""
+        return {
+            "id": self.id,
+            "description": self.description,
+            "dependencies": list(self.dependencies),
+            "status": self.status.value if hasattr(self.status, "value") else str(self.status),
+            "result": self.result,
+            "error": self.error,
+            "speculative": self.speculative,
+            "role": self.role,
+            "retry_count": self.retry_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Task":
+        """Reconstruct Task from dict. Parse status back to TaskStatus enum."""
+        status = data.get("status", TaskStatus.PENDING)
+        if isinstance(status, int):
+            task_status = TaskStatus(status)
+        elif isinstance(status, str):
+            name_to_status = {
+                "PENDING": TaskStatus.PENDING,
+                "RUNNING": TaskStatus.RUNNING,
+                "COMPLETED": TaskStatus.COMPLETED,
+                "FAILED": TaskStatus.FAILED,
+                "0": TaskStatus.PENDING,
+                "1": TaskStatus.RUNNING,
+                "2": TaskStatus.COMPLETED,
+                "-1": TaskStatus.FAILED,
+            }
+            task_status = name_to_status.get(status.upper(), TaskStatus.PENDING)
+        else:
+            task_status = TaskStatus.PENDING
+        return cls(
+            id=data["id"],
+            description=data.get("description", ""),
+            dependencies=list(data.get("dependencies", [])),
+            status=task_status,
+            result=data.get("result"),
+            error=data.get("error"),
+            speculative=data.get("speculative", False),
+            role=data.get("role"),
+            retry_count=data.get("retry_count", 0),
+        )
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, raw: str) -> "Task":
+        return cls.from_dict(json.loads(raw))
+
+    def checksum(self) -> str:
+        """SHA256 of to_json(); used to detect state drift between nodes."""
+        return hashlib.sha256(self.to_json().encode("utf-8")).hexdigest()

devsper/upgrade/__init__.py

@@ -0,0 +1,21 @@
+"""
+Upgrade module: check for updates, changelog, installer detection, perform upgrade.
+"""
+
+from .version_check import (
+    is_update_available,
+    get_current_version,
+    get_latest_version,
+)
+from .installer import detect_installer, perform_install
+from .changelog import fetch_changelog, get_changes_between
+
+__all__ = [
+    "is_update_available",
+    "get_current_version",
+    "get_latest_version",
+    "detect_installer",
+    "perform_install",
+    "fetch_changelog",
+    "get_changes_between",
+]

devsper/upgrade/changelog.py

@@ -0,0 +1,124 @@
+"""
+Changelog fetching and parsing: raw CHANGELOG.md, version sections, Rich formatting.
+"""
+
+import re
+from typing import Literal
+
+import httpx
+
+from .version_check import get_version_diff_type, parse_semver
+
+# Adjust org/repo if needed (e.g. for forks)
+CHANGELOG_URL = "https://raw.githubusercontent.com/anthropic/devsper/main/CHANGELOG.md"
+MAX_LINES_PER_VERSION = 8
+
+
+def fetch_changelog() -> str | None:
+    """Fetch raw CHANGELOG.md content; return None on failure."""
+    try:
+        resp = httpx.get(CHANGELOG_URL, timeout=10.0)
+        resp.raise_for_status()
+        return resp.text
+    except httpx.HTTPError:
+        return None
+
+
+# Match ## [1.2.3], ## [1.2.3] - date, ## 1.2.3, ## 1.2.3 - date
+_VERSION_HEADER = re.compile(
+    r"^##\s+\[?(?P<version>\d+\.\d+\.\d+)\]?(?:\s*-\s*[^\n]*)?\s*$", re.MULTILINE
+)
+
+
+def parse_changelog(content: str) -> dict[str, str]:
+    """
+    Parse markdown changelog into {"1.2.3": "release notes text", ...}.
+    Sections start with ## [1.2.3] or ## 1.2.3.
+    """
+    out: dict[str, str] = {}
+    matches = list(_VERSION_HEADER.finditer(content))
+    for i, m in enumerate(matches):
+        version = m.group("version")
+        start = m.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(content)
+        block = content[start:end].strip()
+        # Normalize: drop leading/trailing blank lines, keep structure
+        out[version] = block
+    return out
+
+
+def _version_in_range(v: str, current: str, latest: str) -> bool:
+    """True if v is strictly after current and <= latest (by semver)."""
+    cur = parse_semver(current)
+    lat = parse_semver(latest)
+    v_tup = parse_semver(v)
+    if v_tup <= cur:
+        return False
+    if v_tup > lat:
+        return False
+    return True
+
+
+def get_changes_between(
+    changelog: dict[str, str], current: str, latest: str
+) -> list[dict]:
+    """
+    Return list of {"version": "1.2.3", "notes": "...", "type": "major|minor|patch"}
+    for all versions between current (exclusive) and latest (inclusive).
+    Type is the bump from the previous release to this one. Sorted newest-first.
+    """
+    cur_tup = parse_semver(current)
+    lat_tup = parse_semver(latest)
+    if lat_tup <= cur_tup:
+        return []
+
+    candidates = [
+        (ver, notes)
+        for ver, notes in changelog.items()
+        if _version_in_range(ver, current, latest)
+    ]
+    # Sort oldest first so we can compute "previous" for each
+    candidates.sort(key=lambda x: parse_semver(x[0]))
+    result: list[dict] = []
+    prev = current
+    for ver, notes in candidates:
+        diff_type: Literal["major", "minor", "patch"] = get_version_diff_type(
+            prev, ver
+        )
+        result.append({"version": ver, "notes": notes, "type": diff_type})
+        prev = ver
+    result.reverse()  # newest first
+    return result
+
+
+def format_changelog_rich(changes: list[dict]) -> str:
+    """
+    Format for terminal with Rich markup.
+    Major: [bold red], minor: [bold yellow], patch: [bold green].
+    Max MAX_LINES_PER_VERSION lines per version, then "... and N more changes".
+    """
+    lines: list[str] = []
+    for entry in changes:
+        ver = entry["version"]
+        notes = entry["notes"]
+        t = entry["type"]
+        if t == "major":
+            header = f"[bold red]Version {ver}[/bold red]"
+        elif t == "minor":
+            header = f"[bold yellow]Version {ver}[/bold yellow]"
+        else:
+            header = f"[bold green]Version {ver}[/bold green]"
+        lines.append(header)
+        note_lines = [ln.strip() for ln in notes.splitlines() if ln.strip()]
+        # Skip sub-headers like "### Added" when counting bullets; treat as structure
+        bullet_lines = [ln for ln in note_lines if re.match(r"^[-*]|\d+\.", ln)]
+        if not bullet_lines:
+            bullet_lines = note_lines[:MAX_LINES_PER_VERSION]
+        shown = bullet_lines[:MAX_LINES_PER_VERSION]
+        for ln in shown:
+            lines.append(f"  • {ln}" if not ln.startswith("•") else f"  {ln}")
+        remaining = len(bullet_lines) - len(shown)
+        if remaining > 0:
+            lines.append(f"  [dim]... and {remaining} more changes[/dim]")
+        lines.append("")
+    return "\n".join(lines).strip()

devsper/upgrade/cli.py

@@ -0,0 +1,145 @@
+"""
+devsper upgrade subcommand: version check, changelog, installer detection, install, verify.
+"""
+
+import sys
+from typing import Literal
+
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.spinner import Spinner
+from .version_check import (
+    get_current_version,
+    get_latest_version,
+    is_update_available,
+    get_version_diff_type,
+)
+from .changelog import fetch_changelog, parse_changelog, get_changes_between, format_changelog_rich
+from .installer import detect_installer, get_install_command, perform_install, verify_installation
+from .notifier import suppress_notifications
+
+_console = Console(stderr=True)
+PACKAGE = "devsper"
+
+
+def _diff_type_color(t: Literal["major", "minor", "patch"]) -> str:
+    return {"major": "red", "minor": "yellow", "patch": "green"}.get(t, "white")
+
+
+def run_upgrade(args: object) -> int:
+    """
+    Entry point for 'devsper upgrade'.
+    Supports: --check, --yes/-y, --version VERSION, --dry-run.
+    """
+    # Avoid startup nag during upgrade
+    suppress_notifications()
+
+    check_only = getattr(args, "check", False)
+    yes = getattr(args, "yes", False)
+    version_override = getattr(args, "version", None)
+    dry_run = getattr(args, "dry_run", False)
+
+    current = get_current_version()
+
+    # ---- Step 1: Version check ----
+    if version_override:
+        latest = version_override
+        from .version_check import parse_semver
+        cur_t = parse_semver(current)
+        lat_t = parse_semver(latest)
+        available = lat_t > cur_t
+        _console.print(f"[dim]Installing specified version {latest}[/dim]")
+    else:
+        _console.print("[dim]Fetching latest version from PyPI...[/dim]")
+        try:
+            available, _, latest = is_update_available()
+        except Exception as e:
+            _console.print(f"[red]Error checking PyPI: {e}[/red]")
+            return 1
+
+    diff_type = get_version_diff_type(current, latest)
+    color = _diff_type_color(diff_type)
+    _console.print(f"{PACKAGE} [bold]{current}[/bold] → [bold]{latest}[/bold]  [{color}][{diff_type} update][/{color}]")
+
+    if check_only:
+        if not available and not version_override:
+            _console.print("[green]You are on the latest version.[/green]")
+        return 0
+
+    if not available and not version_override:
+        _console.print("[green]Already on latest version. Use --version X.Y.Z to install a specific version.[/green]")
+        return 0
+
+    # Specific version check: ensure it exists on PyPI (optional: could add a quick PyPI check)
+    if version_override:
+        # We'll discover "not found" during install
+        pass
+
+    # ---- Step 2: Changelog ----
+    changelog_raw = fetch_changelog()
+    changes: list[dict] = []
+    if changelog_raw:
+        parsed = parse_changelog(changelog_raw)
+        changes = get_changes_between(parsed, current, latest)
+        if changes:
+            if len(changes) > 3:
+                _console.print(f"[dim]Showing changes across {len(changes)} releases[/dim]")
+            formatted = format_changelog_rich(changes)
+            _console.print(Panel(formatted, title="Changelog", border_style="blue"))
+    else:
+        _console.print("[dim]Changelog unavailable (network or repo).[/dim]")
+
+    # ---- Step 3: Installer detection ----
+    installer = detect_installer()
+    if installer == "uv":
+        _console.print("  [green]Installing with uv[/green] ✓")
+        _console.print("  [dim]uv detected in environment[/dim]")
+    else:
+        _console.print("  Installing with [yellow]pip[/yellow]")
+
+    if dry_run:
+        cmd = get_install_command(installer, version=latest)
+        _console.print(f"[dim]Dry run: would run: {' '.join(cmd)}[/dim]")
+        return 0
+
+    # ---- Step 4: Confirmation ----
+    if not yes:
+        proceed = Confirm.ask("Proceed with upgrade?", default=True, console=_console)
+        if not proceed:
+            _console.print("Cancelled.")
+            return 0
+
+    # ---- Step 5: Installation with progress ----
+    with Live(
+        Spinner("dots", text=f"  Installing {PACKAGE} {latest}..."),
+        console=_console,
+        refresh_per_second=10,
+    ):
+        success, output = perform_install(installer, version=latest)
+
+    if not success:
+        _console.print("[red]Installation failed:[/red]")
+        _console.print(output)
+        _console.print("[dim]Try running with --verbose or use pip/uv directly.[/dim]")
+        if "Permission denied" in output or "permission" in output.lower():
+            _console.print("[yellow]Tip: use a virtualenv or run with appropriate permissions.[/yellow]")
+        if "404" in output or "not found" in output.lower():
+            _console.print(f"[yellow]Version {latest} may not exist on PyPI.[/yellow]")
+        return 1
+
+    # ---- Step 6: Verification ----
+    if verify_installation(latest):
+        _console.print(f"  [green]✓ Successfully upgraded to {PACKAGE} {latest}[/green]")
+    else:
+        _console.print(f"  [yellow]Upgrade completed but version check failed. Run [bold]devsper --version[/bold] to confirm.[/yellow]")
+
+    # ---- Step 7: Post-install summary ----
+    if diff_type == "major":
+        _console.print("  [bold red]⚠ Major update — review breaking changes above[/bold red]")
+    _console.print("  [dim]Run devsper --help to see commands[/dim]")
+    if changes:
+        _console.print(f"  [dim]{len(changes)} release(s) applied.[/dim]")
+
+    return 0