shotgun-sh 0.2.29.dev2__py3-none-any.whl → 0.6.1.dev1__py3-none-any.whl

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/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 ErrorNotPickedUpBySentry
+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 ErrorNotPickedUpBySentry 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:

shotgun/cli/spec/commands.py

@@ -16,6 +16,7 @@ from shotgun.shotgun_web.exceptions import (
 from shotgun.tui import app as tui_app
 from shotgun.utils.file_system_utils import get_shotgun_base_path
 
+from .models import PullSource
 from .pull_service import CancelledError, PullProgress, SpecPullService
 
 app = typer.Typer(
@@ -94,6 +95,7 @@ async def _async_pull(version_id: str) -> bool:
                 version_id=version_id,
                 shotgun_dir=shotgun_dir,
                 on_progress=on_progress,
+                source=PullSource.CLI,
             )
 
         if result.success:

shotgun/cli/spec/models.py

@@ -1,10 +1,28 @@
 """Pydantic models for spec CLI commands."""
 
 from datetime import datetime
+from enum import StrEnum
 
 from pydantic import BaseModel, Field
 
 
+class PullSource(StrEnum):
+    """Source of spec pull operation for analytics."""
+
+    CLI = "cli"
+    TUI = "tui"
+
+
+class PullPhase(StrEnum):
+    """Phases during spec pull operation for analytics."""
+
+    STARTING = "starting"
+    FETCHING = "fetching"
+    BACKUP = "backup"
+    DOWNLOADING = "downloading"
+    FINALIZING = "finalizing"
+
+
 class SpecMeta(BaseModel):
     """Metadata stored in .shotgun/meta.json after pulling a spec.