shotgun-sh 0.1.0.dev31__py3-none-any.whl → 0.1.1__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -76,20 +76,25 @@ class MessageHistoryUpdated(Message):
 class PartialResponseMessage(Message):
     """Event posted when a partial response is received."""
 
-    def __init__(self, message: ModelResponse | None, is_last: bool) -> None:
+    def __init__(
+        self,
+        message: ModelResponse | None,
+        messages: list[ModelMessage],
+        is_last: bool,
+    ) -> None:
         """Initialize the partial response message."""
         super().__init__()
         self.message = message
+        self.messages = messages
         self.is_last = is_last
 
 
 @dataclass(slots=True)
 class _PartialStreamState:
-    """Tracks partial response parts while streaming a single agent run."""
+    """Tracks streamed messages while handling a single agent run."""
 
-    parts: list[ModelResponsePart | ToolCallPartDelta] = field(default_factory=list)
-    latest_partial: ModelResponse | None = None
-    final_sent: bool = False
+    messages: list[ModelRequest | ModelResponse] = field(default_factory=list)
+    current_response: ModelResponse | None = None
 
 
 class AgentManager(Widget):
@@ -272,6 +277,7 @@ class AgentManager(Widget):
 
         # Clear file tracker before each run to track only this run's operations
         deps.file_tracker.clear()
+        original_messages = self.ui_message_history.copy()
 
         if prompt:
             self.ui_message_history.append(ModelRequest.user_text_prompt(prompt))
@@ -356,16 +362,11 @@ class AgentManager(Widget):
                 **kwargs,
             )
         finally:
-            # If the stream ended unexpectedly without a final result, clear accumulated state.
-            if self._stream_state is not None and not self._stream_state.final_sent:
-                partial_message = self._build_partial_response(self._stream_state.parts)
-                if partial_message is not None:
-                    self._post_partial_message(partial_message, True)
             self._stream_state = None
 
-        self.ui_message_history = self.ui_message_history + [
-            mes for mes in result.new_messages() if not isinstance(mes, ModelRequest)
-        ]
+        self.ui_message_history = original_messages + cast(
+            list[ModelRequest | ModelResponse | HintMessage], result.new_messages()
+        )
 
         # Apply compaction to persistent message history to prevent cascading growth
         all_messages = result.all_messages()
@@ -390,7 +391,13 @@ class AgentManager(Widget):
         if state is None:
             state = self._stream_state = _PartialStreamState()
 
-        partial_parts = state.parts
+        if state.current_response is not None:
+            partial_parts: list[ModelResponsePart | ToolCallPartDelta] = list(
+                state.current_response.parts
+                # cast(Sequence[ModelResponsePart], state.current_response.parts)
+            )
+        else:
+            partial_parts = []
 
         async for event in stream:
             try:
@@ -409,8 +416,8 @@ class AgentManager(Widget):
 
                     partial_message = self._build_partial_response(partial_parts)
                     if partial_message is not None:
-                        state.latest_partial = partial_message
-                        self._post_partial_message(partial_message, False)
+                        state.current_response = partial_message
+                        self._post_partial_message(False)
 
                 elif isinstance(event, PartDeltaEvent):
                     index = event.index
@@ -435,8 +442,8 @@ class AgentManager(Widget):
 
                     partial_message = self._build_partial_response(partial_parts)
                     if partial_message is not None:
-                        state.latest_partial = partial_message
-                        self._post_partial_message(partial_message, False)
+                        state.current_response = partial_message
+                        self._post_partial_message(False)
 
                 elif isinstance(event, FunctionToolCallEvent):
                     existing_call_idx = next(
@@ -448,29 +455,54 @@ class AgentManager(Widget):
                         ),
                         None,
                     )
+
                     if existing_call_idx is not None:
                         partial_parts[existing_call_idx] = event.part
+                    elif state.messages:
+                        existing_call_idx = next(
+                            (
+                                i
+                                for i, part in enumerate(state.messages[-1].parts)
+                                if isinstance(part, ToolCallPart)
+                                and part.tool_call_id == event.part.tool_call_id
+                            ),
+                            None,
+                        )
                     else:
                         partial_parts.append(event.part)
                     partial_message = self._build_partial_response(partial_parts)
                     if partial_message is not None:
-                        state.latest_partial = partial_message
-                        self._post_partial_message(partial_message, False)
+                        state.current_response = partial_message
+                        self._post_partial_message(False)
                 elif isinstance(event, FunctionToolResultEvent):
-                    self.ui_message_history.append(ModelRequest(parts=[event.result]))
-                    self._post_messages_updated()  ## this is what the user responded with
-                elif isinstance(event, FinalResultEvent):
-                    final_message = (
-                        state.latest_partial
-                        or self._build_partial_response(partial_parts)
-                    )
-                    self._post_partial_message(final_message, False)
+                    request_message = ModelRequest(parts=[event.result])
+                    state.messages.append(request_message)
+                    if (
+                        event.result.tool_name == "ask_user"
+                    ):  # special handling to ask_user, because deferred tool results mean we missed the user response
+                        self.ui_message_history.append(request_message)
+                        self._post_messages_updated()
+                    ## this is what the user responded with
+                    self._post_partial_message(is_last=False)
 
+                elif isinstance(event, FinalResultEvent):
+                    pass
             except Exception:  # pragma: no cover - defensive logging
                 logger.exception(
                     "Error while handling agent stream event", extra={"event": event}
                 )
 
+        final_message = state.current_response or self._build_partial_response(
+            partial_parts
+        )
+        if final_message is not None:
+            state.current_response = final_message
+            if final_message not in state.messages:
+                state.messages.append(final_message)
+            state.current_response = None
+            self._post_partial_message(True)
+        state.current_response = None
+
     def _build_partial_response(
         self, parts: list[ModelResponsePart | ToolCallPartDelta]
     ) -> ModelResponse | None:
@@ -483,11 +515,20 @@ class AgentManager(Widget):
             return None
         return ModelResponse(parts=list(completed_parts))
 
-    def _post_partial_message(
-        self, message: ModelResponse | None, is_last: bool
-    ) -> None:
+    def _post_partial_message(self, is_last: bool) -> None:
         """Post a partial message to the UI."""
