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

shotgun/agents/models.py

@@ -2,6 +2,8 @@
 
 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
 
@@ -11,6 +13,7 @@ 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
 
 
@@ -74,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."""
 
@@ -85,16 +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/tools/artifact_management.py

@@ -4,25 +4,17 @@ These tools provide agents with the ability to create and manage structured
 artifacts instead of flat markdown files.
 """
 
-from shotgun.artifacts.service import ArtifactService
+from pydantic_ai import RunContext
+
+from shotgun.agents.models import AgentDeps
 from shotgun.artifacts.utils import handle_agent_mode_parsing
 from shotgun.logging_config import setup_logger
 
 logger = setup_logger(__name__)
 
-# Global artifact service instance
-_artifact_service: ArtifactService | None = None
-
-
-def get_artifact_service() -> ArtifactService:
-    """Get or create the global artifact service instance."""
-    global _artifact_service
-    if _artifact_service is None:
-        _artifact_service = ArtifactService()
-    return _artifact_service
-
 
-def create_artifact(
+async def create_artifact(
+    ctx: RunContext[AgentDeps],
     artifact_id: str,
     agent_mode: str,
     name: str,
@@ -31,6 +23,7 @@ def create_artifact(
     """Create a new artifact.
 
     Args:
+        ctx: RunContext containing AgentDeps with artifact service
         artifact_id: Unique identifier for the artifact (slug format)
         agent_mode: Agent mode (research, plan, tasks)
         name: Human-readable name for the artifact
@@ -55,12 +48,21 @@ def create_artifact(
         return "Error: Invalid agent mode"
 
     try:
-        service = get_artifact_service()
+        service = ctx.deps.artifact_service
 
         # Pass template_id if provided and not empty
         template_to_use = template_id.strip() if template_id.strip() else None
         artifact = service.create_artifact(artifact_id, mode, name, template_to_use)
 
+        # Track the artifact file creation
+        from shotgun.agents.models import FileOperationType
+        from shotgun.utils.file_system_utils import get_shotgun_base_path
+
+        artifact_path = (
+            get_shotgun_base_path() / mode.value / artifact_id / "artifact.yaml"
+        )
+        ctx.deps.file_tracker.add_operation(artifact_path, FileOperationType.CREATED)
+
         success_msg = (
             f"Created artifact '{artifact_id}' in {agent_mode} mode with name '{name}'"
         )
@@ -110,10 +112,15 @@ def create_artifact(
         return f"Error: {error_msg}"
 
 
-def read_artifact(artifact_id: str, agent_mode: str) -> str:
+async def read_artifact(
+    ctx: RunContext[AgentDeps],
+    artifact_id: str,
+    agent_mode: str,
+) -> str:
     """Read all sections of an artifact.
 
     Args:
+        ctx: RunContext containing AgentDeps with artifact service
         artifact_id: Artifact identifier
         agent_mode: Agent mode (research, plan, tasks)
 
@@ -135,7 +142,7 @@ def read_artifact(artifact_id: str, agent_mode: str) -> str:
         return "Error: Invalid agent mode"
 
     try:
-        service = get_artifact_service()
+        service = ctx.deps.artifact_service
         artifact = service.get_artifact(artifact_id, mode, "")
 
         if not artifact.sections:
@@ -207,7 +214,8 @@ def read_artifact(artifact_id: str, agent_mode: str) -> str:
         return f"Error: {error_msg}"
 
 
-def write_artifact_section(
+async def write_artifact_section(
+    ctx: RunContext[AgentDeps],
     artifact_id: str,
     agent_mode: str,
     section_number: int,
@@ -220,6 +228,7 @@ def write_artifact_section(
     Creates the artifact and/or section if they don't exist.
 
     Args:
+        ctx: RunContext containing AgentDeps with artifact service
         artifact_id: Artifact identifier
         agent_mode: Agent mode (research, plan, tasks)
         section_number: Section number (1, 2, 3, etc.)
@@ -251,13 +260,26 @@ def write_artifact_section(
         return "Error: Agent mode validation failed"
 
     try:
-        service = get_artifact_service()
+        service = ctx.deps.artifact_service
 
         # Get or create the section
         section, created = service.get_or_create_section(
             artifact_id, mode, section_number, section_slug, section_title, content
         )
 
+        # Track the section file operation
+        from shotgun.agents.models import FileOperationType
+        from shotgun.utils.file_system_utils import get_shotgun_base_path
+
+        section_path = (
+            get_shotgun_base_path()
+            / mode.value
+            / artifact_id
+            / f"{section_number:02d}_{section_slug}.md"
+        )
+        operation = FileOperationType.CREATED if created else FileOperationType.UPDATED
+        ctx.deps.file_tracker.add_operation(section_path, operation)
+
         if created:
             success_msg = (
                 f"Created section {section_number} '{section_title}' "
@@ -283,7 +305,8 @@ def write_artifact_section(
         return f"Error: {error_msg}"
 
 
-def read_artifact_section(
+async def read_artifact_section(
+    ctx: RunContext[AgentDeps],
     artifact_id: str,
     agent_mode: str,
     section_number: int,
@@ -291,6 +314,7 @@ def read_artifact_section(
     """Read content from a specific section of an artifact.
 
     Args:
+        ctx: RunContext containing AgentDeps with artifact service
         artifact_id: Artifact identifier
         agent_mode: Agent mode (research, plan, tasks)
         section_number: Section number
@@ -319,7 +343,7 @@ def read_artifact_section(
         return "Error: Agent mode validation failed"
 
     try:
-        service = get_artifact_service()
+        service = ctx.deps.artifact_service
 
         section = service.get_section(artifact_id, mode, section_number)
 
@@ -341,10 +365,14 @@ def read_artifact_section(
         return f"Error: {error_msg}"
 
 
-def list_artifacts(agent_mode: str | None = None) -> str:
+async def list_artifacts(
+    ctx: RunContext[AgentDeps],
+    agent_mode: str | None = None,
+) -> str:
     """List all artifacts, optionally filtered by agent mode.
 
     Args:
+        ctx: RunContext containing AgentDeps with artifact service
         agent_mode: Optional agent mode filter (research, plan, tasks)
 
     Returns:
@@ -357,7 +385,7 @@ def list_artifacts(agent_mode: str | None = None) -> str:
     logger.debug("🔧 Listing artifacts for mode: %s", agent_mode or "all")
 
     try:
-        service = get_artifact_service()
+        service = ctx.deps.artifact_service
 
         mode = None
         if agent_mode:
@@ -399,10 +427,14 @@ def list_artifacts(agent_mode: str | None = None) -> str:
         return f"Error: {error_msg}"
 
 
-def list_artifact_templates(agent_mode: str | None = None) -> str:
+async def list_artifact_templates(
+    ctx: RunContext[AgentDeps],
+    agent_mode: str | None = None,
+) -> str:
     """List available artifact templates, optionally filtered by agent mode.
 
     Args:
+        ctx: RunContext containing AgentDeps with artifact service
         agent_mode: Optional agent mode filter (research, plan, tasks)
 
     Returns:
@@ -415,7 +447,7 @@ def list_artifact_templates(agent_mode: str | None = None) -> str:
     logger.debug("🔧 Listing templates for mode: %s", agent_mode or "all")
 
     try:
-        service = get_artifact_service()
+        service = ctx.deps.artifact_service
 
         mode = None
         if agent_mode:

shotgun/agents/tools/file_management.py

@@ -6,16 +6,15 @@ These tools are restricted to the .shotgun directory for security.
 from pathlib import Path
 from typing import Literal
 
+from pydantic_ai import RunContext
+
+from shotgun.agents.models import AgentDeps, FileOperationType
 from shotgun.logging_config import get_logger
+from shotgun.utils.file_system_utils import get_shotgun_base_path
 
 logger = get_logger(__name__)
 
 
-def get_shotgun_base_path() -> Path:
-    """Get the absolute path to the .shotgun directory."""
-    return Path.cwd() / ".shotgun"
-
-
 def _validate_shotgun_path(filename: str) -> Path:
     """Validate and resolve a file path within the .shotgun directory.
 
@@ -44,7 +43,7 @@ def _validate_shotgun_path(filename: str) -> Path:
     return full_path
 
 
-def read_file(filename: str) -> str:
+async def read_file(ctx: RunContext[AgentDeps], filename: str) -> str:
     """Read a file from the .shotgun directory.
 
     Args:
@@ -75,7 +74,12 @@ def read_file(filename: str) -> str:
         return error_msg
 
 
-def write_file(filename: str, content: str, mode: Literal["w", "a"] = "w") -> str:
+async def write_file(
+    ctx: RunContext[AgentDeps],
+    filename: str,
+    content: str,
+    mode: Literal["w", "a"] = "w",
+) -> str:
     """Write content to a file in the .shotgun directory.
 
     Args:
@@ -97,6 +101,16 @@ def write_file(filename: str, content: str, mode: Literal["w", "a"] = "w") -> st
     try:
         file_path = _validate_shotgun_path(filename)
 
+        # Determine operation type
+        if mode == "a":
+            operation = FileOperationType.UPDATED
+        else:
+            operation = (
+                FileOperationType.CREATED
+                if not file_path.exists()
+                else FileOperationType.UPDATED
+            )
+
         # Ensure parent directory exists
         file_path.parent.mkdir(parents=True, exist_ok=True)
 
@@ -105,11 +119,16 @@ def write_file(filename: str, content: str, mode: Literal["w", "a"] = "w") -> st
             with open(file_path, "a", encoding="utf-8") as f:
                 f.write(content)
             logger.debug("📄 Appended %d characters to %s", len(content), filename)
-            return f"Successfully appended {len(content)} characters to {filename}"
+            result = f"Successfully appended {len(content)} characters to {filename}"
         else:
             file_path.write_text(content, encoding="utf-8")
             logger.debug("📄 Wrote %d characters to %s", len(content), filename)
-            return f"Successfully wrote {len(content)} characters to {filename}"
+            result = f"Successfully wrote {len(content)} characters to {filename}"
+
+        # Track the file operation
+        ctx.deps.file_tracker.add_operation(file_path, operation)
+
+        return result
 
     except Exception as e:
         error_msg = f"Error writing file '{filename}': {str(e)}"
@@ -117,7 +136,7 @@ def write_file(filename: str, content: str, mode: Literal["w", "a"] = "w") -> st
         return error_msg
 
 
-def append_file(filename: str, content: str) -> str:
+async def append_file(ctx: RunContext[AgentDeps], filename: str, content: str) -> str:
     """Append content to a file in the .shotgun directory.
 
     Args:
@@ -127,4 +146,4 @@ def append_file(filename: str, content: str) -> str:
     Returns:
         Success message or error message
     """
-    return write_file(filename, content, mode="a")
+    return await write_file(ctx, filename, content, mode="a")

shotgun/agents/tools/web_search/anthropic.py

@@ -11,10 +11,10 @@ logger = get_logger(__name__)
 
 
 def anthropic_web_search_tool(query: str) -> str:
-    """Perform a web search using Anthropic's Claude API.
+    """Perform a web search using Anthropic's Claude API with streaming.
 
     This tool uses Anthropic's web search capabilities to find current information
-    about the given query.
+    about the given query. Results are streamed for faster response times.
 
     Args:
         query: The search query
@@ -27,7 +27,7 @@ def anthropic_web_search_tool(query: str) -> str:
     span = trace.get_current_span()
     span.set_attribute("input.value", f"**Query:** {query}\n")
 
-    logger.debug("📡 Executing Anthropic web search with prompt: %s", query)
+    logger.debug("📡 Executing Anthropic web search with streaming prompt: %s", query)
 
     # Get API key from centralized configuration
     try:
@@ -41,11 +41,13 @@ def anthropic_web_search_tool(query: str) -> str:
 
     client = anthropic.Anthropic(api_key=api_key)
 
-    # Use the Messages API with web search tool
+    # Use the Messages API with web search tool and streaming
     try:
-        response = client.messages.create(
+        result_text = ""
+
+        with client.messages.stream(
             model="claude-3-5-sonnet-latest",
-            max_tokens=8192,  # Increased from 4096 for more comprehensive results
+            max_tokens=8192,  # Maximum for Claude 3.5 Sonnet
             messages=[{"role": "user", "content": f"Search for: {query}"}],
             tools=[
                 {
@@ -54,17 +56,17 @@ def anthropic_web_search_tool(query: str) -> str:
                 }
             ],
             tool_choice={"type": "tool", "name": "web_search"},
-        )
-
-        # Extract the search results from the response
-        result_text = ""
-        if hasattr(response, "content") and response.content:
-            for content in response.content:
-                if hasattr(content, "text"):
-                    result_text += content.text
-                elif hasattr(content, "tool_use") and content.tool_use:
-                    # Handle tool use response
-                    result_text += f"Search performed for: {query}\n"
+        ) as stream:
+            logger.debug("🌊 Started streaming Anthropic web search response")
+
+            for event in stream:
+                if event.type == "content_block_delta":
+                    if hasattr(event.delta, "text"):
+                        result_text += event.delta.text
+                elif event.type == "message_start":
+                    logger.debug("🚀 Streaming started")
+                elif event.type == "message_stop":
+                    logger.debug("✅ Streaming completed")
 
         if not result_text:
             result_text = "No content returned from search"
@@ -84,3 +86,62 @@ def anthropic_web_search_tool(query: str) -> str:
         logger.debug("💥 Full error details: %s", error_msg)
         span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
         return error_msg
+
+
+def main() -> None:
+    """Main function for testing the Anthropic web search tool."""
+    import logging
+    import os
+    import sys
+
+    # Set up basic console logging for testing
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+        stream=sys.stdout,
+    )
+
+    if len(sys.argv) < 2:
+        print(
+            "Usage: python -m shotgun.agents.tools.web_search.anthropic <search_query>"
+        )
+        print(
+            "Example: python -m shotgun.agents.tools.web_search.anthropic 'latest Python updates'"
+        )
+        sys.exit(1)
+
+    # Join all arguments as the search query
+    query = " ".join(sys.argv[1:])
+
+    print("🔍 Testing Anthropic Web Search with streaming")
+    print(f"📝 Query: {query}")
+    print("=" * 60)
+
+    # Check if API key is available
+    if not (
+        os.getenv("ANTHROPIC_API_KEY")
+        or (
+            callable(get_provider_model)
+            and get_provider_model(ProviderType.ANTHROPIC).api_key
+        )
+    ):
+        print("❌ Error: ANTHROPIC_API_KEY environment variable not set")
+        print("   Please set it with: export ANTHROPIC_API_KEY=your_key_here")
+        sys.exit(1)
+
+    try:
+        result = anthropic_web_search_tool(query)
+        print(f"✅ Search completed! Result length: {len(result)} characters")
+        print("=" * 60)
+        print("📄 RESULTS:")
+        print("=" * 60)
+        print(result)
+    except KeyboardInterrupt:
+        print("\n⏹️  Search interrupted by user")
+    except Exception as e:
+        print(f"❌ Error during search: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

shotgun/agents/tools/web_search/gemini.py

@@ -62,7 +62,7 @@ Instructions:
             search_prompt,
             generation_config=genai.GenerationConfig(  # type: ignore[attr-defined]
                 temperature=0.3,
-                max_output_tokens=8192,  # Explicit limit for comprehensive results
+                max_output_tokens=8192,
             ),
         )
 

shotgun/agents/tools/web_search/openai.py

@@ -40,17 +40,31 @@ def openai_web_search_tool(query: str) -> str:
             span.set_attribute("output.value", f"**Error:**\n {error_msg}\n")
             return error_msg
 
+        prompt = f"""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.
+"""
+
         client = OpenAI(api_key=api_key)
         response = client.responses.create(  # type: ignore[call-overload]
             model="gpt-5-mini",
             input=[
-                {"role": "user", "content": [{"type": "input_text", "text": query}]}
+                {"role": "user", "content": [{"type": "input_text", "text": prompt}]}
             ],
             text={
                 "format": {"type": "text"},
                 "verbosity": "high",
             },  # Increased from medium
-            reasoning={"effort": "high", "summary": "auto"},  # Increased from medium
+            reasoning={"effort": "medium", "summary": "auto"},
             tools=[
                 {
                     "type": "web_search",

shotgun/artifacts/manager.py

@@ -7,6 +7,7 @@ from typing import Any
 import yaml
 
 from shotgun.logging_config import setup_logger
+from shotgun.utils.file_system_utils import get_shotgun_base_path
 
 from .exceptions import (
     ArtifactFileSystemError,
@@ -32,7 +33,7 @@ class ArtifactManager:
             base_path: Base path for artifacts. Defaults to .shotgun in current directory.
         """
         if base_path is None:
-            base_path = Path.cwd() / ".shotgun"
+            base_path = get_shotgun_base_path()
         elif isinstance(base_path, str):
             base_path = Path(base_path)