shotgun-sh 0.2.7.dev1__tar.gz → 0.2.8.dev1__tar.gz

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.7.dev1
+Version: 0.2.8.dev1
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun
@@ -34,7 +34,9 @@ Requires-Dist: pydantic-ai>=0.0.14
 Requires-Dist: rich>=13.0.0
 Requires-Dist: sentencepiece>=0.2.0
 Requires-Dist: sentry-sdk[pure-eval]>=2.0.0
+Requires-Dist: tenacity>=8.0.0
 Requires-Dist: textual-dev>=1.7.0
+Requires-Dist: textual-serve>=0.1.0
 Requires-Dist: textual>=6.1.0
 Requires-Dist: tiktoken>=0.7.0
 Requires-Dist: tree-sitter-go>=0.23.0

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/README.md

@@ -408,6 +408,82 @@ export SENTRY_DSN=your-sentry-dsn
 - **Opt-in for development**: Telemetry requires explicit environment variables
 - **Automatic in production**: Production builds include telemetry for error tracking
 
+## Docker
+
+Run Shotgun in a Docker container with web access.
+
+### Using Pre-built Images (Recommended)
+
+Pull the official image from GitHub Container Registry:
+
+```bash
+# Pull latest stable version
+docker pull ghcr.io/shotgun-sh/shotgun:latest
+
+# Or pull a specific version
+docker pull ghcr.io/shotgun-sh/shotgun:v0.1.0
+
+# Or pull development version
+docker pull ghcr.io/shotgun-sh/shotgun:dev
+```
+
+Then run:
+
+```bash
+docker run -p 8000:8000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+```
+
+### Building from Source (Optional)
+
+If you prefer to build the image yourself:
+
+```bash
+docker build -t shotgun:latest .
+```
+
+### Run the Container
+
+The container requires two volume mounts:
+1. Your codebase/workspace directory (mounted to `/workspace`)
+2. Config directory for API keys and settings (mounted to `/home/shotgun/.shotgun-sh`)
+
+```bash
+# Basic usage (serves on port 8000)
+docker run -p 8000:8000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+
+# Custom port
+docker run -p 3000:3000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check --port 3000
+
+# Different codebase directory
+docker run -p 8000:8000 \
+  -v /path/to/your/project:/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+
+# Run in background with auto-restart
+docker run -d --restart unless-stopped \
+  --name shotgun-web \
+  -p 8000:8000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+```
+
+### Configuration
+
+On first run, configure your API keys through the web UI. The configuration will persist in the mounted `~/.shotgun-sh` directory.
+
+Access the web interface at `http://localhost:8000` (or your custom port).
+
 ## Support
 
 Join our discord https://discord.gg/5RmY6J2N7s

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.2.7.dev1"
+version = "0.2.8.dev1"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README_PYPI.md"
 license = { text = "MIT" }
@@ -32,6 +32,7 @@ dependencies = [
     "posthog>=3.0.0",
     "textual>=6.1.0",
     "textual-dev>=1.7.0",
+    "textual-serve>=0.1.0",
     "kuzu>=0.7.0",
     "tree-sitter>=0.21.0",
     "tree-sitter-python>=0.23.0",
@@ -46,6 +47,7 @@ dependencies = [
     "sentencepiece>=0.2.0",
     "packaging>=23.0",
     "genai-prices>=0.0.27",
+    "tenacity>=8.0.0",
 ]
 
 [project.urls]

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/src/shotgun/agents/agent_manager.py

@@ -4,9 +4,17 @@ import json
 import logging
 from collections.abc import AsyncIterable, Sequence
 from dataclasses import dataclass, field, is_dataclass, replace
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
 import logfire
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception,
+    stop_after_attempt,
+    wait_exponential,
+)
 
 if TYPE_CHECKING:
     from shotgun.agents.conversation_history import ConversationState
@@ -55,6 +63,35 @@ from .tasks import create_tasks_agent
 logger = logging.getLogger(__name__)
 
 