-        self.post_message(PartialResponseMessage(message, is_last))
+        if self._stream_state is None:
+            return
+        self.post_message(
+            PartialResponseMessage(
+                self._stream_state.current_response
+                if self._stream_state.current_response
+                not in self._stream_state.messages
+                else None,
+                self._stream_state.messages,
+                is_last,
+            )
+        )
 
     def _post_messages_updated(
         self, file_operations: list[FileOperation] | None = None

shotgun/agents/config/constants.py

@@ -2,7 +2,6 @@
 
 # Field names
 API_KEY_FIELD = "api_key"
-MODEL_NAME_FIELD = "model_name"
 DEFAULT_PROVIDER_FIELD = "default_provider"
 USER_ID_FIELD = "user_id"
 CONFIG_VERSION_FIELD = "config_version"

shotgun/agents/config/models.py

@@ -117,21 +117,18 @@ 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):

shotgun/agents/config/provider.py

@@ -127,8 +127,8 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
                 f"OpenAI API key not configured. Set via environment variable {OPENAI_API_KEY_ENV} or config."
             )
 
-        # Get model spec
-        model_name = config.openai.model_name
+        # Get model spec - hardcoded to gpt-5
+        model_name = "gpt-5"
         if model_name not in MODEL_SPECS:
             raise ValueError(f"Model '{model_name}' not found")
         spec = MODEL_SPECS[model_name]
@@ -149,8 +149,8 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
                 f"Anthropic API key not configured. Set via environment variable {ANTHROPIC_API_KEY_ENV} or config."
             )
 
-        # Get model spec
-        model_name = config.anthropic.model_name
+        # Get model spec - hardcoded to claude-opus-4-1
+        model_name = "claude-opus-4-1"
         if model_name not in MODEL_SPECS:
             raise ValueError(f"Model '{model_name}' not found")
         spec = MODEL_SPECS[model_name]
@@ -171,8 +171,8 @@ def get_provider_model(provider: ProviderType | None = None) -> ModelConfig:
                 f"Gemini API key not configured. Set via environment variable {GEMINI_API_KEY_ENV} or config."
             )
 
-        # Get model spec
-        model_name = config.google.model_name
+        # Get model spec - hardcoded to gemini-2.5-pro
+        model_name = "gemini-2.5-pro"
         if model_name not in MODEL_SPECS:
             raise ValueError(f"Model '{model_name}' not found")
         spec = MODEL_SPECS[model_name]

shotgun/build_constants.py

@@ -12,8 +12,8 @@ POSTHOG_API_KEY = ''
 POSTHOG_PROJECT_ID = '191396'
 
 # Logfire configuration embedded at build time (only for dev builds)
-LOGFIRE_ENABLED = 'true'
-LOGFIRE_TOKEN = 'pylf_v1_us_KZ5NM1pP3NwgJkbBJt6Ftdzk8mMhmrXcGJHQQgDJ1LfK'
+LOGFIRE_ENABLED = ''
+LOGFIRE_TOKEN = ''
 
 # Build metadata
 BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"

shotgun/codebase/core/cypher_models.py

@@ -0,0 +1,46 @@
+"""Pydantic models and exceptions for Cypher query generation."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class CypherGenerationResponse(BaseModel):
+    """Structured response from LLM for Cypher query generation.
+
+    This model ensures the LLM explicitly indicates whether it can generate
+    a valid Cypher query and provides a reason if it cannot.
+    """
+
+    cypher_query: str | None = Field(
+        default=None,
+        description="The generated Cypher query, or None if generation not possible",
+    )
+    can_generate_valid_cypher: bool = Field(
+        description="Whether a valid Cypher query can be generated for this request"
+    )
+    reason_cannot_generate: str | None = Field(
+        default=None,
+        description="Explanation why query cannot be generated (if applicable)",
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Validate that reason is provided when query cannot be generated."""
+        if not self.can_generate_valid_cypher and not self.reason_cannot_generate:
+            self.reason_cannot_generate = "No reason provided"
+        if self.can_generate_valid_cypher and not self.cypher_query:
+            raise ValueError(
+                "cypher_query must be provided when can_generate_valid_cypher is True"
+            )
+
+
+class CypherGenerationNotPossibleError(Exception):
+    """Raised when LLM cannot generate valid Cypher for the query.
+
+    This typically happens when the query is conceptual rather than structural,
+    or when it requires interpretation beyond what can be expressed in Cypher.
+    """
+
+    def __init__(self, reason: str):
+        self.reason = reason
+        super().__init__(f"Cannot generate Cypher query: {reason}")

shotgun/codebase/core/nl_query.py

@@ -4,15 +4,13 @@ import time
 from datetime import datetime
 from typing import TYPE_CHECKING
 
-from pydantic_ai.messages import (
-    ModelRequest,
-    SystemPromptPart,
-    TextPart,
-    UserPromptPart,
-)
+from pydantic_ai import Agent
 
 from shotgun.agents.config import get_provider_model
-from shotgun.agents.config.models import shotgun_model_request
+from shotgun.codebase.core.cypher_models import (
+    CypherGenerationNotPossibleError,
+    CypherGenerationResponse,
+)
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
 
@@ -25,42 +23,52 @@ logger = get_logger(__name__)
 prompt_loader = PromptLoader()
 
 
-async def llm_cypher_prompt(system_prompt: str, user_prompt: str) -> str:
-    """Generate a Cypher query from a natural language prompt using the configured LLM provider.
+async def llm_cypher_prompt(
+    system_prompt: str, user_prompt: str
+) -> CypherGenerationResponse:
+    """Generate a Cypher query from a natural language prompt using structured output.
 
     Args:
         system_prompt: The system prompt defining the behavior and context for the LLM
         user_prompt: The user's natural language query
     Returns:
