shotgun-sh 0.4.0.dev1__py3-none-any.whl → 0.6.2__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/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:

shotgun/codebase/__init__.py

@@ -1,5 +1,6 @@
 """Shotgun codebase analysis and graph management."""
 
+from shotgun.codebase.indexing_state import IndexingState
 from shotgun.codebase.models import CodebaseGraph, GraphStatus, QueryResult, QueryType
 from shotgun.codebase.service import CodebaseService
 
@@ -7,6 +8,7 @@ __all__ = [
     "CodebaseService",
     "CodebaseGraph",
     "GraphStatus",
+    "IndexingState",
     "QueryResult",
     "QueryType",
 ]

shotgun/codebase/benchmarks/__init__.py

@@ -0,0 +1,35 @@
+"""Benchmark system for codebase indexing performance analysis.
+
+This package provides tools for running benchmarks and reporting metrics
+for the codebase indexing pipeline.
+"""
+
+from shotgun.codebase.benchmarks.benchmark_runner import BenchmarkRunner
+from shotgun.codebase.benchmarks.exporters import MetricsExporter
+from shotgun.codebase.benchmarks.formatters import (
+    JsonFormatter,
+    MarkdownFormatter,
+    MetricsDisplayOptions,
+    get_formatter,
+)
+from shotgun.codebase.benchmarks.models import (
+    BenchmarkConfig,
+    BenchmarkMode,
+    BenchmarkResults,
+    BenchmarkRun,
+    OutputFormat,
+)
+
+__all__ = [
+    "BenchmarkConfig",
+    "BenchmarkMode",
+    "BenchmarkResults",
+    "BenchmarkRun",
+    "BenchmarkRunner",
+    "JsonFormatter",
+    "MarkdownFormatter",
+    "MetricsDisplayOptions",
+    "MetricsExporter",
+    "OutputFormat",
+    "get_formatter",
+]