shotgun-sh 0.1.0.dev2__tar.gz → 0.1.0.dev4__tar.gz

{shotgun_sh-0.1.0.dev2 → shotgun_sh-0.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.0.dev2
+Version: 0.1.0.dev4
 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
@@ -22,20 +22,19 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.39.0
+Requires-Dist: google-generativeai>=0.8.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: kuzu>=0.7.0
-Requires-Dist: openinference-instrumentation-pydantic-ai
-Requires-Dist: opentelemetry-api
-Requires-Dist: opentelemetry-exporter-otlp
-Requires-Dist: opentelemetry-sdk
+Requires-Dist: logfire[pydantic-ai]>=2.0.0
+Requires-Dist: openai>=1.0.0
 Requires-Dist: pydantic-ai>=0.0.14
 Requires-Dist: rich>=13.0.0
 Requires-Dist: textual-dev>=1.7.0
 Requires-Dist: textual>=6.1.0
 Requires-Dist: tree-sitter-go>=0.23.0
 Requires-Dist: tree-sitter-javascript>=0.23.0
-Requires-Dist: tree-sitter-languages>=1.10.0
 Requires-Dist: tree-sitter-python>=0.23.0
 Requires-Dist: tree-sitter-rust>=0.23.0
 Requires-Dist: tree-sitter-typescript>=0.23.0

{shotgun_sh-0.1.0.dev2 → shotgun_sh-0.1.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.0.dev2"
+version = "0.1.0.dev4"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }
@@ -28,10 +28,7 @@ dependencies = [
     "pydantic-ai>=0.0.14",
     "httpx>=0.27.0",
     "jinja2>=3.1.0",
-    "openinference-instrumentation-pydantic-ai",
-    "opentelemetry-sdk",
-    "opentelemetry-exporter-otlp",
-    "opentelemetry-api",
+    "logfire[pydantic-ai]>=2.0.0",
     "textual>=6.1.0",
     "textual-dev>=1.7.0",
     "kuzu>=0.7.0",
@@ -41,8 +38,10 @@ dependencies = [
     "tree-sitter-typescript>=0.23.0",
     "tree-sitter-go>=0.23.0",
     "tree-sitter-rust>=0.23.0",
-    "tree-sitter-languages>=1.10.0",
     "watchdog>=4.0.0",
+    "openai>=1.0.0",
+    "anthropic>=0.39.0",
+    "google-generativeai>=0.8.0",
 ]
 
 [project.urls]

{shotgun_sh-0.1.0.dev2 → shotgun_sh-0.1.0.dev4}/src/shotgun/agents/common.py

@@ -170,7 +170,8 @@ def create_base_agent(
             provider_name.upper(),
             model_config.name,
         )
-        model = model_config.pydantic_model_name
+        # Use the Model instance directly (has API key baked in)
+        model = model_config.model_instance
 
         # Create deps with model config and codebase service
         codebase_service = get_codebase_service()

shotgun_sh-0.1.0.dev4/src/shotgun/agents/config/models.py

@@ -0,0 +1,125 @@
+"""Pydantic models for configuration."""
+
+from enum import Enum
+
+from pydantic import BaseModel, Field, PrivateAttr, SecretStr
+from pydantic_ai.models import Model
+
+
+class ProviderType(str, Enum):
+    """Provider types for AI services."""
+
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    GOOGLE = "google"
+
+
+class ModelSpec(BaseModel):
+    """Static specification for a model - just metadata."""
+
+    name: str  # Model identifier (e.g., "gpt-5", "claude-opus-4-1")
+    provider: ProviderType
+    max_input_tokens: int
+    max_output_tokens: int
+
+
+class ModelConfig(BaseModel):
+    """A fully configured model with API key and settings."""
+
+    name: str  # Model identifier (e.g., "gpt-5", "claude-opus-4-1")
+    provider: ProviderType
+    max_input_tokens: int
+    max_output_tokens: int
+    api_key: str
+    _model_instance: Model | None = PrivateAttr(default=None)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @property
+    def model_instance(self) -> Model:
+        """Lazy load the Model instance."""
+        if self._model_instance is None:
+            from .provider import get_or_create_model
+
+            self._model_instance = get_or_create_model(
+                self.provider, self.name, self.api_key
+            )
+        return self._model_instance
+
+    @property
+    def pydantic_model_name(self) -> str:
+        """Compute the full Pydantic AI model identifier. For backward compatibility."""
+        provider_prefix = {
+            ProviderType.OPENAI: "openai",
+            ProviderType.ANTHROPIC: "anthropic",
+            ProviderType.GOOGLE: "google-gla",
+        }
+        return f"{provider_prefix[self.provider]}:{self.name}"
+
+
+# Model specifications registry (static metadata)
+MODEL_SPECS: dict[str, ModelSpec] = {
+    "gpt-5": ModelSpec(
+        name="gpt-5",
+        provider=ProviderType.OPENAI,
+        max_input_tokens=400_000,
+        max_output_tokens=128_000,
+    ),
+    "gpt-4o": ModelSpec(
+        name="gpt-4o",
+        provider=ProviderType.OPENAI,
+        max_input_tokens=128_000,
+        max_output_tokens=16_000,
+    ),
+    "claude-opus-4-1": ModelSpec(
+        name="claude-opus-4-1",
+        provider=ProviderType.ANTHROPIC,
+        max_input_tokens=200_000,
+        max_output_tokens=32_000,
+    ),
+    "claude-3-5-sonnet-latest": ModelSpec(
+        name="claude-3-5-sonnet-latest",
+        provider=ProviderType.ANTHROPIC,
+        max_input_tokens=200_000,
+        max_output_tokens=20_000,
+    ),
+    "gemini-2.5-pro": ModelSpec(
+        name="gemini-2.5-pro",
+        provider=ProviderType.GOOGLE,
+        max_input_tokens=1_000_000,
+        max_output_tokens=64_000,
+    ),
+}
+
+
+class OpenAIConfig(BaseModel):
+    """Configuration for OpenAI provider."""
+
+    api_key: SecretStr | None = None
+    model_name: str = "gpt-5"
+
+
+class AnthropicConfig(BaseModel):
+    """Configuration for Anthropic provider."""
+
+    api_key: SecretStr | None = None
+    model_name: str = "claude-opus-4-1"
+
+
+class GoogleConfig(BaseModel):
+    """Configuration for Google provider."""
+
+    api_key: SecretStr | None = None
+    model_name: str = "gemini-2.5-pro"
+
+
+class ShotgunConfig(BaseModel):
+    """Main configuration for Shotgun CLI."""
+
+    openai: OpenAIConfig = Field(default_factory=OpenAIConfig)
+    anthropic: AnthropicConfig = Field(default_factory=AnthropicConfig)
+    google: GoogleConfig = Field(default_factory=GoogleConfig)
+    default_provider: ProviderType = Field(
+        default=ProviderType.OPENAI, description="Default AI provider to use"
+    )

shotgun_sh-0.1.0.dev4/src/shotgun/agents/config/provider.py

@@ -0,0 +1,171 @@
+"""Provider management for LLM configuration."""
+
+import os
+
+from pydantic import SecretStr
+from pydantic_ai.models import Model
+from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.models.google import GoogleModel
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.anthropic import AnthropicProvider
+from pydantic_ai.providers.google import GoogleProvider
+from pydantic_ai.providers.openai import OpenAIProvider
+
+from shotgun.logging_config import get_logger
+
+from .manager import get_config_manager
+from .models import MODEL_SPECS, ModelConfig, ProviderType
+
+logger = get_logger(__name__)
+
+# Global cache for Model instances (singleton pattern)
+_model_cache: dict[tuple[ProviderType, str, str], Model] = {}
+
+
+def get_or_create_model(provider: ProviderType, model_name: str, api_key: str) -> Model:
+    """Get or create a singleton Model instance.
+
+    Args:
+        provider: Provider type
+        model_name: Name of the model
+        api_key: API key for the provider
+
+    Returns:
+        Cached or newly created Model instance
+
+    Raises:
+        ValueError: If provider is not supported
+    """
+    cache_key = (provider, model_name, api_key)
+
+    if cache_key not in _model_cache:
+        logger.debug("Creating new %s model instance: %s", provider.value, model_name)
+
+        if provider == ProviderType.OPENAI:
+            openai_provider = OpenAIProvider(api_key=api_key)
+            _model_cache[cache_key] = OpenAIChatModel(
+                model_name, provider=openai_provider
+            )
+        elif provider == ProviderType.ANTHROPIC:
+            anthropic_provider = AnthropicProvider(api_key=api_key)
+            _model_cache[cache_key] = AnthropicModel(
+                model_name, provider=anthropic_provider
+            )
+        elif provider == ProviderType.GOOGLE:
+            google_provider = GoogleProvider(api_key=api_key)
+            _model_cache[cache_key] = GoogleModel(model_name, provider=google_provider)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+    else:
+        logger.debug("Reusing cached %s model instance: %s", provider.value, model_name)
+
+    return _model_cache[cache_key]
+
+
+def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
+    """Get a fully configured ModelConfig with API key and Model instance.
+
+    Args:
+        provider: Provider to get model for. If None, uses default provider
+
+    Returns:
+        ModelConfig with API key configured and lazy Model instance
+
+    Raises:
+        ValueError: If provider is not configured properly or model not found
+    """
+    config_manager = get_config_manager()
+    config = config_manager.load()
+    # Convert string to ProviderType enum if needed
+    provider_enum = (
+        provider
+        if isinstance(provider, ProviderType)
+        else ProviderType(provider)
+        if provider
+        else config.default_provider
+    )
+
+    if provider_enum == ProviderType.OPENAI:
+        api_key = _get_api_key(config.openai.api_key, "OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "OpenAI API key not configured. Set via environment variable OPENAI_API_KEY or config."
+            )
+
+        # Get model spec
+        model_name = config.openai.model_name
+        if model_name not in MODEL_SPECS:
+            raise ValueError(f"Model '{model_name}' not found")
+        spec = MODEL_SPECS[model_name]
+
+        # Create fully configured ModelConfig
+        return ModelConfig(
+            name=spec.name,
+            provider=spec.provider,
+            max_input_tokens=spec.max_input_tokens,
+            max_output_tokens=spec.max_output_tokens,
+            api_key=api_key,
+        )
+
+    elif provider_enum == ProviderType.ANTHROPIC:
+        api_key = _get_api_key(config.anthropic.api_key, "ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Anthropic API key not configured. Set via environment variable ANTHROPIC_API_KEY or config."
+            )
+
+        # Get model spec
+        model_name = config.anthropic.model_name
+        if model_name not in MODEL_SPECS:
+            raise ValueError(f"Model '{model_name}' not found")
+        spec = MODEL_SPECS[model_name]
+
+        # Create fully configured ModelConfig
+        return ModelConfig(
+            name=spec.name,
+            provider=spec.provider,
+            max_input_tokens=spec.max_input_tokens,
+            max_output_tokens=spec.max_output_tokens,
+            api_key=api_key,
+        )
+
+    elif provider_enum == ProviderType.GOOGLE:
+        api_key = _get_api_key(config.google.api_key, "GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Gemini API key not configured. Set via environment variable GEMINI_API_KEY or config."
+            )
+
+        # Get model spec
+        model_name = config.google.model_name
+        if model_name not in MODEL_SPECS:
+            raise ValueError(f"Model '{model_name}' not found")
+        spec = MODEL_SPECS[model_name]
+
+        # Create fully configured ModelConfig
+        return ModelConfig(
+            name=spec.name,
+            provider=spec.provider,
+            max_input_tokens=spec.max_input_tokens,
+            max_output_tokens=spec.max_output_tokens,
+            api_key=api_key,
+        )
+
+    else:
+        raise ValueError(f"Unsupported provider: {provider_enum}")
+
+
+def _get_api_key(config_key: SecretStr | None, env_var: str) -> str | None:
+    """Get API key from config or environment variable.
+
+    Args:
+        config_key: API key from configuration
+        env_var: Environment variable name to check
+
+    Returns:
+        API key string or None
+    """
+    if config_key is not None:
+        return config_key.get_secret_value()
+
+    return os.getenv(env_var)

{shotgun_sh-0.1.0.dev2 → shotgun_sh-0.1.0.dev4}/src/shotgun/agents/research.py

@@ -23,7 +23,7 @@ from .common import (
     run_agent,
 )
 from .models import AgentDeps, AgentRuntimeOptions
-from .tools import web_search_tool
+from .tools import get_available_web_search_tools
 
 logger = get_logger(__name__)
 
@@ -60,11 +60,22 @@ def create_research_agent(
         Tuple of (Configured Pydantic AI agent for research tasks, Agent dependencies)
     """
     logger.debug("Initializing research agent")
+
+    # Get available web search tools based on configured API keys
+    web_search_tools = get_available_web_search_tools()
+    if web_search_tools:
+        logger.info(
+            "Research agent configured with %d web search tool(s)",
+            len(web_search_tools),
+        )
+    else:
+        logger.warning("Research agent configured without web search tools")
+
     agent, deps = create_base_agent(
         _build_research_agent_system_prompt,
         agent_runtime_options,
         load_codebase_understanding_tools=True,
-        additional_tools=[web_search_tool],
+        additional_tools=web_search_tools,
         provider=provider,
     )
     return agent, deps

{shotgun_sh-0.1.0.dev2 → shotgun_sh-0.1.0.dev4}/src/shotgun/agents/tools/__init__.py

@@ -9,10 +9,18 @@ from .codebase import (
 )
 from .file_management import append_file, read_file, write_file
 from .user_interaction import ask_user
-from .web_search import web_search_tool
+from .web_search import (
+    anthropic_web_search_tool,
+    gemini_web_search_tool,
+    get_available_web_search_tools,
+    openai_web_search_tool,
+)
 
 __all__ = [
-    "web_search_tool",
+    "openai_web_search_tool",
+    "anthropic_web_search_tool",
+    "gemini_web_search_tool",
+    "get_available_web_search_tools",
     "ask_user",
     "read_file",
     "write_file",

shotgun_sh-0.1.0.dev4/src/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_sh-0.1.0.dev4/src/shotgun/agents/tools/web_search/anthropic.py

@@ -0,0 +1,86 @@
+"""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.
+
+    This tool uses Anthropic'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 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 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
+    try:
+        response = client.messages.create(
+            model="claude-3-5-sonnet-latest",
+            max_tokens=8192,  # Increased from 4096 for more comprehensive results
+            messages=[{"role": "user", "content": f"Search for: {query}"}],
+            tools=[
+                {
+                    "type": "web_search_20250305",
+                    "name": "web_search",
+                }
+            ],
+            tool_choice={"type": "tool", "name": "web_search"},
+        )
+
+        # Extract the search results from the response
+        result_text = ""
+        if hasattr(response, "content") and response.content:
+            for content in response.content:
+                if hasattr(content, "text"):
+                    result_text += content.text
+                elif hasattr(content, "tool_use") and content.tool_use:
+                    # Handle tool use response
+                    result_text += f"Search performed for: {query}\n"
+
+        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

shotgun_sh-0.1.0.dev4/src/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,  # Explicit limit for comprehensive results
+            ),
+        )
+
+        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