-        The generated Cypher query as a string
+        CypherGenerationResponse with cypher_query, can_generate flag, and reason if not
     """
     model_config = get_provider_model()
-    # Use shotgun wrapper to maximize response quality for codebase queries
-    # Limit max_tokens to 2000 for Cypher queries (they're typically 50-200 tokens)
-    # This prevents Anthropic SDK from requiring streaming for longer token limits
-    query_cypher_response = await shotgun_model_request(
-        model_config=model_config,
-        messages=[
-            ModelRequest(
-                parts=[
-                    SystemPromptPart(content=system_prompt),
-                    UserPromptPart(content=user_prompt),
-                ]
-            ),
-        ],
-        max_tokens=2000,  # Cypher queries are short, 2000 tokens is plenty
+
+    # Create an agent with structured output for Cypher generation
+    cypher_agent = Agent(
+        model=model_config.model_instance,
+        output_type=CypherGenerationResponse,
+        retries=2,
     )
 
-    if not query_cypher_response.parts or not query_cypher_response.parts[0]:
-        raise ValueError("Empty response from LLM")
+    # Combine system and user prompts
+    combined_prompt = f"{system_prompt}\n\nUser Query: {user_prompt}"
+
+    try:
+        # Run the agent to get structured response
+        result = await cypher_agent.run(combined_prompt)
+        response = result.output
+
+        # Log the structured response for debugging
+        logger.debug(
+            "Cypher generation response - can_generate: %s, query: %s, reason: %s",
+            response.can_generate_valid_cypher,
+            response.cypher_query[:50] if response.cypher_query else None,
+            response.reason_cannot_generate,
+        )
+
+        return response
 
-    message_part = query_cypher_response.parts[0]
-    if not isinstance(message_part, TextPart):
-        raise ValueError("Unexpected response part type from LLM")
-    cypher_query = str(message_part.content)
-    if not cypher_query:
-        raise ValueError("Empty content in LLM response")
-    return cypher_query
+    except Exception as e:
+        logger.error("Failed to generate Cypher query with structured output: %s", e)
+        # Return a failure response
+        return CypherGenerationResponse(
+            cypher_query=None,
+            can_generate_valid_cypher=False,
+            reason_cannot_generate=f"LLM error: {str(e)}",
+        )
 
 
 async def generate_cypher(natural_language_query: str) -> str:
@@ -71,6 +79,10 @@ async def generate_cypher(natural_language_query: str) -> str:
 
     Returns:
         Generated Cypher query
+
+    Raises:
+        CypherGenerationNotPossibleError: If the query cannot be converted to Cypher
+        RuntimeError: If there's an error during generation
     """
     # Get current time for context
     current_timestamp = int(time.time())
@@ -88,8 +100,30 @@ async def generate_cypher(natural_language_query: str) -> str:
     )
 
     try:
-        cypher_query = await llm_cypher_prompt(system_prompt, enhanced_query)
-        cleaned_query = clean_cypher_response(cypher_query)
+        response = await llm_cypher_prompt(system_prompt, enhanced_query)
+
+        # Check if the LLM could generate a valid Cypher query
+        if not response.can_generate_valid_cypher:
+            logger.info(
+                "Cannot generate Cypher for query '%s': %s",
+                natural_language_query,
+                response.reason_cannot_generate,
+            )
+            raise CypherGenerationNotPossibleError(
+                response.reason_cannot_generate or "Query cannot be converted to Cypher"
+            )
+
+        if not response.cypher_query:
+            raise ValueError("LLM indicated success but provided no query")
+
+        cleaned_query = clean_cypher_response(response.cypher_query)
+
+        # Validate Cypher keywords
+        is_valid, validation_error = validate_cypher_keywords(cleaned_query)
+        if not is_valid:
+            logger.warning(f"Generated query has invalid syntax: {validation_error}")
+            logger.warning(f"Problematic query: {cleaned_query}")
+            raise ValueError(f"Generated query validation failed: {validation_error}")
 
         # Validate UNION ALL queries
         is_valid, validation_error = validate_union_query(cleaned_query)
@@ -100,6 +134,8 @@ async def generate_cypher(natural_language_query: str) -> str:
 
         return cleaned_query
 
+    except CypherGenerationNotPossibleError:
+        raise  # Re-raise as-is
     except Exception as e:
         raise RuntimeError(f"Failed to generate Cypher query: {e}") from e
 
@@ -170,8 +206,31 @@ MATCH (f:Function) RETURN f.name, f.qualified_name  // WRONG: missing third colu
             base_system_prompt=prompt_loader.render("codebase/cypher_system.j2"),
         )
 
-        cypher_query = await llm_cypher_prompt(enhanced_system_prompt, enhanced_query)
-        cleaned_query = clean_cypher_response(cypher_query)
+        response = await llm_cypher_prompt(enhanced_system_prompt, enhanced_query)
+
+        # Check if the LLM could generate a valid Cypher query
+        if not response.can_generate_valid_cypher:
+            logger.info(
+                "Cannot generate Cypher for retry query '%s': %s",
+                natural_language_query,
+                response.reason_cannot_generate,
+            )
+            raise CypherGenerationNotPossibleError(
+                response.reason_cannot_generate
+                or "Query cannot be converted to Cypher even with error context"
+            )
+
+        if not response.cypher_query:
+            raise ValueError("LLM indicated success but provided no query on retry")
+
+        cleaned_query = clean_cypher_response(response.cypher_query)
+
+        # Validate Cypher keywords
+        is_valid, validation_error = validate_cypher_keywords(cleaned_query)
+        if not is_valid:
+            logger.warning(f"Generated query has invalid syntax: {validation_error}")
+            logger.warning(f"Problematic query: {cleaned_query}")
+            raise ValueError(f"Generated query validation failed: {validation_error}")
 
         # Validate UNION ALL queries
         is_valid, validation_error = validate_union_query(cleaned_query)
@@ -182,6 +241,8 @@ MATCH (f:Function) RETURN f.name, f.qualified_name  // WRONG: missing third colu
 
         return cleaned_query
 
