shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/tui/screens/directory_setup.py

@@ -1,4 +1,4 @@
-"""Screen for setting up the local .shotgun directory."""
+"""Screen for displaying .shotgun directory creation errors."""
 
 from __future__ import annotations
 
@@ -8,13 +8,20 @@ from textual import on
 from textual.app import ComposeResult
 from textual.containers import Horizontal, Vertical
 from textual.screen import Screen
-from textual.widgets import Button, Static
-
-from shotgun.utils.file_system_utils import ensure_shotgun_directory_exists
+from textual.widgets import Button, Label, Static
 
 
 class DirectorySetupScreen(Screen[None]):
-    """Prompt the user to initialize the .shotgun directory."""
+    """Display an error when .shotgun directory creation fails."""
+
+    def __init__(self, error_message: str) -> None:
+        """Initialize the error screen.
+
+        Args:
+            error_message: The error message to display to the user.
+        """
+        super().__init__()
+        self.error_message = error_message
 
     CSS = """
         DirectorySetupScreen {
@@ -56,58 +63,55 @@ class DirectorySetupScreen(Screen[None]):
         #directory-actions > * {
             margin-right: 2;
         }
+
+        #directory-status {
+            height: auto;
+            padding: 0 1;
+            min-height: 1;
+            color: $error;
+            text-align: center;
+        }
     """
 
     BINDINGS = [
-        ("enter", "confirm", "Initialize"),
+        ("enter", "retry", "Retry"),
         ("escape", "cancel", "Exit"),
     ]
 
     def compose(self) -> ComposeResult:
         with Vertical(id="titlebox"):
-            yield Static("Directory setup", id="directory-setup-title")
-            yield Static("Shotgun keeps workspace data in a .shotgun directory.\n")
-            yield Static("Initialize it in the current directory?\n")
-            yield Static(f"[$foreground-muted]({Path.cwd().resolve()})[/]")
-        with Horizontal(id="directory-actions"):
-            yield Button(
-                "Initialize and proceed \\[ENTER]", variant="primary", id="initialize"
+            yield Static(
+                "Failed to create .shotgun directory", id="directory-setup-title"
+            )
+            yield Static("Shotgun was unable to create the .shotgun directory in:\n")
+            yield Static(f"[$foreground-muted]({Path.cwd().resolve()})[/]\n")
+            yield Static(f"[bold red]Error:[/] {self.error_message}\n")
+            yield Static(
+                "This directory is required for storing workspace data. "
+                "Please check permissions and try again."
             )
-            yield Button("Exit without setup \\[ESC]", variant="default", id="exit")
+        yield Label("", id="directory-status")
+        with Horizontal(id="directory-actions"):
+            yield Button("Retry \\[ENTER]", variant="primary", id="retry")
+            yield Button("Exit \\[ESC]", variant="default", id="exit")
 
     def on_mount(self) -> None:
-        self.set_focus(self.query_one("#initialize", Button))
+        self.set_focus(self.query_one("#retry", Button))
 
-    def action_confirm(self) -> None:
-        self._initialize_directory()
+    def action_retry(self) -> None:
+        """Retry by dismissing the screen, which will trigger refresh_startup_screen."""
+        self.dismiss()
 
     def action_cancel(self) -> None:
-        self._exit_application()
+        """Exit the application."""
+        self.app.exit()
 
-    @on(Button.Pressed, "#initialize")
-    def _on_initialize_pressed(self) -> None:
-        self._initialize_directory()
+    @on(Button.Pressed, "#retry")
+    def _on_retry_pressed(self) -> None:
+        """Retry by dismissing the screen."""
+        self.dismiss()
 
     @on(Button.Pressed, "#exit")
     def _on_exit_pressed(self) -> None:
-        self._exit_application()
-
-    def _initialize_directory(self) -> None:
-        try:
-            path = ensure_shotgun_directory_exists()
-        except Exception as exc:  # pragma: no cover - defensive; textual path
-            self.notify(f"Failed to initialize directory: {exc}", severity="error")
-            return
-
-        # Double-check a directory now exists; guard against unexpected filesystem state.
-        if not path.is_dir():
-            self.notify(
-                "Unable to initialize .shotgun directory due to filesystem conflict.",
-                severity="error",
-            )
-            return
-
-        self.dismiss()
-
-    def _exit_application(self) -> None:
+        """Exit the application."""
         self.app.exit()

shotgun/tui/screens/feedback.py

@@ -76,6 +76,13 @@ class FeedbackScreen(Screen[Feedback | None]):
         #feedback-type-list {
             padding: 1;
         }
+
+        #feedback-status {
+            height: auto;
+            padding: 0 1;
+            min-height: 1;
+            color: $error;
+        }
     """
 
     BINDINGS = [
@@ -96,6 +103,7 @@ class FeedbackScreen(Screen[Feedback | None]):
             "",
             id="feedback-description",
         )
+        yield Label("", id="feedback-status")
         with Horizontal(id="feedback-actions"):
             yield Button("Submit", variant="primary", id="submit")
             yield Button("Cancel \\[ESC]", id="cancel")
@@ -125,8 +133,8 @@ class FeedbackScreen(Screen[Feedback | None]):
             self.set_focus(self.query_one("#feedback-description", TextArea))
 
     @on(Button.Pressed, "#submit")
-    def _on_submit_pressed(self) -> None:
-        self._submit_feedback()
+    async def _on_submit_pressed(self) -> None:
+        await self._submit_feedback()
 
     @on(Button.Pressed, "#cancel")
     def _on_cancel_pressed(self) -> None:
@@ -171,18 +179,17 @@ class FeedbackScreen(Screen[Feedback | None]):
         }
         return placeholders.get(kind, "Enter your feedback...")
 
-    def _submit_feedback(self) -> None:
+    async def _submit_feedback(self) -> None:
         text_area = self.query_one("#feedback-description", TextArea)
         description = text_area.text.strip()
 
         if not description:
-            self.notify(
-                "Please enter a description before submitting.", severity="error"
-            )
+            status_label = self.query_one("#feedback-status", Label)
+            status_label.update("❌ Please enter a description before submitting.")
             return
 
         app = cast("ShotgunApp", self.app)
-        shotgun_instance_id = app.config_manager.get_shotgun_instance_id()
+        shotgun_instance_id = await app.config_manager.get_shotgun_instance_id()
 
         feedback = Feedback(
             kind=self.selected_kind,

shotgun/tui/screens/github_issue.py

@@ -0,0 +1,111 @@
+"""Screen for guiding users to create GitHub issues."""
+
+import webbrowser
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Markdown, Static
+
+
+class GitHubIssueScreen(ModalScreen[None]):
+    """Guide users to create issues on GitHub."""
+
+    CSS = """
+        GitHubIssueScreen {
+            align: center middle;
+        }
+
+        #issue-container {
+            width: 70;
+            max-width: 100;
+            height: auto;
+            border: thick $primary;
+            background: $surface;
+            padding: 2;
+        }
+
+        #issue-header {
+            text-style: bold;
+            color: $text-accent;
+            padding-bottom: 1;
+            text-align: center;
+        }
+
+        #issue-content {
+            padding: 1 0;
+        }
+
+        #issue-buttons {
+            height: auto;
+            padding: 2 0 0 0;
+            align: center middle;
+        }
+
+        #issue-buttons Button {
+            margin: 1 1;
+            min-width: 20;
+        }
+
+        #issue-status {
+            height: auto;
+            padding: 1;
+            min-height: 1;
+            text-align: center;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "dismiss", "Close"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the GitHub issue screen."""
+        with Container(id="issue-container"):
+            yield Static("Create a GitHub Issue", id="issue-header")
+            with Vertical(id="issue-content"):
+                yield Markdown(
+                    """
+## Report Bugs or Request Features
+
+We track all bugs, feature requests, and improvements on GitHub Issues.
+
+### How to Create an Issue:
+
+1. Click the button below to open our GitHub Issues page
+2. Click **"New Issue"**
+3. Choose a template:
+   - **Bug Report** - Report a bug or unexpected behavior
+   - **Feature Request** - Suggest new functionality
+   - **Documentation** - Report docs issues or improvements
+4. Fill in the details and submit
+
+We review all issues and will respond as soon as possible!
+
+### Before Creating an Issue:
+
+- Search existing issues to avoid duplicates
+- Include steps to reproduce for bugs
+- Be specific about what you'd like for feature requests
+                    """,
+                    id="issue-markdown",
+                )
+            with Vertical(id="issue-buttons"):
+                yield Label("", id="issue-status")
+                yield Button(
+                    "🐙 Open GitHub Issues", id="github-button", variant="primary"
+                )
+                yield Button("Close", id="close-button")
+
+    @on(Button.Pressed, "#github-button")
+    def handle_github(self) -> None:
+        """Open GitHub issues page in browser."""
+        webbrowser.open("https://github.com/shotgun-sh/shotgun/issues")
+        status_label = self.query_one("#issue-status", Label)
+        status_label.update("✓ Opening GitHub Issues in your browser...")
+
+    @on(Button.Pressed, "#close-button")
+    def handle_close(self) -> None:
+        """Handle close button press."""
+        self.dismiss()

shotgun/tui/screens/model_picker.py

@@ -11,8 +11,13 @@ from textual.reactive import reactive
 from textual.screen import Screen
 from textual.widgets import Button, Label, ListItem, ListView, Static
 
+from shotgun.agents.agent_manager import ModelConfigUpdated
 from shotgun.agents.config import ConfigManager
 from shotgun.agents.config.models import MODEL_SPECS, ModelName, ShotgunConfig
+from shotgun.agents.config.provider import (
+    get_default_model_for_provider,
+    get_provider_model,
+)
 from shotgun.logging_config import get_logger
 
 if TYPE_CHECKING:
@@ -30,8 +35,11 @@ def _sanitize_model_name_for_id(model_name: ModelName) -> str:
     return model_name.value.replace(".", "-")
 
 
-class ModelPickerScreen(Screen[None]):
-    """Select AI model to use."""
+class ModelPickerScreen(Screen[ModelConfigUpdated | None]):
+    """Select AI model to use.
+
+    Returns ModelConfigUpdated when a model is selected, None if cancelled.
+    """
 
     CSS = """
         ModelPicker {
@@ -64,6 +72,11 @@ class ModelPickerScreen(Screen[None]):
             padding: 1 0;
             }
         }
