shotgun-sh 0.3.3.dev1__py3-none-any.whl → 0.6.2__py3-none-any.whl

shotgun/attachments/processor.py

@@ -0,0 +1,193 @@
+"""Attachment processor for file validation and encoding.
+
+Provides functions to validate file sizes against provider limits
+and encode file contents to base64 for API submission.
+"""
+
+import base64
+import logging
+from pathlib import Path
+
+import aiofiles
+
+from shotgun.agents.config.models import ProviderType
+from shotgun.attachments.errors import (
+    cannot_read_file,
+    file_not_found,
+    file_too_large,
+)
+from shotgun.attachments.models import AttachmentType, FileAttachment
+
+logger = logging.getLogger(__name__)
+
+# Provider file size limits in bytes
+PROVIDER_SIZE_LIMITS: dict[ProviderType, int] = {
+    ProviderType.OPENAI: 20 * 1024 * 1024,  # 20MB
+    ProviderType.ANTHROPIC: 32 * 1024 * 1024,  # 32MB
+    ProviderType.GOOGLE: 4 * 1024 * 1024,  # 4MB
+}
+
+# Default limit for unknown providers (most restrictive)
+DEFAULT_SIZE_LIMIT: int = 4 * 1024 * 1024  # 4MB
+
+
+def get_provider_size_limit(provider: ProviderType) -> int:
+    """Get the maximum file size limit for a provider.
+
+    Args:
+        provider: The LLM provider type.
+
+    Returns:
+        Maximum file size in bytes.
+    """
+    return PROVIDER_SIZE_LIMITS.get(provider, DEFAULT_SIZE_LIMIT)
+
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format.
+
+    Args:
+        size_bytes: File size in bytes.
+
+    Returns:
+        Human-readable string (e.g., "2.5 MB", "512 KB", "128 B").
+    """
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    else:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+
+def validate_file_size(
+    attachment: FileAttachment,
+    provider: ProviderType,
+) -> tuple[bool, str | None]:
+    """Validate file size against provider limit.
+
+    Args:
+        attachment: The file attachment to validate.
+        provider: The target LLM provider.
+
+    Returns:
+        Tuple of (is_valid, error_message).
+        If valid: (True, None)
+        If invalid: (False, "File size {size} exceeds {provider} limit of {limit}")
+    """
+    limit = get_provider_size_limit(provider)
+
+    if attachment.file_size_bytes > limit:
+        size_str = format_file_size(attachment.file_size_bytes)
+        limit_str = format_file_size(limit)
+        provider_name = provider.value.capitalize()
+        return (
+            False,
+            file_too_large(size_str, limit_str, provider_name),
+        )
+
+    return (True, None)
+
+
+async def encode_file_to_base64(file_path: Path) -> str:
+    """Asynchronously read and encode file contents to base64.
+
+    Args:
+        file_path: Path to the file to encode.
+
+    Returns:
+        Base64-encoded string of file contents.
+
+    Raises:
+        FileNotFoundError: If file does not exist.
+        PermissionError: If file cannot be read.
+        OSError: If file read fails.
+    """
+    async with aiofiles.open(file_path, "rb") as f:
+        content = await f.read()
+
+    if not content:
+        return ""
+
+    return base64.b64encode(content).decode("utf-8")
+
+
+async def process_attachment(
+    attachment: FileAttachment,
+    provider: ProviderType,
+) -> tuple[FileAttachment, str | None]:
+    """Validate and process an attachment for submission.
+
+    Validates file size against provider limits and encodes content to base64.
+    All supported attachment types (PDF, PNG, JPG, JPEG, GIF, WEBP) work with
+    all providers (OpenAI, Anthropic, Google) via BinaryContent.
+
+    Args:
+        attachment: The file attachment to process.
+        provider: The target LLM provider.
+
+    Returns:
+        Tuple of (processed_attachment, error_message).
+        If successful: (attachment_with_base64_content, None)
+        If failed: (original_attachment, error_message)
+    """
+    # Validate file size
+    is_valid, error = validate_file_size(attachment, provider)
+    if not is_valid:
+        return (attachment, error)
+
+    # Encode file to base64
+    try:
+        content_base64 = await encode_file_to_base64(attachment.file_path)
+    except FileNotFoundError:
+        return (attachment, file_not_found(attachment.file_path))
+    except PermissionError:
+        return (attachment, cannot_read_file(attachment.file_path, "permission denied"))
+    except OSError as e:
+        logger.warning(f"Failed to read file '{attachment.file_path}': {e}")
+        return (attachment, cannot_read_file(attachment.file_path))
+
+    # Create new attachment with base64 content
+    processed = FileAttachment(
+        file_path=attachment.file_path,
+        file_name=attachment.file_name,
+        file_type=attachment.file_type,
+        file_size_bytes=attachment.file_size_bytes,
+        content_base64=content_base64,
+        mime_type=attachment.mime_type,
+    )
+
+    logger.debug(
+        f"Processed attachment: {processed.file_name} "
+        f"({len(content_base64)} base64 chars)"
+    )
+
+    return (processed, None)
+
+
+def create_attachment_hint_display(attachment: FileAttachment) -> str:
+    """Create display string for attachment in chat history.
+
+    Args:
+        attachment: The file attachment.
+
+    Returns:
+        Formatted display string (e.g., "document.pdf (2.5 MB)").
+    """
+    size_str = format_file_size(attachment.file_size_bytes)
+    return f"{attachment.file_name} ({size_str})"
+
+
+def get_attachment_icon(attachment_type: AttachmentType) -> str:
+    """Get the appropriate icon for an attachment type.
+
+    Args:
+        attachment_type: The type of attachment.
+
+    Returns:
+        Icon string for display.
+    """
+    if attachment_type == AttachmentType.PDF:
+        return "\U0001f4c4"  # document emoji
+    else:
+        return "\U0001f5bc\ufe0f"  # framed picture emoji

shotgun/build_constants.py

@@ -4,17 +4,14 @@ This file is auto-generated during the build process.
 DO NOT EDIT MANUALLY.
 """
 
