shotgun-sh 0.1.0__py3-none-any.whl

shotgun/agents/tools/web_search/__init__.py

@@ -0,0 +1,60 @@
+"""Web search tools for Pydantic AI agents.
+
+Provides web search capabilities for multiple LLM providers:
+- OpenAI: Uses Responses API with web_search tool
+- Anthropic: Uses Messages API with web_search_20250305 tool
+- Gemini: Uses grounding with Google Search
+"""
+
+from collections.abc import Callable
+
+from shotgun.agents.config.models import ProviderType
+from shotgun.logging_config import get_logger
+
+from .anthropic import anthropic_web_search_tool
+from .gemini import gemini_web_search_tool
+from .openai import openai_web_search_tool
+from .utils import is_provider_available
+
+logger = get_logger(__name__)
+
+# Type alias for web search tools
+WebSearchTool = Callable[[str], str]
+
+
+def get_available_web_search_tools() -> list[WebSearchTool]:
+    """Get list of available web search tools based on configured API keys.
+
+    Returns:
+        List of web search tool functions that have API keys configured
+    """
+    tools: list[WebSearchTool] = []
+
+    if is_provider_available(ProviderType.OPENAI):
+        logger.debug("✅ OpenAI web search tool available")
+        tools.append(openai_web_search_tool)
+
+    if is_provider_available(ProviderType.ANTHROPIC):
+        logger.debug("✅ Anthropic web search tool available")
+        tools.append(anthropic_web_search_tool)
+
+    if is_provider_available(ProviderType.GOOGLE):
+        logger.debug("✅ Gemini web search tool available")
+        tools.append(gemini_web_search_tool)
+
+    if not tools:
+        logger.warning("⚠️ No web search tools available - no API keys configured")
+    else:
+        logger.info("🔍 %d web search tool(s) available", len(tools))
+
+    return tools
+
+
+__all__ = [
+    "openai_web_search_tool",
+    "anthropic_web_search_tool",
+    "gemini_web_search_tool",
+    "get_available_web_search_tools",
+    "is_provider_available",
+    "WebSearchTool",
+]

shotgun/agents/tools/web_search/anthropic.py

