shotgun-sh 0.2.17__py3-none-any.whl → 0.4.0.dev1__py3-none-any.whl

shotgun/agents/common.py

@@ -1,6 +1,6 @@
 """Common utilities for agent creation and management."""
 
-from collections.abc import Callable
+from collections.abc import AsyncIterable, Awaitable, Callable
 from pathlib import Path
 from typing import Any
 
@@ -17,7 +17,12 @@ from pydantic_ai.messages import (
 )
 
 from shotgun.agents.config import ProviderType, get_provider_model
-from shotgun.agents.models import AgentResponse, AgentType
+from shotgun.agents.models import (
+    AgentResponse,
+    AgentSystemPromptContext,
+    AgentType,
+    ShotgunAgent,
+)
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
 from shotgun.sdk.services import get_codebase_service
@@ -25,7 +30,7 @@ from shotgun.utils import ensure_shotgun_directory_exists
 from shotgun.utils.datetime_utils import get_datetime_context
 from shotgun.utils.file_system_utils import get_shotgun_base_path
 
-from .history import token_limit_compactor
+from .conversation.history import token_limit_compactor
 from .messages import AgentSystemPrompt, SystemStatusPrompt
 from .models import AgentDeps, AgentRuntimeOptions, PipelineConfigEntry
 from .tools import (
@@ -38,7 +43,6 @@ from .tools import (
     retrieve_code,
     write_file,
 )
-from .tools.file_management import AGENT_DIRECTORIES
 
 logger = get_logger(__name__)
 
@@ -74,6 +78,19 @@ async def add_system_status_message(
     # Get current datetime with timezone information
     dt_context = get_datetime_context()
 
+    # Get execution plan and pending approval state if this is the Router agent
+    execution_plan = None
+    pending_approval = False
+    if deps.agent_mode == AgentType.ROUTER:
+        # Import here to avoid circular imports
+        from shotgun.agents.router.models import RouterDeps
+
+        if isinstance(deps, RouterDeps):
+            if deps.current_plan is not None:
+                execution_plan = deps.current_plan.format_for_display()
+            # Check if plan is pending approval (multi-step plan in Planning mode)
+            pending_approval = deps.pending_approval is not None
+
     system_state = prompt_loader.render(
         "agents/state/system_state.j2",
         codebase_understanding_graphs=codebase_understanding_graphs,
@@ -83,6 +100,8 @@ async def add_system_status_message(
         current_datetime=dt_context.datetime_formatted,
         timezone_name=dt_context.timezone_name,
         utc_offset=dt_context.utc_offset,
+        execution_plan=execution_plan,
+        pending_approval=pending_approval,
     )
 
     message_history.append(
@@ -102,7 +121,7 @@ async def create_base_agent(
     additional_tools: list[Any] | None = None,
     provider: ProviderType | None = None,
     agent_mode: AgentType | None = None,
-) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
+) -> tuple[ShotgunAgent, AgentDeps]:
     """Create a base agent with common configuration.
 
     Args:
@@ -352,86 +371,33 @@ async def extract_markdown_toc(agent_mode: AgentType | None) -> str | None:
 
 
 def get_agent_existing_files(agent_mode: AgentType | None = None) -> list[str]:
-    """Get list of existing files for the given agent mode.
+    """Get list of all existing files in .shotgun directory.
+
+    All agents can read any file in .shotgun/, so we list all files regardless
+    of agent mode. This includes user-added files that agents should be aware of.
 
     Args:
-        agent_mode: The agent mode to check files for. If None, lists all files.
+        agent_mode: Unused, kept for backwards compatibility.
 
     Returns:
         List of existing file paths relative to .shotgun directory
     """
     base_path = get_shotgun_base_path()
-    existing_files = []
-
-    # If no agent mode, list all files in base path and first level subdirectories
-    if agent_mode is None:
-        # List files in the root .shotgun directory
-        for item in base_path.iterdir():
-            if item.is_file():
-                existing_files.append(item.name)
-            elif item.is_dir():
-                # List files in first-level subdirectories
-                for subitem in item.iterdir():
-                    if subitem.is_file():
-                        relative_path = subitem.relative_to(base_path)
-                        existing_files.append(str(relative_path))
+    existing_files: list[str] = []
+
+    if not base_path.exists():
         return existing_files
 
-    # Handle specific agent modes
-    if agent_mode not in AGENT_DIRECTORIES:
-        return []
-
-    if agent_mode == AgentType.EXPORT:
-        # For export agent, list all files in exports directory
-        exports_dir = base_path / "exports"
-        if exports_dir.exists():
-            for file_path in exports_dir.rglob("*"):
-                if file_path.is_file():
-                    relative_path = file_path.relative_to(base_path)
+    # List all files in .shotgun directory and subdirectories
+    for item in base_path.iterdir():
+        if item.is_file():
+            existing_files.append(item.name)
+        elif item.is_dir():
+            # List files in subdirectories (one level deep to avoid too much noise)
+            for subitem in item.iterdir():
+                if subitem.is_file():
+                    relative_path = subitem.relative_to(base_path)
                     existing_files.append(str(relative_path))
-    else:
-        # For other agents, check files/directories they have access to
-        allowed_paths_raw = AGENT_DIRECTORIES[agent_mode]
-
-        # Convert single Path/string to list of Paths for uniform handling
-        if isinstance(allowed_paths_raw, str):
-            # Special case: "*" means export agent (shouldn't reach here but handle it)
-            allowed_paths = (
-                [Path(allowed_paths_raw)] if allowed_paths_raw != "*" else []
-            )
-        elif isinstance(allowed_paths_raw, Path):
-            allowed_paths = [allowed_paths_raw]
-        else:
-            # Already a list
-            allowed_paths = allowed_paths_raw
-
-        # Check each allowed path
-        for allowed_path in allowed_paths:
-            allowed_str = str(allowed_path)
-
-            # Check if it's a directory (no .md suffix)
-            if not allowed_path.suffix or not allowed_str.endswith(".md"):
-                # It's a directory - list all files within it
-                dir_path = base_path / allowed_str
-                if dir_path.exists() and dir_path.is_dir():
-                    for file_path in dir_path.rglob("*"):
-                        if file_path.is_file():
-                            relative_path = file_path.relative_to(base_path)
-                            existing_files.append(str(relative_path))
-            else:
-                # It's a file - check if it exists
-                file_path = base_path / allowed_str
-                if file_path.exists():
-                    existing_files.append(allowed_str)
-
-                # Also check for associated directory (e.g., research/ for research.md)
-                base_name = allowed_str.replace(".md", "")
-                dir_path = base_path / base_name
-                if dir_path.exists() and dir_path.is_dir():
-                    for file_path in dir_path.rglob("*"):
-                        if file_path.is_file():
-                            relative_path = file_path.relative_to(base_path)
-                            existing_files.append(str(relative_path))
 
     return existing_files
 
@@ -458,10 +424,24 @@ def build_agent_system_prompt(
         logger.debug("🔧 Building research agent system prompt...")
         logger.debug("Interactive mode: %s", ctx.deps.interactive_mode)
 
-    result = prompt_loader.render(
-        f"agents/{agent_type}.j2",
+    # Build template context using Pydantic model for type safety and testability
+    # Import here to avoid circular imports (same pattern as add_system_status_message)
+    from shotgun.agents.router.models import RouterDeps
+
+    router_mode = None
+    if isinstance(ctx.deps, RouterDeps):
+        router_mode = ctx.deps.router_mode.value
+
+    template_context = AgentSystemPromptContext(
         interactive_mode=ctx.deps.interactive_mode,
         mode=agent_type,
+        sub_agent_context=ctx.deps.sub_agent_context,
+        router_mode=router_mode,
+    )
+
+    result = prompt_loader.render(
+        f"agents/{agent_type}.j2",
+        **template_context.model_dump(),
     )
 
     if agent_type == "research":
@@ -525,13 +505,33 @@ async def add_system_prompt_message(
     return message_history
 
 
+EventStreamHandler = Callable[
+    [RunContext[AgentDeps], AsyncIterable[Any]], Awaitable[None]
+]
+
+
 async def run_agent(
-    agent: Agent[AgentDeps, AgentResponse],
+    agent: ShotgunAgent,
     prompt: str,
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
     usage_limits: UsageLimits | None = None,
+    event_stream_handler: EventStreamHandler | None = None,
 ) -> AgentRunResult[AgentResponse]:
+    """Run an agent with optional streaming support.
+
+    Args:
+        agent: The agent to run.
+        prompt: The prompt to send to the agent.
+        deps: Agent dependencies.
+        message_history: Optional message history to continue from.
+        usage_limits: Optional usage limits for the run.
+        event_stream_handler: Optional callback for streaming events.
+            When provided, enables real-time streaming of agent responses.
+
+    Returns:
+        The agent run result.
+    """
     # Clear file tracker for new run
     deps.file_tracker.clear()
     logger.debug("🔧 Cleared file tracker for new agent run")
@@ -544,6 +544,7 @@ async def run_agent(
         deps=deps,
         usage_limits=usage_limits,
         message_history=message_history,
+        event_stream_handler=event_stream_handler,
     )
 
     # Log file operations summary if any files were modified

shotgun/agents/config/README.md

@@ -0,0 +1,89 @@
+# Configuration Management
+
+This directory contains the configuration management system for Shotgun, including models, migrations, and provider integration.
+
+## Config Version History
+
+### Version 1 (Config Versioning Introduced)
+
+- **Commit**: `f36defc` (Sep 19, 2025)
+- **Title**: "feat: add Sentry error tracking with anonymous user identification"
+- **Key Fields**: `user_id`, `config_version: 1`
+- **Note**: First version to include explicit versioning
+
+### Version 2 (Shotgun Account Provider)
+
+- **Commit**: `37a5add` (Oct 3, 2025)
+- **Title**: "feat: add Shotgun Account provider with LiteLLM proxy support"
+- **Key Fields**: `user_id`, `config_version: 2`, added `shotgun` provider config
+- **Note**: Configs without a version field default to v2 during migration
+
+### Version 3 (OAuth Authentication)
+
+- **Commit**: `39d2af9` (Oct 6, 2025)
+- **Title**: "feat: implement OAuth-style authentication flow for Shotgun Account"
+- **Key Changes**:
+  - Renamed `user_id` → `shotgun_instance_id`
+  - Added `supabase_jwt` field to Shotgun Account config
+- **Git Tags**: Both `0.2.11.dev1` and `0.2.11.dev2` are at this version
+
+### Version 4 (Marketing Messages)
+
+- **Commit**: `8638a6d` (Nov 4, 2025)
+- **Title**: "feat: add marketing message system for GitHub star promotion"
+- **Key Changes**:
+  - Added `marketing` configuration with message tracking
+  - Added `shown_welcome_screen` field (set to `False` for existing BYOK users)
+
+### Version 5 (Streaming Detection) - CURRENT
+
+- **Commit**: `fded351` (Nov 6, 2025)
+- **Title**: "feat: add config migration for streaming capability field (v4->v5)"
+- **Key Changes**:
+  - Added `supports_streaming` field to OpenAI config
+  - Added `shown_onboarding_popup` timestamp field
+  - Added `supabase_jwt` to Shotgun Account config
+
+## Migration System
+
+The migration system is designed to be sequential and idempotent. Migrations are defined in `manager.py`:
+
+- `_migrate_v2_to_v3()`: Renames `user_id` to `shotgun_instance_id`
+- `_migrate_v3_to_v4()`: Adds marketing config and welcome screen flag
+- `_migrate_v4_to_v5()`: Adds streaming support fields
+
+All migrations preserve user data (API keys, settings) and can be safely run multiple times.
+
+## Adding a New Config Version
+
+When adding a new config version:
+
+1. **Update `models.py`**:
+   - Increment `CURRENT_CONFIG_VERSION` constant
+   - Add new fields to appropriate config models
+
+2. **Create migration function in `manager.py`**:
+   ```python
+   def _migrate_vN_to_vN+1(data: dict[str, Any]) -> dict[str, Any]:
+       """Migrate config from version N to N+1."""
+       data["config_version"] = N + 1
+       # Add migration logic
+       return data
+   ```
+
+3. **Register migration**:
+   - Add to `migrations` dict in `_apply_migrations()`
+
+4. **Add tests in `test/unit/test_config_migrations.py`**:
+   - Create example config for version N
+   - Test individual migration function
+   - Test sequential migration from version N to current
+   - Test with populated configs (non-empty API keys, etc.)
+   - Test edge cases
+
+## Files
+
+- **`models.py`**: Pydantic models for configuration schema
+- **`manager.py`**: ConfigManager class and migration functions
+- **`provider.py`**: LLM provider integration and model creation
+- **`streaming_test.py`**: OpenAI streaming capability detection

shotgun/agents/config/__init__.py

@@ -1,11 +1,20 @@
 """Configuration module for Shotgun CLI."""
 
-from .manager import ConfigManager, get_config_manager
+from .manager import (
+    BACKUP_DIR_NAME,
+    ConfigManager,
+    ConfigMigrationError,
+    get_backup_dir,
+    get_config_manager,
+)
 from .models import ProviderType, ShotgunConfig
 from .provider import get_provider_model
 
 __all__ = [
+    "BACKUP_DIR_NAME",
     "ConfigManager",
+    "ConfigMigrationError",
+    "get_backup_dir",
     "get_config_manager",
     "ProviderType",
     "ShotgunConfig",