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

shotgun/cli/plan.py

@@ -1,73 +0,0 @@
-"""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.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="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)
-
-    # Track plan command usage
-    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 = asyncio.run(create_plan_agent(agent_runtime_options, provider))
-
-    # Start planning process with error handling
-    logger.info("🎯 Starting planning...")
-
-    async def async_plan() -> None:
-        try:
-            result = await run_plan_agent(agent, goal, deps)
-            logger.info("✅ Planning Complete!")
-            logger.info("📋 Results:")
-            logger.info("%s", result.output)
-        except ErrorNotPickedUpBySentry as e:
-            print_agent_error(e)
-        except Exception as e:
-            logger.exception("Unexpected error in plan command")
-            print(f"⚠️  An unexpected error occurred: {str(e)}")
-
-    asyncio.run(async_plan())

shotgun/cli/research.py

@@ -1,93 +0,0 @@
-"""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.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="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
-    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 = await create_research_agent(agent_runtime_options, provider)
-
-    # Start research process with error handling
-    logger.info("🔬 Starting research...")
-    try:
-        result = await run_research_agent(agent, query, deps)
-        # Display results
-        print("✅ Research Complete!")
-        print("📋 Findings:")
-        print(result.output)
-    except ErrorNotPickedUpBySentry as e:
-        # All user-actionable errors - display with plain text
-        print_agent_error(e)
-    except Exception as e:
-        # Unexpected errors that weren't wrapped (shouldn't happen)
-        logger.exception("Unexpected error in research command")
-        print(f"⚠️  An unexpected error occurred: {str(e)}")

shotgun/cli/specify.py

@@ -1,70 +0,0 @@
-"""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.cli.error_handler import print_agent_error
-from shotgun.exceptions import ErrorNotPickedUpBySentry
-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)
-
-    # Create agent dependencies
-    agent_runtime_options = AgentRuntimeOptions(interactive_mode=not non_interactive)
-
-    # Create the specify agent with deps and provider
-    agent, deps = asyncio.run(create_specify_agent(agent_runtime_options, provider))
-
-    # Start specification process with error handling
-    logger.info("📋 Starting specification generation...")
-
-    async def async_specify() -> None:
-        try:
-            result = await run_specify_agent(agent, requirement, deps)
-            logger.info("✅ Specification Complete!")
-            logger.info("📋 Results:")
-            logger.info("%s", result.output)
-        except ErrorNotPickedUpBySentry as e:
-            print_agent_error(e)
-        except Exception as e:
-            logger.exception("Unexpected error in specify command")
-            print(f"⚠️  An unexpected error occurred: {str(e)}")
-
-    asyncio.run(async_specify())

shotgun/cli/tasks.py

@@ -1,78 +0,0 @@
-"""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.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="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)
-
-    # Track tasks command usage
-    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 = asyncio.run(create_tasks_agent(agent_runtime_options, provider))
-
-    # Start task creation process with error handling
-    logger.info("🎯 Starting task creation...")
-
-    async def async_tasks() -> None:
-        try:
-            result = await run_tasks_agent(agent, instruction, deps)
-            logger.info("✅ Task Creation Complete!")
-            logger.info("📋 Results:")
-            logger.info("%s", result.output)
-        except ErrorNotPickedUpBySentry as e:
-            print_agent_error(e)
-        except Exception as e:
-            logger.exception("Unexpected error in tasks command")
-            print(f"⚠️  An unexpected error occurred: {str(e)}")
-
-    asyncio.run(async_tasks())

shotgun/sentry_telemetry.py

