shotgun-sh 0.2.11.dev3__py3-none-any.whl → 0.2.19__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -58,7 +58,12 @@ from shotgun.agents.context_analyzer import (
     ContextCompositionTelemetry,
     ContextFormatter,
 )
-from shotgun.agents.models import AgentResponse, AgentType, FileOperation
+from shotgun.agents.models import (
+    AgentResponse,
+    AgentType,
+    FileOperation,
+    FileOperationTracker,
+)
 from shotgun.posthog_telemetry import track_event
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.utils.source_detection import detect_source
@@ -610,19 +615,30 @@ class AgentManager(Widget):
         self._stream_state = _PartialStreamState()
 
         model_name = ""
+        supports_streaming = True  # Default to streaming enabled
+
         if hasattr(deps, "llm_model") and deps.llm_model is not None:
             model_name = deps.llm_model.name
+            supports_streaming = deps.llm_model.supports_streaming
 
-        # Check if it's a Shotgun account
-        is_shotgun_account = (
-            hasattr(deps, "llm_model")
-            and deps.llm_model is not None
-            and deps.llm_model.key_provider == KeyProvider.SHOTGUN
-        )
-
-        # Only disable streaming for GPT-5 if NOT a Shotgun account
-        # Shotgun accounts support streaming for GPT-5
-        is_gpt5_byok = "gpt-5" in model_name.lower() and not is_shotgun_account
+            # Add hint message if streaming is disabled for BYOK GPT-5 models
+            if (
+                not supports_streaming
+                and deps.llm_model.key_provider == KeyProvider.BYOK
+            ):
+                self.ui_message_history.append(
+                    HintMessage(
+                        message=(
+                            "⚠️ **Streaming not available for GPT-5**\n\n"
+                            "Your OpenAI organization doesn't have streaming enabled for this model.\n\n"
+                            "**Options:**\n"
+                            "- Get a [Shotgun Account](https://shotgun.sh) - streaming works out of the box\n"
+                            "- Complete [Biometric Verification](https://platform.openai.com/settings/organization/billing/payment-methods) with OpenAI\n\n"
+                            "Continuing without streaming (responses will appear all at once)."
+                        )
+                    )
+                )
+                self._post_messages_updated()
 
         # Track message send event
         event_name = f"message_send_{self._current_agent_type.value}"
@@ -642,7 +658,7 @@ class AgentManager(Widget):
                 usage_limits=usage_limits,
                 message_history=message_history,
                 event_stream_handler=self._handle_event_stream
-                if not is_gpt5_byok
+                if supports_streaming
                 else None,
                 **kwargs,
             )
@@ -769,6 +785,12 @@ class AgentManager(Widget):
                     HintMessage(message=agent_response.response)
                 )
 
+            # Add file operation hints before questions (so they appear first in UI)
+            if file_operations:
+                file_hint = self._create_file_operation_hint(file_operations)
+                if file_hint:
+                    self.ui_message_history.append(HintMessage(message=file_hint))
+
             if len(agent_response.clarifying_questions) == 1:
                 # Single question - treat as non-blocking suggestion, DON'T enter Q&A mode
                 self.ui_message_history.append(
@@ -1134,6 +1156,38 @@ class AgentManager(Widget):
             )
         )
 
+    def _create_file_operation_hint(
+        self, file_operations: list[FileOperation]
+    ) -> str | None:
+        """Create a hint message for file operations.
+
+        Args:
+            file_operations: List of file operations to create a hint for
+
+        Returns:
+            Hint message string or None if no operations
+        """
+        if not file_operations:
+            return None
+
+        tracker = FileOperationTracker(operations=file_operations)
+        display_path = tracker.get_display_path()
+
+        if not display_path:
+            return None
+
+        path_obj = Path(display_path)
+
+        if len(file_operations) == 1:
+            return f"📝 Modified: `{display_path}`"
+        else:
+            num_files = len({op.file_path for op in file_operations})
+            if path_obj.is_dir():
+                return f"📁 Modified {num_files} files in: `{display_path}`"
+            else:
+                # Common path is a file, show parent directory
+                return f"📁 Modified {num_files} files in: `{path_obj.parent}`"
+
     def _post_messages_updated(
         self, file_operations: list[FileOperation] | None = None
     ) -> None:

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",

shotgun/agents/config/manager.py

@@ -1,7 +1,9 @@
 """Configuration manager for Shotgun CLI."""
 
 import json
