shotgun-sh 0.1.0.dev1__py3-none-any.whl

shotgun/cli/codebase/commands.py

@@ -0,0 +1,202 @@
+"""Codebase management CLI commands."""
+
+import asyncio
+import traceback
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from shotgun.codebase.models import CodebaseGraph, QueryType
+from shotgun.logging_config import get_logger
+from shotgun.sdk.codebase import CodebaseSDK
+from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
+
+from ..models import OutputFormat
+from ..utils import output_result
+from .models import ErrorResult
+
+app = typer.Typer(
+    name="codebase",
+    help="Manage and query code knowledge graphs",
+    no_args_is_help=True,
+)
+
+# Set up logger but it will be suppressed by default
+logger = get_logger(__name__)
+
+
+@app.command(name="list")
+def list_codebases(
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """List all indexed codebases."""
+    sdk = CodebaseSDK()
+
+    try:
+        result = asyncio.run(sdk.list_codebases())
+        output_result(result, format_type)
+    except Exception as e:
+        error_result = ErrorResult(
+            error_message=f"Error listing codebases: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def index(
+    path: Annotated[str, typer.Argument(help="Path to repository to index")],
+    name: Annotated[
+        str, typer.Option("--name", "-n", help="Human-readable name for the codebase")
+    ],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Index a new codebase."""
+    sdk = CodebaseSDK()
+
+    try:
+        repo_path = Path(path)
+        result = asyncio.run(sdk.index_codebase(repo_path, name))
+        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
+
+
+@app.command()
+def delete(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to delete")],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Delete an indexed codebase."""
+    sdk = CodebaseSDK()
+
+    # CLI-specific confirmation callback
+    def cli_confirm(graph: CodebaseGraph) -> bool:
+        return typer.confirm(
+            f"Are you sure you want to delete codebase '{graph.name}' ({graph_id})?"
+        )
+
+    try:
+        result = asyncio.run(sdk.delete_codebase(graph_id, cli_confirm))
+        output_result(result, format_type)
+        if not result.deleted and not result.cancelled:
+            raise typer.Exit(1)
+    except CodebaseNotFoundError 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 deleting codebase: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def info(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to show info for")],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Show detailed information about a codebase."""
+    sdk = CodebaseSDK()
+
+    try:
+        result = asyncio.run(sdk.get_info(graph_id))
+        output_result(result, format_type)
+    except CodebaseNotFoundError 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 getting codebase info: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def query(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to query")],
+    query_text: Annotated[
+        str, typer.Argument(help="Query text (natural language or Cypher)")
+    ],
+    cypher: Annotated[
+        bool,
+        typer.Option(
+            "--cypher", help="Treat query as Cypher instead of natural language"
+        ),
+    ] = False,
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Query a codebase using natural language or Cypher."""
+
+    try:
+        sdk = CodebaseSDK()
+        query_type = QueryType.CYPHER if cypher else QueryType.NATURAL_LANGUAGE
+        result = asyncio.run(sdk.query_codebase(graph_id, query_text, query_type))
+        output_result(result, format_type)
+    except CodebaseNotFoundError 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 executing query: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e
+
+
+@app.command()
+def reindex(
+    graph_id: Annotated[str, typer.Argument(help="Graph ID to reindex")],
+    format_type: Annotated[
+        OutputFormat, typer.Option("--format", "-f", help="Output format")
+    ] = OutputFormat.TEXT,
+) -> None:
+    """Reindex an existing codebase."""
+
+    try:
+        sdk = CodebaseSDK()
+        result = asyncio.run(sdk.reindex_codebase(graph_id))
+        # Stats are always shown now that verbose is controlled by env var
+        output_result(result, format_type)
+    except CodebaseNotFoundError 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 reindexing codebase: {e}",
+            details=f"Full traceback:\n{traceback.format_exc()}",
+        )
+        output_result(error_result, format_type)
+        raise typer.Exit(1) from e

shotgun/cli/codebase/models.py

@@ -0,0 +1,21 @@
+"""Re-export SDK models for backward compatibility."""
+
+from shotgun.sdk.models import (
+    DeleteResult,
+    ErrorResult,
+    IndexResult,
+    InfoResult,
+    ListResult,
+    QueryCommandResult,
+    ReindexResult,
+)
+
+__all__ = [
+    "ListResult",
+    "IndexResult",
+    "DeleteResult",
+    "InfoResult",
+    "QueryCommandResult",
+    "ReindexResult",
+    "ErrorResult",
+]

shotgun/cli/config.py

@@ -0,0 +1,261 @@
+"""Configuration management CLI commands."""
+
+import json
+from typing import Annotated, Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from shotgun.agents.config import ProviderType, get_config_manager
+from shotgun.logging_config import get_logger
+
+logger = get_logger(__name__)
+console = Console()
+
+app = typer.Typer(
+    name="config",
+    help="Manage Shotgun configuration",
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def init(
+    interactive: Annotated[
+        bool,
+        typer.Option("--interactive", "-i", help="Run interactive setup wizard"),
+    ] = True,
+) -> None:
+    """Initialize Shotgun configuration."""
+    config_manager = get_config_manager()
+
+    if config_manager.config_path.exists() and not typer.confirm(
+        f"Configuration already exists at {config_manager.config_path}. Overwrite?"
+    ):
+        console.print("❌ Configuration initialization cancelled.", style="red")
+        raise typer.Exit(1)
+
+    if interactive:
+        console.print(
+            "🚀 [bold blue]Welcome to Shotgun Configuration Setup![/bold blue]"
+        )
+        console.print()
+
+        # Initialize with defaults
+        config = config_manager.initialize()
+
+        # Ask for default provider
+        provider_choices = ["openai", "anthropic", "google"]
+        console.print("Choose your default AI provider:")
+        for i, provider in enumerate(provider_choices, 1):
+            console.print(f"  {i}. {provider}")
+
+        while True:
+            try:
+                choice = typer.prompt("Enter choice (1-3)", type=int)
+                if 1 <= choice <= 3:
+                    config.default_provider = ProviderType(provider_choices[choice - 1])
+                    break
+                else:
+                    console.print(
+                        "❌ Invalid choice. Please enter 1, 2, or 3.", style="red"
+                    )
+            except ValueError:
+                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(
+            f"Enter your {provider.upper()} API key",
+            hide_input=True,
+            default="",
+        )
+
+        if api_key:
+            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()
+        console.print(f"✅ Configuration initialized at {config_manager.config_path}")
+
+
+@app.command()
+def set(
+    provider: Annotated[
+        ProviderType,
+        typer.Argument(help="AI provider to configure (openai, anthropic, google)"),
+    ],
+    api_key: Annotated[
+        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:
+        api_key = typer.prompt(
+            f"Enter your {provider.upper()} API key",
+            hide_input=True,
+            default="",
+        )
+
+    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)
+
+        console.print(f"✅ Configuration updated for {provider}")
+
+    except Exception as e:
+        console.print(f"❌ Failed to update configuration: {e}", style="red")
+        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[
+        ProviderType | None,
+        typer.Option("--provider", "-p", help="Show config for specific provider"),
+    ] = None,
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", "-j", help="Output as JSON"),
+    ] = False,
+) -> None:
+    """Display current configuration."""
+    config_manager = get_config_manager()
+    config = config_manager.load()
+
+    if json_output:
+        # Convert to dict and mask secrets
+        data = config.model_dump()
+        _mask_secrets(data)
+        console.print(json.dumps(data, indent=2))
+        return
+
+    if provider:
+        # Show specific provider configuration
+        _show_provider_config(provider, config)
+    else:
+        # Show all configuration
+        _show_full_config(config)
+
+
+def _show_full_config(config: Any) -> None:
+    """Display full configuration in a table."""
+    table = Table(title="Shotgun Configuration", show_header=True)
+    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]")
+    table.add_row("", "")  # Separator
+
+    # Provider configurations
+    for provider_name, provider_config in [
+        ("OpenAI", config.openai),
+        ("Anthropic", config.anthropic),
+        ("Google", config.google),
+    ]:
+        table.add_row(f"[bold]{provider_name}[/bold]", "")
+
+        # API Key
+        api_key_status = "✅ Set" if provider_config.api_key else "❌ Not set"
+        table.add_row("  API Key", api_key_status)
+        table.add_row("", "")  # Separator
+
+    console.print(table)
+
+
+def _show_provider_config(provider: ProviderType, config: Any) -> None:
+    """Display configuration for a specific provider."""
+    provider_str = provider.value if isinstance(provider, ProviderType) else provider
+
+    if provider_str == "openai":
+        provider_config = config.openai
+    elif provider_str == "anthropic":
+        provider_config = config.anthropic
+    elif provider_str == "google":
+        provider_config = config.google
+    else:
+        console.print(f"❌ Unknown provider: {provider}", style="red")
+        return
+
+    table = Table(title=f"{provider.upper()} Configuration")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="white")
+
+    # API Key
+    api_key_status = "✅ Set" if provider_config.api_key else "❌ Not set"
+    table.add_row("API Key", api_key_status)
+
+    console.print(table)
+
+
+def _mask_secrets(data: dict[str, Any]) -> None:
+    """Mask secrets in configuration data."""
+    for provider in ["openai", "anthropic", "google"]:
+        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"])
+
+
+def _mask_value(value: str) -> str:
+    """Mask a secret value."""
+    if len(value) <= 8:
+        return "••••••••"
+    return f"{value[:4]}{'•' * (len(value) - 8)}{value[-4:]}"

shotgun/cli/models.py

@@ -0,0 +1,10 @@
+"""Common models for CLI commands."""
+
+from enum import Enum
+
+
+class OutputFormat(str, Enum):
+    """Output format options for CLI commands."""
+
+    TEXT = "text"
+    JSON = "json"

shotgun/cli/plan.py

@@ -0,0 +1,65 @@
+"""Plan command for shotgun CLI."""
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from shotgun.agents.config import ProviderType
+from shotgun.agents.models import AgentRuntimeOptions
+from shotgun.agents.plan import create_plan_agent, get_plan_history, run_plan_agent
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(name="plan", help="Generate structured plans", no_args_is_help=True)
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def plan(
+    goal: Annotated[str, typer.Argument(help="Goal or objective to plan for")],
+    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:
+    """Generate a structured plan for achieving the given goal.
+
+    This command will create detailed, actionable plans broken down into steps
+    and milestones to help achieve your specified objective. It can also update
+    existing plans based on new requirements or refinements.
+    """
+
+    logger.info("📋 Planning Goal: %s", goal)
+
+    try:
+        # 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)
+        logger.info("📄 Plan saved to: .shotgun/plan.md")
+        logger.debug("📚 Current plan:")
+        logger.debug("%s", get_plan_history())
+
+    except Exception as e:
+        logger.error("❌ Error during planning: %s", str(e))
+        import traceback
+
+        logger.debug("Full traceback:\n%s", traceback.format_exc())

shotgun/cli/research.py

@@ -0,0 +1,78 @@
+"""Research command for shotgun CLI."""
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from shotgun.agents.config import ProviderType
+from shotgun.agents.models import AgentRuntimeOptions
+from shotgun.agents.research import (
+    create_research_agent,
+    get_research_history,
+    run_research_agent,
+)
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(
+    name="research", help="Perform research with agentic loops", no_args_is_help=True
+)
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def research(
+    query: Annotated[str, typer.Argument(help="Research query or topic")],
+    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:
+    """Perform research on a given query using agentic loops.
+
+    This command will use AI agents to iteratively research the provided topic,
+    gathering information from multiple sources and refining the search process.
+    """
+
+    logger.info("🔍 Research Query: %s", query)
+
+    try:
+        # Run everything in the same event loop
+        asyncio.run(async_research(query, non_interactive, provider))
+
+    except Exception as e:
+        logger.error("❌ Error during research: %s", str(e))
+        import traceback
+
+        logger.debug("Full traceback:\n%s", traceback.format_exc())
+
+
+async def async_research(
+    query: str,
+    non_interactive: bool,
+    provider: ProviderType | None = None,
+) -> None:
+    """Async wrapper for research process."""
+    # Create agent dependencies
+    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)
+
+    # Start research process
+    logger.info("🔬 Starting research...")
+    result = await run_research_agent(agent, query, deps)
+
+    # Display results
+    logger.info("✅ Research Complete!")
+    logger.info("📋 Findings:")
+    logger.info("%s", result.output)
+    logger.info("📄 Full research saved to: .shotgun/research.md")
+    logger.debug("📚 Research history:")
+    logger.debug("%s", get_research_history())