shotgun-sh 0.2.6.dev1__py3-none-any.whl → 0.2.17__py3-none-any.whl

shotgun/cli/compact.py

@@ -0,0 +1,186 @@
+"""Compact command for shotgun CLI."""
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from pydantic_ai.usage import RequestUsage
+from rich.console import Console
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.conversation_manager import ConversationManager
+from shotgun.agents.history.history_processors import token_limit_compactor
+from shotgun.agents.history.token_estimation import estimate_tokens_from_messages
+from shotgun.cli.models import OutputFormat
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(
+    name="compact", help="Compact the conversation history", no_args_is_help=False
+)
+logger = get_logger(__name__)
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def compact(
+    format: Annotated[
+        OutputFormat,
+        typer.Option(
+            "--format",
+            "-f",
+            help="Output format: markdown or json",
+        ),
+    ] = OutputFormat.MARKDOWN,
+) -> None:
+    """Compact the current conversation history to reduce size.
+
+    This command compacts the conversation in ~/.shotgun-sh/conversation.json
+    by summarizing older messages while preserving recent context. The compacted
+    conversation is automatically saved back to the file.
+    """
+    try:
+        result = asyncio.run(compact_conversation())
+
+        if format == OutputFormat.JSON:
+            # Output as JSON
+            console.print_json(json.dumps(result, indent=2))
+        else:
+            # Output as markdown
+            console.print(format_markdown(result))
+
+    except FileNotFoundError as e:
+        console.print(
+            f"[red]Error:[/red] {e}\n\n"
+            "No conversation found. Start a TUI session first with: [cyan]shotgun[/cyan]",
+            style="bold",
+        )
+        raise typer.Exit(code=1) from e
+    except Exception as e:
+        console.print(
+            f"[red]Error:[/red] Failed to compact conversation: {e}", style="bold"
+        )
+        logger.debug("Full traceback:", exc_info=True)
+        raise typer.Exit(code=1) from e
+
+
+async def compact_conversation() -> dict[str, Any]:
+    """Compact the conversation and return statistics.
+
+    Returns:
+        Dictionary with compaction statistics including before/after metrics
+    """
+    # Get conversation file path
+    conversation_file = Path.home() / ".shotgun-sh" / "conversation.json"
+
+    if not conversation_file.exists():
+        raise FileNotFoundError(f"Conversation file not found at {conversation_file}")
+
+    # Load conversation
+    manager = ConversationManager(conversation_file)
+    conversation = await manager.load()
+
+    if not conversation:
+        raise ValueError("Conversation file is empty or corrupted")
+
+    # Get agent messages only (not UI messages)
+    agent_messages = conversation.get_agent_messages()
+
+    if not agent_messages:
+        raise ValueError("No agent messages found in conversation")
+
+    # Get model config
+    model_config = await get_provider_model()
+
+    # Calculate before metrics
+    original_message_count = len(agent_messages)
+    original_tokens = await estimate_tokens_from_messages(agent_messages, model_config)
+
+    # For CLI, we can call token_limit_compactor directly without full AgentDeps
+    # since we only need the model config and message history
+    # Create a minimal context object for compaction
+    class CompactContext:
+        def __init__(self, model_config: Any, usage: RequestUsage) -> None:
+            self.deps = type("Deps", (), {"llm_model": model_config})()
+            self.usage = usage
+
+    # Create minimal usage info for compaction check
+    usage = RequestUsage(input_tokens=original_tokens, output_tokens=0)
+    ctx = CompactContext(model_config, usage)
+
+    # Apply compaction with force=True to bypass threshold checks
+    compacted_messages = await token_limit_compactor(ctx, agent_messages, force=True)
+
+    # Calculate after metrics
+    compacted_message_count = len(compacted_messages)
+    compacted_tokens = await estimate_tokens_from_messages(
+        compacted_messages, model_config
+    )
+
+    # Calculate reduction percentages
+    message_reduction = (
+        ((original_message_count - compacted_message_count) / original_message_count)
+        * 100
+        if original_message_count > 0
+        else 0
+    )
+    token_reduction = (
+        ((original_tokens - compacted_tokens) / original_tokens) * 100
+        if original_tokens > 0
+        else 0
+    )
+
+    # Save compacted conversation
+    conversation.set_agent_messages(compacted_messages)
+    await manager.save(conversation)
+
+    logger.info(
+        f"Compacted conversation: {original_message_count} → {compacted_message_count} messages "
+        f"({message_reduction:.1f}% reduction)"
+    )
+
+    return {
+        "success": True,
+        "before": {
+            "messages": original_message_count,
+            "estimated_tokens": original_tokens,
+        },
+        "after": {
+            "messages": compacted_message_count,
+            "estimated_tokens": compacted_tokens,
+        },
+        "reduction": {
+            "messages_percent": round(message_reduction, 1),
+            "tokens_percent": round(token_reduction, 1),
+        },
+    }
+
+
+def format_markdown(result: dict[str, Any]) -> str:
+    """Format compaction result as markdown.
+
+    Args:
+        result: Dictionary with compaction statistics
+
+    Returns:
+        Formatted markdown string
+    """
+    before = result["before"]
+    after = result["after"]
+    reduction = result["reduction"]
+
+    return f"""# Conversation Compacted ✓
+
+## Before
+- **Messages:** {before["messages"]:,}
+- **Estimated Tokens:** {before["estimated_tokens"]:,}
+
+## After
+- **Messages:** {after["messages"]:,}
+- **Estimated Tokens:** {after["estimated_tokens"]:,}
+
+## Reduction
+- **Messages:** {reduction["messages_percent"]}%
+- **Tokens:** {reduction["tokens_percent"]}%
+"""