+import shutil
 import uuid
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -30,9 +32,196 @@ from .models import (
 
 logger = get_logger(__name__)
 
+
+class ConfigMigrationError(Exception):
+    """Exception raised when config migration fails."""
+
+    def __init__(self, message: str, backup_path: Path | None = None):
+        """Initialize with error message and optional backup path.
+
+        Args:
+            message: Error message describing what went wrong
+            backup_path: Path to backup file if one was created
+        """
+        self.backup_path = backup_path
+        super().__init__(message)
+
+
 # Type alias for provider configuration objects
 ProviderConfig = OpenAIConfig | AnthropicConfig | GoogleConfig | ShotgunAccountConfig
 
+# Current config version
+CURRENT_CONFIG_VERSION = 5
+
+# Backup directory name
+BACKUP_DIR_NAME = "backup"
+
+
+def get_backup_dir(config_path: Path) -> Path:
+    """Get the backup directory path for a given config file.
+
+    Args:
+        config_path: Path to the config file
+
+    Returns:
+        Path to the backup directory (e.g., ~/.shotgun-sh/backup/)
+    """
+    return config_path.parent / BACKUP_DIR_NAME
+
+
+def _create_backup(config_path: Path) -> Path:
+    """Create a timestamped backup of the config file before migration.
+
+    Backups are saved to ~/.shotgun-sh/backup/ directory.
+
+    Args:
+        config_path: Path to the config file to backup
+
+    Returns:
+        Path to the backup file in the backup directory
+
+    Raises:
+        OSError: If backup creation fails
+    """
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_dir = get_backup_dir(config_path)
+    backup_path = backup_dir / f"config.backup.{timestamp}.json"
+
+    try:
+        # Create backup directory if it doesn't exist
+        backup_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(config_path, backup_path)
+        logger.info(f"Created config backup at {backup_path}")
+        return backup_path
+    except Exception as e:
+        logger.error(f"Failed to create config backup: {e}")
+        raise OSError(f"Failed to create config backup: {e}") from e
+
+
+def _migrate_v2_to_v3(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config from version 2 to version 3.
+
+    Changes:
+    - Rename 'user_id' field to 'shotgun_instance_id'
+
+    Args:
+        data: Config data dict at version 2
+
+    Returns:
+        Modified config data dict at version 3
+    """
+    if "user_id" in data and SHOTGUN_INSTANCE_ID_FIELD not in data:
+        data[SHOTGUN_INSTANCE_ID_FIELD] = data.pop("user_id")
+        data["config_version"] = 3
+        logger.info("Migrated config v2->v3: renamed user_id to shotgun_instance_id")
+
+    return data
+
+
+def _migrate_v3_to_v4(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config from version 3 to version 4.
+
+    Changes:
+    - Add 'marketing' field with empty messages dict
+    - Set 'shown_welcome_screen' to False for existing BYOK users
+
+    Args:
+        data: Config data dict at version 3
+
+    Returns:
+        Modified config data dict at version 4
+    """
+    # Add marketing config
+    if "marketing" not in data:
+        data["marketing"] = {"messages": {}}
+        logger.info("Migrated config v3->v4: added marketing configuration")
+
+    # Set shown_welcome_screen for existing BYOK users
+    # If shown_welcome_screen doesn't exist AND any BYOK provider has a key,
+    # set it to False so they see the welcome screen once
+    if "shown_welcome_screen" not in data:
+        has_byok_key = False
+        for section in ["openai", "anthropic", "google"]:
+            if (
+                section in data
+                and isinstance(data[section], dict)
+                and data[section].get("api_key")
+            ):
+                has_byok_key = True
+                break
+
+        if has_byok_key:
+            data["shown_welcome_screen"] = False
+            logger.info(
+                "Existing BYOK user detected: set shown_welcome_screen=False to show welcome screen"
+            )
+
+    data["config_version"] = 4
+    return data
+
+
+def _migrate_v4_to_v5(data: dict[str, Any]) -> dict[str, Any]:
+    """Migrate config from version 4 to version 5.
+
+    Changes:
+    - Add 'supports_streaming' field to OpenAI config (initially None for auto-detection)
+
+    Args:
+        data: Config data dict at version 4
+
+    Returns:
+        Modified config data dict at version 5
+    """
+    if "openai" in data and isinstance(data["openai"], dict):
+        if "supports_streaming" not in data["openai"]:
+            data["openai"]["supports_streaming"] = None
+            logger.info(
+                "Migrated config v4->v5: added streaming capability detection for OpenAI"
+            )
+
+    data["config_version"] = 5
+    return data
+
+
+def _apply_migrations(data: dict[str, Any]) -> dict[str, Any]:
+    """Apply all necessary migrations to bring config to current version.
+
+    Migrations are applied sequentially from the config's current version
+    to CURRENT_CONFIG_VERSION.
+
+    Args:
+        data: Config data dict at any version
+
+    Returns:
+        Config data dict at CURRENT_CONFIG_VERSION
+    """
+    # Get current version (default to 2 for very old configs)
+    current_version = data.get("config_version", 2)
+
+    # Define migrations in order
+    migrations = {
+        2: _migrate_v2_to_v3,
+        3: _migrate_v3_to_v4,
+        4: _migrate_v4_to_v5,
+    }
+
+    # Apply migrations sequentially
+    while current_version < CURRENT_CONFIG_VERSION:
+        if current_version in migrations:
+            logger.info(
+                f"Applying migration from v{current_version} to v{current_version + 1}"
+            )
+            data = migrations[current_version](data)
+            current_version = data.get("config_version", current_version + 1)
+        else:
+            logger.warning(
+                f"No migration defined for v{current_version}, skipping to v{current_version + 1}"
+            )
+            current_version += 1
+            data["config_version"] = current_version
+
+    return data
+
 
 class ConfigManager:
     """Manager for Shotgun configuration."""
@@ -71,44 +260,49 @@ class ConfigManager:
             self._config = await self.initialize()
             return self._config
 
+        backup_path: Path | None = None
         try:
             async with aiofiles.open(self.config_path, encoding="utf-8") as f:
                 content = await f.read()
                 data = json.loads(content)
 
-            # Migration: Rename user_id to shotgun_instance_id (config v2 -> v3)
-            if "user_id" in data and SHOTGUN_INSTANCE_ID_FIELD not in data:
-                data[SHOTGUN_INSTANCE_ID_FIELD] = data.pop("user_id")
-                data["config_version"] = 3
+            # Get current version to determine if migration is needed
+            current_version = data.get("config_version", 2)
+
+            # Create backup before migration if config needs upgrading
+            if current_version < CURRENT_CONFIG_VERSION:
                 logger.info(
-                    "Migrated config v2->v3: renamed user_id to shotgun_instance_id"
+                    f"Config needs migration from v{current_version} to v{CURRENT_CONFIG_VERSION}"
                 )
-
-            # Migration: Set shown_welcome_screen for existing BYOK users
-            # If shown_welcome_screen doesn't exist AND any BYOK provider has a key,
-            # set it to False so they see the welcome screen once
-            if "shown_welcome_screen" not in data:
-                has_byok_key = False
-                for section in ["openai", "anthropic", "google"]:
-                    if (
-                        section in data
-                        and isinstance(data[section], dict)
-                        and data[section].get("api_key")
-                    ):
-                        has_byok_key = True
-                        break
-
-                if has_byok_key:
-                    data["shown_welcome_screen"] = False
-                    logger.info(
-                        "Existing BYOK user detected: set shown_welcome_screen=False to show welcome screen"
+                try:
+                    backup_path = _create_backup(self.config_path)
+                except OSError as backup_error:
+                    logger.warning(
+                        f"Could not create backup before migration: {backup_error}"
                     )
+                    # Continue without backup - better than failing completely
+
+            # Apply all necessary migrations to bring config to current version
+            try:
+                data = _apply_migrations(data)
+            except Exception as migration_error:
+                error_msg = (
+                    f"Failed to migrate configuration from v{current_version} to v{CURRENT_CONFIG_VERSION}. "
+                    f"Error: {migration_error}"
+                )
+                if backup_path:
+                    error_msg += f"\n\nYour original config has been backed up to:\n{backup_path}"
+                    error_msg += (
+                        "\n\nTo start fresh, delete or rename your config file:\n"
+                        f"  rm {self.config_path}\n"
+                        f"  shotgun config init\n\n"
+                        "To restore your backup:\n"
+                        f"  cp {backup_path} {self.config_path}"
+                    )
+                else:
+                    error_msg += "\n\nTo start fresh, run: shotgun config init"
 
-            # Migration: Add marketing config for v3 -> v4
-            if "marketing" not in data:
-                data["marketing"] = {"messages": {}}
-                data["config_version"] = 4
-                logger.info("Migrated config v3->v4: added marketing configuration")
+                raise ConfigMigrationError(error_msg, backup_path) from migration_error
 
             # Convert plain text secrets to SecretStr objects
             self._convert_secrets_to_secretstr(data)
@@ -169,12 +363,56 @@ class ConfigManager:
 
             return self._config
 
-        except Exception as e:
+        except ConfigMigrationError as migration_error:
+            # Migration failed - automatically create fresh config with migration info
             logger.error(
-                "Failed to load configuration from %s: %s", self.config_path, e
+                "Config migration failed, creating fresh config: %s", migration_error
             )
-            logger.info("Creating new configuration with generated shotgun_instance_id")
+            backup_path = migration_error.backup_path
+
+            # Create fresh config with migration failure info
+            self._config = await self.initialize()
+            self._config.migration_failed = True
+            if backup_path:
+                self._config.migration_backup_path = str(backup_path)
+
+            # Save the fresh config
+            await self.save(self._config)
+            logger.info("Created fresh config after migration failure")
+
+            return self._config
+
+        except json.JSONDecodeError as json_error:
+            # Invalid JSON - create backup and fresh config
+            logger.error("Config file has invalid JSON: %s", json_error)
+
+            try:
+                backup_path = _create_backup(self.config_path)
+            except OSError:
+                backup_path = None
+
+            self._config = await self.initialize()
+            self._config.migration_failed = True
+            if backup_path:
+                self._config.migration_backup_path = str(backup_path)
+
+            await self.save(self._config)
+            logger.info("Created fresh config after JSON parse error")
+
+            return self._config
+
+        except Exception as e:
+            # Generic error - create fresh config
+            logger.error("Failed to load config: %s", e)
+
             self._config = await self.initialize()
+            self._config.migration_failed = True
+            if backup_path:
+                self._config.migration_backup_path = str(backup_path)
+
+            await self.save(self._config)
+            logger.info("Created fresh config after load error")
+
             return self._config
 
     async def save(self, config: ShotgunConfig | None = None) -> None:
@@ -237,6 +475,11 @@ class ConfigManager:
                 SecretStr(api_key_value) if api_key_value is not None else None
             )
 
+            # Reset streaming capabilities when OpenAI API key is changed
+            if not is_shotgun and provider_enum == ProviderType.OPENAI:
+                if isinstance(provider_config, OpenAIConfig):
+                    provider_config.supports_streaming = None
+
         # Reject other fields
         unsupported_fields = set(kwargs.keys()) - {API_KEY_FIELD}
         if unsupported_fields:
@@ -266,6 +509,11 @@ class ConfigManager:
             # This prevents the welcome screen from showing again after user has made their choice
             config.shown_welcome_screen = True
 
+        # Clear migration failure flag when user successfully configures a provider
+        if API_KEY_FIELD in kwargs and api_key_value is not None:
+            config.migration_failed = False
+            config.migration_backup_path = None
+
         await self.save(config)
 
     async def clear_provider_key(self, provider: ProviderType | str) -> None:
@@ -283,6 +531,13 @@ class ConfigManager:
         if is_shotgun and isinstance(provider_config, ShotgunAccountConfig):
             provider_config.supabase_jwt = None
 
+        # Reset streaming capabilities when OpenAI API key is cleared
+        if not is_shotgun:
+            provider_enum = self._ensure_provider_enum(provider)
+            if provider_enum == ProviderType.OPENAI:
+                if isinstance(provider_config, OpenAIConfig):
+                    provider_config.supports_streaming = None
+
         await self.save(config)
 
     async def update_selected_model(self, model_name: "ModelName") -> None:

shotgun/agents/config/models.py

@@ -56,6 +56,10 @@ class ModelConfig(BaseModel):
     max_input_tokens: int
     max_output_tokens: int
     api_key: str
+    supports_streaming: bool = Field(
+        default=True,
+        description="Whether this model configuration supports streaming. False only for BYOK GPT-5 models without streaming enabled.",
+    )
     _model_instance: Model | None = PrivateAttr(default=None)
 
     class Config:
@@ -148,6 +152,10 @@ class OpenAIConfig(BaseModel):
     """Configuration for OpenAI provider."""
 
     api_key: SecretStr | None = None
+    supports_streaming: bool | None = Field(
+        default=None,
+        description="Whether streaming is supported for this API key. None = not tested yet",
+    )
 
 
 class AnthropicConfig(BaseModel):
@@ -200,12 +208,24 @@ class ShotgunConfig(BaseModel):
     shotgun_instance_id: str = Field(
         description="Unique shotgun instance identifier (also used for anonymous telemetry)",
     )
-    config_version: int = Field(default=4, description="Configuration schema version")
+    config_version: int = Field(default=5, description="Configuration schema version")
     shown_welcome_screen: bool = Field(
         default=False,
         description="Whether the welcome screen has been shown to the user",
     )
+    shown_onboarding_popup: datetime | None = Field(
+        default=None,
+        description="Timestamp when the onboarding popup was shown to the user (ISO8601 format)",
+    )
     marketing: MarketingConfig = Field(
         default_factory=MarketingConfig,
         description="Marketing messages configuration and tracking",
     )
+    migration_failed: bool = Field(
+        default=False,
+        description="Whether the last config migration failed (cleared after user configures a provider)",
+    )
+    migration_backup_path: str | None = Field(
+        default=None,
+        description="Path to the backup file created when migration failed",
+    )