shotgun-sh 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -362,6 +362,17 @@ class AgentManager(Widget):
                 **kwargs,
             )
         finally:
+            # If the stream ended unexpectedly without a final result, clear accumulated state.
+            # state = self._stream_state
+            # if state is not None:
+            #     pending_response = state.current_response
+            #     if pending_response is not None:
+            #         already_recorded = (
+            #             bool(state.messages) and state.messages[-1] is pending_response
+            #         )
+            #         if not already_recorded:
+            #             self._post_partial_message(pending_response, True)
+            #             state.messages.append(pending_response)
             self._stream_state = None
 
         self.ui_message_history = original_messages + cast(

shotgun/codebase/core/nl_query.py

@@ -4,13 +4,15 @@ import time
 from datetime import datetime
 from typing import TYPE_CHECKING
 
-from pydantic_ai import Agent
+from pydantic_ai.messages import (
+    ModelRequest,
+    SystemPromptPart,
+    TextPart,
+    UserPromptPart,
+)
 
 from shotgun.agents.config import get_provider_model
-from shotgun.codebase.core.cypher_models import (
-    CypherGenerationNotPossibleError,
-    CypherGenerationResponse,
-)
+from shotgun.agents.config.models import shotgun_model_request
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
 
@@ -23,52 +25,42 @@ logger = get_logger(__name__)
 prompt_loader = PromptLoader()
 
 
-async def llm_cypher_prompt(
-    system_prompt: str, user_prompt: str
-) -> CypherGenerationResponse:
-    """Generate a Cypher query from a natural language prompt using structured output.
+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.
 
     Args:
         system_prompt: The system prompt defining the behavior and context for the LLM
         user_prompt: The user's natural language query
     Returns:
-        CypherGenerationResponse with cypher_query, can_generate flag, and reason if not
+        The generated Cypher query as a string
     """
     model_config = get_provider_model()
-
-    # Create an agent with structured output for Cypher generation
-    cypher_agent = Agent(
-        model=model_config.model_instance,
-        output_type=CypherGenerationResponse,
-        retries=2,
+    # 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
     )
 
-    # 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
+    if not query_cypher_response.parts or not query_cypher_response.parts[0]:
+        raise ValueError("Empty response from LLM")
 
-    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)}",
-        )
+    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
 
 
 async def generate_cypher(natural_language_query: str) -> str:
@@ -79,10 +71,6 @@ 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())
@@ -100,30 +88,8 @@ async def generate_cypher(natural_language_query: str) -> str:
     )
 
     try:
-        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}")
+        cypher_query = await llm_cypher_prompt(system_prompt, enhanced_query)
+        cleaned_query = clean_cypher_response(cypher_query)
 
         # Validate UNION ALL queries
         is_valid, validation_error = validate_union_query(cleaned_query)
@@ -134,8 +100,6 @@ 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
 
@@ -206,31 +170,8 @@ MATCH (f:Function) RETURN f.name, f.qualified_name  // WRONG: missing third colu
             base_system_prompt=prompt_loader.render("codebase/cypher_system.j2"),
         )
 
-        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}")
+        cypher_query = await llm_cypher_prompt(enhanced_system_prompt, enhanced_query)
+        cleaned_query = clean_cypher_response(cypher_query)
 
         # Validate UNION ALL queries
         is_valid, validation_error = validate_union_query(cleaned_query)
@@ -241,8 +182,6 @@ 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}"
@@ -263,10 +202,6 @@ 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())
@@ -284,26 +219,9 @@ async def generate_cypher_openai_async(
     )
 
     try:
-        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"
-            )
+        cypher_query = await llm_cypher_prompt(system_prompt, enhanced_query)
+        return clean_cypher_response(cypher_query)
 
-        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
@@ -370,65 +288,6 @@ 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,7 +4,6 @@ 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
@@ -191,22 +190,6 @@ 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/main.py

@@ -22,7 +22,7 @@ from shotgun.posthog_telemetry import setup_posthog_observability
 from shotgun.sentry_telemetry import setup_sentry_observability
 from shotgun.telemetry import setup_logfire_observability
 from shotgun.tui import app as tui_app
