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

shotgun/cli/config.py

@@ -1,5 +1,6 @@
 """Configuration management CLI commands."""
 
+import asyncio
 import json
 from typing import Annotated, Any
 
@@ -9,6 +10,7 @@ from rich.table import Table
 
 from shotgun.agents.config import ProviderType, get_config_manager
 from shotgun.logging_config import get_logger
+from shotgun.utils.env_utils import is_shotgun_account_enabled
 
 logger = get_logger(__name__)
 console = Console()
@@ -43,11 +45,11 @@ def init(
         console.print()
 
         # Initialize with defaults
-        config = config_manager.initialize()
+        asyncio.run(config_manager.initialize())
 
-        # Ask for default provider
+        # Ask for provider
         provider_choices = ["openai", "anthropic", "google"]
-        console.print("Choose your default AI provider:")
+        console.print("Choose your AI provider:")
         for i, provider in enumerate(provider_choices, 1):
             console.print(f"  {i}. {provider}")
 
@@ -55,7 +57,7 @@ def init(
             try:
                 choice = typer.prompt("Enter choice (1-3)", type=int)
                 if 1 <= choice <= 3:
-                    config.default_provider = ProviderType(provider_choices[choice - 1])
+                    provider = ProviderType(provider_choices[choice - 1])
                     break
                 else:
                     console.print(
@@ -65,7 +67,6 @@ def init(
                 console.print("❌ Please enter a valid number.", style="red")
 
         # Ask for API key for the selected provider
-        provider = config.default_provider
         console.print(f"\n🔑 Setting up {provider.upper()} API key...")
 
         api_key = typer.prompt(
@@ -75,16 +76,16 @@ def init(
         )
 
         if api_key:
-            config_manager.update_provider(provider, api_key=api_key)
+            # update_provider will automatically set selected_model for first provider
+            asyncio.run(config_manager.update_provider(provider, api_key=api_key))
 
-        config_manager.save()
         console.print(
             f"\n✅ [bold green]Configuration saved to {config_manager.config_path}[/bold green]"
         )
         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}")
 
 
@@ -98,16 +99,12 @@ def set(
         str | None,
         typer.Option("--api-key", "-k", help="API key for the provider"),
     ] = None,
-    default: Annotated[
-        bool,
-        typer.Option("--default", "-d", help="Set this provider as default"),
-    ] = False,
 ) -> None:
     """Set configuration for a specific provider."""
     config_manager = get_config_manager()
 
-    # If no API key provided via option and not just setting default, prompt for it
-    if api_key is None and not default:
+    # If no API key provided via option, prompt for it
+    if api_key is None:
         api_key = typer.prompt(
             f"Enter your {provider.upper()} API key",
             hide_input=True,
@@ -116,12 +113,7 @@ def set(
 
     try:
         if api_key:
-            config_manager.update_provider(provider, api_key=api_key)
-
-        if default:
-            config = config_manager.load()
-            config.default_provider = provider
-            config_manager.save(config)
+            asyncio.run(config_manager.update_provider(provider, api_key=api_key))
 
         console.print(f"✅ Configuration updated for {provider}")
 
@@ -130,41 +122,6 @@ def set(
         raise typer.Exit(1) from e
 
 
-@app.command()
-def set_default(
-    provider: Annotated[
-        ProviderType,
-        typer.Argument(
-            help="AI provider to set as default (openai, anthropic, google)"
-        ),
-    ],
-) -> None:
-    """Set the default AI provider without modifying API keys."""
-    config_manager = get_config_manager()
-
-    try:
-        config = config_manager.load()
-
-        # Check if the provider has an API key configured
-        provider_config = getattr(config, provider.value)
-        if not provider_config.api_key:
-            console.print(
-                f"⚠️  Warning: {provider.upper()} does not have an API key configured.",
-                style="yellow",
-            )
-            console.print(f"Use 'shotgun config set {provider}' to configure it.")
-
-        # Set as default
-        config.default_provider = provider
-        config_manager.save(config)
-
-        console.print(f"✅ Default provider set to: {provider}")
-
-    except Exception as e:
-        console.print(f"❌ Failed to set default provider: {e}", style="red")
-        raise typer.Exit(1) from e
-
-
 @app.command()
 def get(
     provider: Annotated[
@@ -177,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
@@ -201,16 +160,23 @@ def _show_full_config(config: Any) -> None:
     table.add_column("Setting", style="cyan")
     table.add_column("Value", style="white")
 
-    # Default provider
-    table.add_row("Default Provider", f"[bold]{config.default_provider}[/bold]")
+    # Selected model
+    selected_model = config.selected_model or "None (will auto-detect)"
+    table.add_row("Selected Model", f"[bold]{selected_model}[/bold]")
     table.add_row("", "")  # Separator
 
     # Provider configurations
-    for provider_name, provider_config in [
+    providers_to_show = [
         ("OpenAI", config.openai),
         ("Anthropic", config.anthropic),
         ("Google", config.google),
-    ]:
+    ]
+
+    # Only show Shotgun Account if feature flag is enabled
+    if is_shotgun_account_enabled():
+        providers_to_show.append(("Shotgun Account", config.shotgun))
+
+    for provider_name, provider_config in providers_to_show:
         table.add_row(f"[bold]{provider_name}[/bold]", "")
 
         # API Key
@@ -231,6 +197,8 @@ def _show_provider_config(provider: ProviderType, config: Any) -> None:
         provider_config = config.anthropic
     elif provider_str == "google":
         provider_config = config.google
+    elif provider_str == "shotgun":
+        provider_config = config.shotgun
     else:
         console.print(f"❌ Unknown provider: {provider}", style="red")
         return
@@ -248,7 +216,13 @@ def _show_provider_config(provider: ProviderType, config: Any) -> None:
 
 def _mask_secrets(data: dict[str, Any]) -> None:
     """Mask secrets in configuration data."""
-    for provider in ["openai", "anthropic", "google"]:
+    providers = ["openai", "anthropic", "google"]
+
+    # Only mask shotgun if feature flag is enabled
+    if is_shotgun_account_enabled():
+        providers.append("shotgun")
+
+    for provider in providers:
         if provider in data and isinstance(data[provider], dict):
             if "api_key" in data[provider] and data[provider]["api_key"]:
                 data[provider]["api_key"] = _mask_value(data[provider]["api_key"])
@@ -262,14 +236,14 @@ def _mask_value(value: str) -> str:
 
 
 @app.command()
-def get_user_id() -> None:
-    """Get the anonymous user ID from configuration."""
+def get_shotgun_instance_id() -> None:
+    """Get the anonymous shotgun instance ID from configuration."""
     config_manager = get_config_manager()
 
     try:
-        user_id = config_manager.get_user_id()
-        console.print(f"[green]User ID:[/green] {user_id}")
+        shotgun_instance_id = config_manager.get_shotgun_instance_id()
+        console.print(f"[green]Shotgun Instance ID:[/green] {shotgun_instance_id}")
     except Exception as e:
-        logger.error(f"Error getting user ID: {e}")
-        console.print(f"❌ Failed to get user ID: {str(e)}", style="red")
+        logger.error(f"Error getting shotgun instance ID: {e}")
+        console.print(f"❌ Failed to get shotgun instance ID: {str(e)}", style="red")
         raise typer.Exit(1) from e

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

@@ -0,0 +1,50 @@
+"""Configuration management CLI commands."""
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from shotgun.agents.config import get_config_manager
+from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import Feedback, FeedbackKind, submit_feedback_survey
+
+logger = get_logger(__name__)
+console = Console()
+
+app = typer.Typer(
+    name="feedback",
+    help="Send us feedback",
+    no_args_is_help=True,
+)
+
+
+@app.callback(invoke_without_command=True)
+def send_feedback(
+    description: Annotated[str, typer.Argument(help="Description of the feedback")],
+    kind: Annotated[
+        FeedbackKind,
+        typer.Option("--type", "-t", help="Feedback type"),
+    ],
+) -> None:
+    """Initialize Shotgun configuration."""
+    import asyncio
+
+    config_manager = get_config_manager()
+    asyncio.run(config_manager.load())
+    shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
+
+    if not description:
+        console.print(
+            '❌ Please add your feedback (shotgun feedback "<your feedback>").',
+            style="red",
+        )
+        raise typer.Exit(1)
+
+    feedback = Feedback(
+        kind=kind, description=description, shotgun_instance_id=shotgun_instance_id
+    )
+
+    submit_feedback_survey(feedback)
+
+    console.print("Feedback sent. Thank you!")

shotgun/cli/models.py

@@ -1,10 +1,11 @@
 """Common models for CLI commands."""
 
-from enum import Enum
+from enum import StrEnum
 
 
-class OutputFormat(str, Enum):
+class OutputFormat(StrEnum):
     """Output format options for CLI commands."""
 
     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]