+    except CypherGenerationNotPossibleError:
+        raise  # Re-raise as-is
     except Exception as e:
         raise RuntimeError(
             f"Failed to generate Cypher query with error context: {e}"
@@ -202,6 +263,10 @@ async def generate_cypher_openai_async(
 
     Returns:
         Generated Cypher query
+
+    Raises:
+        CypherGenerationNotPossibleError: If the query cannot be converted to Cypher
+        RuntimeError: If there's an error during generation
     """
     # Get current time for context
     current_timestamp = int(time.time())
@@ -219,9 +284,26 @@ async def generate_cypher_openai_async(
     )
 
     try:
-        cypher_query = await llm_cypher_prompt(system_prompt, enhanced_query)
-        return clean_cypher_response(cypher_query)
+        response = await llm_cypher_prompt(system_prompt, enhanced_query)
+
+        # Check if the LLM could generate a valid Cypher query
+        if not response.can_generate_valid_cypher:
+            logger.info(
+                "Cannot generate Cypher for query '%s': %s",
+                natural_language_query,
+                response.reason_cannot_generate,
+            )
+            raise CypherGenerationNotPossibleError(
+                response.reason_cannot_generate or "Query cannot be converted to Cypher"
+            )
 
+        if not response.cypher_query:
+            raise ValueError("LLM indicated success but provided no query")
+
+        return clean_cypher_response(response.cypher_query)
+
+    except CypherGenerationNotPossibleError:
+        raise  # Re-raise as-is
     except Exception as e:
         logger.error(f"OpenAI API error: {e}")
         raise RuntimeError(f"Failed to generate Cypher query: {e}") from e
@@ -288,6 +370,65 @@ def validate_union_query(cypher_query: str) -> tuple[bool, str]:
     return True, ""
 
 
+def validate_cypher_keywords(query: str) -> tuple[bool, str]:
+    """Validate that a query starts with valid Kuzu Cypher keywords.
+
+    Args:
+        query: The Cypher query to validate
+
+    Returns:
+        Tuple of (is_valid, error_message)
+    """
+    # Valid Kuzu Cypher starting keywords based on parser expectations
+    valid_cypher_keywords = {
+        "ALTER",
+        "ATTACH",
+        "BEGIN",
+        "CALL",
+        "CHECKPOINT",
+        "COMMENT",
+        "COMMIT",
+        "COPY",
+        "CREATE",
+        "DELETE",
+        "DETACH",
+        "DROP",
+        "EXPLAIN",
+        "EXPORT",
+        "FORCE",
+        "IMPORT",
+        "INSTALL",
+        "LOAD",
+        "MATCH",
+        "MERGE",
+        "OPTIONAL",
+        "PROFILE",
+        "RETURN",
+        "ROLLBACK",
+        "SET",
+        "UNWIND",
+        "UNINSTALL",
+        "UPDATE",
+        "USE",
+        "WITH",
+    }
+
+    query = query.strip()
+    if not query:
+        return False, "Empty query"
+
+    # Get the first word
+    first_word = query.upper().split()[0] if query else ""
+
+    if first_word not in valid_cypher_keywords:
+        return (
+            False,
+            f"Query doesn't start with valid Cypher keyword. Found: '{first_word}'",
+        )
+
+    return True, ""
+
+
 def clean_cypher_response(response_text: str) -> str:
     """Clean up common LLM formatting artifacts from a Cypher query.
 

shotgun/codebase/service.py

@@ -4,6 +4,7 @@ import time
 from pathlib import Path
 from typing import Any
 
+from shotgun.codebase.core.cypher_models import CypherGenerationNotPossibleError
 from shotgun.codebase.core.manager import CodebaseGraphManager
 from shotgun.codebase.core.nl_query import generate_cypher
 from shotgun.codebase.models import CodebaseGraph, QueryResult, QueryType
@@ -190,6 +191,22 @@ class CodebaseService:
                 error=None,
             )
 
+        except CypherGenerationNotPossibleError as e:
+            # Handle queries that cannot be converted to Cypher
+            execution_time = (time.time() - start_time) * 1000
+            logger.info(f"Query cannot be converted to Cypher: {e.reason}")
+
+            return QueryResult(
+                query=query,
+                cypher_query=None,
+                results=[],
+                column_names=[],
+                row_count=0,
+                execution_time_ms=execution_time,
+                success=False,
+                error=f"This query cannot be converted to Cypher: {e.reason}",
+            )
+
         except Exception as e:
             execution_time = (time.time() - start_time) * 1000
             logger.error(f"Query execution failed: {e}")

shotgun/prompts/codebase/cypher_system.j2

@@ -25,4 +25,18 @@ Your goal is to return appropriate properties for each node type. Common propert
 {% include 'codebase/partials/temporal_context.j2' %}
 
 **6. Output Format**
-Provide only the Cypher query.
+You must return a structured JSON response with the following fields:
+- `cypher_query`: The generated Cypher query string (or null if not possible)
+- `can_generate_valid_cypher`: Boolean indicating if a valid Cypher query can be generated
+- `reason_cannot_generate`: String explaining why generation isn't possible (or null if successful)
+
+**IMPORTANT:** Some queries cannot be expressed in Cypher:
+- Conceptual questions requiring interpretation (e.g., "What is the main purpose of this codebase?")
+- Questions about code quality or best practices
+- Questions requiring semantic understanding beyond structure
+
+For these, set `can_generate_valid_cypher` to false and provide a clear explanation in `reason_cannot_generate`.
+
+Examples:
+- Query: "Show all classes" → can_generate_valid_cypher: true, cypher_query: "MATCH (c:Class) RETURN c.name, c.qualified_name;"
+- Query: "What is the main purpose of this codebase?" → can_generate_valid_cypher: false, reason_cannot_generate: "This is a conceptual question requiring interpretation and analysis of the code's overall design and intent, rather than a structural query about specific code elements."

shotgun/tui/commands/__init__.py

@@ -55,17 +55,18 @@ class CommandHandler:
 • `/help` - Show this help message
 
 **Keyboard Shortcuts:**
-• `Enter` - Send message
-• `Ctrl+P` - Open command palette
-• `Shift+Tab` - Cycle agent modes
-• `Ctrl+C` - Quit application
+
+* `Enter` - Send message
+* `Ctrl+P` - Open command palette
+* `Shift+Tab` - Cycle agent modes
+* `Ctrl+C` - Quit application
 
 **Agent Modes:**
-• **Research** - Research topics with web search and synthesize findings
-• **Specify** - Create detailed specifications and requirements documents
-• **Planning** - Create comprehensive, actionable plans with milestones
-• **Tasks** - Generate specific, actionable tasks from research and plans
-• **Export** - Export artifacts and findings to various formats
+* **Research** - Research topics with web search and synthesize findings
+* **Specify** - Create detailed specifications and requirements documents
+* **Planning** - Create comprehensive, actionable plans with milestones
+* **Tasks** - Generate specific, actionable tasks from research and plans
+* **Export** - Export artifacts and findings to various formats
 
 **Usage:**
 Type your message and press Enter to chat with the AI. The AI will respond based on the current mode."""

shotgun/tui/components/vertical_tail.py

@@ -7,21 +7,6 @@ class VerticalTail(VerticalScroll):
 
     auto_scroll = reactive(True, layout=False)
 
-    def on_mount(self) -> None:
-        """Set up auto-scrolling when the widget is mounted."""
-        # Start at the bottom
-        if self.auto_scroll:
-            self.scroll_end(animate=False)
-
-    def on_descendant_mount(self) -> None:
-        """Auto-scroll when a new child is added."""
-        if self.auto_scroll:
-            # Check if we're near the bottom (within 1 line of scroll)
-            at_bottom = self.scroll_y >= self.max_scroll_y - 1
-            if at_bottom:
-                # Use call_after_refresh to ensure layout is updated first
-                self.call_after_refresh(self.scroll_end, animate=False)
-
     def watch_auto_scroll(self, value: bool) -> None:
         """Handle auto_scroll property changes."""
         if value:

shotgun/tui/screens/chat.py

@@ -1,7 +1,9 @@
+import asyncio
 import logging
 from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
+from typing import cast
 
 from pydantic_ai import DeferredToolResults, RunContext
 from pydantic_ai.messages import (
@@ -11,7 +13,7 @@ from pydantic_ai.messages import (
     TextPart,
     UserPromptPart,
 )
-from textual import on, work
+from textual import events, on, work
 from textual.app import ComposeResult
 from textual.command import CommandPalette
 from textual.containers import Container, Grid
@@ -101,8 +103,20 @@ class StatusBar(Widget):
         }
     """
 
+    def __init__(self, working: bool = False) -> None:
+        """Initialize the status bar.
+
+        Args:
+            working: Whether an agent is currently working.
+        """
+        super().__init__()
+        self.working = working
+
     def render(self) -> str:
-        return """[$foreground-muted][bold $text]enter[/] to send • [bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • /help for commands[/]"""
+        if self.working:
+            return """[$foreground-muted][bold $text]esc[/] to stop • [bold $text]enter[/] to send • [bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • /help for commands[/]"""
+        else:
+            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):
@@ -328,6 +342,7 @@ class ChatScreen(Screen[None]):
     question: reactive[UserQuestion | None] = reactive(None)
     indexing_job: reactive[CodebaseIndexSelection | None] = reactive(None)
     partial_message: reactive[ModelMessage | None] = reactive(None)
