shotgun-sh 0.2.23.dev1__py3-none-any.whl → 0.2.29.dev2__py3-none-any.whl

shotgun/shotgun_web/supabase_client.py

@@ -0,0 +1,31 @@
+"""Supabase Storage download utilities."""
+
+import httpx
+
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+async def download_file_from_url(download_url: str) -> bytes:
+    """Download a file from a presigned Supabase Storage URL.
+
+    The API returns presigned URLs with embedded tokens that don't require
+    any authentication headers.
+
+    Args:
+        download_url: Presigned Supabase Storage URL
+                     (e.g., "https://...supabase.co/storage/v1/object/sign/...?token=...")
+
+    Returns:
+        File contents as bytes
+
+    Raises:
+        httpx.HTTPStatusError: If download fails
+    """
+    logger.debug("Downloading file from: %s", download_url)
+
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.get(download_url)
+        response.raise_for_status()
+        return response.content

shotgun/tui/app.py

@@ -54,12 +54,16 @@ class ShotgunApp(App[None]):
         no_update_check: bool = False,
         continue_session: bool = False,
         force_reindex: bool = False,
+        show_pull_hint: bool = False,
+        pull_version_id: str | None = None,
     ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
         self.no_update_check = no_update_check
         self.continue_session = continue_session
         self.force_reindex = force_reindex
+        self.show_pull_hint = show_pull_hint
+        self.pull_version_id = pull_version_id
 
         # Initialize dependency injection container
         self.container = TUIContainer()
@@ -77,6 +81,8 @@ class ShotgunApp(App[None]):
             "tui_started",
             {
                 "installation_method": detect_installation_method(),
+                "terminal_width": self.size.width,
+                "terminal_height": self.size.height,
             },
         )
 
@@ -149,6 +155,16 @@ class ShotgunApp(App[None]):
             if isinstance(self.screen, ChatScreen):
                 return
 
+            # If we have a version to pull, show pull screen first
+            if self.pull_version_id:
+                from .screens.spec_pull import SpecPullScreen
+
+                self.push_screen(
+                    SpecPullScreen(self.pull_version_id),
+                    callback=self._handle_pull_complete,
+                )
+                return
+
             # Create ChatScreen with all dependencies injected from container
             # Get the default agent mode (RESEARCH)
             agent_mode = AgentType.RESEARCH
@@ -180,6 +196,7 @@ class ShotgunApp(App[None]):
                 deps=agent_deps,
                 continue_session=self.continue_session,
                 force_reindex=self.force_reindex,
+                show_pull_hint=self.show_pull_hint,
             )
 
             # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
@@ -195,6 +212,22 @@ class ShotgunApp(App[None]):
         shotgun_dir = get_shotgun_base_path()
         return shotgun_dir.exists() and shotgun_dir.is_dir()
 
+    def _handle_pull_complete(self, success: bool | None) -> None:
+        """Handle completion of spec pull screen.
+
+        Args:
+            success: Whether the pull was successful, or None if dismissed.
+        """
+        # Clear version_id so we don't pull again on next refresh
+        self.pull_version_id = None
+
+        if success:
+            # Enable hint for ChatScreen
+            self.show_pull_hint = True
+
+        # Continue to ChatScreen
+        self.refresh_startup_screen()
+
     async def action_quit(self) -> None:
         """Quit the application."""
         # Shut down PostHog client to prevent threading errors
@@ -221,6 +254,8 @@ def run(
     no_update_check: bool = False,
     continue_session: bool = False,
     force_reindex: bool = False,
+    show_pull_hint: bool = False,
+    pull_version_id: str | None = None,
 ) -> None:
     """Run the TUI application.
 
@@ -228,6 +263,8 @@ def run(
         no_update_check: If True, disable automatic update checks.
         continue_session: If True, continue from previous conversation.
         force_reindex: If True, force re-indexing of codebase (ignores existing index).
+        show_pull_hint: If True, show hint about recently pulled spec.
+        pull_version_id: If provided, pull this spec version before showing ChatScreen.
     """
     # Clean up any corrupted databases BEFORE starting the TUI
     # This prevents crashes from corrupted databases during initialization
@@ -253,6 +290,8 @@ def run(
         no_update_check=no_update_check,
         continue_session=continue_session,
         force_reindex=force_reindex,
+        show_pull_hint=show_pull_hint,
+        pull_version_id=pull_version_id,
     )
     app.run(inline_no_clear=True)
 

shotgun/tui/containers.py

@@ -5,7 +5,7 @@ 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.conversation import ConversationManager
 from shotgun.agents.models import AgentDeps
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.tui.commands import CommandHandler

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/screens/chat/chat_screen.py

@@ -36,9 +36,11 @@ from shotgun.agents.agent_manager import (
 )
 from shotgun.agents.config import get_config_manager
 from shotgun.agents.config.models import MODEL_SPECS
-from shotgun.agents.conversation_manager import ConversationManager
-from shotgun.agents.history.compaction import apply_persistent_compaction
-from shotgun.agents.history.token_estimation import estimate_tokens_from_messages
+from shotgun.agents.conversation import ConversationManager
+from shotgun.agents.conversation.history.compaction import apply_persistent_compaction
+from shotgun.agents.conversation.history.token_estimation import (
+    estimate_tokens_from_messages,
+)
 from shotgun.agents.models import (
     AgentDeps,
     AgentType,
@@ -83,16 +85,50 @@ from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.tui.screens.chat_screen.history import ChatHistory
 from shotgun.tui.screens.confirmation_dialog import ConfirmationDialog
 from shotgun.tui.screens.onboarding import OnboardingModal
+from shotgun.tui.screens.shared_specs import (
+    CreateSpecDialog,
+    ShareSpecsAction,
+    ShareSpecsDialog,
+    UploadProgressScreen,
+)
 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
+from shotgun.utils.file_system_utils import get_shotgun_base_path
 from shotgun.utils.marketing import MarketingManager
 
 logger = logging.getLogger(__name__)
 
 
+def _format_duration(seconds: float) -> str:
+    """Format duration in natural language."""
+    if seconds < 60:
+        return f"{int(seconds)} seconds"
+    minutes = int(seconds // 60)
+    secs = int(seconds % 60)
+    if secs == 0:
+        return f"{minutes} minute{'s' if minutes != 1 else ''}"
+    return f"{minutes} minute{'s' if minutes != 1 else ''} {secs} seconds"
+
+
+def _format_count(count: int) -> str:
+    """Format count in natural language (e.g., '5 thousand')."""
+    if count < 1000:
+        return str(count)
+    elif count < 1_000_000:
+        thousands = count / 1000
+        if thousands == int(thousands):
+            return f"{int(thousands)} thousand"
+        return f"{thousands:.1f} thousand"
+    else:
+        millions = count / 1_000_000
+        if millions == int(millions):
+            return f"{int(millions)} million"
+        return f"{millions:.1f} million"
+
+
 class ChatScreen(Screen[None]):
     CSS_PATH = "chat.tcss"
 
@@ -138,6 +174,7 @@ class ChatScreen(Screen[None]):
         deps: AgentDeps,
         continue_session: bool = False,
         force_reindex: bool = False,
+        show_pull_hint: bool = False,
     ) -> None:
         """Initialize the ChatScreen.
 
@@ -156,6 +193,7 @@ class ChatScreen(Screen[None]):
             deps: AgentDeps configuration for agent dependencies
             continue_session: Whether to continue a previous session
             force_reindex: Whether to force reindexing of codebases
+            show_pull_hint: Whether to show hint about recently pulled spec
         """
         super().__init__()
 
@@ -171,6 +209,7 @@ class ChatScreen(Screen[None]):
         self.processing_state = processing_state
         self.continue_session = continue_session
         self.force_reindex = force_reindex
+        self.show_pull_hint = show_pull_hint
 
     def on_mount(self) -> None:
         # Use widget coordinator to focus input
@@ -186,6 +225,10 @@ class ChatScreen(Screen[None]):
         if self.continue_session:
             self.call_later(self._check_and_load_conversation)
 
+        # Show pull hint if launching after spec pull
+        if self.show_pull_hint:
+            self.call_later(self._show_pull_hint)
+
         self.call_later(self.check_if_codebase_is_indexed)
         # Initial update of context indicator
         self.update_context_indicator()
@@ -655,6 +698,38 @@ class ChatScreen(Screen[None]):
         hint = HintMessage(message=markdown)
         self.agent_manager.add_hint_message(hint)
 
+    def _show_pull_hint(self) -> None:
+        """Show hint about recently pulled spec from meta.json."""
+        # Import at runtime to avoid circular import (CLI -> TUI dependency)
+        from shotgun.cli.spec.models import SpecMeta
+
+        shotgun_dir = get_shotgun_base_path()
+        meta_path = shotgun_dir / "meta.json"
+        if not meta_path.exists():
+            return
+
+        try:
+            meta: SpecMeta = SpecMeta.model_validate_json(meta_path.read_text())
+            # Only show if pulled within last 60 seconds
+            age_seconds = (datetime.now(timezone.utc) - meta.pulled_at).total_seconds()
+            if age_seconds > 60:
+                return
+
+            hint_parts = [f"You just pulled **{meta.spec_name}** from the cloud."]
+            if meta.web_url:
+                hint_parts.append(f"[View in browser]({meta.web_url})")
+            hint_parts.append(
+                f"The specs are now located at `{shotgun_dir}` so Shotgun has access to them."
+            )
+            if meta.backup_path:
+                hint_parts.append(
+                    f"Previous files were backed up to: `{meta.backup_path}`"
+                )
+            self.mount_hint("\n\n".join(hint_parts))
+        except Exception:
+            # Ignore errors reading meta.json - this is optional UI feedback
+            logger.debug("Failed to read meta.json for pull hint", exc_info=True)
+
     def mount_hint_with_email(
         self, markdown_before: str, email: str, markdown_after: str = ""
     ) -> None:
@@ -1035,6 +1110,71 @@ class ChatScreen(Screen[None]):
             )
         )
 
+    def share_specs_command(self) -> None:
+        """Launch the share specs workflow."""
+        self.call_later(lambda: self._start_share_specs_flow())
+
+    @work
+    async def _start_share_specs_flow(self) -> None:
+        """Main workflow for sharing specs to workspace."""
+        # 1. Check preconditions (instant check, no API call)
+        shotgun_dir = Path.cwd() / ".shotgun"
+        if not shotgun_dir.exists():
+            self.mount_hint("No .shotgun/ directory found in current directory")
+            return
+
+        # 2. Show spec selection dialog (handles workspace fetch, permissions, and spec loading)
+        result = await self.app.push_screen_wait(ShareSpecsDialog())
+        if result is None or result.action is None:
+            return  # User cancelled or error
+
+        workspace_id = result.workspace_id
+        if not workspace_id:
+            self.mount_hint("Failed to get workspace")
+            return
+
+        # 3. Handle create vs add version
+        if result.action == ShareSpecsAction.CREATE:
+            # Show create spec dialog
+            create_result = await self.app.push_screen_wait(CreateSpecDialog())
+            if create_result is None:
+                return  # User cancelled
+
+            # Pass spec creation info to UploadProgressScreen
+            # It will create the spec/version and then upload
+            upload_result = await self.app.push_screen_wait(
+                UploadProgressScreen(
+                    workspace_id,
+                    spec_name=create_result.name,
+                    spec_description=create_result.description,
+                    spec_is_public=create_result.is_public,
+                )
+            )
+
+        else:  # add_version
+            spec_id = result.spec_id
+            if not spec_id:
+                self.mount_hint("No spec selected")
+                return
+
+            # Pass spec_id to UploadProgressScreen
+            # It will create the version and then upload
+            upload_result = await self.app.push_screen_wait(
+                UploadProgressScreen(workspace_id, spec_id=spec_id)
+            )
+
+        # 7. Show result
+        if upload_result and upload_result.success:
+            if upload_result.web_url:
+                self.mount_hint(
+                    f"Specs shared successfully!\n\nView at: {upload_result.web_url}"
+                )
+            else:
+                self.mount_hint("Specs shared successfully!")
+        elif upload_result and upload_result.cancelled:
+            self.mount_hint("Upload cancelled")
+        # Error case is handled by the upload screen
+
     def delete_codebase_from_palette(self, graph_id: str) -> None:
         stack = getattr(self.app, "screen_stack", None)
         if stack and isinstance(stack[-1], CommandPalette):
@@ -1080,6 +1220,8 @@ class ChatScreen(Screen[None]):
 
     @work
     async def index_codebase(self, selection: CodebaseIndexSelection) -> None:
