shotgun-sh 0.1.0.dev2__py3-none-any.whl → 0.1.0.dev4__py3-none-any.whl

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/agents/config/models.py

@@ -2,7 +2,8 @@
 
 from enum import Enum
 
-from pydantic import BaseModel, Field, SecretStr
+from pydantic import BaseModel, Field, PrivateAttr, SecretStr
+from pydantic_ai.models import Model
 
 
 class ProviderType(str, Enum):
@@ -13,17 +14,42 @@ class ProviderType(str, Enum):
     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):
-    """Configuration for an LLM model."""
+    """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."""
+        """Compute the full Pydantic AI model identifier. For backward compatibility."""
         provider_prefix = {
             ProviderType.OPENAI: "openai",
             ProviderType.ANTHROPIC: "anthropic",
@@ -32,60 +58,39 @@ class ModelConfig(BaseModel):
         return f"{provider_prefix[self.provider]}:{self.name}"
 
 
-# OpenAI Models
-GPT_5 = ModelConfig(
-    name="gpt-5",
-    provider=ProviderType.OPENAI,
-    max_input_tokens=400_000,
-    max_output_tokens=128_000,
-)
-
-GPT_4O = ModelConfig(
-    name="gpt-4o",
-    provider=ProviderType.OPENAI,
-    max_input_tokens=128_000,
-    max_output_tokens=16_000,
-)
-
-# Anthropic Models
-CLAUDE_OPUS_4_1 = ModelConfig(
-    name="claude-opus-4-1",
-    provider=ProviderType.ANTHROPIC,
-    max_input_tokens=200_000,
-    max_output_tokens=32_000,
-)
-
-CLAUDE_3_5_SONNET = ModelConfig(
-    name="claude-3-5-sonnet-latest",
-    provider=ProviderType.ANTHROPIC,
-    max_input_tokens=200_000,
-    max_output_tokens=20_000,
-)
-
-# Google Models
-GEMINI_2_5_PRO = ModelConfig(
-    name="gemini-2.5-pro",
-    provider=ProviderType.GOOGLE,
-    max_input_tokens=1_000_000,
-    max_output_tokens=64_000,
-)
-
-# List of all available models
-AVAILABLE_MODELS = [
-    GPT_5,
-    GPT_4O,
-    CLAUDE_OPUS_4_1,
-    CLAUDE_3_5_SONNET,
-    GEMINI_2_5_PRO,
-]
-
-
-def get_model_by_name(name: str) -> ModelConfig:
-    """Find a model configuration by name."""
-    for model in AVAILABLE_MODELS:
-        if model.name == name:
-            return model
-    raise ValueError(f"Model '{name}' not found")
+# 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):

shotgun/agents/config/provider.py

@@ -3,23 +3,73 @@
 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 ModelConfig, ProviderType, get_model_by_name
+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 model configuration for the specified provider.
+    """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 pydantic_model_name and token limits
+        ModelConfig with API key configured and lazy Model instance
 
     Raises:
         ValueError: If provider is not configured properly or model not found
@@ -41,11 +91,21 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
             raise ValueError(
                 "OpenAI API key not configured. Set via environment variable OPENAI_API_KEY or config."
             )
-        # Set the API key in environment if not already there
-        if "OPENAI_API_KEY" not in os.environ:
-            os.environ["OPENAI_API_KEY"] = api_key
 
-        return get_model_by_name(config.openai.model_name)
+        # 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")
@@ -53,23 +113,43 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
             raise ValueError(
                 "Anthropic API key not configured. Set via environment variable ANTHROPIC_API_KEY or config."
             )
-        # Set the API key in environment if not already there
-        if "ANTHROPIC_API_KEY" not in os.environ:
-            os.environ["ANTHROPIC_API_KEY"] = api_key
 
-        return get_model_by_name(config.anthropic.model_name)
+        # 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, "GOOGLE_API_KEY")
+        api_key = _get_api_key(config.google.api_key, "GEMINI_API_KEY")
         if not api_key:
             raise ValueError(
-                "Google API key not configured. Set via environment variable GOOGLE_API_KEY or config."
+                "Gemini API key not configured. Set via environment variable GEMINI_API_KEY or config."
             )
-        # Set the API key in environment if not already there
-        if "GOOGLE_API_KEY" not in os.environ:
-            os.environ["GOOGLE_API_KEY"] = api_key
 
-        return get_model_by_name(config.google.model_name)
+        # 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}")

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/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/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,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/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

shotgun/agents/tools/{web_search.py → web_search/openai.py}

@@ -1,14 +1,16 @@
-"""Web search tool for Pydantic AI agents."""
+"""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 web_search_tool(query: str) -> str:
+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
@@ -20,27 +22,40 @@ def web_search_tool(query: str) -> str:
     Returns:
         Search results as a formatted string
     """
-    logger.debug("🔧 Invoking web_search_tool with query: %s", query)
+    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 web search with prompt: %s", query)
+        logger.debug("📡 Executing OpenAI web search with prompt: %s", query)
 
-        client = OpenAI()
+        # 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
+
+        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": query}]}
             ],
-            text={"format": {"type": "text"}, "verbosity": "medium"},
-            reasoning={"effort": "medium", "summary": "auto"},
+            text={
+                "format": {"type": "text"},
+                "verbosity": "high",
+            },  # Increased from medium
+            reasoning={"effort": "high", "summary": "auto"},  # Increased from medium
             tools=[
                 {
                     "type": "web_search",
                     "user_location": {"type": "approximate"},
-                    "search_context_size": "low",
+                    "search_context_size": "high",  # Increased from low for more context
                 }
             ],
             store=False,

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/cli/research.py

@@ -9,7 +9,6 @@ from shotgun.agents.config import ProviderType
 from shotgun.agents.models import AgentRuntimeOptions
 from shotgun.agents.research import (
     create_research_agent,
-    get_research_history,
     run_research_agent,
 )
 from shotgun.logging_config import get_logger
@@ -70,9 +69,6 @@ async def async_research(
     result = await run_research_agent(agent, query, deps)
 
     # Display results
-    logger.info("✅ Research Complete!")
-    logger.info("📋 Findings:")
-    logger.info("%s", result.output)
-    logger.info("📄 Full research saved to: .shotgun/research.md")
-    logger.debug("📚 Research history:")
-    logger.debug("%s", get_research_history())
+    print("✅ Research Complete!")
+    print("📋 Findings:")
+    print(result.output)

shotgun/codebase/core/nl_query.py

@@ -35,8 +35,9 @@ async def llm_cypher_prompt(system_prompt: str, user_prompt: str) -> str:
         The generated Cypher query as a string
     """
     model_config = get_provider_model()
+    # Use the Model instance directly (has API key baked in)
     query_cypher_response = await model_request(
-        model=model_config.pydantic_model_name,
+        model=model_config.model_instance,
         messages=[
             ModelRequest(
                 parts=[

shotgun/codebase/core/parser_loader.py

@@ -68,32 +68,6 @@ def load_parsers() -> tuple[dict[str, Parser], dict[str, Any]]:
     except ImportError as e:
         logger.warning(f"Failed to import tree_sitter_rust: {e}")
 
-    # If no individual imports worked, try tree_sitter_languages
-    if not available_languages:
-        try:
-            import tree_sitter_languages  # type: ignore[import-untyped]
-
-            # Get available languages from tree_sitter_languages
-            for lang_name in [
-                "python",
-                "javascript",
-                "typescript",
-                "go",
-                "rust",
-                "java",
-                "cpp",
-            ]:
-                try:
-                    lang = tree_sitter_languages.get_language(lang_name)
-                    language_loaders[lang_name] = lambda lang=lang: lang  # type: ignore[misc]
-                    available_languages.append(lang_name)
-                except Exception as e:
-                    logger.debug(f"Failed to load {lang_name} parser: {e}")
-        except ImportError:
-            logger.warning(
-                "No tree-sitter language libraries found. Install tree-sitter-languages or individual language packages."
-            )
-
     logger.info(f"Available languages: {', '.join(available_languages)}")
 
     # Create parsers for available languages
@@ -144,9 +118,11 @@ def load_parsers() -> tuple[dict[str, Parser], dict[str, Any]]:
 
     if not parsers:
         logger.error(
-            "No parsers could be loaded. Please install tree-sitter-languages or language-specific packages."
+            "No parsers could be loaded. Please install language-specific tree-sitter packages."
+        )
+        logger.error(
+            "Install with: pip install tree-sitter-python tree-sitter-javascript tree-sitter-typescript tree-sitter-go tree-sitter-rust"
         )
-        logger.error("Install with: pip install tree-sitter-languages")
         sys.exit(1)
 
     return parsers, queries

shotgun/main.py

@@ -8,7 +8,8 @@ from dotenv import load_dotenv
 from shotgun.agents.config import get_config_manager
 from shotgun.cli import codebase, config, plan, research, tasks
 from shotgun.logging_config import configure_root_logger, get_logger
-from shotgun.telemetry import setup_phoenix_observability
+from shotgun.telemetry import setup_logfire_observability
+from shotgun.tui import app as tui_app
 
 # Load environment variables from .env file
 load_dotenv()
@@ -25,13 +26,12 @@ except Exception as e:
     logger.debug("Configuration initialization warning: %s", e)
 
 # Initialize telemetry
-_telemetry_enabled = setup_phoenix_observability()
-logger.debug("Phoenix observability enabled: %s", _telemetry_enabled)
+_logfire_enabled = setup_logfire_observability()
+logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 app = typer.Typer(
     name="shotgun",
     help="Shotgun - AI-powered CLI tool for research, planning, and task management",
-    no_args_is_help=True,
     rich_markup_mode="rich",
 )
 
@@ -52,8 +52,9 @@ def version_callback(value: bool) -> None:
         raise typer.Exit()
 
 
-@app.callback()
+@app.callback(invoke_without_command=True)
 def main(
+    ctx: typer.Context,
     version: Annotated[
         bool,
         typer.Option(
@@ -67,6 +68,10 @@ def main(
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
+    if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
+        logger.debug("Launching shotgun TUI application")
+        tui_app.run()
+        raise typer.Exit()
 
 
 if __name__ == "__main__":

shotgun/telemetry.py

@@ -1,4 +1,4 @@
-"""Phoenix AI observability setup for cloud and local deployment."""
+"""Observability setup for Logfire."""
 
 import logging
 import os
@@ -6,63 +6,39 @@ import os
 logger = logging.getLogger(__name__)
 
 
-def setup_phoenix_observability() -> bool:
-    """Set up Phoenix AI observability if enabled.
-
-    Supports both local Phoenix and cloud Phoenix (Arize) configurations.
+def setup_logfire_observability() -> bool:
+    """Set up Logfire observability if enabled.
 
     Returns:
-        True if Phoenix was successfully set up, False otherwise
+        True if Logfire was successfully set up, False otherwise
     """
-    # Check if Phoenix observability is enabled
-    if os.getenv("PHOENIX_ENABLED", "false").lower() not in ("true", "1", "yes"):
-        logger.debug("Phoenix AI observability disabled via PHOENIX_ENABLED env var")
+    # Check if Logfire observability is enabled
+    if os.getenv("LOGFIRE_ENABLED", "false").lower() not in ("true", "1", "yes"):
+        logger.debug("Logfire observability disabled via LOGFIRE_ENABLED env var")
         return False
 
     try:
-        # Check if using cloud Phoenix (Arize) or local Phoenix
-        phoenix_collector_endpoint = os.getenv("PHOENIX_COLLECTOR_ENDPOINT")
-        phoenix_api_key = os.getenv("PHOENIX_API_KEY")
+        import logfire
 
-        if not phoenix_collector_endpoint or not phoenix_api_key:
+        # Check for Logfire token
+        logfire_token = os.getenv("LOGFIRE_TOKEN")
+        if not logfire_token:
+            logger.warning("LOGFIRE_TOKEN not set, Logfire observability disabled")
             return False
 
-        # Cloud Phoenix setup (Arize) - following exact docs pattern
-        logger.debug("Setting up cloud Phoenix AI observability")
-
-        from openinference.instrumentation.pydantic_ai import (
-            OpenInferenceSpanProcessor,
-        )
-        from opentelemetry import trace
-        from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
-            OTLPSpanExporter,
-        )
-        from opentelemetry.sdk.trace import TracerProvider
-        from opentelemetry.sdk.trace.export import BatchSpanProcessor
-
-        # Set up tracer provider
-        tracer_provider = TracerProvider()
-        trace.set_tracer_provider(tracer_provider)
-
-        # Set up OTLP exporter for cloud Phoenix
-        # Phoenix cloud expects Authorization header, not api_key
-        otlp_exporter = OTLPSpanExporter(
-            endpoint=phoenix_collector_endpoint,
-            headers={"authorization": f"Bearer {phoenix_api_key}"},
-        )
+        # Configure Logfire
+        logfire.configure(token=logfire_token)
 
-        # Add both span processors - OpenInference for semantics and BatchSpanProcessor for export
-        tracer_provider.add_span_processor(OpenInferenceSpanProcessor())
-        tracer_provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+        # Instrument Pydantic AI for better observability
+        logfire.instrument_pydantic_ai()
 
-        logger.debug("Cloud Phoenix AI observability configured successfully")
-        logger.debug("Endpoint: %s", phoenix_collector_endpoint)
-        logger.debug("API key configured: %s", "Yes" if phoenix_api_key else "No")
+        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("Phoenix AI not available: %s", e)
+        logger.warning("Logfire not available: %s", e)
         return False
     except Exception as e:
-        logger.warning("Failed to setup Phoenix AI observability: %s", e)
+        logger.warning("Failed to setup Logfire observability: %s", e)
         return False

shotgun/tui/screens/chat.py

@@ -146,7 +146,7 @@ class StatusBar(Widget):
     """
 
     def render(self) -> str:
-        return """[$foreground-muted]Press [bold $text]Enter[/] to send • [bold $text]Ctrl+P[/] for command palette • /help for commands[/]"""
+        return """[$foreground-muted][bold $text]enter[/] to send • [bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • /help for commands[/]"""
 
 
 class ModeIndicator(Widget):
@@ -284,12 +284,13 @@ class ChatScreen(Screen[None]):
 
     BINDINGS = [
         ("ctrl+p", "command_palette", "Command Palette"),
+        ("shift+tab", "toggle_mode", "Toggle mode"),
     ]
 
     COMMANDS = {AgentModeProvider, ProviderSetupProvider}
 
     value = reactive("")
-    mode = reactive(AgentType.RESEARCH, recompose=True)
+    mode = reactive(AgentType.RESEARCH)
     history: PromptHistory = PromptHistory()
     messages = reactive(list[ModelMessage]())
     working = reactive(False)
@@ -314,13 +315,19 @@ class ChatScreen(Screen[None]):
 
     def watch_mode(self, new_mode: AgentType) -> None:
         """React to mode changes by updating the agent manager."""
-        if hasattr(self, "agent_manager"):
+
+        if self.is_mounted:
             self.agent_manager.set_agent(new_mode)
 
+            mode_indicator = self.query_one(ModeIndicator)
+            mode_indicator.mode = new_mode
+            mode_indicator.refresh()
+
     def watch_working(self, is_working: bool) -> None:
         """Show or hide the spinner based on working state."""
         if self.is_mounted:
             spinner = self.query_one("#spinner")
+            spinner.set_classes("" if is_working else "hidden")
             spinner.display = is_working
 
     def watch_messages(self, messages: list[ModelMessage]) -> None:
@@ -340,6 +347,13 @@ class ChatScreen(Screen[None]):
                 question_display.update("")
                 question_display.display = False
 
+    def action_toggle_mode(self) -> None:
+        modes = [AgentType.RESEARCH, AgentType.PLAN, AgentType.TASKS]
+        self.mode = modes[(modes.index(self.mode) + 1) % len(modes)]
+        self.agent_manager.set_agent(self.mode)
+        # whoops it actually changes focus. Let's be brutal for now
+        self.call_later(lambda: self.query_one(PromptInput).focus())
+
     @work
     async def add_question_listener(self) -> None:
         while True:
@@ -355,7 +369,11 @@ class ChatScreen(Screen[None]):
             yield Markdown(markdown="", id="question-display")
             yield self.agent_manager
             with Container(id="footer"):
-                yield Spinner(text="Processing...", id="spinner")
+                yield Spinner(
+                    text="Processing...",
+                    id="spinner",
+                    classes="" if self.working else "hidden",
+                )
                 yield StatusBar()
                 yield PromptInput(
                     text=self.value,

shotgun/tui/screens/chat.tcss

@@ -25,4 +25,8 @@ ModeIndicator {
 
 #window {
   align: left bottom;
+}
+
+.hidden {
+  display: none;
 }

{shotgun_sh-0.1.0.dev2.dist-info → shotgun_sh-0.1.0.dev4.dist-info}/METADATA

@@ -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.dist-info → shotgun_sh-0.1.0.dev4.dist-info}/RECORD

@@ -1,25 +1,24 @@
 shotgun/__init__.py,sha256=5pveArOu7XFzA-uGyx58sIlsoja3-yr25JiMg6LaoGY,55
 shotgun/logging_config.py,sha256=EJL2kpwH8-zRtpKit3_BbpeUxbRR-wen3MaNXuHCoD4,5600
-shotgun/main.py,sha256=41ENJ7j2sNYVUSFOvry-nh_yZkUe8WwkayvzG056OTQ,2055
+shotgun/main.py,sha256=SOwxw49hbWlSe_APstonRU3uB34fIToYfx-GFGmXolE,2291
 shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shotgun/telemetry.py,sha256=aq9wd-t2bYyCpRV927mUQdqMcL67QoZgsu3oZrVu83w,2605
+shotgun/telemetry.py,sha256=42mItPr4uZ5NtMF--WbRCy2DX8o_cN_zz4se3E3ULLA,1346
 shotgun/agents/__init__.py,sha256=8Jzv1YsDuLyNPFJyckSr_qI4ehTVeDyIMDW4omsfPGc,25
 shotgun/agents/agent_manager.py,sha256=1Aof8btrV2Ei3V3bNn8bLzdBiBsJ-sjaQq0t7bnwbpo,6564
-shotgun/agents/common.py,sha256=BxeZkkMsT1gWR_EwFXo4gjatuWarT0nct1o2xeIahas,9379
+shotgun/agents/common.py,sha256=xNlbvwt68de2588930iI4JnNVyPMGsUEwf_ySFXttFE,9439
 shotgun/agents/models.py,sha256=EY84zpsZW1g-K6-JHVDJoO6R_Q6ZM7YKyUtZO1j0Gmo,2453
 shotgun/agents/plan.py,sha256=mSkaMfavZ1-WNJ-Yk-8ivbNtmbOz-TZI4oO8vIXXu5Y,3537
-shotgun/agents/research.py,sha256=JZKioKrl9ExiwRilCvz66orn1gKX3GO-D-EULCHy85c,3705
+shotgun/agents/research.py,sha256=zDoS1BLVn7Wvcc4VAoYWOZ33IhtaHCY_CIlvEFiD1_A,4089
 shotgun/agents/tasks.py,sha256=8miXmOB6zp-9jTZgzpgs-109M5BWAg0n5-TD5D8tm1c,3648
 shotgun/agents/config/__init__.py,sha256=Fl8K_81zBpm-OfOW27M_WWLSFdaHHek6lWz95iDREjQ,318
 shotgun/agents/config/manager.py,sha256=d5Eb0TK6Fwez9XN3f33_meGxs2iP7lukwaAyJM5e4fQ,7821
-shotgun/agents/config/models.py,sha256=ziQoHEAL15GgVBrpS-tW2kPlHSVwn8imhRdbOunnVRY,2906
-shotgun/agents/config/provider.py,sha256=XZHi8_AHTG8bKjaNXnmx0hCvWSmtfNp6HCHjaedxUcg,3029
+shotgun/agents/config/models.py,sha256=TqVtmCDqlSRxc3ZK53O-nJDTTwT_eS2TWvC1RmSin28,3518
+shotgun/agents/config/provider.py,sha256=tN__agB1MiaNL49HTDUz1QzvOXTegLRoJ9xQKoklK-k,5820
 shotgun/agents/history/__init__.py,sha256=XFQj2a6fxDqVg0Q3juvN9RjV_RJbgvFZtQOCOjVJyp4,147
 shotgun/agents/history/history_processors.py,sha256=U0HiJM4zVLfwUnlZ6_2YoXNRteedMxwmr52KE4jky5w,7036
-shotgun/agents/tools/__init__.py,sha256=ArlUVsNnFxq10QTKarP5QAod6EVVD5XwIE70HyJtSmY,553
+shotgun/agents/tools/__init__.py,sha256=QaN80IqWvB5qEcjHqri1-PYvYlO74vdhcwLugoEdblo,772
 shotgun/agents/tools/file_management.py,sha256=Lua9KZ_zZMbKl8mLO9EIkfjQwjjCnJ3E3R97GzjO460,3985
 shotgun/agents/tools/user_interaction.py,sha256=7l0OY8EdgO-9gkKy-yOv0V0P_Uzzfk0jMU39d4XN1xM,1087
-shotgun/agents/tools/web_search.py,sha256=BCCjHPDh83cHjDJbT78fTBd4s1qg2kxbkzDQcljLk2o,2268
 shotgun/agents/tools/codebase/__init__.py,sha256=ceAGkK006NeOYaIJBLQsw7Q46sAyCRK9PYDs8feMQVw,661
 shotgun/agents/tools/codebase/codebase_shell.py,sha256=2zEq8YXzdcYttYAfKso_JGRqXHyy3xgAuWlf0unopFg,8635
 shotgun/agents/tools/codebase/directory_lister.py,sha256=MCLGDEc0F-4J8-UrquxdJrIQYs5xzYgws65mjf7Q7X4,4724
@@ -27,11 +26,16 @@ shotgun/agents/tools/codebase/file_read.py,sha256=mqS04CI9OEmWiSHjL5SPUCUgPzoQa3
 shotgun/agents/tools/codebase/models.py,sha256=8eR3_8DQiBNgB2twu0aC_evIJbugN9KW3gtxMZdGYCE,10087
 shotgun/agents/tools/codebase/query_graph.py,sha256=ffm8kTZap0KwPTtae5hvYLy_AQDjpDHUcx0ui9nX2OQ,2136
 shotgun/agents/tools/codebase/retrieve_code.py,sha256=yhWCiam6Dgs9Pyx0mVVzsC4KhQb2NmP5DEToOj3q1Vw,2899
+shotgun/agents/tools/web_search/__init__.py,sha256=Sj1tVokrCsJiLRWWTq0zrAolMHEGntRIYnqiyFi8L2E,1840
+shotgun/agents/tools/web_search/anthropic.py,sha256=v6R4z_c5L_YbBX3FPNWYUKXUBgFQwTxEgHvtGDlqlgk,3092
+shotgun/agents/tools/web_search/gemini.py,sha256=RB7AeGDBvjlsA2RLCI8ErxZh3gOPtA0rhxtW28NyOeE,3025
+shotgun/agents/tools/web_search/openai.py,sha256=ItpV3IquamYJ13ZNUHYjXrSsgOROD51jDd2mwnz0KCE,2972
+shotgun/agents/tools/web_search/utils.py,sha256=GLJ5QV9bT2ubFMuFN7caMN7tK9OTJ0R3GD57B-tCMF0,532
 shotgun/cli/__init__.py,sha256=_F1uW2g87y4bGFxz8Gp8u7mq2voHp8vQIUtCmm8Tojo,40
 shotgun/cli/config.py,sha256=_eKnKG8ySLNDRavw5EC3mXB3u0UKDoqSSj5ZVd6KYkY,8267
 shotgun/cli/models.py,sha256=LoajeEK7MEDUSnZXb1Li-dbhXqne812YZglx-LcVpiQ,181
 shotgun/cli/plan.py,sha256=q3nMrNK0J1HAhnfFFqllcHXN_grmzZMd1FBPcCikNvA,2186
-shotgun/cli/research.py,sha256=d0Afoi4P9q2Nl4T2eTDUGNdeB1KtDQFKFaauK_t0H8Q,2421
+shotgun/cli/research.py,sha256=cmJa1ejxsnK_eqB1KsPQtqsq0cIMSS0Z8R2tJamHu8k,2212
 shotgun/cli/tasks.py,sha256=VdZM0tObUALRg2e_r9YwZYdrG6rYe1wXo5LubXdJ4qw,2289
 shotgun/cli/utils.py,sha256=umVWXDx8pelovMk-nT8B7m0c39AKY9hHsuAMnbw_Hcg,732
 shotgun/cli/codebase/__init__.py,sha256=rKdvx33p0i_BYbNkz5_4DCFgEMwzOOqLi9f5p7XTLKM,73
@@ -46,8 +50,8 @@ shotgun/codebase/core/code_retrieval.py,sha256=_JVyyQKHDFm3dxOOua1mw9eIIOHIVz3-I
 shotgun/codebase/core/ingestor.py,sha256=zMjadeqDOEr2v3vhTS25Jvx0WsLPXpgwquZfbdiz57o,59810
 shotgun/codebase/core/language_config.py,sha256=vsqHyuFnumRPRBV1lMOxWKNOIiClO6FyfKQR0fGrtl4,8934
 shotgun/codebase/core/manager.py,sha256=5GlJKykDGvnb6nTr9w3kyCPTL4OQgmBoesnWr28wvTg,55419
-shotgun/codebase/core/nl_query.py,sha256=eljEFXwXnFMxvZuQFHy7K-417NnZ8S4dE25u3aUaJpw,11321
-shotgun/codebase/core/parser_loader.py,sha256=D2rNGNBuRbmF6OTV8isH-9l5gYYkFk0Uv7IkScXBp30,5223
+shotgun/codebase/core/nl_query.py,sha256=ZQRVc9qBNEqPwdPIHmgePCKgBZrWzqos8Xd1dALRMYY,11377
+shotgun/codebase/core/parser_loader.py,sha256=LZRrDS8Sp518jIu3tQW-BxdwJ86lnsTteI478ER9Td8,4278
 shotgun/prompts/__init__.py,sha256=RswUm0HMdfm2m2YKUwUsEdRIwoczdbI7zlucoEvHYRo,132
 shotgun/prompts/loader.py,sha256=jy24-E02pCSmz2651aCT2NgHfRrHAGMYvKrD6gs0Er8,4424
 shotgun/prompts/agents/__init__.py,sha256=YRIJMbzpArojNX1BP5gfxxois334z_GQga8T-xyWMbY,39
@@ -81,14 +85,14 @@ shotgun/tui/components/prompt_input.py,sha256=Ss-htqraHZAPaehGE4x86ij0veMjc4Ugad
 shotgun/tui/components/spinner.py,sha256=ovTDeaJ6FD6chZx_Aepia6R3UkPOVJ77EKHfRmn39MY,2427
 shotgun/tui/components/splash.py,sha256=vppy9vEIEvywuUKRXn2y11HwXSRkQZHLYoVjhDVdJeU,1267
 shotgun/tui/components/vertical_tail.py,sha256=kkCH0WjAh54jDvRzIaOffRZXUKn_zHFZ_ichfUpgzaE,1071
-shotgun/tui/screens/chat.py,sha256=2-A28icICOt2eZzu37U6r-HGoVtmvR5llPiyZnUS714,13682
-shotgun/tui/screens/chat.tcss,sha256=EJ3wGTwYTTbaVx39fHSrOZWd44grodQnmi39X-9qRC4,282
+shotgun/tui/screens/chat.py,sha256=FLzBeh-UJGloAnhMlQx_XDiREWDx640vI58ux_YeVe4,14428
+shotgun/tui/screens/chat.tcss,sha256=MV7-HhXSpBxIsSbB57RugNeM0wOpqMpIVke7qCf4-yQ,312
 shotgun/tui/screens/provider_config.py,sha256=A_tvDHF5KLP5PV60LjMJ_aoOdT3TjI6_g04UIUqGPqM,7126
 shotgun/tui/screens/splash.py,sha256=E2MsJihi3c9NY1L28o_MstDxGwrCnnV7zdq00MrGAsw,706
 shotgun/utils/__init__.py,sha256=WinIEp9oL2iMrWaDkXz2QX4nYVPAm8C9aBSKTeEwLtE,198
 shotgun/utils/file_system_utils.py,sha256=KQCxgkspb1CR8VE1n66q7-oT6O7MmV_edCXFEEO-CNY,871
-shotgun_sh-0.1.0.dev2.dist-info/METADATA,sha256=aBCHtstHlaPSwf1pZWI7C-gOHprXWc_2hjnY7pT5UzQ,7765
-shotgun_sh-0.1.0.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.1.0.dev2.dist-info/entry_points.txt,sha256=zMC2AP_RmTKW4s4FlQRdap3AzzPOUvByudp8cALAiVY,71
-shotgun_sh-0.1.0.dev2.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.1.0.dev2.dist-info/RECORD,,
+shotgun_sh-0.1.0.dev4.dist-info/METADATA,sha256=B8s8d8TmfgScM6mfMfHuhoHq6a-y0nfcb81mGsxCGrQ,7701
+shotgun_sh-0.1.0.dev4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.1.0.dev4.dist-info/entry_points.txt,sha256=zMC2AP_RmTKW4s4FlQRdap3AzzPOUvByudp8cALAiVY,71
+shotgun_sh-0.1.0.dev4.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.1.0.dev4.dist-info/RECORD,,