shotgun-sh 0.1.0__py3-none-any.whl

shotgun/sdk/codebase.py

@@ -0,0 +1,219 @@
+"""Codebase SDK for framework-agnostic business logic."""
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from shotgun.codebase.models import CodebaseGraph, QueryType
+
+from .exceptions import CodebaseNotFoundError, InvalidPathError
+from .models import (
+    DeleteResult,
+    IndexResult,
+    InfoResult,
+    ListResult,
+    QueryCommandResult,
+    ReindexResult,
+)
+from .services import get_codebase_service
+
+
+class CodebaseSDK:
+    """Framework-agnostic SDK for codebase operations.
+
+    This SDK provides business logic for codebase management that can be
+    used by both CLI and TUI implementations without framework dependencies.
+    """
+
+    def __init__(self, storage_dir: Path | None = None):
+        """Initialize SDK with optional storage directory.
+
+        Args:
+            storage_dir: Optional custom storage directory.
+                        Defaults to ~/.shotgun-sh/codebases/
+        """
+        self.service = get_codebase_service(storage_dir)
+
+    async def list_codebases(self) -> ListResult:
+        """List all indexed codebases.
+
+        Returns:
+            ListResult containing list of codebases
+        """
+        graphs = await self.service.list_graphs()
+        return ListResult(graphs=graphs)
+
+    async def list_codebases_for_directory(
+        self, directory: Path | None = None
+    ) -> ListResult:
+        """List codebases accessible from a specific directory.
+
+        Args:
+            directory: Directory to filter by. If None, uses current working directory.
+
+        Returns:
+            ListResult containing filtered list of codebases
+        """
+        graphs = await self.service.list_graphs_for_directory(directory)
+        return ListResult(graphs=graphs)
+
+    async def index_codebase(
+        self, path: Path, name: str, indexed_from_cwd: str | None = None
+    ) -> IndexResult:
+        """Index a new codebase.
+
+        Args:
+            path: Path to the repository to index
+            name: Human-readable name for the codebase
+            indexed_from_cwd: Working directory from which indexing was initiated.
+                            If None, uses current working directory.
+
+        Returns:
+            IndexResult with indexing details
+
+        Raises:
+            InvalidPathError: If the path does not exist
+        """
+        resolved_path = path.resolve()
+        if not resolved_path.exists():
+            raise InvalidPathError(f"Path does not exist: {resolved_path}")
+
+        # Default to current working directory if not specified
+        if indexed_from_cwd is None:
+            indexed_from_cwd = str(Path.cwd().resolve())
+
+        graph = await self.service.create_graph(
+            resolved_path, name, indexed_from_cwd=indexed_from_cwd
+        )
+        file_count = sum(graph.language_stats.values()) if graph.language_stats else 0
+
+        return IndexResult(
+            graph_id=graph.graph_id,
+            name=name,
+            repo_path=str(resolved_path),
+            file_count=file_count,
+            node_count=graph.node_count,
+            relationship_count=graph.relationship_count,
+        )
+
+    async def delete_codebase(
+        self,
+        graph_id: str,
+        confirm_callback: Callable[[CodebaseGraph], bool]
+        | Callable[[CodebaseGraph], Awaitable[bool]]
+        | None = None,
+    ) -> DeleteResult:
+        """Delete a codebase with optional confirmation.
+
+        Args:
+            graph_id: ID of the graph to delete
+            confirm_callback: Optional callback for confirmation.
+                            Can be sync or async function that receives
+                            the CodebaseGraph object and returns boolean.
+
+        Returns:
+            DeleteResult indicating success, failure, or cancellation
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        # Handle confirmation callback if provided
+        if confirm_callback:
+            if asyncio.iscoroutinefunction(confirm_callback):
+                confirmed = await confirm_callback(graph)
+            else:
+                confirmed = confirm_callback(graph)
+
+            if not confirmed:
+                return DeleteResult(
+                    graph_id=graph_id,
+                    name=graph.name,
+                    deleted=False,
+                    cancelled=True,
+                )
+
+        await self.service.delete_graph(graph_id)
+        return DeleteResult(
+            graph_id=graph_id,
+            name=graph.name,
+            deleted=True,
+            cancelled=False,
+        )
+
+    async def get_info(self, graph_id: str) -> InfoResult:
+        """Get detailed information about a codebase.
+
+        Args:
+            graph_id: ID of the graph to get info for
+
+        Returns:
+            InfoResult with detailed graph information
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        return InfoResult(graph=graph)
+
+    async def query_codebase(
+        self, graph_id: str, query_text: str, query_type: QueryType
+    ) -> QueryCommandResult:
+        """Query a codebase using natural language or Cypher.
+
+        Args:
+            graph_id: ID of the graph to query
+            query_text: Query text (natural language or Cypher)
+            query_type: Type of query (NATURAL_LANGUAGE or CYPHER)
+
+        Returns:
+            QueryCommandResult with query results
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        query_result = await self.service.execute_query(
+            graph_id, query_text, query_type
+        )
+
+        return QueryCommandResult(
+            graph_name=graph.name,
+            query_type="Cypher"
+            if query_type == QueryType.CYPHER
+            else "natural language",
+            result=query_result,
+        )
+
+    async def reindex_codebase(self, graph_id: str) -> ReindexResult:
+        """Reindex an existing codebase.
+
+        Args:
+            graph_id: ID of the graph to reindex
+
+        Returns:
+            ReindexResult with reindexing details
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        stats = await self.service.reindex_graph(graph_id)
+
+        return ReindexResult(
+            graph_id=graph_id,
+            name=graph.name,
+            stats=stats,
+        )

shotgun/sdk/exceptions.py

@@ -0,0 +1,17 @@
+"""SDK-specific exceptions."""
+
+
+class ShotgunSDKError(Exception):
+    """Base exception for all SDK operations."""
+
+
+class CodebaseNotFoundError(ShotgunSDKError):
+    """Raised when a codebase or graph is not found."""
+
+
+class CodebaseOperationError(ShotgunSDKError):
+    """Raised when a codebase operation fails."""
+
+
+class InvalidPathError(ShotgunSDKError):
+    """Raised when a provided path is invalid."""

shotgun/sdk/models.py

@@ -0,0 +1,189 @@
+"""Result models for SDK operations."""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from shotgun.codebase.models import CodebaseGraph, QueryResult
+
+
+class ListResult(BaseModel):
+    """Result for list command."""
+
+    graphs: list[CodebaseGraph]
+
+    def __str__(self) -> str:
+        """Format list result as plain text table."""
+        if not self.graphs:
+            return "No indexed codebases found."
+
+        lines = [
+            f"{'ID':<12} {'Name':<30} {'Status':<10} {'Files':<8} {'Path'}",
+            "-" * 80,
+        ]
+
+        for graph in self.graphs:
+            file_count = (
+                sum(graph.language_stats.values()) if graph.language_stats else 0
+            )
+            lines.append(
+                f"{graph.graph_id[:12]:<12} {graph.name[:30]:<30} {graph.status.value:<10} {file_count:<8} {graph.repo_path}"
+            )
+
+        return "\n".join(lines)
+
+
+class IndexResult(BaseModel):
+    """Result for index command."""
+
+    graph_id: str
+    name: str
+    repo_path: str
+    file_count: int
+    node_count: int
+    relationship_count: int
+
+    def __str__(self) -> str:
+        """Format index result as success message."""
+        return (
+            "Successfully indexed codebase!\n"
+            f"Graph ID: {self.graph_id}\n"
+            f"Files processed: {self.file_count}\n"
+            f"Nodes: {self.node_count}\n"
+            f"Relationships: {self.relationship_count}"
+        )
+
+
+class DeleteResult(BaseModel):
+    """Result for delete command."""
+
+    graph_id: str
+    name: str
+    deleted: bool
+    cancelled: bool = False
+
+    def __str__(self) -> str:
+        """Format delete result message."""
+        if self.cancelled:
+            return "Deletion cancelled."
+        elif self.deleted:
+            return f"Successfully deleted codebase: {self.graph_id}"
+        else:
+            return f"Failed to delete codebase: {self.graph_id}"
+
+
+class InfoResult(BaseModel):
+    """Result for info command."""
+
+    graph: CodebaseGraph
+
+    def __str__(self) -> str:
+        """Format detailed graph information."""
+        graph = self.graph
+        lines = [
+            f"Graph ID: {graph.graph_id}",
+            f"Name: {graph.name}",
+            f"Status: {graph.status.value}",
+            f"Repository Path: {graph.repo_path}",
+            f"Database Path: {graph.graph_path}",
+            f"Created: {graph.created_at}",
+            f"Updated: {graph.updated_at}",
+            f"Schema Version: {graph.schema_version}",
+            f"Total Nodes: {graph.node_count}",
+            f"Total Relationships: {graph.relationship_count}",
+        ]
+
+        if graph.language_stats:
+            lines.append("\nLanguage Statistics:")
+            for lang, count in graph.language_stats.items():
+                lines.append(f"  {lang}: {count} files")
+
+        if graph.node_stats:
+            lines.append("\nNode Statistics:")
+            for node_type, count in graph.node_stats.items():
+                lines.append(f"  {node_type}: {count}")
+
+        if graph.relationship_stats:
+            lines.append("\nRelationship Statistics:")
+            for rel_type, count in graph.relationship_stats.items():
+                lines.append(f"  {rel_type}: {count}")
+
+        return "\n".join(lines)
+
+
+class QueryCommandResult(BaseModel):
+    """Result for query command."""
+
+    graph_name: str
+    query_type: str
+    result: QueryResult
+
+    def __str__(self) -> str:
+        """Format query results table."""
+        query_result = self.result
+
+        if not query_result.success:
+            return f"Query failed: {query_result.error}"
+
+        if not query_result.results:
+            return "No results found."
+
+        lines = [
+            f"Query executed in {query_result.execution_time_ms:.2f}ms",
+            f"Results: {query_result.row_count} rows",
+        ]
+
+        if query_result.cypher_query:
+            lines.append(f"Generated Cypher: {query_result.cypher_query}")
+
+        lines.append("")  # Empty line
+
+        # Format results table
+        if query_result.column_names:
+            header = " | ".join(f"{col:<20}" for col in query_result.column_names)
+            lines.append(header)
+            lines.append("-" * len(header))
+
+            for row in query_result.results:
+                row_data = " | ".join(
+                    f"{str(row.get(col, '')):<20}" for col in query_result.column_names
+                )
+                lines.append(row_data)
+        else:
+            # Fallback for results without column names
+            for i, row in enumerate(query_result.results):
+                lines.append(f"Row {i + 1}:")
+                for key, value in row.items():
+                    lines.append(f"  {key}: {value}")
+                lines.append("")
+
+        return "\n".join(lines)
+
+
+class ReindexResult(BaseModel):
+    """Result for reindex command."""
+
+    graph_id: str
+    name: str
+    stats: dict[str, Any] | None = None
+
+    def __str__(self) -> str:
+        """Format reindex completion message."""
+        lines = ["Reindexing completed!"]
+        if self.stats:
+            lines.append(f"Stats: {self.stats}")
+        return "\n".join(lines)
+
+
+class ErrorResult(BaseModel):
+    """Result for error cases."""
+
+    error_message: str
+    details: str | None = None
+
+    def __str__(self) -> str:
+        """Format error message."""
+        output = f"Error: {self.error_message}"
+        if self.details:
+            output += f"\n{self.details}"
+        return output

