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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.1.dev4
+Version: 0.2.1.dev6
 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.dev4 → shotgun_sh-0.2.1.dev6}/pyproject.toml

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

{shotgun_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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 (
@@ -60,10 +62,10 @@ class ConfigManager:
 
         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
 
@@ -71,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)
 
@@ -134,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
 
@@ -148,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
@@ -276,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
 
@@ -292,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
@@ -299,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
@@ -312,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."""
@@ -376,14 +409,36 @@ 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.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()
-        return config.user_id
+
+        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

{shotgun_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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,46 @@ 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
+
+# Directory prefixes that should always be ignored
+IGNORED_DIRECTORY_PREFIXES = (".",)
+
+
+def should_ignore_directory(name: str, ignore_patterns: set[str] | None = None) -> bool:
+    """Return True if the directory name should be ignored."""
+    patterns = IGNORE_PATTERNS if ignore_patterns is None else ignore_patterns
+    if name in patterns:
+        return True
+    return name.startswith(IGNORED_DIRECTORY_PREFIXES)
+
+
+def is_path_ignored(path: Path, ignore_patterns: set[str] | None = None) -> bool:
+    """Return True if any part of the path should be ignored."""
+    patterns = IGNORE_PATTERNS if ignore_patterns is None else ignore_patterns
+    return any(should_ignore_directory(part, patterns) for part in path.parts)
+
 
 class Ingestor:
     """Handles all communication and ingestion with the Kuzu database."""
@@ -607,7 +644,9 @@ class SimpleGraphBuilder:
         """First pass: Walk directory to find packages and folders."""
         dir_count = 0
         for root_str, dirs, _ in os.walk(self.repo_path, topdown=True):
-            dirs[:] = [d for d in dirs if d not in self.ignore_dirs]
+            dirs[:] = [
+                d for d in dirs if not should_ignore_directory(d, self.ignore_dirs)
+            ]
             root = Path(root_str)
             relative_root = root.relative_to(self.repo_path)
 
@@ -740,7 +779,7 @@ class SimpleGraphBuilder:
             root = Path(root_str)
 
             # Skip ignored directories
-            if any(part in self.ignore_dirs for part in root.parts):
+            if is_path_ignored(root, self.ignore_dirs):
                 continue
 
             for filename in files:
@@ -757,7 +796,7 @@ class SimpleGraphBuilder:
             root = Path(root_str)
 
             # Skip ignored directories
-            if any(part in self.ignore_dirs for part in root.parts):
+            if is_path_ignored(root, self.ignore_dirs):
                 continue
 
             for filename in files:

{shotgun_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/shotgun/codebase/core/manager.py

@@ -51,9 +51,13 @@ class CodebaseFileHandler(FileSystemEventHandler):
         self.pending_changes: list[FileChange] = []
         self._lock = anyio.Lock()
         # Import default ignore patterns from ingestor
-        from shotgun.codebase.core.ingestor import IGNORE_PATTERNS
+        from shotgun.codebase.core.ingestor import (
+            IGNORE_PATTERNS,
+            should_ignore_directory,
+        )
 
         self.ignore_patterns = ignore_patterns or IGNORE_PATTERNS
+        self._should_ignore_directory = should_ignore_directory
 
     def on_any_event(self, event: FileSystemEvent) -> None:
         """Handle any file system event."""
@@ -71,7 +75,7 @@ class CodebaseFileHandler(FileSystemEventHandler):
 
         # Check if any parent directory should be ignored
         for parent in path.parents:
-            if parent.name in self.ignore_patterns:
+            if self._should_ignore_directory(parent.name, self.ignore_patterns):
                 logger.debug(
                     f"Ignoring file in ignored directory: {parent.name} - path: {src_path_str}"
                 )
@@ -106,7 +110,7 @@ class CodebaseFileHandler(FileSystemEventHandler):
             )
             dest_path = Path(dest_path_str)
             for parent in dest_path.parents:
-                if parent.name in self.ignore_patterns:
+                if self._should_ignore_directory(parent.name, self.ignore_patterns):
                     logger.debug(
                         f"Ignoring move to ignored directory: {parent.name} - dest_path: {dest_path_str}"
                     )

{shotgun_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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_sh-0.2.1.dev4 → shotgun_sh-0.2.1.dev6}/src/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_sh-0.2.1.dev6/src/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_sh-0.2.1.dev6/src/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_sh-0.2.1.dev6/src/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