shotgun-sh 0.1.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

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_manager 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/filtered_codebase_service.py

@@ -0,0 +1,46 @@
+"""Filtered codebase service that restricts access to current directory's codebase only."""
+
+from pathlib import Path
+
+from shotgun.codebase.models import CodebaseGraph
+from shotgun.codebase.service import CodebaseService
+
+
+class FilteredCodebaseService(CodebaseService):
+    """CodebaseService subclass that filters graphs to only those accessible from CWD.
+
+    This ensures TUI agents can only see and access the codebase indexed from the
+    current working directory, providing isolation between different project directories.
+    """
+
+    def __init__(self, storage_dir: Path | str):
+        """Initialize the filtered service.
+
+        Args:
+            storage_dir: Directory to store graph databases
+        """
+        super().__init__(storage_dir)
+        self._cwd = str(Path.cwd().resolve())
+
+    async def list_graphs(self) -> list[CodebaseGraph]:
+        """List only graphs accessible from the current working directory.
+
+        Returns:
+            Filtered list of CodebaseGraph objects accessible from CWD
+        """
+        # Use the existing filtering logic from list_graphs_for_directory
+        return await super().list_graphs_for_directory(self._cwd)
+
+    async def list_graphs_for_directory(
+        self, directory: Path | str | None = None
+    ) -> list[CodebaseGraph]:
+        """List graphs for directory - always filters to CWD for TUI context.
+
+        Args:
+            directory: Ignored in TUI context, always uses CWD
+
+        Returns:
+            Filtered list of CodebaseGraph objects accessible from CWD
+        """
+        # Always use CWD regardless of what directory is passed
+        return await super().list_graphs_for_directory(self._cwd)

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;
+}