shotgun-sh 0.3.3.dev1__py3-none-any.whl → 0.6.2__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

@@ -326,10 +326,8 @@ class ModelPickerScreen(Screen[ModelConfigUpdated | None]):
         """Get human-readable model name."""
         names = {
             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.GPT_5_2: "GPT-5.2 (OpenAI)",
             ModelName.CLAUDE_OPUS_4_5: "Claude Opus 4.5 (Anthropic)",
-            ModelName.CLAUDE_SONNET_4: "Claude Sonnet 4 (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)",

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/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"]

shotgun/tui/widgets/approval_widget.py

@@ -0,0 +1,152 @@
+"""Plan approval widget for Planning mode.
+
+This widget displays when a multi-step plan is created in Planning mode,
+allowing the user to approve or reject the plan before execution begins.
+"""
+
+from textual import events, on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.css.query import NoMatches
+from textual.widget import Widget
+from textual.widgets import Button, Static
+
+from shotgun.agents.router.models import ExecutionPlan
+from shotgun.tui.screens.chat_screen.messages import (
+    PlanApproved,
+    PlanRejected,
+)
+
+
+class PlanApprovalWidget(Widget):
+    """Widget for plan approval in Planning mode.
+
+    Displays the execution plan summary with goal and steps,
+    and provides action buttons for the user to approve or reject.
+
+    Attributes:
+        plan: The execution plan that needs user approval.
+    """
+
+    DEFAULT_CSS = """
+        PlanApprovalWidget {
+            background: $secondary-background-darken-1;
+            height: auto;
+            max-height: 20;
+            margin: 0 1;
+            padding: 1;
+        }
+
+        PlanApprovalWidget .approval-header {
+            height: auto;
+        }
+
+        PlanApprovalWidget .plan-content {
+            height: auto;
+            max-height: 12;
+            margin: 1 0;
+        }
+
+        PlanApprovalWidget .plan-goal {
+            color: $text;
+            margin-bottom: 1;
+        }
+
+        PlanApprovalWidget .plan-steps-label {
+            color: $text-muted;
+        }
+
+        PlanApprovalWidget .step-item {
+            color: $text;
+            margin-left: 2;
+        }
+
+        PlanApprovalWidget .approval-buttons {
+            height: auto;
+            width: 100%;
+            dock: bottom;
+        }
+
+        PlanApprovalWidget Button {
+            margin-right: 1;
+            min-width: 18;
+        }
+
+        PlanApprovalWidget #btn-approve {
+            background: $success;
+        }
+
+        PlanApprovalWidget #btn-reject {
+            background: $error;
+        }
+    """
+
+    def __init__(self, plan: ExecutionPlan) -> None:
+        """Initialize the approval widget.
+
+        Args:
+            plan: The execution plan that needs user approval.
+        """
+        super().__init__()
+        self.plan = plan
+
+    def compose(self) -> ComposeResult:
+        """Compose the approval widget layout."""
+        # Header with step count
+        yield Static(
+            f"[bold]📋 Plan created with {len(self.plan.steps)} steps[/]",
+            classes="approval-header",
+        )
+
+        # Scrollable content area for goal and steps
+        with VerticalScroll(classes="plan-content"):
+            # Goal
+            yield Static(
+                f"[dim]Goal:[/] {self.plan.goal}",
+                classes="plan-goal",
+            )
+
+            # Steps list
+            yield Static("[dim]Steps:[/]", classes="plan-steps-label")
+            for i, step in enumerate(self.plan.steps, 1):
+                yield Static(
+                    f"{i}. {step.title}",
+                    classes="step-item",
+                )
+
+        # Action buttons (always visible at bottom)
+        with Horizontal(classes="approval-buttons"):
+            yield Button("✓ Go Ahead", id="btn-approve")
+            yield Button("✗ No, Let Me Clarify", id="btn-reject")
+
+    def on_mount(self) -> None:
+        """Auto-focus the Go Ahead button on mount."""
+        try:
+            approve_btn = self.query_one("#btn-approve", Button)
+            approve_btn.focus()
+        except NoMatches:
+            pass
+
+    @on(Button.Pressed, "#btn-approve")
+    def handle_approve(self) -> None:
+        """Handle Go Ahead button press."""
+        self.post_message(PlanApproved())
+
+    @on(Button.Pressed, "#btn-reject")
+    def handle_reject(self) -> None:
+        """Handle No, Let Me Clarify button press."""
+        self.post_message(PlanRejected())
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle keyboard shortcuts for approval actions.
+
+        Shortcuts:
+            Enter/Y: Approve plan (Go Ahead)
+            Escape/N: Reject plan (No, Let Me Clarify)
+        """
+        if event.key in ("enter", "y", "Y"):
+            self.post_message(PlanApproved())
+            event.stop()
+        elif event.key in ("escape", "n", "N"):
+            self.post_message(PlanRejected())
+            event.stop()