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

shotgun/tui/screens/kuzu_error_dialog.py

@@ -0,0 +1,135 @@
+"""Error dialog for Windows kuzu/graph database import failures."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from shotgun.codebase.core.kuzu_compat import (
+    _VC_INSTALL_SCRIPT,
+    _VC_REDIST_URL,
+    copy_vcpp_script_to_clipboard,
+    open_vcpp_download_page,
+)
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class KuzuErrorDialog(ModalScreen[bool]):
+    """Error dialog for Windows kuzu import failures with copy/open buttons."""
+
+    DEFAULT_CSS = """
+        KuzuErrorDialog {
+            align: center middle;
+            background: rgba(0, 0, 0, 0.5);
+        }
+
+        KuzuErrorDialog > #dialog-container {
+            width: 90%;
+            max-width: 100;
+            height: auto;
+            max-height: 90%;
+            border: wide $error;
+            padding: 1 2;
+            layout: vertical;
+            background: $surface;
+        }
+
+        #error-title {
+            text-style: bold;
+            color: $error;
+            padding-bottom: 1;
+        }
+
+        #error-message {
+            padding: 1 0;
+        }
+
+        #script-display {
+            padding: 1;
+            margin: 1 0;
+            background: $surface-darken-1;
+            border: round $primary;
+            overflow-x: auto;
+        }
+
+        #status-label {
+            color: $success;
+            padding: 1 0;
+            min-height: 1;
+        }
+
+        #dialog-buttons {
+            layout: horizontal;
+            align-horizontal: center;
+            height: auto;
+            padding-top: 1;
+        }
+
+        #dialog-buttons Button {
+            margin: 0 1;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "close", "Close"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Container(id="dialog-container"):
+            yield Label("Code Indexing Requires Visual C++", id="error-title")
+            yield Static(
+                "The graph database library requires the Visual C++ Redistributable "
+                "to be installed on Windows.\n\n"
+                "Run this PowerShell script as Administrator:",
+                id="error-message",
+            )
+            yield Static(_VC_INSTALL_SCRIPT, id="script-display")
+            yield Static("", id="status-label")
+            with Horizontal(id="dialog-buttons"):
+                yield Button(
+                    "Copy Script to Clipboard", id="copy-btn", variant="primary"
+                )
+                yield Button("Open Download Page", id="open-btn", variant="default")
+                yield Button("Close", id="close-btn", variant="default")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        event.stop()
+
+        if event.button.id == "copy-btn":
+            self._copy_script()
+        elif event.button.id == "open-btn":
+            self._open_download()
+        elif event.button.id == "close-btn":
+            self.dismiss(True)
+
+    def _copy_script(self) -> None:
+        """Copy the PowerShell installation script to clipboard."""
+        status_label = self.query_one("#status-label", Static)
+
+        if copy_vcpp_script_to_clipboard():
+            status_label.update("Copied script to clipboard!")
+            self.query_one("#copy-btn", Button).label = "Copied!"
+            logger.debug("Copied VC++ installation script to clipboard")
+        else:
+            status_label.update(f"Could not copy. Download from: {_VC_REDIST_URL}")
+            logger.warning("Failed to copy VC++ script to clipboard")
+
+    def _open_download(self) -> None:
+        """Open the download page in the default browser."""
+        status_label = self.query_one("#status-label", Static)
+
+        if open_vcpp_download_page():
+            status_label.update("Opened download page in browser")
+            logger.debug(f"Opened VC++ download page: {_VC_REDIST_URL}")
+        else:
+            status_label.update(f"Could not open browser. URL: {_VC_REDIST_URL}")
+            logger.warning("Failed to open VC++ download page")
+
+    def action_close(self) -> None:
+        """Close the dialog."""
+        self.dismiss(True)

shotgun/tui/screens/model_picker.py

@@ -293,6 +293,12 @@ class ModelPickerScreen(Screen[ModelConfigUpdated | None]):
         )
         return has_key
 
+    def _format_tokens(self, tokens: int) -> str:
+        """Format token count for display (K for thousands, M for millions)."""
+        if tokens >= 1_000_000:
+            return f"{tokens / 1_000_000:.1f}M"
+        return f"{tokens // 1000}K"
+
     def _model_label(self, model_name: ModelName, is_current: bool) -> str:
         """Generate label for model with specs and current indicator."""
         if model_name not in MODEL_SPECS:
@@ -302,13 +308,13 @@ class ModelPickerScreen(Screen[ModelConfigUpdated | None]):
         display_name = self._model_display_name(model_name)
 
         # Format context/output tokens in readable format
