shotgun-sh 0.1.0.dev6__py3-none-any.whl → 0.1.0.dev8__py3-none-any.whl

shotgun/__init__.py

@@ -1,3 +1,5 @@
 """Shotgun CLI package."""
 
-__version__ = "0.1.0.dev2"
+from importlib.metadata import version
+
+__version__ = version("shotgun-sh")

shotgun/agents/config/manager.py

@@ -1,6 +1,7 @@
 """Configuration manager for Shotgun CLI."""
 
 import json
+import uuid
 from pathlib import Path
 from typing import Any
 
@@ -41,9 +42,11 @@ class ConfigManager:
 
         if not self.config_path.exists():
             logger.info(
-                "Configuration file not found, using defaults: %s", self.config_path
+                "Configuration file not found, creating new config with user_id: %s",
+                self.config_path,
             )
-            self._config = ShotgunConfig()
+            # Create new config with generated user_id
+            self._config = self.initialize()
             return self._config
 
         try:
@@ -61,8 +64,8 @@ class ConfigManager:
             logger.error(
                 "Failed to load configuration from %s: %s", self.config_path, e
             )
-            logger.info("Using default configuration")
-            self._config = ShotgunConfig()
+            logger.info("Creating new configuration with generated user_id")
+            self._config = self.initialize()
             return self._config
 
     def save(self, config: ShotgunConfig | None = None) -> None:
@@ -72,7 +75,14 @@ class ConfigManager:
             config: Configuration to save. If None, saves current loaded config
         """
         if config is None:
-            config = self._config or ShotgunConfig()
+            if self._config:
+                config = self._config
+            else:
+                # Create a new config with generated user_id
+                config = ShotgunConfig(
+                    user_id=str(uuid.uuid4()),
+                    config_version=1,
+                )
 
         # Ensure directory exists
         self.config_path.parent.mkdir(parents=True, exist_ok=True)
@@ -150,9 +160,17 @@ class ConfigManager:
         Returns:
             Default ShotgunConfig
         """
-        config = ShotgunConfig()
+        # Generate unique user ID for new config
+        config = ShotgunConfig(
+            user_id=str(uuid.uuid4()),
+            config_version=1,
+        )
         self.save(config)
-        logger.info("Configuration initialized at %s", self.config_path)
+        logger.info(
+            "Configuration initialized at %s with user_id: %s",
+            self.config_path,
+            config.user_id,
+        )
         return config
 
     def _convert_secrets_to_secretstr(self, data: dict[str, Any]) -> None:
@@ -209,6 +227,15 @@ class ConfigManager:
 
         return bool(value.strip())
 
+    def get_user_id(self) -> str:
+        """Get the user ID from configuration.
+
+        Returns:
+            The unique user ID string
+        """
+        config = self.load()
+        return config.user_id
+
 
 def get_config_manager() -> ConfigManager:
     """Get the global ConfigManager instance."""

shotgun/agents/config/models.py

@@ -123,3 +123,5 @@ class ShotgunConfig(BaseModel):
     default_provider: ProviderType = Field(
         default=ProviderType.OPENAI, description="Default AI provider to use"
     )
+    user_id: str = Field(description="Unique anonymous user identifier")
+    config_version: int = Field(default=1, description="Configuration schema version")

shotgun/build_constants.py

@@ -0,0 +1,20 @@
+"""Build-time constants generated during packaging.
+
+This file is auto-generated during the build process.
+DO NOT EDIT MANUALLY.
+"""
+
+# Sentry DSN embedded at build time (empty string if not provided)
+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_PROJECT_ID = '191396'
+
+# Logfire configuration embedded at build time (only for dev builds)
+LOGFIRE_ENABLED = 'true'
+LOGFIRE_TOKEN = 'pylf_v1_us_KZ5NM1pP3NwgJkbBJt6Ftdzk8mMhmrXcGJHQQgDJ1LfK'
+
+# Build metadata
+BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"
+IS_DEV_BUILD = True

shotgun/cli/config.py

@@ -259,3 +259,17 @@ def _mask_value(value: str) -> str:
     if len(value) <= 8:
         return "••••••••"
     return f"{value[:4]}{'•' * (len(value) - 8)}{value[-4:]}"
