shotgun-sh 0.2.11__py3-none-any.whl → 0.2.11.dev2__py3-none-any.whl

shotgun/agents/config/models.py

@@ -1,6 +1,5 @@
 """Pydantic models for configuration."""
 
-from datetime import datetime
 from enum import StrEnum
 
 from pydantic import BaseModel, Field, PrivateAttr, SecretStr
@@ -171,21 +170,6 @@ class ShotgunAccountConfig(BaseModel):
     )
 
 
-class MarketingMessageRecord(BaseModel):
-    """Record of when a marketing message was shown to the user."""
-
-    shown_at: datetime = Field(description="Timestamp when the message was shown")
-
-
-class MarketingConfig(BaseModel):
-    """Configuration for marketing messages shown to users."""
-
-    messages: dict[str, MarketingMessageRecord] = Field(
-        default_factory=dict,
-        description="Tracking which marketing messages have been shown. Key is message ID (e.g., 'github_star_v1')",
-    )
-
-
 class ShotgunConfig(BaseModel):
     """Main configuration for Shotgun CLI."""
 
@@ -200,16 +184,8 @@ class ShotgunConfig(BaseModel):
     shotgun_instance_id: str = Field(
         description="Unique shotgun instance identifier (also used for anonymous telemetry)",
     )
-    config_version: int = Field(default=4, description="Configuration schema version")
+    config_version: int = Field(default=3, description="Configuration schema version")
     shown_welcome_screen: bool = Field(
         default=False,
         description="Whether the welcome screen has been shown to the user",
     )
-    shown_onboarding_popup: datetime | None = Field(
-        default=None,
-        description="Timestamp when the onboarding popup was shown to the user (ISO8601 format)",
-    )
-    marketing: MarketingConfig = Field(
-        default_factory=MarketingConfig,
-        description="Marketing messages configuration and tracking",
-    )

shotgun/agents/config/provider.py

