shotgun-sh 0.1.16.dev2__py3-none-any.whl → 0.2.1__py3-none-any.whl

shotgun/shotgun_web/client.py

@@ -0,0 +1,138 @@
+"""HTTP client for Shotgun Web API."""
+
+import httpx
+
+from shotgun.logging_config import get_logger
+
+from .constants import (
+    SHOTGUN_WEB_BASE_URL,
+    UNIFICATION_TOKEN_CREATE_PATH,
+    UNIFICATION_TOKEN_STATUS_PATH,
+)
+from .models import (
+    TokenCreateRequest,
+    TokenCreateResponse,
+    TokenStatusResponse,
+)
+
+logger = get_logger(__name__)
+
+
+class ShotgunWebClient:
+    """HTTP client for Shotgun Web API."""
+
+    def __init__(self, base_url: str | None = None, timeout: float = 10.0):
+        """Initialize Shotgun Web client.
+
+        Args:
+            base_url: Base URL for Shotgun Web API. If None, uses SHOTGUN_WEB_BASE_URL
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url or SHOTGUN_WEB_BASE_URL
+        self.timeout = timeout
+
+    def create_unification_token(self, shotgun_instance_id: str) -> TokenCreateResponse:
+        """Create a unification token for CLI authentication.
+
+        Args:
+            shotgun_instance_id: UUID for this shotgun instance
+
+        Returns:
+            Token creation response with token and auth URL
+
+        Raises:
+            httpx.HTTPError: If request fails
+        """
+        url = f"{self.base_url}{UNIFICATION_TOKEN_CREATE_PATH}"
+        request_data = TokenCreateRequest(shotgun_instance_id=shotgun_instance_id)
+
+        logger.debug("Creating unification token for instance %s", shotgun_instance_id)
+
+        try:
+            response = httpx.post(
+                url,
+                json=request_data.model_dump(),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            result = TokenCreateResponse.model_validate(data)
+
+            logger.info(
+                "Successfully created unification token, expires in %d seconds",
+                result.expires_in_seconds,
+            )
+            return result
+
+        except httpx.HTTPError as e:
+            logger.error("Failed to create unification token: %s", e)
+            raise
+
+    def check_token_status(self, token: str) -> TokenStatusResponse:
+        """Check token status and get keys if completed.
+
+        Args:
+            token: Unification token to check
+
+        Returns:
+            Token status response with status and keys (if completed)
+
+        Raises:
+            httpx.HTTPStatusError: If token not found (404) or expired (410)
+            httpx.HTTPError: For other request failures
+        """
+        url = f"{self.base_url}{UNIFICATION_TOKEN_STATUS_PATH.format(token=token)}"
+
+        logger.debug("Checking status for token %s...", token[:8])
+
+        try:
+            response = httpx.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            data = response.json()
+            result = TokenStatusResponse.model_validate(data)
+
+            logger.debug("Token status: %s", result.status)
+            return result
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                logger.error("Token not found: %s", token[:8])
+            elif e.response.status_code == 410:
+                logger.error("Token expired: %s", token[:8])
+            raise
+        except httpx.HTTPError as e:
+            logger.error("Failed to check token status: %s", e)
+            raise
+
+
+# Convenience functions for standalone use
+def create_unification_token(shotgun_instance_id: str) -> TokenCreateResponse:
+    """Create a unification token.
+
+    Convenience function that creates a client and calls create_unification_token.
+
+    Args:
+        shotgun_instance_id: UUID for this shotgun instance
+
+    Returns:
+        Token creation response
+    """
+    client = ShotgunWebClient()
+    return client.create_unification_token(shotgun_instance_id)
+
+
+def check_token_status(token: str) -> TokenStatusResponse:
+    """Check token status.
+
+    Convenience function that creates a client and calls check_token_status.
+
+    Args:
+        token: Unification token to check
+
+    Returns:
+        Token status response
+    """
+    client = ShotgunWebClient()
+    return client.check_token_status(token)

shotgun/shotgun_web/constants.py

@@ -0,0 +1,17 @@
+"""Constants for Shotgun Web API."""
+
+import os
+
+# Shotgun Web API base URL
+# Default to production URL, can be overridden with environment variable
+SHOTGUN_WEB_BASE_URL = os.environ.get(
+    "SHOTGUN_WEB_BASE_URL", "https://api-701197220809.us-east1.run.app"
+)
+
+# API endpoints
+UNIFICATION_TOKEN_CREATE_PATH = "/api/unification/token/create"  # noqa: S105
+UNIFICATION_TOKEN_STATUS_PATH = "/api/unification/token/{token}/status"  # noqa: S105
+
+# Polling configuration
+DEFAULT_POLL_INTERVAL_SECONDS = 3
+DEFAULT_TOKEN_TIMEOUT_SECONDS = 1800  # 30 minutes

shotgun/shotgun_web/models.py

@@ -0,0 +1,47 @@
+"""Pydantic models for Shotgun Web API."""
+
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class TokenStatus(StrEnum):
+    """Token status enum matching API specification."""
+
+    PENDING = "pending"
+    COMPLETED = "completed"
+    AWAITING_PAYMENT = "awaiting_payment"
+    EXPIRED = "expired"
+
+
+class TokenCreateRequest(BaseModel):
+    """Request model for creating a unification token."""
+
+    shotgun_instance_id: str = Field(
+        description="CLI-provided UUID for shotgun instance"
+    )
+
+
+class TokenCreateResponse(BaseModel):
+    """Response model for token creation."""
+
+    token: str = Field(description="Secure authentication token")
+    auth_url: str = Field(description="Web authentication URL for user to complete")
+    expires_in_seconds: int = Field(description="Token expiration time in seconds")
+
+
+class TokenStatusResponse(BaseModel):
+    """Response model for token status check."""
+
+    status: TokenStatus = Field(description="Current token status")
+    supabase_key: str | None = Field(
+        default=None,
+        description="Supabase user JWT (only returned when status=completed)",
+    )
+    litellm_key: str | None = Field(
+        default=None,
+        description="LiteLLM virtual key (only returned when status=completed)",
+    )
+    message: str | None = Field(
+        default=None, description="Human-readable status message"
+    )

shotgun/telemetry.py

@@ -72,12 +72,15 @@ def setup_logfire_observability() -> bool:
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
+            shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
-            # Set user_id as baggage in global context - this will be included in all logs/spans
-            ctx = baggage.set_baggage("user_id", user_id)
+            # Set shotgun_instance_id as baggage in global context - this will be included in all logs/spans
+            ctx = baggage.set_baggage("shotgun_instance_id", shotgun_instance_id)
             context.attach(ctx)
-            logger.debug("Logfire user context set with user_id: %s", user_id)
+            logger.debug(
+                "Logfire user context set with shotgun_instance_id: %s",
+                shotgun_instance_id,
+            )
         except Exception as e:
             logger.warning("Failed to set Logfire user context: %s", e)
 

shotgun/tui/app.py

@@ -8,13 +8,16 @@ from textual.screen import Screen
 from shotgun.agents.config import ConfigManager, get_config_manager
 from shotgun.logging_config import get_logger
 from shotgun.tui.screens.splash import SplashScreen
+from shotgun.utils.env_utils import is_shotgun_account_enabled
 from shotgun.utils.file_system_utils import get_shotgun_base_path
 from shotgun.utils.update_checker import perform_auto_update_async
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
 from .screens.feedback import FeedbackScreen
+from .screens.model_picker import ModelPickerScreen
 from .screens.provider_config import ProviderConfigScreen
+from .screens.welcome import WelcomeScreen
 
 logger = get_logger(__name__)
 
@@ -23,6 +26,7 @@ class ShotgunApp(App[None]):
     SCREENS = {
         "chat": ChatScreen,
         "provider_config": ProviderConfigScreen,
+        "model_picker": ModelPickerScreen,
         "directory_setup": DirectorySetupScreen,
         "feedback": FeedbackScreen,
     }
@@ -58,20 +62,34 @@ class ShotgunApp(App[None]):
     def refresh_startup_screen(self) -> None:
         """Push the appropriate screen based on configured providers."""
         if not self.config_manager.has_any_provider_key():
-            if isinstance(self.screen, ProviderConfigScreen):
+            # If Shotgun Account is enabled, show welcome screen with choice
+            # Otherwise, go directly to provider config (BYOK only)
+            if is_shotgun_account_enabled():
+                if isinstance(self.screen, WelcomeScreen):
+                    return
+
+                self.push_screen(
+                    WelcomeScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
+                return
+            else:
+                if isinstance(self.screen, ProviderConfigScreen):
+                    return
+
+                self.push_screen(
+                    ProviderConfigScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
                 return
-
-            self.push_screen(
-                "provider_config", callback=lambda _arg: self.refresh_startup_screen()
-            )
-            return
 
         if not self.check_local_shotgun_directory_exists():
             if isinstance(self.screen, DirectorySetupScreen):
                 return
 
             self.push_screen(
-                "directory_setup", callback=lambda _arg: self.refresh_startup_screen()
+                DirectorySetupScreen(),
+                callback=lambda _arg: self.refresh_startup_screen(),
             )
             return
 
@@ -108,7 +126,7 @@ class ShotgunApp(App[None]):
                 submit_feedback_survey(feedback)
                 self.notify("Feedback sent. Thank you!")
 
-        self.push_screen("feedback", callback=handle_feedback)
+        self.push_screen(FeedbackScreen(), callback=handle_feedback)
 
 
 def run(no_update_check: bool = False, continue_session: bool = False) -> None:

shotgun/tui/screens/chat.py

@@ -54,11 +54,8 @@ from ..components.prompt_input import PromptInput
 from ..components.spinner import Spinner
 from ..utils.mode_progress import PlaceholderHints
 from .chat_screen.command_providers import (
-    AgentModeProvider,
-    CodebaseCommandProvider,
     DeleteCodebasePaletteProvider,
-    ProviderSetupProvider,
-    UsageProvider,
+    UnifiedCommandProvider,
 )
 
 logger = logging.getLogger(__name__)
@@ -233,10 +230,7 @@ class ChatScreen(Screen[None]):
     ]
 
     COMMANDS = {
-        AgentModeProvider,
-        ProviderSetupProvider,
-        CodebaseCommandProvider,
-        UsageProvider,
+        UnifiedCommandProvider,
     }
 
     value = reactive("")

shotgun/tui/screens/chat_screen/command_providers.py

@@ -5,6 +5,8 @@ from textual.command import DiscoveryHit, Hit, Provider
 
 from shotgun.agents.models import AgentType
 from shotgun.codebase.models import CodebaseGraph
+from shotgun.tui.screens.model_picker import ModelPickerScreen
+from shotgun.tui.screens.provider_config import ProviderConfigScreen
 
 if TYPE_CHECKING:
     from shotgun.tui.screens.chat import ChatScreen
@@ -139,7 +141,11 @@ class ProviderSetupProvider(Provider):
 
     def open_provider_config(self) -> None:
         """Show the provider configuration screen."""
-        self.chat_screen.app.push_screen("provider_config")
+        self.chat_screen.app.push_screen(ProviderConfigScreen())
+
+    def open_model_picker(self) -> None:
+        """Show the model picker screen."""
+        self.chat_screen.app.push_screen(ModelPickerScreen())
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
         yield DiscoveryHit(
@@ -147,9 +153,15 @@ class ProviderSetupProvider(Provider):
             self.open_provider_config,
             help="⚙️ Manage API keys for available providers",
         )
+        yield DiscoveryHit(
+            "Select AI Model",
+            self.open_model_picker,
+            help="🤖 Choose which AI model to use",
+        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         matcher = self.matcher(query)
+
         title = "Open Provider Setup"
         score = matcher.match(title)
         if score > 0:
@@ -160,6 +172,16 @@ class ProviderSetupProvider(Provider):
                 help="⚙️ Manage API keys for available providers",
             )
 
+        title = "Select AI Model"
+        score = matcher.match(title)
+        if score > 0:
+            yield Hit(
+                score,
+                matcher.highlight(title),
+                self.open_model_picker,
+                help="🤖 Choose which AI model to use",
+            )
+
 
 class CodebaseCommandProvider(Provider):
     """Command palette entries for codebase management."""
@@ -171,30 +193,30 @@ class CodebaseCommandProvider(Provider):
         return cast(ChatScreen, self.screen)
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
-        yield DiscoveryHit(
-            "Codebase: Index Codebase",
-            self.chat_screen.index_codebase_command,
-            help="Index a repository into the codebase graph",
-        )
         yield DiscoveryHit(
             "Codebase: Delete Codebase Index",
             self.chat_screen.delete_codebase_command,
             help="Delete an existing codebase index",
         )
+        yield DiscoveryHit(
+            "Codebase: Index Codebase",
+            self.chat_screen.index_codebase_command,
+            help="Index a repository into the codebase graph",
+        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         matcher = self.matcher(query)
         commands = [
-            (
-                "Codebase: Index Codebase",
-                self.chat_screen.index_codebase_command,
-                "Index a repository into the codebase graph",
-            ),
             (
                 "Codebase: Delete Codebase Index",
                 self.chat_screen.delete_codebase_command,
                 "Delete an existing codebase index",
             ),
+            (
+                "Codebase: Index Codebase",
+                self.chat_screen.index_codebase_command,
+                "Index a repository into the codebase graph",
+            ),
         ]
         for title, callback, help_text in commands:
             score = matcher.match(title)
@@ -249,3 +271,88 @@ class DeleteCodebasePaletteProvider(Provider):
                     ),
                     help=graph.repo_path,
                 )
+
+
+class UnifiedCommandProvider(Provider):
+    """Unified command provider with all commands in alphabetical order."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    def open_provider_config(self) -> None:
+        """Show the provider configuration screen."""
+        self.chat_screen.app.push_screen(ProviderConfigScreen())
+
+    def open_model_picker(self) -> None:
+        """Show the model picker screen."""
+        self.chat_screen.app.push_screen(ModelPickerScreen())
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        """Provide commands in alphabetical order when palette opens."""
+        # Alphabetically ordered commands
+        yield DiscoveryHit(
+            "Codebase: Delete Codebase Index",
+            self.chat_screen.delete_codebase_command,
+            help="Delete an existing codebase index",
+        )
+        yield DiscoveryHit(
+            "Codebase: Index Codebase",
+            self.chat_screen.index_codebase_command,
+            help="Index a repository into the codebase graph",
+        )
+        yield DiscoveryHit(
+            "Open Provider Setup",
+            self.open_provider_config,
+            help="⚙️ Manage API keys for available providers",
+        )
+        yield DiscoveryHit(
+            "Select AI Model",
+            self.open_model_picker,
+            help="🤖 Choose which AI model to use",
+        )
+        yield DiscoveryHit(
+            "Show usage",
+            self.chat_screen.action_show_usage,
+            help="Display usage information for the current session",
+        )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        """Search for commands in alphabetical order."""
+        matcher = self.matcher(query)
+
+        # Define all commands in alphabetical order
+        commands = [
+            (
+                "Codebase: Delete Codebase Index",
+                self.chat_screen.delete_codebase_command,
+                "Delete an existing codebase index",
+            ),
+            (
+                "Codebase: Index Codebase",
+                self.chat_screen.index_codebase_command,
+                "Index a repository into the codebase graph",
+            ),
+            (
+                "Open Provider Setup",
+                self.open_provider_config,
+                "⚙️ Manage API keys for available providers",
+            ),
+            (
+                "Select AI Model",
+                self.open_model_picker,
+                "🤖 Choose which AI model to use",
+            ),
+            (
+                "Show usage",
+                self.chat_screen.action_show_usage,
+                "Display usage information for the current session",
+            ),
+        ]
+
+        for title, callback, help_text in commands:
+            score = matcher.match(title)
+            if score > 0:
+                yield Hit(score, matcher.highlight(title), callback, help=help_text)

shotgun/tui/screens/chat_screen/history.py

@@ -217,7 +217,9 @@ class AgentResponseWidget(Widget):
             return ""
         for idx, part in enumerate(self.item.parts):
             if isinstance(part, TextPart):
-                acc += f"**⏺** {part.content}\n\n"
+                # Only show the circle prefix if there's actual content
+                if part.content and part.content.strip():
+                    acc += f"**⏺** {part.content}\n\n"
             elif isinstance(part, ToolCallPart):
                 parts_str = self._format_tool_call_part(part)
                 acc += parts_str + "\n\n"

shotgun/tui/screens/feedback.py

@@ -182,12 +182,12 @@ class FeedbackScreen(Screen[Feedback | None]):
             return
 
         app = cast("ShotgunApp", self.app)
-        user_id = app.config_manager.get_user_id()
+        shotgun_instance_id = app.config_manager.get_shotgun_instance_id()
 
         feedback = Feedback(
             kind=self.selected_kind,
             description=description,
-            user_id=user_id,
+            shotgun_instance_id=shotgun_instance_id,
         )
 
         self.dismiss(feedback)