shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/tui/components/context_indicator.py

@@ -0,0 +1,179 @@
+"""Context window indicator component for showing model usage."""
+
+from textual.reactive import reactive
+from textual.timer import Timer
+from textual.widgets import Static
+
+from shotgun.agents.config.models import MODEL_SPECS, ModelName
+from shotgun.agents.context_analyzer.models import ContextAnalysis
+
+
+class ContextIndicator(Static):
+    """Display context window usage and current model name."""
+
+    DEFAULT_CSS = """
+    ContextIndicator {
+        width: auto;
+        height: 1;
+        text-align: right;
+    }
+    """
+
+    context_analysis: reactive[ContextAnalysis | None] = reactive(None)
+    model_name: reactive[ModelName | None] = reactive(None)
+    is_streaming: reactive[bool] = reactive(False)
+
+    _animation_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    _animation_index = 0
+
+    def __init__(
+        self,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self._animation_timer: Timer | None = None
+
+    def update_context(
+        self, analysis: ContextAnalysis | None, model: ModelName | None
+    ) -> None:
+        """Update the context indicator with new analysis and model data.
+
+        Args:
+            analysis: Context analysis with token usage data
+            model: Current model name
+        """
+        self.context_analysis = analysis
+        self.model_name = model
+        self._refresh_display()
+
+    def set_streaming(self, streaming: bool) -> None:
+        """Enable or disable streaming animation.
+
+        Args:
+            streaming: Whether to show streaming animation
+        """
+        self.is_streaming = streaming
+        if streaming:
+            self._start_animation()
+        else:
+            self._stop_animation()
+
+    def _start_animation(self) -> None:
+        """Start the pulsing animation."""
+        if self._animation_timer is None:
+            self._animation_timer = self.set_interval(0.1, self._animate_frame)
+
+    def _stop_animation(self) -> None:
+        """Stop the pulsing animation."""
+        if self._animation_timer is not None:
+            self._animation_timer.stop()
+            self._animation_timer = None
+        self._animation_index = 0
+        self._refresh_display()
+
+    def _animate_frame(self) -> None:
+        """Advance the animation frame."""
+        self._animation_index = (self._animation_index + 1) % len(
+            self._animation_frames
+        )
+        self._refresh_display()
+
+    def _get_percentage_color(self, percentage: float) -> str:
+        """Get color for percentage based on threshold.
+
+        Args:
+            percentage: Usage percentage (0-100)
+
+        Returns:
+            Color name for Textual markup
+        """
+        if percentage < 60:
+            return "#00ff00"  # Green
+        elif percentage < 85:
+            return "#ffff00"  # Yellow
+        else:
+            return "#ff0000"  # Red
+
+    def _format_token_count(self, tokens: int) -> str:
+        """Format token count for display (e.g., 115000 -> "115K").
+
+        Args:
+            tokens: Token count
+
+        Returns:
+            Formatted string
+        """
+        if tokens >= 1_000_000:
+            return f"{tokens / 1_000_000:.1f}M"
+        elif tokens >= 1_000:
+            return f"{tokens / 1_000:.0f}K"
+        else:
+            return str(tokens)
+
+    def _refresh_display(self) -> None:
+        """Refresh the display with current context data."""
+        # If no analysis yet, show placeholder with model name or empty
+        if self.context_analysis is None:
+            if self.model_name:
+                model_spec = MODEL_SPECS.get(self.model_name)
+                model_display = (
+                    model_spec.short_name if model_spec else str(self.model_name)
+                )
+                self.update(f"[bold]{model_display}[/bold]")
+            else:
+                self.update("")
+            return
+
+        analysis = self.context_analysis
+
+        # Calculate percentage
+        if analysis.max_usable_tokens > 0:
+            percentage = round(
+                (analysis.agent_context_tokens / analysis.max_usable_tokens) * 100, 1
+            )
+        else:
+            percentage = 0.0
+
+        # Format token counts
+        current_tokens = self._format_token_count(analysis.agent_context_tokens)
+        max_tokens = self._format_token_count(analysis.max_usable_tokens)
+
+        # Get color based on percentage
+        color = self._get_percentage_color(percentage)
+
+        # Build the display string - always show full context info
+        parts = [
+            "[$foreground-muted]Context window:[/]",
+            f"[{color}]{percentage}% ({current_tokens}/{max_tokens})[/]",
+        ]
+
+        # Add streaming animation indicator if streaming
+        if self.is_streaming:
+            animation_char = self._animation_frames[self._animation_index]
+            parts.append(f"[bold cyan]{animation_char}[/]")
+
+        # Add model name if available
+        if self.model_name:
+            model_spec = MODEL_SPECS.get(self.model_name)
+            model_display = (
+                model_spec.short_name if model_spec else str(self.model_name)
+            )
+            parts.extend(
+                [
+                    "[$foreground-muted]|[/]",
+                    f"[bold]{model_display}[/bold]",
+                ]
+            )
+
+        self.update(" ".join(parts))
+
+    def watch_context_analysis(self, analysis: ContextAnalysis | None) -> None:
+        """React to context analysis changes."""
+        self._refresh_display()
+
+    def watch_model_name(self, model: ModelName | None) -> None:
+        """React to model name changes."""
+        self._refresh_display()

shotgun/tui/components/mode_indicator.py

@@ -0,0 +1,70 @@
+"""Widget to display the current agent mode."""
+
+from textual.widget import Widget
+
+from shotgun.agents.models import AgentType
+from shotgun.tui.protocols import QAStateProvider
+from shotgun.tui.utils.mode_progress import PlaceholderHints
+
+
+class ModeIndicator(Widget):
+    """Widget to display the current agent mode."""
+
+    DEFAULT_CSS = """
+        ModeIndicator {
+            text-wrap: wrap;
+            padding-left: 1;
+        }
+    """
+
+    def __init__(self, mode: AgentType) -> None:
+        """Initialize the mode indicator.
+
+        Args:
+            mode: The current agent type/mode.
+        """
+        super().__init__()
+        self.mode = mode
+        self.progress_checker = PlaceholderHints().progress_checker
+
+    def render(self) -> str:
+        """Render the mode indicator."""
+        # Check if in Q&A mode first
+        if isinstance(self.screen, QAStateProvider) and self.screen.qa_mode:
+            return (
+                "[bold $text-accent]Q&A mode[/]"
+                "[$foreground-muted] (Answer the clarifying questions or ESC to cancel)[/]"
+            )
+
+        mode_display = {
+            AgentType.RESEARCH: "Research",
+            AgentType.PLAN: "Planning",
+            AgentType.TASKS: "Tasks",
+            AgentType.SPECIFY: "Specify",
+            AgentType.EXPORT: "Export",
+        }
+        mode_description = {
+            AgentType.RESEARCH: (
+                "Research topics with web search and synthesize findings"
+            ),
+            AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
+            AgentType.TASKS: (
+                "Generate specific, actionable tasks from research and plans"
+            ),
+            AgentType.SPECIFY: (
+                "Create detailed specifications and requirements documents"
+            ),
+            AgentType.EXPORT: "Export artifacts and findings to various formats",
+        }
+
+        mode_title = mode_display.get(self.mode, self.mode.value.title())
+        description = mode_description.get(self.mode, "")
+
+        # Check if mode has content
+        has_content = self.progress_checker.has_mode_content(self.mode)
+        status_icon = " ✓" if has_content else ""
+
+        return (
+            f"[bold $text-accent]{mode_title}{status_icon} mode[/]"
+            f"[$foreground-muted] ({description})[/]"
+        )

shotgun/tui/components/status_bar.py

@@ -0,0 +1,48 @@
+"""Widget to display the status bar with contextual help text."""
+
+from textual.widget import Widget
+
+from shotgun.tui.protocols import QAStateProvider
+
+
+class StatusBar(Widget):
+    """Widget to display the status bar with contextual help text."""
+
+    DEFAULT_CSS = """
+        StatusBar {
+            text-wrap: wrap;
+            padding-left: 1;
+        }
+    """
+
+    def __init__(self, working: bool = False) -> None:
+        """Initialize the status bar.
+
+        Args:
+            working: Whether an agent is currently working.
+        """
+        super().__init__()
+        self.working = working
+
+    def render(self) -> str:
+        """Render the status bar with contextual help text."""
+        # Check if in Q&A mode first (highest priority)
+        if isinstance(self.screen, QAStateProvider) and self.screen.qa_mode:
+            return (
+                "[$foreground-muted][bold $text]esc[/] to exit Q&A mode • "
+                "[bold $text]enter[/] to send answer • [bold $text]ctrl+j[/] for newline[/]"
+            )
+
+        if self.working:
+            return (
+                "[$foreground-muted][bold $text]esc[/] to stop • "
+                "[bold $text]enter[/] to send • [bold $text]ctrl+j[/] for newline • "
+                "[bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • "
+                "/help for commands[/]"
+            )
+        else:
+            return (
+                "[$foreground-muted][bold $text]enter[/] to send • "
+                "[bold $text]ctrl+j[/] for newline • [bold $text]ctrl+p[/] command palette • "
+                "[bold $text]shift+tab[/] cycle modes • /help for commands[/]"
+            )

shotgun/tui/containers.py

@@ -0,0 +1,91 @@
+"""Dependency injection container for TUI components."""
+
+from typing import TYPE_CHECKING
+
+from dependency_injector import containers, providers
+from pydantic_ai import RunContext
+
+from shotgun.agents.conversation import ConversationManager
+from shotgun.agents.models import AgentDeps
+from shotgun.sdk.codebase import CodebaseSDK
+from shotgun.tui.commands import CommandHandler
+from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
+from shotgun.tui.services.conversation_service import ConversationService
+from shotgun.tui.state.processing_state import ProcessingStateManager
+from shotgun.tui.utils.mode_progress import PlaceholderHints
+from shotgun.tui.widgets.widget_coordinator import WidgetCoordinator
+from shotgun.utils import get_shotgun_home
+
+if TYPE_CHECKING:
+    pass
+
+
+# Placeholder system prompt function (agents provide their own)
+# Using Object provider to pass the function itself, not call it
+def _placeholder_system_prompt(ctx: "RunContext[AgentDeps]") -> str:
+    raise RuntimeError(
+        "This should not be called - agents provide their own system_prompt_fn"
+    )
+
+
+class TUIContainer(containers.DeclarativeContainer):
+    """Dependency injection container for TUI components.
+
+    This container manages the lifecycle and dependencies of all TUI components,
+    ensuring consistent configuration and facilitating testing.
+
+    Note: model_config and agent_deps are created lazily via async factory methods
+    since get_provider_model() is now async.
+    """
+
+    # Configuration
+    config = providers.Configuration()
+
+    # Core dependencies
+    # TODO: Figure out a better solution for async dependency injection
+    # model_config is now loaded lazily via create_default_tui_deps()
+    # because get_provider_model() is async. This breaks the DI pattern
+    # and should be refactored to support async factories properly.
+
+    storage_dir = providers.Singleton(lambda: get_shotgun_home() / "codebases")
+
+    codebase_service = providers.Singleton(
+        FilteredCodebaseService, storage_dir=storage_dir
+    )
+
+    system_prompt_fn = providers.Object(_placeholder_system_prompt)
+
+    # TODO: Figure out a better solution for async dependency injection
+    # AgentDeps is now created via async create_default_tui_deps()
+    # instead of using DI container's Singleton provider because it requires
+    # async model_config initialization
+
+    # Service singletons
+    codebase_sdk = providers.Singleton(CodebaseSDK)
+
+    command_handler = providers.Singleton(CommandHandler)
+
+    placeholder_hints = providers.Singleton(PlaceholderHints)
+
+    conversation_manager = providers.Singleton(ConversationManager)
+
+    conversation_service = providers.Factory(
+        ConversationService, conversation_manager=conversation_manager
+    )
+
+    # TODO: Figure out a better solution for async dependency injection
+    # AgentManager factory removed - create via async initialization
+    # since it requires async agent creation
+
+    # Factory for ProcessingStateManager (needs ChatScreen reference)
+    processing_state_factory = providers.Factory(
+        ProcessingStateManager,
+        screen=providers.Object(None),  # Will be overridden when creating ChatScreen
+        telemetry_context=providers.Object({}),  # Will be overridden when creating
+    )
+
+    # Factory for WidgetCoordinator (needs ChatScreen reference)
+    widget_coordinator_factory = providers.Factory(
+        WidgetCoordinator,
+        screen=providers.Object(None),  # Will be overridden when creating ChatScreen
+    )

shotgun/tui/dependencies.py

@@ -0,0 +1,39 @@
+"""Dependency creation utilities for TUI components."""
+
+from pydantic_ai import RunContext
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.models import AgentDeps
+from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
+from shotgun.utils import get_shotgun_home
+
+
+async def create_default_tui_deps() -> AgentDeps:
+    """Create default AgentDeps for TUI components.
+
+    This creates a standard AgentDeps configuration suitable for interactive
+    TUI usage with:
+    - Interactive mode enabled
+    - TUI context flag set
+    - Filtered codebase service (restricted to CWD)
+    - Placeholder system prompt (agents provide their own)
+
+    Returns:
+        Configured AgentDeps instance ready for TUI use.
+    """
+    model_config = await get_provider_model()
+    storage_dir = get_shotgun_home() / "codebases"
+    codebase_service = FilteredCodebaseService(storage_dir)
+
+    def _placeholder_system_prompt_fn(ctx: RunContext[AgentDeps]) -> str:
+        raise RuntimeError(
+            "This should not be called - agents provide their own system_prompt_fn"
+        )
+
+    return AgentDeps(
+        interactive_mode=True,
+        is_tui_context=True,
+        llm_model=model_config,
+        codebase_service=codebase_service,
+        system_prompt_fn=_placeholder_system_prompt_fn,
+    )

shotgun/tui/layout.py

@@ -0,0 +1,5 @@
+"""Layout utilities for responsive terminal UI."""
+
+# Height thresholds for responsive layouts
+TINY_HEIGHT_THRESHOLD = 25  # Below this: minimal UI, hide most content
+COMPACT_HEIGHT_THRESHOLD = 35  # Below this: reduced padding, hide verbose text

shotgun/tui/protocols.py

@@ -0,0 +1,45 @@
+"""Protocol definitions for TUI components.
+
+These protocols define interfaces that components can depend on without
+creating circular imports. Screens like ChatScreen can satisfy these
+protocols without explicitly implementing them.
+"""
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class QAStateProvider(Protocol):
+    """Protocol for screens that provide Q&A mode state.
+
+    This protocol allows components to check if they're on a screen with
+    Q&A mode without importing the concrete ChatScreen class, eliminating
+    circular dependencies.
+    """
+
+    @property
+    def qa_mode(self) -> bool:
+        """Whether Q&A mode is currently active.
+
+        Returns:
+            True if Q&A mode is active, False otherwise.
+        """
+        ...
+
+
+@runtime_checkable
+class ProcessingStateProvider(Protocol):
+    """Protocol for screens that provide processing state.
+
+    This protocol allows components to check if they're on a screen with
+    an active agent processing without importing the concrete ChatScreen class.
+    """
+
+    @property
+    def working(self) -> bool:
+        """Whether an agent is currently working.
+
+        Returns:
+            True if an agent is processing, False otherwise.
+        """
+        ...

shotgun/tui/screens/chat/__init__.py

@@ -0,0 +1,5 @@
+"""Chat screen module."""
+
+from shotgun.tui.screens.chat.chat_screen import ChatScreen
+
+__all__ = ["ChatScreen"]

shotgun/tui/screens/chat/chat.tcss

@@ -0,0 +1,54 @@
+ChatHistory {
+  height: auto;
+}
+
+PromptInput {
+  min-height: 3;
+  max-height: 7;
+  height: auto;
+}
+
+StatusBar {
+  height: auto;
+}
+
+ModeIndicator {
+  height: auto;
+}
+
+#footer {
+  dock: bottom;
+  height: auto;
+  padding: 1 1 1 2;
+  max-height: 14;
+}
+
+#window {
+  align: left bottom;
+}
+
+.hidden {
+  display: none;
+}
+
+#footer > Grid {
+  height: auto;
+  grid-columns: 1fr auto;
+  grid-size: 2;
+}
+
+
+#right-footer-indicators {
+  width: auto;
+  height: auto;
+  layout: vertical;
+}
+
+#context-indicator {
+  text-align: end;
+  height: 1;
+}
+
+#indexing-job-display {
+  text-align: end;
+}