shotgun-sh 0.1.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

shotgun/codebase/models.py

@@ -1,12 +1,13 @@
 """Data models for codebase service."""
 
-from enum import Enum
+from collections.abc import Callable
+from enum import StrEnum
 from typing import Any
 
 from pydantic import BaseModel, Field
 
 
-class GraphStatus(str, Enum):
+class GraphStatus(StrEnum):
     """Status of a code knowledge graph."""
 
     READY = "READY"  # Graph is ready for queries
@@ -15,13 +16,37 @@ class GraphStatus(str, Enum):
     ERROR = "ERROR"  # Last operation failed
 
 
-class QueryType(str, Enum):
+class QueryType(StrEnum):
     """Type of query being executed."""
 
     NATURAL_LANGUAGE = "natural_language"
     CYPHER = "cypher"
 
 
+class ProgressPhase(StrEnum):
+    """Phase of codebase indexing progress."""
+
+    STRUCTURE = "structure"  # Identifying packages and folders
+    DEFINITIONS = "definitions"  # Processing files and extracting definitions
+    RELATIONSHIPS = "relationships"  # Processing relationships (calls, imports)
+
+
+class IndexProgress(BaseModel):
+    """Progress information for codebase indexing."""
+
+    phase: ProgressPhase = Field(..., description="Current indexing phase")
+    phase_name: str = Field(..., description="Human-readable phase name")
+    current: int = Field(..., description="Current item count")
+    total: int | None = Field(None, description="Total items (None if unknown)")
+    phase_complete: bool = Field(
+        default=False, description="Whether this phase is complete"
+    )
+
+
+# Type alias for progress callback function
+ProgressCallback = Callable[[IndexProgress], None]
+
+
 class OperationStats(BaseModel):
     """Statistics for a graph operation (build/update)."""
 

shotgun/codebase/service.py

@@ -69,11 +69,19 @@ class CodebaseService:
             # Otherwise, check if current directory is in the allowed list
             elif target_path in graph.indexed_from_cwds:
                 filtered_graphs.append(graph)
+            # Also allow access if current directory IS the repository itself
+            # Use Path.resolve() for robust comparison (handles symlinks, etc.)
+            elif Path(target_path).resolve() == Path(graph.repo_path).resolve():
+                filtered_graphs.append(graph)
 
         return filtered_graphs
 
     async def create_graph(
-        self, repo_path: str | Path, name: str, indexed_from_cwd: str | None = None
+        self,
+        repo_path: str | Path,
+        name: str,
+        indexed_from_cwd: str | None = None,
+        progress_callback: Any | None = None,
     ) -> CodebaseGraph:
         """Create and index a new graph from a repository.
 
@@ -81,12 +89,16 @@ class CodebaseService:
             repo_path: Path to the repository to index
             name: Human-readable name for the graph
             indexed_from_cwd: Working directory from which indexing was initiated
+            progress_callback: Optional callback for progress reporting
 
         Returns:
             The created CodebaseGraph
         """
         return await self.manager.build_graph(
-            str(repo_path), name, indexed_from_cwd=indexed_from_cwd
+            str(repo_path),
+            name,
+            indexed_from_cwd=indexed_from_cwd,
+            progress_callback=progress_callback,
         )
 
     async def get_graph(self, graph_id: str) -> CodebaseGraph | None:

shotgun/exceptions.py

@@ -0,0 +1,32 @@
+"""General exceptions for Shotgun application."""
+
+
+class ErrorNotPickedUpBySentry(Exception):  # noqa: N818
+    """Base for user-actionable errors that shouldn't be sent to Sentry.
+
+    These errors represent expected user conditions requiring action
+    rather than bugs that need tracking.
+    """
+
+
+class ContextSizeLimitExceeded(ErrorNotPickedUpBySentry):
+    """Raised when conversation context exceeds the model's limits.
+
+    This is a user-actionable error - they need to either:
+    1. Switch to a larger context model
+    2. Switch to a larger model, compact their conversation, then switch back
+    3. Clear the conversation and start fresh
+    """
+
+    def __init__(self, model_name: str, max_tokens: int):
+        """Initialize the exception.
+
+        Args:
+            model_name: Name of the model whose limit was exceeded
+            max_tokens: Maximum tokens allowed by the model
+        """
+        self.model_name = model_name
+        self.max_tokens = max_tokens
+        super().__init__(
+            f"Context too large for {model_name} (limit: {max_tokens:,} tokens)"
+        )

shotgun/llm_proxy/__init__.py

