shotgun-sh 0.2.1.dev3__py3-none-any.whl → 0.2.1.dev5__py3-none-any.whl

shotgun/agents/config/constants.py

@@ -4,7 +4,8 @@ from enum import StrEnum, auto
 
 # Field names
 API_KEY_FIELD = "api_key"
-USER_ID_FIELD = "user_id"
+SUPABASE_JWT_FIELD = "supabase_jwt"
+SHOTGUN_INSTANCE_ID_FIELD = "shotgun_instance_id"
 CONFIG_VERSION_FIELD = "config_version"
 
 

shotgun/agents/config/manager.py

@@ -12,6 +12,8 @@ from shotgun.utils import get_shotgun_home
 
 from .constants import (
     API_KEY_FIELD,
+    SHOTGUN_INSTANCE_ID_FIELD,
+    SUPABASE_JWT_FIELD,
     ConfigSection,
 )
 from .models import (
@@ -46,21 +48,24 @@ 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():
             logger.info(
-                "Configuration file not found, creating new config with user_id: %s",
+                "Configuration file not found, creating new config at: %s",
                 self.config_path,
             )
-            # Create new config with generated user_id
+            # Create new config with generated shotgun_instance_id
             self._config = self.initialize()
             return self._config
 
@@ -68,6 +73,14 @@ class ConfigManager:
             with open(self.config_path, encoding="utf-8") as f:
                 data = json.load(f)
 
+            # Migration: Rename user_id to shotgun_instance_id (config v2 -> v3)
+            if "user_id" in data and SHOTGUN_INSTANCE_ID_FIELD not in data:
+                data[SHOTGUN_INSTANCE_ID_FIELD] = data.pop("user_id")
+                data["config_version"] = 3
+                logger.info(
+                    "Migrated config v2->v3: renamed user_id to shotgun_instance_id"
+                )
+
             # Convert plain text secrets to SecretStr objects
             self._convert_secrets_to_secretstr(data)
 
@@ -131,7 +144,7 @@ class ConfigManager:
             logger.error(
                 "Failed to load configuration from %s: %s", self.config_path, e
             )
-            logger.info("Creating new configuration with generated user_id")
+            logger.info("Creating new configuration with generated shotgun_instance_id")
             self._config = self.initialize()
             return self._config
 
@@ -145,9 +158,9 @@ class ConfigManager:
             if self._config:
                 config = self._config
             else:
-                # Create a new config with generated user_id
+                # Create a new config with generated shotgun_instance_id
                 config = ShotgunConfig(
-                    user_id=str(uuid.uuid4()),
+                    shotgun_instance_id=str(uuid.uuid4()),
                 )
 
         # Ensure directory exists
@@ -243,7 +256,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 +265,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))
@@ -271,15 +286,15 @@ class ConfigManager:
         Returns:
             Default ShotgunConfig
         """
-        # Generate unique user ID for new config
+        # Generate unique shotgun instance ID for new config
         config = ShotgunConfig(
-            user_id=str(uuid.uuid4()),
+            shotgun_instance_id=str(uuid.uuid4()),
         )
         self.save(config)
         logger.info(
-            "Configuration initialized at %s with user_id: %s",
+            "Configuration initialized at %s with shotgun_instance_id: %s",
             self.config_path,
-            config.user_id,
+            config.shotgun_instance_id,
         )
         return config
 
@@ -287,6 +302,7 @@ class ConfigManager:
         """Convert plain text secrets in data to SecretStr objects."""
         for section in ConfigSection:
             if section.value in data and isinstance(data[section.value], dict):
+                # Convert API key
                 if (
                     API_KEY_FIELD in data[section.value]
                     and data[section.value][API_KEY_FIELD] is not None
@@ -294,11 +310,21 @@ class ConfigManager:
                     data[section.value][API_KEY_FIELD] = SecretStr(
                         data[section.value][API_KEY_FIELD]
                     )
+                # Convert supabase JWT (shotgun section only)
+                if (
+                    section == ConfigSection.SHOTGUN
+                    and SUPABASE_JWT_FIELD in data[section.value]
+                    and data[section.value][SUPABASE_JWT_FIELD] is not None
+                ):
+                    data[section.value][SUPABASE_JWT_FIELD] = SecretStr(
+                        data[section.value][SUPABASE_JWT_FIELD]
+                    )
 
     def _convert_secretstr_to_plain(self, data: dict[str, Any]) -> None:
         """Convert SecretStr objects in data to plain text for JSON serialization."""
         for section in ConfigSection:
             if section.value in data and isinstance(data[section.value], dict):
+                # Convert API key
                 if (
                     API_KEY_FIELD in data[section.value]
                     and data[section.value][API_KEY_FIELD] is not None
@@ -307,6 +333,18 @@ class ConfigManager:
                         data[section.value][API_KEY_FIELD] = data[section.value][
                             API_KEY_FIELD
                         ].get_secret_value()
+                # Convert supabase JWT (shotgun section only)
+                if (
+                    section == ConfigSection.SHOTGUN
+                    and SUPABASE_JWT_FIELD in data[section.value]
+                    and data[section.value][SUPABASE_JWT_FIELD] is not None
+                ):
+                    if hasattr(
+                        data[section.value][SUPABASE_JWT_FIELD], "get_secret_value"
+                    ):
+                        data[section.value][SUPABASE_JWT_FIELD] = data[section.value][
+                            SUPABASE_JWT_FIELD
+                        ].get_secret_value()
 
     def _ensure_provider_enum(self, provider: ProviderType | str) -> ProviderType:
         """Normalize provider values to ProviderType enum."""
@@ -371,16 +409,49 @@ class ConfigManager:
         provider_enum = self._ensure_provider_enum(provider)
         return (self._get_provider_config(config, provider_enum), False)
 
-    def get_user_id(self) -> str:
-        """Get the user ID from configuration.
+    def get_shotgun_instance_id(self) -> str:
+        """Get the shotgun instance ID from configuration.
 
         Returns:
-            The unique user ID string
+            The unique shotgun instance ID string
         """
         config = self.load()
