shotgun-sh 0.2.10.dev9__tar.gz → 0.2.10.dev11__tar.gz

{shotgun_sh-0.2.10.dev9 → shotgun_sh-0.2.10.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.10.dev9
+Version: 0.2.10.dev11
 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.10.dev9 → shotgun_sh-0.2.10.dev11}/pyproject.toml

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

{shotgun_sh-0.2.10.dev9 → shotgun_sh-0.2.10.dev11}/src/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",

{shotgun_sh-0.2.10.dev9 → shotgun_sh-0.2.10.dev11}/src/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
@@ -785,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)
@@ -853,58 +878,92 @@ 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: {exc}", severity="error")
+                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_sh-0.2.10.dev9 → shotgun_sh-0.2.10.dev11}/src/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_sh-0.2.10.dev9 → shotgun_sh-0.2.10.dev11}/src/shotgun/tui/screens/pipx_migration.py

@@ -101,7 +101,7 @@ Or install permanently: `uv tool install shotgun-sh`
 
 **Discord:** https://discord.gg/5RmY6J2N7s
 
-**Full Migration Guide:** https://github.com/shotgun-sh/shotgun-sdk/blob/main/PIPX_MIGRATION.md
+**Full Migration Guide:** https://github.com/shotgun-sh/shotgun/blob/main/PIPX_MIGRATION.md
 """
                 )