+        #model-picker-status {
+            height: auto;
+            padding: 0 1;
+            color: $error;
+        }
         #model-actions {
             padding: 1;
         }
@@ -76,7 +89,7 @@ class ModelPickerScreen(Screen[None]):
         ("escape", "done", "Back"),
     ]
 
-    selected_model: reactive[ModelName] = reactive(ModelName.GPT_5)
+    selected_model: reactive[ModelName] = reactive(ModelName.GPT_5_1)
 
     def compose(self) -> ComposeResult:
         with Vertical(id="titlebox"):
@@ -86,11 +99,12 @@ class ModelPickerScreen(Screen[None]):
                 id="model-picker-summary",
             )
         yield ListView(id="model-list")
+        yield Label("", id="model-picker-status")
         with Horizontal(id="model-actions"):
             yield Button("Select \\[ENTER]", variant="primary", id="select")
             yield Button("Done \\[ESC]", id="done")
 
-    def _rebuild_model_list(self) -> None:
+    async def _rebuild_model_list(self) -> None:
         """Rebuild the model list from current config.
 
         This method is called both on first show and when screen is resumed
@@ -100,7 +114,7 @@ class ModelPickerScreen(Screen[None]):
 
         # Load current config with force_reload to get latest API keys
         config_manager = self.config_manager
-        config = config_manager.load(force_reload=True)
+        config = await config_manager.load(force_reload=True)
 
         # Log provider key status
         logger.debug(
@@ -111,7 +125,7 @@ class ModelPickerScreen(Screen[None]):
             config_manager._provider_has_api_key(config.shotgun),
         )
 
-        current_model = config.selected_model or ModelName.CLAUDE_SONNET_4_5
+        current_model = config.selected_model or get_default_model_for_provider(config)
         self.selected_model = current_model
         logger.debug("Current selected model: %s", current_model)
 
@@ -125,7 +139,7 @@ class ModelPickerScreen(Screen[None]):
         logger.debug("Removed %d existing model items from list", old_count)
 
         # Add new items (labels already have correct text including current indicator)
-        new_items = self._build_model_items(config)
+        new_items = await self._build_model_items(config)
         for item in new_items:
             list_view.append(item)
         logger.debug("Added %d available model items to list", len(new_items))
@@ -145,7 +159,7 @@ class ModelPickerScreen(Screen[None]):
     def on_show(self) -> None:
         """Rebuild model list when screen is first shown."""
         logger.debug("ModelPickerScreen.on_show() called")
-        self._rebuild_model_list()
+        self.run_worker(self._rebuild_model_list(), exclusive=False)
 
     def on_screenresume(self) -> None:
         """Rebuild model list when screen is resumed (subsequent visits).