-        return config.user_id
+        return config.shotgun_instance_id
+
+    def update_shotgun_account(
+        self, api_key: str | None = None, supabase_jwt: str | None = None
+    ) -> None:
+        """Update Shotgun Account configuration.
+
+        Args:
+            api_key: LiteLLM proxy API key (optional)
+            supabase_jwt: Supabase authentication JWT (optional)
+        """
+        config = self.load()
+
+        if api_key is not None:
+            config.shotgun.api_key = SecretStr(api_key) if api_key else None
+
+        if supabase_jwt is not None:
+            config.shotgun.supabase_jwt = (
+                SecretStr(supabase_jwt) if supabase_jwt else None
+            )
+
+        self.save(config)
+        logger.info("Updated Shotgun Account configuration")
+
+
+# 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/agents/config/models.py

@@ -149,6 +149,9 @@ class ShotgunAccountConfig(BaseModel):
     """Configuration for Shotgun Account (LiteLLM proxy)."""
 
     api_key: SecretStr | None = None
+    supabase_jwt: SecretStr | None = Field(
+        default=None, description="Supabase authentication JWT"
+    )
 
 
 class ShotgunConfig(BaseModel):
@@ -162,5 +165,11 @@ class ShotgunConfig(BaseModel):
         default=None,
         description="User-selected model",
     )
-    user_id: str = Field(description="Unique anonymous user identifier")
-    config_version: int = Field(default=2, description="Configuration schema version")
+    shotgun_instance_id: str = Field(
+        description="Unique shotgun instance identifier (also used for anonymous telemetry)",
+    )
+    config_version: int = Field(default=3, description="Configuration schema version")
+    shown_welcome_screen: bool = Field(
+        default=False,
+        description="Whether the welcome screen has been shown to the user",
+    )

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/cli/config.py

@@ -233,14 +233,14 @@ def _mask_value(value: str) -> str:
 
 
 @app.command()
-def get_user_id() -> None:
-    """Get the anonymous user ID from configuration."""
+def get_shotgun_instance_id() -> None:
+    """Get the anonymous shotgun instance ID from configuration."""
     config_manager = get_config_manager()
 
     try:
-        user_id = config_manager.get_user_id()
-        console.print(f"[green]User ID:[/green] {user_id}")
+        shotgun_instance_id = config_manager.get_shotgun_instance_id()
+        console.print(f"[green]Shotgun Instance ID:[/green] {shotgun_instance_id}")
     except Exception as e:
