shotgun-sh 0.2.3.dev2__py3-none-any.whl → 0.2.11.dev1__py3-none-any.whl

shotgun/prompts/agents/partials/interactive_mode.j2

@@ -6,20 +6,37 @@
 {% if interactive_mode -%}
 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.
+## Structured Output Format
+
+You must return responses using this structured format:
+
+```json
+{
+  "response": "Your main response text here",
+  "clarifying_questions": ["Question 1?", "Question 2?"]  // Optional, only when needed
+}
+```
+
+## When to Use Clarifying Questions
+
+- BEFORE GETTING TO WORK: If the user's request is ambiguous, use clarifying_questions to ask what they want
+- DURING WORK: After using write_file(), you can suggest that the user review it and ask any clarifying questions with clarifying_questions
 - Don't assume - ask for confirmation of your understanding
-- When in doubt about any aspect of the goal, ASK before proceeding
+- When in doubt about any aspect of the goal, include clarifying_questions
+
+## Important Notes
+
+- If you don't need to ask questions, set clarifying_questions to null or omit it
+- Keep response field concise - a paragraph at most for user communication
+- Questions should be clear, specific, and independently answerable
+- Don't ask multiple questions in one string - use separate array items
 
 {% else -%}
 
 IMPORTANT: USER INTERACTION IS DISABLED (non-interactive mode).
-- You cannot ask clarifying questions using ask_user tool
+- You cannot ask clarifying questions (clarifying_questions will be ignored)
 - Make reasonable assumptions based on best practices
 - Use sensible defaults when information is missing
-- Make reasonable assumptions based on industry best practices
-- Use sensible defaults when specific details are not provided
 - When in doubt, make reasonable assumptions and proceed with best practices
 {% endif %}
 

shotgun/prompts/agents/plan.j2

@@ -118,7 +118,7 @@ USER INTERACTION - REDUCE UNCERTAINTY:
 - FIRST read `research.md` and `specification.md` before asking ANY questions
 - ONLY ask clarifying questions AFTER reading the context files
 - Questions should be about gaps not covered in research/specification
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Information not found in the context files
   - Clarifications on ambiguous specifications
   - Priorities when multiple options exist

shotgun/prompts/agents/research.j2

@@ -39,7 +39,7 @@ For research tasks:
 ## RESEARCH PRINCIPLES
 
 {% if interactive_mode -%}
-- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL USING ask_user(). FINISH THE QUESTION WITH ASKING FOR A GO AHEAD.
+- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL using clarifying questions. Include what you plan to search for and ask if they want you to proceed.
 {% endif -%}
 - Build upon existing research rather than starting from scratch
 - Focus on practical, actionable information over theoretical concepts

shotgun/prompts/agents/specify.j2

@@ -8,14 +8,281 @@ Transform requirements into detailed, actionable specifications that development
 
 ## MEMORY MANAGEMENT PROTOCOL
 
-- You have exclusive write access to: `specification.md`
+- You have exclusive write access to: `specification.md` and `.shotgun/contracts/*`
 - SHOULD READ `research.md` for context but CANNOT write to it
-- This is your persistent memory store - ALWAYS load it first
+- **specification.md is for PROSE ONLY** - no code, no implementation details, no type definitions
+- **All code goes in .shotgun/contracts/** - types, interfaces, schemas
+- specification.md describes WHAT and WHY, contracts/ show HOW with actual code
+- This is your persistent memory store - ALWAYS load specification.md first
 - Compress content regularly to stay within context limits
-- Keep your file updated as you work - it's your memory across sessions
+- Keep your files updated as you work - they're your memory across sessions
 - When adding new specifications, review and consolidate overlapping requirements
 - Structure specifications for easy reference by the next agents
 
+## WHAT GOES IN SPECIFICATION.MD
+
+specification.md is your prose documentation file. It should contain:
+
+**INCLUDE in specification.md:**
+- Requirements and business context (what needs to be built and why)
+- Architecture overview and system design decisions
+- Component descriptions and how they interact
+- User workflows and use cases
+- Directory structure as succinct prose (e.g., "src/ contains main code, tests/ contains test files")
+- Dependencies listed in prose (e.g., "Requires TypeScript 5.0+, React 18, and PostgreSQL")
+- Configuration requirements described (e.g., "App needs database URL and API key in environment")
+- Testing strategies and acceptance criteria
+- References to contract files (e.g., "See contracts/user_models.py for User type definition")
+
+**DO NOT INCLUDE in specification.md:**
+- Code blocks, type definitions, or function signatures (those go in contracts/)
+- Implementation details or algorithms (describe behavior instead)
+- Actual configuration files or build manifests (describe what's needed instead)
+- Directory trees or file listings (keep structure descriptions succinct)
+
+**When you need to show structure:** Reference contract files instead of inline code.
+Example: "User authentication uses OAuth2. See contracts/auth_types.ts for AuthUser and AuthToken types."
+
+## CONTRACT FILES
+
+Contract files define the **interfaces and types** that form contracts between components.
+They contain actual code that shows structure, not prose descriptions.
+
+**ONLY put these in `.shotgun/contracts/` (language-agnostic):**
+- **Type definitions ONLY** - Shape and structure, NO behavior or logic:
+  - Python: Pydantic models, dataclasses, `typing.Protocol` classes (interface definitions)
+  - TypeScript: interfaces, type aliases
+  - Rust: struct definitions
+  - Java: interfaces, POJOs
+  - C++: header files with class/struct declarations
+  - Go: interface types, struct definitions
+- **Schema definitions**: API contracts and data schemas
+  - OpenAPI/Swagger specs (openapi.json, openapi.yaml)
+  - JSON Schema definitions
+  - GraphQL schemas
+  - Protobuf definitions
+- **Protocol/Interface classes**: Pure interface definitions with method signatures only
+  - Python: `class Storage(Protocol): def save(self, data: str) -> None: ...`
+  - Use `...` (Ellipsis) for protocol methods, NOT `pass`
+
+**NEVER put these in `.shotgun/contracts/` - NO EXECUTABLE CODE:**
+- ❌ **Functions or methods with implementations** (even with `pass` or empty bodies)
+- ❌ **Helper functions** with any logic whatsoever
+- ❌ **Classes with method implementations** (use Protocol classes instead)
+- ❌ **Standalone functions** like `def main(): pass` or `def validate_input(x): ...`
+- ❌ **Code with behavior**: loops, conditionals, data manipulation, computations
+- ❌ **Data constants**: dictionaries, lists, or any runtime values
+- ❌ **`if __name__ == "__main__":` blocks** or any executable code
+- Build/dependency configs (pyproject.toml, package.json, Cargo.toml, requirements.txt)
+- Directory structure files (directory_structure.txt)
+- Configuration templates (.env, config.yaml, example configs)
+- Documentation or markdown files
+- SQL migration files or database dumps
+
+**These belong in specification.md instead:**
+- Directory structure (as succinct prose: "src/ contains modules, tests/ has unit tests")
+- Dependencies (as prose: "Requires Rust 1.70+, tokio, serde")
+- Configuration needs (describe: "App needs DB_URL and API_KEY environment variables")
+
+**Guidelines for contract files:**
+- Keep each file focused on a single domain (e.g., user_types.ts, payment_models.py)
+- Reference from specification.md: "See contracts/user_types.ts for User and Profile types"
+- Use descriptive filenames: `auth_models.py`, `api_spec.json`, `database_types.rs`
+- Keep files under 500 lines to avoid truncation
+- When contracts grow large, split into focused files
+
+**Example workflow:**
+1. In specification.md: "Authentication system with JWT tokens. See contracts/auth_types.ts for types."
+2. Create contract file: `write_file("contracts/auth_types.ts", content)` with actual TypeScript interfaces
+3. Create contract file: `write_file("contracts/auth_api.json", content)` with actual OpenAPI spec
+4. Coding agents can directly use these contracts to implement features
+
+## HOW TO WRITE CONTRACT FILES
+
+**CRITICAL - Always use correct file paths with write_file():**
+
+Your working directory is `.shotgun/`, so paths should be relative to that directory.
+
+<GOOD_EXAMPLES>
+✅ `write_file("contracts/user_models.py", content)` - Correct path for Python models
+✅ `write_file("contracts/auth_types.ts", content)` - Correct path for TypeScript types
+✅ `write_file("contracts/api_spec.json", content)` - Correct path for OpenAPI spec
+✅ `write_file("contracts/payment_service.rs", content)` - Correct path for Rust code
+</GOOD_EXAMPLES>
+
+<BAD_EXAMPLES>
+❌ `write_file(".shotgun/contracts/user_models.py", content)` - WRONG! Don't include .shotgun/ prefix
+❌ `write_file("contracts/directory_structure.txt", content)` - WRONG! No documentation files
+❌ `write_file("contracts/pyproject.toml", content)` - WRONG! No build configs in contracts/
+❌ `write_file("contracts/requirements.txt", content)` - WRONG! No dependency lists in contracts/
+❌ `write_file("contracts/config.yaml", content)` - WRONG! No config templates in contracts/
+</BAD_EXAMPLES>
+
+**Path format rule:** Always use `contracts/filename.ext`, never `.shotgun/contracts/filename.ext`
+
+**Language-specific examples:**
+
+<PYTHON_EXAMPLE>
+# Python Pydantic model contract
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class User(BaseModel):
+    """User model contract."""
+    id: int
+    email: str = Field(..., description="User email address")
+    username: str
+    is_active: bool = True
+    role: Optional[str] = None
+
+# Save as: write_file("contracts/user_models.py", content)
+</PYTHON_EXAMPLE>
+
+<TYPESCRIPT_EXAMPLE>
+// TypeScript interface contract
+interface User {
+  id: number;
+  email: string;
+  username: string;
+  isActive: boolean;
+  role?: string;
+}
+
+interface AuthToken {
+  token: string;
+  expiresAt: Date;
+  userId: number;
+}
+
+// Save as: write_file("contracts/auth_types.ts", content)
+</TYPESCRIPT_EXAMPLE>
+
+<RUST_EXAMPLE>
+// Rust struct contract
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct User {
+    pub id: u64,
+    pub email: String,
+    pub username: String,
+    pub is_active: bool,
+    pub role: Option<String>,
+}
+
+// Save as: write_file("contracts/user_types.rs", content)
+</RUST_EXAMPLE>
+
+<OPENAPI_EXAMPLE>
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "User API",
+    "version": "1.0.0"
+  },
+  "paths": {
+    "/users": {
+      "get": {
+        "summary": "List users",
+        "responses": {
+          "200": {
+            "description": "Successful response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": { "$ref": "#/components/schemas/User" }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "User": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "integer" },
+          "email": { "type": "string" },
+          "username": { "type": "string" }
+        }
+      }
+    }
+  }
+}
+
+// Save as: write_file("contracts/user_api.json", content)
+</OPENAPI_EXAMPLE>
+
+## WHAT IS ALLOWED vs WHAT IS FORBIDDEN
+
+**✅ ALLOWED - Type Definitions (Shape and Structure):**
+
+```python
+# ✅ GOOD: Pydantic model (type definition)
+from pydantic import BaseModel
+
+class User(BaseModel):
+    id: int
+    email: str
+    username: str
+
+# ✅ GOOD: Protocol class (interface definition)
+from typing import Protocol
+
+class Storage(Protocol):
+    def save(self, data: str) -> None: ...
+    def load(self) -> str: ...
+
+# ✅ GOOD: Type aliases and enums
+from typing import Literal
+from enum import Enum
+
+UserRole = Literal["admin", "user", "guest"]
+
+class Status(Enum):
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+```
+
+**❌ FORBIDDEN - Executable Code (Behavior and Logic):**
+
+```python
+# ❌ BAD: Function with pass (executable code)
+def main() -> int:
+    pass
+
+# ❌ BAD: Function with implementation
+def validate_input(x: str) -> str:
+    return x.strip()
+
+# ❌ BAD: Class with method implementations
+class HistoryManager:
+    def __init__(self):
+        pass
+
+    def add_message(self, msg: str):
+        pass
+
+# ❌ BAD: Data constants (runtime values)
+SUPPORTED_PROVIDERS = [
+    {"name": "openai", "key": "OPENAI_API_KEY"}
+]
+
+# ❌ BAD: Helper functions
+def get_default_config() -> dict:
+    return {"model": "gpt-4"}
+
+# ❌ BAD: Executable code blocks
+if __name__ == "__main__":
+    main()
+```
+
+**Remember**: Contracts define **SHAPES** (types, interfaces, schemas), NOT **BEHAVIOR** (functions, logic, implementations).
+
 ## AI AGENT PIPELINE AWARENESS
 
 **CRITICAL**: Your output will be consumed by AI coding agents (Claude Code, Cursor, Windsurf, etc.)

shotgun/prompts/agents/state/system_state.j2

@@ -1,5 +1,7 @@
 ## System Status
 
+Your training data may be old. The current date and time is: {{ current_datetime }} in {{ timezone_name }} (UTC{{ utc_offset }})
+
 {% include 'agents/state/codebase/codebase_graphs_available.j2' %}
 
 ## Available Files
@@ -20,6 +22,8 @@ No files currently exist in your allowed directories. You can create:
 - `exports/` folder - For exported documents
 {% endif %}
 
+When updating a file try to add into the footer that this was created using Shotgun (https://shotgun.sh).
+
 {% if markdown_toc %}
 ## Document Table of Contents - READ THE ENTIRE FILE TO UNDERSTAND MORE
 

shotgun/prompts/agents/tasks.j2

@@ -99,7 +99,7 @@ Then organize tasks into logical sections:
 USER INTERACTION - ASK CLARIFYING QUESTIONS:
 
 - ALWAYS ask clarifying questions when the request is vague or ambiguous
-- Use ask_user tool to gather specific details about:
+- Use clarifying questions to gather specific details about:
   - Specific features or functionality to prioritize
   - Technical constraints or preferences
   - Timeline and resource constraints

shotgun/prompts/loader.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any
 
-from jinja2 import Environment, FileSystemLoader, Template, select_autoescape
+from jinja2 import Environment, FileSystemLoader, Template
 
 from shotgun.logging_config import setup_logger
 
@@ -32,7 +32,7 @@ class PromptLoader:
         self.templates_dir = templates_dir
         self.env = Environment(
             loader=FileSystemLoader(str(templates_dir)),
-            autoescape=select_autoescape(["j2"]),
+            autoescape=False,  # noqa: S701 - These are LLM prompts, not HTML
             trim_blocks=True,
             lstrip_blocks=True,
         )

shotgun/prompts/tools/web_search.j2

@@ -0,0 +1,14 @@
+Your training data may be old. The current date and time is: {{ current_datetime }} ({{ timezone_name }}, {{ utc_offset }})
+
+Please provide current and accurate information about the following query:
+
+Query: {{ query }}
+
+Instructions:
+- Provide comprehensive, factual information
+- Include relevant details and context
+- Focus on current and recent information
+- Be specific and accurate in your response
+- You can't ask the user for details, so assume the most relevant details for the query
+
+ALWAYS PROVIDE THE SOURCES (urls) TO BACK UP THE INFORMATION YOU PROVIDE.

shotgun/sentry_telemetry.py

@@ -1,9 +1,8 @@
 """Sentry observability setup for Shotgun."""
 
-import os
-
 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__)
@@ -23,24 +22,14 @@ def setup_sentry_observability() -> bool:
             logger.debug("Sentry is already initialized, skipping")
             return True
 
-        # Try to get DSN from build constants first (production builds)
-        dsn = None
-        try:
-            from shotgun import build_constants
-
-            dsn = build_constants.SENTRY_DSN
-            logger.debug("Using Sentry DSN from build constants")
-        except ImportError:
-            # Fallback to environment variable (development)
-            dsn = os.getenv("SENTRY_DSN", "")
-            if dsn:
-                logger.debug("Using Sentry DSN from environment variable")
+        # 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("Found DSN, proceeding with Sentry setup")
+        logger.debug("Using Sentry DSN from settings, proceeding with setup")
 
         # Determine environment based on version
         # Dev versions contain "dev", "rc", "alpha", or "beta"

shotgun/settings.py

@@ -0,0 +1,238 @@
+"""Centralized application settings using Pydantic Settings.
+
+All environment variables use the SHOTGUN_ prefix to avoid conflicts with other tools.
+Settings are loaded with the following priority:
+1. Environment variables (highest priority)
+2. Build constants (embedded at build time)
+3. Default values (lowest priority)
+
+Example usage:
+    from shotgun.settings import settings
+
+    # Access telemetry settings
+    if settings.telemetry.sentry_dsn:
+        sentry_sdk.init(dsn=settings.telemetry.sentry_dsn)
+
+    # Access logging settings
+    logger.setLevel(settings.logging.log_level)
+
+    # Access API settings
+    response = httpx.get(settings.api.web_base_url)
+"""
+
+from typing import Any
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _get_build_constant(name: str, default: Any = None) -> Any:
+    """Get a value from build_constants.py, falling back to default.
+
+    Args:
+        name: The constant name to retrieve (e.g., "SENTRY_DSN")
+        default: Default value if constant not found
+
+    Returns:
+        The constant value, or default if not found/import fails
+    """
+    try:
+        from shotgun import build_constants
+
+        return getattr(build_constants, name, default)
+    except ImportError:
+        return default
+
+
+class TelemetrySettings(BaseSettings):
+    """Telemetry and observability settings.
+
+    These settings control error tracking (Sentry), analytics (PostHog),
+    and observability (Logfire) integrations.
+    """
+
+    sentry_dsn: str = Field(
+        default_factory=lambda: _get_build_constant("SENTRY_DSN", ""),
+        description="Sentry DSN for error tracking",
+    )
+    posthog_api_key: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_API_KEY", ""),
+        description="PostHog API key for analytics",
+    )
+    posthog_project_id: str = Field(
+        default_factory=lambda: _get_build_constant("POSTHOG_PROJECT_ID", ""),
+        description="PostHog project ID",
+    )
+    logfire_enabled: bool = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_ENABLED", False),
+        description="Enable Logfire observability (dev builds only)",
+    )
+    logfire_token: str = Field(
+        default_factory=lambda: _get_build_constant("LOGFIRE_TOKEN", ""),
+        description="Logfire authentication token",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("logfire_enabled", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class LoggingSettings(BaseSettings):
+    """Logging configuration settings.
+
+    Controls log level, console output, and file logging behavior.
+    """
+
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    )
+    logging_to_console: bool = Field(
+        default=False,
+        description="Enable console logging output",
+    )
+    logging_to_file: bool = Field(
+        default=True,
+        description="Enable file logging output",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("log_level")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level is one of the allowed values."""
+        v = v.upper()
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if v not in valid_levels:
+            return "INFO"  # Default to INFO if invalid
+        return v
+
+    @field_validator("logging_to_console", "logging_to_file", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class ApiSettings(BaseSettings):
+    """API endpoint settings.
+
+    Configuration for Shotgun backend services.
+    """
+
+    web_base_url: str = Field(
+        default="https://api-219702594231.us-east4.run.app",
+        description="Shotgun Web API base URL (authentication/subscription)",
+    )
+    account_llm_base_url: str = Field(
+        default="https://litellm-219702594231.us-east4.run.app",
+        description="Shotgun's LiteLLM proxy base URL (AI model requests)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+class DevelopmentSettings(BaseSettings):
+    """Development and testing settings.
+
+    These settings are primarily used for testing and development purposes.
+    """
+
+    home: str | None = Field(
+        default=None,
+        description="Override Shotgun home directory (for testing)",
+    )
+    pipx_simulate: bool = Field(
+        default=False,
+        description="Simulate pipx installation (for testing)",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("pipx_simulate", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings (matches is_truthy behavior)."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
+class Settings(BaseSettings):
+    """Main application settings with SHOTGUN_ prefix.
+
+    This is the main settings class that composes all other settings groups.
+    Access settings via the global `settings` singleton instance.
+
+    Example:
+        from shotgun.settings import settings
+
+        # Telemetry settings
+        settings.telemetry.sentry_dsn
+        settings.telemetry.posthog_api_key
+        settings.telemetry.logfire_enabled
+
+        # Logging settings
+        settings.logging.log_level
+        settings.logging.logging_to_console
+
+        # API settings
+        settings.api.web_base_url
+        settings.api.account_llm_base_url
+
+        # Development settings
+        settings.dev.home
+        settings.dev.pipx_simulate
+    """
+
+    telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
+    logging: LoggingSettings = Field(default_factory=LoggingSettings)
+    api: ApiSettings = Field(default_factory=ApiSettings)
+    dev: DevelopmentSettings = Field(default_factory=DevelopmentSettings)
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+# Global settings singleton
+# Import this in your modules: from shotgun.settings import settings
+settings = Settings()