@@ -0,0 +1,19 @@
+"""LiteLLM proxy client utilities and configuration."""
+
+from .clients import (
+    create_anthropic_proxy_provider,
+    create_litellm_provider,
+)
+from .constants import (
+    LITELLM_PROXY_ANTHROPIC_BASE,
+    LITELLM_PROXY_BASE_URL,
+    LITELLM_PROXY_OPENAI_BASE,
+)
+
+__all__ = [
+    "LITELLM_PROXY_BASE_URL",
+    "LITELLM_PROXY_ANTHROPIC_BASE",
+    "LITELLM_PROXY_OPENAI_BASE",
+    "create_litellm_provider",
+    "create_anthropic_proxy_provider",
+]

shotgun/llm_proxy/clients.py

@@ -0,0 +1,44 @@
+"""Client creation utilities for LiteLLM proxy."""
+
+from pydantic_ai.providers.anthropic import AnthropicProvider
+from pydantic_ai.providers.litellm import LiteLLMProvider
+
+from .constants import LITELLM_PROXY_ANTHROPIC_BASE, LITELLM_PROXY_BASE_URL
+
+
+def create_litellm_provider(api_key: str) -> LiteLLMProvider:
+    """Create LiteLLM provider for Shotgun Account.
+
+    Args:
+        api_key: Shotgun API key
+
+    Returns:
+        Configured LiteLLM provider pointing to Shotgun's proxy
+    """
+    return LiteLLMProvider(
+        api_base=LITELLM_PROXY_BASE_URL,
+        api_key=api_key,
+    )
+
+
+def create_anthropic_proxy_provider(api_key: str) -> AnthropicProvider:
+    """Create Anthropic provider configured for LiteLLM proxy.
+
+    This provider uses native Anthropic API format while routing through
+    the LiteLLM proxy. This preserves Anthropic-specific features like
+    tool_choice and web search.
+
+    The provider's .client attribute provides access to the async Anthropic
+    client (AsyncAnthropic), which should be used for all API operations
+    including token counting.
+
+    Args:
+        api_key: Shotgun API key
+
+    Returns:
+        AnthropicProvider configured to use LiteLLM proxy /anthropic endpoint
+    """
+    return AnthropicProvider(
+        api_key=api_key,
+        base_url=LITELLM_PROXY_ANTHROPIC_BASE,
+    )

shotgun/llm_proxy/constants.py

@@ -0,0 +1,15 @@
+"""LiteLLM proxy constants and configuration."""
+
+# Import from centralized API endpoints module
+from shotgun.api_endpoints import (
+    LITELLM_PROXY_ANTHROPIC_BASE,
+    LITELLM_PROXY_BASE_URL,
+    LITELLM_PROXY_OPENAI_BASE,
+)
+
+# Re-export for backward compatibility
+__all__ = [
+    "LITELLM_PROXY_BASE_URL",
+    "LITELLM_PROXY_ANTHROPIC_BASE",
+    "LITELLM_PROXY_OPENAI_BASE",
+]

shotgun/logging_config.py

@@ -2,12 +2,16 @@
 
 import logging
 import logging.handlers
-import os
 import sys
+from datetime import datetime, timezone
 from pathlib import Path
 
+from shotgun.settings import settings
 from shotgun.utils.env_utils import is_truthy
 
