shotgun-sh 0.1.0.dev7__tar.gz → 0.1.0.dev9__tar.gz

{shotgun_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/.gitignore

@@ -7,6 +7,9 @@ playground/
 # Output directory
 .shotgun/
 
+# Generated build files
+src/shotgun/build_constants.py
+
 # Claude code
 ./claude/.claude/settings.local.json
 

{shotgun_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.0.dev7
+Version: 0.1.0.dev9
 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
@@ -29,8 +29,11 @@ Requires-Dist: jinja2>=3.1.0
 Requires-Dist: kuzu>=0.7.0
 Requires-Dist: logfire[pydantic-ai]>=2.0.0
 Requires-Dist: openai>=1.0.0
+Requires-Dist: packaging>=23.0
+Requires-Dist: posthog>=3.0.0
 Requires-Dist: pydantic-ai>=0.0.14
 Requires-Dist: rich>=13.0.0
+Requires-Dist: sentry-sdk[pure-eval]>=2.0.0
 Requires-Dist: textual-dev>=1.7.0
 Requires-Dist: textual>=6.1.0
 Requires-Dist: tree-sitter-go>=0.23.0
@@ -131,6 +134,44 @@ uv run shotgun plan "Build a web application"
 uv run shotgun tasks "Create a machine learning model"
 ```
 
+## Auto-Updates
+
+Shotgun automatically checks for updates to keep you on the latest version.
+
+### How it works
+
+- Checks for updates on startup (runs in background, non-blocking)
+- Caches results for 24 hours to minimize API calls
+- Shows notification after command execution if an update is available
+- Never auto-updates development versions
+
+### Update Commands
+
+```bash
+# Check for available updates
+shotgun update --check
+
+# Install available updates
+shotgun update
+
+# Force update (even for dev versions with confirmation)
+shotgun update --force
+```
+
+### Disable Update Checks
+
+```bash
+# Disable for a single command
+shotgun --no-update-check research "topic"
+```
+
+### Installation Methods
+
+The update command automatically detects and uses the appropriate method:
+- **pipx**: `pipx upgrade shotgun-sh`
+- **pip**: `pip install --upgrade shotgun-sh`
+- **venv**: Updates within the virtual environment
+
 ## Development Setup
 
 ### Requirements
@@ -312,6 +353,114 @@ GitHub Actions automatically:
 - Validates code with ruff, ruff-format, and mypy
 - Ensures all checks pass before merge
 
+## Observability & Telemetry
+
+Shotgun includes built-in observability with Sentry for error tracking and Logfire for logging and tracing. Both services track users anonymously using a UUID generated on first run.
+
+### Anonymous User Tracking
+
+Each user gets a unique anonymous ID stored in their config:
+```bash
+# Get your anonymous user ID
+shotgun config get-user-id
+```
+
+This ID is automatically included in:
+- **Sentry**: Error reports and exceptions
+- **Logfire**: All logs, traces, and spans
+
+### Logfire Queries
+
+Logfire uses SQL for querying logs. Here are helpful queries for debugging and analysis:
+
+#### Find all logs for a specific user
+```sql
+SELECT * FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+ORDER BY timestamp DESC;
+```
+
+#### Track user actions
+```sql
+SELECT
+  timestamp,
+  span_name,
+  message,
+  attributes
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND span_name LIKE '%research%'
+ORDER BY timestamp DESC;
+```
+
+#### Find slow operations for a user
+```sql
+SELECT
+  span_name,
+  duration_ms,
+  attributes
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND duration_ms > 1000
+ORDER BY duration_ms DESC;
+```
+
+#### Find errors for a user
+```sql
+SELECT * FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND level = 'error'
+ORDER BY timestamp DESC;
+```
+
+#### Analyze user's AI provider usage
+```sql
+SELECT
+  attributes->>'provider' as provider,
+  COUNT(*) as usage_count,
+  AVG(duration_ms) as avg_duration
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND attributes->>'provider' IS NOT NULL
+GROUP BY provider;
+```
+
+#### Track feature usage by user
+```sql
+SELECT
+  span_name,
+  COUNT(*) as usage_count
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND span_name IN ('research', 'plan', 'tasks')
+GROUP BY span_name
+ORDER BY usage_count DESC;
+```
+
+### Setting Up Observability (Optional)
+
+For local development with Logfire:
+```bash
+# Set environment variables
+export LOGFIRE_ENABLED=true
+export LOGFIRE_TOKEN=your-logfire-token
+
+# Run shotgun - will now send logs to Logfire
+shotgun research "topic"
+```
+
+For Sentry (automatically configured in production builds):
+```bash
+# Set for local development
+export SENTRY_DSN=your-sentry-dsn
+```
+
+### Privacy
+
+- **No PII collected**: Only anonymous UUIDs are used for identification
+- **Opt-in for development**: Telemetry requires explicit environment variables
+- **Automatic in production**: Production builds include telemetry for error tracking
+
 ## Support
 
 Join our discord https://discord.gg/5RmY6J2N7s

{shotgun_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/README.md

@@ -81,6 +81,44 @@ uv run shotgun plan "Build a web application"
 uv run shotgun tasks "Create a machine learning model"
 ```
 
+## Auto-Updates
+
+Shotgun automatically checks for updates to keep you on the latest version.
+
+### How it works
+
+- Checks for updates on startup (runs in background, non-blocking)
+- Caches results for 24 hours to minimize API calls
+- Shows notification after command execution if an update is available
+- Never auto-updates development versions
+
+### Update Commands
+
+```bash
+# Check for available updates
+shotgun update --check
+
+# Install available updates
+shotgun update
+
+# Force update (even for dev versions with confirmation)
+shotgun update --force
+```
+
+### Disable Update Checks
+
+```bash
+# Disable for a single command
+shotgun --no-update-check research "topic"
+```
+
+### Installation Methods
+
+The update command automatically detects and uses the appropriate method:
+- **pipx**: `pipx upgrade shotgun-sh`
+- **pip**: `pip install --upgrade shotgun-sh`
+- **venv**: Updates within the virtual environment
+
 ## Development Setup
 
 ### Requirements
@@ -262,6 +300,114 @@ GitHub Actions automatically:
 - Validates code with ruff, ruff-format, and mypy
 - Ensures all checks pass before merge
 
+## Observability & Telemetry
+
+Shotgun includes built-in observability with Sentry for error tracking and Logfire for logging and tracing. Both services track users anonymously using a UUID generated on first run.
+
+### Anonymous User Tracking
+
+Each user gets a unique anonymous ID stored in their config:
+```bash
+# Get your anonymous user ID
+shotgun config get-user-id
+```
+
+This ID is automatically included in:
+- **Sentry**: Error reports and exceptions
+- **Logfire**: All logs, traces, and spans
+
+### Logfire Queries
+
+Logfire uses SQL for querying logs. Here are helpful queries for debugging and analysis:
+
+#### Find all logs for a specific user
+```sql
+SELECT * FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+ORDER BY timestamp DESC;
+```
+
+#### Track user actions
+```sql
+SELECT
+  timestamp,
+  span_name,
+  message,
+  attributes
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND span_name LIKE '%research%'
+ORDER BY timestamp DESC;
+```
+
+#### Find slow operations for a user
+```sql
+SELECT
+  span_name,
+  duration_ms,
+  attributes
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND duration_ms > 1000
+ORDER BY duration_ms DESC;
+```
+
+#### Find errors for a user
+```sql
+SELECT * FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND level = 'error'
+ORDER BY timestamp DESC;
+```
+
+#### Analyze user's AI provider usage
+```sql
+SELECT
+  attributes->>'provider' as provider,
+  COUNT(*) as usage_count,
+  AVG(duration_ms) as avg_duration
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND attributes->>'provider' IS NOT NULL
+GROUP BY provider;
+```
+
+#### Track feature usage by user
+```sql
+SELECT
+  span_name,
+  COUNT(*) as usage_count
+FROM records
+WHERE attributes->>'user_id' = 'your-user-id-here'
+  AND span_name IN ('research', 'plan', 'tasks')
+GROUP BY span_name
+ORDER BY usage_count DESC;
+```
+
+### Setting Up Observability (Optional)
+
+For local development with Logfire:
+```bash
+# Set environment variables
+export LOGFIRE_ENABLED=true
+export LOGFIRE_TOKEN=your-logfire-token
+
+# Run shotgun - will now send logs to Logfire
+shotgun research "topic"
+```
+
+For Sentry (automatically configured in production builds):
+```bash
+# Set for local development
+export SENTRY_DSN=your-sentry-dsn
+```
+
+### Privacy
+
+- **No PII collected**: Only anonymous UUIDs are used for identification
+- **Opt-in for development**: Telemetry requires explicit environment variables
+- **Automatic in production**: Production builds include telemetry for error tracking
+
 ## Support
 
 Join our discord https://discord.gg/5RmY6J2N7s

shotgun_sh-0.1.0.dev9/hatch_build.py

@@ -0,0 +1,84 @@
+"""Hatchling build hook for generating build constants."""
+
+import os
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+class CustomBuildHook(BuildHookInterface):  # type: ignore[type-arg]
+    """Custom build hook to generate build constants from environment variables."""
+
+    def initialize(self, version, build_data):  # type: ignore[no-untyped-def]
+        """Generate build constants file from environment variables.
+
+        This runs immediately before each build.
+        """
+        # Check if this is a development build based on version
+        is_dev_build = any(
+            marker in str(version)
+            for marker in ["dev", "rc", "alpha", "beta", "a", "b"]
+        )
+
+        # Only generate constants if SENTRY_DSN is provided (production builds)
+        sentry_dsn = os.environ.get("SENTRY_DSN", "")
+
+        # Get PostHog configuration from environment
+        posthog_api_key = os.environ.get("POSTHOG_API_KEY", "")
+        posthog_project_id = os.environ.get("POSTHOG_PROJECT_ID", "")
+
+        # Get Logfire configuration (only for dev builds)
+        logfire_enabled = ""
+        logfire_token = ""
+        if is_dev_build:
+            logfire_enabled = os.environ.get("LOGFIRE_ENABLED", "")
+            logfire_token = os.environ.get("LOGFIRE_TOKEN", "")
+
+        # Generate Python configuration file with build-time constants
+        constants_content = f'''"""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 = {repr(sentry_dsn)}
+
+# PostHog configuration embedded at build time (empty strings if not provided)
+POSTHOG_API_KEY = {repr(posthog_api_key)}
+POSTHOG_PROJECT_ID = {repr(posthog_project_id)}
+
+# Logfire configuration embedded at build time (only for dev builds)
+LOGFIRE_ENABLED = {repr(logfire_enabled)}
+LOGFIRE_TOKEN = {repr(logfire_token)}
+
+# Build metadata
+BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"
+IS_DEV_BUILD = {repr(is_dev_build)}
+'''
+
+        # Write to build_constants.py in the source directory
+        output_path = Path(self.root) / "src" / "shotgun" / "build_constants.py"
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(constants_content)
+
+        # Log the build hook execution
+        features = []
+        if sentry_dsn:
+            features.append("Sentry")
+        if posthog_api_key:
+            features.append("PostHog")
+        if logfire_enabled and logfire_token:
+            features.append("Logfire")
+
+        if features:
+            build_type = "development" if is_dev_build else "production"
+            print(
+                f"✅ Generated build_constants.py with {', '.join(features)} ({build_type} build)"
+            )
+        else:
+            print(
+                "⚠️  Generated build_constants.py without analytics keys (development build)"
+            )

{shotgun_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.0.dev7"
+version = "0.1.0.dev9"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }
@@ -29,6 +29,8 @@ dependencies = [
     "httpx>=0.27.0",
     "jinja2>=3.1.0",
     "logfire[pydantic-ai]>=2.0.0",
+    "sentry-sdk[pure_eval]>=2.0.0",
+    "posthog>=3.0.0",
     "textual>=6.1.0",
     "textual-dev>=1.7.0",
     "kuzu>=0.7.0",
@@ -42,6 +44,7 @@ dependencies = [
     "openai>=1.0.0",
     "anthropic>=0.39.0",
     "google-generativeai>=0.8.0",
+    "packaging>=23.0",
 ]
 
 [project.urls]
@@ -60,7 +63,6 @@ dev = [
 
 [project.scripts]
 shotgun = "shotgun.main:app"
-tui = "shotgun.tui.app:run"
 
 [build-system]
 requires = ["hatchling"]
@@ -77,9 +79,18 @@ include = [
     "/pyproject.toml"
 ]
 
+[tool.hatch.build.hooks.custom]
+# Custom build hook configuration
+
+[tool.hatch.build]
+artifacts = [
+    "src/shotgun/build_constants.py"
+]
+
 [tool.ruff]
 line-length = 88
 target-version = "py310"
+exclude = ["src/shotgun/build_constants.py"]
 
 [tool.ruff.lint]
 select = ["E", "W", "F", "I", "N", "UP", "B", "S", "C4", "PIE", "T20"]
@@ -93,8 +104,8 @@ python_version = "3.10"
 strict = true
 warn_return_any = true
 warn_unused_configs = true
-# Remove test exclusion to enable type checking on tests
-# exclude = ["^test/"]
+# Exclude build hooks and generated files
+exclude = ["hatch_build.py", "src/shotgun/build_constants.py"]
 plugins = ["pydantic.mypy"]
 
 # Configure test-specific settings

shotgun_sh-0.1.0.dev9/src/shotgun/__init__.py

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

{shotgun_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/src/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_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/src/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_sh-0.1.0.dev9/src/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_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/src/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_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/src/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_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/src/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_sh-0.1.0.dev7 → shotgun_sh-0.1.0.dev9}/src/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