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

shotgun/agents/models.py

@@ -1,14 +1,19 @@
 """Pydantic models for agent dependencies and configuration."""
 
 from asyncio import Future, Queue
+from collections.abc import Callable
+from datetime import datetime
+from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING
 
 from pydantic import BaseModel, ConfigDict, Field
+from pydantic_ai import RunContext
 
 from .config.models import ModelConfig
 
 if TYPE_CHECKING:
+    from shotgun.artifacts.service import ArtifactService
     from shotgun.codebase.service import CodebaseService
 
 
@@ -72,6 +77,117 @@ class AgentRuntimeOptions(BaseModel):
     )
 
 
+class FileOperationType(str, Enum):
+    """Types of file operations that can be tracked."""
+
+    CREATED = "created"
+    UPDATED = "updated"
+    DELETED = "deleted"
+
+
+class FileOperation(BaseModel):
+    """Single file operation record."""
+
+    file_path: str = Field(
+        description="Full absolute path to the file",
+    )
+    operation: FileOperationType = Field(
+        description="Type of operation performed",
+    )
+    timestamp: datetime = Field(
+        default_factory=datetime.now,
+        description="When the operation occurred",
+    )
+
+
+class FileOperationTracker(BaseModel):
+    """Tracks file operations during a single agent run."""
+
+    operations: list[FileOperation] = Field(
+        default_factory=list,
+        description="List of file operations performed",
+    )
+
+    def add_operation(
+        self, file_path: Path | str, operation: FileOperationType
+    ) -> None:
+        """Record a file operation.
+
+        Args:
+            file_path: Path to the file (will be converted to absolute)
+            operation: Type of operation performed
+        """
+        # Convert to absolute path string
+        if isinstance(file_path, Path):
+            absolute_path = str(file_path.resolve())
+        else:
+            absolute_path = str(Path(file_path).resolve())
+
+        self.operations.append(
+            FileOperation(file_path=absolute_path, operation=operation)
+        )
+
+    def clear(self) -> None:
+        """Clear all tracked operations for a new run."""
+        self.operations = []
+
+    def get_summary(self) -> dict[FileOperationType, list[str]]:
+        """Get operations grouped by type.
+
+        Returns:
+            Dictionary mapping operation types to lists of file paths
+        """
+        summary: dict[FileOperationType, list[str]] = {
+            FileOperationType.CREATED: [],
+            FileOperationType.UPDATED: [],
+            FileOperationType.DELETED: [],
+        }
+
+        for op in self.operations:
+            summary[op.operation].append(op.file_path)
+
+        # Remove duplicates while preserving order
+        for op_type in summary:
+            seen = set()
+            unique_paths = []
+            for path in summary[op_type]:
+                if path not in seen:
+                    seen.add(path)
+                    unique_paths.append(path)
+            summary[op_type] = unique_paths
+
+        return summary
+
+    def format_summary(self) -> str:
+        """Generate human-readable summary for the user.
+
+        Returns:
+            Formatted string showing files modified during the run
+        """
+        if not self.operations:
+            return "No files were modified during this run."
+
+        summary = self.get_summary()
+        lines = ["Files modified during this run:"]
+
+        if summary[FileOperationType.CREATED]:
+            lines.append("\nCreated:")
+            for path in summary[FileOperationType.CREATED]:
+                lines.append(f"  - {path}")
+
+        if summary[FileOperationType.UPDATED]:
+            lines.append("\nUpdated:")
+            for path in summary[FileOperationType.UPDATED]:
+                lines.append(f"  - {path}")
+
+        if summary[FileOperationType.DELETED]:
+            lines.append("\nDeleted:")
+            for path in summary[FileOperationType.DELETED]:
+                lines.append(f"  - {path}")
+
+        return "\n".join(lines)
+
+
 class AgentDeps(AgentRuntimeOptions):
     """Dependencies passed to all agents for configuration and runtime behavior."""
 
@@ -83,12 +199,26 @@ class AgentDeps(AgentRuntimeOptions):
         description="Codebase service for code analysis tools",
     )
 
