shotgun-sh 0.2.29.dev2__py3-none-any.whl → 0.6.1.dev1__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())