shotgun-sh 0.1.0__py3-none-any.whl

shotgun/codebase/service.py

@@ -0,0 +1,206 @@
+"""High-level service for managing codebase graphs and executing queries."""
+
+import time
+from pathlib import Path
+from typing import Any
+
+from shotgun.codebase.core.manager import CodebaseGraphManager
+from shotgun.codebase.core.nl_query import generate_cypher
+from shotgun.codebase.models import CodebaseGraph, QueryResult, QueryType
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class CodebaseService:
+    """High-level service for codebase graph management and querying."""
+
+    def __init__(self, storage_dir: Path | str):
+        """Initialize the service.
+
+        Args:
+            storage_dir: Directory to store graph databases
+        """
+        if isinstance(storage_dir, str):
+            storage_dir = Path(storage_dir)
+
+        self.storage_dir = storage_dir
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+        self.manager = CodebaseGraphManager(storage_dir)
+
+    async def list_graphs(self) -> list[CodebaseGraph]:
+        """List all existing graphs.
+
+        Returns:
+            List of CodebaseGraph objects
+        """
+        return await self.manager.list_graphs()
+
+    async def list_graphs_for_directory(
+        self, directory: Path | str | None = None
+    ) -> list[CodebaseGraph]:
+        """List graphs that match a specific directory.
+
+        Args:
+            directory: Directory to filter by. If None, uses current working directory.
+
+        Returns:
+            List of CodebaseGraph objects accessible from the specified directory
+        """
+        from pathlib import Path
+
+        if directory is None:
+            directory = Path.cwd()
+        elif isinstance(directory, str):
+            directory = Path(directory)
+
+        # Resolve to absolute path for comparison
+        target_path = str(directory.resolve())
+
+        # Get all graphs and filter by those accessible from this directory
+        all_graphs = await self.manager.list_graphs()
+        filtered_graphs = []
+
+        for graph in all_graphs:
+            # If indexed_from_cwds is empty, it's globally accessible (backward compatibility)
+            if not graph.indexed_from_cwds:
+                filtered_graphs.append(graph)
+            # Otherwise, check if current directory is in the allowed list
+            elif target_path in graph.indexed_from_cwds:
+                filtered_graphs.append(graph)
+
+        return filtered_graphs
+
+    async def create_graph(
+        self, repo_path: str | Path, name: str, indexed_from_cwd: str | None = None
+    ) -> CodebaseGraph:
+        """Create and index a new graph from a repository.
+
+        Args:
+            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
+
+        Returns:
+            The created CodebaseGraph
+        """
+        return await self.manager.build_graph(
+            str(repo_path), name, indexed_from_cwd=indexed_from_cwd
+        )
+
+    async def get_graph(self, graph_id: str) -> CodebaseGraph | None:
+        """Get graph metadata by ID.
+
+        Args:
+            graph_id: Graph ID to retrieve
+
+        Returns:
+            CodebaseGraph object or None if not found
+        """
+        return await self.manager.get_graph(graph_id)
+
+    async def add_cwd_access(self, graph_id: str, cwd: str | None = None) -> None:
+        """Add a working directory to a graph's access list.
+
+        Args:
+            graph_id: Graph ID to update
+            cwd: Working directory to add. If None, uses current working directory.
+        """
+        await self.manager.add_cwd_access(graph_id, cwd)
+
+    async def remove_cwd_access(self, graph_id: str, cwd: str) -> None:
+        """Remove a working directory from a graph's access list.
+
+        Args:
+            graph_id: Graph ID to update
+            cwd: Working directory to remove
+        """
+        await self.manager.remove_cwd_access(graph_id, cwd)
+
+    async def delete_graph(self, graph_id: str) -> None:
+        """Delete a graph and its data.
+
+        Args:
+            graph_id: Graph ID to delete
+        """
+        await self.manager.delete_graph(graph_id)
+
+    async def reindex_graph(self, graph_id: str) -> dict[str, Any]:
+        """Rebuild an existing graph (full reindex).
+
+        Args:
+            graph_id: Graph ID to reindex
+
+        Returns:
+            Statistics from the reindex operation
+        """
+        return await self.manager.update_graph_incremental(graph_id)
+
+    async def execute_query(
+        self,
+        graph_id: str,
+        query: str,
+        query_type: QueryType,
+        parameters: dict[str, Any] | None = None,
+    ) -> QueryResult:
+        """Execute a query against a graph.
+
+        Args:
+            graph_id: Graph ID to query
+            query: The query (natural language or Cypher)
+            query_type: Type of query being executed
+            parameters: Optional parameters for Cypher queries
+
+        Returns:
+            QueryResult with results and metadata
+        """
+        start_time = time.time()
+        cypher_query = None
+
+        try:
+            # Handle query type conversion
+            if query_type == QueryType.NATURAL_LANGUAGE:
+                logger.info(f"Converting natural language query to Cypher: {query}")
+                cypher_query = await generate_cypher(query)
+                logger.info(f"Generated Cypher: {cypher_query}")
+                execute_query = cypher_query
+            else:
+                execute_query = query
+
+            # Execute the query
+            results = await self.manager.execute_query(
+                graph_id=graph_id, query=execute_query, parameters=parameters
+            )
+
+            # Extract column names from first result
+            column_names = list(results[0].keys()) if results else []
+
+            execution_time = (time.time() - start_time) * 1000
+
+            return QueryResult(
+                query=query,
+                cypher_query=cypher_query
+                if query_type == QueryType.NATURAL_LANGUAGE
+                else None,
+                results=results,
+                column_names=column_names,
+                row_count=len(results),
+                execution_time_ms=execution_time,
+                success=True,
+                error=None,
+            )
+
+        except Exception as e:
+            execution_time = (time.time() - start_time) * 1000
+            logger.error(f"Query execution failed: {e}")
+
+            return QueryResult(
+                query=query,
+                cypher_query=cypher_query,
+                results=[],
+                column_names=[],
+                row_count=0,
+                execution_time_ms=execution_time,
+                success=False,
+                error=str(e),
+            )

