scc-cli 1.5.3__py3-none-any.whl

scc_cli/ui/dashboard/loaders.py

@@ -0,0 +1,452 @@
+"""Data loading functions for dashboard tabs.
+
+This module contains functions to load data for each dashboard tab:
+- Status: System overview (team, organization, counts)
+- Containers: Docker containers managed by SCC
+- Sessions: Recent Claude sessions
+- Worktrees: Git worktrees in current repository
+
+Each loader function returns a TabData instance ready for display.
+Loaders handle errors gracefully, returning placeholder items on failure.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..list_screen import ListItem
+from .models import DashboardTab, TabData
+
+
+def _load_status_tab_data() -> TabData:
+    """Load Status tab data showing system overview.
+
+    The Status tab displays:
+    - Current team and organization info
+    - Sync status with remote config
+    - Resource counts for quick overview
+    - Optional enhancements (statusline)
+
+    Returns:
+        TabData with status summary items.
+    """
+    # Import here to avoid circular imports
+    from ... import config, docker, sessions
+    from ...docker import core as docker_core
+
+    items: list[ListItem[str]] = []
+
+    # Start new session (primary action)
+    items.append(
+        ListItem(
+            value="start_session",
+            label="Start new session",
+            description="Launch Claude in a workspace",
+        )
+    )
+
+    # Load current team info
+    try:
+        user_config = config.load_user_config()
+        team = user_config.get("selected_profile")
+        org_source = user_config.get("organization_source")
+
+        if team:
+            items.append(
+                ListItem(
+                    value="team",
+                    label="Team",
+                    description=f"{team} (Enter to switch)",
+                )
+            )
+        else:
+            items.append(
+                ListItem(
+                    value="team",
+                    label="Team",
+                    description="No team selected (Enter to choose)",
+                )
+            )
+
+        # Organization/sync status
+        if org_source and isinstance(org_source, dict):
+            org_url = org_source.get("url", "")
+            if org_url:
+                # Extract domain for display
+                domain = org_url.replace("https://", "").replace("http://", "").split("/")[0]
+                org_name = None
+                try:
+                    org_config = config.load_cached_org_config()
+                    if org_config:
+                        org_name = org_config.get("organization", {}).get("name")
+                except Exception:
+                    org_name = None
+
+                desc = domain
+                if org_name:
+                    desc = f"{org_name} ({domain})"
+
+                items.append(
+                    ListItem(
+                        value="organization",
+                        label="Organization",
+                        description=desc,
+                    )
+                )
+        elif user_config.get("standalone"):
+            items.append(
+                ListItem(
+                    value="organization",
+                    label="Mode",
+                    description="Standalone (no remote config)",
+                )
+            )
+
+    except Exception:
+        items.append(
+            ListItem(
+                value="config_error",
+                label="Configuration",
+                description="Error loading config",
+            )
+        )
+
+    # Load container count
+    try:
+        containers = docker_core.list_scc_containers()
+        running = sum(1 for c in containers if "Up" in c.status)
+        total = len(containers)
+        items.append(
+            ListItem(
+                value="containers",
+                label="Containers",
+                description=f"{running} running, {total} total",
+            )
+        )
+    except Exception:
+        items.append(
+            ListItem(
+                value="containers",
+                label="Containers",
+                description="Unable to query Docker",
+            )
+        )
+
+    # Load session count
+    try:
+        recent_sessions = sessions.list_recent(limit=100)
+        session_count = len(recent_sessions)
+        items.append(
+            ListItem(
+                value="sessions",
+                label="Sessions",
+                description=f"{session_count} recorded",
+            )
+        )
+    except Exception:
+        items.append(
+            ListItem(
+                value="sessions",
+                label="Sessions",
+                description="Error loading sessions",
+            )
+        )
+
+    # Check statusline status (optional enhancement)
+    try:
+        settings = docker.get_sandbox_settings()
+        has_statusline = settings is not None and "statusLine" in settings
+        if has_statusline:
+            items.append(
+                ListItem(
+                    value="statusline_installed",
+                    label="Statusline",
+                    description="✓ Installed",
+                )
+            )
+        else:
+            items.append(
+                ListItem(
+                    value="statusline_not_installed",
+                    label="Statusline",
+                    description="Not installed - Enter to install",
+                    governance_status="warning",
+                )
+            )
+    except Exception:
+        # Docker not available - don't show statusline option
+        pass
+
+    return TabData(
+        tab=DashboardTab.STATUS,
+        title="Status",
+        items=items,
+        count_active=len(items),
+        count_total=len(items),
+    )
+
+
+def _load_containers_tab_data() -> TabData:
+    """Load Containers tab data showing SCC-managed containers.
+
+    Returns:
+        TabData with container list items.
+    """
+    from ...docker import core as docker_core
+
+    items: list[ListItem[str]] = []
+
+    try:
+        containers = docker_core.list_scc_containers()
+        running_count = 0
+
+        for container in containers:
+            is_running = "Up" in container.status
+            if is_running:
+                running_count += 1
+
+            # Build description from available info
+            desc_parts = []
+            if container.profile:
+                desc_parts.append(container.profile)
+            if container.workspace:
+                # Show just the workspace name
+                workspace_name = container.workspace.split("/")[-1]
+                desc_parts.append(workspace_name)
+            if container.status:
+                # Simplify status (e.g., "Up 2 hours" → "Up 2h")
+                status_short = container.status.replace(" hours", "h").replace(" hour", "h")
+                status_short = status_short.replace(" minutes", "m").replace(" minute", "m")
+                status_short = status_short.replace(" days", "d").replace(" day", "d")
+                desc_parts.append(status_short)
+
+            items.append(
+                ListItem(
+                    value=container.id,
+                    label=container.name,
+                    description="  ".join(desc_parts),
+                )
+            )
+
+        if not items:
+            items.append(
+                ListItem(
+                    value="no_containers",
+                    label="No containers",
+                    description="Run 'scc start' to create one",
+                )
+            )
+
+        return TabData(
+            tab=DashboardTab.CONTAINERS,
+            title="Containers",
+            items=items,
+            count_active=running_count,
+            count_total=len(containers),
+        )
+
+    except Exception:
+        return TabData(
+            tab=DashboardTab.CONTAINERS,
+            title="Containers",
+            items=[
+                ListItem(
+                    value="error",
+                    label="Error",
+                    description="Unable to query Docker",
+                )
+            ],
+            count_active=0,
+            count_total=0,
+        )
+
+
+def _load_sessions_tab_data() -> TabData:
+    """Load Sessions tab data showing recent Claude sessions.
+
+    Returns:
+        TabData with session list items. Each ListItem.value contains
+        the raw session dict for access in the details pane.
+    """
+    from ... import sessions
+
+    items: list[ListItem[dict[str, Any]]] = []
+
+    try:
+        recent = sessions.list_recent(limit=20)
+
+        for session in recent:
+            name = session.get("name", "Unnamed")
+            desc_parts = []
+
+            if session.get("team"):
+                desc_parts.append(str(session["team"]))
+            if session.get("branch"):
+                desc_parts.append(str(session["branch"]))
+            if session.get("last_used"):
+                desc_parts.append(str(session["last_used"]))
+
+            # Store full session dict for details pane access
+            items.append(
+                ListItem(
+                    value=session,
+                    label=name,
+                    description="  ".join(desc_parts),
+                )
+            )
+
+        if not items:
+            # Placeholder with sentinel dict (startable: True enables Enter action)
+            items.append(
+                ListItem(
+                    value={"_placeholder": "no_sessions", "_startable": True},
+                    label="No sessions",
+                    description="Press Enter to start",
+                )
+            )
+
+        return TabData(
+            tab=DashboardTab.SESSIONS,
+            title="Sessions",
+            items=items,
+            count_active=len(recent),
+            count_total=len(recent),
+        )
+
+    except Exception:
+        return TabData(
+            tab=DashboardTab.SESSIONS,
+            title="Sessions",
+            items=[
+                ListItem(
+                    value="error",
+                    label="Error",
+                    description="Unable to load sessions",
+                )
+            ],
+            count_active=0,
+            count_total=0,
+        )
+
+
+def _load_worktrees_tab_data(verbose: bool = False) -> TabData:
+    """Load Worktrees tab data showing git worktrees.
+
+    Worktrees are loaded from the current working directory if it's a git repo.
+
+    Args:
+        verbose: If True, fetch git status for each worktree (slower but shows
+            staged/modified/untracked counts with +N/!N/?N indicators).
+
+    Returns:
+        TabData with worktree list items.
+    """
+    import os
+    from pathlib import Path
+
+    from ... import git
+
+    items: list[ListItem[str]] = []
+
+    try:
+        cwd = Path(os.getcwd())
+        worktrees = git.list_worktrees(cwd)
+        current_count = 0
+
+        # If verbose, fetch status for each worktree
+        if verbose:
+            for wt in worktrees:
+                staged, modified, untracked, timed_out = git.get_worktree_status(wt.path)
+                wt.staged_count = staged
+                wt.modified_count = modified
+                wt.untracked_count = untracked
+                wt.status_timed_out = timed_out
+                wt.has_changes = (staged + modified + untracked) > 0
+
+        for wt in worktrees:
+            if wt.is_current:
+                current_count += 1
+
+            desc_parts = []
+            if wt.branch:
+                desc_parts.append(wt.branch)
+
+            # Show status markers when verbose
+            if verbose:
+                if wt.status_timed_out:
+                    desc_parts.append("…")  # Timeout indicator
+                else:
+                    status_parts = []
+                    if wt.staged_count > 0:
+                        status_parts.append(f"+{wt.staged_count}")
+                    if wt.modified_count > 0:
+                        status_parts.append(f"!{wt.modified_count}")
+                    if wt.untracked_count > 0:
+                        status_parts.append(f"?{wt.untracked_count}")
+                    if status_parts:
+                        desc_parts.append(" ".join(status_parts))
+                    elif not wt.has_changes:
+                        desc_parts.append(".")  # Clean indicator
+            elif wt.has_changes:
+                desc_parts.append("*modified")
+
+            if wt.is_current:
+                desc_parts.append("(current)")
+
+            items.append(
+                ListItem(
+                    value=wt.path,
+                    label=Path(wt.path).name,
+                    description="  ".join(desc_parts),
+                )
+            )
+
+        if not items:
+            items.append(
+                ListItem(
+                    value="no_worktrees",
+                    label="No worktrees",
+                    description="Press 'w' recent | 'i' init | 'c' clone",
+                )
+            )
+
+        return TabData(
+            tab=DashboardTab.WORKTREES,
+            title="Worktrees",
+            items=items,
+            count_active=current_count,
+            count_total=len(worktrees),
+        )
+
+    except Exception:
+        return TabData(
+            tab=DashboardTab.WORKTREES,
+            title="Worktrees",
+            items=[
+                ListItem(
+                    value="no_git",
+                    label="Not available",
+                    description="Press 'w' recent | 'i' init | 'c' clone",
+                )
+            ],
+            count_active=0,
+            count_total=0,
+        )
+
+
+def _load_all_tab_data(verbose_worktrees: bool = False) -> dict[DashboardTab, TabData]:
+    """Load data for all dashboard tabs.
+
+    Args:
+        verbose_worktrees: If True, fetch git status for each worktree
+            (shows +N/!N/?N indicators but takes longer).
+
+    Returns:
+        Dictionary mapping each tab to its data.
+    """
+    return {
+        DashboardTab.STATUS: _load_status_tab_data(),
+        DashboardTab.CONTAINERS: _load_containers_tab_data(),
+        DashboardTab.SESSIONS: _load_sessions_tab_data(),
+        DashboardTab.WORKTREES: _load_worktrees_tab_data(verbose=verbose_worktrees),
+    }

scc_cli/ui/dashboard/models.py

@@ -0,0 +1,185 @@
+"""Data models for the dashboard module.
+
+This module contains the core data structures used by the dashboard:
+- DashboardTab: Enum for available tabs
+- TabData: Content for a single tab
+- DashboardState: State management for the dashboard
+
+These models are intentionally simple dataclasses with no external dependencies
+beyond the UI layer, enabling clean separation and testability.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import Any
+
+from ..list_screen import ListItem, ListState
+
+
+class DashboardTab(Enum):
+    """Available dashboard tabs.
+
+    Each tab represents a major resource category in SCC.
+    Tabs are displayed in definition order (Status first, Worktrees last).
+    """
+
+    STATUS = auto()
+    CONTAINERS = auto()
+    SESSIONS = auto()
+    WORKTREES = auto()
+
+    @property
+    def display_name(self) -> str:
+        """Human-readable name for display in chrome."""
+        names = {
+            DashboardTab.STATUS: "Status",
+            DashboardTab.CONTAINERS: "Containers",
+            DashboardTab.SESSIONS: "Sessions",
+            DashboardTab.WORKTREES: "Worktrees",
+        }
+        return names[self]
+
+
+# Ordered list for tab cycling
+TAB_ORDER: tuple[DashboardTab, ...] = (
+    DashboardTab.STATUS,
+    DashboardTab.CONTAINERS,
+    DashboardTab.SESSIONS,
+    DashboardTab.WORKTREES,
+)
+
+
+@dataclass
+class TabData:
+    """Data for a single dashboard tab.
+
+    Attributes:
+        tab: The tab identifier.
+        title: Display title for the tab content area.
+        items: List items to display in this tab. Value type varies by tab:
+            - Containers/Worktrees: str (container ID or worktree name)
+            - Sessions: dict[str, Any] (full session data for details pane)
+        count_active: Number of active items (e.g., running containers).
+        count_total: Total number of items.
+    """
+
+    tab: DashboardTab
+    title: str
+    items: Sequence[ListItem[Any]]
+    count_active: int
+    count_total: int
+
+    @property
+    def subtitle(self) -> str:
+        """Generate subtitle from counts."""
+        if self.count_active == self.count_total:
+            return f"{self.count_total} total"
+        return f"{self.count_active} active, {self.count_total} total"
+
+
+@dataclass
+class DashboardState:
+    """State for the tabbed dashboard view.
+
+    Manages which tab is active and provides methods for tab navigation.
+    Each tab switch resets the list state for the new tab.
+
+    Attributes:
+        active_tab: Currently active tab.
+        tabs: Mapping from tab to its data.
+        list_state: Navigation state for the current tab's list.
+        status_message: Transient message to display (cleared on next action).
+        details_open: Whether the details pane is visible.
+        help_visible: Whether the help overlay is shown (rendered inside Live).
+    """
+
+    active_tab: DashboardTab
+    tabs: dict[DashboardTab, TabData]
+    list_state: ListState[str]
+    status_message: str | None = None
+    details_open: bool = False
+    help_visible: bool = False
+    verbose_worktrees: bool = False  # Toggle for worktree status display
+
+    @property
+    def current_tab_data(self) -> TabData:
+        """Get data for the currently active tab."""
+        return self.tabs[self.active_tab]
+
+    def is_placeholder_selected(self) -> bool:
+        """Check if the current selection is a placeholder row.
+
+        Placeholder rows represent empty states or errors (e.g., "No containers",
+        "Error loading sessions") and shouldn't show details.
+
+        Placeholders can be identified by:
+        - String value matching known placeholder names (containers, worktrees)
+        - Dict value with "_placeholder" key (sessions)
+
+        Returns:
+            True if current item is a placeholder, False otherwise.
+        """
+        current = self.list_state.current_item
+        if not current:
+            return True  # No item = treat as placeholder
+
+        # Known placeholder string values from tab data loaders
+        placeholder_values = {
+            "no_containers",
+            "no_sessions",
+            "no_worktrees",
+            "no_git",
+            "error",
+            "config_error",
+        }
+
+        # Check string placeholders (must be string type first - dicts are unhashable)
+        if isinstance(current.value, str) and current.value in placeholder_values:
+            return True
+
+        # Check dict placeholders (sessions tab uses dicts)
+        if isinstance(current.value, dict) and "_placeholder" in current.value:
+            return True
+
+        return False
+
+    def switch_tab(self, tab: DashboardTab) -> DashboardState:
+        """Create new state with different active tab.
+
+        Resets list state (cursor, filter) for the new tab.
+
+        Args:
+            tab: Tab to switch to.
+
+        Returns:
+            New DashboardState with the specified tab active.
+        """
+        new_list_state = ListState(items=self.tabs[tab].items)
+        return DashboardState(
+            active_tab=tab,
+            tabs=self.tabs,
+            list_state=new_list_state,
+        )
+
+    def next_tab(self) -> DashboardState:
+        """Switch to the next tab (wraps around).
+
+        Returns:
+            New DashboardState with next tab active.
+        """
+        current_index = TAB_ORDER.index(self.active_tab)
+        next_index = (current_index + 1) % len(TAB_ORDER)
+        return self.switch_tab(TAB_ORDER[next_index])
+
+    def prev_tab(self) -> DashboardState:
+        """Switch to the previous tab (wraps around).
+
+        Returns:
+            New DashboardState with previous tab active.
+        """
+        current_index = TAB_ORDER.index(self.active_tab)
+        prev_index = (current_index - 1) % len(TAB_ORDER)
+        return self.switch_tab(TAB_ORDER[prev_index])