shotgun-sh 0.1.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

shotgun/agents/common.py

@@ -1,14 +1,12 @@
 """Common utilities for agent creation and management."""
 
-import asyncio
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
+import aiofiles
 from pydantic_ai import (
     Agent,
-    DeferredToolRequests,
-    DeferredToolResults,
     RunContext,
     UsageLimits,
 )
@@ -18,21 +16,20 @@ from pydantic_ai.messages import (
     ModelRequest,
 )
 
-from shotgun.agents.config import ProviderType, get_config_manager, get_provider_model
-from shotgun.agents.models import AgentType
+from shotgun.agents.config import ProviderType, get_provider_model
+from shotgun.agents.models import AgentResponse, AgentType
 from shotgun.logging_config import get_logger
 from shotgun.prompts import PromptLoader
 from shotgun.sdk.services import get_codebase_service
 from shotgun.utils import ensure_shotgun_directory_exists
+from shotgun.utils.datetime_utils import get_datetime_context
 from shotgun.utils.file_system_utils import get_shotgun_base_path
 
 from .history import token_limit_compactor
-from .history.compaction import apply_persistent_compaction
 from .messages import AgentSystemPrompt, SystemStatusPrompt
 from .models import AgentDeps, AgentRuntimeOptions, PipelineConfigEntry
 from .tools import (
     append_file,
-    ask_user,
     codebase_shell,
     directory_lister,
     file_read,
@@ -72,7 +69,10 @@ async def add_system_status_message(
     existing_files = get_agent_existing_files(deps.agent_mode)
 
     # Extract table of contents from the agent's markdown file
-    markdown_toc = extract_markdown_toc(deps.agent_mode)
+    markdown_toc = await extract_markdown_toc(deps.agent_mode)
+
+    # Get current datetime with timezone information
+    dt_context = get_datetime_context()
 
     system_state = prompt_loader.render(
         "agents/state/system_state.j2",
@@ -80,6 +80,9 @@ async def add_system_status_message(
         is_tui_context=deps.is_tui_context,
         existing_files=existing_files,
         markdown_toc=markdown_toc,
+        current_datetime=dt_context.datetime_formatted,
+        timezone_name=dt_context.timezone_name,
+        utc_offset=dt_context.utc_offset,
     )
 
     message_history.append(
@@ -92,14 +95,14 @@ async def add_system_status_message(
     return message_history
 
 
-def create_base_agent(
+async def create_base_agent(
     system_prompt_fn: Callable[[RunContext[AgentDeps]], str],
     agent_runtime_options: AgentRuntimeOptions,
     load_codebase_understanding_tools: bool = True,
     additional_tools: list[Any] | None = None,
     provider: ProviderType | None = None,
     agent_mode: AgentType | None = None,
-) -> tuple[Agent[AgentDeps, str | DeferredToolRequests], AgentDeps]:
+) -> tuple[Agent[AgentDeps, AgentResponse], AgentDeps]:
     """Create a base agent with common configuration.
 
     Args:
@@ -115,14 +118,13 @@ def create_base_agent(
     """
     ensure_shotgun_directory_exists()
 
-    # Get configured model or fall back to hardcoded default
+    # Get configured model or fall back to first available provider
     try:
-        model_config = get_provider_model(provider)
-        config_manager = get_config_manager()
-        provider_name = provider or config_manager.load().default_provider
+        model_config = await get_provider_model(provider)
+        provider_name = model_config.provider
         logger.debug(
             "🤖 Creating agent with configured %s model: %s",
-            provider_name.upper(),
+            provider_name.value.upper(),
             model_config.name,
         )
         # Use the Model instance directly (has API key baked in)
@@ -158,7 +160,7 @@ def create_base_agent(
 
     agent = Agent(
         model,
-        output_type=[str, DeferredToolRequests],
+        output_type=AgentResponse,
         deps_type=AgentDeps,
         instrument=True,
         history_processors=[history_processor],
@@ -173,11 +175,6 @@ def create_base_agent(
     for tool in additional_tools or []:
         agent.tool_plain(tool)
 
-    # Register interactive tool conditionally based on deps
-    if deps.interactive_mode:
-        agent.tool(ask_user)
-        logger.debug("📞 Interactive mode enabled - ask_user tool registered")
-
     # Register common file management tools (always available)
     agent.tool(write_file)
     agent.tool(append_file)
@@ -198,7 +195,7 @@ def create_base_agent(
     return agent, deps
 
 
-def _extract_file_toc_content(
+async def _extract_file_toc_content(
     file_path: Path, max_depth: int | None = None, max_chars: int = 500
 ) -> str | None:
     """Extract TOC from a single file with depth and character limits.
@@ -215,7 +212,8 @@ def _extract_file_toc_content(
         return None
 
     try:
-        content = file_path.read_text(encoding="utf-8")
+        async with aiofiles.open(file_path, encoding="utf-8") as f:
+            content = await f.read()
         lines = content.split("\n")
 
         # Extract headings
@@ -261,7 +259,7 @@ def _extract_file_toc_content(
         return None
 
 
-def extract_markdown_toc(agent_mode: AgentType | None) -> str | None:
+async def extract_markdown_toc(agent_mode: AgentType | None) -> str | None:
     """Extract TOCs from current and prior agents' files in the pipeline.
 
     Shows full TOC of agent's own file and high-level summaries of prior agents'
@@ -313,22 +311,30 @@ def extract_markdown_toc(agent_mode: AgentType | None) -> str | None:
     for prior_file in config.prior_files:
         file_path = base_path / prior_file
         # Only show # and ## headings from prior files, max 500 chars each
-        prior_toc = _extract_file_toc_content(file_path, max_depth=2, max_chars=500)
+        prior_toc = await _extract_file_toc_content(
+            file_path, max_depth=2, max_chars=500
+        )
         if prior_toc:
             # Add section with XML tags
             toc_sections.append(
-                f'<TABLE_OF_CONTENTS file_name="{prior_file}">\n{prior_toc}\n</TABLE_OF_CONTENTS>'
+                f'<TABLE_OF_CONTENTS file_name="{prior_file}">\n'
+                f"{prior_toc}\n"
+                f"</TABLE_OF_CONTENTS>"
             )
 
     # Extract TOC from own file (full detail)
     if config.own_file:
         own_path = base_path / config.own_file
-        own_toc = _extract_file_toc_content(own_path, max_depth=None, max_chars=2000)
+        own_toc = await _extract_file_toc_content(
+            own_path, max_depth=None, max_chars=2000
+        )
         if own_toc:
             # Put own file TOC at the beginning with XML tags
             toc_sections.insert(
                 0,
-                f'<TABLE_OF_CONTENTS file_name="{config.own_file}">\n{own_toc}\n</TABLE_OF_CONTENTS>',
+                f'<TABLE_OF_CONTENTS file_name="{config.own_file}">\n'
+                f"{own_toc}\n"
+                f"</TABLE_OF_CONTENTS>",
             )
 
     # Combine all sections
@@ -384,23 +390,48 @@ def get_agent_existing_files(agent_mode: AgentType | None = None) -> list[str]:
                     relative_path = file_path.relative_to(base_path)
                     existing_files.append(str(relative_path))
     else:
-        # For other agents, check both .md file and directory with same name
-        allowed_file = AGENT_DIRECTORIES[agent_mode]
-
-        # Check for the .md file
-        md_file_path = base_path / allowed_file
-        if md_file_path.exists():
-            existing_files.append(allowed_file)
-
-        # Check for directory with same base name (e.g., research/ for research.md)
-        base_name = allowed_file.replace(".md", "")
-        dir_path = base_path / base_name
-        if dir_path.exists() and dir_path.is_dir():
-            # List all files in the directory
-            for file_path in dir_path.rglob("*"):
-                if file_path.is_file():
-                    relative_path = file_path.relative_to(base_path)
-                    existing_files.append(str(relative_path))
+        # For other agents, check files/directories they have access to
+        allowed_paths_raw = AGENT_DIRECTORIES[agent_mode]
+
+        # Convert single Path/string to list of Paths for uniform handling
+        if isinstance(allowed_paths_raw, str):
+            # Special case: "*" means export agent (shouldn't reach here but handle it)
+            allowed_paths = (
+                [Path(allowed_paths_raw)] if allowed_paths_raw != "*" else []
+            )
+        elif isinstance(allowed_paths_raw, Path):
+            allowed_paths = [allowed_paths_raw]
+        else:
+            # Already a list
+            allowed_paths = allowed_paths_raw
+
+        # Check each allowed path
+        for allowed_path in allowed_paths:
+            allowed_str = str(allowed_path)
+
+            # Check if it's a directory (no .md suffix)
+            if not allowed_path.suffix or not allowed_str.endswith(".md"):
+                # It's a directory - list all files within it
+                dir_path = base_path / allowed_str
+                if dir_path.exists() and dir_path.is_dir():
+                    for file_path in dir_path.rglob("*"):
+                        if file_path.is_file():
+                            relative_path = file_path.relative_to(base_path)
+                            existing_files.append(str(relative_path))
+            else:
+                # It's a file - check if it exists
+                file_path = base_path / allowed_str
+                if file_path.exists():
+                    existing_files.append(allowed_str)
+
+                # Also check for associated directory (e.g., research/ for research.md)
+                base_name = allowed_str.replace(".md", "")
+                dir_path = base_path / base_name
+                if dir_path.exists() and dir_path.is_dir():
+                    for file_path in dir_path.rglob("*"):
+                        if file_path.is_file():
+                            relative_path = file_path.relative_to(base_path)
+                            existing_files.append(str(relative_path))
 
     return existing_files
 
@@ -470,7 +501,8 @@ async def add_system_prompt_message(
     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
+    # 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}
     )()
@@ -494,12 +526,12 @@ async def add_system_prompt_message(
 
 
 async def run_agent(
-    agent: Agent[AgentDeps, str | DeferredToolRequests],
+    agent: Agent[AgentDeps, AgentResponse],
     prompt: str,
     deps: AgentDeps,
     message_history: list[ModelMessage] | None = None,
     usage_limits: UsageLimits | None = None,
-) -> AgentRunResult[str | DeferredToolRequests]:
+) -> AgentRunResult[AgentResponse]:
     # Clear file tracker for new run
     deps.file_tracker.clear()
     logger.debug("🔧 Cleared file tracker for new agent run")
@@ -514,33 +546,6 @@ async def run_agent(
         message_history=message_history,
     )
 
-    # 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()
-        requests = result.output
-        done, _ = await asyncio.wait(deps.tasks)
-
-        task_results = [task.result() for task in done]
-        task_results_by_tool_call_id = {
-            result.tool_call_id: result.answer for result in task_results
-        }
-        logger.info("got task results", task_results_by_tool_call_id)
-        results = DeferredToolResults()
-        for call in requests.calls:
-            results.calls[call.tool_call_id] = task_results_by_tool_call_id[
-                call.tool_call_id
-            ]
-        result = await agent.run(
-            deps=deps,
-            usage_limits=usage_limits,
-            message_history=messages,
-            deferred_tool_results=results,
-        )
-        # 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()

shotgun/agents/config/constants.py

@@ -1,17 +1,28 @@
 """Configuration constants for Shotgun agents."""
 
+from enum import StrEnum, auto
+
 # Field names
 API_KEY_FIELD = "api_key"
-DEFAULT_PROVIDER_FIELD = "default_provider"
-USER_ID_FIELD = "user_id"
+SUPABASE_JWT_FIELD = "supabase_jwt"
+SHOTGUN_INSTANCE_ID_FIELD = "shotgun_instance_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"
+class ConfigSection(StrEnum):
+    """Configuration file section names (JSON keys)."""
+
+    OPENAI = auto()
+    ANTHROPIC = auto()
+    GOOGLE = auto()
+    SHOTGUN = auto()
+
+
+# Backwards compatibility - deprecated
+OPENAI_PROVIDER = ConfigSection.OPENAI.value
+ANTHROPIC_PROVIDER = ConfigSection.ANTHROPIC.value
+GOOGLE_PROVIDER = ConfigSection.GOOGLE.value
+SHOTGUN_PROVIDER = ConfigSection.SHOTGUN.value
+
+# Token limits
+MEDIUM_TEXT_8K_TOKENS = 8192  # Default max_tokens for web search requests