+    _current_worker = None  # Track the current running worker for cancellation
 
     def __init__(self, continue_session: bool = False) -> None:
         super().__init__()
@@ -369,6 +384,18 @@ class ChatScreen(Screen[None]):
         # Start the question listener worker to handle ask_user interactions
         self.call_later(self.add_question_listener)
 
+    async def on_key(self, event: events.Key) -> None:
+        """Handle key presses for cancellation."""
+        # If escape is pressed while agent is working, cancel the operation
+        if event.key == "escape" and self.working and self._current_worker:
+            # Cancel the running agent worker
+            self._current_worker.cancel()
+            # Show cancellation message
+            self.mount_hint("⚠️ Cancelling operation...")
+            # Re-enable the input
+            prompt_input = self.query_one(PromptInput)
+            prompt_input.focus()
+
     @work
     async def check_if_codebase_is_indexed(self) -> None:
         cur_dir = Path.cwd().resolve()
@@ -384,7 +411,7 @@ class ChatScreen(Screen[None]):
             await self.codebase_sdk.list_codebases_for_directory()
         ).graphs
         if accessible_graphs:
-            self.mount_hint(help_text_with_codebase())
+            self.mount_hint(help_text_with_codebase(already_indexed=True))
             return
 
         should_index = await self.app.push_screen_wait(CodebaseIndexPromptScreen())
@@ -392,6 +419,8 @@ class ChatScreen(Screen[None]):
             self.mount_hint(help_text_empty_dir())
             return
 
+        self.mount_hint(help_text_with_codebase(already_indexed=False))
+
         self.index_codebase_command()
 
     def watch_mode(self, new_mode: AgentType) -> None:
@@ -418,6 +447,11 @@ class ChatScreen(Screen[None]):
             spinner.set_classes("" if is_working else "hidden")
             spinner.display = is_working
 
+            # Update the status bar to show/hide "ESC to stop"
+            status_bar = self.query_one(StatusBar)
+            status_bar.working = is_working
+            status_bar.refresh()
+
     def watch_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
         """Update the chat history when messages change."""
         if self.is_mounted:
@@ -468,7 +502,7 @@ class ChatScreen(Screen[None]):
                     id="spinner",
                     classes="" if self.working else "hidden",
                 )
-                yield StatusBar()
+                yield StatusBar(working=self.working)
                 yield PromptInput(
                     text=self.value,
                     highlight_cursor_line=False,
@@ -487,10 +521,12 @@ class ChatScreen(Screen[None]):
     def handle_partial_response(self, event: PartialResponseMessage) -> None:
         self.partial_message = event.message
 
-        partial_response_widget = self.query_one(ChatHistory)
-        partial_response_widget.partial_response = self.partial_message
-        if event.is_last:
-            partial_response_widget.partial_response = None
+        history = self.query_one(ChatHistory)
+        history.update_messages(
+            self.messages + cast(list[ModelMessage | HintMessage], event.messages)
+        )
+
+        history.partial_response = self.partial_message
 
     def _clear_partial_response(self) -> None:
         partial_response_widget = self.query_one(ChatHistory)
@@ -658,7 +694,6 @@ class ChatScreen(Screen[None]):
                 timeout=8,
             )
 
-            self.mount_hint(codebase_indexed_hint(selection.name))
         except CodebaseAlreadyIndexedError as exc:
             logger.warning(f"Codebase already indexed: {exc}")
             self.notify(str(exc), severity="warning")
@@ -684,6 +719,11 @@ class ChatScreen(Screen[None]):
         prompt = None
         self.working = True
 