shotgun/sdk/services.py

@@ -0,0 +1,23 @@
+"""Service factory functions for SDK."""
+
+from pathlib import Path
+
+from shotgun.codebase.service import CodebaseService
+from shotgun.utils import get_shotgun_home
+
+
+def get_codebase_service(storage_dir: Path | str | None = None) -> CodebaseService:
+    """Get CodebaseService instance with configurable storage.
+
+    Args:
+        storage_dir: Optional custom storage directory.
+                    Defaults to ~/.shotgun-sh/codebases/
+
+    Returns:
+        Configured CodebaseService instance
+    """
+    if storage_dir is None:
+        storage_dir = get_shotgun_home() / "codebases"
+    elif isinstance(storage_dir, str):
+        storage_dir = Path(storage_dir)
+    return CodebaseService(storage_dir)

shotgun/sentry_telemetry.py

@@ -0,0 +1,87 @@
+"""Sentry observability setup for Shotgun."""
+
+import os
+
+from shotgun.logging_config import get_early_logger
+
+# Use early logger to prevent automatic StreamHandler creation
+logger = get_early_logger(__name__)
+
+
+def setup_sentry_observability() -> bool:
+    """Set up Sentry observability for error tracking.
+
+    Returns:
+        True if Sentry was successfully set up, False otherwise
+    """
+    try:
+        import sentry_sdk
+
+        # Check if Sentry is already initialized
+        if sentry_sdk.is_initialized():
+            logger.debug("Sentry is already initialized, skipping")
+            return True
+
+        # Try to get DSN from build constants first (production builds)
+        dsn = None
+        try:
+            from shotgun import build_constants
+
+            dsn = build_constants.SENTRY_DSN
+            logger.debug("Using Sentry DSN from build constants")
+        except ImportError:
+            # Fallback to environment variable (development)
+            dsn = os.getenv("SENTRY_DSN", "")
+            if dsn:
+                logger.debug("Using Sentry DSN from environment variable")
+
+        if not dsn:
+            logger.debug("No Sentry DSN configured, skipping Sentry initialization")
+            return False
+
+        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"]):
+            environment = "development"
+        else:
+            environment = "production"
+
+        # Initialize Sentry
+        sentry_sdk.init(
+            dsn=dsn,
+            release=f"shotgun-sh@{__version__}",
+            environment=environment,
+            send_default_pii=False,  # Privacy-first: never send PII
+            traces_sample_rate=0.1 if environment == "production" else 1.0,
+            profiles_sample_rate=0.1 if environment == "production" else 1.0,
+        )
+
+        # 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()
+            sentry_sdk.set_user({"id": user_id})
+            logger.debug("Sentry user context set with anonymous ID")
+        except Exception as e:
+            logger.warning("Failed to set Sentry user context: %s", e)
+
+        logger.debug(
+            "Sentry observability configured successfully (environment: %s, version: %s)",
+            environment,
+            __version__,
+        )
+        return True
+
+    except ImportError as e:
+        logger.error("Sentry SDK not available: %s", e)
+        return False
+    except Exception as e:
+        logger.warning("Failed to setup Sentry observability: %s", e)
+        return False