+def _is_retryable_error(exception: BaseException) -> bool:
+    """Check if exception should trigger a retry.
+
+    Args:
+        exception: The exception to check.
+
+    Returns:
+        True if the exception is a transient error that should be retried.
+    """
+    # ValueError for truncated/incomplete JSON
+    if isinstance(exception, ValueError):
+        error_str = str(exception)
+        return "EOF while parsing" in error_str or (
+            "JSON" in error_str and "parsing" in error_str
+        )
+
+    # API errors (overload, rate limits)
+    exception_name = type(exception).__name__
+    if "APIStatusError" in exception_name:
+        error_str = str(exception)
+        return "overload" in error_str.lower() or "rate" in error_str.lower()
+
+    # Network errors
+    if "ConnectionError" in exception_name or "TimeoutError" in exception_name:
+        return True
+
+    return False
+
+
 class MessageHistoryUpdated(Message):
     """Event posted when the message history is updated."""
 
@@ -268,6 +305,49 @@ class AgentManager(Widget):
                 f"Invalid agent type: {agent_type}. Must be one of: {', '.join(e.value for e in AgentType)}"
             ) from None
 
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=8),
+        retry=retry_if_exception(_is_retryable_error),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+        reraise=True,
+    )
+    async def _run_agent_with_retry(
+        self,
+        agent: Agent[AgentDeps, AgentResponse],
+        prompt: str | None,
+        deps: AgentDeps,
+        usage_limits: UsageLimits | None,
+        message_history: list[ModelMessage],
+        event_stream_handler: Any,
+        **kwargs: Any,
+    ) -> AgentRunResult[AgentResponse]:
+        """Run agent with automatic retry on transient errors.
+
+        Args:
+            agent: The agent to run.
+            prompt: Optional prompt to send to the agent.
+            deps: Agent dependencies.
+            usage_limits: Optional usage limits.
+            message_history: Message history to provide to agent.
+            event_stream_handler: Event handler for streaming.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The agent run result.
+
+        Raises:
+            Various exceptions if all retries fail.
+        """
+        return await agent.run(
+            prompt,
+            deps=deps,
+            usage_limits=usage_limits,
+            message_history=message_history,
+            event_stream_handler=event_stream_handler,
+            **kwargs,
+        )
+
     async def run(
         self,
         prompt: str | None = None,
@@ -394,8 +474,9 @@ class AgentManager(Widget):
         )
 
         try:
