shotgun-sh 0.2.11.dev7__py3-none-any.whl → 0.2.19__py3-none-any.whl

shotgun/agents/config/streaming_test.py

@@ -0,0 +1,119 @@
+"""Utility for testing streaming capability of OpenAI models."""
+
+import logging
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+# Maximum number of attempts to test streaming capability
+MAX_STREAMING_TEST_ATTEMPTS = 3
+
+# Timeout for each streaming test attempt (in seconds)
+STREAMING_TEST_TIMEOUT = 10.0
+
+
+async def check_streaming_capability(
+    api_key: str, model_name: str, max_attempts: int = MAX_STREAMING_TEST_ATTEMPTS
+) -> bool:
+    """Check if the given OpenAI model supports streaming with this API key.
+
+    Retries multiple times to handle transient network issues. Only returns False
+    if streaming definitively fails after all retry attempts.
+
+    Args:
+        api_key: The OpenAI API key to test
+        model_name: The model name (e.g., "gpt-5", "gpt-5-mini")
+        max_attempts: Maximum number of attempts (default: 3)
+
+    Returns:
+        True if streaming is supported, False if it definitively fails
+    """
+    url = "https://api.openai.com/v1/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    # GPT-5 family uses max_completion_tokens instead of max_tokens
+    payload = {
+        "model": model_name,
+        "messages": [{"role": "user", "content": "test"}],
+        "stream": True,
+        "max_completion_tokens": 10,
+    }
+
+    last_error = None
+
+    for attempt in range(1, max_attempts + 1):
+        logger.debug(
+            f"Streaming test attempt {attempt}/{max_attempts} for {model_name}"
+        )
+
+        try:
+            async with httpx.AsyncClient(timeout=STREAMING_TEST_TIMEOUT) as client:
+                async with client.stream(
+                    "POST", url, json=payload, headers=headers
+                ) as response:
+                    # Check if we get a successful response
+                    if response.status_code != 200:
+                        last_error = f"HTTP {response.status_code}"
+                        logger.warning(
+                            f"Streaming test attempt {attempt} failed for {model_name}: {last_error}"
+                        )
+
+                        # For definitive errors (403 Forbidden, 404 Not Found), don't retry
+                        if response.status_code in (403, 404):
+                            logger.info(
+                                f"Streaming definitively unsupported for {model_name} (HTTP {response.status_code})"
+                            )
+                            return False
+
+                        # For other errors, retry
+                        continue
+
+                    # Try to read at least one chunk from the stream
+                    try:
+                        async for _ in response.aiter_bytes():
+                            # Successfully received streaming data
+                            logger.info(
+                                f"Streaming test passed for {model_name} (attempt {attempt})"
+                            )
+                            return True
+                    except Exception as e:
+                        last_error = str(e)
+                        logger.warning(
+                            f"Streaming test attempt {attempt} failed for {model_name} while reading stream: {e}"
+                        )
+                        continue
+
+        except httpx.TimeoutException:
+            last_error = "timeout"
+            logger.warning(
+                f"Streaming test attempt {attempt} timed out for {model_name}"
+            )
+            continue
+        except httpx.HTTPStatusError as e:
+            last_error = str(e)
+            logger.warning(
+                f"Streaming test attempt {attempt} failed for {model_name}: {e}"
+            )
+            continue
+        except Exception as e:
+            last_error = str(e)
+            logger.warning(
+                f"Streaming test attempt {attempt} failed for {model_name} with unexpected error: {e}"
+            )
+            continue
+
+        # If we got here without reading any chunks, streaming didn't work
+        last_error = "no data received"
+        logger.warning(
+            f"Streaming test attempt {attempt} failed for {model_name}: no data received"
+        )
+
+    # All attempts exhausted
+    logger.error(
+        f"Streaming test failed for {model_name} after {max_attempts} attempts. "
+        f"Last error: {last_error}. Assuming streaming is NOT supported."
+    )
+    return False

shotgun/build_constants.py

@@ -8,12 +8,12 @@ DO NOT EDIT MANUALLY.
 SENTRY_DSN = 'https://2818a6d165c64eccc94cfd51ce05d6aa@o4506813296738304.ingest.us.sentry.io/4510045952409600'
 
 # PostHog configuration embedded at build time (empty strings if not provided)
