shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/cli/clear.py

@@ -0,0 +1,53 @@
+"""Clear command for shotgun CLI."""
+
+import asyncio
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from shotgun.agents.conversation import ConversationManager
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(
+    name="clear", help="Clear the conversation history", no_args_is_help=False
+)
+logger = get_logger(__name__)
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def clear() -> None:
+    """Clear the current conversation history.
+
+    This command deletes the conversation file at ~/.shotgun-sh/conversation.json,
+    removing all conversation history. Other files in ~/.shotgun-sh/ (config, usage,
+    codebases, logs) are preserved.
+    """
+    try:
+        # Get conversation file path
+        conversation_file = Path.home() / ".shotgun-sh" / "conversation.json"
+
+        # Check if file exists
+        if not conversation_file.exists():
+            console.print(
+                "[yellow]No conversation file found.[/yellow] Nothing to clear.",
+                style="bold",
+            )
+            return
+
+        # Clear the conversation
+        manager = ConversationManager(conversation_file)
+        asyncio.run(manager.clear())
+
+        console.print(
+            "[green]✓[/green] Conversation cleared successfully", style="bold"
+        )
+        logger.info("Conversation cleared successfully")
+
+    except Exception as e:
+        console.print(
+            f"[red]Error:[/red] Failed to clear conversation: {e}", style="bold"
+        )
+        logger.debug("Full traceback:", exc_info=True)
+        raise typer.Exit(code=1) from e

shotgun/cli/compact.py

