shotgun-sh 0.1.0.dev18__tar.gz → 0.1.0.dev19__tar.gz

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.0.dev18
+Version: 0.1.0.dev19
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.0.dev18"
+version = "0.1.0.dev19"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/agents/agent_manager.py

@@ -34,6 +34,7 @@ from textual.widget import Widget
 
 from shotgun.agents.common import add_system_prompt_message
 
+from .export import create_export_agent
 from .history.compaction import apply_persistent_compaction
 from .models import AgentDeps, AgentRuntimeOptions, FileOperation
 from .plan import create_plan_agent
@@ -51,6 +52,7 @@ class AgentType(Enum):
     PLAN = "plan"
     TASKS = "tasks"
     SPECIFY = "specify"
+    EXPORT = "export"
 
 
 class MessageHistoryUpdated(Message):
@@ -138,6 +140,9 @@ class AgentManager(Widget):
         self.specify_agent, self.specify_deps = create_specify_agent(
             agent_runtime_options=agent_runtime_options
         )
+        self.export_agent, self.export_deps = create_export_agent(
+            agent_runtime_options=agent_runtime_options
+        )
 
         # Track current active agent
         self._current_agent_type: AgentType = initial_type
@@ -173,6 +178,7 @@ class AgentManager(Widget):
             AgentType.PLAN: self.plan_agent,
             AgentType.TASKS: self.tasks_agent,
             AgentType.SPECIFY: self.specify_agent,
+            AgentType.EXPORT: self.export_agent,
         }
         return agent_map[agent_type]
 
@@ -190,6 +196,7 @@ class AgentManager(Widget):
             AgentType.PLAN: self.plan_deps,
             AgentType.TASKS: self.tasks_deps,
             AgentType.SPECIFY: self.specify_deps,
+            AgentType.EXPORT: self.export_deps,
         }
         return deps_map[agent_type]
 

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/agents/common.py

@@ -160,6 +160,7 @@ def create_base_agent(
         deps_type=AgentDeps,
         instrument=True,
         history_processors=[history_processor],
+        retries=3,  # Default retry count for tool calls and output validation
     )
 
     # System prompt function is stored in deps and will be called manually in run_agent
