shotgun-sh 0.2.1.dev3__tar.gz → 0.2.1.dev4__tar.gz

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.1.dev3
+Version: 0.2.1.dev4
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.2.1.dev3"
+version = "0.2.1.dev4"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/src/shotgun/agents/config/manager.py

@@ -46,13 +46,16 @@ class ConfigManager:
 
         self._config: ShotgunConfig | None = None
 
-    def load(self) -> ShotgunConfig:
+    def load(self, force_reload: bool = True) -> ShotgunConfig:
         """Load configuration from file.
 
+        Args:
+            force_reload: If True, reload from disk even if cached (default: True)
+
         Returns:
             ShotgunConfig: Loaded configuration or default config if file doesn't exist
         """
-        if self._config is not None:
+        if self._config is not None and not force_reload:
             return self._config
 
         if not self.config_path.exists():
@@ -243,7 +246,8 @@ class ConfigManager:
 
         This checks only the configuration file.
         """
-        config = self.load()
+        # Use force_reload=False to avoid infinite loop when called from load()
+        config = self.load(force_reload=False)
         provider_enum = self._ensure_provider_enum(provider)
         provider_config = self._get_provider_config(config, provider_enum)
 
@@ -251,7 +255,8 @@ class ConfigManager:
 
     def has_any_provider_key(self) -> bool:
         """Determine whether any provider has a configured API key."""
-        config = self.load()
+        # Use force_reload=False to avoid infinite loop when called from load()
+        config = self.load(force_reload=False)
         # Check LLM provider keys (BYOK)
         has_llm_key = any(
             self._provider_has_api_key(self._get_provider_config(config, provider))
@@ -381,6 +386,17 @@ class ConfigManager:
         return config.user_id
 
 
+# Global singleton instance
+_config_manager_instance: ConfigManager | None = None
+
+
 def get_config_manager() -> ConfigManager:
-    """Get the global ConfigManager instance."""
-    return ConfigManager()
+    """Get the global singleton ConfigManager instance.
+
+    Returns:
+        The singleton ConfigManager instance
+    """
+    global _config_manager_instance
+    if _config_manager_instance is None:
+        _config_manager_instance = ConfigManager()
+    return _config_manager_instance

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/src/shotgun/agents/config/provider.py

@@ -139,7 +139,8 @@ def get_provider_model(
         ValueError: If provider is not configured properly or model not found
     """
     config_manager = get_config_manager()
-    config = config_manager.load()
+    # Use cached config for read-only access (performance)
+    config = config_manager.load(force_reload=False)
 
     # Priority 1: Check if Shotgun key exists - if so, use it for ANY model
     shotgun_api_key = _get_api_key(config.shotgun.api_key)

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/src/shotgun/tui/app.py

@@ -64,7 +64,8 @@ class ShotgunApp(App[None]):
                 return
 
             self.push_screen(
-                "provider_config", callback=lambda _arg: self.refresh_startup_screen()
+                ProviderConfigScreen(),
+                callback=lambda _arg: self.refresh_startup_screen(),
             )
             return
 
@@ -73,7 +74,8 @@ class ShotgunApp(App[None]):
                 return
 
             self.push_screen(
-                "directory_setup", callback=lambda _arg: self.refresh_startup_screen()
+                DirectorySetupScreen(),
+                callback=lambda _arg: self.refresh_startup_screen(),
             )
             return
 