@@ -1,232 +0,0 @@
-"""Sentry observability setup for Shotgun."""
-
-from pathlib import Path
-from typing import Any
-
-from shotgun import __version__
-from shotgun.logging_config import get_early_logger
-from shotgun.settings import settings
-
-# Use early logger to prevent automatic StreamHandler creation
-logger = get_early_logger(__name__)
-
-
-def _scrub_path(path: str) -> str:
-    """Scrub sensitive information from file paths.
-
-    Removes home directory and current working directory prefixes to prevent
-    leaking usernames that might be part of the path.
-
-    Args:
-        path: The file path to scrub
-
-    Returns:
-        The scrubbed path with sensitive prefixes removed
-    """
-    if not path:
-        return path
-
-    try:
-        # Get home and cwd as Path objects for comparison
-        home = Path.home()
-        cwd = Path.cwd()
-
-        # Convert path to Path object
-        path_obj = Path(path)
-
-        # Try to make path relative to cwd first (most common case)
-        try:
-            relative_to_cwd = path_obj.relative_to(cwd)
-            return str(relative_to_cwd)
-        except ValueError:
-            pass
-
-        # Try to replace home directory with ~
-        try:
-            relative_to_home = path_obj.relative_to(home)
-            return f"~/{relative_to_home}"
-        except ValueError:
-            pass
-
-        # If path is absolute but not under cwd or home, just return filename
-        if path_obj.is_absolute():
-            return path_obj.name
-
-        # Return as-is if already relative
-        return path
-
-    except Exception:
-        # If anything goes wrong, return the original path
-        # Better to leak a path than break error reporting
-        return path
-
-
-def _scrub_sensitive_paths(event: dict[str, Any]) -> None:
-    """Scrub sensitive paths from Sentry event data.
-
-    Modifies the event in-place to remove:
-    - Home directory paths (might contain usernames)
-    - Current working directory paths (might contain usernames)
-    - Server name/hostname
-    - Paths in sys.argv
-
-    Args:
-        event: The Sentry event dictionary to scrub
-    """
-    extra = event.get("extra", {})
-    if "sys.argv" in extra:
-        argv = extra["sys.argv"]
-        if isinstance(argv, list):
-            extra["sys.argv"] = [
-                _scrub_path(arg) if isinstance(arg, str) else arg for arg in argv
-            ]
-
-    # Scrub server name if present
-    if "server_name" in event:
-        event["server_name"] = ""
-
-    # Scrub contexts that might contain paths
-    if "contexts" in event:
-        contexts = event["contexts"]
-        # Remove runtime context if it has CWD
-        if "runtime" in contexts:
-            if "cwd" in contexts["runtime"]:
-                del contexts["runtime"]["cwd"]
-            # Scrub sys.argv to remove paths
-            if "sys.argv" in contexts["runtime"]:
-                argv = contexts["runtime"]["sys.argv"]
-                if isinstance(argv, list):
-                    contexts["runtime"]["sys.argv"] = [
-                        _scrub_path(arg) if isinstance(arg, str) else arg
-                        for arg in argv
-                    ]
-
-    # Scrub exception stack traces
-    if "exception" in event and "values" in event["exception"]:
-        for exception in event["exception"]["values"]:
-            if "stacktrace" in exception and "frames" in exception["stacktrace"]:
-                for frame in exception["stacktrace"]["frames"]:
-                    # Scrub file paths
-                    if "abs_path" in frame:
-                        frame["abs_path"] = _scrub_path(frame["abs_path"])
-                    if "filename" in frame:
-                        frame["filename"] = _scrub_path(frame["filename"])
-
-                    # Scrub local variables that might contain paths
-                    if "vars" in frame:
-                        for var_name, var_value in frame["vars"].items():
-                            if isinstance(var_value, str):
-                                frame["vars"][var_name] = _scrub_path(var_value)
-
-    # Scrub breadcrumbs that might contain paths
-    if "breadcrumbs" in event and "values" in event["breadcrumbs"]:
-        for breadcrumb in event["breadcrumbs"]["values"]:
-            if "data" in breadcrumb:
-                for key, value in breadcrumb["data"].items():
-                    if isinstance(value, str):
-                        breadcrumb["data"][key] = _scrub_path(value)
-
-
-def setup_sentry_observability() -> bool:
-    """Set up Sentry observability for error tracking.
-
-    Returns:
-        True if Sentry was successfully set up, False otherwise
-    """
-    try:
-        import sentry_sdk
-
-        # Check if Sentry is already initialized
-        if sentry_sdk.is_initialized():
-            logger.debug("Sentry is already initialized, skipping")
-            return True
-
-        # Get DSN from settings (handles build constants + env vars automatically)
-        dsn = settings.telemetry.sentry_dsn
-
-        if not dsn:
-            logger.debug("No Sentry DSN configured, skipping Sentry initialization")
-            return False
-
-        logger.debug("Using Sentry DSN from settings, proceeding with setup")
-
-        # Determine environment based on version
-        # Dev versions contain "dev", "rc", "alpha", "beta"
-        if any(marker in __version__ for marker in ["dev", "rc", "alpha", "beta"]):
-            environment = "development"
-        else:
-            environment = "production"
-
-        def before_send(event: Any, hint: dict[str, Any]) -> Any:
-            """Filter out user-actionable errors and scrub sensitive paths.
-
-            User-actionable errors (like context size limits) are expected conditions
-            that users need to resolve, not bugs that need tracking.
-
-            Also scrubs sensitive information like usernames from file paths and
-            working directories to protect user privacy.
-            """
-
-            log_record = hint.get("log_record")
-            if log_record:
-                # Scrub pathname using the helper function
-                log_record.pathname = _scrub_path(log_record.pathname)
-
-                # Scrub traceback text if it exists
-                if hasattr(log_record, "exc_text") and isinstance(
-                    log_record.exc_text, str
-                ):
-                    # Replace home directory in traceback text
-                    home = Path.home()
-                    log_record.exc_text = log_record.exc_text.replace(str(home), "~")
-
-            if "exc_info" in hint:
-                _, exc_value, _ = hint["exc_info"]
-                from shotgun.exceptions import ErrorNotPickedUpBySentry
-
-                if isinstance(exc_value, ErrorNotPickedUpBySentry):
-                    # Don't send to Sentry - this is user-actionable, not a bug
-                    return None
-
-            # Scrub sensitive paths from the event
-            _scrub_sensitive_paths(event)
-            return event
-
-        # Initialize Sentry
-        sentry_sdk.init(
-            dsn=dsn,
-            release=f"shotgun-sh@{__version__}",
-            environment=environment,
-            send_default_pii=False,  # Privacy-first: never send PII
-            server_name="",  # Privacy: don't send hostname (may contain username)
-            traces_sample_rate=0.1 if environment == "production" else 1.0,
-            profiles_sample_rate=0.1 if environment == "production" else 1.0,
-            before_send=before_send,
-        )
-
-        # Set user context with anonymous shotgun instance ID from config
-        try:
-            import asyncio
-
-            from shotgun.agents.config import get_config_manager
-
-            config_manager = get_config_manager()
-            shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
-            sentry_sdk.set_user({"id": shotgun_instance_id})
-            logger.debug("Sentry user context set with anonymous ID")
-        except Exception as e:
-            logger.warning("Failed to set Sentry user context: %s", e)
-
-        logger.debug(
-            "Sentry observability configured successfully (environment: %s, version: %s)",
-            environment,
-            __version__,
-        )
-        return True
-
-    except ImportError as e:
-        logger.error("Sentry SDK not available: %s", e)
-        return False
-    except Exception as e:
-        logger.warning("Failed to setup Sentry observability: %s", e)
-        return False