+        index_start_time = time.time()
+
         label = self.query_one("#indexing-job-display", Static)
         label.update(
             f"[$foreground-muted]Indexing codebase: [bold $text-accent]{selection.name}[/][/]"
@@ -1119,24 +1261,40 @@ class ChatScreen(Screen[None]):
 
         def progress_callback(progress_info: IndexProgress) -> None:
             """Update progress state (timer renders it independently)."""
-            # Calculate overall percentage (0-95%, reserve 95-100% for finalization)
+            # Calculate overall percentage with weights based on actual timing:
+            # Structure: 0-2%, Definitions: 2-18%, Relationships: 18-20%
+            # Flush nodes: 20-28%, Flush relationships: 28-100%
             if progress_info.phase == ProgressPhase.STRUCTURE:
-                # Phase 1: 0-10%, always show 5% while running, 10% when complete
-                overall_pct = 10.0 if progress_info.phase_complete else 5.0
+                # Phase 1: 0-2% (actual: ~0%)
+                overall_pct = 2.0 if progress_info.phase_complete else 1.0
             elif progress_info.phase == ProgressPhase.DEFINITIONS:
-                # Phase 2: 10-80% based on files processed
+                # Phase 2: 2-18% based on files processed (actual: ~16%)
                 if progress_info.total and progress_info.total > 0:
-                    phase_pct = (progress_info.current / progress_info.total) * 70.0
-                    overall_pct = 10.0 + phase_pct
+                    phase_pct = (progress_info.current / progress_info.total) * 16.0
+                    overall_pct = 2.0 + phase_pct
                 else:
-                    overall_pct = 10.0
+                    overall_pct = 2.0
             elif progress_info.phase == ProgressPhase.RELATIONSHIPS:
-                # Phase 3: 80-95% based on relationships processed (cap at 95%)
+                # Phase 3: 18-20% based on relationships processed (actual: ~0.3%)
+                if progress_info.total and progress_info.total > 0:
+                    phase_pct = (progress_info.current / progress_info.total) * 2.0
+                    overall_pct = 18.0 + phase_pct
+                else:
+                    overall_pct = 18.0
+            elif progress_info.phase == ProgressPhase.FLUSH_NODES:
+                # Phase 4: 20-28% based on nodes flushed (actual: ~7.5%)
+                if progress_info.total and progress_info.total > 0:
+                    phase_pct = (progress_info.current / progress_info.total) * 8.0
+                    overall_pct = 20.0 + phase_pct
+                else:
+                    overall_pct = 20.0
+            elif progress_info.phase == ProgressPhase.FLUSH_RELATIONSHIPS:
+                # Phase 5: 28-100% based on relationships flushed (actual: ~76%)
                 if progress_info.total and progress_info.total > 0:
-                    phase_pct = (progress_info.current / progress_info.total) * 15.0
-                    overall_pct = 80.0 + phase_pct
+                    phase_pct = (progress_info.current / progress_info.total) * 72.0
+                    overall_pct = 28.0 + phase_pct
                 else:
-                    overall_pct = 80.0
+                    overall_pct = 28.0
             else:
                 overall_pct = 0.0
 
@@ -1189,12 +1347,19 @@ class ChatScreen(Screen[None]):
                 )
                 label.refresh()
 
+                # Calculate duration and format message
+                duration = time.time() - index_start_time
+                duration_str = _format_duration(duration)
+                entity_count = result.node_count + result.relationship_count
+                entity_str = _format_count(entity_count)
+
                 logger.info(
-                    f"Successfully indexed codebase '{result.name}' (ID: {result.graph_id})"
+                    f"Successfully indexed codebase '{result.name}' in {duration_str} "
+                    f"({entity_count} entities)"
                 )
                 self.agent_manager.add_hint_message(
                     HintMessage(
-                        message=f"✓ Indexed codebase '{result.name}' (ID: {result.graph_id})"
+                        message=f"✓ Indexed '{result.name}' in {duration_str} ({entity_str} entities)"
                     )
                 )
                 break  # Success - exit retry loop
@@ -1279,6 +1444,11 @@ class ChatScreen(Screen[None]):
             # Stop context indicator animation
             self.widget_coordinator.set_context_streaming(False)
 
+            # Check for low balance after agent loop completes (only for Shotgun Account)
+            # This runs after processing but doesn't interfere with Q&A mode
+            if self.deps.llm_model.is_shotgun_account:
+                await self._check_low_balance_warning()
+
         # Save conversation after each interaction
         self._save_conversation()
 
@@ -1293,6 +1463,32 @@ class ChatScreen(Screen[None]):
             exclusive=True,
         )
 
+    async def _check_low_balance_warning(self) -> None:
+        """Check account balance and show warning if $2.50 or less remaining.
+
+        This runs after every agent loop completion for Shotgun Account users.
+        Errors are silently caught to avoid disrupting user workflow.
+        """
+        try:
+            from shotgun.llm_proxy import LiteLLMProxyClient
+
+            client = LiteLLMProxyClient(self.deps.llm_model.api_key)
+            budget_info = await client.get_budget_info()
+
+            # Show warning if remaining balance is $2.50 or less
+            if budget_info.remaining <= 2.50:
+                warning_message = (
+                    f"⚠️ **Low Balance Warning**\n\n"
+                    f"Your Shotgun Account has **${budget_info.remaining:.2f}** remaining.\n\n"
+                    f"👉 **[Top Up Now at https://app.shotgun.sh/dashboard](https://app.shotgun.sh/dashboard)**"
+                )
+                self.agent_manager.add_hint_message(
+                    HintMessage(message=warning_message)
+                )
+        except Exception as e:
+            # Silently log and continue - don't block user workflow
+            logger.debug(f"Failed to check low balance warning: {e}")
+
     async def _check_and_load_conversation(self) -> None:
         """Check if conversation exists and load it if it does."""
         if await self.conversation_manager.exists():