-from shotgun.utils.update_checker import check_for_updates_async
+from shotgun.utils.update_checker import check_and_install_updates_async
 
 # Load environment variables from .env file
 load_dotenv()
@@ -52,6 +52,7 @@ logger.debug("PostHog analytics enabled: %s", _posthog_enabled)
 
 # Global variable to store update notification
 _update_notification: str | None = None
+_update_progress: str | None = None
 
 
 def _update_callback(notification: str) -> None:
@@ -60,6 +61,13 @@ def _update_callback(notification: str) -> None:
     _update_notification = notification
 
 
+def _update_progress_callback(progress: str) -> None:
+    """Callback to store update progress."""
+    global _update_progress
+    _update_progress = progress
+    logger.debug(f"Update progress: {progress}")
+
+
 app = typer.Typer(
     name="shotgun",
     help="Shotgun - AI-powered CLI tool for research, planning, and task management",
@@ -121,10 +129,12 @@ def main(
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
 
-    # Start async update check (non-blocking)
+    # Start async update check and install (non-blocking)
     if not ctx.resilient_parsing:
-        check_for_updates_async(
-            callback=_update_callback, no_update_check=no_update_check
+        check_and_install_updates_async(
+            callback=_update_callback,
+            no_update_check=no_update_check,
+            progress_callback=_update_progress_callback,
         )
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:

shotgun/prompts/codebase/cypher_system.j2

@@ -25,18 +25,4 @@ Your goal is to return appropriate properties for each node type. Common propert
 {% include 'codebase/partials/temporal_context.j2' %}
 
 **6. Output Format**
-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."
+Provide only the Cypher query.

shotgun/tui/app.py

@@ -9,7 +9,7 @@ from shotgun.agents.config import ConfigManager, get_config_manager
 from shotgun.logging_config import get_logger
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.file_system_utils import get_shotgun_base_path
-from shotgun.utils.update_checker import check_for_updates_async
+from shotgun.utils.update_checker import check_and_install_updates_async
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
@@ -37,16 +37,26 @@ class ShotgunApp(App[None]):
         self.no_update_check = no_update_check
         self.continue_session = continue_session
         self.update_notification: str | None = None
+        self.update_progress: str | None = None
 
-        # Start async update check
+        # Start async update check and install
         if not no_update_check:
-            check_for_updates_async(callback=self._update_callback)
+            check_and_install_updates_async(
+                callback=self._update_callback,
+                no_update_check=no_update_check,
+                progress_callback=self._update_progress_callback,
+            )
 
     def _update_callback(self, notification: str) -> None:
         """Store update notification to show later."""
         self.update_notification = notification
         logger.debug(f"Update notification received: {notification}")
 
+    def _update_progress_callback(self, progress: str) -> None:
+        """Store update progress."""
+        self.update_progress = progress
+        logger.debug(f"Update progress: {progress}")
+
     def on_mount(self) -> None:
         self.theme = "gruvbox"
         # Track TUI startup

shotgun/tui/screens/chat.py

@@ -411,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(already_indexed=True))
+            self.mount_hint(help_text_with_codebase())
             return
 
         should_index = await self.app.push_screen_wait(CodebaseIndexPromptScreen())
@@ -419,8 +419,6 @@ 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:
@@ -694,6 +692,7 @@ 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")
@@ -797,10 +796,17 @@ class ChatScreen(Screen[None]):
         self.mode = AgentType(conversation.last_agent_model)
 
 
-def help_text_with_codebase(already_indexed: bool = False) -> str:
+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:
     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"
-        f"{'' if already_indexed else 'Once your codebase is indexed, '}I can help with:\n\n"
+        "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

@@ -136,8 +136,7 @@ class UserQuestionWidget(Widget):
                 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
-                    pass
+                    acc += "  ∟ finished\n\n"  # let's not show anything yet
             elif isinstance(part, UserPromptPart):
                 acc += f"**>** {part.content}\n\n"
         return acc
@@ -153,7 +152,7 @@ class AgentResponseWidget(Widget):
         if self.item is None:
             yield Markdown(markdown="")
         else:
-            yield Markdown(markdown=self.compute_output())
+            yield Markdown(markdown=f"**⏺** {self.compute_output()}")
 
     def compute_output(self) -> str:
         acc = ""
@@ -161,10 +160,10 @@ class AgentResponseWidget(Widget):
             return ""
         for idx, part in enumerate(self.item.parts):
             if isinstance(part, TextPart):
-                acc += f"**⏺** {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"
+                acc += f"{part.tool_name}: " + parts_str + "\n\n"
             elif isinstance(part, BuiltinToolCallPart):
                 acc += f"{part.tool_name}({part.args})\n\n"
             elif isinstance(part, BuiltinToolReturnPart):

shotgun/utils/update_checker.py

@@ -294,6 +294,31 @@ def format_update_notification(current: str, latest: str) -> str:
     return f"Update available: {current} → {latest}. Run 'shotgun update' to upgrade."
 
 
+def format_update_status(
+    status: str, current: str | None = None, latest: str | None = None
+) -> str:
+    """Format update status messages.
+
+    Args:
+        status: Status type ('installing', 'success', 'failed', 'checking').
+        current: Current version (optional).
+        latest: Latest version (optional).
+
+    Returns:
+        Formatted status message.
+    """
+    if status == "checking":
+        return "Checking for updates..."
+    elif status == "installing" and current and latest:
+        return f"Installing update: {current} → {latest}..."
+    elif status == "success" and latest:
+        return f"✓ Successfully updated to version {latest}. Restart your terminal to use the new version."
+    elif status == "failed":
+        return "Update failed. Run 'shotgun update' to try manually."
+    else:
+        return ""
+
+
 def check_for_updates_sync(no_update_check: bool = False) -> str | None:
     """Synchronously check for updates and return notification if available.
 
@@ -336,6 +361,69 @@ def check_for_updates_sync(no_update_check: bool = False) -> str | None:
     return None
 
 
+def check_and_install_updates_sync(no_update_check: bool = False) -> tuple[str, bool]:
+    """Synchronously check for updates and install if available.
+
+    Args:
+        no_update_check: If True, skip update checks and installation.
+
+    Returns:
+        Tuple of (status message, success boolean).
+    """
+    if no_update_check:
+        return "", False
+
+    if not should_check_for_updates(no_update_check):
+        return "", False
+
+    # Skip auto-install for development versions
+    if is_dev_version():
+        logger.debug("Skipping auto-install for development version")
+        return "", False
+
+    latest_version = get_latest_version()
+    if not latest_version:
+        return "", False
+    latest = latest_version  # Type narrowing
+
+    # Check if update is needed
+    if not compare_versions(__version__, latest):
+        # Already up to date, update cache
+        now = datetime.now(timezone.utc)
+        cache_data = UpdateCache(
+            last_check=now,
+            latest_version=latest,
+            current_version=__version__,
+            update_available=False,
+        )
+        save_cache(cache_data)
+        return "", False
+
+    # Perform the update
+    logger.info(f"Auto-installing update: {__version__} → {latest}")
+    success, message = perform_update(force=False)
+
+    if success:
+        # Clear cache on successful update
+        cache_file = get_cache_file()
+        if cache_file.exists():
+            cache_file.unlink()
+        return format_update_status("success", latest=latest), True
+    else:
+        # Update cache to mark that we tried and failed
+        # This prevents repeated attempts within the check interval
+        now = datetime.now(timezone.utc)
+        cache_data = UpdateCache(
+            last_check=now,
+            latest_version=latest,
+            current_version=__version__,
+            update_available=True,  # Still available, but we failed to install
+        )
+        save_cache(cache_data)
+        logger.warning(f"Auto-update failed: {message}")
+        return format_update_status("failed"), False
+
+
 def check_for_updates_async(
     callback: Callable[[str], None] | None = None, no_update_check: bool = False
 ) -> threading.Thread:
@@ -362,6 +450,117 @@ def check_for_updates_async(
     return thread
 
 
+def check_and_install_updates_async(
+    callback: Callable[[str], None] | None = None,
+    no_update_check: bool = False,
+    progress_callback: Callable[[str], None] | None = None,
+) -> threading.Thread:
+    """Asynchronously check for updates and install in a background thread.
+
+    Args:
+        callback: Optional callback function to call with final status message.
+        no_update_check: If True, skip update checks and installation.
+        progress_callback: Optional callback for progress updates.
+
+    Returns:
+        The thread object that was started.
+    """
+
+    def _check_and_install() -> None:
+        try:
+            # Send checking status if progress callback provided
+            if progress_callback:
+                progress_callback(format_update_status("checking"))
+
+            # Skip if disabled
+            if no_update_check:
+                return
+
+            # Skip for dev versions
+            if is_dev_version():
+                logger.debug("Skipping auto-install for development version")
+                return
+
+            # Check if we should check for updates
+            if not should_check_for_updates(no_update_check):
+                # Check cache to see if update is still pending
+                cache = load_cache()
+                if cache and cache.update_available:
+                    # We have a pending update from a previous check
+                    # Don't retry installation automatically to avoid repeated failures
+                    if callback:
+                        callback(
+                            format_update_notification(
+                                cache.current_version, cache.latest_version
+                            )
+                        )
+                return
+
+            # Get latest version
+            latest_version = get_latest_version()
+            if not latest_version:
+                return
+            latest = latest_version  # Type narrowing
+
+            # Check if update is needed
+            if not compare_versions(__version__, latest):
+                # Already up to date, update cache
+                now = datetime.now(timezone.utc)
+                cache_data = UpdateCache(
+                    last_check=now,
+                    latest_version=latest,
+                    current_version=__version__,
+                    update_available=False,
+                )
+                save_cache(cache_data)
+                logger.debug(f"Already at latest version ({__version__})")
+                return
+
+            # Send installing status
+            if progress_callback:
+                progress_callback(
+                    format_update_status(
+                        "installing", current=__version__, latest=latest
+                    )
+                )
+
+            # Perform the update
+            logger.info(f"Auto-installing update: {__version__} → {latest}")
+            success, message = perform_update(force=False)
+
+            if success:
+                # Clear cache on successful update
+                cache_file = get_cache_file()
+                if cache_file.exists():
+                    cache_file.unlink()
+
+                if callback:
+                    callback(format_update_status("success", latest=latest))
+            else:
+                # Update cache to mark that we tried and failed
+                now = datetime.now(timezone.utc)
+                cache_data = UpdateCache(
+                    last_check=now,
+                    latest_version=latest,
+                    current_version=__version__,
+                    update_available=True,
+                )
+                save_cache(cache_data)
+                logger.warning(f"Auto-update failed: {message}")
+
+                if callback:
+                    callback(format_update_status("failed"))
+
+        except Exception as e:
+            logger.debug(f"Error in async update check and install: {e}")
+            if callback:
+                callback(format_update_status("failed"))
+
+    thread = threading.Thread(target=_check_and_install, daemon=True)
+    thread.start()
+    return thread
+
+
 __all__ = [
     "UpdateCache",
     "is_dev_version",
@@ -371,5 +570,8 @@ __all__ = [
     "perform_update",
     "check_for_updates_async",
     "check_for_updates_sync",
+    "check_and_install_updates_async",
+    "check_and_install_updates_sync",
     "format_update_notification",
+    "format_update_status",
 ]

{shotgun_sh-0.1.1.dist-info → shotgun_sh-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.1
+Version: 0.1.2
 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.1.dist-info → shotgun_sh-0.1.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 shotgun/__init__.py,sha256=P40K0fnIsb7SKcQrFnXZ4aREjpWchVDhvM1HxI4cyIQ,104
 shotgun/build_constants.py,sha256=hDFr6eO0lwN0iCqHQ1A5s0D68txR8sYrTJLGa7tSi0o,654
 shotgun/logging_config.py,sha256=UKenihvgH8OA3W0b8ZFcItYaFJVe9MlsMYlcevyW1HY,7440
-shotgun/main.py,sha256=5WEtPs5kwD1tdeWCnM-jIAwarcwQNc4dhaqdPKCyxug,5510
+shotgun/main.py,sha256=lFx8IsLIfMvOw6lMJGnzg8o9HKcuj59VxhjNgetMZP0,5854
 shotgun/posthog_telemetry.py,sha256=usfaJ8VyqckLIbLgoj2yhuNyDh0VWA5EJPRr7a0dyVs,5054
 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=xw9xNEwVU-P4NGqF8W6mzVw4HNqtSfegAN9atog7aEo,23813
+shotgun/agents/agent_manager.py,sha256=7BjTRQ7s77OqxYHBdbM1IECOERTfv5GFAETDGz9YLy4,24444
 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
@@ -62,15 +62,14 @@ 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=CZR5f1vZyUS3gVXuDiZj0cIuuxiR7fbkHK65PTPAovI,7504
+shotgun/codebase/service.py,sha256=IK7h6IW84cblpHZVx5z9ulLDqJImGg6L9aZJimijBu8,6804
 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=kPoSJXBlm5rLhzOofZhqPVMJ_Lj3rV2H6sld6BwtMdg,16115
+shotgun/codebase/core/nl_query.py,sha256=vOc8S_5U5wJEzIznFPhV5KDB438M4Rr0dnpoGraEthM,11653
 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
@@ -88,7 +87,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=jo8d_AIoyAd0zKCvPXSmYGBxvtulMsCfeaOTdOfeC5g,2620
+shotgun/prompts/codebase/cypher_system.j2,sha256=kV-OJ8gM3vsBo8hW4mLSEHpJW-wV_2tNaPck3HUM52c,1497
 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
@@ -102,14 +101,14 @@ shotgun/sdk/exceptions.py,sha256=qBcQv0v7ZTwP7CMcxZST4GqCsfOWtOUjSzGBo0-heqo,412
 shotgun/sdk/models.py,sha256=X9nOTUHH0cdkQW1NfnMEDu-QgK9oUsEISh1Jtwr5Am4,5496
 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/app.py,sha256=AAoFQYw6A9_kVxB0c0p7g-BNdplexfZIQbrGDQ1m4KI,4407
 shotgun/tui/styles.tcss,sha256=ETyyw1bpMBOqTi5RLcAJUScdPWTvAWEqE9YcT0kVs_E,121
 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=GavHXNMq1X8hc0juDLKDWTW9seRLk3VlhBBMl60uPG0,439
-shotgun/tui/screens/chat.py,sha256=U3FfJj0c3HIXxPW8W7wRRWP5WruxUBFcHdsShQ_sMoQ,29820
+shotgun/tui/screens/chat.py,sha256=Sa9MGwdcHcLxzy0c6MC--fePEA5y3-e13lZmRtioHc8,29912
 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
@@ -117,15 +116,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=JjQOKjCZpLBcw9CMorkBjOt2U5Ikr81hEQRtQmhw_KM,7459
+shotgun/tui/screens/chat_screen/history.py,sha256=ZozEVG1ffdmruQ-XCr25qePWReFAJZFJACdwq9g8wIk,7461
 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.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,,
+shotgun/utils/update_checker.py,sha256=Q3va_lsDTWtIS7B_8RQh7bjrWlLt7pzDR_AR-4aAKnc,18522
+shotgun_sh-0.1.2.dist-info/METADATA,sha256=awGmV6yuJ20hZYwH36bnd58OUZC2-LXTkK4D3A6vjxE,11191
+shotgun_sh-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.1.2.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
+shotgun_sh-0.1.2.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.1.2.dist-info/RECORD,,

shotgun/codebase/core/cypher_models.py

@@ -1,46 +0,0 @@
-"""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}")