shotgun/logging_config.py

@@ -0,0 +1,227 @@
+"""Centralized logging configuration for Shotgun CLI."""
+
+import logging
+import logging.handlers
+import os
+import sys
+from pathlib import Path
+
+from shotgun.utils.env_utils import is_truthy
+
+
+def get_log_directory() -> Path:
+    """Get the log directory path, creating it if necessary.
+
+    Returns:
+        Path to log directory (~/.shotgun-sh/logs/)
+    """
+    # Lazy import to avoid circular dependency
+    from shotgun.utils.file_system_utils import get_shotgun_home
+
+    log_dir = get_shotgun_home() / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter with colors for different log levels."""
+
+    # ANSI color codes
+    COLORS = {
+        "DEBUG": "\033[36m",  # Cyan
+        "INFO": "\033[32m",  # Green
+        "WARNING": "\033[33m",  # Yellow
+        "ERROR": "\033[31m",  # Red
+        "CRITICAL": "\033[35m",  # Magenta
+    }
+    RESET = "\033[0m"
+
+    def format(self, record: logging.LogRecord) -> str:
+        # Create a copy of the record to avoid modifying the original
+        record = logging.makeLogRecord(record.__dict__)
+
+        # Add color to levelname
+        if record.levelname in self.COLORS:
+            colored_levelname = (
+                f"{self.COLORS[record.levelname]}{record.levelname}{self.RESET}"
+            )
+            record.levelname = colored_levelname
+
+        return super().format(record)
+
+
+def setup_logger(
+    name: str,
+    format_string: str | None = None,
+) -> logging.Logger:
+    """Set up a logger with consistent configuration.
+
+    Args:
+        name: Logger name (typically __name__)
+        format_string: Custom format string, uses default if None
+
+    Returns:
+        Configured logger instance
+    """
+    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
+    )
+
+    # 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"
+
+    logger.setLevel(getattr(logging, env_level))
+
+    # Default format string
+    if format_string is None:
+        format_string = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
+
+    # Check if this is a dev build with Logfire enabled
+    is_logfire_dev_build = False
+    try:
+        from shotgun.build_constants import IS_DEV_BUILD, LOGFIRE_ENABLED
+
+        if IS_DEV_BUILD and is_truthy(LOGFIRE_ENABLED):
+            is_logfire_dev_build = True
+            # This debug message will only appear in file logs
+            logger.debug("Console logging disabled for Logfire dev build")
+    except ImportError:
+        # No build constants available (local development)
+        pass
+
+    # 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
+    )
+
+    if console_logging_enabled:
+        # Create console handler
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setLevel(getattr(logging, env_level))
+
+        # Use colored formatter for console
+        console_formatter = ColoredFormatter(format_string, datefmt="%H:%M:%S")
+        console_handler.setFormatter(console_formatter)
+
+        # Add handler to logger
+        logger.addHandler(console_handler)
+
+    # Check if file logging is enabled (default: on)
+    file_logging_enabled = is_truthy(os.getenv("LOGGING_TO_FILE", "true"))
+
+    if file_logging_enabled:
+        try:
+            # Create file handler with rotation
+            log_dir = get_log_directory()
+            log_file = log_dir / "shotgun.log"
+
+            # Use TimedRotatingFileHandler - rotates daily and keeps 7 days of logs
+            file_handler = logging.handlers.TimedRotatingFileHandler(
+                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))
+
+            # Use standard formatter for file (no colors)
+            file_formatter = logging.Formatter(
+                format_string, datefmt="%Y-%m-%d %H:%M:%S"
+            )
+            file_handler.setFormatter(file_formatter)
+
+            # Add handler to logger
+            logger.addHandler(file_handler)
+        except Exception as e:
+            # If file logging fails, log to stderr but don't crash
+            print(f"Warning: Could not set up file logging: {e}", file=sys.stderr)
+
+    # Prevent propagation to avoid duplicate messages from parent loggers
+    if name != "shotgun":  # Keep propagation for root logger
+        logger.propagate = False
+
+    return logger
+
+
+def get_early_logger(name: str) -> logging.Logger:
+    """Get a logger with NullHandler for early initialization.
+
+    Use this for loggers created at module import time, before
+    configure_root_logger() is called. The NullHandler prevents
+    Python from automatically adding a StreamHandler when WARNING
+    or ERROR messages are logged.
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        Logger with NullHandler attached
+    """
+    logger = logging.getLogger(name)
+    # Only add NullHandler if no handlers exist
+    if not logger.handlers:
+        logger.addHandler(logging.NullHandler())
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Get a logger instance with default configuration.
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        Logger instance with handlers configured
+    """
+    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
+    )
+
+    # If no file handler, set up the logger (will add file handler)
+    if not has_file_handler:
+        return setup_logger(name)
+
+    return logger
+
+
+def set_global_log_level(level: str) -> None:
+    """Set log level for all shotgun loggers.
+
+    Args:
+        level: Log level ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
+    """
+    # Set level for all existing shotgun loggers
+    for name, logger in logging.getLogger().manager.loggerDict.items():
+        if isinstance(logger, logging.Logger) and name.startswith("shotgun"):
+            logger.setLevel(getattr(logging, level.upper()))
+            # Only set handler levels if handlers exist
+            for handler in logger.handlers:
+                handler.setLevel(getattr(logging, level.upper()))
+
+
+def configure_root_logger() -> None:
+    """Configure the root shotgun logger."""
+    # Always set up the root logger to ensure file handler is added
+    setup_logger("shotgun")
+
+    # Also ensure main module gets configured
+    setup_logger("__main__")

