shotgun-sh 0.1.0__py3-none-any.whl

shotgun/cli/config.py

@@ -0,0 +1,275 @@
+"""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:]}"
+
+
+@app.command()
+def get_user_id() -> None:
+    """Get the anonymous user 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}")
+    except Exception as e:
+        logger.error(f"Error getting user ID: {e}")
+        console.print(f"❌ Failed to get user ID: {str(e)}", style="red")
+        raise typer.Exit(1) from e

shotgun/cli/export.py

@@ -0,0 +1,81 @@
+"""Export command for shotgun CLI."""
+
+import asyncio
+from typing import Annotated
+
+import typer
+
+from shotgun.agents.config import ProviderType
+from shotgun.agents.export import (
+    create_export_agent,
+    run_export_agent,
+)
+from shotgun.agents.models import AgentRuntimeOptions
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(
+    name="export", help="Export artifacts to various formats with agentic approach"
+)
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def export(
+    instruction: Annotated[
+        str, typer.Argument(help="Export instruction or format specification")
+    ],
+    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:
+    """Export artifacts and findings to various formats.
+
+    This command exports research, plans, tasks, and other project artifacts
+    to different formats like Markdown, HTML, JSON, CSV, or project management
+    tool formats. The AI agent will analyze available content and transform
+    it according to your export requirements.
+    """
+
+    logger.info("📤 Export Instruction: %s", instruction)
+
+    try:
+        # Track export command usage
+        from shotgun.posthog_telemetry import track_event
+
+        track_event(
+            "export_command",
+            {
+                "non_interactive": non_interactive,
+                "provider": provider.value if provider else "default",
+            },
+        )
+
+        # Create agent dependencies
+        agent_runtime_options = AgentRuntimeOptions(
+            interactive_mode=not non_interactive
+        )
+
+        # Create the export agent with deps and provider
+        agent, deps = create_export_agent(agent_runtime_options, provider)
+
+        # Start export process
+        logger.info("🎯 Starting export...")
+        result = asyncio.run(run_export_agent(agent, instruction, deps))
+
+        # Display results
+        logger.info("✅ Export Complete!")
+        logger.info("📤 Results:")
+        logger.info("%s", result.output)
+
+    except Exception as e:
+        logger.error("❌ Error during export: %s", str(e))
+        import traceback
+
+        logger.debug("Full traceback:\n%s", traceback.format_exc())

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,73 @@
+"""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, 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:
+        # Track plan command usage
+        from shotgun.posthog_telemetry import track_event
+
+        track_event(
+            "plan_command",
+            {
+                "non_interactive": non_interactive,
+                "provider": provider.value if provider else "default",
+            },
+        )
+
+        # 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)
+
+    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,85 @@
+"""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,
+    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."""
+    # Track research command usage
+    from shotgun.posthog_telemetry import track_event
+
+    track_event(
+        "research_command",
+        {
+            "non_interactive": non_interactive,
+            "provider": provider.value if provider else "default",
+        },
+    )
+
+    # 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
+    print("✅ Research Complete!")
+    print("📋 Findings:")
+    print(result.output)

shotgun/cli/specify.py

@@ -0,0 +1,69 @@
+"""Specify 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.specify import (
+    create_specify_agent,
+    run_specify_agent,
+)
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(
+    name="specify", help="Generate comprehensive specifications", no_args_is_help=True
+)
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def specify(
+    requirement: Annotated[
+        str, typer.Argument(help="Requirement or feature to specify")
+    ],
+    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 comprehensive specifications for software features and systems.
+
+    This command creates detailed technical specifications including requirements,
+    architecture, implementation details, and acceptance criteria based on your
+    provided requirement or feature description.
+    """
+
+    logger.info("📝 Specification Requirement: %s", requirement)
+
+    try:
+        # Create agent dependencies
+        agent_runtime_options = AgentRuntimeOptions(
+            interactive_mode=not non_interactive
+        )
+
+        # Create the specify agent with deps and provider
+        agent, deps = create_specify_agent(agent_runtime_options, provider)
+
+        # Start specification process
+        logger.info("📋 Starting specification generation...")
+        result = asyncio.run(run_specify_agent(agent, requirement, deps))
+
+        # Display results
+        logger.info("✅ Specification Complete!")
+        logger.info("📋 Results:")
+        logger.info("%s", result.output)
+
+    except Exception as e:
+        logger.error("❌ Error during specification: %s", str(e))
+        import traceback
+
+        logger.debug("Full traceback:\n%s", traceback.format_exc())

shotgun/cli/tasks.py

@@ -0,0 +1,78 @@
+"""Tasks 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.tasks import (
+    create_tasks_agent,
+    run_tasks_agent,
+)
+from shotgun.logging_config import get_logger
+
+app = typer.Typer(name="tasks", help="Generate task lists with agentic approach")
+logger = get_logger(__name__)
+
+
+@app.callback(invoke_without_command=True)
+def tasks(
+    instruction: Annotated[
+        str, typer.Argument(help="Task creation instruction or project description")
+    ],
+    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 actionable task lists based on existing research and plans.
+
+    This command creates detailed task breakdowns using AI agents that analyze
+    your research and plans to generate prioritized, actionable tasks with
+    acceptance criteria and effort estimates.
+    """
+
+    logger.info("📋 Task Creation Instruction: %s", instruction)
+
+    try:
+        # Track tasks command usage
+        from shotgun.posthog_telemetry import track_event
+
+        track_event(
+            "tasks_command",
+            {
+                "non_interactive": non_interactive,
+                "provider": provider.value if provider else "default",
+            },
+        )
+
+        # Create agent dependencies
+        agent_runtime_options = AgentRuntimeOptions(
+            interactive_mode=not non_interactive
+        )
+
+        # Create the tasks agent with deps and provider
+        agent, deps = create_tasks_agent(agent_runtime_options, provider)
+
+        # Start task creation process
+        logger.info("🎯 Starting task creation...")
+        result = asyncio.run(run_tasks_agent(agent, instruction, deps))
+
+        # Display results
+        logger.info("✅ Task Creation Complete!")
+        logger.info("📋 Results:")
+        logger.info("%s", result.output)
+
+    except Exception as e:
+        logger.error("❌ Error during task creation: %s", str(e))
+        import traceback
+
+        logger.debug("Full traceback:\n%s", traceback.format_exc())