shotgun-sh 0.1.10.dev1__tar.gz → 0.1.11.dev1__tar.gz

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.10.dev1
+Version: 0.1.11.dev1
 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.1.10.dev1 → shotgun_sh-0.1.11.dev1}/pyproject.toml

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

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/agents/agent_manager.py

@@ -37,7 +37,9 @@ from textual.widget import Widget
 
 from shotgun.agents.common import add_system_prompt_message, add_system_status_message
 from shotgun.agents.models import AgentType, FileOperation
+from shotgun.posthog_telemetry import track_event
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
+from shotgun.utils.source_detection import detect_source
 
 from .export import create_export_agent
 from .history.compaction import apply_persistent_compaction
@@ -351,6 +353,17 @@ class AgentManager(Widget):
             "gpt-5" in model_name.lower()
         )
 
+        # Track message send event
+        event_name = f"message_send_{self._current_agent_type.value}"
+        track_event(
+            event_name,
+            {
+                "has_prompt": prompt is not None,
+                "has_deferred_results": deferred_tool_results is not None,
+                "model_name": model_name,
+            },
+        )
+
         try:
             result: AgentRunResult[
                 str | DeferredToolRequests
@@ -448,6 +461,22 @@ class AgentManager(Widget):
                         self._post_partial_message(False)
 
                 elif isinstance(event, FunctionToolCallEvent):
+                    # Track tool call event
+
+                    # Detect source from call stack
+                    source = detect_source()
+
+                    track_event(
+                        "tool_called",
+                        {
+                            "tool_name": event.part.tool_name,
+                            "agent_mode": self._current_agent_type.value
+                            if self._current_agent_type
+                            else "unknown",
+                            "source": source,
+                        },
+                    )
+
                     existing_call_idx = next(
                         (
                             i
@@ -477,6 +506,24 @@ class AgentManager(Widget):
                         state.current_response = partial_message
                         self._post_partial_message(False)
                 elif isinstance(event, FunctionToolResultEvent):
+                    # Track tool completion event
+
+                    # Detect source from call stack
+                    source = detect_source()
+
+                    track_event(
+                        "tool_completed",
+                        {
+                            "tool_name": event.result.tool_name
+                            if hasattr(event.result, "tool_name")
+                            else "unknown",
+                            "agent_mode": self._current_agent_type.value
+                            if self._current_agent_type
+                            else "unknown",
+                            "source": source,
+                        },
+                    )
+
                     request_message = ModelRequest(parts=[event.result])
                     state.messages.append(request_message)
                     ## this is what the user responded with

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/agents/history/compaction.py

@@ -5,6 +5,7 @@ from pydantic_ai.usage import RequestUsage
 
 from shotgun.agents.models import AgentDeps
 from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
 
 from .token_estimation import estimate_tokens_from_messages
 
@@ -57,6 +58,20 @@ async def apply_persistent_compaction(
                 f"Persistent compaction applied: {original_size} → {compacted_size} messages "
                 f"({reduction_pct:.1f}% reduction)"
             )
+
+            # Track persistent compaction event
+            track_event(
+                "persistent_compaction_applied",
+                {
+                    "messages_before": original_size,
+                    "messages_after": compacted_size,
+                    "tokens_before": estimated_tokens,
+                    "reduction_percentage": round(reduction_pct, 2),
+                    "agent_mode": deps.agent_mode.value
+                    if hasattr(deps, "agent_mode") and deps.agent_mode
+                    else "unknown",
+                },
+            )
         else:
             logger.debug(
                 f"No persistent compaction needed: {original_size} messages unchanged"

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/agents/history/history_processors.py

@@ -14,6 +14,7 @@ from shotgun.agents.config.models import shotgun_model_request
 from shotgun.agents.messages import AgentSystemPrompt, SystemStatusPrompt
 from shotgun.agents.models import AgentDeps
 from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
 from shotgun.prompts import PromptLoader
 
 from .constants import SUMMARY_MARKER, TOKEN_LIMIT_RATIO
@@ -179,6 +180,10 @@ async def token_limit_compactor(
             "Post-summary conversation exceeds threshold, performing incremental compaction"
         )
 
+        # Track compaction event
+        messages_before = len(messages)
+        tokens_before = post_summary_tokens
+
         # Extract existing summary content
         summary_message = messages[last_summary_index]
         existing_summary_part = None
@@ -320,6 +325,31 @@ async def token_limit_compactor(
         logger.debug(
             f"Incremental compaction complete: {len(messages)} -> {len(compacted_messages)} messages"
         )
+
+        # Track compaction completion
+        messages_after = len(compacted_messages)
+        tokens_after = estimate_tokens_from_messages(compacted_messages, deps.llm_model)
+        reduction_percentage = (
+            ((messages_before - messages_after) / messages_before * 100)
+            if messages_before > 0
+            else 0
+        )
+
+        track_event(
+            "context_compaction_triggered",
+            {
+                "compaction_type": "incremental",
+                "messages_before": messages_before,
+                "messages_after": messages_after,
+                "tokens_before": tokens_before,
+                "tokens_after": tokens_after,
+                "reduction_percentage": round(reduction_percentage, 2),
+                "agent_mode": deps.agent_mode.value
+                if hasattr(deps, "agent_mode") and deps.agent_mode
+                else "unknown",
+            },
+        )
+
         return compacted_messages
 
     else:
@@ -423,4 +453,25 @@ async def _full_compaction(
     # Ensure history ends with ModelRequest for PydanticAI compatibility
     compacted_messages = ensure_ends_with_model_request(compacted_messages, messages)
 
+    # Track full compaction event
+    messages_before = len(messages)
+    messages_after = len(compacted_messages)
+    tokens_before = current_tokens  # Already calculated above
+    tokens_after = summary_usage.output_tokens if summary_usage else 0
+
+    track_event(
+        "context_compaction_triggered",
+        {
+            "compaction_type": "full",
+            "messages_before": messages_before,
+            "messages_after": messages_after,
+            "tokens_before": tokens_before,
+            "tokens_after": tokens_after,
+            "reduction_percentage": round(reduction_percentage, 2),
+            "agent_mode": deps.agent_mode.value
+            if hasattr(deps, "agent_mode") and deps.agent_mode
+            else "unknown",
+        },
+    )
+
     return compacted_messages

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/cli/update.py

@@ -6,8 +6,10 @@ import typer
 from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
+from shotgun import __version__
 from shotgun.logging_config import get_logger
 from shotgun.utils.update_checker import (
+    compare_versions,
     detect_installation_method,
     get_latest_version,
     is_dev_version,
@@ -70,9 +72,6 @@ def update(
                 )
                 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]",

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/posthog_telemetry.py

@@ -1,8 +1,11 @@
 """PostHog analytics setup for Shotgun."""
 
-import os
 from typing import Any
 
+import posthog
+
+from shotgun import __version__
+from shotgun.agents.config import get_config_manager
 from shotgun.logging_config import get_early_logger
 
 # Use early logger to prevent automatic StreamHandler creation
@@ -21,41 +24,15 @@ def setup_posthog_observability() -> bool:
     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")
+        # Hardcoded PostHog configuration
+        api_key = "phc_KKnChzZUKeNqZDOTJ6soCBWNQSx3vjiULdwTR9H5Mcr"
 
-        # Get version for context
-        from shotgun import __version__
+        logger.debug("Using hardcoded PostHog configuration")
 
         # Determine environment based on version
         # Dev versions contain "dev", "rc", "alpha", or "beta"
@@ -73,20 +50,25 @@ def setup_posthog_observability() -> bool:
 
         # 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()
 
+            # Identify the user in PostHog
+            posthog.identify(  # type: ignore[attr-defined]
+                distinct_id=user_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
 
-            logger.debug(
-                "PostHog user context will be set with anonymous ID: %s", user_id
-            )
+            logger.debug("PostHog user identified with anonymous ID: %s", user_id)
         except Exception as e:
-            logger.warning("Failed to get user context: %s", e)
+            logger.warning("Failed to set user context: %s", e)
 
         logger.debug(
             "PostHog analytics configured successfully (environment: %s, version: %s)",
@@ -95,9 +77,6 @@ def setup_posthog_observability() -> bool:
         )
         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
@@ -117,9 +96,6 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         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()

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/sdk/codebase.py

@@ -5,6 +5,9 @@ from collections.abc import Awaitable, Callable
 from pathlib import Path
 
 from shotgun.codebase.models import CodebaseGraph, QueryType
+from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
+from shotgun.utils.source_detection import detect_source
 
 from .exceptions import CodebaseNotFoundError, InvalidPathError
 from .models import (
@@ -17,6 +20,8 @@ from .models import (
 )
 from .services import get_codebase_service
 
+logger = get_logger(__name__)
+
 
 class CodebaseSDK:
     """Framework-agnostic SDK for codebase operations.
@@ -87,6 +92,28 @@ class CodebaseSDK:
         )
         file_count = sum(graph.language_stats.values()) if graph.language_stats else 0
 
+        # Track codebase indexing event
+        # Detect if called from TUI by checking the call stack
+        source = detect_source()
+
+        logger.debug(
+            "Tracking codebase_indexed event: file_count=%d, node_count=%d, relationship_count=%d, source=%s",
+            file_count,
+            graph.node_count,
+            graph.relationship_count,
+            source,
+        )
+
+        track_event(
+            "codebase_indexed",
+            {
+                "file_count": file_count,
+                "node_count": graph.node_count,
+                "relationship_count": graph.relationship_count,
+                "source": source,
+            },
+        )
+
         return IndexResult(
             graph_id=graph.graph_id,
             name=name,
@@ -212,6 +239,28 @@ class CodebaseSDK:
 
         stats = await self.service.reindex_graph(graph_id)
 
+        # Track codebase reindexing event
+        # Detect if called from TUI by checking the call stack
+        source = detect_source()
+
+        logger.debug(
+            "Tracking codebase_reindexed event: nodes_added=%d, nodes_removed=%d, source=%s",
+            stats.get("nodes_added", 0),
+            stats.get("nodes_removed", 0),
+            source,
+        )
+
+        track_event(
+            "codebase_reindexed",
+            {
+                "nodes_added": stats.get("nodes_added", 0),
+                "nodes_removed": stats.get("nodes_removed", 0),
+                "relationships_added": stats.get("relationships_added", 0),
+                "relationships_removed": stats.get("relationships_removed", 0),
+                "source": source,
+            },
+        )
+
         return ReindexResult(
             graph_id=graph_id,
             name=graph.name,

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/sentry_telemetry.py

@@ -2,6 +2,7 @@
 
 import os
 
+from shotgun import __version__
 from shotgun.logging_config import get_early_logger
 
 # Use early logger to prevent automatic StreamHandler creation
@@ -41,9 +42,6 @@ def setup_sentry_observability() -> bool:
 
         logger.debug("Found DSN, proceeding with Sentry setup")
 
-        # Get version for release tracking
-        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"]):

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/tui/screens/chat.py

@@ -41,6 +41,7 @@ from shotgun.agents.models import (
     UserQuestion,
 )
 from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
+from shotgun.posthog_telemetry import track_event
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
 from shotgun.sdk.services import get_codebase_service
@@ -388,6 +389,14 @@ class ChatScreen(Screen[None]):
         """Handle key presses for cancellation."""
         # If escape is pressed while agent is working, cancel the operation
         if event.key == "escape" and self.working and self._current_worker:
+            # Track ESC cancellation event
+            track_event(
+                "agent_cancelled_escape",
+                {
+                    "agent_mode": self.mode.value,
+                },
+            )
+
             # Cancel the running agent worker
             self._current_worker.cancel()
             # Show cancellation message

shotgun_sh-0.1.11.dev1/src/shotgun/utils/source_detection.py

@@ -0,0 +1,16 @@
+"""Utility for detecting the source of function calls (CLI vs TUI)."""
+
+import inspect
+
+
+def detect_source() -> str:
+    """Detect if the call originated from CLI or TUI by inspecting the call stack.
+
+    Returns:
+        "tui" if any frame in the call stack contains "tui" in the filename,
+        "cli" otherwise.
+    """
+    for frame_info in inspect.stack():
+        if "tui" in frame_info.filename.lower():
+            return "tui"
+    return "cli"

{shotgun_sh-0.1.10.dev1 → shotgun_sh-0.1.11.dev1}/src/shotgun/utils/update_checker.py

@@ -5,6 +5,10 @@ import sys
 import threading
 from pathlib import Path
 
+import httpx
+from packaging import version
+
+from shotgun import __version__
 from shotgun.logging_config import get_logger
 
 logger = get_logger(__name__)
@@ -110,13 +114,6 @@ def perform_auto_update_async(no_update_check: bool = False) -> threading.Thread
     return thread
 
 
-# Keep these for backward compatibility with the update CLI command
-import httpx  # noqa: E402
-from packaging import version  # noqa: E402
-
-from shotgun import __version__  # noqa: E402
-
-
 def is_dev_version(version_str: str | None = None) -> bool:
     """Check if the current or given version is a development version.