+    artifact_service: "ArtifactService" = Field(
+        description="Artifact service for managing structured artifacts",
+    )
+
+    system_prompt_fn: Callable[[RunContext["AgentDeps"]], str] = Field(
+        description="Function that generates the system prompt for this agent",
+    )
+
+    file_tracker: FileOperationTracker = Field(
+        default_factory=FileOperationTracker,
+        description="Tracker for file operations during agent run",
+    )
+
 
 # Rebuild model to resolve forward references after imports are available
 try:
+    from shotgun.artifacts.service import ArtifactService
     from shotgun.codebase.service import CodebaseService
 
     AgentDeps.model_rebuild()
 except ImportError:
-    # CodebaseService may not be available in all contexts
+    # Services may not be available in all contexts
     pass

shotgun/agents/plan.py

@@ -1,51 +1,33 @@
 """Plan agent factory and functions using Pydantic AI with file-based memory."""
 
+from functools import partial
+
 from pydantic_ai import (
     Agent,
     DeferredToolRequests,
-    RunContext,
 )
 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 shotgun.prompts import PromptLoader
 
 from .common import (
     add_system_status_message,
+    build_agent_system_prompt,
     create_base_agent,
     create_usage_limits,
-    ensure_file_exists,
-    get_file_history,
     run_agent,
 )
 from .models import AgentDeps, AgentRuntimeOptions
 
 logger = get_logger(__name__)
 
-# Global prompt loader instance
-prompt_loader = PromptLoader()
-
-
-def _build_plan_agent_system_prompt(ctx: RunContext[AgentDeps]) -> str:
-    """Build the system prompt for the plan agent.
-
-    Args:
-        ctx: RunContext containing AgentDeps with interactive_mode and other settings
-
-    Returns:
-        The complete system prompt string for the plan agent
-    """
-    return prompt_loader.render(
-        "agents/plan.j2", interactive_mode=ctx.deps.interactive_mode, context="plans"
-    )
-
 
 def create_plan_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
-    """Create a plan agent with file management capabilities.
+    """Create a plan agent with artifact management capabilities.
 
     Args:
         agent_runtime_options: Agent runtime options for the agent