@@ -170,7 +170,7 @@ def get_or_create_model(
     return _model_cache[cache_key]
 
 
-async def get_provider_model(
+def get_provider_model(
     provider_or_model: ProviderType | ModelName | None = None,
 ) -> ModelConfig:
     """Get a fully configured ModelConfig with API key and Model instance.
@@ -189,7 +189,7 @@ async def get_provider_model(
     """
     config_manager = get_config_manager()
     # Use cached config for read-only access (performance)
-    config = await config_manager.load(force_reload=False)
+    config = config_manager.load(force_reload=False)
 
     # Priority 1: Check if Shotgun key exists - if so, use it for ANY model
     shotgun_api_key = _get_api_key(config.shotgun.api_key)

shotgun/agents/context_analyzer/analyzer.py

@@ -67,13 +67,26 @@ class ContextAnalyzer:
         for msg in reversed(message_history):
             if isinstance(msg, ModelResponse) and msg.usage:
                 last_input_tokens = msg.usage.input_tokens + msg.usage.cache_read_tokens
+                logger.debug(
+                    f"[ANALYZER] Found last response with usage - "
+                    f"input_tokens={msg.usage.input_tokens}, "
+                    f"cache_read_tokens={msg.usage.cache_read_tokens}, "
+                    f"total={last_input_tokens}"
+                )
                 break
 
         if last_input_tokens == 0:
-            # Fallback to token estimation (no logging to reduce verbosity)
+            logger.warning(
+                f"[ANALYZER] No usage data found in message history! "
+                f"message_count={len(message_history)}, "
+                f"response_count={sum(1 for m in message_history if isinstance(m, ModelResponse))}"
+            )
+            # Fallback to token estimation
+            logger.info("[ANALYZER] Falling back to token estimation")
             last_input_tokens = await estimate_tokens_from_messages(
                 message_history, self.model_config
             )
+            logger.debug(f"[ANALYZER] Estimated tokens: {last_input_tokens}")
 
         # Step 2: Calculate total output tokens (sum across all responses)
         for msg in message_history:
@@ -234,7 +247,16 @@ class ContextAnalyzer:
             # If no content, put all in agent responses
             agent_response_tokens = total_output_tokens
 
-        # Token allocation complete (no logging to reduce verbosity)
+        logger.debug(
+            f"Token allocation complete: user={user_tokens}, agent_responses={agent_response_tokens}, "
+            f"system_prompts={system_prompt_tokens}, system_status={system_status_tokens}, "
+            f"codebase_understanding={codebase_understanding_tokens}, "
+            f"artifact_management={artifact_management_tokens}, web_research={web_research_tokens}, "
+            f"unknown={unknown_tokens}"
+        )
+        logger.debug(
+            f"Input tokens (from last response): {last_input_tokens}, Output tokens (sum): {total_output_tokens}"
+        )
 
         # Create TokenAllocation model
         return TokenAllocation(

shotgun/agents/conversation_manager.py

@@ -1,15 +1,11 @@
 """Manager for handling conversation persistence operations."""
 
-import asyncio
 import json
+import shutil
 from pathlib import Path
 
-import aiofiles
-import aiofiles.os
-
 from shotgun.logging_config import get_logger
 from shotgun.utils import get_shotgun_home
-from shotgun.utils.file_system_utils import async_copy_file
 
 from .conversation_history import ConversationHistory
 
@@ -31,14 +27,14 @@ class ConversationManager:
         else:
             self.conversation_path = conversation_path
 
-    async def save(self, conversation: ConversationHistory) -> None:
+    def save(self, conversation: ConversationHistory) -> None:
         """Save conversation history to file.
 
         Args:
             conversation: ConversationHistory to save
         """
         # Ensure directory exists
-        await aiofiles.os.makedirs(self.conversation_path.parent, exist_ok=True)
+        self.conversation_path.parent.mkdir(parents=True, exist_ok=True)
 
         try:
             # Update timestamp
@@ -46,17 +42,11 @@ class ConversationManager:
 
             conversation.updated_at = datetime.now()
 
-            # Serialize to JSON in background thread to avoid blocking event loop
-            # This is crucial for large conversations (5k+ tokens)
-            data = await asyncio.to_thread(conversation.model_dump, mode="json")
-            json_content = await asyncio.to_thread(
-                json.dumps, data, indent=2, ensure_ascii=False
-            )
+            # Serialize to JSON using Pydantic's model_dump
+            data = conversation.model_dump(mode="json")
 
-            async with aiofiles.open(
-                self.conversation_path, "w", encoding="utf-8"
-            ) as f:
-                await f.write(json_content)
+            with open(self.conversation_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
 
             logger.debug("Conversation saved to %s", self.conversation_path)
 
@@ -66,26 +56,21 @@ class ConversationManager:
             )
             # Don't raise - we don't want to interrupt the user's session
 
-    async def load(self) -> ConversationHistory | None:
+    def load(self) -> ConversationHistory | None:
         """Load conversation history from file.
 
         Returns:
             ConversationHistory if file exists and is valid, None otherwise
         """
-        if not await aiofiles.os.path.exists(self.conversation_path):
+        if not self.conversation_path.exists():
             logger.debug("No conversation history found at %s", self.conversation_path)
             return None
 
         try:
-            async with aiofiles.open(self.conversation_path, encoding="utf-8") as f:
-                content = await f.read()
-                # Deserialize JSON in background thread to avoid blocking
-                data = await asyncio.to_thread(json.loads, content)
-
-            # Validate model in background thread for large conversations
-            conversation = await asyncio.to_thread(
-                ConversationHistory.model_validate, data
-            )
+            with open(self.conversation_path, encoding="utf-8") as f:
+                data = json.load(f)
+
+            conversation = ConversationHistory.model_validate(data)
             logger.debug(
                 "Conversation loaded from %s with %d agent messages",
                 self.conversation_path,
@@ -104,7 +89,7 @@ class ConversationManager:
             # Create a backup of the corrupted file for debugging
             backup_path = self.conversation_path.with_suffix(".json.backup")
             try:
-                await async_copy_file(self.conversation_path, backup_path)
+                shutil.copy2(self.conversation_path, backup_path)
                 logger.info("Backed up corrupted conversation to %s", backup_path)
             except Exception as backup_error:  # pragma: no cover
                 logger.warning("Failed to backup corrupted file: %s", backup_error)
@@ -120,12 +105,11 @@ class ConversationManager:
             )
             return None
 
-    async def clear(self) -> None:
+    def clear(self) -> None:
         """Delete the conversation history file."""
-        if await aiofiles.os.path.exists(self.conversation_path):
+        if self.conversation_path.exists():
             try:
-                # Use asyncio.to_thread for unlink operation
-                await asyncio.to_thread(self.conversation_path.unlink)
+                self.conversation_path.unlink()
                 logger.debug(
                     "Conversation history cleared at %s", self.conversation_path
                 )
@@ -134,10 +118,10 @@ class ConversationManager:
                     "Failed to clear conversation at %s: %s", self.conversation_path, e
                 )
 
-    async def exists(self) -> bool:
+    def exists(self) -> bool:
         """Check if a conversation history file exists.
 
         Returns:
             True if conversation file exists, False otherwise
         """
-        return await aiofiles.os.path.exists(str(self.conversation_path))
+        return self.conversation_path.exists()

shotgun/agents/export.py

@@ -23,7 +23,7 @@ from .models import AgentDeps, AgentResponse, AgentRuntimeOptions, AgentType
 logger = get_logger(__name__)
 
 
-async def create_export_agent(
+def create_export_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create an export agent with file management capabilities.
@@ -39,7 +39,7 @@ async def create_export_agent(
     # Use partial to create system prompt function for export agent
     system_prompt_fn = partial(build_agent_system_prompt, "export")
 
-    agent, deps = await create_base_agent(
+    agent, deps = create_base_agent(
         system_prompt_fn,
         agent_runtime_options,
         provider=provider,

shotgun/agents/history/history_processors.py

@@ -1,9 +1,7 @@
 """History processors for managing conversation history in Shotgun agents."""
 
-from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, Protocol
 
-from anthropic import APIStatusError
 from pydantic_ai import ModelSettings
 from pydantic_ai.messages import (
     ModelMessage,
@@ -16,7 +14,6 @@ from pydantic_ai.messages import (
 from shotgun.agents.llm import shotgun_model_request
 from shotgun.agents.messages import AgentSystemPrompt, SystemStatusPrompt
 from shotgun.agents.models import AgentDeps
-from shotgun.exceptions import ContextSizeLimitExceeded
 from shotgun.logging_config import get_logger
 from shotgun.posthog_telemetry import track_event
 from shotgun.prompts import PromptLoader
@@ -54,86 +51,6 @@ logger = get_logger(__name__)
 prompt_loader = PromptLoader()
 
 
-async def _safe_token_estimation(
-    estimation_func: Callable[..., Awaitable[int]],
-    model_name: str,
-    max_tokens: int,
-    *args: Any,
-    **kwargs: Any,
-) -> int:
-    """Safely estimate tokens with proper error handling.
-
-    Wraps token estimation functions to handle failures gracefully.
-    Only RuntimeError (from token counters) is wrapped in ContextSizeLimitExceeded.
-    Other errors (network, auth) are allowed to bubble up.
-
-    Args:
-        estimation_func: Async function that estimates tokens
-        model_name: Name of the model for error messages
-        max_tokens: Maximum tokens for the model
-        *args: Arguments to pass to estimation_func
-        **kwargs: Keyword arguments to pass to estimation_func
-
-    Returns:
-        Token count from estimation_func
-
-    Raises:
-        ContextSizeLimitExceeded: If token counting fails with RuntimeError
-        Exception: Any other exceptions from estimation_func
-    """
-    try:
-        return await estimation_func(*args, **kwargs)
-    except Exception as e:
-        # Log the error with full context
-        logger.warning(
-            f"Token counting failed for {model_name}",
-            extra={
-                "error_type": type(e).__name__,
-                "error_message": str(e),
-                "model": model_name,
-            },
-        )
-
-        # Token counting behavior with oversized context (verified via testing):
-        #
-        # 1. OpenAI/tiktoken:
-        #    - Successfully counts any size (tested with 752K tokens, no error)
-        #    - Library errors: ValueError, KeyError, AttributeError, SSLError (file/cache issues)
-        #    - Wrapped as: RuntimeError by our counter
-        #
-        # 2. Gemini/SentencePiece:
-        #    - Successfully counts any size (tested with 752K tokens, no error)
-        #    - Library errors: RuntimeError, IOError, TypeError (file/model loading issues)
-        #    - Wrapped as: RuntimeError by our counter
-        #
-        # 3. Anthropic API:
-        #    - Successfully counts large token counts (tested with 752K tokens, no error)
-        #    - Only enforces 32 MB request size limit (not token count)
-        #    - Raises: APIStatusError(413) with error type 'request_too_large' for 32MB+ requests
-        #    - Other API errors: APIConnectionError, RateLimitError, APIStatusError (4xx/5xx)
-        #    - Wrapped as: RuntimeError by our counter
-        #
-        # IMPORTANT: No provider raises errors for "too many tokens" during counting.
-        # Token count validation happens separately by comparing count to max_input_tokens.
-        #
-        # We wrap RuntimeError (library-level failures from tiktoken/sentencepiece).
-        # We also wrap Anthropic's 413 error (request exceeds 32 MB) as it indicates
-        # context is effectively too large and needs user action to reduce it.
-        if isinstance(e, RuntimeError):
-            raise ContextSizeLimitExceeded(
-                model_name=model_name, max_tokens=max_tokens
-            ) from e
-
-        # Check for Anthropic's 32 MB request size limit (APIStatusError with status 413)
-        if isinstance(e, APIStatusError) and e.status_code == 413:
-            raise ContextSizeLimitExceeded(
-                model_name=model_name, max_tokens=max_tokens
-            ) from e
-
-        # Re-raise other exceptions (network errors, auth failures, etc.)
-        raise
-
-
 def is_summary_part(part: Any) -> bool:
     """Check if a message part is a compacted summary."""
     return isinstance(part, TextPart) and part.content.startswith(SUMMARY_MARKER)
@@ -240,15 +157,9 @@ async def token_limit_compactor(
 
     if last_summary_index is not None:
         # Check if post-summary conversation exceeds threshold for incremental compaction
-        post_summary_tokens = await _safe_token_estimation(
-            estimate_post_summary_tokens,
-            deps.llm_model.name,
-            model_max_tokens,
-            messages,
-            last_summary_index,
-            deps.llm_model,
+        post_summary_tokens = await estimate_post_summary_tokens(
+            messages, last_summary_index, deps.llm_model
         )
-
         post_summary_percentage = (
             (post_summary_tokens / max_tokens) * 100 if max_tokens > 0 else 0
         )
@@ -455,14 +366,7 @@ async def token_limit_compactor(
 
     else:
         # Check if total conversation exceeds threshold for full compaction
-        total_tokens = await _safe_token_estimation(
-            estimate_tokens_from_messages,
-            deps.llm_model.name,
-            model_max_tokens,
-            messages,
-            deps.llm_model,
-        )
-
+        total_tokens = await estimate_tokens_from_messages(messages, deps.llm_model)
         total_percentage = (total_tokens / max_tokens) * 100 if max_tokens > 0 else 0
 
         logger.debug(

shotgun/agents/history/token_counting/anthropic.py

@@ -72,23 +72,11 @@ class AnthropicTokenCounter(TokenCounter):
         Raises:
             RuntimeError: If API call fails
         """
-        # Handle empty text to avoid unnecessary API calls
-        # Anthropic API requires non-empty content, so we need a strict check
-        if not text or not text.strip():
-            return 0
-
-        # Additional validation: ensure the text has actual content
-        # Some edge cases might have only whitespace or control characters
-        cleaned_text = text.strip()
-        if not cleaned_text:
-            return 0
-
         try:
             # Anthropic API expects messages format and model parameter
             # Use await with async client
             result = await self.client.messages.count_tokens(
-                messages=[{"role": "user", "content": cleaned_text}],
-                model=self.model_name,
+                messages=[{"role": "user", "content": text}], model=self.model_name
             )
             return result.input_tokens
         except Exception as e:
@@ -119,9 +107,5 @@ class AnthropicTokenCounter(TokenCounter):
         Raises:
             RuntimeError: If token counting fails
         """
-        # Handle empty message list early
-        if not messages:
-            return 0
-
         total_text = extract_text_from_messages(messages)
         return await self.count_tokens(total_text)

shotgun/agents/history/token_counting/base.py

@@ -56,23 +56,12 @@ def extract_text_from_messages(messages: list[ModelMessage]) -> str:
         if hasattr(message, "parts"):
             for part in message.parts:
                 if hasattr(part, "content") and isinstance(part.content, str):
-                    # Only add non-empty content
-                    if part.content.strip():
-                        text_parts.append(part.content)
+                    text_parts.append(part.content)
                 else:
                     # Handle non-text parts (tool calls, etc.)
-                    part_str = str(part)
-                    if part_str.strip():
-                        text_parts.append(part_str)
+                    text_parts.append(str(part))
         else:
             # Handle messages without parts
-            msg_str = str(message)
-            if msg_str.strip():
-                text_parts.append(msg_str)
-
-    # If no valid text parts found, return a minimal placeholder
-    # This ensures we never send completely empty content to APIs
-    if not text_parts:
-        return "."
+            text_parts.append(str(message))
 
     return "\n".join(text_parts)

shotgun/agents/history/token_counting/openai.py

@@ -57,15 +57,9 @@ class OpenAITokenCounter(TokenCounter):
         Raises:
             RuntimeError: If token counting fails
         """
-        # Handle empty text to avoid unnecessary encoding
-        if not text or not text.strip():
-            return 0
-
         try:
             return len(self.encoding.encode(text))
-        except BaseException as e:
-            # Must catch BaseException to handle PanicException from tiktoken's Rust layer
-            # which can occur with extremely long texts. Regular Exception won't catch it.
+        except Exception as e:
             raise RuntimeError(
                 f"Failed to count tokens for OpenAI model {self.model_name}"
             ) from e
@@ -82,9 +76,5 @@ class OpenAITokenCounter(TokenCounter):
         Raises:
             RuntimeError: If token counting fails
         """
-        # Handle empty message list early
-        if not messages:
-            return 0
-
         total_text = extract_text_from_messages(messages)
         return await self.count_tokens(total_text)

shotgun/agents/history/token_counting/sentencepiece_counter.py

@@ -88,10 +88,6 @@ class SentencePieceTokenCounter(TokenCounter):
         Raises:
             RuntimeError: If token counting fails
         """
-        # Handle empty text to avoid unnecessary tokenization
-        if not text or not text.strip():
-            return 0
-
         await self._ensure_tokenizer()
 
         if self.sp is None:
@@ -119,9 +115,5 @@ class SentencePieceTokenCounter(TokenCounter):
         Raises:
             RuntimeError: If token counting fails
         """
-        # Handle empty message list early
-        if not messages:
-            return 0
-
         total_text = extract_text_from_messages(messages)
         return await self.count_tokens(total_text)

shotgun/agents/history/token_counting/tokenizer_cache.py

@@ -3,7 +3,6 @@
 import hashlib
 from pathlib import Path
 
-import aiofiles
 import httpx
 
 from shotgun.logging_config import get_logger
@@ -79,8 +78,7 @@ async def download_gemini_tokenizer() -> Path:
 
         # Atomic write: write to temp file first, then rename
         temp_path = cache_path.with_suffix(".tmp")
-        async with aiofiles.open(temp_path, "wb") as f:
-            await f.write(content)
+        temp_path.write_bytes(content)
         temp_path.rename(cache_path)
 
         logger.info(f"Gemini tokenizer downloaded and cached at {cache_path}")

shotgun/agents/history/token_counting/utils.py

@@ -44,6 +44,9 @@ def get_token_counter(model_config: ModelConfig) -> TokenCounter:
 
     # Return cached instance if available
     if cache_key in _token_counter_cache:
+        logger.debug(
+            f"Reusing cached token counter for {model_config.provider.value}:{model_config.name}"
+        )
         return _token_counter_cache[cache_key]
 
     # Create new instance and cache it

shotgun/agents/plan.py

@@ -23,7 +23,7 @@ from .models import AgentDeps, AgentResponse, AgentRuntimeOptions, AgentType
 logger = get_logger(__name__)
 
 
-async def create_plan_agent(
+def create_plan_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a plan agent with artifact management capabilities.
@@ -39,7 +39,7 @@ async def create_plan_agent(
     # Use partial to create system prompt function for plan agent
     system_prompt_fn = partial(build_agent_system_prompt, "plan")
 
-    agent, deps = await create_base_agent(
+    agent, deps = create_base_agent(
         system_prompt_fn,
         agent_runtime_options,
         load_codebase_understanding_tools=True,

shotgun/agents/research.py

@@ -26,7 +26,7 @@ from .tools import get_available_web_search_tools
 logger = get_logger(__name__)
 
 
-async def create_research_agent(
+def create_research_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a research agent with web search and artifact management capabilities.
@@ -41,7 +41,7 @@ async def create_research_agent(
     logger.debug("Initializing research agent")
 
     # Get available web search tools based on configured API keys
-    web_search_tools = await get_available_web_search_tools()
+    web_search_tools = get_available_web_search_tools()
     if web_search_tools:
         logger.info(
             "Research agent configured with %d web search tool(s)",
@@ -53,7 +53,7 @@ async def create_research_agent(
     # Use partial to create system prompt function for research agent
     system_prompt_fn = partial(build_agent_system_prompt, "research")
 
-    agent, deps = await create_base_agent(
+    agent, deps = create_base_agent(
         system_prompt_fn,
         agent_runtime_options,
         load_codebase_understanding_tools=True,

shotgun/agents/specify.py

@@ -23,7 +23,7 @@ from .models import AgentDeps, AgentResponse, AgentRuntimeOptions, AgentType
 logger = get_logger(__name__)
 
 
-async def create_specify_agent(
+def create_specify_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a specify agent with artifact management capabilities.
@@ -39,7 +39,7 @@ async def create_specify_agent(
     # Use partial to create system prompt function for specify agent
     system_prompt_fn = partial(build_agent_system_prompt, "specify")
 
-    agent, deps = await create_base_agent(
+    agent, deps = create_base_agent(
         system_prompt_fn,
         agent_runtime_options,
         load_codebase_understanding_tools=True,

shotgun/agents/tasks.py

@@ -23,7 +23,7 @@ from .models import AgentDeps, AgentResponse, AgentRuntimeOptions, AgentType
 logger = get_logger(__name__)
 
 
-async def create_tasks_agent(
+def create_tasks_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a tasks agent with file management capabilities.
@@ -39,7 +39,7 @@ async def create_tasks_agent(
     # Use partial to create system prompt function for tasks agent
     system_prompt_fn = partial(build_agent_system_prompt, "tasks")
 
-    agent, deps = await create_base_agent(
+    agent, deps = create_base_agent(
         system_prompt_fn,
         agent_runtime_options,
         provider=provider,

shotgun/agents/tools/codebase/file_read.py

@@ -2,7 +2,6 @@
 
 from pathlib import Path
 
-import aiofiles
 from pydantic_ai import RunContext
 
 from shotgun.agents.models import AgentDeps
@@ -94,8 +93,7 @@ async def file_read(
         # Read file contents
         encoding_used = "utf-8"
         try:
-            async with aiofiles.open(full_file_path, encoding="utf-8") as f:
-                content = await f.read()
+            content = full_file_path.read_text(encoding="utf-8")
             size_bytes = full_file_path.stat().st_size
 
             logger.debug(
@@ -121,8 +119,7 @@ async def file_read(
             try:
                 # Try with different encoding
                 encoding_used = "latin-1"
-                async with aiofiles.open(full_file_path, encoding="latin-1") as f:
-                    content = await f.read()
+                content = full_file_path.read_text(encoding="latin-1")
                 size_bytes = full_file_path.stat().st_size
 
                 # Detect language from file extension