shotgun-sh 0.2.6.dev5__tar.gz → 0.2.7.dev1__tar.gz

shotgun_sh-0.2.7.dev1/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: shotgun-sh
+Version: 0.2.7.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
+Project-URL: Issues, https://github.com/shotgun-sh/shotgun-alpha/issues
+Project-URL: Discord, https://discord.gg/5RmY6J2N7s
+Author-email: "Proofs.io" <hello@proofs.io>
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,cli,llm,planning,productivity,pydantic-ai,research,task-management
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.39.0
+Requires-Dist: genai-prices>=0.0.27
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: kuzu>=0.7.0
+Requires-Dist: logfire[pydantic-ai]>=2.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: packaging>=23.0
+Requires-Dist: posthog>=3.0.0
+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: textual-dev>=1.7.0
+Requires-Dist: textual>=6.1.0
+Requires-Dist: tiktoken>=0.7.0
+Requires-Dist: tree-sitter-go>=0.23.0
+Requires-Dist: tree-sitter-javascript>=0.23.0
+Requires-Dist: tree-sitter-python>=0.23.0
+Requires-Dist: tree-sitter-rust>=0.23.0
+Requires-Dist: tree-sitter-typescript>=0.23.0
+Requires-Dist: tree-sitter>=0.21.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: watchdog>=4.0.0
+Provides-Extra: dev
+Requires-Dist: commitizen>=3.13.0; extra == 'dev'
+Requires-Dist: lefthook>=1.12.0; extra == 'dev'
+Requires-Dist: mypy>=1.11.0; extra == 'dev'
+Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Shotgun
+
+**Spec-Driven Development for AI Code Generation**
+
+Shotgun is a CLI tool that turns work with AI code-gen tools from "I want to build X" into: **research → specs → plans → tasks → implementation**. It reads your entire codebase, coordinates AI agents to do the heavy lifting, and exports clean artifacts in the agents.md format so your code-gen tools actually know what they're building.
+
+🌐 **Learn more at [shotgun.sh](https://shotgun.sh/)**
+
+## Features
+
+### 📊 Complete Codebase Understanding
+
+Before writing a single line, Shotgun reads all of it. Your patterns. Your dependencies. Your technical debt. Whether you're adding features, onboarding devs, planning migrations, or refactoring - Shotgun knows what you're working with.
+
+### 🔄 Five Modes. One Journey. Zero Gaps.
+
+**Research** (what exists) → **Specify** (what to build) → **Plan** (how to build) → **Tasks** (break it down) → **Export** (to any tool)
+
+Not another chatbot. A complete workflow where each mode feeds the next.
+
+### ➡️ Export to agents.md
+
+Outputs plug into many code-generation tools including Codex, Cursor, Warp, Devin, opencode, Jules, and more.
+
+### 📝 Specs That Don't Die in Slack
+
+Every research finding, every architectural decision, every "here's why we didn't use that library" - captured as markdown in your repo. Version controlled. Searchable.
+
+## Installation
+
+### Using pipx (Recommended)
+
+```bash
+pipx install shotgun-sh
+```
+
+**Why pipx?** It installs Shotgun in an isolated environment, preventing dependency conflicts with your other Python projects.
+
+### Using pip
+
+```bash
+pip install shotgun-sh
+```
+
+## Quick Start
+
+```bash
+# Research your codebase or a topic
+shotgun research "What is our authentication flow?"
+
+# Generate specifications
+shotgun spec "Add OAuth2 authentication"
+
+# Create an implementation plan
+shotgun plan "Build user dashboard"
+
+# Break down into tasks
+shotgun tasks "Implement payment system"
+
+# Export to agents.md format for your code-gen tools
+shotgun export
+```
+
+## Support
+
+Have questions? Join our community on **[Discord](https://discord.gg/5RmY6J2N7s)**
+
+---
+
+**License:** MIT
+**Python:** 3.11+

shotgun_sh-0.2.7.dev1/README_PYPI.md

@@ -0,0 +1,71 @@
+# Shotgun
+
+**Spec-Driven Development for AI Code Generation**
+
+Shotgun is a CLI tool that turns work with AI code-gen tools from "I want to build X" into: **research → specs → plans → tasks → implementation**. It reads your entire codebase, coordinates AI agents to do the heavy lifting, and exports clean artifacts in the agents.md format so your code-gen tools actually know what they're building.
+
+🌐 **Learn more at [shotgun.sh](https://shotgun.sh/)**
+
+## Features
+
+### 📊 Complete Codebase Understanding
+
+Before writing a single line, Shotgun reads all of it. Your patterns. Your dependencies. Your technical debt. Whether you're adding features, onboarding devs, planning migrations, or refactoring - Shotgun knows what you're working with.
+
+### 🔄 Five Modes. One Journey. Zero Gaps.
+
+**Research** (what exists) → **Specify** (what to build) → **Plan** (how to build) → **Tasks** (break it down) → **Export** (to any tool)
+
+Not another chatbot. A complete workflow where each mode feeds the next.
+
+### ➡️ Export to agents.md
+
+Outputs plug into many code-generation tools including Codex, Cursor, Warp, Devin, opencode, Jules, and more.
+
+### 📝 Specs That Don't Die in Slack
+
+Every research finding, every architectural decision, every "here's why we didn't use that library" - captured as markdown in your repo. Version controlled. Searchable.
+
+## Installation
+
+### Using pipx (Recommended)
+
+```bash
+pipx install shotgun-sh
+```
+
+**Why pipx?** It installs Shotgun in an isolated environment, preventing dependency conflicts with your other Python projects.
+
+### Using pip
+
+```bash
+pip install shotgun-sh
+```
+
+## Quick Start
+
+```bash
+# Research your codebase or a topic
+shotgun research "What is our authentication flow?"
+
+# Generate specifications
+shotgun spec "Add OAuth2 authentication"
+
+# Create an implementation plan
+shotgun plan "Build user dashboard"
+
+# Break down into tasks
+shotgun tasks "Implement payment system"
+
+# Export to agents.md format for your code-gen tools
+shotgun export
+```
+
+## Support
+
+Have questions? Join our community on **[Discord](https://discord.gg/5RmY6J2N7s)**
+
+---
+
+**License:** MIT
+**Python:** 3.11+

{shotgun_sh-0.2.6.dev5 → shotgun_sh-0.2.7.dev1}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "shotgun-sh"
-version = "0.2.6.dev5"
+version = "0.2.7.dev1"
 description = "AI-powered research, planning, and task management CLI tool"
-readme = "README.md"
+readme = "README_PYPI.md"
 license = { text = "MIT" }
 authors = [
     { name = "Proofs.io", email = "hello@proofs.io" }
@@ -76,6 +76,7 @@ packages = ["src/shotgun"]
 include = [
     "/src",
     "/README.md",
+    "/README_PYPI.md",
     "/LICENSE",
     "/pyproject.toml"
 ]

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

@@ -1,10 +1,13 @@
 """Agent manager for coordinating multiple AI agents with shared message history."""
 
+import json
 import logging
 from collections.abc import AsyncIterable, Sequence
 from dataclasses import dataclass, field, is_dataclass, replace
 from typing import TYPE_CHECKING, Any, cast
 
+import logfire
+
 if TYPE_CHECKING:
     from shotgun.agents.conversation_history import ConversationState
 
@@ -401,6 +404,24 @@ class AgentManager(Widget):
                 else None,
                 **kwargs,
             )
+        except Exception as e:
+            # Log the error with full stack trace to shotgun.log and Logfire
+            logger.exception(
+                "Agent execution failed",
+                extra={
+                    "agent_mode": self._current_agent_type.value,
+                    "model_name": model_name,
+                    "error_type": type(e).__name__,
+                },
+            )
+            logfire.exception(
+                "Agent execution failed",
+                agent_mode=self._current_agent_type.value,
+                model_name=model_name,
+                error_type=type(e).__name__,
+            )
+            # Re-raise to let TUI handle user messaging
+            raise
         finally:
             self._stream_state = None
 
@@ -468,7 +489,33 @@ class AgentManager(Widget):
 
         # Apply compaction to persistent message history to prevent cascading growth
         all_messages = result.all_messages()
-        self.message_history = await apply_persistent_compaction(all_messages, deps)
+        try:
+            logger.debug(
+                "Starting message history compaction",
+                extra={"message_count": len(all_messages)},
+            )
+            self.message_history = await apply_persistent_compaction(all_messages, deps)
+            logger.debug(
+                "Completed message history compaction",
+                extra={
+                    "original_count": len(all_messages),
+                    "compacted_count": len(self.message_history),
+                },
+            )
+        except Exception as e:
+            # If compaction fails, log full error with stack trace and use uncompacted messages
+            logger.error(
+                "Failed to compact message history - using uncompacted messages",
+                exc_info=True,
+                extra={
+                    "error": str(e),
+                    "message_count": len(all_messages),
+                    "agent_mode": self._current_agent_type.value,
+                },
+            )
+            # Fallback: use uncompacted messages to prevent data loss
+            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
@@ -554,6 +601,39 @@ class AgentManager(Widget):
                     # Detect source from call stack
                     source = detect_source()
 
+                    # Log if tool call has incomplete args (for debugging truncated JSON)
+                    if isinstance(event.part.args, str):
+                        try:
+                            json.loads(event.part.args)
+                        except (json.JSONDecodeError, ValueError):
+                            args_preview = (
+                                event.part.args[:100] + "..."
+                                if len(event.part.args) > 100
+                                else event.part.args
+                            )
+                            logger.warning(
+                                "FunctionToolCallEvent received with incomplete JSON args",
+                                extra={
+                                    "tool_name": event.part.tool_name,
+                                    "tool_call_id": event.part.tool_call_id,
+                                    "args_preview": args_preview,
+                                    "args_length": len(event.part.args)
+                                    if event.part.args
+                                    else 0,
+                                    "agent_mode": self._current_agent_type.value,
+                                },
+                            )
+                            logfire.warn(
+                                "FunctionToolCallEvent received with incomplete JSON args",
+                                tool_name=event.part.tool_name,
+                                tool_call_id=event.part.tool_call_id,
+                                args_preview=args_preview,
+                                args_length=len(event.part.args)
+                                if event.part.args
+                                else 0,
+                                agent_mode=self._current_agent_type.value,
+                            )
+
                     track_event(
                         "tool_called",
                         {

shotgun_sh-0.2.7.dev1/src/shotgun/agents/conversation_history.py

@@ -0,0 +1,227 @@
+"""Models and utilities for persisting TUI conversation history."""
+
+import json
+import logging
+from datetime import datetime
+from typing import Any, cast
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic_ai.messages import (
+    ModelMessage,
+    ModelMessagesTypeAdapter,
+    ModelResponse,
+    ToolCallPart,
+)
+from pydantic_core import to_jsonable_python
+
+from shotgun.tui.screens.chat_screen.hint_message import HintMessage
+
+logger = logging.getLogger(__name__)
+
+SerializedMessage = dict[str, Any]
+
+
+def is_tool_call_complete(tool_call: ToolCallPart) -> bool:
+    """Check if a tool call has valid, complete JSON arguments.
+
+    Args:
+        tool_call: The tool call part to validate
+
+    Returns:
+        True if the tool call args are valid JSON, False otherwise
+    """
+    if tool_call.args is None:
+        return True  # No args is valid
+
+    if isinstance(tool_call.args, dict):
+        return True  # Already parsed dict is valid
+
+    if not isinstance(tool_call.args, str):
+        return False
+
+    # Try to parse the JSON string
+    try:
+        json.loads(tool_call.args)
+        return True
+    except (json.JSONDecodeError, ValueError) as e:
+        # Log incomplete tool call detection
+        args_preview = (
+            tool_call.args[:100] + "..."
+            if len(tool_call.args) > 100
+            else tool_call.args
+        )
+        logger.info(
+            "Detected incomplete tool call in validation",
+            extra={
+                "tool_name": tool_call.tool_name,
+                "tool_call_id": tool_call.tool_call_id,
+                "args_preview": args_preview,
+                "error": str(e),
+            },
+        )
+        return False
+
+
+def filter_incomplete_messages(messages: list[ModelMessage]) -> list[ModelMessage]:
+    """Filter out messages with incomplete tool calls.
+
+    Args:
+        messages: List of messages to filter
+
+    Returns:
+        List of messages with only complete tool calls
+    """
+    filtered: list[ModelMessage] = []
+    filtered_count = 0
+    filtered_tool_names: list[str] = []
+
+    for message in messages:
+        # Only check ModelResponse messages for tool calls
+        if not isinstance(message, ModelResponse):
+            filtered.append(message)
+            continue
+
+        # Check if any tool calls are incomplete
+        has_incomplete_tool_call = False
+        for part in message.parts:
+            if isinstance(part, ToolCallPart) and not is_tool_call_complete(part):
+                has_incomplete_tool_call = True
+                filtered_tool_names.append(part.tool_name)
+                break
+
+        # Only include messages without incomplete tool calls
+        if not has_incomplete_tool_call:
+            filtered.append(message)
+        else:
+            filtered_count += 1
+
+    # Log if any messages were filtered
+    if filtered_count > 0:
+        logger.info(
+            "Filtered incomplete messages before saving",
+            extra={
+                "filtered_count": filtered_count,
+                "total_messages": len(messages),
+                "filtered_tool_names": filtered_tool_names,
+            },
+        )
+
+    return filtered
+
+
+class ConversationState(BaseModel):
+    """Represents the complete state of a conversation in memory."""
+
+    agent_messages: list[ModelMessage]
+    ui_messages: list[ModelMessage | HintMessage] = Field(default_factory=list)
+    agent_type: str  # Will store AgentType.value
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class ConversationHistory(BaseModel):
+    """Persistent conversation history for TUI sessions."""
+
+    version: int = 1
+    agent_history: list[SerializedMessage] = Field(
+        default_factory=list
+    )  # Stores serialized ModelMessage objects
+    ui_history: list[SerializedMessage] = Field(
+        default_factory=list
+    )  # Stores serialized ModelMessage and HintMessage objects
+    last_agent_model: str = "research"
+    updated_at: datetime = Field(default_factory=datetime.now)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def set_agent_messages(self, messages: list[ModelMessage]) -> None:
+        """Set agent_history from a list of ModelMessage objects.
+
+        Args:
+            messages: List of ModelMessage objects to serialize and store
+        """
+        # Filter out messages with incomplete tool calls to prevent corruption
+        filtered_messages = filter_incomplete_messages(messages)
+
+        # Serialize ModelMessage list to JSON-serializable format
+        self.agent_history = to_jsonable_python(
+            filtered_messages, fallback=lambda x: str(x), exclude_none=True
+        )
+
+    def set_ui_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
+        """Set ui_history from a list of UI messages."""
+
+        # Filter out ModelMessages with incomplete tool calls (keep all HintMessages)
+        # We need to maintain message order, so we'll check each message individually
+        filtered_messages: list[ModelMessage | HintMessage] = []
+
+        for msg in messages:
+            if isinstance(msg, HintMessage):
+                # Always keep hint messages
+                filtered_messages.append(msg)
+            elif isinstance(msg, ModelResponse):
+                # Check if this ModelResponse has incomplete tool calls
+                has_incomplete = False
+                for part in msg.parts:
+                    if isinstance(part, ToolCallPart) and not is_tool_call_complete(
+                        part
+                    ):
+                        has_incomplete = True
+                        break
+
+                if not has_incomplete:
+                    filtered_messages.append(msg)
+            else:
+                # Keep all other ModelMessage types (ModelRequest, etc.)
+                filtered_messages.append(msg)
+
+        def _serialize_message(
+            message: ModelMessage | HintMessage,
+        ) -> Any:
+            if isinstance(message, HintMessage):
+                data = message.model_dump()
+                data["message_type"] = "hint"
+                return data
+            payload = to_jsonable_python(
+                message, fallback=lambda x: str(x), exclude_none=True
+            )
+            if isinstance(payload, dict):
+                payload.setdefault("message_type", "model")
+            return payload
+
+        self.ui_history = [_serialize_message(msg) for msg in filtered_messages]
+
+    def get_agent_messages(self) -> list[ModelMessage]:
+        """Get agent_history as a list of ModelMessage objects.
+
+        Returns:
+            List of deserialized ModelMessage objects
+        """
+        if not self.agent_history:
+            return []
+
+        # Deserialize from JSON format back to ModelMessage objects
+        return ModelMessagesTypeAdapter.validate_python(self.agent_history)
+
+    def get_ui_messages(self) -> list[ModelMessage | HintMessage]:
+        """Get ui_history as a list of Model or hint messages."""
+
+        if not self.ui_history:
+            # Fallback for older conversation files without UI history
+            return cast(list[ModelMessage | HintMessage], self.get_agent_messages())
+
+        messages: list[ModelMessage | HintMessage] = []
+        for item in self.ui_history:
+            message_type = item.get("message_type") if isinstance(item, dict) else None
+            if message_type == "hint":
+                messages.append(HintMessage.model_validate(item))
+                continue
+
+            # Backwards compatibility: data may not include the type marker
+            payload = item
+            if isinstance(payload, dict):
+                payload = {k: v for k, v in payload.items() if k != "message_type"}
+            deserialized = ModelMessagesTypeAdapter.validate_python([payload])
+            messages.append(deserialized[0])
+
+        return messages

{shotgun_sh-0.2.6.dev5 → shotgun_sh-0.2.7.dev1}/src/shotgun/agents/conversation_manager.py

@@ -1,6 +1,7 @@
 """Manager for handling conversation persistence operations."""
 
 import json
+import shutil
 from pathlib import Path
 
 from shotgun.logging_config import get_logger
@@ -77,9 +78,30 @@ class ConversationManager:
             )
             return conversation
 
-        except Exception as e:
+        except (json.JSONDecodeError, ValueError) as e:
+            # Handle corrupted JSON or validation errors
+            logger.error(
+                "Corrupted conversation file at %s: %s. Creating backup and starting fresh.",
+                self.conversation_path,
+                e,
+            )
+
+            # Create a backup of the corrupted file for debugging
+            backup_path = self.conversation_path.with_suffix(".json.backup")
+            try:
+                shutil.copy2(self.conversation_path, backup_path)
+                logger.info("Backed up corrupted conversation to %s", backup_path)
+            except Exception as backup_error:  # pragma: no cover
+                logger.warning("Failed to backup corrupted file: %s", backup_error)
+
+            return None
+
+        except Exception as e:  # pragma: no cover
+            # Catch-all for unexpected errors
             logger.error(
-                "Failed to load conversation from %s: %s", self.conversation_path, e
+                "Unexpected error loading conversation from %s: %s",
+                self.conversation_path,
+                e,
             )
             return None