+        # Store the worker so we can cancel it if needed
+        from textual.worker import get_current_worker
+
+        self._current_worker = get_current_worker()
+
         if self.question:
             # This is a response to a question from the agent
             self.question.result.set_result(
@@ -701,11 +741,17 @@ class ChatScreen(Screen[None]):
             # This is a new user prompt
             prompt = message
 
-        await self.agent_manager.run(
-            prompt=prompt,
-            deferred_tool_results=deferred_tool_results,
-        )
-        self.working = False
+        try:
+            await self.agent_manager.run(
+                prompt=prompt,
+                deferred_tool_results=deferred_tool_results,
+            )
+        except asyncio.CancelledError:
+            # Handle cancellation gracefully - DO NOT re-raise
+            self.mount_hint("⚠️ Operation cancelled by user")
+        finally:
+            self.working = False
+            self._current_worker = None
 
         # Save conversation after each interaction
         self._save_conversation()
@@ -751,17 +797,10 @@ class ChatScreen(Screen[None]):
         self.mode = AgentType(conversation.last_agent_model)
 
 
-def codebase_indexed_hint(codebase_name: str) -> str:
-    return (
-        f"Codebase **{codebase_name}** indexed successfully. You can now use it in your chat.\n\n"
-        + help_text_with_codebase()
-    )
-
-
-def help_text_with_codebase() -> str:
+def help_text_with_codebase(already_indexed: bool = False) -> str:
     return (
         "Howdy! Welcome to Shotgun - the context tool for software engineering. \n\nYou can research, build specs, plan, create tasks, and export context to your favorite code-gen agents.\n\n"
-        "I can help with:\n\n"
+        f"{'' if already_indexed else 'Once your codebase is indexed, '}I can help with:\n\n"
         "- Speccing out a new feature\n"
         "- Onboarding you onto this project\n"
         "- Helping with a refactor spec\n"

shotgun/tui/screens/chat_screen/history.py

@@ -12,6 +12,7 @@ from pydantic_ai.messages import (
     ThinkingPart,
     ToolCallPart,
     ToolReturnPart,
+    UserPromptPart,
 )
 from textual.app import ComposeResult
 from textual.reactive import reactive
@@ -39,6 +40,7 @@ class PartialResponseWidget(Widget):  # TODO: doesn't work lol
         self.item = item
 
     def compose(self) -> ComposeResult:
+        yield Markdown(markdown="**partial response**")
         if self.item is None:
             pass
         elif self.item.kind == "response":
@@ -76,7 +78,7 @@ class ChatHistory(Widget):
 
     def __init__(self) -> None:
         super().__init__()
-        self.items: list[ModelMessage | HintMessage] = []
+        self.items: Sequence[ModelMessage | HintMessage] = []
         self.vertical_tail: VerticalTail | None = None
         self.partial_response = None
 
@@ -94,9 +96,7 @@ class ChatHistory(Widget):
             yield PartialResponseWidget(self.partial_response).data_bind(
                 item=ChatHistory.partial_response
             )
-
-    def watch_partial_response(self, _partial_response: ModelMessage | None) -> None:
-        self.call_after_refresh(self.autoscroll)
+        self.call_later(self.autoscroll)
 
     def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
         """Update the displayed messages without recomposing."""
@@ -105,12 +105,11 @@ class ChatHistory(Widget):
 
         self.items = messages
         self.refresh(recompose=True)
-
-        self.autoscroll()
+        self.call_later(self.autoscroll)
 
     def autoscroll(self) -> None:
         if self.vertical_tail:
-            self.vertical_tail.scroll_end(animate=False)
+            self.vertical_tail.scroll_end(animate=False, immediate=False, force=True)
 
 
 class UserQuestionWidget(Widget):
@@ -123,23 +122,24 @@ class UserQuestionWidget(Widget):
         if self.item is None:
             yield Markdown(markdown="")
         else:
-            prompt = "".join(
-                str(part.content) for part in self.item.parts if part.content
-            )
-            yield Markdown(markdown=f"**>** {prompt}")
+            prompt = self.format_prompt_parts(self.item.parts)
+            yield Markdown(markdown=prompt)
 
     def format_prompt_parts(self, parts: Sequence[ModelRequestPart]) -> str:
         acc = ""
         for part in parts:
-            if isinstance(part, TextPart):
+            if isinstance(part, UserPromptPart):
                 acc += (
                     f"**>** {part.content if isinstance(part.content, str) else ''}\n\n"
                 )
-            elif isinstance(part, ToolCallPart):
+            elif isinstance(part, ToolReturnPart):
                 if part.tool_name == "ask_user" and isinstance(part.content, dict):
                     acc += f"**>** {part.content['answer']}\n\n"
                 else:
-                    acc += "∟ finished\n\n"  # let's not show anything yet
+                    # acc += "  ∟ finished\n\n"  # let's not show anything yet
+                    pass
+            elif isinstance(part, UserPromptPart):
+                acc += f"**>** {part.content}\n\n"
         return acc
 
 
@@ -153,7 +153,7 @@ class AgentResponseWidget(Widget):
         if self.item is None:
             yield Markdown(markdown="")
         else:
-            yield Markdown(markdown=f"**⏺** {self.compute_output()}")
+            yield Markdown(markdown=self.compute_output())
 
     def compute_output(self) -> str:
         acc = ""
@@ -161,18 +161,12 @@ class AgentResponseWidget(Widget):
             return ""
         for idx, part in enumerate(self.item.parts):
             if isinstance(part, TextPart):
-                acc += part.content + "\n\n"
+                acc += f"**⏺** {part.content}\n\n"
             elif isinstance(part, ToolCallPart):
                 parts_str = self._format_tool_call_part(part)
                 acc += parts_str + "\n\n"
-            elif isinstance(part, ToolReturnPart):
-                acc += (
-                    f"tool ({part.tool_name}) return: "
-                    + self._format_tool_return_call_part(part)
-                    + "\n\n"
-                )
             elif isinstance(part, BuiltinToolCallPart):
-                acc += f"builtin tool ({part.tool_name}): {part.args}\n\n"
+                acc += f"{part.tool_name}({part.args})\n\n"
             elif isinstance(part, BuiltinToolReturnPart):
                 acc += f"builtin tool ({part.tool_name}) return: {part.content}\n\n"
             elif isinstance(part, ThinkingPart):
@@ -226,10 +220,3 @@ class AgentResponseWidget(Widget):
             return f"{_args['question']}"
         else:
             return "❓ "
-
-    def _format_tool_return_call_part(self, part: ToolReturnPart) -> str:
-        content = part.content
-        if part.tool_name == "ask_user":
-            response = content.get("answer", "") if isinstance(content, dict) else ""
-            return f"**⏺** {response}"
-        return f"∟ {content}"

{shotgun_sh-0.1.0.dev31.dist-info → shotgun_sh-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.0.dev31
+Version: 0.1.1
 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

{shotgun_sh-0.1.0.dev31.dist-info → shotgun_sh-0.1.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 shotgun/__init__.py,sha256=P40K0fnIsb7SKcQrFnXZ4aREjpWchVDhvM1HxI4cyIQ,104
-shotgun/build_constants.py,sha256=RXNxMz46HaB5jucgMVpw8a2yCJqjbhTOh0PddyEVMN8,713
+shotgun/build_constants.py,sha256=hDFr6eO0lwN0iCqHQ1A5s0D68txR8sYrTJLGa7tSi0o,654
 shotgun/logging_config.py,sha256=UKenihvgH8OA3W0b8ZFcItYaFJVe9MlsMYlcevyW1HY,7440
 shotgun/main.py,sha256=5WEtPs5kwD1tdeWCnM-jIAwarcwQNc4dhaqdPKCyxug,5510
 shotgun/posthog_telemetry.py,sha256=usfaJ8VyqckLIbLgoj2yhuNyDh0VWA5EJPRr7a0dyVs,5054
@@ -7,7 +7,7 @@ shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/sentry_telemetry.py,sha256=0W0o810ewFpIcdPsi_q4uKLiaP6zDYRRE5MHpIbQIPo,2954
 shotgun/telemetry.py,sha256=Ves6Ih3hshpKVNVAUUmwRdtW8NkTjFPg8hEqvFKZ0t0,3208
 shotgun/agents/__init__.py,sha256=8Jzv1YsDuLyNPFJyckSr_qI4ehTVeDyIMDW4omsfPGc,25
-shotgun/agents/agent_manager.py,sha256=zfGlZGb7A6ZRvTtHaJa9_mFnL_myc52wNbkdVS8Bfxk,22465
+shotgun/agents/agent_manager.py,sha256=xw9xNEwVU-P4NGqF8W6mzVw4HNqtSfegAN9atog7aEo,23813
 shotgun/agents/common.py,sha256=vt7ECq1rT6GR5Rt63t0whH0R0cydrk7Mty2KyPL8mEg,19045
 shotgun/agents/conversation_history.py,sha256=5J8_1yxdZiiWTq22aDio88DkBDZ4_Lh_p5Iy5_ENszc,3898
 shotgun/agents/conversation_manager.py,sha256=fxAvXbEl3Cl2ugJ4N9aWXaqZtkrnfj3QzwjWC4LFXwI,3514
@@ -19,10 +19,10 @@ shotgun/agents/research.py,sha256=lYG7Rytcitop8mXs3isMI3XvYzzI3JH9u0VZz6K9zfo,32
 shotgun/agents/specify.py,sha256=7MoMxfIn34G27mw6wrp_F0i2O5rid476L3kHFONDCd0,3137
 shotgun/agents/tasks.py,sha256=nk8zIl24o01hfzOGyWSbeVWeke6OGseO4Ppciurh13U,2999
 shotgun/agents/config/__init__.py,sha256=Fl8K_81zBpm-OfOW27M_WWLSFdaHHek6lWz95iDREjQ,318
-shotgun/agents/config/constants.py,sha256=c1k7LFvx29rzQCUXxyfr2PukwS5ol8rH8AXQaxALPVM,526
+shotgun/agents/config/constants.py,sha256=MogArrb2r5rFI6BBzc6NhPz1payGeM6K-t5oIFbJgxg,494
 shotgun/agents/config/manager.py,sha256=kwMbPjz0kEH_WCQAamESGjHdE8d_P-ztel4NL4FWNUw,10662
-shotgun/agents/config/models.py,sha256=bX4zVTY5n7qQRlEOcA0SFmyPef9MvxcFW9hKLf_thLs,6018
-shotgun/agents/config/provider.py,sha256=ScT1NfmaXJdewP1UAAD51MLR00YbmPAM53oeMfrVzq8,7202
+shotgun/agents/config/models.py,sha256=vpVXrtiHsDt2D_h7BLyMiiQeT97vAz2L6lYKx2SEMjo,5909
+shotgun/agents/config/provider.py,sha256=pVWf_WM3MNWH0v2fU-peBCqx49X-nW81piQ_M-AKWRE,7249
 shotgun/agents/history/__init__.py,sha256=XFQj2a6fxDqVg0Q3juvN9RjV_RJbgvFZtQOCOjVJyp4,147
 shotgun/agents/history/compaction.py,sha256=KY_ZvRvvlrB6eLPGqtlC6H8h4HPPOtuPcUkgQJUjK5I,2890
 shotgun/agents/history/constants.py,sha256=yWY8rrTZarLA3flCCMB_hS2NMvUDRDTwP4D4j7MIh1w,446
@@ -62,14 +62,15 @@ shotgun/cli/codebase/commands.py,sha256=zvcM9gjHHO6styhXojb_1bnpq-Cozh2c77ZOIjw4
 shotgun/cli/codebase/models.py,sha256=B9vs-d-Bq0aS6FZKebhHT-9tw90Y5f6k_t71VlZpL8k,374
 shotgun/codebase/__init__.py,sha256=QBgFE2Abd5Vl7_NdYOglF9S6d-vIjkb3C0cpIYoHZEU,309
 shotgun/codebase/models.py,sha256=hxjbfDUka8loTApXq9KTvkXKt272fzdjr5u2ImYrNtk,4367
-shotgun/codebase/service.py,sha256=IK7h6IW84cblpHZVx5z9ulLDqJImGg6L9aZJimijBu8,6804
+shotgun/codebase/service.py,sha256=CZR5f1vZyUS3gVXuDiZj0cIuuxiR7fbkHK65PTPAovI,7504
 shotgun/codebase/core/__init__.py,sha256=GWWhJEqChiDXAF4omYCgzgoZmJjwsAf6P1aZ5Bl8OE0,1170
 shotgun/codebase/core/change_detector.py,sha256=kWCYLWzRzb3IGGOj71KBn7UOCOKMpINJbOBDf98aMxE,12409
 shotgun/codebase/core/code_retrieval.py,sha256=_JVyyQKHDFm3dxOOua1mw9eIIOHIVz3-I8aZtEsEj1E,7927
+shotgun/codebase/core/cypher_models.py,sha256=Yfysfa9lLguILftkmtuJCN3kLBFIo7WW7NigM-Zr-W4,1735
 shotgun/codebase/core/ingestor.py,sha256=H_kVCqdOKmnQpjcXvUdPFpep8OC2AbOhhE-9HKr_XZM,59836
 shotgun/codebase/core/language_config.py,sha256=vsqHyuFnumRPRBV1lMOxWKNOIiClO6FyfKQR0fGrtl4,8934
 shotgun/codebase/core/manager.py,sha256=6gyjfACbC5n1Hdy-JQIEDH2aNAlesUS9plQP_FHoJ94,59277
-shotgun/codebase/core/nl_query.py,sha256=vOc8S_5U5wJEzIznFPhV5KDB438M4Rr0dnpoGraEthM,11653
+shotgun/codebase/core/nl_query.py,sha256=kPoSJXBlm5rLhzOofZhqPVMJ_Lj3rV2H6sld6BwtMdg,16115
 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
@@ -87,7 +88,7 @@ shotgun/prompts/agents/state/system_state.j2,sha256=TQPnCLtmiNwQCbMxnCE7nLhXMJpK
 shotgun/prompts/agents/state/codebase/codebase_graphs_available.j2,sha256=U-hy-H9bPwV0sYIHTZ5TESxc5EOCtntI8GUZOmJipJw,601
 shotgun/prompts/codebase/__init__.py,sha256=NYuPMtmYM2ptuwf3YxVuotNlJOUq0hnjmwlzKcJkGK4,42
 shotgun/prompts/codebase/cypher_query_patterns.j2,sha256=ufTx_xT3VoS76KcVUbIgGQx-bJoJHx3bBE3dagAXv18,8913
-shotgun/prompts/codebase/cypher_system.j2,sha256=kV-OJ8gM3vsBo8hW4mLSEHpJW-wV_2tNaPck3HUM52c,1497
+shotgun/prompts/codebase/cypher_system.j2,sha256=jo8d_AIoyAd0zKCvPXSmYGBxvtulMsCfeaOTdOfeC5g,2620
 shotgun/prompts/codebase/enhanced_query_context.j2,sha256=WzGnFaBLZO-mOdkZ_u_PewSu9niKy87DKNL4uzQq1Jg,724
 shotgun/prompts/codebase/partials/cypher_rules.j2,sha256=vtc5OqTp-z5Rq_ti-_RG31bVOIA_iNe80_x3CdxO6bs,2397
 shotgun/prompts/codebase/partials/graph_schema.j2,sha256=fUsD1ZgU1pIWUzrs97jHq3TatKeGSvZgG8XP5gCQUJc,1939
@@ -103,12 +104,12 @@ shotgun/sdk/services.py,sha256=J4PJFSxCQ6--u7rb3Ta-9eYtlYcxcbnzrMP6ThyCnw4,705
 shotgun/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/tui/app.py,sha256=t0IAQbGr0lKKEoBVnp85DcmZ-V92bi79SjyEE2uKpuw,3990
 shotgun/tui/styles.tcss,sha256=ETyyw1bpMBOqTi5RLcAJUScdPWTvAWEqE9YcT0kVs_E,121
-shotgun/tui/commands/__init__.py,sha256=Wy8s8TBSA3twK6agtsf57EFV2VfL8HGvEBF1VOg5-mM,2535
+shotgun/tui/commands/__init__.py,sha256=8D5lvtpqMW5-fF7Bg3oJtUzU75cKOv6aUaHYYszydU8,2518
 shotgun/tui/components/prompt_input.py,sha256=Ss-htqraHZAPaehGE4x86ij0veMjc4UgadMXpbdXr40,2229
 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=c9g457FR8JUr_ArTi1bbweC_chYlXastUvCa9XGfDYQ,28075
+shotgun/tui/components/vertical_tail.py,sha256=GavHXNMq1X8hc0juDLKDWTW9seRLk3VlhBBMl60uPG0,439
+shotgun/tui/screens/chat.py,sha256=U3FfJj0c3HIXxPW8W7wRRWP5WruxUBFcHdsShQ_sMoQ,29820
 shotgun/tui/screens/chat.tcss,sha256=2Yq3E23jxsySYsgZf4G1AYrYVcpX0UDW6kNNI0tDmtM,437
 shotgun/tui/screens/directory_setup.py,sha256=lIZ1J4A6g5Q2ZBX8epW7BhR96Dmdcg22CyiM5S-I5WU,3237
 shotgun/tui/screens/provider_config.py,sha256=A_tvDHF5KLP5PV60LjMJ_aoOdT3TjI6_g04UIUqGPqM,7126
@@ -116,15 +117,15 @@ shotgun/tui/screens/splash.py,sha256=E2MsJihi3c9NY1L28o_MstDxGwrCnnV7zdq00MrGAsw
 shotgun/tui/screens/chat_screen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/tui/screens/chat_screen/command_providers.py,sha256=55JIH9T8QnyHRsMoXhOi87FiVM-d6o7OKpCe82uDP9I,7840
 shotgun/tui/screens/chat_screen/hint_message.py,sha256=WOpbk8q7qt7eOHTyyHvh_IQIaublVDeJGaLpsxEk9FA,933
-shotgun/tui/screens/chat_screen/history.py,sha256=PKUqj3kYk0NqQyQRoM7fTn4lsivfTOlKqm_77cO5RG4,7930
+shotgun/tui/screens/chat_screen/history.py,sha256=JjQOKjCZpLBcw9CMorkBjOt2U5Ikr81hEQRtQmhw_KM,7459
 shotgun/tui/utils/__init__.py,sha256=cFjDfoXTRBq29wgP7TGRWUu1eFfiIG-LLOzjIGfadgI,150
 shotgun/tui/utils/mode_progress.py,sha256=lseRRo7kMWLkBzI3cU5vqJmS2ZcCjyRYf9Zwtvc-v58,10931
 shotgun/utils/__init__.py,sha256=WinIEp9oL2iMrWaDkXz2QX4nYVPAm8C9aBSKTeEwLtE,198
 shotgun/utils/env_utils.py,sha256=8QK5aw_f_V2AVTleQQlcL0RnD4sPJWXlDG46fsHu0d8,1057
 shotgun/utils/file_system_utils.py,sha256=l-0p1bEHF34OU19MahnRFdClHufThfGAjQ431teAIp0,1004
 shotgun/utils/update_checker.py,sha256=Xf-7w3Pos3etzCoT771gJe2HLkA8_V2GrqWy7ni9UqA,11373
-shotgun_sh-0.1.0.dev31.dist-info/METADATA,sha256=fK3jZfstqvS9w_vujcIFo1SWL2FsND3eLOQciGN2cAI,11197
-shotgun_sh-0.1.0.dev31.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.1.0.dev31.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
-shotgun_sh-0.1.0.dev31.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.1.0.dev31.dist-info/RECORD,,
+shotgun_sh-0.1.1.dist-info/METADATA,sha256=D6rAxtG6uoiaP8xQqDm6mhO-MAqPTE595suqA7GkWNY,11191
+shotgun_sh-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.1.1.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
+shotgun_sh-0.1.1.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.1.1.dist-info/RECORD,,