-# Sentry DSN embedded at build time (empty string if not provided)
-SENTRY_DSN = 'https://2818a6d165c64eccc94cfd51ce05d6aa@o4506813296738304.ingest.us.sentry.io/4510045952409600'
-
 # PostHog configuration embedded at build time (empty strings if not provided)
 POSTHOG_API_KEY = 'phc_KKnChzZUKeNqZDOTJ6soCBWNQSx3vjiULdwTR9H5Mcr'
 POSTHOG_PROJECT_ID = '191396'
 
 # Logfire configuration embedded at build time (only for dev builds)
-LOGFIRE_ENABLED = 'true'
-LOGFIRE_TOKEN = 'pylf_v1_us_RwZMlJm1tX6j0PL5RWWbmZpzK2hLBNtFWStNKlySfjh8'
+LOGFIRE_ENABLED = ''
+LOGFIRE_TOKEN = ''
 
 # Build metadata
-BUILD_TIME_ENV = "production" if SENTRY_DSN else "development"
-IS_DEV_BUILD = True
+BUILD_TIME_ENV = "production" if POSTHOG_API_KEY else "development"
+IS_DEV_BUILD = False

shotgun/cli/clear.py

@@ -1,13 +1,13 @@
 """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
+from shotgun.utils import get_shotgun_home
 
 app = typer.Typer(
     name="clear", help="Clear the conversation history", no_args_is_help=False
@@ -26,7 +26,7 @@ def clear() -> None:
     """
     try:
         # Get conversation file path
-        conversation_file = Path.home() / ".shotgun-sh" / "conversation.json"
+        conversation_file = get_shotgun_home() / "conversation.json"
 
         # Check if file exists
         if not conversation_file.exists():

shotgun/cli/codebase/commands.py

@@ -16,6 +16,8 @@ from rich.progress import (
     TimeElapsedColumn,
 )
 