+# Generate a single timestamp for this run to be used across all loggers
+_RUN_TIMESTAMP = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
 
 def get_log_directory() -> Path:
     """Get the log directory path, creating it if necessary.
@@ -66,21 +70,16 @@ def setup_logger(
     logger = logging.getLogger(name)
 
     # Check if we already have a file handler
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If we already have a file handler, just return the logger
     if has_file_handler:
         return logger
 
-    # Get log level from environment variable, default to INFO
-    env_level = os.getenv("SHOTGUN_LOG_LEVEL", "INFO").upper()
-    if env_level not in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
-        env_level = "INFO"
+    # Get log level from settings (already validated and uppercased)
+    log_level = settings.logging.log_level
 
-    logger.setLevel(getattr(logging, env_level))
+    logger.setLevel(getattr(logging, log_level))
 
     # Default format string
     if format_string is None:
@@ -102,13 +101,13 @@ def setup_logger(
     # Check if console logging is enabled (default: off)
     # Force console logging OFF if Logfire is enabled in dev build
     console_logging_enabled = (
-        is_truthy(os.getenv("LOGGING_TO_CONSOLE", "false")) and not is_logfire_dev_build
+        settings.logging.logging_to_console and not is_logfire_dev_build
     )
 
     if console_logging_enabled:
         # Create console handler
         console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setLevel(getattr(logging, env_level))
+        console_handler.setLevel(getattr(logging, log_level))
 
         # Use colored formatter for console
         console_formatter = ColoredFormatter(format_string, datefmt="%H:%M:%S")
@@ -118,26 +117,21 @@ def setup_logger(
         logger.addHandler(console_handler)
 
     # Check if file logging is enabled (default: on)
-    file_logging_enabled = is_truthy(os.getenv("LOGGING_TO_FILE", "true"))
+    file_logging_enabled = settings.logging.logging_to_file
 
     if file_logging_enabled:
         try:
-            # Create file handler with rotation
+            # Create file handler with ISO8601 timestamp for each run
             log_dir = get_log_directory()
-            log_file = log_dir / "shotgun.log"
+            log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
 
-            # Use TimedRotatingFileHandler - rotates daily and keeps 7 days of logs
-            file_handler = logging.handlers.TimedRotatingFileHandler(
+            # Use regular FileHandler - each run gets its own isolated log file
+            file_handler = logging.FileHandler(
                 filename=log_file,
-                when="midnight",  # Rotate at midnight
-                interval=1,  # Every 1 day
-                backupCount=7,  # Keep 7 days of logs
                 encoding="utf-8",
             )
 
-            # Also set max file size (10MB) using RotatingFileHandler as fallback
-            # Note: We'll use TimedRotatingFileHandler which handles both time and size
-            file_handler.setLevel(getattr(logging, env_level))
+            file_handler.setLevel(getattr(logging, log_level))
 
             # Use standard formatter for file (no colors)
             file_formatter = logging.Formatter(
@@ -191,10 +185,7 @@ def get_logger(name: str) -> logging.Logger:
     logger = logging.getLogger(name)
 
     # Check if we have a file handler already
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If no file handler, set up the logger (will add file handler)
     if not has_file_handler:

shotgun/main.py

@@ -1,5 +1,11 @@
 """Main CLI application for shotgun."""
 
+# NOTE: These are before we import any Google library to stop the noisy gRPC logs.
+import os  # noqa: I001
+
+os.environ["GRPC_VERBOSITY"] = "ERROR"
+os.environ["GLOG_minloglevel"] = "2"
+
 import logging
 
 # CRITICAL: Add NullHandler to root logger before ANY other imports.
@@ -16,7 +22,20 @@ from dotenv import load_dotenv
 
 from shotgun import __version__
 from shotgun.agents.config import get_config_manager
-from shotgun.cli import codebase, config, export, plan, research, specify, tasks, update
+from shotgun.cli import (
+    clear,
+    codebase,
+    compact,
+    config,
+    context,
+    export,
+    feedback,
+    plan,
+    research,
+    specify,
+    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
@@ -37,8 +56,10 @@ logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
 try:
+    import asyncio
+
     config_manager = get_config_manager()
-    config_manager.load()  # Ensure config is loaded at startup
+    asyncio.run(config_manager.load())  # Ensure config is loaded at startup
 except Exception as e:
     logger.debug("Configuration initialization warning: %s", e)
 
@@ -62,12 +83,16 @@ app.add_typer(config.app, name="config", help="Manage Shotgun configuration")
 app.add_typer(
     codebase.app, name="codebase", help="Manage and query code knowledge graphs"
 )
+app.add_typer(context.app, name="context", help="Analyze conversation context usage")
+app.add_typer(compact.app, name="compact", help="Compact conversation history")
+app.add_typer(clear.app, name="clear", help="Clear conversation history")
 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(specify.app, name="specify", help="Generate comprehensive specifications")
 app.add_typer(tasks.app, name="tasks", help="Generate task lists with agentic approach")
 app.add_typer(export.app, name="export", help="Export artifacts to various formats")
 app.add_typer(update.app, name="update", help="Check for and install updates")
+app.add_typer(feedback.app, name="feedback", help="Send us feedback")
 
 
 def version_callback(value: bool) -> None:
@@ -108,6 +133,41 @@ def main(
             help="Continue previous TUI conversation",
         ),
     ] = False,
+    web: Annotated[
+        bool,
+        typer.Option(
+            "--web",
+            help="Serve TUI as web application",
+        ),
+    ] = False,
+    port: Annotated[
+        int,
+        typer.Option(
+            "--port",
+            help="Port for web server (only used with --web)",
+        ),
+    ] = 8000,
+    host: Annotated[
+        str,
+        typer.Option(
+            "--host",
+            help="Host address for web server (only used with --web)",
+        ),
+    ] = "localhost",
+    public_url: Annotated[
+        str | None,
+        typer.Option(
+            "--public-url",
+            help="Public URL if behind proxy (only used with --web)",
+        ),
+    ] = None,
+    force_reindex: Annotated[
+        bool,
+        typer.Option(
+            "--force-reindex",
+            help="Force re-indexing of codebase (ignores existing index)",
+        ),
+    ] = False,
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
@@ -117,8 +177,35 @@ def main(
         perform_auto_update_async(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(no_update_check=no_update_check, continue_session=continue_session)
+        if web:
+            logger.debug("Launching shotgun TUI as web application")
+            try:
+                tui_app.serve(
+                    host=host,
+                    port=port,
+                    public_url=public_url,
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if server exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
+        else:
+            logger.debug("Launching shotgun TUI application")
+            try:
+                tui_app.run(
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
         raise typer.Exit()
 
     # For CLI commands, register PostHog shutdown handler

shotgun/posthog_telemetry.py

@@ -1,9 +1,16 @@
 """PostHog analytics setup for Shotgun."""
 
-import os
+from enum import StrEnum
 from typing import Any
 
+import posthog
+from pydantic import BaseModel
+
+from shotgun import __version__
+from shotgun.agents.config import get_config_manager
+from shotgun.agents.conversation_manager import ConversationManager
 from shotgun.logging_config import get_early_logger
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -21,41 +28,20 @@ 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")
+        # Get API key from settings (handles build constants + env vars automatically)
+        api_key = settings.telemetry.posthog_api_key
 
+        # If no API key is available, skip PostHog initialization
         if not api_key:
-            logger.debug(
-                "No PostHog API key configured, skipping PostHog initialization"
-            )
+            logger.debug("No PostHog API key available, skipping initialization")
             return False
 
-        logger.debug("Found PostHog configuration, proceeding with setup")
-
-        # Get version for context
-        from shotgun import __version__
+        logger.debug("Using PostHog API key from settings")
 
         # Determine environment based on version
         # Dev versions contain "dev", "rc", "alpha", or "beta"
@@ -71,22 +57,31 @@ 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:
-            from shotgun.agents.config import get_config_manager
+            import asyncio
 
             config_manager = get_config_manager()
-            user_id = config_manager.get_user_id()
+            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
 
             logger.debug(
-                "PostHog user context will be set with anonymous ID: %s", user_id
+                "PostHog user identified with anonymous ID: %s", shotgun_instance_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 +90,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,12 +109,11 @@ 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
+        import asyncio
 
-        # 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 = asyncio.run(config_manager.get_shotgun_instance_id())
 
         # Add version and environment to properties
         if properties is None:
@@ -137,7 +128,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:
@@ -156,3 +147,59 @@ def shutdown() -> None:
             logger.warning("Error shutting down PostHog: %s", e)
         finally:
             _posthog_client = None
+
+
+class FeedbackKind(StrEnum):
+    BUG = "bug"
+    FEATURE = "feature"
+    OTHER = "other"
+
+
+class Feedback(BaseModel):
+    kind: FeedbackKind
+    description: str
+    shotgun_instance_id: str
+
+
+SURVEY_ID = "01999f81-9486-0000-4fa6-9632959f92f3"
+Q_KIND_ID = "aaa5fcc3-88ba-4c24-bcf5-1481fd5efc2b"
+Q_DESCRIPTION_ID = "a0ed6283-5d4b-452c-9160-6768d879db8a"
+
+
+def submit_feedback_survey(feedback: Feedback) -> None:
+    global _posthog_client
+    if _posthog_client is None:
+        logger.debug("PostHog not initialized, skipping feedback survey")
+        return
+
+    import asyncio
+
+    config_manager = get_config_manager()
+    config = asyncio.run(config_manager.load())
+    conversation_manager = ConversationManager()
+    conversation = None
+    try:
+        conversation = asyncio.run(conversation_manager.load())
+    except Exception as e:
+        logger.debug(f"Failed to load conversation history: {e}")
+    last_10_messages = []
+    if conversation is not None:
+        last_10_messages = conversation.get_agent_messages()[:10]
+
+    track_event(
+        "survey sent",
+        properties={
+            "$survey_id": SURVEY_ID,
+            "$survey_questions": [
+                {"id": Q_KIND_ID, "question": "Feedback type"},
+                {"id": Q_DESCRIPTION_ID, "question": "Feedback description"},
+            ],
+            f"$survey_response_{Q_KIND_ID}": feedback.kind,
+            f"$survey_response_{Q_DESCRIPTION_ID}": feedback.description,
+            "selected_model": config.selected_model.value
+            if config.selected_model
+            else None,
+            "config_version": config.config_version,
+            "last_10_messages": last_10_messages,  # last 10 messages
+        },
+    )