@@ -154,7 +168,7 @@ class ModelPickerScreen(Screen[None]):
         ensuring the model list reflects any config changes made while away.
         """
         logger.debug("ModelPickerScreen.on_screenresume() called")
-        self._rebuild_model_list()
+        self.run_worker(self._rebuild_model_list(), exclusive=False)
 
     def action_done(self) -> None:
         self.dismiss()
@@ -185,15 +199,15 @@ class ModelPickerScreen(Screen[None]):
         app = cast("ShotgunApp", self.app)
         return app.config_manager
 
-    def refresh_model_labels(self) -> None:
+    async def refresh_model_labels(self) -> None:
         """Update the list view entries to reflect current selection.
 
         Note: This method only updates labels for currently displayed models.
         To rebuild the entire list after provider changes, on_show() should be used.
         """
         # Load config once with force_reload
-        config = self.config_manager.load(force_reload=True)
-        current_model = config.selected_model or ModelName.CLAUDE_SONNET_4_5
+        config = await self.config_manager.load(force_reload=True)
+        current_model = config.selected_model or get_default_model_for_provider(config)
 
         # Update labels for available models only
         for model_name in AVAILABLE_MODELS:
@@ -207,9 +221,11 @@ class ModelPickerScreen(Screen[None]):
                 self._model_label(model_name, is_current=model_name == current_model)
             )
 
-    def _build_model_items(self, config: ShotgunConfig | None = None) -> list[ListItem]:
+    async def _build_model_items(
+        self, config: ShotgunConfig | None = None
+    ) -> list[ListItem]:
         if config is None:
-            config = self.config_manager.load(force_reload=True)
+            config = await self.config_manager.load(force_reload=True)
 
         items: list[ListItem] = []
         current_model = self.selected_model
@@ -238,9 +254,7 @@ class ModelPickerScreen(Screen[None]):
                 return model_name
         return None
 
-    def _is_model_available(
-        self, model_name: ModelName, config: ShotgunConfig | None = None
-    ) -> bool:
+    def _is_model_available(self, model_name: ModelName, config: ShotgunConfig) -> bool:
         """Check if a model is available based on provider key configuration.
 
         A model is available if:
@@ -249,14 +263,11 @@ class ModelPickerScreen(Screen[None]):
 
         Args:
             model_name: The model to check availability for
-            config: Optional pre-loaded config to avoid multiple reloads
+            config: Pre-loaded config (must be provided)
 
         Returns:
             True if the model can be used, False otherwise
         """
-        if config is None:
-            config = self.config_manager.load(force_reload=True)
-
         # If Shotgun Account is configured, all models are available
         if self.config_manager._provider_has_api_key(config.shotgun):
             logger.debug("Model %s available (Shotgun Account configured)", model_name)
@@ -282,6 +293,12 @@ class ModelPickerScreen(Screen[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:
@@ -291,13 +308,13 @@ class ModelPickerScreen(Screen[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:
@@ -308,20 +325,48 @@ class ModelPickerScreen(Screen[None]):
     def _model_display_name(self, model_name: ModelName) -> str:
         """Get human-readable model name."""
         names = {
-            ModelName.GPT_5: "GPT-5 (OpenAI)",
-            ModelName.CLAUDE_OPUS_4_1: "Claude Opus 4.1 (Anthropic)",
+            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_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)",
+            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)
 
     def _select_model(self) -> None:
         """Save the selected model."""
+        self.run_worker(self._do_select_model(), exclusive=True)
+
+    async def _do_select_model(self) -> None:
+        """Async implementation of model selection."""
         try:
-            self.config_manager.update_selected_model(self.selected_model)
-            self.refresh_model_labels()
-            self.notify(
-                f"Selected model: {self._model_display_name(self.selected_model)}"
+            # Get old model before updating
+            config = await self.config_manager.load()
+            old_model = config.selected_model
+
+            # Update the selected model in config
+            await self.config_manager.update_selected_model(self.selected_model)
+            await self.refresh_model_labels()
+
+            # Get the full model config with provider information
+            model_config = await get_provider_model(self.selected_model)
+
+            # Dismiss the screen and return the model config update to the caller
+            self.dismiss(
+                ModelConfigUpdated(
+                    old_model=old_model,
+                    new_model=self.selected_model,
+                    provider=model_config.provider,
+                    key_provider=model_config.key_provider,
+                    model_config=model_config,
+                )
             )
         except Exception as exc:  # pragma: no cover - defensive; textual path
-            self.notify(f"Failed to select model: {exc}", severity="error")
+            status_label = self.query_one("#model-picker-status", Label)
+            status_label.update(f"❌ Failed to select model: {exc}")