+
+
+@app.command()
+def get_user_id() -> None:
+    """Get the anonymous user 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}")
+    except Exception as e:
+        logger.error(f"Error getting user ID: {e}")
+        console.print(f"❌ Failed to get user ID: {str(e)}", style="red")
+        raise typer.Exit(1) from e

shotgun/cli/plan.py

@@ -38,6 +38,17 @@ def plan(
     logger.info("📋 Planning Goal: %s", goal)
 
     try:
+        # Track plan command usage
+        from shotgun.posthog_telemetry import track_event
+
+        track_event(
+            "plan_command",
+            {
+                "non_interactive": non_interactive,
+                "provider": provider.value if provider else "default",
+            },
+        )
+
         # Create agent dependencies
         agent_runtime_options = AgentRuntimeOptions(
             interactive_mode=not non_interactive

shotgun/cli/research.py

@@ -58,6 +58,17 @@ async def async_research(
     provider: ProviderType | None = None,
 ) -> None:
     """Async wrapper for research process."""
+    # Track research command usage
+    from shotgun.posthog_telemetry import track_event
+
+    track_event(
+        "research_command",
+        {
+            "non_interactive": non_interactive,
+            "provider": provider.value if provider else "default",
+        },
+    )
+
     # Create agent dependencies
     agent_runtime_options = AgentRuntimeOptions(interactive_mode=not non_interactive)
 

shotgun/cli/tasks.py

@@ -44,6 +44,17 @@ def tasks(
     logger.info("📋 Task Creation Instruction: %s", instruction)
 
     try:
+        # Track tasks command usage
+        from shotgun.posthog_telemetry import track_event
+
+        track_event(
+            "tasks_command",
+            {
+                "non_interactive": non_interactive,
+                "provider": provider.value if provider else "default",
+            },
+        )
+
         # Create agent dependencies
         agent_runtime_options = AgentRuntimeOptions(
             interactive_mode=not non_interactive

shotgun/cli/update.py

@@ -0,0 +1,152 @@
+"""Update command for shotgun CLI."""
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from shotgun.logging_config import get_logger
+from shotgun.utils.update_checker import (
+    detect_installation_method,
+    get_latest_version,
+    is_dev_version,
+    perform_update,
+)
+
+logger = get_logger(__name__)
+console = Console()
+app = typer.Typer()
+
+
+@app.callback(invoke_without_command=True)
+def update(
+    ctx: typer.Context,
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force",
+            "-f",
+            help="Force update even for development versions",
+        ),
+    ] = False,
+    check_only: Annotated[
+        bool,
+        typer.Option(
+            "--check",
+            "-c",
+            help="Check for updates without installing",
+        ),
+    ] = False,
+) -> None:
+    """Check for and install updates to shotgun-sh.
+
+    This command will:
+    - Check PyPI for the latest version
+    - Detect your installation method (pipx, pip, or venv)
+    - Perform the appropriate upgrade command
+
+    Examples:
+        shotgun update         # Check and install updates
+        shotgun update --check # Only check for updates
+        shotgun update --force # Force update (even for dev versions)
+    """
+    if ctx.resilient_parsing:
+        return
+
+    # Handle check-only mode
+    if check_only:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            progress.add_task("Checking for updates...", total=None)
+
+            latest = get_latest_version()
+            if not latest:
+                console.print(
+                    "[red]✗[/red] Failed to check for updates", style="bold red"
+                )
+                raise typer.Exit(1)
+
+        from shotgun import __version__
+        from shotgun.utils.update_checker import compare_versions
+
+        if compare_versions(__version__, latest):
+            console.print(
+                f"[green]✓[/green] Update available: [cyan]{__version__}[/cyan] → [green]{latest}[/green]",
+                style="bold",
+            )
+            console.print("Run 'shotgun update' to install the update")
+        else:
+            console.print(
+                f"[green]✓[/green] You're on the latest version ([cyan]{__version__}[/cyan])",
+                style="bold",
+            )
+        return
+
+    # Check for dev version
+    if is_dev_version() and not force:
+        console.print(
+            "[yellow]⚠[/yellow] You're running a development version",
+            style="bold yellow",
+        )
+        console.print(
+            "Use --force to update anyway, or install the stable version with:\n"
+            "  pipx install shotgun-sh\n"
+            "  or\n"
+            "  pip install shotgun-sh",
+        )
+        raise typer.Exit(1)
+
+    # Confirm if forcing dev version update
+    if is_dev_version() and force:
+        confirm = typer.confirm(
+            "⚠️  You're about to replace a development version. Continue?",
+            default=False,
+        )
+        if not confirm:
+            console.print("Update cancelled", style="dim")
+            raise typer.Exit(0)
+
+    # Detect installation method
+    method = detect_installation_method()
+    console.print(f"Installation method: [cyan]{method}[/cyan]", style="dim")
+
+    # Perform update
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Updating shotgun-sh...", total=None)
+
+        success, message = perform_update(force=force)
+
+        if success:
+            progress.update(task, description="[green]✓[/green] Update complete!")
+            console.print(f"\n[green]✓[/green] {message}", style="bold green")
+            console.print(
+                "\n[dim]Restart your terminal or run 'shotgun --version' to verify the update[/dim]"
+            )
+        else:
+            progress.update(task, description="[red]✗[/red] Update failed")
+            console.print(f"\n[red]✗[/red] {message}", style="bold red")
+
+            # Provide manual update instructions
+            if method == "pipx":
+                console.print(
+                    "\n[yellow]Try updating manually:[/yellow]\n"
+                    "  pipx upgrade shotgun-sh"
+                )
+            else:
+                console.print(
+                    "\n[yellow]Try updating manually:[/yellow]\n"
+                    "  pip install --upgrade shotgun-sh"
+                )
+            raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

shotgun/main.py

@@ -5,11 +5,15 @@ from typing import Annotated
 import typer
 from dotenv import load_dotenv
 
+from shotgun import __version__
 from shotgun.agents.config import get_config_manager
-from shotgun.cli import codebase, config, plan, research, tasks
+from shotgun.cli import codebase, config, plan, research, tasks, update
 from shotgun.logging_config import configure_root_logger, get_logger
+from shotgun.posthog_telemetry import setup_posthog_observability
+from shotgun.sentry_telemetry import setup_sentry_observability
 from shotgun.telemetry import setup_logfire_observability
 from shotgun.tui import app as tui_app
+from shotgun.utils.update_checker import check_for_updates_async
 
 # Load environment variables from .env file
 load_dotenv()
@@ -29,6 +33,24 @@ except Exception as e:
 _logfire_enabled = setup_logfire_observability()
 logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
+# Initialize Sentry telemetry
+_sentry_enabled = setup_sentry_observability()
+logger.debug("Sentry observability enabled: %s", _sentry_enabled)
+
+# Initialize PostHog analytics
+_posthog_enabled = setup_posthog_observability()
+logger.debug("PostHog analytics enabled: %s", _posthog_enabled)
+
+# Global variable to store update notification
+_update_notification: str | None = None
+
+
+def _update_callback(notification: str) -> None:
+    """Callback to store update notification."""
+    global _update_notification
+    _update_notification = notification
+
+
 app = typer.Typer(
     name="shotgun",
     help="Shotgun - AI-powered CLI tool for research, planning, and task management",
@@ -43,12 +65,16 @@ app.add_typer(
 app.add_typer(research.app, name="research", help="Perform research with agentic loops")
 app.add_typer(plan.app, name="plan", help="Generate structured plans")
 app.add_typer(tasks.app, name="tasks", help="Generate task lists with agentic approach")
+app.add_typer(update.app, name="update", help="Check for and install updates")
 
 
 def version_callback(value: bool) -> None:
     """Show version and exit."""
     if value:
-        logger.info("shotgun 0.1.0")
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"shotgun {__version__}")
         raise typer.Exit()
 
 
@@ -65,14 +91,58 @@ def main(
             help="Show version and exit",
         ),
     ] = False,
+    no_update_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-update-check",
+            help="Disable automatic update checks",
+        ),
+    ] = False,
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
+
+    # Start async update check (non-blocking)
+    if not ctx.resilient_parsing:
+        check_for_updates_async(
+            callback=_update_callback, no_update_check=no_update_check
+        )
+
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
         logger.debug("Launching shotgun TUI application")
-        tui_app.run()
+        tui_app.run(no_update_check=no_update_check)
+
+        # Show update notification after TUI exits
+        if _update_notification:
+            from rich.console import Console
+
+            console = Console()
+            console.print(f"\n[cyan]{_update_notification}[/cyan]", style="bold")
+
         raise typer.Exit()
 
+    # For CLI commands, we'll show notification at the end
+    # This is handled by registering an atexit handler
+    if not ctx.resilient_parsing and ctx.invoked_subcommand is not None:
+        import atexit
+
+        def show_update_notification() -> None:
+            if _update_notification:
+                from rich.console import Console
+
+                console = Console()
+                console.print(f"\n[cyan]{_update_notification}[/cyan]", style="bold")
+
+        atexit.register(show_update_notification)
+
+        # Register PostHog shutdown handler
+        def shutdown_posthog() -> None:
+            from shotgun.posthog_telemetry import shutdown
+
+            shutdown()
+
+        atexit.register(shutdown_posthog)
+
 
 if __name__ == "__main__":
     app()

shotgun/posthog_telemetry.py

@@ -0,0 +1,156 @@
+"""PostHog analytics setup for Shotgun."""
+
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Global PostHog client instance
+_posthog_client = None
+
+
+def setup_posthog_observability() -> bool:
+    """Set up PostHog analytics for usage tracking.
+
+    Returns:
+        True if PostHog was successfully set up, False otherwise
+    """
+    global _posthog_client
+
+    try:
+        import posthog
+
+        # Check if PostHog is already initialized
+        if _posthog_client is not None:
+            logger.debug("PostHog is already initialized, skipping")
+            return True
+
+        # Try to get API key from build constants first (production builds)
+        api_key = None
+
+        try:
+            from shotgun import build_constants
+
+            api_key = build_constants.POSTHOG_API_KEY
+            if api_key:
+                logger.debug("Using PostHog configuration from build constants")
+        except (ImportError, AttributeError):
+            pass
+
+        # Fallback to environment variables if build constants are empty or missing
+        if not api_key:
+            api_key = os.getenv("POSTHOG_API_KEY", "")
+            if api_key:
+                logger.debug("Using PostHog configuration from environment variables")
+
+        if not api_key:
+            logger.debug(
+                "No PostHog API key configured, skipping PostHog initialization"
+            )
+            return False
+
+        logger.debug("Found PostHog configuration, proceeding with setup")
+
+        # Get version for context
+        from shotgun import __version__
+
+        # Determine environment based on version
+        # Dev versions contain "dev", "rc", "alpha", or "beta"
+        if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
+            environment = "development"
+        else:
+            environment = "production"
+
+        # Initialize PostHog client
+        posthog.api_key = api_key
+        posthog.host = "https://us.i.posthog.com"  # Use US cloud instance
+
+        # Store the client for later use
+        _posthog_client = posthog
+
+        # Set user context with anonymous user ID from config
+        try:
+            from shotgun.agents.config import get_config_manager
+
+            config_manager = get_config_manager()
+            user_id = config_manager.get_user_id()
+
+            # Set default properties for all events
+            posthog.disabled = False
+            posthog.personal_api_key = None  # Not needed for event tracking
+
+            logger.debug(
+                "PostHog user context will be set with anonymous ID: %s", user_id
+            )
+        except Exception as e:
+            logger.warning("Failed to get user context: %s", e)
+
+        logger.debug(
+            "PostHog analytics configured successfully (environment: %s, version: %s)",
+            environment,
+            __version__,
+        )
+        return True
+
+    except ImportError as e:
+        logger.error("PostHog SDK not available: %s", e)
+        return False
+    except Exception as e:
+        logger.warning("Failed to setup PostHog analytics: %s", e)
+        return False
+
+
+def track_event(event_name: str, properties: dict[str, Any] | None = None) -> None:
+    """Track an event in PostHog.
+
+    Args:
+        event_name: Name of the event to track
+        properties: Optional properties to include with the event
+    """
+    global _posthog_client
+
+    if _posthog_client is None:
+        logger.debug("PostHog not initialized, skipping event: %s", event_name)
+        return
+
+    try:
+        from shotgun import __version__
+        from shotgun.agents.config import get_config_manager
+
+        # Get user ID for tracking
+        config_manager = get_config_manager()
+        user_id = config_manager.get_user_id()
+
+        # Add version and environment to properties
+        if properties is None:
+            properties = {}
+        properties["version"] = __version__
+
+        # Determine environment
+        if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
+            properties["environment"] = "development"
+        else:
+            properties["environment"] = "production"
+
+        # Track the event using PostHog's capture method
+        _posthog_client.capture(
+            distinct_id=user_id, event=event_name, properties=properties
+        )
+        logger.debug("Tracked PostHog event: %s", event_name)
+    except Exception as e:
+        logger.warning("Failed to track PostHog event '%s': %s", event_name, e)
+
+
+def shutdown() -> None:
+    """Shutdown PostHog client and flush any pending events."""
+    global _posthog_client
+
+    if _posthog_client is not None:
+        try:
+            _posthog_client.shutdown()
+            logger.debug("PostHog client shutdown successfully")
+        except Exception as e:
+            logger.warning("Error shutting down PostHog: %s", e)
+        finally:
+            _posthog_client = None