-            result: AgentRunResult[AgentResponse] = await self.current_agent.run(
-                prompt,
+            result: AgentRunResult[AgentResponse] = await self._run_agent_with_retry(
+                agent=self.current_agent,
+                prompt=prompt,
                 deps=deps,
                 usage_limits=usage_limits,
                 message_history=message_history,
@@ -404,6 +485,36 @@ class AgentManager(Widget):
                 else None,
                 **kwargs,
             )
+        except ValueError as e:
+            # Handle truncated/incomplete JSON in tool calls specifically
+            error_str = str(e)
+            if "EOF while parsing" in error_str or (
+                "JSON" in error_str and "parsing" in error_str
+            ):
+                logger.error(
+                    "Tool call with truncated/incomplete JSON arguments detected",
+                    extra={
+                        "agent_mode": self._current_agent_type.value,
+                        "model_name": model_name,
+                        "error": error_str,
+                    },
+                )
+                logfire.error(
+                    "Tool call with truncated JSON arguments",
+                    agent_mode=self._current_agent_type.value,
+                    model_name=model_name,
+                    error=error_str,
+                )
+                # Add helpful hint message for the user
+                self.ui_message_history.append(
+                    HintMessage(
+                        message="⚠️ The agent attempted an operation with arguments that were too large (truncated JSON). "
+                        "Try breaking your request into smaller steps or more focused contracts."
+                    )
+                )
+                self._post_messages_updated()
+            # Re-raise to maintain error visibility
+            raise
         except Exception as e:
             # Log the error with full stack trace to shotgun.log and Logfire
             logger.exception(
@@ -427,13 +538,40 @@ class AgentManager(Widget):
 
         # Agent ALWAYS returns AgentResponse with structured output
         agent_response = result.output
-        logger.debug("Agent returned structured AgentResponse")
+        logger.debug(
+            "Agent returned structured AgentResponse",
+            extra={
+                "has_response": agent_response.response is not None,
+                "response_length": len(agent_response.response)
+                if agent_response.response
+                else 0,
+                "response_preview": agent_response.response[:100] + "..."
+                if agent_response.response and len(agent_response.response) > 100
+                else agent_response.response or "(empty)",
+                "has_clarifying_questions": bool(agent_response.clarifying_questions),
+                "num_clarifying_questions": len(agent_response.clarifying_questions)
+                if agent_response.clarifying_questions
+                else 0,
+            },
+        )
 
         # Always add the agent's response messages to maintain conversation history
         self.ui_message_history = original_messages + cast(
             list[ModelRequest | ModelResponse | HintMessage], result.new_messages()
         )
 
+        # Get file operations early so we can use them for contextual messages
+        file_operations = deps.file_tracker.operations.copy()
+        self.recently_change_files = file_operations
+
+        logger.debug(
+            "File operations tracked",
+            extra={
+                "num_file_operations": len(file_operations),
+                "operation_files": [Path(op.file_path).name for op in file_operations],
+            },
+        )
+
         # Check if there are clarifying questions
         if agent_response.clarifying_questions:
             logger.info(
@@ -480,12 +618,50 @@ class AgentManager(Widget):
                         response_text=agent_response.response,
                     )
                 )
+
+            # Post UI update with hint messages and file operations
+            logger.debug(
+                "Posting UI update for Q&A mode with hint messages and file operations"
+            )
+            self._post_messages_updated(file_operations)
         else:
-            # No clarifying questions - just show the response if present
+            # No clarifying questions - show the response or a default success message
             if agent_response.response and agent_response.response.strip():
+                logger.debug(
+                    "Adding agent response as hint",
+                    extra={
+                        "response_preview": agent_response.response[:100] + "..."
+                        if len(agent_response.response) > 100
+                        else agent_response.response,
+                        "has_file_operations": len(file_operations) > 0,
+                    },
+                )
                 self.ui_message_history.append(
                     HintMessage(message=agent_response.response)
                 )
+            else:
+                # Fallback: response is empty or whitespace
+                logger.debug(
+                    "Agent response was empty, using fallback completion message",
+                    extra={"has_file_operations": len(file_operations) > 0},
+                )
+                # Show contextual message based on whether files were modified
+                if file_operations:
+                    self.ui_message_history.append(
+                        HintMessage(
+                            message="✅ Task completed - files have been modified"
+                        )
+                    )
+                else:
+                    self.ui_message_history.append(
+                        HintMessage(message="✅ Task completed")
+                    )
+
+            # Post UI update immediately so user sees the response without delay
+            logger.debug(
+                "Posting immediate UI update with hint message and file operations"
+            )
+            self._post_messages_updated(file_operations)
 
         # Apply compaction to persistent message history to prevent cascading growth
         all_messages = result.all_messages()
@@ -517,16 +693,18 @@ class AgentManager(Widget):
             self.message_history = all_messages
 
         usage = result.usage()
-        deps.usage_manager.add_usage(
-            usage, model_name=deps.llm_model.name, provider=deps.llm_model.provider
-        )
-
-        # Log file operations summary if any files were modified
-        file_operations = deps.file_tracker.operations.copy()
-        self.recently_change_files = file_operations
+        if hasattr(deps, "llm_model") and deps.llm_model is not None:
+            deps.usage_manager.add_usage(
+                usage, model_name=deps.llm_model.name, provider=deps.llm_model.provider
+            )
+        else:
+            logger.warning(
+                "llm_model is None, skipping usage tracking",
+                extra={"agent_mode": self._current_agent_type.value},
+            )
 
-        # Post message history update (hints are now added synchronously above)
-        self._post_messages_updated(file_operations)
+        # UI updates are now posted immediately in each branch (Q&A or non-Q&A)
+        # before compaction, so no duplicate posting needed here
 
         return result
 

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/src/shotgun/agents/common.py

@@ -384,23 +384,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
 

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/src/shotgun/agents/tools/file_management.py

@@ -15,11 +15,18 @@ from shotgun.utils.file_system_utils import get_shotgun_base_path
 logger = get_logger(__name__)
 
 # Map agent modes to their allowed directories/files (in workflow order)
-AGENT_DIRECTORIES = {
-    AgentType.RESEARCH: "research.md",
-    AgentType.SPECIFY: "specification.md",
-    AgentType.PLAN: "plan.md",
-    AgentType.TASKS: "tasks.md",
+# Values can be:
+# - A Path: exact file (e.g., Path("research.md"))
+# - A list of Paths: multiple allowed files/directories (e.g., [Path("specification.md"), Path("contracts")])
+# - "*": any file except protected files (for export agent)
+AGENT_DIRECTORIES: dict[AgentType, str | Path | list[Path]] = {
+    AgentType.RESEARCH: Path("research.md"),
+    AgentType.SPECIFY: [
+        Path("specification.md"),
+        Path("contracts"),
+    ],  # Specify can write specs and contract files
+    AgentType.PLAN: Path("plan.md"),
+    AgentType.TASKS: Path("tasks.md"),
     AgentType.EXPORT: "*",  # Export agent can write anywhere except protected files
 }
 
@@ -60,13 +67,52 @@ def _validate_agent_scoped_path(filename: str, agent_mode: AgentType | None) ->
             # Allow writing anywhere else in .shotgun directory
             full_path = (base_path / filename).resolve()
         else:
-            # For other agents, only allow writing to their specific file
-            allowed_file = AGENT_DIRECTORIES[agent_mode]
-            if filename != allowed_file:
+            # For other agents, check if they have access to the requested file
+            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
+                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 if filename matches any allowed path
+            is_allowed = False
+            for allowed_path in allowed_paths:
+                allowed_str = str(allowed_path)
+
+                # Check if it's a directory (no .md extension or suffix)
+                # Directories: Path("contracts") has no suffix, files: Path("spec.md") has .md suffix
+                if not allowed_path.suffix or (
+                    allowed_path.suffix and not allowed_str.endswith(".md")
+                ):
+                    # Directory - allow any file within this directory
+                    # Check both "contracts/file.py" and "contracts" prefix
+                    if (
+                        filename.startswith(allowed_str + "/")
+                        or filename == allowed_str
+                    ):
+                        is_allowed = True
+                        break
+                else:
+                    # Exact file match
+                    if filename == allowed_str:
+                        is_allowed = True
+                        break
+
+            if not is_allowed:
+                allowed_display = ", ".join(f"'{p}'" for p in allowed_paths)
                 raise ValueError(
-                    f"{agent_mode.value.capitalize()} agent can only write to '{allowed_file}'. "
+                    f"{agent_mode.value.capitalize()} agent can only write to {allowed_display}. "
                     f"Attempted to write to '{filename}'"
                 )
+
             full_path = (base_path / filename).resolve()
     else:
         # No agent mode specified, fall back to old validation

{shotgun_sh-0.2.7.dev1 → shotgun_sh-0.2.8.dev1}/src/shotgun/main.py

@@ -125,6 +125,34 @@ def main(
             help="Continue previous TUI conversation",
         ),
     ] = False,
+    web: Annotated[
+        bool,
+        typer.Option(
+            "--web",
+            help="Serve TUI as web application",
+        ),
+    ] = False,
+    port: Annotated[
+        int,
+        typer.Option(
+            "--port",
+            help="Port for web server (only used with --web)",
+        ),
+    ] = 8000,
+    host: Annotated[
+        str,
+        typer.Option(
+            "--host",
+            help="Host address for web server (only used with --web)",
+        ),
+    ] = "localhost",
+    public_url: Annotated[
+        str | None,
+        typer.Option(
+            "--public-url",
+            help="Public URL if behind proxy (only used with --web)",
+        ),
+    ] = None,
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
@@ -134,16 +162,32 @@ def main(
         perform_auto_update_async(no_update_check=no_update_check)
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
-        logger.debug("Launching shotgun TUI application")
-        try:
-            tui_app.run(
-                no_update_check=no_update_check, continue_session=continue_session
-            )
-        finally:
-            # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
-            from shotgun.posthog_telemetry import shutdown
-
-            shutdown()
+        if web:
+            logger.debug("Launching shotgun TUI as web application")
+            try:
+                tui_app.serve(
+                    host=host,
+                    port=port,
+                    public_url=public_url,
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if server exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
+        else:
+            logger.debug("Launching shotgun TUI application")
+            try:
+                tui_app.run(
+                    no_update_check=no_update_check, continue_session=continue_session
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
         raise typer.Exit()
 
     # For CLI commands, register PostHog shutdown handler