-POSTHOG_API_KEY = ''
+POSTHOG_API_KEY = 'phc_KKnChzZUKeNqZDOTJ6soCBWNQSx3vjiULdwTR9H5Mcr'
 POSTHOG_PROJECT_ID = '191396'
 
 # Logfire configuration embedded at build time (only for dev builds)
-LOGFIRE_ENABLED = 'true'
-LOGFIRE_TOKEN = 'pylf_v1_us_RwZMlJm1tX6j0PL5RWWbmZpzK2hLBNtFWStNKlySfjh8'
+LOGFIRE_ENABLED = ''
+LOGFIRE_TOKEN = ''
 
 # Build metadata
 BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"

shotgun/logging_config.py

@@ -27,6 +27,44 @@ def get_log_directory() -> Path:
     return log_dir
 
 
+def cleanup_old_log_files(log_dir: Path, max_files: int) -> None:
+    """Remove old log files, keeping only the most recent ones.
+
+    Also removes the legacy shotgun.log file if it exists.
+
+    Args:
+        log_dir: Directory containing log files
+        max_files: Maximum number of log files to keep
+    """
+    try:
+        # Remove legacy non-timestamped log file if it exists
+        legacy_log = log_dir / "shotgun.log"
+        if legacy_log.exists():
+            try:
+                legacy_log.unlink()
+            except OSError:
+                pass  # noqa: S110
+
+        # Find all shotgun log files
+        log_files = sorted(
+            log_dir.glob("shotgun-*.log"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,  # Newest first
+        )
+
+        # Remove files beyond the limit
+        files_to_delete = log_files[max_files:]
+        for log_file in files_to_delete:
+            try:
+                log_file.unlink()
+            except OSError:
+                # Ignore errors when deleting individual files
+                pass  # noqa: S110
+    except Exception:  # noqa: S110
+        # Silently fail - log cleanup shouldn't break the application
+        pass
+
+
 class ColoredFormatter(logging.Formatter):
     """Custom formatter with colors for different log levels."""
 
@@ -123,6 +161,10 @@ def setup_logger(
         try:
             # Create file handler with ISO8601 timestamp for each run
             log_dir = get_log_directory()
+
+            # Clean up old log files before creating a new one
+            cleanup_old_log_files(log_dir, settings.logging.max_log_files)
+
             log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
 
             # Use regular FileHandler - each run gets its own isolated log file

shotgun/main.py

@@ -55,6 +55,8 @@ logger = get_logger(__name__)
 logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
+# Note: If config migration fails, ConfigManager will auto-create fresh config
+# and set migration_failed flag for user notification
 try:
     import asyncio
 

shotgun/posthog_telemetry.py

@@ -18,6 +18,9 @@ logger = get_early_logger(__name__)
 # Global PostHog client instance
 _posthog_client = None
 
+# Cache the shotgun instance ID to avoid async calls during event tracking
+_shotgun_instance_id: str | None = None
+
 
 def setup_posthog_observability() -> bool:
     """Set up PostHog analytics for usage tracking.
@@ -25,7 +28,7 @@ def setup_posthog_observability() -> bool:
     Returns:
         True if PostHog was successfully set up, False otherwise
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     try:
         # Check if PostHog is already initialized
@@ -57,31 +60,20 @@ def setup_posthog_observability() -> bool:
         # Store the client for later use
         _posthog_client = posthog
 
-        # Set user context with anonymous shotgun instance ID from config
+        # Cache the shotgun instance ID for later use (avoids async issues)
         try:
             import asyncio
 
             config_manager = get_config_manager()
-            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
-
-            # Identify the user in PostHog
-            posthog.identify(  # type: ignore[attr-defined]
-                distinct_id=shotgun_instance_id,
-                properties={
-                    "version": __version__,
-                    "environment": environment,
-                },
-            )
-
-            # Set default properties for all events
-            posthog.disabled = False
-            posthog.personal_api_key = None  # Not needed for event tracking
+            _shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             logger.debug(
-                "PostHog user identified with anonymous ID: %s", shotgun_instance_id
+                "PostHog initialized with shotgun instance ID: %s",
+                _shotgun_instance_id,
             )
         except Exception as e:
-            logger.warning("Failed to set user context: %s", e)
+            logger.warning("Failed to load shotgun instance ID: %s", e)
+            # Continue anyway - we'll try to get it during event tracking
 
         logger.debug(
             "PostHog analytics configured successfully (environment: %s, version: %s)",
@@ -102,18 +94,19 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         event_name: Name of the event to track
         properties: Optional properties to include with the event
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     if _posthog_client is None:
         logger.debug("PostHog not initialized, skipping event: %s", event_name)
         return
 
     try:
-        import asyncio
-
-        # Get shotgun instance ID for tracking
-        config_manager = get_config_manager()
-        shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
+        # Use cached instance ID (loaded during setup)
+        if _shotgun_instance_id is None:
+            logger.warning(
+                "Shotgun instance ID not available, skipping event: %s", event_name
+            )
+            return
 
         # Add version and environment to properties
         if properties is None:
@@ -128,7 +121,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=shotgun_instance_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:

shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -7,10 +7,11 @@ Your extensive expertise spans, among other things:
 ## KEY RULES
 
 {% if interactive_mode %}
-0. Always ask CLARIFYING QUESTIONS using structured output if the user's request is ambiguous or lacks sufficient detail.
+0. Always ask CLARIFYING QUESTIONS using structured output before doing work.
    - Return your response with the clarifying_questions field populated
-   - Do not make assumptions about what the user wants
+   - Do not make assumptions about what the user wants, get a clear understanding first.
    - Questions should be clear, specific, and answerable
+   - Do not ask too many questions that might overwhelm the user; prioritize the most important ones.
 {% endif %}
 1. Above all, prefer using tools to do the work and NEVER respond with text.
 2. IMPORTANT: Always ask for review and go ahead to move forward after using write_file().

shotgun/sentry_telemetry.py

@@ -1,5 +1,6 @@
 """Sentry observability setup for Shotgun."""
 
+from pathlib import Path
 from typing import Any
 
 from shotgun import __version__
@@ -10,6 +11,122 @@ from shotgun.settings import settings
 logger = get_early_logger(__name__)
 
 
+def _scrub_path(path: str) -> str:
+    """Scrub sensitive information from file paths.
+
+    Removes home directory and current working directory prefixes to prevent
+    leaking usernames that might be part of the path.
+
+    Args:
+        path: The file path to scrub
+
+    Returns:
+        The scrubbed path with sensitive prefixes removed
+    """
+    if not path:
+        return path
+
+    try:
+        # Get home and cwd as Path objects for comparison
+        home = Path.home()
+        cwd = Path.cwd()
+
+        # Convert path to Path object
+        path_obj = Path(path)
+
+        # Try to make path relative to cwd first (most common case)
+        try:
+            relative_to_cwd = path_obj.relative_to(cwd)
+            return str(relative_to_cwd)
+        except ValueError:
+            pass
+
+        # Try to replace home directory with ~
+        try:
+            relative_to_home = path_obj.relative_to(home)
+            return f"~/{relative_to_home}"
+        except ValueError:
+            pass
+
+        # If path is absolute but not under cwd or home, just return filename
+        if path_obj.is_absolute():
+            return path_obj.name
+
+        # Return as-is if already relative
+        return path
+
+    except Exception:
+        # If anything goes wrong, return the original path
+        # Better to leak a path than break error reporting
+        return path
+
+
+def _scrub_sensitive_paths(event: dict[str, Any]) -> None:
+    """Scrub sensitive paths from Sentry event data.
+
+    Modifies the event in-place to remove:
+    - Home directory paths (might contain usernames)
+    - Current working directory paths (might contain usernames)
+    - Server name/hostname
+    - Paths in sys.argv
+
+    Args:
+        event: The Sentry event dictionary to scrub
+    """
+    extra = event.get("extra", {})
+    if "sys.argv" in extra:
+        argv = extra["sys.argv"]
+        if isinstance(argv, list):
+            extra["sys.argv"] = [
+                _scrub_path(arg) if isinstance(arg, str) else arg for arg in argv
+            ]
+
+    # Scrub server name if present
+    if "server_name" in event:
+        event["server_name"] = ""
+
+    # Scrub contexts that might contain paths
+    if "contexts" in event:
+        contexts = event["contexts"]
+        # Remove runtime context if it has CWD
+        if "runtime" in contexts:
+            if "cwd" in contexts["runtime"]:
+                del contexts["runtime"]["cwd"]
+            # Scrub sys.argv to remove paths
+            if "sys.argv" in contexts["runtime"]:
+                argv = contexts["runtime"]["sys.argv"]
+                if isinstance(argv, list):
+                    contexts["runtime"]["sys.argv"] = [
+                        _scrub_path(arg) if isinstance(arg, str) else arg
+                        for arg in argv
+                    ]
+
+    # Scrub exception stack traces
+    if "exception" in event and "values" in event["exception"]:
+        for exception in event["exception"]["values"]:
+            if "stacktrace" in exception and "frames" in exception["stacktrace"]:
+                for frame in exception["stacktrace"]["frames"]:
+                    # Scrub file paths
+                    if "abs_path" in frame:
+                        frame["abs_path"] = _scrub_path(frame["abs_path"])
+                    if "filename" in frame:
+                        frame["filename"] = _scrub_path(frame["filename"])
+
+                    # Scrub local variables that might contain paths
+                    if "vars" in frame:
+                        for var_name, var_value in frame["vars"].items():
+                            if isinstance(var_value, str):
+                                frame["vars"][var_name] = _scrub_path(var_value)
+
+    # Scrub breadcrumbs that might contain paths
+    if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
+        for breadcrumb in event["breadcrumbs"]["values"]:
+            if "data" in breadcrumb:
+                for key, value in breadcrumb["data"].items():
+                    if isinstance(value, str):
+                        breadcrumb["data"][key] = _scrub_path(value)
+
+
 def setup_sentry_observability() -> bool:
     """Set up Sentry observability for error tracking.
 
@@ -41,18 +158,38 @@ def setup_sentry_observability() -> bool:
             environment = "production"
 
         def before_send(event: Any, hint: dict[str, Any]) -> Any:
-            """Filter out user-actionable errors from Sentry.
+            """Filter out user-actionable errors and scrub sensitive paths.
 
             User-actionable errors (like context size limits) are expected conditions
             that users need to resolve, not bugs that need tracking.
+
+            Also scrubs sensitive information like usernames from file paths and
+            working directories to protect user privacy.
             """
+
+            log_record = hint.get("log_record")
+            if log_record:
+                # Scrub pathname using the helper function
+                log_record.pathname = _scrub_path(log_record.pathname)
+
+                # Scrub traceback text if it exists
+                if hasattr(log_record, "exc_text") and isinstance(
+                    log_record.exc_text, str
+                ):
+                    # Replace home directory in traceback text
+                    home = Path.home()
+                    log_record.exc_text = log_record.exc_text.replace(str(home), "~")
+
             if "exc_info" in hint:
-                exc_type, exc_value, tb = hint["exc_info"]
+                _, exc_value, _ = hint["exc_info"]
                 from shotgun.exceptions import ErrorNotPickedUpBySentry
 
                 if isinstance(exc_value, ErrorNotPickedUpBySentry):
                     # Don't send to Sentry - this is user-actionable, not a bug
                     return None
+
+            # Scrub sensitive paths from the event
+            _scrub_sensitive_paths(event)
             return event
 
         # Initialize Sentry
@@ -61,6 +198,7 @@ def setup_sentry_observability() -> bool:
             release=f"shotgun-sh@{__version__}",
             environment=environment,
             send_default_pii=False,  # Privacy-first: never send PII
+            server_name="",  # Privacy: don't send hostname (may contain username)
             traces_sample_rate=0.1 if environment == "production" else 1.0,
             profiles_sample_rate=0.1 if environment == "production" else 1.0,
             before_send=before_send,

shotgun/settings.py

@@ -108,6 +108,11 @@ class LoggingSettings(BaseSettings):
         default=True,
         description="Enable file logging output",
     )
+    max_log_files: int = Field(
+        default=10,
+        description="Maximum number of log files to keep (older files are deleted)",
+        ge=1,
+    )
 
     model_config = SettingsConfigDict(
         env_prefix="SHOTGUN_",

shotgun/tui/app.py

@@ -6,7 +6,10 @@ from textual.binding import Binding
 from textual.screen import Screen
 
 from shotgun.agents.agent_manager import AgentManager
-from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.agents.config import (
+    ConfigManager,
+    get_config_manager,
+)
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
 from shotgun.tui.containers import TUIContainer
@@ -99,7 +102,10 @@ class ShotgunApp(App[None]):
         # Run async config loading in worker
         async def _check_config() -> None:
             # Show welcome screen if no providers are configured OR if user hasn't seen it yet
+            # Note: If config migration fails, ConfigManager will auto-create fresh config
+            # and set migration_failed flag, which WelcomeScreen will display
             config = await self.config_manager.load()
+
             has_any_key = await self.config_manager.has_any_provider_key()
             if not has_any_key or not config.shown_welcome_screen:
                 if isinstance(self.screen, WelcomeScreen):