shotgun/telemetry.py

@@ -0,0 +1,93 @@
+"""Observability setup for Logfire."""
+
+import os
+
+from shotgun.logging_config import get_early_logger
+from shotgun.utils.env_utils import is_falsy, is_truthy
+
+# Use early logger to prevent automatic StreamHandler creation
+logger = get_early_logger(__name__)
+
+
+def setup_logfire_observability() -> bool:
+    """Set up Logfire observability if enabled.
+
+    Returns:
+        True if Logfire was successfully set up, False otherwise
+    """
+    # Try to get Logfire configuration from build constants first, fall back to env vars
+    logfire_enabled = None
+    logfire_token = None
+
+    try:
+        from shotgun.build_constants import LOGFIRE_ENABLED, LOGFIRE_TOKEN
+
+        # Use build constants if they're not empty
+        if LOGFIRE_ENABLED:
+            logfire_enabled = LOGFIRE_ENABLED
+        if LOGFIRE_TOKEN:
+            logfire_token = LOGFIRE_TOKEN
+    except ImportError:
+        # No build constants available
+        pass
+
+    # Fall back to environment variables if not set from build constants
+    if not logfire_enabled:
+        logfire_enabled = os.getenv("LOGFIRE_ENABLED", "false")
+    if not logfire_token:
+        logfire_token = os.getenv("LOGFIRE_TOKEN")
+
+    # Allow environment variable to override and disable Logfire
+    env_override = os.getenv("LOGFIRE_ENABLED")
+    if env_override and is_falsy(env_override):
+        logfire_enabled = env_override
+
+    # Check if Logfire observability is enabled
+    if not is_truthy(logfire_enabled):
+        logger.debug("Logfire observability disabled via LOGFIRE_ENABLED")
+        return False
+
+    try:
+        import logfire
+
+        # Check for Logfire token
+        if not logfire_token:
+            logger.warning("LOGFIRE_TOKEN not set, Logfire observability disabled")
+            return False
+
+        # Configure Logfire
+        # Always disable console output - we only want telemetry sent to the web service
+        logfire.configure(
+            token=logfire_token,
+            console=False,  # Never output to console, only send to Logfire service
+        )
+
+        # Instrument Pydantic AI for better observability
+        logfire.instrument_pydantic_ai()
+
+        # Set user context using baggage for all logs and spans
+        try:
+            from opentelemetry import baggage, context
+
+            from shotgun.agents.config import get_config_manager
+
+            config_manager = get_config_manager()
+            user_id = config_manager.get_user_id()
+
+            # Set user_id as baggage in global context - this will be included in all logs/spans
+            ctx = baggage.set_baggage("user_id", user_id)
+            context.attach(ctx)
+            logger.debug("Logfire user context set with user_id: %s", user_id)
+        except Exception as e:
+            logger.warning("Failed to set Logfire user context: %s", e)
+
+        logger.debug("Logfire observability configured successfully")
+        logger.debug("Token configured: %s", "Yes" if logfire_token else "No")
+        return True
+
+    except ImportError as e:
+        logger.warning("Logfire not available: %s", e)
+        return False
+    except Exception as e:
+        logger.warning("Failed to setup Logfire observability: %s", e)
+        return False