@@ -0,0 +1,144 @@
+"""Anthropic web search tool implementation."""
+
+import anthropic
+from opentelemetry import trace
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.config.models import ProviderType
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def anthropic_web_search_tool(query: str) -> str:
+    """Perform a web search using Anthropic's Claude API with streaming.
+
+    This tool uses Anthropic's web search capabilities to find current information
+    about the given query. Results are streamed for faster response times.
+
+    Args:
+        query: The search query
+
+    Returns:
+        Search results as a formatted string
+    """
+    logger.debug("🔧 Invoking Anthropic web_search_tool with query: %s", query)
+
+    span = trace.get_current_span()
+    span.set_attribute("input.value", f"**Query:** {query}\n")
+
+    logger.debug("📡 Executing Anthropic web search with streaming prompt: %s", query)
+
+    # Get API key from centralized configuration
+    try:
+        model_config = get_provider_model(ProviderType.ANTHROPIC)
+        api_key = model_config.api_key
+    except ValueError as e:
+        error_msg = f"Anthropic API key not configured: {str(e)}"
+        logger.error("❌ %s", error_msg)
+        span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
+        return error_msg
+
+    client = anthropic.Anthropic(api_key=api_key)
+
+    # Use the Messages API with web search tool and streaming
+    try:
+        result_text = ""
+
+        with client.messages.stream(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=8192,  # Maximum for Claude 3.5 Sonnet
+            messages=[{"role": "user", "content": f"Search for: {query}"}],
+            tools=[
+                {
+                    "type": "web_search_20250305",
+                    "name": "web_search",
+                }
+            ],
+            tool_choice={"type": "tool", "name": "web_search"},
+        ) as stream:
+            logger.debug("🌊 Started streaming Anthropic web search response")
+
+            for event in stream:
+                if event.type == "content_block_delta":
+                    if hasattr(event.delta, "text"):
+                        result_text += event.delta.text
+                elif event.type == "message_start":
+                    logger.debug("🚀 Streaming started")
+                elif event.type == "message_stop":
+                    logger.debug("✅ Streaming completed")
+
+        if not result_text:
+            result_text = "No content returned from search"
+
+        logger.debug("📄 Anthropic web search result: %d characters", len(result_text))
+        logger.debug(
+            "🔍 Result preview: %s...",
+            result_text[:100] if result_text else "No result",
+        )
+
+        span.set_attribute("output.value", f"**Results:**\n {result_text}\n")
+
+        return result_text
+    except Exception as e:
+        error_msg = f"Error performing Anthropic web search: {str(e)}"
+        logger.error("❌ Anthropic web search failed: %s", str(e))
+        logger.debug("💥 Full error details: %s", error_msg)
+        span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
+        return error_msg
+
+
+def main() -> None:
+    """Main function for testing the Anthropic web search tool."""
+    import os
+    import sys
+
+    from shotgun.logging_config import setup_logger
+
+    # Use project's logging configuration instead of basicConfig
+    setup_logger(__name__)
+
+    if len(sys.argv) < 2:
+        print(
+            "Usage: python -m shotgun.agents.tools.web_search.anthropic <search_query>"
+        )
+        print(
+            "Example: python -m shotgun.agents.tools.web_search.anthropic 'latest Python updates'"
+        )
+        sys.exit(1)
+
+    # Join all arguments as the search query
+    query = " ".join(sys.argv[1:])
+
+    print("🔍 Testing Anthropic Web Search with streaming")
+    print(f"📝 Query: {query}")
+    print("=" * 60)
+
+    # Check if API key is available
+    if not (
+        os.getenv("ANTHROPIC_API_KEY")
+        or (
+            callable(get_provider_model)
+            and get_provider_model(ProviderType.ANTHROPIC).api_key
+        )
+    ):
+        print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
+        print("   Please set it with: export ANTHROPIC_API_KEY=your_key_here")
+        sys.exit(1)
+
+    try:
+        result = anthropic_web_search_tool(query)
+        print(f"✅ Search completed! Result length: {len(result)} characters")
+        print("=" * 60)
+        print("📄 RESULTS:")
+        print("=" * 60)
+        print(result)
+    except KeyboardInterrupt:
+        print("\n⏹️  Search interrupted by user")
+    except Exception as e:
+        print(f"❌ Error during search: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

shotgun/agents/tools/web_search/gemini.py

@@ -0,0 +1,85 @@
+"""Gemini web search tool implementation."""
+
+import google.generativeai as genai
+from opentelemetry import trace
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.config.models import ProviderType
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def gemini_web_search_tool(query: str) -> str:
+    """Perform a web search using Google's Gemini API with grounding.
+
+    This tool uses Gemini's Google Search grounding to find current information
+    about the given query.
+
+    Args:
+        query: The search query
+
+    Returns:
+        Search results as a formatted string
+    """
+    logger.debug("🔧 Invoking Gemini web_search_tool with query: %s", query)
+
+    span = trace.get_current_span()
+    span.set_attribute("input.value", f"**Query:** {query}\n")
+
+    logger.debug("📡 Executing Gemini web search with prompt: %s", query)
+
+    # Get API key from centralized configuration
+    try:
+        model_config = get_provider_model(ProviderType.GOOGLE)
+        api_key = model_config.api_key
+    except ValueError as e:
+        error_msg = f"Gemini API key not configured: {str(e)}"
+        logger.error("❌ %s", error_msg)
+        span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
+        return error_msg
+
+    genai.configure(api_key=api_key)  # type: ignore[attr-defined]
+
+    # Create model without built-in tools to avoid conflict with Pydantic AI
+    # Using prompt-based search approach instead
+    model = genai.GenerativeModel("gemini-2.5-pro")  # type: ignore[attr-defined]
+
+    # Create a search-optimized prompt that leverages Gemini's knowledge
+    search_prompt = f"""Please provide current and accurate information about the following query:
+
+Query: {query}
+
+Instructions:
+- Provide comprehensive, factual information
+- Include relevant details and context
+- Focus on current and recent information
+- Be specific and accurate in your response"""
+
+    # Generate response using the model's knowledge
+    try:
+        response = model.generate_content(
+            search_prompt,
+            generation_config=genai.GenerationConfig(  # type: ignore[attr-defined]
+                temperature=0.3,
+                max_output_tokens=8192,
+            ),
+        )
+
+        result_text = response.text or "No content returned from search"
+
+        logger.debug("📄 Gemini web search result: %d characters", len(result_text))
+        logger.debug(
+            "🔍 Result preview: %s...",
+            result_text[:100] if result_text else "No result",
+        )
+
+        span.set_attribute("output.value", f"**Results:**\n {result_text}\n")
+
+        return result_text
+    except Exception as e:
+        error_msg = f"Error performing Gemini web search: {str(e)}"
+        logger.error("❌ Gemini web search failed: %s", str(e))
+        logger.debug("💥 Full error details: %s", error_msg)
+        span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
+        return error_msg

shotgun/agents/tools/web_search/openai.py

@@ -0,0 +1,98 @@
+"""OpenAI web search tool implementation."""
+
+from openai import OpenAI
+from opentelemetry import trace
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.config.models import ProviderType
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def openai_web_search_tool(query: str) -> str:
+    """Perform a web search and return results.
+
+    This tool uses OpenAI's web search capabilities to find current information
+    about the given query.
+
+    Args:
+        query: The search query
+
+    Returns:
+        Search results as a formatted string
+    """
+    logger.debug("🔧 Invoking OpenAI web_search_tool with query: %s", query)
+
+    span = trace.get_current_span()
+    span.set_attribute("input.value", f"**Query:** {query}\n")
+
+    try:
+        logger.debug("📡 Executing OpenAI web search with prompt: %s", query)
+
+        # Get API key from centralized configuration
+        try:
+            model_config = get_provider_model(ProviderType.OPENAI)
+            api_key = model_config.api_key
+        except ValueError as e:
+            error_msg = f"OpenAI API key not configured: {str(e)}"
+            logger.error("❌ %s", error_msg)
+            span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
+            return error_msg
+
+        prompt = f"""Please provide current and accurate information about the following query:
+
+Query: {query}
+
+Instructions:
+- Provide comprehensive, factual information
+- Include relevant details and context
+- Focus on current and recent information
+- Be specific and accurate in your response
+- You can't ask the user for details, so assume the most relevant details for the query
+
+ALWAYS PROVIDE THE SOURCES (urls) TO BACK UP THE INFORMATION YOU PROVIDE.
+"""
+
+        client = OpenAI(api_key=api_key)
+        response = client.responses.create(  # type: ignore[call-overload]
+            model="gpt-5-mini",
+            input=[
+                {"role": "user", "content": [{"type": "input_text", "text": prompt}]}
+            ],
+            text={
+                "format": {"type": "text"},
+                "verbosity": "high",
+            },  # Increased from medium
+            reasoning={"effort": "medium", "summary": "auto"},
+            tools=[
+                {
+                    "type": "web_search",
+                    "user_location": {"type": "approximate"},
+                    "search_context_size": "high",  # Increased from low for more context
+                }
+            ],
+            store=False,
+            include=[
+                "reasoning.encrypted_content",
+                "web_search_call.action.sources",  # pyright: ignore[reportArgumentType]
+            ],
+        )
+
+        result_text = response.output_text or "No content returned"
+
+        logger.debug("📄 Web search result: %d characters", len(result_text))
+        logger.debug(
+            "🔍 Result preview: %s...",
+            result_text[:100] if result_text else "No result",
+        )
+
+        span.set_attribute("output.value", f"**Results:**\n {result_text}\n")
+
+        return result_text
+    except Exception as e:
+        error_msg = f"Error performing web search: {str(e)}"
+        logger.error("❌ Web search failed: %s", str(e))
+        logger.debug("💥 Full error details: %s", error_msg)
+        span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
+        return error_msg

shotgun/agents/tools/web_search/utils.py

@@ -0,0 +1,20 @@
+"""Utility functions for web search tools."""
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.config.models import ProviderType
+
+
+def is_provider_available(provider: ProviderType) -> bool:
+    """Check if a provider has API key configured.
+
+    Args:
+        provider: The provider to check
+
+    Returns:
+        True if the provider has valid credentials configured (from config or env)
+    """
+    try:
+        get_provider_model(provider)
+        return True
+    except ValueError:
+        return False

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 = ''
+LOGFIRE_TOKEN = ''
+
+# Build metadata
+BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"
+IS_DEV_BUILD = True

shotgun/cli/__init__.py

@@ -0,0 +1 @@
+"""Commands package for shotgun CLI."""

shotgun/cli/codebase/__init__.py

@@ -0,0 +1,5 @@
+"""Codebase CLI module."""
+
+from .commands import app
+
+__all__ = ["app"]

shotgun/cli/codebase/commands.py

@@ -0,0 +1,202 @@
+"""Codebase management CLI commands."""
+
+import asyncio
+import traceback
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from shotgun.codebase.models import CodebaseGraph, QueryType
+from shotgun.logging_config import get_logger
+from shotgun.sdk.codebase import CodebaseSDK
+from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
+
+from ..models import OutputFormat
+from ..utils import output_result
+from .models import ErrorResult
+
+app = typer.Typer(
+    name="codebase",
+    help="Manage and query code knowledge graphs",
+    no_args_is_help=True,
+)
+
+# Set up logger but it will be suppressed by default
+logger = get_logger(__name__)
+
+
+@app.command(name="list")
+def list_codebases(
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """List all indexed codebases."""
+    sdk = CodebaseSDK()
+
+    try:
+        result = asyncio.run(sdk.list_codebases())
+        output_result(result, format_type)
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error listing codebases: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def index(
+    path: Annotated[str, typer.Argument(help="Path to repository to index")],
+    name: Annotated[
+        str, typer.Option("--name", "-n", help="Human-readable name for the codebase")
+    ],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Index a new codebase."""
+    sdk = CodebaseSDK()
+
+    try:
+        repo_path = Path(path)
+        result = asyncio.run(sdk.index_codebase(repo_path, name))
+        output_result(result, format_type)
+    except InvalidPathError as e:
+        error_result = ErrorResult(error_message=str(e))
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error indexing codebase: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def delete(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to delete")],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Delete an indexed codebase."""
+    sdk = CodebaseSDK()
+
+    # CLI-specific confirmation callback
+    def cli_confirm(graph: CodebaseGraph) -> bool:
+        return typer.confirm(
+            f"Are you sure you want to delete codebase '{graph.name}' ({graph_id})?"
+        )
+
+    try:
+        result = asyncio.run(sdk.delete_codebase(graph_id, cli_confirm))
+        output_result(result, format_type)
+        if not result.deleted and not result.cancelled:
+            raise typer.Exit(1)
+    except CodebaseNotFoundError as e:
+        error_result = ErrorResult(error_message=str(e))
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error deleting codebase: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def info(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to show info for")],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Show detailed information about a codebase."""
+    sdk = CodebaseSDK()
+
+    try:
+        result = asyncio.run(sdk.get_info(graph_id))
+        output_result(result, format_type)
+    except CodebaseNotFoundError as e:
+        error_result = ErrorResult(error_message=str(e))
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error getting codebase info: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def query(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to query")],
+    query_text: Annotated[
+        str, typer.Argument(help="Query text (natural language or Cypher)")
+    ],
+    cypher: Annotated[
+        bool,
+        typer.Option(
+            "--cypher", help="Treat query as Cypher instead of natural language"
+        ),
+    ] = False,
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Query a codebase using natural language or Cypher."""
+
+    try:
+        sdk = CodebaseSDK()
+        query_type = QueryType.CYPHER if cypher else QueryType.NATURAL_LANGUAGE
+        result = asyncio.run(sdk.query_codebase(graph_id, query_text, query_type))
+        output_result(result, format_type)
+    except CodebaseNotFoundError as e:
+        error_result = ErrorResult(error_message=str(e))
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error executing query: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def reindex(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to reindex")],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Reindex an existing codebase."""
+
+    try:
+        sdk = CodebaseSDK()
+        result = asyncio.run(sdk.reindex_codebase(graph_id))
+        # Stats are always shown now that verbose is controlled by env var
+        output_result(result, format_type)
+    except CodebaseNotFoundError as e:
+        error_result = ErrorResult(error_message=str(e))
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error reindexing codebase: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e

shotgun/cli/codebase/models.py

@@ -0,0 +1,21 @@
+"""Re-export SDK models for backward compatibility."""
+
+from shotgun.sdk.models import (
+    DeleteResult,
+    ErrorResult,
+    IndexResult,
+    InfoResult,
+    ListResult,
+    QueryCommandResult,
+    ReindexResult,
+)
+
+__all__ = [
+    "ListResult",
+    "IndexResult",
+    "DeleteResult",
+    "InfoResult",
+    "QueryCommandResult",
+    "ReindexResult",
+    "ErrorResult",
+]