@@ -0,0 +1,188 @@
+"""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 import ConversationManager
+from shotgun.agents.conversation.history.history_processors import token_limit_compactor
+from shotgun.agents.conversation.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,154 @@
+"""Context command for shotgun CLI."""
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Annotated
+
+import httpx
+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 import ConversationManager
+from shotgun.cli.models import OutputFormat
+from shotgun.llm_proxy import BudgetInfo, LiteLLMProxyClient
+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)
+
+    # Add budget info for Shotgun Account users
+    if model_config.is_shotgun_account:
+        try:
+            logger.debug("Fetching budget info for Shotgun Account")
+            client = LiteLLMProxyClient(model_config.api_key)
+            budget_info = await client.get_budget_info()
+
+            # Format budget section for markdown
+            budget_markdown = _format_budget_markdown(budget_info)
+            markdown = f"{markdown}\n\n{budget_markdown}"
+
+            # Add budget info to JSON using Pydantic model
+            json_data["budget"] = budget_info.model_dump()
+            logger.debug("Successfully added budget info to context output")
+
+        except httpx.HTTPError as e:
+            logger.warning(f"Failed to fetch budget info: {e}")
+            # Don't fail the entire command if budget fetch fails
+        except Exception as e:
+            logger.warning(f"Unexpected error fetching budget info: {e}")
+            # Don't fail the entire command if budget fetch fails
+
+    return ContextAnalysisOutput(markdown=markdown, json_data=json_data)
+
+
+def _format_budget_markdown(budget_info: BudgetInfo) -> str:
+    """Format budget information as markdown.
+
+    Args:
+        budget_info: BudgetInfo instance
+
+    Returns:
+        Formatted markdown string
+    """
+    source_label = "Key" if budget_info.source == "key" else "Team"
+
+    return f"""## Shotgun Account Budget
+
+* Max Budget:     ${budget_info.max_budget:.2f}
+* Current Spend:  ${budget_info.spend:.2f}
+* Remaining:      ${budget_info.remaining:.2f} ({100 - budget_info.percentage_used:.1f}%)
+* Budget Source:  {source_label}-level"""

shotgun/cli/error_handler.py

@@ -0,0 +1,24 @@
+"""CLI-specific error handling utilities.
+
+This module provides utilities for displaying agent errors in the CLI
+by printing formatted messages to the console.
+"""
+
+from rich.console import Console
+
+from shotgun.exceptions import ErrorNotPickedUpBySentry
+
+console = Console(stderr=True)
+
+
+def print_agent_error(exception: ErrorNotPickedUpBySentry) -> None:
+    """Print an agent error to the console in yellow.
+
+    Args:
+        exception: The error exception with formatting methods
+    """
+    # Get plain text version for CLI
+    message = exception.to_plain_text()
+
+    # Print with yellow styling
+    console.print(message, style="yellow")

shotgun/cli/export.py

@@ -11,7 +11,10 @@ from shotgun.agents.export import (
     run_export_agent,
 )
 from shotgun.agents.models import AgentRuntimeOptions
+from shotgun.cli.error_handler import print_agent_error
+from shotgun.exceptions import ErrorNotPickedUpBySentry
 from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
 
 app = typer.Typer(
     name="export", help="Export artifacts to various formats with agentic approach"
@@ -45,37 +48,34 @@ def export(
 
     logger.info("📤 Export Instruction: %s", instruction)
 
-    try:
-        # Track export command usage
-        from shotgun.posthog_telemetry import track_event
-
-        track_event(
-            "export_command",
-            {
-                "non_interactive": non_interactive,
-                "provider": provider.value if provider else "default",
-            },
-        )
-
-        # Create agent dependencies
-        agent_runtime_options = AgentRuntimeOptions(
-            interactive_mode=not non_interactive
-        )
-
-        # Create the export agent with deps and provider
-        agent, deps = create_export_agent(agent_runtime_options, provider)
-
-        # Start export process
-        logger.info("🎯 Starting export...")
-        result = asyncio.run(run_export_agent(agent, instruction, deps))
-
-        # Display results
-        logger.info("✅ Export Complete!")
-        logger.info("📤 Results:")
-        logger.info("%s", result.output)
-
-    except Exception as e:
-        logger.error("❌ Error during export: %s", str(e))
-        import traceback
-
-        logger.debug("Full traceback:\n%s", traceback.format_exc())
+    # Track export command usage
+    track_event(
+        "export_command",
+        {
+            "non_interactive": non_interactive,
+            "provider": provider.value if provider else "default",
+        },
+    )
+
+    # Create agent dependencies
+    agent_runtime_options = AgentRuntimeOptions(interactive_mode=not non_interactive)
+
+    # Create the export agent with deps and provider
+    agent, deps = asyncio.run(create_export_agent(agent_runtime_options, provider))
+
+    # Start export process with error handling
+    logger.info("🎯 Starting export...")
+
+    async def async_export() -> None:
+        try:
+            result = await run_export_agent(agent, instruction, deps)
+            logger.info("✅ Export Complete!")
+            logger.info("📤 Results:")
+            logger.info("%s", result.output)
+        except ErrorNotPickedUpBySentry as e:
+            print_agent_error(e)
+        except Exception as e:
+            logger.exception("Unexpected error in export command")
+            print(f"⚠️  An unexpected error occurred: {str(e)}")
+
+    asyncio.run(async_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

@@ -8,7 +8,10 @@ import typer
 from shotgun.agents.config import ProviderType
 from shotgun.agents.models import AgentRuntimeOptions
 from shotgun.agents.plan import create_plan_agent, run_plan_agent
+from shotgun.cli.error_handler import print_agent_error
+from shotgun.exceptions import ErrorNotPickedUpBySentry
 from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
 
 app = typer.Typer(name="plan", help="Generate structured plans", no_args_is_help=True)
 logger = get_logger(__name__)
@@ -37,37 +40,34 @@ def plan(
 
     logger.info("📋 Planning Goal: %s", goal)
 
-    try:
-        # Track plan command usage
-        from shotgun.posthog_telemetry import track_event
-
-        track_event(
-            "plan_command",
-            {
-                "non_interactive": non_interactive,
-                "provider": provider.value if provider else "default",
-            },
-        )
-
-        # Create agent dependencies
-        agent_runtime_options = AgentRuntimeOptions(
-            interactive_mode=not non_interactive
-        )
-
-        # Create the plan agent with deps and provider
-        agent, deps = create_plan_agent(agent_runtime_options, provider)
-
-        # Start planning process
-        logger.info("🎯 Starting planning...")
-        result = asyncio.run(run_plan_agent(agent, goal, deps))
-
-        # Display results
-        logger.info("✅ Planning Complete!")
-        logger.info("📋 Results:")
-        logger.info("%s", result.output)
-
-    except Exception as e:
-        logger.error("❌ Error during planning: %s", str(e))
-        import traceback
-
-        logger.debug("Full traceback:\n%s", traceback.format_exc())
+    # Track plan command usage
+    track_event(
+        "plan_command",
+        {
+            "non_interactive": non_interactive,
+            "provider": provider.value if provider else "default",
+        },
+    )
+
+    # Create agent dependencies
+    agent_runtime_options = AgentRuntimeOptions(interactive_mode=not non_interactive)
+
+    # Create the plan agent with deps and provider
+    agent, deps = asyncio.run(create_plan_agent(agent_runtime_options, provider))
+
+    # Start planning process with error handling
+    logger.info("🎯 Starting planning...")
+
+    async def async_plan() -> None:
+        try:
+            result = await run_plan_agent(agent, goal, deps)
+            logger.info("✅ Planning Complete!")
+            logger.info("📋 Results:")
+            logger.info("%s", result.output)
+        except ErrorNotPickedUpBySentry as e:
+            print_agent_error(e)
+        except Exception as e:
+            logger.exception("Unexpected error in plan command")
+            print(f"⚠️  An unexpected error occurred: {str(e)}")
+
+    asyncio.run(async_plan())