shotgun-sh 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

shotgun/agents/config/manager.py

@@ -142,7 +142,7 @@ class ConfigManager:
                             # Find default model for this provider
                             provider_models = {
                                 ProviderType.OPENAI: ModelName.GPT_5,
-                                ProviderType.ANTHROPIC: ModelName.CLAUDE_SONNET_4_5,
+                                ProviderType.ANTHROPIC: ModelName.CLAUDE_HAIKU_4_5,
                                 ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
                             }
 
@@ -243,7 +243,7 @@ class ConfigManager:
 
                 provider_models = {
                     ProviderType.OPENAI: ModelName.GPT_5,
-                    ProviderType.ANTHROPIC: ModelName.CLAUDE_SONNET_4_5,
+                    ProviderType.ANTHROPIC: ModelName.CLAUDE_HAIKU_4_5,
                     ProviderType.GOOGLE: ModelName.GEMINI_2_5_PRO,
                 }
                 if provider_enum in provider_models:

shotgun/agents/config/models.py

@@ -28,6 +28,7 @@ class ModelName(StrEnum):
     GPT_5_MINI = "gpt-5-mini"
     CLAUDE_OPUS_4_1 = "claude-opus-4-1"
     CLAUDE_SONNET_4_5 = "claude-sonnet-4-5"
+    CLAUDE_HAIKU_4_5 = "claude-haiku-4-5"
     GEMINI_2_5_PRO = "gemini-2.5-pro"
     GEMINI_2_5_FLASH = "gemini-2.5-flash"
 
@@ -110,6 +111,13 @@ MODEL_SPECS: dict[ModelName, ModelSpec] = {
         max_output_tokens=16_000,
         litellm_proxy_model_name="anthropic/claude-sonnet-4-5",
     ),