-        logger.error(f"Error getting user ID: {e}")
-        console.print(f"❌ Failed to get user ID: {str(e)}", style="red")
+        logger.error(f"Error getting shotgun instance ID: {e}")
+        console.print(f"❌ Failed to get shotgun instance ID: {str(e)}", style="red")
         raise typer.Exit(1) from e

shotgun/cli/feedback.py

@@ -30,7 +30,7 @@ def send_feedback(
     """Initialize Shotgun configuration."""
     config_manager = get_config_manager()
     config_manager.load()
-    user_id = config_manager.get_user_id()
+    shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
     if not description:
         console.print(
@@ -39,7 +39,9 @@ def send_feedback(
         )
         raise typer.Exit(1)
 
-    feedback = Feedback(kind=kind, description=description, user_id=user_id)
+    feedback = Feedback(
+        kind=kind, description=description, shotgun_instance_id=shotgun_instance_id
+    )
 
     submit_feedback_survey(feedback)
 

shotgun/codebase/core/ingestor.py

@@ -18,15 +18,12 @@ from shotgun.logging_config import get_logger
 logger = get_logger(__name__)
 
 
-# Default ignore patterns
-IGNORE_PATTERNS = {
+# Directories that should never be traversed during indexing
+BASE_IGNORE_DIRECTORIES = {
     ".git",
     "venv",
     ".venv",
     "__pycache__",
-    "node_modules",
-    "build",
-    "dist",
     ".eggs",
     ".pytest_cache",
     ".mypy_cache",
@@ -36,6 +33,29 @@ IGNORE_PATTERNS = {
     ".vscode",
 }
 
+# Well-known build output directories to skip when determining source files
+BUILD_ARTIFACT_DIRECTORIES = {
+    "node_modules",
+    ".next",
+    ".nuxt",
+    ".vite",
+    ".yarn",
+    ".svelte-kit",
+    ".output",
+    ".turbo",
+    ".parcel-cache",
+    ".vercel",
+    ".serverless",
+    "build",
+    "dist",
+    "out",
+    "tmp",
+    "coverage",
+}
+
+# Default ignore patterns combines base directories and build artifacts
+IGNORE_PATTERNS = BASE_IGNORE_DIRECTORIES | BUILD_ARTIFACT_DIRECTORIES
+
 
 class Ingestor:
     """Handles all communication and ingestion with the Kuzu database."""

shotgun/posthog_telemetry.py

@@ -51,14 +51,14 @@ def setup_posthog_observability() -> bool:
         # Store the client for later use
         _posthog_client = posthog
 
-        # Set user context with anonymous user ID from config
+        # Set user context with anonymous shotgun instance ID from config
         try:
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
+            shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
             # Identify the user in PostHog
             posthog.identify(  # type: ignore[attr-defined]
-                distinct_id=user_id,
+                distinct_id=shotgun_instance_id,
                 properties={
                     "version": __version__,
                     "environment": environment,
@@ -69,7 +69,9 @@ def setup_posthog_observability() -> bool:
             posthog.disabled = False
             posthog.personal_api_key = None  # Not needed for event tracking
 
-            logger.debug("PostHog user identified with anonymous ID: %s", user_id)
+            logger.debug(
+                "PostHog user identified with anonymous ID: %s", shotgun_instance_id
+            )
         except Exception as e:
             logger.warning("Failed to set user context: %s", e)
 
@@ -99,9 +101,9 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         return
 
     try:
-        # Get user ID for tracking
+        # Get shotgun instance ID for tracking
         config_manager = get_config_manager()
-        user_id = config_manager.get_user_id()
+        shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
         # Add version and environment to properties
         if properties is None:
@@ -116,7 +118,7 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
 
         # Track the event using PostHog's capture method
         _posthog_client.capture(
-            distinct_id=user_id, event=event_name, properties=properties
+            distinct_id=shotgun_instance_id, event=event_name, properties=properties
         )
         logger.debug("Tracked PostHog event: %s", event_name)
     except Exception as e:
@@ -146,7 +148,7 @@ class FeedbackKind(StrEnum):
 class Feedback(BaseModel):
     kind: FeedbackKind
     description: str
-    user_id: str
+    shotgun_instance_id: str
 
 
 SURVEY_ID = "01999f81-9486-0000-4fa6-9632959f92f3"

shotgun/sentry_telemetry.py

@@ -59,13 +59,13 @@ def setup_sentry_observability() -> bool:
             profiles_sample_rate=0.1 if environment == "production" else 1.0,
         )
 
-        # Set user context with anonymous user ID from config
+        # Set user context with anonymous shotgun instance ID from config
         try:
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
-            sentry_sdk.set_user({"id": user_id})
+            shotgun_instance_id = config_manager.get_shotgun_instance_id()
+            sentry_sdk.set_user({"id": shotgun_instance_id})
             logger.debug("Sentry user context set with anonymous ID")
         except Exception as e:
             logger.warning("Failed to set Sentry user context: %s", e)

shotgun/shotgun_web/__init__.py

@@ -0,0 +1,19 @@
+"""Shotgun Web API client for subscription and authentication."""
+
+from .client import ShotgunWebClient, check_token_status, create_unification_token
+from .models import (
+    TokenCreateRequest,
+    TokenCreateResponse,
+    TokenStatus,
+    TokenStatusResponse,
+)
+
+__all__ = [
+    "ShotgunWebClient",
+    "create_unification_token",
+    "check_token_status",
+    "TokenCreateRequest",
+    "TokenCreateResponse",
+    "TokenStatus",
+    "TokenStatusResponse",
+]

shotgun/shotgun_web/client.py

@@ -0,0 +1,138 @@
+"""HTTP client for Shotgun Web API."""
+
+import httpx
+
+from shotgun.logging_config import get_logger
+
+from .constants import (
+    SHOTGUN_WEB_BASE_URL,
+    UNIFICATION_TOKEN_CREATE_PATH,
+    UNIFICATION_TOKEN_STATUS_PATH,
+)
+from .models import (
+    TokenCreateRequest,
+    TokenCreateResponse,
+    TokenStatusResponse,
+)
+
+logger = get_logger(__name__)
+
+
+class ShotgunWebClient:
+    """HTTP client for Shotgun Web API."""
+
+    def __init__(self, base_url: str | None = None, timeout: float = 10.0):
+        """Initialize Shotgun Web client.
+
+        Args:
+            base_url: Base URL for Shotgun Web API. If None, uses SHOTGUN_WEB_BASE_URL
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url or SHOTGUN_WEB_BASE_URL
+        self.timeout = timeout
+
+    def create_unification_token(self, shotgun_instance_id: str) -> TokenCreateResponse:
+        """Create a unification token for CLI authentication.
+
+        Args:
+            shotgun_instance_id: UUID for this shotgun instance
+
+        Returns:
+            Token creation response with token and auth URL
+
+        Raises:
+            httpx.HTTPError: If request fails
+        """
+        url = f"{self.base_url}{UNIFICATION_TOKEN_CREATE_PATH}"
+        request_data = TokenCreateRequest(shotgun_instance_id=shotgun_instance_id)
+
+        logger.debug("Creating unification token for instance %s", shotgun_instance_id)
+
+        try:
+            response = httpx.post(
+                url,
+                json=request_data.model_dump(),
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+
+            data = response.json()
+            result = TokenCreateResponse.model_validate(data)
+
+            logger.info(
+                "Successfully created unification token, expires in %d seconds",
+                result.expires_in_seconds,
+            )
+            return result
+
+        except httpx.HTTPError as e:
+            logger.error("Failed to create unification token: %s", e)
+            raise
+
+    def check_token_status(self, token: str) -> TokenStatusResponse:
+        """Check token status and get keys if completed.
+
+        Args:
+            token: Unification token to check
+
+        Returns:
+            Token status response with status and keys (if completed)
+
+        Raises:
+            httpx.HTTPStatusError: If token not found (404) or expired (410)
+            httpx.HTTPError: For other request failures
+        """
+        url = f"{self.base_url}{UNIFICATION_TOKEN_STATUS_PATH.format(token=token)}"
+
+        logger.debug("Checking status for token %s...", token[:8])
+
+        try:
+            response = httpx.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            data = response.json()
+            result = TokenStatusResponse.model_validate(data)
+
+            logger.debug("Token status: %s", result.status)
+            return result
+
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                logger.error("Token not found: %s", token[:8])
+            elif e.response.status_code == 410:
+                logger.error("Token expired: %s", token[:8])
+            raise
+        except httpx.HTTPError as e:
+            logger.error("Failed to check token status: %s", e)
+            raise
+
+
+# Convenience functions for standalone use
+def create_unification_token(shotgun_instance_id: str) -> TokenCreateResponse:
+    """Create a unification token.
+
+    Convenience function that creates a client and calls create_unification_token.
+
+    Args:
+        shotgun_instance_id: UUID for this shotgun instance
+
+    Returns:
+        Token creation response
+    """
+    client = ShotgunWebClient()
+    return client.create_unification_token(shotgun_instance_id)
+
+
+def check_token_status(token: str) -> TokenStatusResponse:
+    """Check token status.
+
+    Convenience function that creates a client and calls check_token_status.
+
+    Args:
+        token: Unification token to check
+
+    Returns:
+        Token status response
+    """
+    client = ShotgunWebClient()
+    return client.check_token_status(token)

shotgun/shotgun_web/constants.py

@@ -0,0 +1,17 @@
+"""Constants for Shotgun Web API."""
+
+import os
+
+# Shotgun Web API base URL
+# Default to production URL, can be overridden with environment variable
+SHOTGUN_WEB_BASE_URL = os.environ.get(
+    "SHOTGUN_WEB_BASE_URL", "https://api-701197220809.us-east1.run.app"
+)
+
+# API endpoints
+UNIFICATION_TOKEN_CREATE_PATH = "/api/unification/token/create"  # noqa: S105
+UNIFICATION_TOKEN_STATUS_PATH = "/api/unification/token/{token}/status"  # noqa: S105
+
+# Polling configuration
+DEFAULT_POLL_INTERVAL_SECONDS = 3
+DEFAULT_TOKEN_TIMEOUT_SECONDS = 1800  # 30 minutes

shotgun/shotgun_web/models.py

@@ -0,0 +1,47 @@
+"""Pydantic models for Shotgun Web API."""
+
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class TokenStatus(StrEnum):
+    """Token status enum matching API specification."""
+
+    PENDING = "pending"
+    COMPLETED = "completed"
+    AWAITING_PAYMENT = "awaiting_payment"
+    EXPIRED = "expired"
+
+
+class TokenCreateRequest(BaseModel):
+    """Request model for creating a unification token."""
+
+    shotgun_instance_id: str = Field(
+        description="CLI-provided UUID for shotgun instance"
+    )
+
+
+class TokenCreateResponse(BaseModel):
+    """Response model for token creation."""
+
+    token: str = Field(description="Secure authentication token")
+    auth_url: str = Field(description="Web authentication URL for user to complete")
+    expires_in_seconds: int = Field(description="Token expiration time in seconds")
+
+
+class TokenStatusResponse(BaseModel):
+    """Response model for token status check."""
+
+    status: TokenStatus = Field(description="Current token status")
+    supabase_key: str | None = Field(
+        default=None,
+        description="Supabase user JWT (only returned when status=completed)",
+    )
+    litellm_key: str | None = Field(
+        default=None,
+        description="LiteLLM virtual key (only returned when status=completed)",
+    )
+    message: str | None = Field(
+        default=None, description="Human-readable status message"
+    )

shotgun/telemetry.py

@@ -72,12 +72,15 @@ def setup_logfire_observability() -> bool:
             from shotgun.agents.config import get_config_manager
 
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
+            shotgun_instance_id = config_manager.get_shotgun_instance_id()
 
-            # Set user_id as baggage in global context - this will be included in all logs/spans
-            ctx = baggage.set_baggage("user_id", user_id)
+            # Set shotgun_instance_id as baggage in global context - this will be included in all logs/spans
+            ctx = baggage.set_baggage("shotgun_instance_id", shotgun_instance_id)
             context.attach(ctx)
-            logger.debug("Logfire user context set with user_id: %s", user_id)
+            logger.debug(
+                "Logfire user context set with shotgun_instance_id: %s",
+                shotgun_instance_id,
+            )
         except Exception as e:
             logger.warning("Failed to set Logfire user context: %s", e)