-        input_k = spec.max_input_tokens // 1000
-        output_k = spec.max_output_tokens // 1000
+        input_fmt = self._format_tokens(spec.max_input_tokens)
+        output_fmt = self._format_tokens(spec.max_output_tokens)
 
-        label = f"{display_name} · {input_k}K context · {output_k}K output"
+        label = f"{display_name} · {input_fmt} context · {output_fmt} output"
 
         # Add cost indicator for expensive models
-        if model_name == ModelName.CLAUDE_OPUS_4_1:
+        if model_name == ModelName.CLAUDE_OPUS_4_5:
             label += " · Expensive"
 
         if is_current:
@@ -319,16 +325,15 @@ class ModelPickerScreen(Screen[ModelConfigUpdated | None]):
     def _model_display_name(self, model_name: ModelName) -> str:
         """Get human-readable model name."""
         names = {
-            ModelName.GPT_5: "GPT-5 (OpenAI)",
-            ModelName.GPT_5_MINI: "GPT-5 Mini (OpenAI)",
             ModelName.GPT_5_1: "GPT-5.1 (OpenAI)",
-            ModelName.GPT_5_1_CODEX: "GPT-5.1 Codex (OpenAI)",
-            ModelName.GPT_5_1_CODEX_MINI: "GPT-5.1 Codex Mini (OpenAI)",
-            ModelName.CLAUDE_OPUS_4_1: "Claude Opus 4.1 (Anthropic)",
+            ModelName.GPT_5_2: "GPT-5.2 (OpenAI)",
+            ModelName.CLAUDE_OPUS_4_5: "Claude Opus 4.5 (Anthropic)",
             ModelName.CLAUDE_SONNET_4_5: "Claude Sonnet 4.5 (Anthropic)",
             ModelName.CLAUDE_HAIKU_4_5: "Claude Haiku 4.5 (Anthropic)",
             ModelName.GEMINI_2_5_PRO: "Gemini 2.5 Pro (Google)",
             ModelName.GEMINI_2_5_FLASH: "Gemini 2.5 Flash (Google)",
+            ModelName.GEMINI_2_5_FLASH_LITE: "Gemini 2.5 Flash Lite (Google)",
+            ModelName.GEMINI_3_PRO_PREVIEW: "Gemini 3 Pro Preview (Google)",
         }
         return names.get(model_name, model_name.value)
 

shotgun/tui/screens/models.py

@@ -0,0 +1,11 @@
+"""Models and enums for TUI screens."""
+
+from enum import StrEnum
+
+
+class LockedDialogAction(StrEnum):
+    """Actions available in the database locked dialog."""
+
+    RETRY = "retry"
+    DELETE = "delete"
+    QUIT = "quit"

shotgun/tui/screens/shotgun_auth.py

@@ -1,6 +1,7 @@
 """Shotgun Account authentication screen."""
 
 import asyncio
+import time
 import webbrowser
 from typing import TYPE_CHECKING, cast
 
@@ -15,6 +16,7 @@ from textual.worker import Worker, WorkerState
 
 from shotgun.agents.config import ConfigManager
 from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
 from shotgun.shotgun_web import (
     ShotgunWebClient,
     TokenStatus,
@@ -118,6 +120,7 @@ class ShotgunAuthScreen(Screen[bool]):
         self.token: str | None = None
         self.auth_url: str | None = None
         self.poll_worker: Worker[None] | None = None
+        self._auth_start_time: float | None = None
 
     def compose(self) -> ComposeResult:
         with Vertical(id="titlebox"):
@@ -158,6 +161,7 @@ class ShotgunAuthScreen(Screen[bool]):
 
     def action_cancel(self) -> None:
         """Cancel authentication and close screen."""
+        track_event("auth_cancelled")
         if self.poll_worker and self.poll_worker.state == WorkerState.RUNNING:
             self.poll_worker.cancel()
         self.dismiss(False)
@@ -174,6 +178,9 @@ class ShotgunAuthScreen(Screen[bool]):
 
     async def _start_auth_flow(self) -> None:
         """Start the authentication flow."""
+        self._auth_start_time = time.time()
+        track_event("auth_started")
+
         try:
             # Get shotgun instance ID from config
             shotgun_instance_id = await self.config_manager.get_shotgun_instance_id()
@@ -220,12 +227,20 @@ class ShotgunAuthScreen(Screen[bool]):
 
         except httpx.HTTPError as e:
             logger.error("Failed to create auth token: %s", e)
+            track_event(
+                "auth_failed",
+                {"phase": "token_creation", "error_type": type(e).__name__},
+            )
             self.query_one("#status", Label).update(
                 f"❌ Error: Failed to create authentication token\n{e}"
             )
 
         except Exception as e:
             logger.error("Unexpected error during auth flow: %s", e)
+            track_event(
+                "auth_failed",
+                {"phase": "token_creation", "error_type": type(e).__name__},
+            )
             self.query_one("#status", Label).update(f"❌ Unexpected error: {e}")
 
     async def _poll_token_status(self) -> None:
@@ -272,6 +287,17 @@ class ShotgunAuthScreen(Screen[bool]):
                             workspace_id=workspace_id,
                         )
 