shotgun/cli/config.py

@@ -1,5 +1,6 @@
 """Configuration management CLI commands."""
 
+import asyncio
 import json
 from typing import Annotated, Any
 
@@ -44,7 +45,7 @@ def init(
         console.print()
 
         # Initialize with defaults
-        config_manager.initialize()
+        asyncio.run(config_manager.initialize())
 
         # Ask for provider
         provider_choices = ["openai", "anthropic", "google"]
@@ -76,7 +77,7 @@ def init(
 
         if api_key:
             # update_provider will automatically set selected_model for first provider
-            config_manager.update_provider(provider, api_key=api_key)
+            asyncio.run(config_manager.update_provider(provider, api_key=api_key))
 
         console.print(
             f"\n✅ [bold green]Configuration saved to {config_manager.config_path}[/bold green]"
@@ -84,7 +85,7 @@ def init(
         console.print("🎯 You can now use Shotgun with your configured provider!")
 
     else:
-        config_manager.initialize()
+        asyncio.run(config_manager.initialize())
         console.print(f"✅ Configuration initialized at {config_manager.config_path}")
 
 
@@ -112,7 +113,7 @@ def set(
 
     try:
         if api_key:
-            config_manager.update_provider(provider, api_key=api_key)
+            asyncio.run(config_manager.update_provider(provider, api_key=api_key))
 
         console.print(f"✅ Configuration updated for {provider}")
 
@@ -133,8 +134,10 @@ def get(
     ] = False,
 ) -> None:
     """Display current configuration."""
+    import asyncio
+
     config_manager = get_config_manager()
-    config = config_manager.load()
+    config = asyncio.run(config_manager.load())
 
     if json_output:
         # Convert to dict and mask secrets

shotgun/cli/context.py

@@ -0,0 +1,111 @@
+"""Context command for shotgun CLI."""
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from shotgun.agents.config import get_provider_model
+from shotgun.agents.context_analyzer import (
+    ContextAnalysisOutput,
+    ContextAnalyzer,
+    ContextFormatter,
+)
+from shotgun.agents.conversation_manager import ConversationManager
+from shotgun.cli.models import OutputFormat
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(
+    name="context", help="Analyze conversation context usage", no_args_is_help=False
+)
+logger = get_logger(__name__)
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def context(
+    format: Annotated[
+        OutputFormat,
+        typer.Option(
+            "--format",
+            "-f",
+            help="Output format: markdown or json",
+        ),
+    ] = OutputFormat.MARKDOWN,
+) -> None:
+    """Analyze the current conversation's context usage.
+
+    This command analyzes the agent's message history from ~/.shotgun-sh/conversation.json
+    and displays token usage breakdown by message type. Only agent context is counted
+    (UI elements like hints are excluded).
+    """
+    try:
+        result = asyncio.run(analyze_context())
+
+        if format == OutputFormat.JSON:
+            # Output as JSON
+            console.print_json(json.dumps(result.json_data, indent=2))
+        else:
+            # Output as plain text (Markdown() reformats and makes categories inline)
+            console.print(result.markdown)
+
+    except FileNotFoundError as e:
+        console.print(
+            f"[red]Error:[/red] {e}\n\n"
+            "No conversation found. Start a TUI session first with: [cyan]shotgun[/cyan]",
+            style="bold",
+        )
+        raise typer.Exit(code=1) from e
+    except Exception as e:
+        console.print(f"[red]Error:[/red] Failed to analyze context: {e}", style="bold")
+        logger.debug("Full traceback:", exc_info=True)
+        raise typer.Exit(code=1) from e
+
+
+async def analyze_context() -> ContextAnalysisOutput:
+    """Analyze the conversation context and return structured data.
+
+    Returns:
+        ContextAnalysisOutput with both markdown and JSON representations of the analysis
+    """
+    # Get conversation file path
+    conversation_file = Path.home() / ".shotgun-sh" / "conversation.json"
+
+    if not conversation_file.exists():
+        raise FileNotFoundError(f"Conversation file not found at {conversation_file}")
+
+    # Load conversation
+    manager = ConversationManager(conversation_file)
+    conversation = await manager.load()
+
+    if not conversation:
+        raise ValueError("Conversation file is empty or corrupted")
+
+    # Get agent messages only (not UI messages)
+    agent_messages = conversation.get_agent_messages()
+
+    if not agent_messages:
+        raise ValueError("No agent messages found in conversation")
+
+    # Get model config (use default provider settings)
+    model_config = await get_provider_model()
+
+    # Debug: Log the model being used
+    logger.debug(f"Using model: {model_config.name.value}")
+    logger.debug(f"Provider: {model_config.provider.value}")
+    logger.debug(f"Key provider: {model_config.key_provider.value}")
+    logger.debug(f"Max input tokens: {model_config.max_input_tokens}")
+
+    # Analyze with ContextAnalyzer
+    analyzer = ContextAnalyzer(model_config)
+    # For CLI, agent_messages and ui_message_history are the same (no hints in CLI mode)
+    analysis = await analyzer.analyze_conversation(agent_messages, list(agent_messages))
+
+    # Use formatter to generate markdown and JSON
+    markdown = ContextFormatter.format_markdown(analysis)
+    json_data = ContextFormatter.format_json(analysis)
+
+    return ContextAnalysisOutput(markdown=markdown, json_data=json_data)

shotgun/cli/export.py

@@ -63,7 +63,7 @@ def export(
         )
 
         # Create the export agent with deps and provider
-        agent, deps = create_export_agent(agent_runtime_options, provider)
+        agent, deps = asyncio.run(create_export_agent(agent_runtime_options, provider))
 
         # Start export process
         logger.info("🎯 Starting export...")

shotgun/cli/feedback.py

@@ -28,9 +28,11 @@ def send_feedback(
     ],
 ) -> None:
     """Initialize Shotgun configuration."""
+    import asyncio
+
     config_manager = get_config_manager()
-    config_manager.load()
-    shotgun_instance_id = config_manager.get_shotgun_instance_id()
+    asyncio.run(config_manager.load())
+    shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
     if not description:
         console.print(

shotgun/cli/models.py

@@ -8,3 +8,4 @@ class OutputFormat(StrEnum):
 
     TEXT = "text"
     JSON = "json"
+    MARKDOWN = "markdown"

shotgun/cli/plan.py

@@ -55,7 +55,7 @@ def plan(
         )
 
         # Create the plan agent with deps and provider
-        agent, deps = create_plan_agent(agent_runtime_options, provider)
+        agent, deps = asyncio.run(create_plan_agent(agent_runtime_options, provider))
 
         # Start planning process
         logger.info("🎯 Starting planning...")

shotgun/cli/research.py

@@ -73,7 +73,7 @@ async def async_research(
     agent_runtime_options = AgentRuntimeOptions(interactive_mode=not non_interactive)
 
     # Create the research agent with deps and provider
-    agent, deps = create_research_agent(agent_runtime_options, provider)
+    agent, deps = await create_research_agent(agent_runtime_options, provider)
 
     # Start research process
     logger.info("🔬 Starting research...")

shotgun/cli/specify.py

@@ -51,7 +51,7 @@ def specify(
         )
 
         # Create the specify agent with deps and provider
-        agent, deps = create_specify_agent(agent_runtime_options, provider)
+        agent, deps = asyncio.run(create_specify_agent(agent_runtime_options, provider))
 
         # Start specification process
         logger.info("📋 Starting specification generation...")

shotgun/cli/tasks.py

@@ -60,7 +60,7 @@ def tasks(
         )
 
         # Create the tasks agent with deps and provider
-        agent, deps = create_tasks_agent(agent_runtime_options, provider)
+        agent, deps = asyncio.run(create_tasks_agent(agent_runtime_options, provider))
 
         # Start task creation process
         logger.info("🎯 Starting task creation...")

shotgun/cli/update.py

@@ -45,7 +45,7 @@ def update(
 
     This command will:
     - Check PyPI for the latest version
-    - Detect your installation method (pipx, pip, or venv)
+    - Detect your installation method (uvx, uv-tool, pipx, pip, or venv)
     - Perform the appropriate upgrade command
 
     Examples:
@@ -93,6 +93,8 @@ def update(
         )
         console.print(
             "Use --force to update anyway, or install the stable version with:\n"
+            "  uv tool install shotgun-sh\n"
+            "  or\n"
             "  pipx install shotgun-sh\n"
             "  or\n"
             "  pip install shotgun-sh",
@@ -134,7 +136,19 @@ def update(
             console.print(f"\n[red]✗[/red] {message}", style="bold red")
 
             # Provide manual update instructions
-            if method == "pipx":
+            if method == "uvx":
+                console.print(
+                    "\n[yellow]Run uvx again to use the latest version:[/yellow]\n"
+                    "  uvx shotgun-sh\n"
+                    "\n[yellow]Or install permanently:[/yellow]\n"
+                    "  uv tool install shotgun-sh"
+                )
+            elif method == "uv-tool":
+                console.print(
+                    "\n[yellow]Try updating manually:[/yellow]\n"
+                    "  uv tool upgrade shotgun-sh"
+                )
+            elif method == "pipx":
                 console.print(
                     "\n[yellow]Try updating manually:[/yellow]\n"
                     "  pipx upgrade shotgun-sh"

shotgun/codebase/core/change_detector.py

@@ -6,6 +6,7 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, cast
 
+import aiofiles
 import kuzu
 
 from shotgun.logging_config import get_logger
@@ -301,7 +302,7 @@ class ChangeDetector:
             # Direct substring match
             return pattern in filepath
 
-    def _calculate_file_hash(self, filepath: Path) -> str:
+    async def _calculate_file_hash(self, filepath: Path) -> str:
         """Calculate hash of file contents.
 
         Args:
@@ -311,8 +312,9 @@ class ChangeDetector:
             SHA256 hash of file contents
         """
         try:
-            with open(filepath, "rb") as f:
-                return hashlib.sha256(f.read()).hexdigest()
+            async with aiofiles.open(filepath, "rb") as f:
+                content = await f.read()
+                return hashlib.sha256(content).hexdigest()
         except Exception as e:
             logger.error(f"Failed to calculate hash for {filepath}: {e}")
             return ""

shotgun/codebase/core/code_retrieval.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+import aiofiles
 from pydantic import BaseModel
 
 from shotgun.logging_config import get_logger
@@ -141,8 +142,9 @@ async def retrieve_code_by_qualified_name(
 
         # Read the file and extract the snippet
         try:
-            with full_path.open("r", encoding="utf-8") as f:
-                all_lines = f.readlines()
+            async with aiofiles.open(full_path, encoding="utf-8") as f:
+                content = await f.read()
+                all_lines = content.splitlines(keepends=True)
 
             # Extract the relevant lines (1-indexed to 0-indexed)
             snippet_lines = all_lines[start_line - 1 : end_line]

shotgun/codebase/core/ingestor.py

@@ -1,5 +1,6 @@
 """Kuzu graph ingestor for building code knowledge graphs."""
 
+import asyncio
 import hashlib
 import os
 import time
@@ -8,6 +9,7 @@ from collections import defaultdict
 from pathlib import Path
 from typing import Any
 
+import aiofiles
 import kuzu
 from tree_sitter import Node, Parser, QueryCursor
 
@@ -619,7 +621,7 @@ class SimpleGraphBuilder:
             # Don't let progress callback errors crash the build
             logger.debug(f"Progress callback error: {e}")
 
-    def run(self) -> None:
+    async def run(self) -> None:
         """Run the three-pass graph building process."""
         logger.info(f"Building graph for project: {self.project_name}")
 
@@ -629,7 +631,7 @@ class SimpleGraphBuilder:
 
         # Pass 2: Definitions
         logger.info("Pass 2: Processing files and extracting definitions...")
-        self._process_files()
+        await self._process_files()
 
         # Pass 3: Relationships
         logger.info("Pass 3: Processing relationships (calls, imports)...")
@@ -771,7 +773,7 @@ class SimpleGraphBuilder:
             phase_complete=True,
         )
 
-    def _process_files(self) -> None:
+    async def _process_files(self) -> None:
         """Second pass: Process files and extract definitions."""
         # First pass: Count total files
         total_files = 0
@@ -807,7 +809,7 @@ class SimpleGraphBuilder:
                 lang_config = get_language_config(ext)
 
                 if lang_config and lang_config.name in self.parsers:
-                    self._process_single_file(filepath, lang_config.name)
+                    await self._process_single_file(filepath, lang_config.name)
                     file_count += 1
 
                     # Report progress after each file
@@ -832,7 +834,7 @@ class SimpleGraphBuilder:
             phase_complete=True,
         )
 
-    def _process_single_file(self, filepath: Path, language: str) -> None:
+    async def _process_single_file(self, filepath: Path, language: str) -> None:
         """Process a single file."""
         relative_path = filepath.relative_to(self.repo_path)
         relative_path_str = str(relative_path).replace(os.sep, "/")
@@ -873,8 +875,8 @@ class SimpleGraphBuilder:
 
         # Parse file
         try:
-            with open(filepath, "rb") as f:
-                content = f.read()
+            async with aiofiles.open(filepath, "rb") as f:
+                content = await f.read()
 
             parser = self.parsers[language]
             tree = parser.parse(content)
@@ -1636,7 +1638,7 @@ class CodebaseIngestor:
             )
             if self.project_name:
                 builder.project_name = self.project_name
-            builder.run()
+            asyncio.run(builder.run())
 
             logger.info(f"Graph successfully created at: {self.db_path}")
 

shotgun/codebase/core/manager.py

@@ -371,7 +371,16 @@ class CodebaseGraphManager:
                 )
                 import shutil
 
-                shutil.rmtree(graph_path)
+                # Handle both files and directories (kuzu v0.11.2+ uses files)
+                if graph_path.is_file():
+                    graph_path.unlink()  # Delete file
+                    # Also delete WAL file if it exists
+                    wal_path = graph_path.with_suffix(graph_path.suffix + ".wal")
+                    if wal_path.exists():
+                        wal_path.unlink()
+                        logger.debug(f"Deleted WAL file: {wal_path}")
+                else:
+                    shutil.rmtree(graph_path)  # Delete directory
 
         # Import the builder from local core module
         from shotgun.codebase.core import CodebaseIngestor
@@ -760,7 +769,7 @@ class CodebaseGraphManager:
 
                     lang_config = get_language_config(full_path.suffix)
                     if lang_config and lang_config.name in parsers:
-                        builder._process_single_file(full_path, lang_config.name)
+                        await builder._process_single_file(full_path, lang_config.name)
                         stats["nodes_modified"] += 1  # Approximate
 
             # Process additions
@@ -775,7 +784,7 @@ class CodebaseGraphManager:
 
                     lang_config = get_language_config(full_path.suffix)
                     if lang_config and lang_config.name in parsers:
-                        builder._process_single_file(full_path, lang_config.name)
+                        await builder._process_single_file(full_path, lang_config.name)
                         stats["nodes_added"] += 1  # Approximate
 
             # Flush all pending operations
@@ -1742,7 +1751,7 @@ class CodebaseGraphManager:
             )
 
             # Build the graph
-            builder.run()
+            asyncio.run(builder.run())
 
         # Run build in thread pool
         await anyio.to_thread.run_sync(_build_graph)

shotgun/codebase/core/nl_query.py

@@ -34,7 +34,7 @@ async def llm_cypher_prompt(
     Returns:
         CypherGenerationResponse with cypher_query, can_generate flag, and reason if not
     """
-    model_config = get_provider_model()
+    model_config = await get_provider_model()
 
     # Create an agent with structured output for Cypher generation
     cypher_agent = Agent(

shotgun/exceptions.py

@@ -0,0 +1,32 @@
+"""General exceptions for Shotgun application."""
+
+
+class ErrorNotPickedUpBySentry(Exception):  # noqa: N818
+    """Base for user-actionable errors that shouldn't be sent to Sentry.
+
+    These errors represent expected user conditions requiring action
+    rather than bugs that need tracking.
+    """
+
+
+class ContextSizeLimitExceeded(ErrorNotPickedUpBySentry):
+    """Raised when conversation context exceeds the model's limits.
+
+    This is a user-actionable error - they need to either:
+    1. Switch to a larger context model
+    2. Switch to a larger model, compact their conversation, then switch back
+    3. Clear the conversation and start fresh
+    """
+
+    def __init__(self, model_name: str, max_tokens: int):
+        """Initialize the exception.
+
+        Args:
+            model_name: Name of the model whose limit was exceeded
+            max_tokens: Maximum tokens allowed by the model
+        """
+        self.model_name = model_name
+        self.max_tokens = max_tokens
+        super().__init__(
+            f"Context too large for {model_name} (limit: {max_tokens:,} tokens)"
+        )