superqode 0.1.5__py3-none-any.whl

superqode/widgets/agent_switcher.py

@@ -0,0 +1,395 @@
+"""Agent switcher modal widget (Ctrl+A) - Redesigned for accessibility."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import uuid
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll, Horizontal
+from textual.message import Message
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+@dataclass
+class AgentInfo:
+    """Information about an agent."""
+
+    identity: str
+    name: str
+    short_name: str
+    description: str
+    installed: bool = False
+    connected: bool = False
+    agent_type: str = "coding"
+    provider: str = ""  # e.g., "OpenCode", "Gemini", "OpenAI"
+
+
+class AgentItem(Widget):
+    """A single agent item in the switcher - high contrast design."""
+
+    DEFAULT_CSS = """
+    AgentItem {
+        height: auto;
+        min-height: 5;
+        padding: 1;
+        margin: 0 0 1 0;
+        background: #1a1a1a;
+        border: solid #444444;
+        layout: vertical;
+    }
+
+    AgentItem:hover {
+        border: solid #00ffff;
+        background: #2a2a2a;
+    }
+
+    AgentItem.selected {
+        border: double #00ff00;
+        background: #002200;
+    }
+
+    AgentItem.connected {
+        border: solid #00ff00;
+        background: #002200;
+    }
+
+    AgentItem .agent-header {
+        height: 1;
+        width: 100%;
+    }
+
+    AgentItem .status-icon {
+        width: 4;
+        color: #ffffff;
+    }
+
+    AgentItem .agent-name {
+        text-style: bold;
+        color: #ffffff;
+    }
+
+    AgentItem .agent-status-text {
+        dock: right;
+        color: #00ff00;
+        text-style: bold;
+        padding-right: 1;
+    }
+
+    AgentItem .agent-provider {
+        color: #00ffff;
+        text-style: bold;
+        padding-left: 4;
+        height: 1;
+    }
+
+    AgentItem .agent-description {
+        color: #aaaaaa;
+        padding-left: 4;
+        height: 1;
+    }
+
+    AgentItem .agent-type {
+        color: #888888;
+        padding-left: 4;
+        text-style: italic;
+    }
+
+    AgentItem.not-installed .agent-name {
+        color: #888888;
+    }
+
+    AgentItem.not-installed .agent-status-text {
+        color: #ffaa00;
+    }
+    """
+
+    class Selected(Message):
+        """Message sent when agent is selected."""
+
+        def __init__(self, agent: AgentInfo) -> None:
+            self.agent = agent
+            super().__init__()
+
+    selected: reactive[bool] = reactive(False)
+
+    def __init__(self, agent: AgentInfo, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.agent = agent
+
+    def compose(self) -> ComposeResult:
+        # Header row with icon, name, and status
+        with Horizontal(classes="agent-header"):
+            # Status icon - clear and visible
+            if self.agent.connected:
+                icon = "🟢"
+                status_text = "CONNECTED"
+            elif self.agent.installed:
+                icon = "✅"
+                status_text = "READY"
+            else:
+                icon = "📦"
+                status_text = "INSTALL"
+
+            yield Static(icon, classes="status-icon")
+            yield Static(f"{self.agent.name}", classes="agent-name")
+            yield Static(status_text, classes="agent-status-text")
+
+        # Provider/Coding Agent info
+        provider_text = self.agent.provider or self.agent.short_name.upper()
+        yield Static(f"🤖 Coding Agent: {provider_text}", classes="agent-provider")
+
+        # Description
+        desc = (
+            self.agent.description[:55] + "..."
+            if len(self.agent.description) > 55
+            else self.agent.description
+        )
+        yield Static(desc if desc else "No description", classes="agent-description")
+
+        # Agent type
+        yield Static(f"Type: {self.agent.agent_type}", classes="agent-type")
+
+    def on_mount(self) -> None:
+        """Set classes on mount."""
+        self.set_class(self.agent.connected, "connected")
+        self.set_class(not self.agent.installed, "not-installed")
+
+    def watch_selected(self, selected: bool) -> None:
+        self.set_class(selected, "selected")
+
+    def on_click(self) -> None:
+        self.post_message(self.Selected(self.agent))
+
+
+class AgentSwitcher(Widget):
+    """
+    Quick agent switcher modal (Ctrl+A) - High contrast, accessible design.
+
+    Shows available agents with their status and allows quick switching.
+    """
+
+    DEFAULT_CSS = """
+    AgentSwitcher {
+        layer: overlay;
+        align: center middle;
+        width: 75;
+        height: auto;
+        max-height: 28;
+        background: #000000;
+        border: double #00ffff;
+        display: none;
+    }
+
+    AgentSwitcher.visible {
+        display: block;
+    }
+
+    AgentSwitcher #switcher-title-bar {
+        height: 3;
+        background: #001a33;
+        padding: 1;
+    }
+
+    AgentSwitcher #switcher-title {
+        text-style: bold;
+        color: #00ffff;
+        text-align: center;
+    }
+
+    AgentSwitcher #switcher-subtitle {
+        color: #888888;
+        text-align: center;
+    }
+
+    AgentSwitcher #agent-list {
+        height: auto;
+        max-height: 21;
+        padding: 1;
+        background: #0a0a0a;
+    }
+
+    AgentSwitcher #switcher-footer {
+        height: 2;
+        background: #1a1a1a;
+        color: #00ffff;
+        padding: 0 1;
+        border-top: solid #333333;
+    }
+
+    AgentSwitcher #footer-hints {
+        text-align: center;
+        color: #00ff00;
+    }
+
+    AgentSwitcher .empty-message {
+        padding: 2;
+        color: #ffff00;
+        text-style: bold;
+        text-align: center;
+        background: #1a1a00;
+        border: solid #ffff00;
+        margin: 1;
+    }
+
+    AgentSwitcher .agent-count {
+        dock: right;
+        color: #00ff00;
+    }
+    """
+
+    class AgentSelected(Message):
+        """Message sent when an agent is selected."""
+
+        def __init__(self, agent: AgentInfo) -> None:
+            self.agent = agent
+            super().__init__()
+
+    class Dismissed(Message):
+        """Message sent when switcher is dismissed."""
+
+    # State
+    is_visible: reactive[bool] = reactive(False)
+    selected_index: reactive[int] = reactive(0)
+
+    def __init__(self, agents: list[AgentInfo] | None = None, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.agents: list[AgentInfo] = agents or []
+        self._render_id = ""  # Unique ID for each render
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="switcher-title-bar"):
+            yield Static("🤖 AGENT SWITCHER", id="switcher-title")
+            yield Static("Select a coding agent to connect", id="switcher-subtitle")
+        yield VerticalScroll(id="agent-list")
+        with Vertical(id="switcher-footer"):
+            yield Static("↑↓ Navigate  │  Enter Connect  │  Esc Close", id="footer-hints")
+
+    def show(self, agents: list[AgentInfo] | None = None) -> None:
+        """Show agent switcher."""
+        if agents is not None:
+            self.agents = agents
+        self.selected_index = 0
+        self.is_visible = True
+        self.add_class("visible")
+        self._render_agents()
+        self.focus()
+
+    def hide(self) -> None:
+        """Hide agent switcher."""
+        self.is_visible = False
+        self.remove_class("visible")
+        self.post_message(self.Dismissed())
+
+    def toggle(self, agents: list[AgentInfo] | None = None) -> None:
+        """Toggle visibility."""
+        if self.is_visible:
+            self.hide()
+        else:
+            self.show(agents)
+
+    def _render_agents(self) -> None:
+        """Render the agent list with clear visibility."""
+        # Generate unique ID for this render to avoid duplicate widget IDs
+        self._render_id = uuid.uuid4().hex[:8]
+
+        container = self.query_one("#agent-list", VerticalScroll)
+        container.remove_children()
+
+        if not self.agents:
+            container.mount(
+                Static(
+                    "No agents found!\nUse /store to browse and install agents.",
+                    classes="empty-message",
+                )
+            )
+            return
+
+        # Sort: connected first, then installed, then others
+        sorted_agents = sorted(
+            self.agents,
+            key=lambda a: (not a.connected, not a.installed, a.name),
+        )
+
+        for i, agent in enumerate(sorted_agents):
+            # Use unique render_id + index to ensure unique widget IDs
+            item = AgentItem(agent, id=f"agent-{self._render_id}-{i}")
+            item.selected = i == self.selected_index
+            container.mount(item)
+
+        # Update title to show count
+        title = self.query_one("#switcher-title", Static)
+        installed = sum(1 for a in self.agents if a.installed)
+        connected = sum(1 for a in self.agents if a.connected)
+        title.update(f"🤖 CODING AGENTS ({installed} installed, {connected} connected)")
+
+    def _update_selection(self) -> None:
+        """Update visual selection state."""
+        items = list(self.query("#agent-list AgentItem"))
+        for i, item in enumerate(items):
+            if isinstance(item, AgentItem):
+                item.selected = i == self.selected_index
+
+    def move_selection(self, delta: int) -> None:
+        """Move selection up or down."""
+        if not self.agents:
+            return
+        new_index = (self.selected_index + delta) % len(self.agents)
+        self.selected_index = new_index
+        self._update_selection()
+
+        # Scroll to make selection visible
+        try:
+            container = self.query_one("#agent-list", VerticalScroll)
+            items = list(self.query("#agent-list AgentItem"))
+            if 0 <= self.selected_index < len(items):
+                container.scroll_visible(items[self.selected_index])
+        except Exception:
+            pass
+
+    def select_current(self) -> AgentInfo | None:
+        """Select the current agent."""
+        if self.agents and 0 <= self.selected_index < len(self.agents):
+            # Get sorted agents (same order as rendered)
+            sorted_agents = sorted(
+                self.agents,
+                key=lambda a: (not a.connected, not a.installed, a.name),
+            )
+            agent = sorted_agents[self.selected_index]
+            self.post_message(self.AgentSelected(agent))
+            self.hide()
+            return agent
+        return None
+
+    def on_key(self, event) -> None:
+        """Handle key events."""
+        if not self.is_visible:
+            return
+
+        if event.key == "escape":
+            self.hide()
+            event.stop()
+        elif event.key == "up":
+            self.move_selection(-1)
+            event.stop()
+        elif event.key == "down":
+            self.move_selection(1)
+            event.stop()
+        elif event.key == "enter":
+            self.select_current()
+            event.stop()
+
+    @on(AgentItem.Selected)
+    def on_agent_item_selected(self, event: AgentItem.Selected) -> None:
+        """Handle agent selection via click."""
+        self.post_message(self.AgentSelected(event.agent))
+        self.hide()
+
+    def update_agents(self, agents: list[AgentInfo]) -> None:
+        """Update the agent list."""
+        self.agents = agents
+        if self.is_visible:
+            self._render_agents()

superqode/widgets/animation_manager.py

@@ -0,0 +1,284 @@
+"""
+Animation Manager - Performance-Conscious Animation Control.
+
+Provides centralized control for TUI animations to prevent
+performance issues from multiple concurrent animations.
+
+Features:
+- Global frame rate limiting
+- Focus-aware animation pausing
+- Low-power mode support
+- Batched updates for multiple animated widgets
+"""
+
+import time
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Set
+from weakref import WeakSet
+
+from textual.app import App
+from textual.timer import Timer
+from textual.widget import Widget
+
+
+@dataclass
+class AnimationConfig:
+    """Configuration for animation behavior."""
+
+    max_fps: int = 10  # Maximum frames per second
+    pause_on_blur: bool = True  # Pause when app loses focus
+    low_power_mode: bool = False  # Reduce animations for battery
+    batch_updates: bool = True  # Batch widget updates together
+
+    @property
+    def frame_interval(self) -> float:
+        """Get interval between frames in seconds."""
+        return 1.0 / self.max_fps
+
+
+class AnimationManager:
+    """Central manager for TUI animations.
+
+    Controls animation timing across multiple widgets to prevent
+    performance degradation from too many concurrent animations.
+
+    Usage:
+        # In your App class
+        class MyApp(App):
+            def on_mount(self):
+                self.animation_manager = AnimationManager(self)
+                self.animation_manager.start()
+
+        # In animated widgets
+        class MyWidget(Static):
+            def on_mount(self):
+                app = self.app
+                if hasattr(app, 'animation_manager'):
+                    app.animation_manager.register(self, self._animate)
+
+            def _animate(self, frame: int) -> None:
+                # Update animation state
+                self.refresh()
+    """
+
+    def __init__(
+        self,
+        app: App,
+        config: Optional[AnimationConfig] = None,
+    ):
+        self.app = app
+        self.config = config or AnimationConfig()
+
+        # Registered widgets and their callbacks
+        self._widgets: WeakSet[Widget] = WeakSet()
+        self._callbacks: Dict[int, Callable[[int], None]] = {}
+
+        # State
+        self._timer: Optional[Timer] = None
+        self._frame: int = 0
+        self._running: bool = False
+        self._focused: bool = True
+        self._last_tick: float = 0.0
+
+        # Batching
+        self._pending_refreshes: Set[Widget] = set()
+
+    @property
+    def is_running(self) -> bool:
+        """Check if animation manager is running."""
+        return self._running
+
+    @property
+    def current_frame(self) -> int:
+        """Get the current animation frame number."""
+        return self._frame
+
+    @property
+    def should_animate(self) -> bool:
+        """Check if animations should run right now."""
+        if self.config.low_power_mode:
+            return False
+        if self.config.pause_on_blur and not self._focused:
+            return False
+        return self._running
+
+    def register(
+        self,
+        widget: Widget,
+        callback: Callable[[int], None],
+    ) -> None:
+        """Register a widget for animation updates.
+
+        Args:
+            widget: The widget to animate
+            callback: Called each frame with frame number
+        """
+        self._widgets.add(widget)
+        self._callbacks[id(widget)] = callback
+
+    def unregister(self, widget: Widget) -> None:
+        """Unregister a widget from animation updates."""
+        self._widgets.discard(widget)
+        self._callbacks.pop(id(widget), None)
+        self._pending_refreshes.discard(widget)
+
+    def start(self) -> None:
+        """Start the animation manager."""
+        if self._running:
+            return
+
+        self._running = True
+        self._last_tick = time.monotonic()
+
+        # Create timer for animation ticks
+        self._timer = self.app.set_interval(
+            self.config.frame_interval,
+            self._tick,
+        )
+
+    def stop(self) -> None:
+        """Stop the animation manager."""
+        self._running = False
+        if self._timer:
+            self._timer.stop()
+            self._timer = None
+
+    def pause(self) -> None:
+        """Pause animations (e.g., when app loses focus)."""
+        self._focused = False
+
+    def resume(self) -> None:
+        """Resume animations (e.g., when app gains focus)."""
+        self._focused = True
+
+    def set_low_power(self, enabled: bool) -> None:
+        """Enable/disable low power mode."""
+        self.config.low_power_mode = enabled
+
+    def request_refresh(self, widget: Widget) -> None:
+        """Request a refresh for a widget (batched if enabled)."""
+        if self.config.batch_updates:
+            self._pending_refreshes.add(widget)
+        else:
+            widget.refresh()
+
+    def _tick(self) -> None:
+        """Called each animation frame."""
+        if not self.should_animate:
+            return
+
+        self._frame += 1
+        current_time = time.monotonic()
+
+        # Call all registered callbacks
+        dead_widgets = []
+        for widget in list(self._widgets):
+            if not widget.is_attached:
+                dead_widgets.append(widget)
+                continue
+
+            callback = self._callbacks.get(id(widget))
+            if callback:
+                try:
+                    callback(self._frame)
+                except Exception:
+                    # Don't let one widget break others
+                    dead_widgets.append(widget)
+
+        # Cleanup dead widgets
+        for widget in dead_widgets:
+            self.unregister(widget)
+
+        # Flush batched refreshes
+        if self.config.batch_updates and self._pending_refreshes:
+            for widget in self._pending_refreshes:
+                if widget.is_attached:
+                    widget.refresh()
+            self._pending_refreshes.clear()
+
+        self._last_tick = current_time
+
+
+class AnimatedWidget(Widget):
+    """Base class for widgets that participate in managed animations.
+
+    Automatically registers with the app's AnimationManager if present.
+
+    Subclasses should override `on_animation_frame()` to update state.
+    """
+
+    def on_mount(self) -> None:
+        """Register with animation manager when mounted."""
+        super().on_mount()
+        self._register_animation()
+
+    def on_unmount(self) -> None:
+        """Unregister from animation manager when unmounted."""
+        self._unregister_animation()
+        super().on_unmount()
+
+    def _register_animation(self) -> None:
+        """Register with the app's animation manager."""
+        app = self.app
+        if hasattr(app, "animation_manager"):
+            app.animation_manager.register(self, self.on_animation_frame)
+
+    def _unregister_animation(self) -> None:
+        """Unregister from the app's animation manager."""
+        app = self.app
+        if hasattr(app, "animation_manager"):
+            app.animation_manager.unregister(self)
+
+    def on_animation_frame(self, frame: int) -> None:
+        """Called each animation frame.
+
+        Override this method to update animation state.
+        Call self.refresh() when visual update is needed.
+
+        Args:
+            frame: The current frame number
+        """
+        pass
+
+
+class ThrottledRefreshMixin:
+    """Mixin that provides throttled refresh capability.
+
+    Use this to prevent excessive refreshes in widgets that
+    receive rapid updates.
+
+    Usage:
+        class MyWidget(ThrottledRefreshMixin, Static):
+            def update_content(self, data):
+                self._data = data
+                self.throttled_refresh()
+    """
+
+    _throttle_interval: float = 0.05  # 50ms minimum between refreshes
+    _last_refresh: float = 0.0
+    _refresh_pending: bool = False
+    _refresh_timer: Optional[Timer] = None
+
+    def throttled_refresh(self) -> None:
+        """Request a throttled refresh."""
+        current = time.monotonic()
+        elapsed = current - self._last_refresh
+
+        if elapsed >= self._throttle_interval:
+            # Enough time has passed, refresh immediately
+            self._last_refresh = current
+            self.refresh()
+        elif not self._refresh_pending:
+            # Schedule a refresh for later
+            self._refresh_pending = True
+            remaining = self._throttle_interval - elapsed
+
+            # Use call_later if available (Textual widget)
+            if hasattr(self, "call_later"):
+                self.call_later(self._do_throttled_refresh, delay=remaining)
+
+    def _do_throttled_refresh(self) -> None:
+        """Execute the pending throttled refresh."""
+        self._refresh_pending = False
+        self._last_refresh = time.monotonic()
+        self.refresh()