@@ -176,9 +177,9 @@ def create_base_agent(
         logger.debug("📞 Interactive mode enabled - ask_user tool registered")
 
     # Register common file management tools (always available)
-    agent.tool(read_file)
     agent.tool(write_file)
     agent.tool(append_file)
+    agent.tool(read_file)
 
     # Register artifact management tools (always available)
     agent.tool(create_artifact)

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/agents/config/models.py

@@ -102,7 +102,7 @@ MODEL_SPECS: dict[str, ModelSpec] = {
         name="claude-3-5-sonnet-latest",
         provider=ProviderType.ANTHROPIC,
         max_input_tokens=200_000,
-        max_output_tokens=20_000,
+        max_output_tokens=8_192,
     ),
     "gemini-2.5-pro": ModelSpec(
         name="gemini-2.5-pro",

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/agents/config/provider.py

@@ -4,12 +4,13 @@ import os
 
 from pydantic import SecretStr
 from pydantic_ai.models import Model
-from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
 from pydantic_ai.models.google import GoogleModel
 from pydantic_ai.models.openai import OpenAIChatModel
 from pydantic_ai.providers.anthropic import AnthropicProvider
 from pydantic_ai.providers.google import GoogleProvider
 from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.settings import ModelSettings
 
 from shotgun.logging_config import get_logger
 
@@ -47,18 +48,47 @@ def get_or_create_model(provider: ProviderType, model_name: str, api_key: str) -
         logger.debug("Creating new %s model instance: %s", provider.value, model_name)
 
         if provider == ProviderType.OPENAI:
+            # Get max_tokens from MODEL_SPECS to use full capacity
+            if model_name in MODEL_SPECS:
+                max_tokens = MODEL_SPECS[model_name].max_output_tokens
+            else:
+                max_tokens = 16_000  # Default for GPT models
+
             openai_provider = OpenAIProvider(api_key=api_key)
             _model_cache[cache_key] = OpenAIChatModel(
-                model_name, provider=openai_provider
+                model_name,
+                provider=openai_provider,
+                settings=ModelSettings(max_tokens=max_tokens),
             )
         elif provider == ProviderType.ANTHROPIC:
+            # Get max_tokens from MODEL_SPECS to use full capacity
+            if model_name in MODEL_SPECS:
+                max_tokens = MODEL_SPECS[model_name].max_output_tokens
+            else:
+                max_tokens = 32_000  # Default for Claude models
+
             anthropic_provider = AnthropicProvider(api_key=api_key)
             _model_cache[cache_key] = AnthropicModel(
-                model_name, provider=anthropic_provider
+                model_name,
+                provider=anthropic_provider,
+                settings=AnthropicModelSettings(
+                    max_tokens=max_tokens,
+                    timeout=600,  # 10 minutes timeout for large responses
+                ),
             )
         elif provider == ProviderType.GOOGLE:
+            # Get max_tokens from MODEL_SPECS to use full capacity
+            if model_name in MODEL_SPECS:
+                max_tokens = MODEL_SPECS[model_name].max_output_tokens
+            else:
+                max_tokens = 64_000  # Default for Gemini models
+
             google_provider = GoogleProvider(api_key=api_key)
-            _model_cache[cache_key] = GoogleModel(model_name, provider=google_provider)
+            _model_cache[cache_key] = GoogleModel(
+                model_name,
+                provider=google_provider,
+                settings=ModelSettings(max_tokens=max_tokens),
+            )
         else:
             raise ValueError(f"Unsupported provider: {provider}")
     else:

shotgun_sh-0.1.0.dev19/src/shotgun/agents/export.py

@@ -0,0 +1,93 @@
+"""Export agent factory and functions using Pydantic AI with file-based memory."""
+
+from functools import partial
+
+from pydantic_ai import (
+    Agent,
+    DeferredToolRequests,
+)
+from pydantic_ai.agent import AgentRunResult
+from pydantic_ai.messages import ModelMessage
+
+from shotgun.agents.config import ProviderType
+from shotgun.logging_config import get_logger
+
+from .common import (
+    add_system_status_message,
+    build_agent_system_prompt,
+    create_base_agent,
+    create_usage_limits,
+    run_agent,
+)
+from .models import AgentDeps, AgentRuntimeOptions
+
+logger = get_logger(__name__)
+
+
+def create_export_agent(
+    agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
+) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
+    """Create an export agent with file management capabilities.
+
+    Args:
+        agent_runtime_options: Agent runtime options for the agent
+        provider: Optional provider override. If None, uses configured default
+
+    Returns:
+        Tuple of (Configured Pydantic AI agent for export management, Agent dependencies)
+    """
+    logger.debug("Initializing export agent")
+    # Use partial to create system prompt function for export agent
+    system_prompt_fn = partial(build_agent_system_prompt, "export")
+
+    agent, deps = create_base_agent(
+        system_prompt_fn, agent_runtime_options, provider=provider
+    )
+    return agent, deps
+
+
+async def run_export_agent(
+    agent: Agent[AgentDeps, str | DeferredToolRequests],
+    instruction: str,
+    deps: AgentDeps,
+    message_history: list[ModelMessage] | None = None,
+) -> AgentRunResult[str | DeferredToolRequests]:
+    """Export artifacts based on the given instruction.
+
+    Args:
+        agent: The configured export agent
+        instruction: The export instruction
+        deps: Agent dependencies
+        message_history: Optional message history for conversation continuity
+
+    Returns:
+        AgentRunResult containing the export process output
+    """
+    logger.debug("📤 Starting export for instruction: %s", instruction)
+
+    message_history = await add_system_status_message(deps, message_history)
+
+    # Let the agent use its tools to read existing artifacts and export them
+    full_prompt = f"Export artifacts or findings based on: {instruction}"
+
+    try:
+        # Create usage limits for responsible API usage
+        usage_limits = create_usage_limits()
+
+        result = await run_agent(
+            agent=agent,
+            prompt=full_prompt,
+            deps=deps,
+            message_history=message_history,
+            usage_limits=usage_limits,
+        )
+
+        logger.debug("✅ Export completed successfully")
+        return result
+
+    except Exception as e:
+        import traceback
+
+        logger.error("Full traceback:\n%s", traceback.format_exc())
+        logger.error("❌ Export failed: %s", str(e))
+        raise

shotgun_sh-0.1.0.dev19/src/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_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/main.py

@@ -7,7 +7,7 @@ from dotenv import load_dotenv
 
 from shotgun import __version__
 from shotgun.agents.config import get_config_manager
-from shotgun.cli import codebase, config, plan, research, specify, tasks, update
+from shotgun.cli import codebase, config, export, plan, research, specify, tasks, update
 from shotgun.logging_config import configure_root_logger, get_logger
 from shotgun.posthog_telemetry import setup_posthog_observability
 from shotgun.sentry_telemetry import setup_sentry_observability
@@ -66,6 +66,7 @@ app.add_typer(research.app, name="research", help="Perform research with agentic
 app.add_typer(plan.app, name="plan", help="Generate structured plans")
 app.add_typer(specify.app, name="specify", help="Generate comprehensive specifications")
 app.add_typer(tasks.app, name="tasks", help="Generate task lists with agentic approach")
+app.add_typer(export.app, name="export", help="Export artifacts to various formats")
 app.add_typer(update.app, name="update", help="Check for and install updates")
 
 

shotgun_sh-0.1.0.dev19/src/shotgun/prompts/agents/export.j2

@@ -0,0 +1,83 @@
+You are an experienced Export Specialist and Data Transformation Expert.
+
+Your job is to help export artifacts, research findings, plans, and other project data to various formats and destinations.
+
+{% include 'agents/partials/common_agent_system_prompt.j2' %}
+
+## EXPORT WORKFLOW
+
+For export tasks:
+1. **Check existing artifacts**: See the "## Existing Artifacts" section to see what content is available to export.
+2. **Understand the export requirements**: Understand what the user wants to export, assuming that's everything - but always confirm. For example some research might not be relevant for export. Priority: Tasks, Plan, Specify, Research.
+3. **Analyze export requirements**: Understand the requested format, destination, and scope
+4. **Read source content**: Read the content of all the relevant artifacts.
+5. **Transform and format**: Convert content to the requested format
+5. **Create export artifacts**: Use write_file with BOTH "filename" AND "content" parameters:
+6. **Validate output**: Ensure the export meets requirements and is properly formatted using read_file()
+
+## SUPPORTED EXPORT FORMATS
+
+- **AGENTS.md**: See below
+- **Markdown (.md)**: Nicely formatted Markdown file with everything the user wants to export
+
+### AGENTS.md
+
+Your task: generate an **AGENTS.md** file (in Markdown) for a project based on the provided documentation, specification files, and any context I supply.
+
+**Instructions / constraints**:
+- Use clear headings (e.g. “Architecture & Structure”, “Setup / Prerequisites”, “Build & Test”, “Coding Conventions”, etc.).
+- For sections with commands, wrap them in backticks so they can be executed directly.
+- Provide enough detail so that an AI coding agent can understand how to build, test, validate, deploy, and work with the project, without needing to hunt in scattered docs.
+- Link or refer to deeper docs (README, design docs) rather than duplicating large content.
+- If the project is a monorepo or modular, mention whether nested AGENTS.md may override parts.
+- Do **not** include large prose — focus on actionable instructions and bullet lists.
+- Assume the agent must obey programmatic checks listed in the file after generating code.
+
+
+## EXPORT PRINCIPLES
+
+- Preserve content structure and meaning during transformation
+- Include proper headers, metadata, and formatting for target format
+- Maintain links, references, and cross-references where applicable
+- Create self-contained exports that can be used independently
+- Add appropriate file extensions and format indicators
+- Include export timestamp and source information
+- Validate exported content is properly formatted and complete
+- Handle missing or incomplete source data gracefully
+- Consider target audience and use case for formatting decisions
+
+{% if interactive_mode %}
+USER INTERACTION - CLARIFY EXPORT REQUIREMENTS:
+
+- ALWAYS ask clarifying questions when export requirements are unclear
+- Use ask_user tool to gather specific details about:
+  - Target format and file type preferences
+  - Intended use case and audience for the export
+  - Specific content sections or artifacts to include/exclude
+  - Output structure and organization preferences
+  - Destination (where to save the file)
+- Ask follow-up questions to ensure exports meet exact needs
+- Confirm export scope and format before proceeding with large exports
+- Better to ask 2-3 targeted questions than create generic exports
+{% else %}
+NON-INTERACTIVE MODE - MAKE REASONABLE EXPORT DECISIONS:
+
+- Make reasonable assumptions about format based on content type
+- Use standard formats and conventions for the target format
+- Include comprehensive content unless scope is clearly limited
+- Apply sensible default formatting and structure
+- Export to commonly used and widely compatible formats
+- Include standard metadata and documentation
+{% endif %}
+
+IMPORTANT RULES:
+- Always verify source content exists before attempting export
+- Preserve all critical information during format conversion
+- Include source attribution and export metadata
+- Create well-structured, properly formatted output
+{% if interactive_mode %}
+- When export requirements are ambiguous, ASK before proceeding
+{% else %}
+- When requirements are unclear, use industry standard practices
+{% endif %}
+- Ensure exported content is self-contained and usable

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -7,16 +7,20 @@ Your extensive expertise spans, among other things:
 
 ## KEY RULES
 
-0. Above all, prefer using tools to do the work and NEVER respond with text.
-1. **Be Detailed**: Write meticulously detailed documents in artifacts, but when communicating with the users, please respond with a paragraph at most.
-2. **Be Helpful**: Always prioritize user needs and provide actionable assistance
-3. **Be Precise**: Provide specific, detailed responses rather than vague generalities
-4. **Be Collaborative**: Work effectively with other agents when needed
-5. **Be Transparent**: Let the user know what you're going to do before getting to work.
-6. **Be Efficient**: Avoid redundant work - check existing artifacts and agent outputs
-7. **Be Creative**: If the user seems not to know something, always be creative and come up with ideas that fit their thinking.
-8. Greet the user when you're just starting to work.
-9. DO NOT repeat yourself.
+{% if interactive_mode %}
+0. Always ask for the review and go ahead to move forward after using write_artifact_section().
+{% endif %}
+1. Above all, prefer using tools to do the work and NEVER respond with text.
+2. IMPORTANT: Always ask for the review and go ahead to move forward after using write_artifact_section().
+3. **Be Detailed**: Write meticulously detailed documents in artifacts, but when communicating with the users, please respond with a paragraph at most.
+4. **Be Helpful**: Always prioritize user needs and provide actionable assistance
+5. **Be Precise**: Provide specific, detailed responses rather than vague generalities
+6. **Be Collaborative**: Work effectively with other agents when needed
+7. **Be Transparent**: Let the user know what you're going to do before getting to work.
+8. **Be Efficient**: Avoid redundant work - check existing artifacts and agent outputs
+9. **Be Creative**: If the user seems not to know something, always be creative and come up with ideas that fit their thinking.
+10. Greet the user when you're just starting to work.
+11. DO NOT repeat yourself.
 
 
 ## Quality Standards

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/prompts/agents/partials/interactive_mode.j2

@@ -8,6 +8,7 @@ IMPORTANT: USER INTERACTION IS ENABLED (interactive mode).
 
 - BEFORE GETTING TO WORK, ALWAYS THINK WHAT YOU'RE GOING TO DO AND ask_user() TO ACCEPT WHAT YOU'RE GOING TO DO.
 - ALWAYS USE ask_user TO REVIEW AND ACCEPT THE ARTIFACT SECTION YOU'VE WORKED ON BEFORE PROCEEDING TO THE NEXT SECTION.
+- AFTER USING write_artifact_section(), ALWAYS USE ask_user() TO REVIEW AND ACCEPT THE ARTIFACT SECTION YOU'VE WORKED ON BEFORE PROCEEDING TO THE NEXT SECTION.
 - Don't assume - ask for confirmation of your understanding
 - When in doubt about any aspect of the goal, ASK before proceeding
 

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/tui/commands/__init__.py

@@ -62,8 +62,10 @@ class CommandHandler:
 
 **Agent Modes:**
 • **Research** - Research topics with web search and synthesize findings
+• **Specify** - Create detailed specifications and requirements documents
 • **Planning** - Create comprehensive, actionable plans with milestones
 • **Tasks** - Generate specific, actionable tasks from research and plans
+• **Export** - Export artifacts and findings to various formats
 
 **Usage:**
 Type your message and press Enter to chat with the AI. The AI will respond based on the current mode."""

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/tui/screens/chat.py

@@ -124,12 +124,14 @@ class ModeIndicator(Widget):
             AgentType.PLAN: "Planning",
             AgentType.TASKS: "Tasks",
             AgentType.SPECIFY: "Specify",
+            AgentType.EXPORT: "Export",
         }
         mode_description = {
             AgentType.RESEARCH: "Research topics with web search and synthesize findings",
             AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
             AgentType.TASKS: "Generate specific, actionable tasks from research and plans",
             AgentType.SPECIFY: "Create detailed specifications and requirements documents",
+            AgentType.EXPORT: "Export artifacts and findings to various formats",
         }
 
         mode_title = mode_display.get(self.mode, self.mode.value.title())
@@ -317,6 +319,9 @@ class ChatScreen(Screen[None]):
         AgentType.SPECIFY: (
             "Request detailed specifications, e.g. create a comprehensive spec for user authentication system"
         ),
+        AgentType.EXPORT: (
+            "Request export tasks, e.g. export research findings to Markdown or convert tasks to CSV"
+        ),
     }
 
     value = reactive("")
@@ -430,7 +435,13 @@ class ChatScreen(Screen[None]):
                 question_display.display = False
 
     def action_toggle_mode(self) -> None:
-        modes = [AgentType.RESEARCH, AgentType.SPECIFY, AgentType.PLAN, AgentType.TASKS]
+        modes = [
+            AgentType.RESEARCH,
+            AgentType.SPECIFY,
+            AgentType.PLAN,
+            AgentType.TASKS,
+            AgentType.EXPORT,
+        ]
         self.mode = modes[(modes.index(self.mode) + 1) % len(modes)]
         self.agent_manager.set_agent(self.mode)
         # whoops it actually changes focus. Let's be brutal for now

{shotgun_sh-0.1.0.dev18 → shotgun_sh-0.1.0.dev19}/src/shotgun/tui/screens/chat_screen/command_providers.py

@@ -30,6 +30,11 @@ class AgentModeProvider(Provider):
             lambda: self.set_mode(AgentType.RESEARCH),
             help="🔬 Research topics with web search and synthesize findings",
         )
+        yield DiscoveryHit(
+            "Switch to Specify Mode",
+            lambda: self.set_mode(AgentType.SPECIFY),
+            help="📝 Create detailed specifications and requirements documents",
+        )
         yield DiscoveryHit(
             "Switch to Plan Mode",
             lambda: self.set_mode(AgentType.PLAN),
@@ -40,6 +45,11 @@ class AgentModeProvider(Provider):
             lambda: self.set_mode(AgentType.TASKS),
             help="✅ Generate specific, actionable tasks from research and plans",
         )
+        yield DiscoveryHit(
+            "Switch to Export Mode",
+            lambda: self.set_mode(AgentType.EXPORT),
+            help="📤 Export artifacts and findings to various formats",
+        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         """Search for mode commands."""
@@ -70,6 +80,12 @@ class AgentModeProvider(Provider):
                 lambda: self.set_mode(AgentType.TASKS),
                 AgentType.TASKS,
             ),
+            (
+                "Switch to Export Mode",
+                "📤 Export artifacts and findings to various formats",
+                lambda: self.set_mode(AgentType.EXPORT),
+                AgentType.EXPORT,
+            ),
         ]
 
         for title, help_text, callback, mode in commands: