shotgun-sh 0.1.0.dev12__py3-none-any.whl → 0.1.0.dev14__py3-none-any.whl

shotgun/agents/agent_manager.py

@@ -3,13 +3,19 @@
 from enum import Enum
 from typing import Any
 
-from pydantic_ai import Agent, DeferredToolRequests, DeferredToolResults, UsageLimits
+from pydantic_ai import (
+    Agent,
+    DeferredToolRequests,
+    DeferredToolResults,
+    UsageLimits,
+)
 from pydantic_ai.agent import AgentRunResult
 from pydantic_ai.messages import ModelMessage, ModelRequest
 from textual.message import Message
 from textual.widget import Widget
 
-from .models import AgentDeps, AgentRuntimeOptions
+from .history.compaction import apply_persistent_compaction
+from .models import AgentDeps, AgentRuntimeOptions, FileOperation
 from .plan import create_plan_agent
 from .research import create_research_agent
 from .tasks import create_tasks_agent
@@ -84,6 +90,7 @@ class AgentManager(Widget):
         # Maintain shared message history
         self.ui_message_history: list[ModelMessage] = []
         self.message_history: list[ModelMessage] = []
+        self.recently_change_files: list[FileOperation] = []
 
     @property
     def current_agent(self) -> Agent[AgentDeps, str | DeferredToolRequests]:
@@ -181,9 +188,15 @@ class AgentManager(Widget):
             mes for mes in result.new_messages() if not isinstance(mes, ModelRequest)
         ]
 
-        self.message_history = result.all_messages()
+        # Apply compaction to persistent message history to prevent cascading growth
+        self.message_history = await apply_persistent_compaction(
+            result.all_messages(), deps
+        )
         self._post_messages_updated()
 
+        # Log file operations summary if any files were modified
+        self.recently_change_files = deps.file_tracker.operations.copy()
+
         return result
 
     def _post_messages_updated(self) -> None:

shotgun/agents/artifact_state.py

@@ -0,0 +1,58 @@
+"""Utilities for collecting and organizing artifact state information."""
+
+from datetime import datetime
+from typing import TypedDict
+
+from shotgun.artifacts.models import ArtifactSummary
+from shotgun.artifacts.templates.models import TemplateSummary
+from shotgun.sdk.services import get_artifact_service
+
+
+class ArtifactState(TypedDict):
+    """Type definition for artifact state information."""
+
+    available_templates: dict[str, list[TemplateSummary]]
+    existing_artifacts: dict[str, list[ArtifactSummary]]
+    current_date: str
+
+
+def collect_artifact_state() -> ArtifactState:
+    """Collect and organize artifact state information for system context.
+
+    Returns:
+        ArtifactState containing organized templates and artifacts by mode, plus current date
+    """
+    artifact_service = get_artifact_service()
+
+    # Get available templates
+    available_templates_list = artifact_service.list_templates()
+
+    # Group templates by mode for better organization
+    templates_by_mode: dict[str, list[TemplateSummary]] = {}
+    for template in available_templates_list:
+        mode_name = template.template_id.split("/")[0]
+        if mode_name not in templates_by_mode:
+            templates_by_mode[mode_name] = []
+        templates_by_mode[mode_name].append(template)
+
+    # Get ALL existing artifacts regardless of current agent mode for complete visibility
+    existing_artifacts_list = (
+        artifact_service.list_artifacts()
+    )  # No mode filter = all modes
+
+    # Group artifacts by mode for organized display
+    artifacts_by_mode: dict[str, list[ArtifactSummary]] = {}
+    for artifact in existing_artifacts_list:
+        mode_name = artifact.agent_mode.value
+        if mode_name not in artifacts_by_mode:
+            artifacts_by_mode[mode_name] = []
+        artifacts_by_mode[mode_name].append(artifact)
+
+    # Get current date for temporal context (month in words for clarity)
+    current_date = datetime.now().strftime("%B %d, %Y")
+
+    return {
+        "available_templates": templates_by_mode,
+        "existing_artifacts": artifacts_by_mode,
+        "current_date": current_date,
+    }

shotgun/agents/common.py

@@ -2,7 +2,6 @@
 
 import asyncio
 from collections.abc import Callable
-from pathlib import Path
 from typing import Any
 
 from pydantic_ai import (
@@ -15,17 +14,20 @@ from pydantic_ai import (
 from pydantic_ai.agent import AgentRunResult
 from pydantic_ai.messages import (
     ModelMessage,
+    ModelRequest,
     ModelResponse,
+    SystemPromptPart,
     TextPart,
 )
 
 from shotgun.agents.config import ProviderType, get_config_manager, get_provider_model
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
-from shotgun.sdk.services import get_codebase_service
+from shotgun.sdk.services import get_artifact_service, get_codebase_service
 from shotgun.utils import ensure_shotgun_directory_exists
 
 from .history import token_limit_compactor
+from .history.compaction import apply_persistent_compaction
 from .models import AgentDeps, AgentRuntimeOptions
 from .tools import (
     append_file,
@@ -38,6 +40,14 @@ from .tools import (
     retrieve_code,
     write_file,
 )
+from .tools.artifact_management import (
+    create_artifact,
+    list_artifact_templates,
+    list_artifacts,
+    read_artifact,
+    read_artifact_section,
+    write_artifact_section,
+)
 
 logger = get_logger(__name__)
 
@@ -45,70 +55,6 @@ logger = get_logger(__name__)
 prompt_loader = PromptLoader()
 
 
-def ensure_file_exists(filename: str, header: str) -> str:
-    """Ensure a markdown file exists with proper header and return its content.
-
-    Args:
-        filename: Name of the file (e.g., "research.md")
-        header: Header to add if file is empty (e.g., "# Research")
-
-    Returns:
-        Current file content
-    """
-    shotgun_dir = Path.cwd() / ".shotgun"
-    file_path = shotgun_dir / filename
-
-    try:
-        if file_path.exists():
-            content = file_path.read_text(encoding="utf-8")
-            if not content.strip():
-                # File exists but is empty, add header
-                header_content = f"{header}\n\n"
-                file_path.write_text(header_content, encoding="utf-8")
-                return header_content
-            return content
-        else:
-            # File doesn't exist, create it with header
-            shotgun_dir.mkdir(exist_ok=True)
-            header_content = f"{header}\n\n"
-            file_path.write_text(header_content, encoding="utf-8")
-            return header_content
-    except Exception as e:
-        logger.error("Failed to initialize %s: %s", filename, str(e))
-        return f"{header}\n\n"
-
-
-def register_common_tools(
-    agent: Agent[AgentDeps], additional_tools: list[Any], interactive_mode: bool
-) -> None:
-    """Register common tools with an agent.
-
-    Args:
-        agent: The Pydantic AI agent to register tools with
-        additional_tools: List of additional tools specific to this agent
-        interactive_mode: Whether to register interactive tools
-    """
-    logger.debug("📌 Registering tools with agent")
-
-    # Register additional tools first (agent-specific)
-    for tool in additional_tools:
-        agent.tool_plain(tool)
-
-    # Register interactive tool if enabled
-    if interactive_mode:
-        agent.tool(ask_user)
-        logger.debug("📞 User interaction tool registered")
-    else:
-        logger.debug("🚫 User interaction disabled (non-interactive mode)")
-
-    # Register common file management tools
-    agent.tool_plain(read_file)
-    agent.tool_plain(write_file)
-    agent.tool_plain(append_file)
-
-    logger.debug("✅ Tool registration complete")
-
-
 async def add_system_status_message(
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
@@ -125,11 +71,17 @@ async def add_system_status_message(
     message_history = message_history or []
     codebase_understanding_graphs = await deps.codebase_service.list_graphs()
 
+    # Collect artifact state information
+    from .artifact_state import collect_artifact_state
+
+    artifact_state = collect_artifact_state()
+
     system_state = prompt_loader.render(
         "agents/state/system_state.j2",
         codebase_understanding_graphs=codebase_understanding_graphs,
-        context="system state",
+        **artifact_state,
     )
+
     message_history.append(
         ModelResponse(
             parts=[
@@ -173,12 +125,15 @@ def create_base_agent(
         # Use the Model instance directly (has API key baked in)
         model = model_config.model_instance
 
-        # Create deps with model config and codebase service
+        # Create deps with model config and services
         codebase_service = get_codebase_service()
+        artifact_service = get_artifact_service()
         deps = AgentDeps(
             **agent_runtime_options.model_dump(),
             llm_model=model_config,
             codebase_service=codebase_service,
+            artifact_service=artifact_service,
+            system_prompt_fn=system_prompt_fn,
         )
 
     except Exception as e:
@@ -186,16 +141,30 @@ def create_base_agent(
         logger.debug("🤖 Creating agent with fallback OpenAI GPT-4o")
         raise ValueError("Configured model is required") from e
 
+    # Create a history processor that has access to deps via closure
+    async def history_processor(messages: list[ModelMessage]) -> list[ModelMessage]:
+        """History processor with access to deps via closure."""
+
+        # Create a minimal context for compaction
+        class ProcessorContext:
+            def __init__(self, deps: AgentDeps):
+                self.deps = deps
+                self.usage = None  # Will be estimated from messages
+
+        ctx = ProcessorContext(deps)
+        return await token_limit_compactor(ctx, messages)
+
     agent = Agent(
         model,
         output_type=[str, DeferredToolRequests],
         deps_type=AgentDeps,
         instrument=True,
-        history_processors=[token_limit_compactor],
+        history_processors=[history_processor],
     )
 
-    # Decorate the system prompt function
-    agent.system_prompt(system_prompt_fn)
+    # System prompt function is stored in deps and will be called manually in run_agent
+    func_name = getattr(system_prompt_fn, "__name__", str(system_prompt_fn))
+    logger.debug("🔧 System prompt function stored: %s", func_name)
 
     # Register additional tools first (agent-specific)
     for tool in additional_tools or []:
@@ -207,11 +176,19 @@ def create_base_agent(
         logger.debug("📞 Interactive mode enabled - ask_user tool registered")
 
     # Register common file management tools (always available)
-    agent.tool_plain(read_file)
-    agent.tool_plain(write_file)
-    agent.tool_plain(append_file)
-
-    # Register codebase understanding tools (always available)
+    agent.tool(read_file)
+    agent.tool(write_file)
+    agent.tool(append_file)
+
+    # Register artifact management tools (always available)
+    agent.tool(create_artifact)
+    agent.tool(list_artifacts)
+    agent.tool(list_artifact_templates)
+    agent.tool(read_artifact)
+    agent.tool(read_artifact_section)
+    agent.tool(write_artifact_section)
+
+    # Register codebase understanding tools (conditional)
     if load_codebase_understanding_tools:
         agent.tool(query_graph)
         agent.tool(retrieve_code)
@@ -222,10 +199,47 @@ def create_base_agent(
     else:
         logger.debug("🚫🧠 Codebase understanding tools not registered")
 
-    logger.debug("✅ Agent creation complete")
+    logger.debug("✅ Agent creation complete with artifact and codebase tools")
     return agent, deps
 
 
+def build_agent_system_prompt(
+    agent_type: str,
+    ctx: RunContext[AgentDeps],
+    context_name: str | None = None,
+) -> str:
+    """Build system prompt for any agent type.
+
+    Args:
+        agent_type: Type of agent ('research', 'plan', 'tasks')
+        ctx: RunContext containing AgentDeps
+        context_name: Optional context name for template rendering
+
+    Returns:
+        Rendered system prompt
+    """
+    prompt_loader = PromptLoader()
+
+    # Add logging if research agent
+    if agent_type == "research":
+        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",
+        interactive_mode=ctx.deps.interactive_mode,
+        mode=agent_type,
+    )
+
+    if agent_type == "research":
+        logger.debug(
+            "✅ Research system prompt built successfully (length: %d chars)",
+            len(result),
+        )
+
+    return result
+
+
 def create_usage_limits() -> UsageLimits:
     """Create reasonable usage limits for agent runs.
 
@@ -238,20 +252,41 @@ def create_usage_limits() -> UsageLimits:
     )
 
 
-def get_file_history(filename: str) -> str:
-    """Get the history content from a file.
+async def add_system_prompt_message(
+    deps: AgentDeps,
+    message_history: list[ModelMessage] | None = None,
+) -> list[ModelMessage]:
+    """Add the system prompt as the first message in the message history.
 
     Args:
-        filename: Name of the file (e.g., "research.md")
+        deps: Agent dependencies containing system_prompt_fn
+        message_history: Existing message history
 
     Returns:
-        File content or fallback message
+        Updated message history with system prompt prepended as first message
     """
-    try:
-        return read_file(filename)
-    except Exception as e:
-        logger.debug("Could not load %s history: %s", filename, str(e))
-        return f"No {filename.replace('.md', '')} history available."
+    message_history = message_history or []
+
+    # Create a minimal RunContext to call the system prompt function
+    # We'll pass None for model and usage since they're not used by our system prompt functions
+    context = type(
+        "RunContext", (), {"deps": deps, "retry": 0, "model": None, "usage": None}
+    )()
+
+    # Render the system prompt using the stored function
+    system_prompt_content = deps.system_prompt_fn(context)
+    logger.debug(
+        "🎯 Rendered system prompt (length: %d chars)", len(system_prompt_content)
+    )
+
+    # Create system message and prepend to message history
+    system_message = ModelRequest(
+        parts=[SystemPromptPart(content=system_prompt_content)]
+    )
+    message_history.insert(0, system_message)
+    logger.debug("✅ System prompt prepended as first message")
+
+    return message_history
 
 
 async def run_agent(
@@ -261,6 +296,13 @@ async def run_agent(
     message_history: list[ModelMessage] | None = None,
     usage_limits: UsageLimits | None = None,
 ) -> AgentRunResult[str | DeferredToolRequests]:
+    # Clear file tracker for new run
+    deps.file_tracker.clear()
+    logger.debug("🔧 Cleared file tracker for new agent run")
+
+    # Add system prompt as first message
+    message_history = await add_system_prompt_message(deps, message_history)
+
     result = await agent.run(
         prompt,
         deps=deps,
@@ -268,7 +310,8 @@ async def run_agent(
         message_history=message_history,
     )
 
-    messages = result.all_messages()
+    # Apply persistent compaction to prevent cascading token growth across CLI commands
+    messages = await apply_persistent_compaction(result.all_messages(), deps)
     while isinstance(result.output, DeferredToolRequests):
         logger.info("got deferred tool requests")
         await deps.queue.join()
@@ -291,6 +334,12 @@ async def run_agent(
             message_history=messages,
             deferred_tool_results=results,
         )
-        messages = result.all_messages()
+        # Apply persistent compaction to prevent cascading token growth in multi-turn loops
+        messages = await apply_persistent_compaction(result.all_messages(), deps)
+
+    # Log file operations summary if any files were modified
+    if deps.file_tracker.operations:
+        summary = deps.file_tracker.format_summary()
+        logger.info("📁 %s", summary)
 
     return result

shotgun/agents/config/constants.py

@@ -0,0 +1,18 @@
+"""Configuration constants for Shotgun agents."""
+
+# Field names
+API_KEY_FIELD = "api_key"
+MODEL_NAME_FIELD = "model_name"
+DEFAULT_PROVIDER_FIELD = "default_provider"
+USER_ID_FIELD = "user_id"
+CONFIG_VERSION_FIELD = "config_version"
+
+# Provider names (for consistency with data dict keys)
+OPENAI_PROVIDER = "openai"
+ANTHROPIC_PROVIDER = "anthropic"
+GOOGLE_PROVIDER = "google"
+
+# Environment variable names
+OPENAI_API_KEY_ENV = "OPENAI_API_KEY"
+ANTHROPIC_API_KEY_ENV = "ANTHROPIC_API_KEY"
+GEMINI_API_KEY_ENV = "GEMINI_API_KEY"

shotgun/agents/config/manager.py

@@ -1,6 +1,7 @@
 """Configuration manager for Shotgun CLI."""
 
 import json
+import os
 import uuid
 from pathlib import Path
 from typing import Any
@@ -10,6 +11,15 @@ from pydantic import SecretStr
 from shotgun.logging_config import get_logger
 from shotgun.utils import get_shotgun_home
 
+from .constants import (
+    ANTHROPIC_API_KEY_ENV,
+    ANTHROPIC_PROVIDER,
+    API_KEY_FIELD,
+    GEMINI_API_KEY_ENV,
+    GOOGLE_PROVIDER,
+    OPENAI_API_KEY_ENV,
+    OPENAI_PROVIDER,
+)
 from .models import ProviderType, ShotgunConfig
 
 logger = get_logger(__name__)
@@ -58,6 +68,22 @@ class ConfigManager:
 
             self._config = ShotgunConfig.model_validate(data)
             logger.debug("Configuration loaded successfully from %s", self.config_path)
+
+            # Check if the default provider has a key, if not find one that does
+            if not self.has_provider_key(self._config.default_provider):
+                original_default = self._config.default_provider
+                # Find first provider with a configured key
+                for provider in ProviderType:
+                    if self.has_provider_key(provider):
+                        logger.info(
+                            "Default provider %s has no API key, updating to %s",
+                            original_default.value,
+                            provider.value,
+                        )
+                        self._config.default_provider = provider
+                        self.save(self._config)
+                        break
+
             return self._config
 
         except Exception as e:
@@ -114,17 +140,25 @@ class ConfigManager:
         provider_config = self._get_provider_config(config, provider_enum)
 
         # Only support api_key updates
-        if "api_key" in kwargs:
-            api_key_value = kwargs["api_key"]
+        if API_KEY_FIELD in kwargs:
+            api_key_value = kwargs[API_KEY_FIELD]
             provider_config.api_key = (
                 SecretStr(api_key_value) if api_key_value is not None else None
             )
 
         # Reject other fields
-        unsupported_fields = set(kwargs.keys()) - {"api_key"}
+        unsupported_fields = set(kwargs.keys()) - {API_KEY_FIELD}
         if unsupported_fields:
             raise ValueError(f"Unsupported configuration fields: {unsupported_fields}")
 
+        # If no other providers have keys configured and we just added one,
+        # set this provider as the default
+        if API_KEY_FIELD in kwargs and api_key_value is not None:
+            other_providers = [p for p in ProviderType if p != provider_enum]
+            has_other_keys = any(self.has_provider_key(p) for p in other_providers)
+            if not has_other_keys:
+                config.default_provider = provider_enum
+
         self.save(config)
 
     def clear_provider_key(self, provider: ProviderType | str) -> None:
@@ -136,11 +170,27 @@ class ConfigManager:
         self.save(config)
 
     def has_provider_key(self, provider: ProviderType | str) -> bool:
-        """Check if the given provider has a non-empty API key configured."""
+        """Check if the given provider has a non-empty API key configured.
+
+        This checks both the configuration file and environment variables.
+        """
         config = self.load()
         provider_enum = self._ensure_provider_enum(provider)
         provider_config = self._get_provider_config(config, provider_enum)
-        return self._provider_has_api_key(provider_config)
+
+        # Check config first
+        if self._provider_has_api_key(provider_config):
+            return True
+
+        # Check environment variable
+        if provider_enum == ProviderType.OPENAI:
+            return bool(os.getenv(OPENAI_API_KEY_ENV))
+        elif provider_enum == ProviderType.ANTHROPIC:
+            return bool(os.getenv(ANTHROPIC_API_KEY_ENV))
+        elif provider_enum == ProviderType.GOOGLE:
+            return bool(os.getenv(GEMINI_API_KEY_ENV))
+
+        return False
 
     def has_any_provider_key(self) -> bool:
         """Determine whether any provider has a configured API key."""
@@ -175,25 +225,27 @@ class ConfigManager:
 
     def _convert_secrets_to_secretstr(self, data: dict[str, Any]) -> None:
         """Convert plain text secrets in data to SecretStr objects."""
-        for provider in ["openai", "anthropic", "google"]:
+        for provider in [OPENAI_PROVIDER, ANTHROPIC_PROVIDER, GOOGLE_PROVIDER]:
             if provider in data and isinstance(data[provider], dict):
                 if (
-                    "api_key" in data[provider]
-                    and data[provider]["api_key"] is not None
+                    API_KEY_FIELD in data[provider]
+                    and data[provider][API_KEY_FIELD] is not None
                 ):
-                    data[provider]["api_key"] = SecretStr(data[provider]["api_key"])
+                    data[provider][API_KEY_FIELD] = SecretStr(
+                        data[provider][API_KEY_FIELD]
+                    )
 
     def _convert_secretstr_to_plain(self, data: dict[str, Any]) -> None:
         """Convert SecretStr objects in data to plain text for JSON serialization."""
-        for provider in ["openai", "anthropic", "google"]:
+        for provider in [OPENAI_PROVIDER, ANTHROPIC_PROVIDER, GOOGLE_PROVIDER]:
             if provider in data and isinstance(data[provider], dict):
                 if (
-                    "api_key" in data[provider]
-                    and data[provider]["api_key"] is not None
+                    API_KEY_FIELD in data[provider]
+                    and data[provider][API_KEY_FIELD] is not None
                 ):
-                    if hasattr(data[provider]["api_key"], "get_secret_value"):
-                        data[provider]["api_key"] = data[provider][
-                            "api_key"
+                    if hasattr(data[provider][API_KEY_FIELD], "get_secret_value"):
+                        data[provider][API_KEY_FIELD] = data[provider][
+                            API_KEY_FIELD
                         ].get_secret_value()
 
     def _ensure_provider_enum(self, provider: ProviderType | str) -> ProviderType:
@@ -216,7 +268,7 @@ class ConfigManager:
 
     def _provider_has_api_key(self, provider_config: Any) -> bool:
         """Return True if the provider config contains a usable API key."""
-        api_key = getattr(provider_config, "api_key", None)
+        api_key = getattr(provider_config, API_KEY_FIELD, None)
         if api_key is None:
             return False