shotgun/main.py

@@ -0,0 +1,167 @@
+"""Main CLI application for shotgun."""
+
+import logging
+
+# CRITICAL: Add NullHandler to root logger before ANY other imports.
+# This prevents Python from automatically adding a StreamHandler when
+# WARNING/ERROR messages are logged by modules during import.
+# DO NOT MOVE THIS BELOW OTHER IMPORTS.
+logging.getLogger().addHandler(logging.NullHandler())
+
+# ruff: noqa: E402 (module import not at top - intentionally after NullHandler setup)
+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, export, 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
+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()
+
+# Initialize telemetry FIRST (before logging setup to prevent handler conflicts)
+_logfire_enabled = setup_logfire_observability()
+
+# Initialize logging AFTER telemetry
+configure_root_logger()
+logger = get_logger(__name__)
+logger.debug("Logfire observability enabled: %s", _logfire_enabled)
+
+# Initialize configuration
+try:
+    config_manager = get_config_manager()
+    config_manager.load()  # Ensure config is loaded at startup
+except Exception as e:
+    logger.debug("Configuration initialization warning: %s", e)
+
+# 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",
+    rich_markup_mode="rich",
+)
+
+# Add commands
+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(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")
+
+
+def version_callback(value: bool) -> None:
+    """Show version and exit."""
+    if value:
+        from rich.console import Console
+
+        console = Console()
+        console.print(f"shotgun {__version__}")
+        raise typer.Exit()
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-v",
+            callback=version_callback,
+            is_eager=True,
+            help="Show version and exit",
+        ),
+    ] = False,
+    no_update_check: Annotated[
+        bool,
+        typer.Option(
+            "--no-update-check",
+            help="Disable automatic update checks",
+        ),
+    ] = False,
+    continue_session: Annotated[
+        bool,
+        typer.Option(
+            "--continue",
+            "-c",
+            help="Continue previous TUI conversation",
+        ),
+    ] = 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(no_update_check=no_update_check, continue_session=continue_session)
+
+        # 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()