+                        # Track successful auth
+                        duration = (
+                            time.time() - self._auth_start_time
+                            if self._auth_start_time
+                            else 0
+                        )
+                        track_event(
+                            "auth_completed",
+                            {"duration_seconds": round(duration, 2)},
+                        )
+
                         self.query_one("#status", Label).update(
                             "✅ Authentication successful! Saving credentials..."
                         )
@@ -279,6 +305,10 @@ class ShotgunAuthScreen(Screen[bool]):
                         self.dismiss(True)
                     else:
                         logger.error("Completed but missing keys")
+                        track_event(
+                            "auth_failed",
+                            {"phase": "polling", "error_type": "MissingKeys"},
+                        )
                         self.query_one("#status", Label).update(
                             "❌ Error: Authentication completed but keys are missing"
                         )
@@ -293,6 +323,10 @@ class ShotgunAuthScreen(Screen[bool]):
 
                 elif status_response.status == TokenStatus.EXPIRED:
                     logger.error("Token expired")
+                    track_event(
+                        "auth_failed",
+                        {"phase": "token_expired", "error_type": "TokenExpired"},
+                    )
                     self.query_one("#status", Label).update(
                         "❌ Authentication token expired (30 minutes)\n"
                         "Please try again."
@@ -312,6 +346,10 @@ class ShotgunAuthScreen(Screen[bool]):
                 if e.response.status_code == 410:
                     # Token expired
                     logger.error("Token expired (410)")
+                    track_event(
+                        "auth_failed",
+                        {"phase": "token_expired", "error_type": "TokenExpired"},
+                    )
                     self.query_one("#status", Label).update(
                         "❌ Authentication token expired"
                     )
@@ -320,6 +358,10 @@ class ShotgunAuthScreen(Screen[bool]):
                     return
                 else:
                     logger.error("HTTP error polling status: %s", e)
+                    track_event(
+                        "auth_failed",
+                        {"phase": "polling_error", "error_type": type(e).__name__},
+                    )
                     self.query_one("#status", Label).update(
                         f"❌ Error checking status: {e}"
                     )
@@ -327,11 +369,19 @@ class ShotgunAuthScreen(Screen[bool]):
 
             except Exception as e:
                 logger.error("Error polling token status: %s", e)
+                track_event(
+                    "auth_failed",
+                    {"phase": "polling_error", "error_type": type(e).__name__},
+                )
                 self.query_one("#status", Label).update(f"⚠️ Error checking status: {e}")
                 await asyncio.sleep(5)  # Wait a bit longer on error
 
         # Timeout reached
         logger.error("Polling timeout reached")
+        track_event(
+            "auth_failed",
+            {"phase": "timeout", "error_type": "Timeout"},
+        )
         self.query_one("#status", Label).update(
             "❌ Authentication timeout (30 minutes)\nPlease try again."
         )

shotgun/tui/screens/spec_pull.py

@@ -8,6 +8,7 @@ from textual.screen import ModalScreen
 from textual.widgets import Button, Label, ProgressBar, Static
 from textual.worker import Worker, get_current_worker
 
+from shotgun.cli.spec.models import PullSource
 from shotgun.cli.spec.pull_service import (
     CancelledError,
     PullProgress,
@@ -187,6 +188,7 @@ class SpecPullScreen(ModalScreen[bool]):
                 shotgun_dir=shotgun_dir,
                 on_progress=on_progress,
                 is_cancelled=lambda: worker.is_cancelled,
+                source=PullSource.TUI,
             )
 
             if result.success:

shotgun/tui/state/processing_state.py

@@ -7,6 +7,7 @@ This module provides centralized management of processing state including:
 - Providing clean cancellation API
 """
 
+import asyncio
 from typing import TYPE_CHECKING, Any
 
 from shotgun.logging_config import get_logger
@@ -61,6 +62,7 @@ class ProcessingStateManager:
         self._spinner_widget: Spinner | None = None
         self._default_spinner_text = "Processing..."
         self._telemetry_context = telemetry_context or {}
+        self._cancellation_event: asyncio.Event | None = None
 
     @property
     def is_working(self) -> bool:
@@ -71,6 +73,15 @@ class ProcessingStateManager:
         """
         return self._working
 
+    @property
+    def cancellation_event(self) -> asyncio.Event | None:
+        """Get the current cancellation event for agent deps.
+
+        Returns:
+            The cancellation event for the current operation, or None if not processing
+        """
+        return self._cancellation_event
+
     def bind_spinner(self, spinner: "Spinner") -> None:
         """Bind a spinner widget for state coordination.
 
@@ -95,6 +106,9 @@ class ProcessingStateManager:
         self._working = True
         text = spinner_text or self._default_spinner_text
 
+        # Create a new cancellation event for this operation
+        self._cancellation_event = asyncio.Event()
+
         # Update screen's reactive working state
         if hasattr(self.screen, "working"):
             self.screen.working = True
@@ -113,6 +127,7 @@ class ProcessingStateManager:
 
         self._working = False
         self._current_worker = None
+        self._cancellation_event = None
 
         # Update screen's reactive working state
         if hasattr(self.screen, "working"):
@@ -151,6 +166,10 @@ class ProcessingStateManager:
             return False
 
         try:
+            # Set the cancellation event first for immediate effect on streaming
+            if self._cancellation_event:
+                self._cancellation_event.set()
+
             self._current_worker.cancel()
             logger.info("Operation cancelled successfully")
 

shotgun/tui/utils/mode_progress.py

@@ -113,93 +113,24 @@ class ModeProgressChecker:
 
 
 class PlaceholderHints:
-    """Manages dynamic placeholder hints for each mode based on progress."""
+    """Manages dynamic placeholder hints for the Router agent."""
 
-    # Placeholder variations for each mode and state
+    # Placeholder variations for Router mode
     HINTS = {
-        # Research mode
-        AgentType.RESEARCH: {
+        AgentType.ROUTER: {
             False: [
-                "Research a product or idea (SHIFT+TAB to cycle modes)",
-                "What would you like to explore? Start your research journey here (SHIFT+TAB to switch modes)",
-                "Dive into discovery mode - research anything that sparks curiosity (SHIFT+TAB for mode menu)",
-                "Ready to investigate? Feed me your burning questions (SHIFT+TAB to explore other modes)",
-                " 🔍 The research rabbit hole awaits! What shall we uncover? (SHIFT+TAB for mode carousel)",
+                "What would you like to work on? (SHIFT+TAB to toggle Planning/Drafting)",
+                "Ask me to research, plan, or implement anything (SHIFT+TAB toggles mode)",
+                "Describe your goal and I'll help break it down (SHIFT+TAB for mode toggle)",
+                "Ready to help with research, specs, plans, or tasks (SHIFT+TAB toggles mode)",
+                "Tell me what you need - I'll coordinate the work (SHIFT+TAB for Planning/Drafting)",
             ],
             True: [
-                "Research complete! SHIFT+TAB to move to Specify mode",
-                "Great research! Time to specify (SHIFT+TAB to Specify mode)",
-                "Research done! Ready to create specifications (SHIFT+TAB to Specify)",
-                "Findings gathered! Move to specifications (SHIFT+TAB for Specify mode)",
-                " 🎯 Research complete! Advance to Specify mode (SHIFT+TAB)",
-            ],
-        },
-        # Specify mode
-        AgentType.SPECIFY: {
-            False: [
-                "Create detailed specifications and requirements (SHIFT+TAB to switch modes)",
-                "Define your project specifications here (SHIFT+TAB to navigate modes)",
-                "Time to get specific - write comprehensive specs (SHIFT+TAB for mode options)",
-                "Specification station: Document requirements and designs (SHIFT+TAB to change modes)",
-                " 📋 Spec-tacular time! Let's architect your ideas (SHIFT+TAB for mode magic)",
-            ],
-            True: [
-                "Specifications complete! SHIFT+TAB to create a Plan",
-                "Specs ready! Time to plan (SHIFT+TAB to Plan mode)",
-                "Requirements defined! Move to planning (SHIFT+TAB to Plan)",
-                "Specifications done! Create your roadmap (SHIFT+TAB for Plan mode)",
-                " 🚀 Specs complete! Advance to Plan mode (SHIFT+TAB)",
-            ],
-        },
-        # Tasks mode
-        AgentType.TASKS: {
-            False: [
-                "Break down your project into actionable tasks (SHIFT+TAB for modes)",
-                "Task creation time! Define your implementation steps (SHIFT+TAB to switch)",
-                "Ready to get tactical? Create your task list (SHIFT+TAB for mode options)",
-                "Task command center: Organize your work items (SHIFT+TAB to navigate)",
-                " ✅ Task mode activated! Break it down into bite-sized pieces (SHIFT+TAB)",
-            ],
-            True: [
-                "Tasks defined! Ready to export or cycle back (SHIFT+TAB)",
-                "Task list complete! Export your work (SHIFT+TAB to Export)",
-                "All tasks created! Time to export (SHIFT+TAB for Export mode)",
-                "Implementation plan ready! Export everything (SHIFT+TAB to Export)",
-                " 🎊 Tasks complete! Export your masterpiece (SHIFT+TAB)",
-            ],
-        },
-        # Export mode
-        AgentType.EXPORT: {
-            False: [
-                "Export your complete project documentation (SHIFT+TAB for modes)",
-                "Ready to package everything? Export time! (SHIFT+TAB to switch)",
-                "Export station: Generate deliverables (SHIFT+TAB for mode menu)",
-                "Time to share your work! Export documents (SHIFT+TAB to navigate)",
-                " 📦 Export mode! Package and share your creation (SHIFT+TAB)",
-            ],
-            True: [
-                "Exported! Start new research or continue refining (SHIFT+TAB)",
-                "Export complete! New cycle begins (SHIFT+TAB to Research)",
-                "All exported! Ready for another round (SHIFT+TAB for Research)",
-                "Documents exported! Start fresh (SHIFT+TAB to Research mode)",
-                " 🎉 Export complete! Begin a new adventure (SHIFT+TAB)",
-            ],
-        },
-        # Plan mode
-        AgentType.PLAN: {
-            False: [
-                "Create a strategic plan for your project (SHIFT+TAB for modes)",
-                "Planning phase: Map out your roadmap (SHIFT+TAB to switch)",
-                "Time to strategize! Create your project plan (SHIFT+TAB for options)",
-                "Plan your approach and milestones (SHIFT+TAB to navigate)",
-                " 🗺️ Plan mode! Chart your course to success (SHIFT+TAB)",
-            ],
-            True: [
-                "Plan complete! Move to Tasks mode (SHIFT+TAB)",
-                "Strategy ready! Time for tasks (SHIFT+TAB to Tasks mode)",
-                "Roadmap done! Create task list (SHIFT+TAB for Tasks)",
-                "Planning complete! Break into tasks (SHIFT+TAB to Tasks)",
-                " ⚡ Plan ready! Advance to Tasks mode (SHIFT+TAB)",
+                "Continue working or start something new (SHIFT+TAB toggles mode)",
+                "What's next? (SHIFT+TAB to toggle Planning/Drafting)",
+                "Ready for the next task (SHIFT+TAB toggles Planning/Drafting)",
+                "Let's keep going! (SHIFT+TAB to toggle mode)",
+                "What else can I help with? (SHIFT+TAB for mode toggle)",
             ],
         },
     }
@@ -224,19 +155,22 @@ class PlaceholderHints:
         Returns:
             A contextual hint string for the placeholder.
         """
+        # Always use Router hints since Router is the only user-facing agent
+        mode_key = AgentType.ROUTER
+
         # Default hint if mode not configured
-        if current_mode not in self.HINTS:
-            return f"Enter your {current_mode.value} mode prompt (SHIFT+TAB to switch modes)"
+        if mode_key not in self.HINTS:
+            return "Enter your prompt (SHIFT+TAB to toggle Planning/Drafting mode)"
 
         # For placeholder text, we default to "no content" state (initial hints)
         # This avoids async file system checks in the UI rendering path
         has_content = False
 
         # Get hint variations for this mode and state
-        hints_list = self.HINTS[current_mode][has_content]
+        hints_list = self.HINTS[mode_key][has_content]
 
         # Cache key for this mode and state
-        cache_key = (current_mode, has_content)
+        cache_key = (mode_key, has_content)
 
         # Force refresh or first time
         if force_refresh or cache_key not in self._cached_hints:

shotgun/tui/widgets/__init__.py

@@ -1,5 +1,6 @@
 """Widget utilities and coordinators for TUI."""
 
+from shotgun.tui.widgets.plan_panel import PlanPanelWidget
 from shotgun.tui.widgets.widget_coordinator import WidgetCoordinator
 
-__all__ = ["WidgetCoordinator"]
+__all__ = ["PlanPanelWidget", "WidgetCoordinator"]