+    ModelName.CLAUDE_HAIKU_4_5: ModelSpec(
+        name=ModelName.CLAUDE_HAIKU_4_5,
+        provider=ProviderType.ANTHROPIC,
+        max_input_tokens=200_000,
+        max_output_tokens=64_000,
+        litellm_proxy_model_name="anthropic/claude-haiku-4-5",
+    ),
     ModelName.GEMINI_2_5_PRO: ModelSpec(
         name=ModelName.GEMINI_2_5_PRO,
         provider=ProviderType.GOOGLE,

shotgun/agents/config/provider.py

@@ -32,6 +32,34 @@ logger = get_logger(__name__)
 _model_cache: dict[tuple[ProviderType, KeyProvider, ModelName, str], Model] = {}
 
 
+def get_default_model_for_provider(config: ShotgunConfig) -> ModelName:
+    """Get the default model based on which provider/account is configured.
+
+    Checks API keys in priority order and returns appropriate default model.
+    Treats Shotgun Account as a provider context.
+
+    Args:
+        config: Shotgun configuration containing API keys
+
+    Returns:
+        Default ModelName for the configured provider/account
+    """
+    # Priority 1: Shotgun Account
+    if _get_api_key(config.shotgun.api_key):
+        return ModelName.CLAUDE_HAIKU_4_5
+
+    # Priority 2: Individual provider keys
+    if _get_api_key(config.anthropic.api_key):
+        return ModelName.CLAUDE_HAIKU_4_5
+    if _get_api_key(config.openai.api_key):
+        return ModelName.GPT_5
+    if _get_api_key(config.google.api_key):
+        return ModelName.GEMINI_2_5_PRO
+
+    # Fallback: system-wide default
+    return ModelName.CLAUDE_HAIKU_4_5
+
+
 def get_or_create_model(
     provider: ProviderType,
     key_provider: "KeyProvider",
@@ -172,7 +200,7 @@ def get_provider_model(
             model_name = provider_or_model
         else:
             # No specific model requested - use selected or default
-            model_name = config.selected_model or ModelName.CLAUDE_SONNET_4_5
+            model_name = config.selected_model or ModelName.CLAUDE_HAIKU_4_5
 
         if model_name not in MODEL_SPECS:
             raise ValueError(f"Model '{model_name.value}' not found")
@@ -247,8 +275,8 @@ def get_provider_model(
         if not api_key:
             raise ValueError("Anthropic API key not configured. Set via config.")
 
-        # Use requested model or default to claude-sonnet-4-5
-        model_name = requested_model if requested_model else ModelName.CLAUDE_SONNET_4_5
+        # Use requested model or default to claude-haiku-4-5
+        model_name = requested_model if requested_model else ModelName.CLAUDE_HAIKU_4_5
         if model_name not in MODEL_SPECS:
             raise ValueError(f"Model '{model_name.value}' not found")
         spec = MODEL_SPECS[model_name]

shotgun/api_endpoints.py

@@ -1,10 +1,16 @@
 """Shotgun backend service API endpoints and URLs."""
 
+import os
+
 # Shotgun Web API base URL (for authentication/subscription)
 # Can be overridden with environment variable
-SHOTGUN_WEB_BASE_URL = "https://api-219702594231.us-east4.run.app"
+SHOTGUN_WEB_BASE_URL = os.getenv(
+    "SHOTGUN_WEB_BASE_URL", "https://api-219702594231.us-east4.run.app"
+)
 # Shotgun's LiteLLM proxy base URL (for AI model requests)
-LITELLM_PROXY_BASE_URL = "https://litellm-219702594231.us-east4.run.app"
+LITELLM_PROXY_BASE_URL = os.getenv(
+    "SHOTGUN_ACCOUNT_LLM_BASE_URL", "https://litellm-219702594231.us-east4.run.app"
+)
 
 # Provider-specific LiteLLM proxy endpoints
 LITELLM_PROXY_ANTHROPIC_BASE = f"{LITELLM_PROXY_BASE_URL}/anthropic"

shotgun/cli/update.py

@@ -45,7 +45,7 @@ def update(
 
     This command will:
     - Check PyPI for the latest version
-    - Detect your installation method (pipx, pip, or venv)
+    - Detect your installation method (uvx, uv-tool, pipx, pip, or venv)
     - Perform the appropriate upgrade command
 
     Examples:
@@ -93,6 +93,8 @@ def update(
         )
         console.print(
             "Use --force to update anyway, or install the stable version with:\n"
+            "  uv tool install shotgun-sh\n"
+            "  or\n"
             "  pipx install shotgun-sh\n"
             "  or\n"
             "  pip install shotgun-sh",
@@ -134,7 +136,19 @@ def update(
             console.print(f"\n[red]✗[/red] {message}", style="bold red")
 
             # Provide manual update instructions
-            if method == "pipx":
+            if method == "uvx":
+                console.print(
+                    "\n[yellow]Run uvx again to use the latest version:[/yellow]\n"
+                    "  uvx shotgun-sh\n"
+                    "\n[yellow]Or install permanently:[/yellow]\n"
+                    "  uv tool install shotgun-sh"
+                )
+            elif method == "uv-tool":
+                console.print(
+                    "\n[yellow]Try updating manually:[/yellow]\n"
+                    "  uv tool upgrade shotgun-sh"
+                )
+            elif method == "pipx":
                 console.print(
                     "\n[yellow]Try updating manually:[/yellow]\n"
                     "  pipx upgrade shotgun-sh"

shotgun/codebase/core/manager.py

@@ -371,7 +371,16 @@ class CodebaseGraphManager:
                 )
                 import shutil
 
-                shutil.rmtree(graph_path)
+                # Handle both files and directories (kuzu v0.11.2+ uses files)
+                if graph_path.is_file():
+                    graph_path.unlink()  # Delete file
+                    # Also delete WAL file if it exists
+                    wal_path = graph_path.with_suffix(graph_path.suffix + ".wal")
+                    if wal_path.exists():
+                        wal_path.unlink()
+                        logger.debug(f"Deleted WAL file: {wal_path}")
+                else:
+                    shutil.rmtree(graph_path)  # Delete directory
 
         # Import the builder from local core module
         from shotgun.codebase.core import CodebaseIngestor

shotgun/main.py

@@ -125,6 +125,41 @@ def main(
             help="Continue previous TUI conversation",
         ),
     ] = False,
+    web: Annotated[
+        bool,
+        typer.Option(
+            "--web",
+            help="Serve TUI as web application",
+        ),
+    ] = False,
+    port: Annotated[
+        int,
+        typer.Option(
+            "--port",
+            help="Port for web server (only used with --web)",
+        ),
+    ] = 8000,
+    host: Annotated[
+        str,
+        typer.Option(
+            "--host",
+            help="Host address for web server (only used with --web)",
+        ),
+    ] = "localhost",
+    public_url: Annotated[
+        str | None,
+        typer.Option(
+            "--public-url",
+            help="Public URL if behind proxy (only used with --web)",
+        ),
+    ] = None,
+    force_reindex: Annotated[
+        bool,
+        typer.Option(
+            "--force-reindex",
+            help="Force re-indexing of codebase (ignores existing index)",
+        ),
+    ] = False,
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
@@ -134,16 +169,35 @@ def main(
         perform_auto_update_async(no_update_check=no_update_check)
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
-        logger.debug("Launching shotgun TUI application")
-        try:
-            tui_app.run(
-                no_update_check=no_update_check, continue_session=continue_session
-            )
-        finally:
-            # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
-            from shotgun.posthog_telemetry import shutdown
-
-            shutdown()
+        if web:
+            logger.debug("Launching shotgun TUI as web application")
+            try:
+                tui_app.serve(
+                    host=host,
+                    port=port,
+                    public_url=public_url,
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if server exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
+        else:
+            logger.debug("Launching shotgun TUI application")
+            try:
+                tui_app.run(
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
         raise typer.Exit()
 
     # For CLI commands, register PostHog shutdown handler

shotgun/tui/app.py

@@ -9,12 +9,16 @@ from shotgun.agents.config import ConfigManager, get_config_manager
 from shotgun.logging_config import get_logger
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.file_system_utils import get_shotgun_base_path
-from shotgun.utils.update_checker import perform_auto_update_async
+from shotgun.utils.update_checker import (
+    detect_installation_method,
+    perform_auto_update_async,
+)
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
 from .screens.feedback import FeedbackScreen
 from .screens.model_picker import ModelPickerScreen
+from .screens.pipx_migration import PipxMigrationScreen
 from .screens.provider_config import ProviderConfigScreen
 from .screens.welcome import WelcomeScreen
 
@@ -36,12 +40,16 @@ class ShotgunApp(App[None]):
     CSS_PATH = "styles.tcss"
 
     def __init__(
-        self, no_update_check: bool = False, continue_session: bool = False
+        self,
+        no_update_check: bool = False,
+        continue_session: bool = False,
+        force_reindex: bool = False,
     ) -> 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
 
         # Start async update check and install
         if not no_update_check:
@@ -52,14 +60,35 @@ class ShotgunApp(App[None]):
         # Track TUI startup
         from shotgun.posthog_telemetry import track_event
 
-        track_event("tui_started", {})
+        track_event(
+            "tui_started",
+            {
+                "installation_method": detect_installation_method(),
+            },
+        )
 
         self.push_screen(
             SplashScreen(), callback=lambda _arg: self.refresh_startup_screen()
         )
 
-    def refresh_startup_screen(self) -> None:
+    def refresh_startup_screen(self, skip_pipx_check: bool = False) -> None:
         """Push the appropriate screen based on configured providers."""
+        # Check for pipx installation and show migration modal first
+        if not skip_pipx_check:
+            installation_method = detect_installation_method()
+            if installation_method == "pipx":
+                if isinstance(self.screen, PipxMigrationScreen):
+                    return
+
+                # Show pipx migration modal as a blocking modal screen
+                self.push_screen(
+                    PipxMigrationScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(
+                        skip_pipx_check=True
+                    ),
+                )
+                return
+
         # Show welcome screen if no providers are configured OR if user hasn't seen it yet
         config = self.config_manager.load()
         if (
@@ -87,8 +116,12 @@ class ShotgunApp(App[None]):
 
         if isinstance(self.screen, ChatScreen):
             return
-        # Pass continue_session flag to ChatScreen
-        self.push_screen(ChatScreen(continue_session=self.continue_session))
+        # Pass continue_session and force_reindex flags to ChatScreen
+        self.push_screen(
+            ChatScreen(
+                continue_session=self.continue_session, force_reindex=self.force_reindex
+            )
+        )
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -121,12 +154,17 @@ class ShotgunApp(App[None]):
         self.push_screen(FeedbackScreen(), callback=handle_feedback)
 
 
-def run(no_update_check: bool = False, continue_session: bool = False) -> None:
+def run(
+    no_update_check: bool = False,
+    continue_session: bool = False,
+    force_reindex: bool = False,
+) -> None:
     """Run the TUI application.
 
     Args:
         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).
     """
     # Clean up any corrupted databases BEFORE starting the TUI
     # This prevents crashes from corrupted databases during initialization
@@ -148,9 +186,133 @@ def run(no_update_check: bool = False, continue_session: bool = False) -> None:
         logger.error(f"Failed to cleanup corrupted databases: {e}")
         # Continue anyway - the TUI can still function
 
-    app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
+    app = ShotgunApp(
+        no_update_check=no_update_check,
+        continue_session=continue_session,
+        force_reindex=force_reindex,
+    )
     app.run(inline_no_clear=True)
 
 
+def serve(
+    host: str = "localhost",
+    port: int = 8000,
+    public_url: str | None = None,
+    no_update_check: bool = False,
+    continue_session: bool = False,
+    force_reindex: bool = False,
+) -> None:
+    """Serve the TUI application as a web application.
+
+    Args:
+        host: Host address for the web server.
+        port: Port number for the web server.
+        public_url: Public URL if behind a proxy.
+        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).
+    """
+    # Clean up any corrupted databases BEFORE starting the TUI
+    # This prevents crashes from corrupted databases during initialization
+    import asyncio
+
+    from textual_serve.server import Server
+
+    from shotgun.codebase.core.manager import CodebaseGraphManager
+    from shotgun.utils import get_shotgun_home
+
+    storage_dir = get_shotgun_home() / "codebases"
+    manager = CodebaseGraphManager(storage_dir)
+
+    try:
+        removed = asyncio.run(manager.cleanup_corrupted_databases())
+        if removed:
+            logger.info(
+                f"Cleaned up {len(removed)} corrupted database(s) before TUI startup"
+            )
+    except Exception as e:
+        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        # Continue anyway - the TUI can still function
+
+    # Create a new event loop after asyncio.run() closes the previous one
+    # This is needed for the Server.serve() method
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    # Build the command string based on flags
+    command = "shotgun"
+    if no_update_check:
+        command += " --no-update-check"
+    if continue_session:
+        command += " --continue"
+    if force_reindex:
+        command += " --force-reindex"
+
+    # Create and start the server with hardcoded title and debug=False
+    server = Server(
+        command=command,
+        host=host,
+        port=port,
+        title="The Shotgun",
+        public_url=public_url,
+    )
+
+    # Set up graceful shutdown on SIGTERM/SIGINT
+    import signal
+    import sys
+
+    def signal_handler(_signum: int, _frame: Any) -> None:
+        """Handle shutdown signals gracefully."""
+        from shotgun.posthog_telemetry import shutdown
+
+        logger.info("Received shutdown signal, cleaning up...")
+        # Restore stdout/stderr before shutting down
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        shutdown()
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Suppress the textual-serve banner by redirecting stdout/stderr
+    import io
+
+    # Capture and suppress the banner, but show the actual serving URL
+    original_stdout = sys.stdout
+    original_stderr = sys.stderr
+
+    captured_output = io.StringIO()
+    sys.stdout = captured_output
+    sys.stderr = captured_output
+
+    try:
+        # This will print the banner to our captured output
+        import logging
+
+        # Temporarily set logging to ERROR level to suppress INFO messages
+        textual_serve_logger = logging.getLogger("textual_serve")
+        original_level = textual_serve_logger.level
+        textual_serve_logger.setLevel(logging.ERROR)
+
+        # Print our own message to the original stdout
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        print(f"Serving Shotgun TUI at http://{host}:{port}")
+        print("Press Ctrl+C to quit")
+
+        # Now suppress output again for the serve call
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        server.serve(debug=False)
+    finally:
+        # Restore original stdout/stderr
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        if "textual_serve_logger" in locals():
+            textual_serve_logger.setLevel(original_level)
+
+
 if __name__ == "__main__":
     run()

shotgun/tui/screens/chat.py

@@ -39,7 +39,10 @@ from shotgun.agents.models import (
     AgentType,
     FileOperationTracker,
 )
-from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
+from shotgun.codebase.core.manager import (
+    CodebaseAlreadyIndexedError,
+    CodebaseGraphManager,
+)
 from shotgun.codebase.models import IndexProgress, ProgressPhase
 from shotgun.posthog_telemetry import track_event
 from shotgun.sdk.codebase import CodebaseSDK
@@ -291,7 +294,9 @@ class ChatScreen(Screen[None]):
     qa_current_index = reactive(0)
     qa_answers: list[str] = []
 
-    def __init__(self, continue_session: bool = False) -> None:
+    def __init__(
+        self, continue_session: bool = False, force_reindex: bool = False
+    ) -> None:
         super().__init__()
         # Get the model configuration and services
         model_config = get_provider_model()
@@ -319,6 +324,7 @@ class ChatScreen(Screen[None]):
         self.placeholder_hints = PlaceholderHints()
         self.conversation_manager = ConversationManager()
         self.continue_session = continue_session
+        self.force_reindex = force_reindex
 
     def on_mount(self) -> None:
         self.query_one(PromptInput).focus(scroll_visible=True)
@@ -378,6 +384,22 @@ class ChatScreen(Screen[None]):
         if is_empty or self.continue_session:
             return
 
+        # If force_reindex is True, delete any existing graphs for this directory
+        if self.force_reindex:
+            accessible_graphs = (
+                await self.codebase_sdk.list_codebases_for_directory()
+            ).graphs
+            for graph in accessible_graphs:
+                try:
+                    await self.codebase_sdk.delete_codebase(graph.graph_id)
+                    logger.info(
+                        f"Deleted existing graph {graph.graph_id} due to --force-reindex"
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to delete graph {graph.graph_id} during force reindex: {e}"
+                    )
+
         # Check if the current directory has any accessible codebases
         accessible_graphs = (
             await self.codebase_sdk.list_codebases_for_directory()
@@ -766,6 +788,28 @@ class ChatScreen(Screen[None]):
         except Exception as exc:  # pragma: no cover - defensive UI path
             self.notify(f"Failed to delete codebase: {exc}", severity="error")
 
+    def _is_kuzu_corruption_error(self, exception: Exception) -> bool:
+        """Check if error is related to kuzu database corruption.
+
+        Args:
+            exception: The exception to check
+
+        Returns:
+            True if the error indicates kuzu database corruption
+        """
+        error_str = str(exception).lower()
+        error_indicators = [
+            "not a directory",
+            "errno 20",
+            "corrupted",
+            ".kuzu",
+            "ioexception",
+            "unordered_map",  # C++ STL map errors from kuzu
+            "key not found",  # unordered_map::at errors
+            "std::exception",  # Generic C++ exceptions from kuzu
+        ]
+        return any(indicator in error_str for indicator in error_indicators)
+
     @work
     async def index_codebase(self, selection: CodebaseIndexSelection) -> None:
         label = self.query_one("#indexing-job-display", Static)
@@ -834,58 +878,96 @@ class ChatScreen(Screen[None]):
         # Start progress animation timer (10 fps = 100ms interval)
         progress_timer = self.set_interval(0.1, update_progress_display)
 
-        try:
-            # Pass the current working directory as the indexed_from_cwd
-            logger.debug(
-                f"Starting indexing - repo_path: {selection.repo_path}, "
-                f"name: {selection.name}, cwd: {Path.cwd().resolve()}"
-            )
-            result = await self.codebase_sdk.index_codebase(
-                selection.repo_path,
-                selection.name,
-                indexed_from_cwd=str(Path.cwd().resolve()),
-                progress_callback=progress_callback,
-            )
+        # Retry logic for handling kuzu corruption
+        max_retries = 3
+
+        for attempt in range(max_retries):
+            try:
+                # Clean up corrupted DBs before retry (skip on first attempt)
+                if attempt > 0:
+                    logger.info(
+                        f"Retry attempt {attempt + 1}/{max_retries} - cleaning up corrupted databases"
+                    )
+                    manager = CodebaseGraphManager(
+                        self.codebase_sdk.service.storage_dir
+                    )
+                    cleaned = await manager.cleanup_corrupted_databases()
+                    logger.info(f"Cleaned up {len(cleaned)} corrupted database(s)")
+                    self.notify(
+                        f"Retrying indexing after cleanup (attempt {attempt + 1}/{max_retries})...",
+                        severity="information",
+                    )
 
-            # Stop progress animation
-            progress_timer.stop()
+                # Pass the current working directory as the indexed_from_cwd
+                logger.debug(
+                    f"Starting indexing - repo_path: {selection.repo_path}, "
+                    f"name: {selection.name}, cwd: {Path.cwd().resolve()}"
+                )
+                result = await self.codebase_sdk.index_codebase(
+                    selection.repo_path,
+                    selection.name,
+                    indexed_from_cwd=str(Path.cwd().resolve()),
+                    progress_callback=progress_callback,
+                )
 
-            # Show 100% completion after indexing finishes
-            final_bar = create_progress_bar(100.0)
-            label.update(f"[$foreground-muted]Indexing codebase: {final_bar} 100%[/]")
-            label.refresh()
+                # Success! Stop progress animation
+                progress_timer.stop()
 
-            logger.info(
-                f"Successfully indexed codebase '{result.name}' (ID: {result.graph_id})"
-            )
-            self.notify(
-                f"Indexed codebase '{result.name}' (ID: {result.graph_id})",
-                severity="information",
-                timeout=8,
-            )
+                # Show 100% completion after indexing finishes
+                final_bar = create_progress_bar(100.0)
+                label.update(
+                    f"[$foreground-muted]Indexing codebase: {final_bar} 100%[/]"
+                )
+                label.refresh()
 
-        except CodebaseAlreadyIndexedError as exc:
-            progress_timer.stop()
-            logger.warning(f"Codebase already indexed: {exc}")
-            self.notify(str(exc), severity="warning")
-            return
-        except InvalidPathError as exc:
-            progress_timer.stop()
-            logger.error(f"Invalid path error: {exc}")
-            self.notify(str(exc), severity="error")
+                logger.info(
+                    f"Successfully indexed codebase '{result.name}' (ID: {result.graph_id})"
+                )
+                self.notify(
+                    f"Indexed codebase '{result.name}' (ID: {result.graph_id})",
+                    severity="information",
+                    timeout=8,
+                )
+                break  # Success - exit retry loop
+
+            except CodebaseAlreadyIndexedError as exc:
+                progress_timer.stop()
+                logger.warning(f"Codebase already indexed: {exc}")
+                self.notify(str(exc), severity="warning")
+                return
+            except InvalidPathError as exc:
+                progress_timer.stop()
+                logger.error(f"Invalid path error: {exc}")
+                self.notify(str(exc), severity="error")
+                return
+
+            except Exception as exc:  # pragma: no cover - defensive UI path
+                # Check if this is a kuzu corruption error and we have retries left
+                if attempt < max_retries - 1 and self._is_kuzu_corruption_error(exc):
+                    logger.warning(
+                        f"Kuzu corruption detected on attempt {attempt + 1}/{max_retries}: {exc}. "
+                        f"Will retry after cleanup..."
+                    )
+                    # Exponential backoff: 1s, 2s
+                    await asyncio.sleep(2**attempt)
+                    continue
+
+                # Either final retry failed OR not a corruption error - show error
+                logger.exception(
+                    f"Failed to index codebase after {attempt + 1} attempts - "
+                    f"repo_path: {selection.repo_path}, name: {selection.name}, error: {exc}"
+                )
+                self.notify(
+                    f"Failed to index codebase after {attempt + 1} attempts: {exc}",
+                    severity="error",
+                    timeout=30,  # Keep error visible for 30 seconds
+                )
+                break
 
-        except Exception as exc:  # pragma: no cover - defensive UI path
-            # Log full exception details with stack trace
-            logger.exception(
-                f"Failed to index codebase - repo_path: {selection.repo_path}, "
-                f"name: {selection.name}, error: {exc}"
-            )
-            self.notify(f"Failed to index codebase: {exc}", severity="error")
-        finally:
-            # Always stop the progress timer
-            progress_timer.stop()
-            label.update("")
-            label.refresh()
+        # Always stop the progress timer and clean up label
+        progress_timer.stop()
+        label.update("")
+        label.refresh()
 
     @work
     async def run_agent(self, message: str) -> None:

shotgun/tui/screens/model_picker.py

@@ -13,6 +13,7 @@ from textual.widgets import Button, Label, ListItem, ListView, Static
 
 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
 from shotgun.logging_config import get_logger
 
 if TYPE_CHECKING:
@@ -111,7 +112,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)
 
@@ -193,7 +194,7 @@ class ModelPickerScreen(Screen[None]):
         """
         # 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
+        current_model = config.selected_model or get_default_model_for_provider(config)
 
         # Update labels for available models only
         for model_name in AVAILABLE_MODELS:

shotgun/tui/screens/pipx_migration.py

@@ -0,0 +1,153 @@
+"""Migration notice screen for pipx users."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Markdown
+
+if TYPE_CHECKING:
+    pass
+
+
+class PipxMigrationScreen(ModalScreen[None]):
+    """Modal screen warning pipx users about migration to uvx."""
+
+    CSS = """
+        PipxMigrationScreen {
+            align: center middle;
+        }
+
+        #migration-container {
+            width: 90;
+            height: auto;
+            max-height: 90%;
+            border: thick $error;
+            background: $surface;
+            padding: 2;
+        }
+
+        #migration-content {
+            height: 1fr;
+            padding: 1 0;
+        }
+
+        #buttons-container {
+            height: auto;
+            padding: 2 0 1 0;
+        }
+
+        #action-buttons {
+            width: 100%;
+            height: auto;
+            align: center middle;
+        }
+
+        .action-button {
+            margin: 0 1;
+            min-width: 20;
+        }
+    """
+
+    BINDINGS = [
+        ("escape", "dismiss", "Continue Anyway"),
+        ("ctrl+c", "app.quit", "Quit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        """Compose the migration notice modal."""
+        with Container(id="migration-container"):
+            with VerticalScroll(id="migration-content"):
+                yield Markdown(
+                    """
+## We've Switched to uvx
+
+We've switched from `pipx` to `uvx` as the primary installation method due to critical build issues with our `kuzu` dependency.
+
+### The Problem
+Users with pipx encounter cmake build errors during installation because pip falls back to building from source instead of using pre-built binary wheels.
+
+### The Solution: uvx
+- ✅ **No build tools required** - Binary wheels enforced
+- ✅ **10-100x faster** - Much faster than pipx
+- ✅ **Better reliability** - No cmake/build errors
+
+### How to Migrate
+
+**1. Uninstall shotgun-sh from pipx:**
+```bash
+pipx uninstall shotgun-sh
+```
+
+**2. Install uv:**
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+Or with Homebrew: `brew install uv`
+
+**3. Run shotgun-sh with uvx:**
+```bash
+uvx shotgun-sh
+```
+Or install permanently: `uv tool install shotgun-sh`
+
+---
+
+### Need Help?
+
+**Discord:** https://discord.gg/5RmY6J2N7s
+
+**Full Migration Guide:** https://github.com/shotgun-sh/shotgun/blob/main/PIPX_MIGRATION.md
+"""
+                )
+
+                with Container(id="buttons-container"):
+                    with Horizontal(id="action-buttons"):
+                        yield Button(
+                            "Copy Instructions to Clipboard",
+                            variant="default",
+                            id="copy-instructions",
+                            classes="action-button",
+                        )
+                        yield Button(
+                            "Continue Anyway",
+                            variant="primary",
+                            id="continue",
+                            classes="action-button",
+                        )
+
+    def on_mount(self) -> None:
+        """Focus the continue button and ensure scroll starts at top."""
+        self.query_one("#continue", Button).focus()
+        self.query_one("#migration-content", VerticalScroll).scroll_home(animate=False)
+
+    @on(Button.Pressed, "#copy-instructions")
+    def _copy_instructions(self) -> None:
+        """Copy all migration instructions to clipboard."""
+        instructions = """# Step 1: Uninstall from pipx
+pipx uninstall shotgun-sh
+
+# Step 2: Install uv
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Step 3: Run shotgun with uvx
+uvx shotgun-sh"""
+        try:
+            import pyperclip  # type: ignore[import-untyped]  # noqa: PGH003
+
+            pyperclip.copy(instructions)
+            self.notify("Copied migration instructions to clipboard!")
+        except ImportError:
+            self.notify(
+                "Clipboard not available. See instructions above.",
+                severity="warning",
+            )
+
+    @on(Button.Pressed, "#continue")
+    def _continue(self) -> None:
+        """Dismiss the modal and continue."""
+        self.dismiss()

shotgun/utils/update_checker.py

@@ -1,5 +1,6 @@
 """Simple auto-update functionality for shotgun-sh CLI."""
 
+import os
 import subprocess
 import sys
 import threading
@@ -18,8 +19,34 @@ def detect_installation_method() -> str:
     """Detect how shotgun-sh was installed.
 
     Returns:
-        Installation method: 'pipx', 'pip', 'venv', or 'unknown'.
+        Installation method: 'uvx', 'uv-tool', 'pipx', 'pip', 'venv', or 'unknown'.
     """
+    # Check for simulation environment variable (for testing)
+    if os.getenv("PIPX_SIMULATE", "").lower() in ("true", "1"):
+        logger.debug("PIPX_SIMULATE enabled, simulating pipx installation")
+        return "pipx"
+
+    # Check for uvx (ephemeral execution) by looking at executable path
+    # uvx runs from a temporary cache directory
+    executable = Path(sys.executable)
+    if ".cache/uv" in str(executable) or "uv/cache" in str(executable):
+        logger.debug("Detected uvx (ephemeral) execution")
+        return "uvx"
+
+    # Check for uv tool installation
+    try:
+        result = subprocess.run(
+            ["uv", "tool", "list"],  # noqa: S607, S603
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0 and "shotgun-sh" in result.stdout:
+            logger.debug("Detected uv tool installation")
+            return "uv-tool"
+    except (subprocess.SubprocessError, FileNotFoundError):
+        pass
+
     # Check for pipx installation
     try:
         result = subprocess.run(
@@ -59,7 +86,7 @@ def detect_installation_method() -> str:
 
 
 def perform_auto_update(no_update_check: bool = False) -> None:
-    """Perform automatic update if installed via pipx.
+    """Perform automatic update if installed via pipx or uv tool.
 
     Args:
         no_update_check: If True, skip the update.
@@ -68,23 +95,40 @@ def perform_auto_update(no_update_check: bool = False) -> None:
         return
 
     try:
-        # Only auto-update for pipx installations
-        if detect_installation_method() != "pipx":
-            logger.debug("Not a pipx installation, skipping auto-update")
+        method = detect_installation_method()
+
+        # Skip auto-update for ephemeral uvx executions
+        if method == "uvx":
+            logger.debug("uvx (ephemeral) execution, skipping auto-update")
             return
 
-        # Run pipx upgrade quietly
-        logger.debug("Running pipx upgrade shotgun-sh --quiet")
-        result = subprocess.run(
-            ["pipx", "upgrade", "shotgun-sh", "--quiet"],  # noqa: S607, S603
+        # Only auto-update for pipx and uv-tool installations
+        if method not in ["pipx", "uv-tool"]:
+            logger.debug(f"Installation method '{method}', skipping auto-update")
+            return
+
+        # Determine the appropriate upgrade command
+        if method == "pipx":
+            command = ["pipx", "upgrade", "shotgun-sh", "--quiet"]
+            logger.debug("Running pipx upgrade shotgun-sh --quiet")
+        elif method == "uv-tool":
+            command = ["uv", "tool", "upgrade", "shotgun-sh"]
+            logger.debug("Running uv tool upgrade shotgun-sh")
+        else:
+            return
+
+        # Run upgrade command
+        result = subprocess.run(  # noqa: S603, S607
+            command,
             capture_output=True,
             text=True,
             timeout=30,
         )
 
         if result.returncode == 0:
-            # Check if there was an actual update (pipx shows output even with --quiet for actual updates)
-            if result.stdout and "upgraded" in result.stdout.lower():
+            # Check if there was an actual update
+            output = result.stdout.lower()
+            if "upgraded" in output or "updated" in output:
                 logger.info("Shotgun-sh has been updated to the latest version")
         else:
             # Only log errors at debug level to not annoy users
@@ -166,16 +210,18 @@ def compare_versions(current: str, latest: str) -> bool:
         return False
 
 
-def get_update_command(method: str) -> list[str]:
+def get_update_command(method: str) -> list[str] | None:
     """Get the appropriate update command based on installation method.
 
     Args:
-        method: Installation method ('pipx', 'pip', 'venv', or 'unknown').
+        method: Installation method ('uvx', 'uv-tool', 'pipx', 'pip', 'venv', or 'unknown').
 
     Returns:
-        Command list to execute for updating.
+        Command list to execute for updating, or None for uvx (ephemeral).
     """
     commands = {
+        "uvx": None,  # uvx is ephemeral, no update command
+        "uv-tool": ["uv", "tool", "upgrade", "shotgun-sh"],
         "pipx": ["pipx", "upgrade", "shotgun-sh"],
         "pip": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
         "venv": [sys.executable, "-m", "pip", "install", "--upgrade", "shotgun-sh"],
@@ -210,6 +256,15 @@ def perform_update(force: bool = False) -> tuple[bool, str]:
     method = detect_installation_method()
     command = get_update_command(method)
 
+    # Handle uvx (ephemeral) installations
+    if method == "uvx" or command is None:
+        return (
+            False,
+            "You're running shotgun-sh via uvx (ephemeral mode). "
+            "To get the latest version, simply run 'uvx shotgun-sh' again, "
+            "or install permanently with 'uv tool install shotgun-sh'.",
+        )
+
     # Perform update
     try:
         logger.info(f"Updating shotgun-sh using {method}...")

{shotgun_sh-0.2.9.dist-info → shotgun_sh-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.9
+Version: 0.2.10
 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
@@ -26,7 +26,7 @@ Requires-Dist: genai-prices>=0.0.27
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: kuzu>=0.7.0
-Requires-Dist: logfire[pydantic-ai]>=2.0.0
+Requires-Dist: logfire>=2.0.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: packaging>=23.0
 Requires-Dist: posthog>=3.0.0
@@ -36,6 +36,7 @@ Requires-Dist: sentencepiece>=0.2.0
 Requires-Dist: sentry-sdk[pure-eval]>=2.0.0
 Requires-Dist: tenacity>=8.0.0
 Requires-Dist: textual-dev>=1.7.0
+Requires-Dist: textual-serve>=0.1.0
 Requires-Dist: textual>=6.1.0
 Requires-Dist: tiktoken>=0.7.0
 Requires-Dist: tree-sitter-go>=0.23.0
@@ -83,13 +84,30 @@ Every research finding, every architectural decision, every "here's why we didn'
 
 ## Installation
 
-### Using pipx (Recommended)
+### Using uvx (Recommended)
+
+**Quick start (ephemeral):**
+```bash
+uvx shotgun-sh
+```
+
+**Install permanently:**
+```bash
+uv tool install shotgun-sh
+```
+
+**Why uvx?** It's 10-100x faster than pipx and handles binary wheels more reliably. If you don't have `uv` installed, get it at [astral.sh/uv](https://astral.sh/uv) or `curl -LsSf https://astral.sh/uv/install.sh | sh`
+
+### Using pipx
 
 ```bash
 pipx install shotgun-sh
 ```
 
-**Why pipx?** It installs Shotgun in an isolated environment, preventing dependency conflicts with your other Python projects.
+If you encounter build errors with kuzu on macOS:
+```bash
+pipx install --pip-args="--only-binary kuzu" shotgun-sh
+```
 
 ### Using pip
 

{shotgun_sh-0.2.9.dist-info → shotgun_sh-0.2.10.dist-info}/RECORD

@@ -1,8 +1,8 @@
 shotgun/__init__.py,sha256=P40K0fnIsb7SKcQrFnXZ4aREjpWchVDhvM1HxI4cyIQ,104
-shotgun/api_endpoints.py,sha256=TvxuJyMrZLy6KZTrR6lrdkG8OBtb3TJ48qaw3pWitO0,526
+shotgun/api_endpoints.py,sha256=fBMTAQDyDXFY622MSrya5i_0ur_KYrCNg6wMf7QJVb4,627
 shotgun/build_constants.py,sha256=hDFr6eO0lwN0iCqHQ1A5s0D68txR8sYrTJLGa7tSi0o,654
 shotgun/logging_config.py,sha256=UKenihvgH8OA3W0b8ZFcItYaFJVe9MlsMYlcevyW1HY,7440
-shotgun/main.py,sha256=RA3q1xPfqxCu43UmgI2ryZpA-IxPhJb_MJrbLqp9c_g,5140
+shotgun/main.py,sha256=4HLlnSmkVdm97yFCsXpY7d598xkOL7jtJLTq5sHPzrs,6762
 shotgun/posthog_telemetry.py,sha256=TOiyBtLg21SttHGWKc4-e-PQgpbq6Uz_4OzlvlxMcZ0,6099
 shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/sentry_telemetry.py,sha256=VD8es-tREfgtRKhDsEVvqpo0_kM_ab6iVm2lkOEmTlI,2950
@@ -23,9 +23,9 @@ shotgun/agents/tasks.py,sha256=AuriwtDn6uZz2G0eKfqBHYQrxYfJlbiAd-fcsw9lU3I,2949
 shotgun/agents/usage_manager.py,sha256=5d9JC4_cthXwhTSytMfMExMDAUYp8_nkPepTJZXk13w,5017
 shotgun/agents/config/__init__.py,sha256=Fl8K_81zBpm-OfOW27M_WWLSFdaHHek6lWz95iDREjQ,318
 shotgun/agents/config/constants.py,sha256=JNuLpeBUKikEsxGSjwX3RVWUQpbCKnDKstF2NczuDqk,932
-shotgun/agents/config/manager.py,sha256=WO3TOwXCSOa7e3s_rmvH74jGw7xTqA_OaGhNaUsZ0a4,18922
-shotgun/agents/config/models.py,sha256=ohLXt9niCy4uFfFP1E6WSBZtxh7aZ16gTA2S3pHYkmc,5431
-shotgun/agents/config/provider.py,sha256=K2uW7DkdAhZfoDJcWV7NxOrSoEq1rQzArtZnxIgEe3E,12496
+shotgun/agents/config/manager.py,sha256=Z8EQoWPQM7uj3MyklmxHQ1GR6va1uv9BjT5DDvAv3pY,18920
+shotgun/agents/config/models.py,sha256=tM0JnMf-hWWzJCmOsJBA6tIiwrdFTQI_4B0zYFNg6CU,5736
+shotgun/agents/config/provider.py,sha256=8TLiyTowkjT5p0zjocv9zGjem5hgQKnNuiN1nESguok,13412
 shotgun/agents/history/__init__.py,sha256=XFQj2a6fxDqVg0Q3juvN9RjV_RJbgvFZtQOCOjVJyp4,147
 shotgun/agents/history/compaction.py,sha256=9RMpG0aY_7L4TecbgwHSOkGtbd9W5XZTg-MbzZmNl00,3515
 shotgun/agents/history/constants.py,sha256=yWY8rrTZarLA3flCCMB_hS2NMvUDRDTwP4D4j7MIh1w,446
@@ -64,7 +64,7 @@ shotgun/cli/plan.py,sha256=T-eu-I9z-dSoKqJ-KI8X5i5Mm0VL1BfornxRiUjTgnk,2324
 shotgun/cli/research.py,sha256=qvBBtX3Wyn6pDZlJpcEvbeK-0iTOXegi71tm8HKVYaE,2490
 shotgun/cli/specify.py,sha256=ErRQ72Zc75fmxopZbKy0vvnLPuYBLsGynpjj1X6-BwI,2166
 shotgun/cli/tasks.py,sha256=17qWoGCVYpNIxa2vaoIH1P-xz2RcGLaK8SF4JlPsOWI,2420
-shotgun/cli/update.py,sha256=Dn_No7jPmdZ-7qYlhzI0BtmlufetVdw1BN-xRi_UE5A,4718
+shotgun/cli/update.py,sha256=sc3uuw3AXFF0kpskWah1JEoTwrKv67fCnqp9BjeND3o,5328
 shotgun/cli/utils.py,sha256=umVWXDx8pelovMk-nT8B7m0c39AKY9hHsuAMnbw_Hcg,732
 shotgun/cli/codebase/__init__.py,sha256=rKdvx33p0i_BYbNkz5_4DCFgEMwzOOqLi9f5p7XTLKM,73
 shotgun/cli/codebase/commands.py,sha256=1N2yOGmok0ZarqXPIpWGcsQrwm_ZJcyWiMxy6tm0j70,8711
@@ -78,7 +78,7 @@ shotgun/codebase/core/code_retrieval.py,sha256=_JVyyQKHDFm3dxOOua1mw9eIIOHIVz3-I
 shotgun/codebase/core/cypher_models.py,sha256=Yfysfa9lLguILftkmtuJCN3kLBFIo7WW7NigM-Zr-W4,1735
 shotgun/codebase/core/ingestor.py,sha256=CNYbdoJycnbA2psYCD9uKcUwIe3Ao7I7T6NrPhTQE9k,64613
 shotgun/codebase/core/language_config.py,sha256=vsqHyuFnumRPRBV1lMOxWKNOIiClO6FyfKQR0fGrtl4,8934
-shotgun/codebase/core/manager.py,sha256=kjxQ9eCs5vVCVDproCN1eYSKuGiqtcxF01reQ18JfOw,66184
+shotgun/codebase/core/manager.py,sha256=1ykkGSrR4ooEKiluGp-17q3n9hd2LSjonvZL10Xb0pk,66697
 shotgun/codebase/core/nl_query.py,sha256=kPoSJXBlm5rLhzOofZhqPVMJ_Lj3rV2H6sld6BwtMdg,16115
 shotgun/codebase/core/parser_loader.py,sha256=LZRrDS8Sp518jIu3tQW-BxdwJ86lnsTteI478ER9Td8,4278
 shotgun/llm_proxy/__init__.py,sha256=3ST3ygtf2sXXSOjIFHxVZ5xqRbT3TF7jpNHwuZAtIwA,452
@@ -119,7 +119,7 @@ shotgun/shotgun_web/client.py,sha256=n5DDuVfSa6VPZjhSsfSxQlSFOnhgDHyidRnB8Hv9XF4
 shotgun/shotgun_web/constants.py,sha256=eNvtjlu81bAVQaCwZXOVjSpDopUm9pf34XuZEvuMiko,661
 shotgun/shotgun_web/models.py,sha256=Ie9VfqKZM2tIJhIjentU9qLoNaMZvnUJaIu-xg9kQsA,1391
 shotgun/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shotgun/tui/app.py,sha256=B2tKbXeGhWBIVec1jJHGAuBcP1SMbO_6xol2OaBpw2Y,5374
+shotgun/tui/app.py,sha256=I4rPtHIp_XiO4Vy3TQe3Rjfp20xHkxDvijdlY7x6wi8,10636
 shotgun/tui/filtered_codebase_service.py,sha256=lJ8gTMhIveTatmvmGLP299msWWTkVYKwvY_2FhuL2s4,1687
 shotgun/tui/styles.tcss,sha256=ETyyw1bpMBOqTi5RLcAJUScdPWTvAWEqE9YcT0kVs_E,121
 shotgun/tui/commands/__init__.py,sha256=8D5lvtpqMW5-fF7Bg3oJtUzU75cKOv6aUaHYYszydU8,2518
@@ -127,11 +127,12 @@ shotgun/tui/components/prompt_input.py,sha256=Ss-htqraHZAPaehGE4x86ij0veMjc4Ugad
 shotgun/tui/components/spinner.py,sha256=ovTDeaJ6FD6chZx_Aepia6R3UkPOVJ77EKHfRmn39MY,2427
 shotgun/tui/components/splash.py,sha256=vppy9vEIEvywuUKRXn2y11HwXSRkQZHLYoVjhDVdJeU,1267
 shotgun/tui/components/vertical_tail.py,sha256=kROwTaRjUwVB7H35dtmNcUVPQqNYvvfq7K2tXBKEb6c,638
-shotgun/tui/screens/chat.py,sha256=D_HKVSOjT1ex3AHRtE41hTmDKiiUmmHY7BIbHvTyj-w,38747
+shotgun/tui/screens/chat.py,sha256=-MPbvdeWSWLK2VTgPYicMXger2vMHA9t_YrEzaux-1Q,42255
 shotgun/tui/screens/chat.tcss,sha256=2Yq3E23jxsySYsgZf4G1AYrYVcpX0UDW6kNNI0tDmtM,437
 shotgun/tui/screens/directory_setup.py,sha256=lIZ1J4A6g5Q2ZBX8epW7BhR96Dmdcg22CyiM5S-I5WU,3237
 shotgun/tui/screens/feedback.py,sha256=VxpW0PVxMp22ZvSfQkTtgixNrpEOlfWtekjqlVfYEjA,5708
-shotgun/tui/screens/model_picker.py,sha256=G-EvalpxgHKk0W3FgHMcxIr817VwZyEgh_ZadSQiRwo,11831
+shotgun/tui/screens/model_picker.py,sha256=kPvBnMK20SJrAGAC0HHM4Yi8n7biHraz58eiE8jiPxg,11927
+shotgun/tui/screens/pipx_migration.py,sha256=BY6R1Z__htCLjWwffXbHUpxfAk1nnLQnzGRUCmXfwiY,4321
 shotgun/tui/screens/provider_config.py,sha256=UCnAzjXPoP7Y73gsXxZF2PNA4LdSgpgoGYwiOd6fERA,10902
 shotgun/tui/screens/shotgun_auth.py,sha256=Y--7LZewV6gfDkucxymfAO7BCd7eI2C3H1ClDMztVio,10663
 shotgun/tui/screens/splash.py,sha256=E2MsJihi3c9NY1L28o_MstDxGwrCnnV7zdq00MrGAsw,706
@@ -147,9 +148,9 @@ shotgun/utils/datetime_utils.py,sha256=x_uYmG1n9rkhSO2oR2uV9ttiuPL0nKa9os8YYaPfd
 shotgun/utils/env_utils.py,sha256=ulM3BRi9ZhS7uC-zorGeDQm4SHvsyFuuU9BtVPqdrHY,1418
 shotgun/utils/file_system_utils.py,sha256=l-0p1bEHF34OU19MahnRFdClHufThfGAjQ431teAIp0,1004
 shotgun/utils/source_detection.py,sha256=Co6Q03R3fT771TF3RzB-70stfjNP2S4F_ArZKibwzm8,454
-shotgun/utils/update_checker.py,sha256=IgzPHRhS1ETH7PnJR_dIx6lxgr1qHpCkMTgzUxvGjhI,7586
-shotgun_sh-0.2.9.dist-info/METADATA,sha256=Oa7hEsFj4nzgRGje9A2ScEOndeRTHh0TcrzIaSVUzdQ,4294
-shotgun_sh-0.2.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.2.9.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
-shotgun_sh-0.2.9.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.2.9.dist-info/RECORD,,
+shotgun/utils/update_checker.py,sha256=5pK9ZXEjgnE-BQLvibm9Fj6SJHVYeG0U-WspRf0bJec,9660
+shotgun_sh-0.2.10.dist-info/METADATA,sha256=57UVH3orQmmh8ahq3pJYX6NpHiGZCxPvPJV0x1MWr2k,4665
+shotgun_sh-0.2.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.2.10.dist-info/entry_points.txt,sha256=GQmtjKaPtviqYOuB3C0SMGlG5RZS9-VDDIKxV_IVHmY,75
+shotgun_sh-0.2.10.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.2.10.dist-info/RECORD,,

{shotgun_sh-0.2.9.dist-info → shotgun_sh-0.2.10.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 shotgun = shotgun.main:app
+shotgun-sh = shotgun.main:app