@@ -55,8 +37,15 @@ def create_plan_agent(
         Tuple of (Configured Pydantic AI agent for planning tasks, Agent dependencies)
     """
     logger.debug("Initializing plan agent")
+    # Use partial to create system prompt function for plan agent
+    system_prompt_fn = partial(build_agent_system_prompt, "plan")
+
     agent, deps = create_base_agent(
-        _build_plan_agent_system_prompt, agent_runtime_options, provider=provider
+        system_prompt_fn,
+        agent_runtime_options,
+        load_codebase_understanding_tools=True,
+        additional_tools=None,
+        provider=provider,
     )
     return agent, deps
 
@@ -67,7 +56,7 @@ async def run_plan_agent(
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
 ) -> AgentRunResult[str | DeferredToolRequests]:
-    """Create or update a plan based on the given goal.
+    """Create or update a plan based on the given goal using artifacts.
 
     Args:
         agent: The configured plan agent
@@ -80,11 +69,9 @@ async def run_plan_agent(
     """
     logger.debug("📋 Starting planning for goal: %s", goal)
 
-    # Ensure plan.md exists
-    ensure_file_exists("plan.md", "# Plan")
-
-    # Let the agent use its tools to read existing plan and research
+    # Simple prompt - the agent system prompt has all the artifact instructions
     full_prompt = f"Create a comprehensive plan for: {goal}"
+
     try:
         # Create usage limits for responsible API usage
         usage_limits = create_usage_limits()
@@ -108,12 +95,3 @@ async def run_plan_agent(
         logger.error("Full traceback:\n%s", traceback.format_exc())
         logger.error("❌ Planning failed: %s", str(e))
         raise
-
-
-def get_plan_history() -> str:
-    """Get the full plan history from the file.
-
-    Returns:
-        Plan history content or fallback message
-    """
-    return get_file_history("plan.md")

shotgun/agents/research.py

@@ -1,9 +1,10 @@
 """Research agent factory and functions using Pydantic AI with file-based memory."""
 
+from functools import partial
+
 from pydantic_ai import (
     Agent,
     DeferredToolRequests,
-    RunContext,
 )
 from pydantic_ai.agent import AgentRunResult
 from pydantic_ai.messages import (
@@ -12,14 +13,12 @@ from pydantic_ai.messages import (
 
 from shotgun.agents.config import ProviderType
 from shotgun.logging_config import get_logger
-from shotgun.prompts import PromptLoader
 
 from .common import (
     add_system_status_message,
+    build_agent_system_prompt,
     create_base_agent,
     create_usage_limits,
-    ensure_file_exists,
-    get_file_history,
     run_agent,
 )
 from .models import AgentDeps, AgentRuntimeOptions
@@ -27,30 +26,11 @@ from .tools import get_available_web_search_tools
 
 logger = get_logger(__name__)
 
-# Global prompt loader instance
-prompt_loader = PromptLoader()
-
-
-def _build_research_agent_system_prompt(ctx: RunContext[AgentDeps]) -> str:
-    """Build the system prompt for the research agent.
-
-    Args:
-        ctx: RunContext containing AgentDeps with interactive_mode and other settings
-
-    Returns:
-        The complete system prompt string for the research agent
-    """
-    return prompt_loader.render(
-        "agents/research.j2",
-        interactive_mode=ctx.deps.interactive_mode,
-        context="research output",
-    )
-
 
 def create_research_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
 ) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
-    """Create a research agent with web search capabilities.
+    """Create a research agent with web search and artifact management capabilities.
 
     Args:
         agent_runtime_options: Agent runtime options for the agent
@@ -71,8 +51,11 @@ def create_research_agent(
     else:
         logger.warning("Research agent configured without web search tools")
 
+    # Use partial to create system prompt function for research agent
+    system_prompt_fn = partial(build_agent_system_prompt, "research")
+
     agent, deps = create_base_agent(
-        _build_research_agent_system_prompt,
+        system_prompt_fn,
         agent_runtime_options,
         load_codebase_understanding_tools=True,
         additional_tools=web_search_tools,
@@ -87,7 +70,7 @@ async def run_research_agent(
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
 ) -> AgentRunResult[str | DeferredToolRequests]:
-    """Perform research on the given query and update the research file.
+    """Perform research on the given query and update research artifacts.
 
     Args:
         agent: The configured research agent
@@ -99,24 +82,15 @@ async def run_research_agent(
     """
     logger.debug("🔬 Starting research for query: %s", query)
 
-    # Ensure research.md exists
-    ensure_file_exists("research.md", "# Research")
-
     message_history = await add_system_status_message(deps, message_history)
 
-    user_prompt = prompt_loader.render(
-        "user/research.j2",
-        user_query=query,
-        context="research output",
-    )
-
     try:
         # Create usage limits for responsible API usage
         usage_limits = create_usage_limits()
 
         result = await run_agent(
             agent=agent,
-            prompt=user_prompt,
+            prompt=query,
             deps=deps,
             message_history=message_history,
             usage_limits=usage_limits,
@@ -131,12 +105,3 @@ async def run_research_agent(
         logger.error("Full traceback:\n%s", traceback.format_exc())
         logger.error("❌ Research failed: %s", str(e))
         raise
-
-
-def get_research_history() -> str:
-    """Get the full research history from the file.
-
-    Returns:
-        Research history content or fallback message
-    """
-    return get_file_history("research.md")

shotgun/agents/specify.py

@@ -0,0 +1,97 @@
+"""Specify 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_specify_agent(
+    agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
+) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
+    """Create a specify agent with artifact 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 specification tasks, Agent dependencies)
+    """
+    logger.debug("Initializing specify agent")
+    # Use partial to create system prompt function for specify agent
+    system_prompt_fn = partial(build_agent_system_prompt, "specify")
+
+    agent, deps = create_base_agent(
+        system_prompt_fn,
+        agent_runtime_options,
+        load_codebase_understanding_tools=True,
+        additional_tools=None,
+        provider=provider,
+    )
+    return agent, deps
+
+
+async def run_specify_agent(
+    agent: Agent[AgentDeps, str | DeferredToolRequests],
+    requirement: str,
+    deps: AgentDeps,
+    message_history: list[ModelMessage] | None = None,
+) -> AgentRunResult[str | DeferredToolRequests]:
+    """Create or update specifications based on the given requirement.
+
+    Args:
+        agent: The configured specify agent
+        requirement: The specification requirement or instruction
+        deps: Agent dependencies
+        message_history: Optional message history for conversation continuity
+
+    Returns:
+        AgentRunResult containing the specification process output
+    """
+    logger.debug("📋 Starting specification for requirement: %s", requirement)
+
+    # Simple prompt - the agent system prompt has all the artifact instructions
+    full_prompt = f"Create a comprehensive specification for: {requirement}"
+
+    try:
+        # Create usage limits for responsible API usage
+        usage_limits = create_usage_limits()
+
+        message_history = await add_system_status_message(deps, message_history)
+
+        result = await run_agent(
+            agent=agent,
+            prompt=full_prompt,
+            deps=deps,
+            message_history=message_history,
+            usage_limits=usage_limits,
+        )
+
+        logger.debug("✅ Specification completed successfully")
+        return result
+
+    except Exception as e:
+        import traceback
+
+        logger.error("Full traceback:\n%s", traceback.format_exc())
+        logger.error("❌ Specification failed: %s", str(e))
+        raise

shotgun/agents/tasks.py

@@ -1,48 +1,28 @@
 """Tasks agent factory and functions using Pydantic AI with file-based memory."""
 
+from functools import partial
+
 from pydantic_ai import (
     Agent,
     DeferredToolRequests,
-    RunContext,
 )
 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 shotgun.prompts import PromptLoader
 
 from .common import (
     add_system_status_message,
+    build_agent_system_prompt,
     create_base_agent,
     create_usage_limits,
-    ensure_file_exists,
-    get_file_history,
     run_agent,
 )
 from .models import AgentDeps, AgentRuntimeOptions
 
 logger = get_logger(__name__)
 
-# Global prompt loader instance
-prompt_loader = PromptLoader()
-
-
-def _build_tasks_agent_system_prompt(ctx: RunContext[AgentDeps]) -> str:
-    """Build the system prompt for the tasks agent.
-
-    Args:
-        ctx: RunContext containing AgentDeps with interactive_mode and other settings
-
-    Returns:
-        The complete system prompt string for the tasks agent
-    """
-    return prompt_loader.render(
-        "agents/tasks.j2",
-        interactive_mode=ctx.deps.interactive_mode,
-        context="task lists",
-    )
-
 
 def create_tasks_agent(
     agent_runtime_options: AgentRuntimeOptions, provider: ProviderType | None = None
@@ -57,8 +37,11 @@ def create_tasks_agent(
         Tuple of (Configured Pydantic AI agent for task management, Agent dependencies)
     """
     logger.debug("Initializing tasks agent")
+    # Use partial to create system prompt function for tasks agent
+    system_prompt_fn = partial(build_agent_system_prompt, "tasks")
+
     agent, deps = create_base_agent(
-        _build_tasks_agent_system_prompt, agent_runtime_options, provider=provider
+        system_prompt_fn, agent_runtime_options, provider=provider
     )
     return agent, deps
 
@@ -82,9 +65,6 @@ async def run_tasks_agent(
     """
     logger.debug("📋 Starting task creation for instruction: %s", instruction)
 
-    # Ensure tasks.md exists
-    ensure_file_exists("tasks.md", "# Tasks")
-
     message_history = await add_system_status_message(deps, message_history)
 
     # Let the agent use its tools to read existing tasks, plan, and research
@@ -111,12 +91,3 @@ async def run_tasks_agent(
         logger.error("Full traceback:\n%s", traceback.format_exc())
         logger.error("❌ Task creation failed: %s", str(e))
         raise
-
-
-def get_tasks_history() -> str:
-    """Get the full tasks history from the file.
-
-    Returns:
-        Tasks history content or fallback message
-    """
-    return get_file_history("tasks.md")