@@ -110,7 +112,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_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/src/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,11 +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("model_picker")
+        self.chat_screen.app.push_screen(ModelPickerScreen())
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
         yield DiscoveryHit(
@@ -282,11 +284,11 @@ class UnifiedCommandProvider(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("model_picker")
+        self.chat_screen.app.push_screen(ModelPickerScreen())
 
     async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
         """Provide commands in alphabetical order when palette opens."""

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/src/shotgun/tui/screens/model_picker.py

@@ -12,11 +12,14 @@ from textual.screen import Screen
 from textual.widgets import Button, Label, ListItem, ListView, Static
 
 from shotgun.agents.config import ConfigManager
-from shotgun.agents.config.models import MODEL_SPECS, ModelName
+from shotgun.agents.config.models import MODEL_SPECS, ModelName, ShotgunConfig
+from shotgun.logging_config import get_logger
 
 if TYPE_CHECKING:
     from ..app import ShotgunApp
 
+logger = get_logger(__name__)
+
 
 # Available models for selection
 AVAILABLE_MODELS = list(ModelName)
@@ -82,20 +85,52 @@ class ModelPickerScreen(Screen[None]):
                 "Select the AI model you want to use for your tasks.",
                 id="model-picker-summary",
             )
-        yield ListView(*self._build_model_items(), id="model-list")
+        yield ListView(id="model-list")
         with Horizontal(id="model-actions"):
             yield Button("Select \\[ENTER]", variant="primary", id="select")
             yield Button("Done \\[ESC]", id="done")
 
-    def on_mount(self) -> None:
-        # Load current selection
+    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
+        to ensure the list always reflects the current configuration.
+        """
+        logger.debug("Rebuilding model list from current config")
+
+        # Load current config with force_reload to get latest API keys
         config_manager = self.config_manager
-        config = config_manager.load()
+        config = config_manager.load(force_reload=True)
+
+        # Log provider key status
+        logger.debug(
+            "Provider keys: openai=%s, anthropic=%s, google=%s, shotgun=%s",
+            config_manager._provider_has_api_key(config.openai),
+            config_manager._provider_has_api_key(config.anthropic),
+            config_manager._provider_has_api_key(config.google),
+            config_manager._provider_has_api_key(config.shotgun),
+        )
+
         current_model = config.selected_model or ModelName.CLAUDE_SONNET_4_5
         self.selected_model = current_model
+        logger.debug("Current selected model: %s", current_model)
 
-        # Find and highlight current selection (if it's in the filtered list)
+        # Rebuild the model list with current available models
         list_view = self.query_one(ListView)
+
+        # Remove all existing items
+        old_count = len(list(list_view.children))
+        for child in list(list_view.children):
+            child.remove()
+        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)
+        for item in new_items:
+            list_view.append(item)
+        logger.debug("Added %d available model items to list", len(new_items))
+
+        # Find and highlight current selection (if it's in the filtered list)
         if list_view.children:
             for i, child in enumerate(list_view.children):
                 if isinstance(child, ListItem) and child.id:
@@ -106,7 +141,20 @@ class ModelPickerScreen(Screen[None]):
                             if model_name == current_model:
                                 list_view.index = i
                                 break
-        self.refresh_model_labels()
+
+    def on_show(self) -> None:
+        """Rebuild model list when screen is first shown."""
+        logger.debug("ModelPickerScreen.on_show() called")
+        self._rebuild_model_list()
+
+    def on_screenresume(self) -> None:
+        """Rebuild model list when screen is resumed (subsequent visits).
+
+        This is called when returning to the screen after it was suspended,
+        ensuring the model list reflects any config changes made while away.
+        """
+        logger.debug("ModelPickerScreen.on_screenresume() called")
+        self._rebuild_model_list()
 
     def action_done(self) -> None:
         self.dismiss()
@@ -138,13 +186,19 @@ class ModelPickerScreen(Screen[None]):
         return app.config_manager
 
     def refresh_model_labels(self) -> None:
-        """Update the list view entries to reflect current selection."""
-        current_model = (
-            self.config_manager.load().selected_model or ModelName.CLAUDE_SONNET_4_5
-        )
+        """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
+
         # Update labels for available models only
         for model_name in AVAILABLE_MODELS:
-            if not self._is_model_available(model_name):
+            # Pass config to avoid multiple force reloads
+            if not self._is_model_available(model_name, config):
                 continue
             label = self.query_one(
                 f"#label-{_sanitize_model_name_for_id(model_name)}", Label
@@ -153,12 +207,15 @@ class ModelPickerScreen(Screen[None]):
                 self._model_label(model_name, is_current=model_name == current_model)
             )
 
-    def _build_model_items(self) -> list[ListItem]:
+    def _build_model_items(self, config: ShotgunConfig | None = None) -> list[ListItem]:
+        if config is None:
+            config = self.config_manager.load(force_reload=True)
+
         items: list[ListItem] = []
         current_model = self.selected_model
         for model_name in AVAILABLE_MODELS:
             # Only add models that are available
-            if not self._is_model_available(model_name):
+            if not self._is_model_available(model_name, config):
                 continue
 
             label = Label(
@@ -181,7 +238,9 @@ class ModelPickerScreen(Screen[None]):
                 return model_name
         return None
 
-    def _is_model_available(self, model_name: ModelName) -> bool:
+    def _is_model_available(
+        self, model_name: ModelName, config: ShotgunConfig | None = None
+    ) -> bool:
         """Check if a model is available based on provider key configuration.
 
         A model is available if:
@@ -190,22 +249,38 @@ class ModelPickerScreen(Screen[None]):
 
         Args:
             model_name: The model to check availability for
+            config: Optional pre-loaded config to avoid multiple reloads
 
         Returns:
             True if the model can be used, False otherwise
         """
-        config = self.config_manager.load()
+        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)
             return True
 
         # In BYOK mode, check if the model's provider has a key
         if model_name not in MODEL_SPECS:
+            logger.debug("Model %s not available (not in MODEL_SPECS)", model_name)
             return False
 
         spec = MODEL_SPECS[model_name]
-        return self.config_manager.has_provider_key(spec.provider)
+        # Check provider key directly using the loaded config to avoid stale cache
+        provider_config = self.config_manager._get_provider_config(
+            config, spec.provider
+        )
+        has_key = self.config_manager._provider_has_api_key(provider_config)
+        logger.debug(
+            "Model %s available=%s (provider=%s, has_key=%s)",
+            model_name,
+            has_key,
+            spec.provider,
+            has_key,
+        )
+        return has_key
 
     def _model_label(self, model_name: ModelName, is_current: bool) -> str:
         """Generate label for model with specs and current indicator."""

{shotgun_sh-0.2.1.dev3 → shotgun_sh-0.2.1.dev4}/src/shotgun/tui/screens/provider_config.py

@@ -119,6 +119,13 @@ class ProviderConfigScreen(Screen[None]):
         self.selected_provider = "openai"
         self.set_focus(self.query_one("#api-key", Input))
 
+    def on_screenresume(self) -> None:
+        """Refresh provider status when screen is resumed.
+
+        This ensures the UI reflects any provider changes made elsewhere.
+        """
+        self.refresh_provider_status()
+
     def action_done(self) -> None:
         self.dismiss()