+from shotgun.codebase.benchmarks import BenchmarkRunner, MetricsExporter, get_formatter
+from shotgun.codebase.benchmarks.formatters import MetricsDisplayOptions
 from shotgun.codebase.models import (
     CodebaseGraph,
     IndexProgress,
@@ -69,81 +71,195 @@ def index(
     format_type: Annotated[
         OutputFormat, typer.Option("--format", "-f", help="Output format")
     ] = OutputFormat.TEXT,
+    # Benchmark flags
+    benchmark: Annotated[
+        bool,
+        typer.Option("--benchmark", help="Enable benchmark mode with detailed metrics"),
+    ] = False,
+    iterations: Annotated[
+        int,
+        typer.Option(
+            "--benchmark-iterations",
+            help="Number of benchmark runs (requires --benchmark)",
+        ),
+    ] = 1,
+    warmup: Annotated[
+        int,
+        typer.Option(
+            "--benchmark-warmup", help="Number of warmup runs (requires --benchmark)"
+        ),
+    ] = 0,
+    benchmark_output: Annotated[
+        str,
+        typer.Option(
+            "--benchmark-output",
+            help="Benchmark output format: json|markdown",
+        ),
+    ] = "json",
+    benchmark_export: Annotated[
+        str | None,
+        typer.Option("--benchmark-export", help="Export metrics to file"),
+    ] = None,
+    show_files: Annotated[
+        bool,
+        typer.Option("--show-files", help="Show per-file metrics in benchmark output"),
+    ] = False,
+    show_workers: Annotated[
+        bool,
+        typer.Option(
+            "--show-workers", help="Show per-worker metrics in benchmark output"
+        ),
+    ] = False,
+    top_n: Annotated[
+        int | None,
+        typer.Option("--top-n", help="Show N slowest files (requires --benchmark)"),
+    ] = None,
+    sequential: Annotated[
+        bool,
+        typer.Option(
+            "--sequential", help="Force sequential mode (disable parallelization)"
+        ),
+    ] = False,
 ) -> None:
-    """Index a new codebase."""
-    sdk = CodebaseSDK()
+    """Index a new codebase.
+
+    By default, runs with a TUI progress display. Use --benchmark for detailed
+    metrics reporting.
+    """
     console = Console()
 
-    # Create progress display
-    progress = Progress(
-        SpinnerColumn(),
-        TextColumn("[bold blue]{task.description}"),
-        BarColumn(),
-        TaskProgressColumn(),
-        TimeElapsedColumn(),
-        console=console,
-    )
-
-    # Track tasks by phase
-    tasks = {}
-
-    def progress_callback(progress_info: IndexProgress) -> None:
-        """Update progress display based on indexing phase."""
-        phase = progress_info.phase
-
-        # Create task if it doesn't exist
-        if phase not in tasks:
-            if progress_info.total is not None:
-                tasks[phase] = progress.add_task(
-                    progress_info.phase_name, total=progress_info.total
-                )
-            else:
-                # Indeterminate progress (spinner only)
-                tasks[phase] = progress.add_task(progress_info.phase_name, total=None)
-
-        task_id = tasks[phase]
-
-        # Update task
-        if progress_info.total is not None:
-            progress.update(
-                task_id,
-                completed=progress_info.current,
-                total=progress_info.total,
-                description=f"[bold blue]{progress_info.phase_name}",
+    # Validate path
+    repo_path = Path(path).resolve()
+    if not repo_path.exists():
+        error_result = ErrorResult(error_message=f"Path does not exist: {repo_path}")
+        output_result(error_result, format_type)
+        raise typer.Exit(1)
+
+    # Benchmark mode
+    if benchmark:
+        try:
+            # Create and run benchmark
+            runner = BenchmarkRunner(
+                codebase_path=repo_path,
+                codebase_name=name,
+                iterations=iterations,
+                warmup_iterations=warmup,
+                parallel=not sequential,
+                collect_file_metrics=show_files or top_n is not None,
+                collect_worker_metrics=show_workers,
+            )
+
+            console.print(f"\n[bold blue]Starting benchmark: {name}[/bold blue]")
+            console.print(f"Path: {repo_path}")
+            console.print(f"Mode: {'Sequential' if sequential else 'Parallel'}")
+            console.print(f"Iterations: {iterations} ({warmup} warmup)")
+            console.print()
+
+            results = asyncio.run(runner.run())
+
+            # Format output
+            formatter = get_formatter(benchmark_output)
+            options = MetricsDisplayOptions(
+                show_phase_metrics=True,
+                show_worker_metrics=show_workers,
+                show_file_metrics=show_files or top_n is not None,
+                top_n_files=top_n,
             )
-        else:
-            # Just update description for indeterminate tasks
-            progress.update(
-                task_id,
-                description=f"[bold blue]{progress_info.phase_name} ({progress_info.current} items)",
+            output = formatter.format_results(results, options)
+            console.print(output)
+
+            # Export if requested
+            if benchmark_export:
+                exporter = MetricsExporter()
+                exporter.export(results, Path(benchmark_export), options=options)
+                console.print(
+                    f"\n[green]Metrics exported to: {benchmark_export}[/green]"
+                )
+
+        except Exception as e:
+            error_result = ErrorResult(
+                error_message=f"Benchmark error: {e}",
+                details=f"Full traceback:\n{traceback.format_exc()}",
             )
+            output_result(error_result, format_type)
+            raise typer.Exit(1) from e
+
+    else:
+        # Normal mode with TUI progress display
+        sdk = CodebaseSDK()
+
+        # Create progress display
+        progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            TimeElapsedColumn(),
+            console=console,
+        )
+
+        # Track tasks by phase
+        tasks = {}
 
-        # Mark as complete if phase is done
-        if progress_info.phase_complete:
+        def progress_callback(progress_info: IndexProgress) -> None:
+            """Update progress display based on indexing phase."""
+            phase = progress_info.phase
+
+            # Create task if it doesn't exist
+            if phase not in tasks:
+                if progress_info.total is not None:
+                    tasks[phase] = progress.add_task(
+                        progress_info.phase_name, total=progress_info.total
+                    )
+                else:
+                    # Indeterminate progress (spinner only)
+                    tasks[phase] = progress.add_task(
+                        progress_info.phase_name, total=None
+                    )
+
+            task_id = tasks[phase]
+
+            # Update task
             if progress_info.total is not None:
-                progress.update(task_id, completed=progress_info.total)
+                progress.update(
+                    task_id,
+                    completed=progress_info.current,
+                    total=progress_info.total,
+                    description=f"[bold blue]{progress_info.phase_name}",
+                )
+            else:
+                # Just update description for indeterminate tasks
+                progress.update(
+                    task_id,
+                    description=f"[bold blue]{progress_info.phase_name} ({progress_info.current} items)",
+                )
 
-    try:
-        repo_path = Path(path)
+            # Mark as complete if phase is done
+            if progress_info.phase_complete:
+                if progress_info.total is not None:
+                    progress.update(task_id, completed=progress_info.total)
+
+        try:
+            # Run indexing with progress display
+            with progress:
+                result = asyncio.run(
+                    sdk.index_codebase(
+                        repo_path, name, progress_callback=progress_callback
+                    )
+                )
 
-        # Run indexing with progress display
-        with progress:
-            result = asyncio.run(
-                sdk.index_codebase(repo_path, name, progress_callback=progress_callback)
+            output_result(result, format_type)
+        except InvalidPathError as e:
+            error_result = ErrorResult(error_message=str(e))
+            output_result(error_result, format_type)
+            raise typer.Exit(1) from e
+        except Exception as e:
+            error_result = ErrorResult(
+                error_message=f"Error indexing codebase: {e}",
+                details=f"Full traceback:\n{traceback.format_exc()}",
             )
-
-        output_result(result, format_type)
-    except InvalidPathError as e:
-        error_result = ErrorResult(error_message=str(e))
-        output_result(error_result, format_type)
-        raise typer.Exit(1) from e
-    except Exception as e:
-        error_result = ErrorResult(
-            error_message=f"Error indexing codebase: {e}",
-            details=f"Full traceback:\n{traceback.format_exc()}",
-        )
-        output_result(error_result, format_type)
-        raise typer.Exit(1) from e
+            output_result(error_result, format_type)
+            raise typer.Exit(1) from e
 
 
 @app.command()

shotgun/cli/compact.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import json
-from pathlib import Path
 from typing import Annotated, Any
 
 import typer
@@ -17,6 +16,7 @@ from shotgun.agents.conversation.history.token_estimation import (
 )
 from shotgun.cli.models import OutputFormat
 from shotgun.logging_config import get_logger
+from shotgun.utils import get_shotgun_home
 
 app = typer.Typer(
     name="compact", help="Compact the conversation history", no_args_is_help=False
@@ -74,7 +74,7 @@ async def compact_conversation() -> dict[str, Any]:
         Dictionary with compaction statistics including before/after metrics
     """
     # Get conversation file path
-    conversation_file = Path.home() / ".shotgun-sh" / "conversation.json"
+    conversation_file = get_shotgun_home() / "conversation.json"
 
     if not conversation_file.exists():
         raise FileNotFoundError(f"Conversation file not found at {conversation_file}")

shotgun/cli/context.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import json
-from pathlib import Path
 from typing import Annotated
 
 import httpx
@@ -19,6 +18,7 @@ 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
+from shotgun.utils import get_shotgun_home
 
 app = typer.Typer(
     name="context", help="Analyze conversation context usage", no_args_is_help=False
@@ -74,7 +74,7 @@ async def analyze_context() -> ContextAnalysisOutput:
         ContextAnalysisOutput with both markdown and JSON representations of the analysis
     """
     # Get conversation file path
-    conversation_file = Path.home() / ".shotgun-sh" / "conversation.json"
+    conversation_file = get_shotgun_home() / "conversation.json"
 
     if not conversation_file.exists():
         raise FileNotFoundError(f"Conversation file not found at {conversation_file}")

shotgun/cli/error_handler.py

@@ -6,12 +6,12 @@ by printing formatted messages to the console.
 
 from rich.console import Console
 
-from shotgun.exceptions import ErrorNotPickedUpBySentry
+from shotgun.exceptions import UserActionableError
 
 console = Console(stderr=True)
 
 
-def print_agent_error(exception: ErrorNotPickedUpBySentry) -> None:
+def print_agent_error(exception: UserActionableError) -> None:
     """Print an agent error to the console in yellow.
 
     Args:

shotgun/cli/run.py

@@ -0,0 +1,90 @@
+"""Run command for shotgun CLI - executes prompts using the Router agent."""
+
+import asyncio
+import traceback
+from typing import Annotated
+
+import typer
+
+from shotgun.agents.config import ProviderType
+from shotgun.agents.models import AgentRuntimeOptions
+from shotgun.agents.router import (
+    RouterMode,
+    create_router_agent,
+    run_router_agent,
+)
+from shotgun.cli.error_handler import print_agent_error
+from shotgun.exceptions import UserActionableError
+from shotgun.logging_config import get_logger
+from shotgun.posthog_telemetry import track_event
+
+app = typer.Typer(
+    name="run", help="Run a prompt using the Router agent", no_args_is_help=True
+)
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def run(
+    prompt: Annotated[str, typer.Argument(help="The prompt to execute")],
+    non_interactive: Annotated[
+        bool,
+        typer.Option(
+            "--non-interactive", "-n", help="Disable user interaction (for CI/CD)"
+        ),
+    ] = False,
+    provider: Annotated[
+        ProviderType | None,
+        typer.Option("--provider", "-p", help="AI provider to use (overrides default)"),
+    ] = None,
+) -> None:
+    """Execute a prompt using the Router agent in drafting mode.
+
+    The Router agent orchestrates sub-agents (Research, Specify, Plan, Tasks, Export)
+    based on your prompt. In drafting mode, it auto-executes without confirmation.
+    """
+    logger.info("Running prompt: %s", prompt[:100])
+
+    try:
+        asyncio.run(async_run(prompt, non_interactive, provider))
+    except Exception as e:
+        logger.error("Error during execution: %s", str(e))
+        logger.debug("Full traceback:\n%s", traceback.format_exc())
+
+
+async def async_run(
+    prompt: str,
+    non_interactive: bool,
+    provider: ProviderType | None = None,
+) -> None:
+    """Async implementation of the run command."""
+    track_event(
+        "run_command",
+        {
+            "non_interactive": non_interactive,
+            "provider": provider.value if provider else "default",
+        },
+    )
+
+    # Create agent runtime options
+    agent_runtime_options = AgentRuntimeOptions(
+        interactive_mode=not non_interactive,
+    )
+
+    # Create the router agent
+    agent, deps = await create_router_agent(agent_runtime_options, provider)
+
+    # Set drafting mode for CLI (auto-execute without confirmation)
+    deps.router_mode = RouterMode.DRAFTING
+
+    logger.info("Starting Router agent in drafting mode...")
+    try:
+        result = await run_router_agent(agent, prompt, deps)
+        print("Complete!")
+        print("Response:")
+        print(result.output)
+    except UserActionableError as e:
+        print_agent_error(e)
+    except Exception as e:
+        logger.exception("Unexpected error in run command")
+        print(f"An unexpected error occurred: {str(e)}")

shotgun/cli/spec/backup.py

@@ -6,11 +6,12 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from shotgun.logging_config import get_logger
+from shotgun.utils import get_shotgun_home
 
 logger = get_logger(__name__)
 
 # Backup directory location
-BACKUP_DIR = Path.home() / ".shotgun-sh" / "backups"
+BACKUP_DIR = get_shotgun_home() / "backups"
 
 
 async def create_backup(shotgun_dir: Path) -> str | None: