shotgun-sh 0.2.6.dev5__py3-none-any.whl → 0.2.7.dev1__py3-none-any.whl

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/agents/conversation_history.py

@@ -1,5 +1,7 @@
 """Models and utilities for persisting TUI conversation history."""
 
+import json
+import logging
 from datetime import datetime
 from typing import Any, cast
 
@@ -7,14 +9,106 @@ 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."""
 
@@ -46,14 +140,41 @@ class ConversationHistory(BaseModel):
         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(
-            messages, fallback=lambda x: str(x), exclude_none=True
+            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:
@@ -68,7 +189,7 @@ class ConversationHistory(BaseModel):
                 payload.setdefault("message_type", "model")
             return payload
 
-        self.ui_history = [_serialize_message(msg) for msg in messages]
+        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.

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
 

shotgun/agents/history/context_extraction.py

@@ -1,5 +1,9 @@
 """Context extraction utilities for history processing."""
 
+import json
+import logging
+import traceback
+
 from pydantic_ai.messages import (
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
@@ -16,6 +20,46 @@ from pydantic_ai.messages import (
     UserPromptPart,
 )
 
+logger = logging.getLogger(__name__)
+
+
+def _safely_parse_tool_args(args: dict[str, object] | str | None) -> dict[str, object]:
+    """Safely parse tool call arguments, handling incomplete/invalid JSON.
+
+    Args:
+        args: Tool call arguments (dict, JSON string, or None)
+
+    Returns:
+        Parsed args dict, or empty dict if parsing fails
+    """
+    if args is None:
+        return {}
+
+    if isinstance(args, dict):
+        return args
+
+    if not isinstance(args, str):
+        return {}
+
+    try:
+        parsed = json.loads(args)
+        return parsed if isinstance(parsed, dict) else {}
+    except (json.JSONDecodeError, ValueError) as e:
+        # Only log warning if it looks like JSON (starts with { or [) - incomplete JSON
+        # Plain strings are valid args and shouldn't trigger warnings
+        stripped_args = args.strip()
+        if stripped_args.startswith(("{", "[")):
+            args_preview = args[:100] + "..." if len(args) > 100 else args
+            logger.warning(
+                "Detected incomplete/invalid JSON in tool call args during parsing",
+                extra={
+                    "args_preview": args_preview,
+                    "error": str(e),
+                    "args_length": len(args),
+                },
+            )
+        return {}
+
 
 def extract_context_from_messages(messages: list[ModelMessage]) -> str:
     """Extract context from a list of messages for summarization."""
@@ -87,12 +131,55 @@ def extract_context_from_part(
         return f"<ASSISTANT_TEXT>\n{message_part.content}\n</ASSISTANT_TEXT>"
 
     elif isinstance(message_part, ToolCallPart):
-        if isinstance(message_part.args, dict):
-            args_str = ", ".join(f"{k}={repr(v)}" for k, v in message_part.args.items())
-            tool_call_str = f"{message_part.tool_name}({args_str})"
-        else:
-            tool_call_str = f"{message_part.tool_name}({message_part.args})"
-        return f"<TOOL_CALL>\n{tool_call_str}\n</TOOL_CALL>"
+        # Safely parse args to avoid crashes from incomplete JSON during streaming
+        try:
+            parsed_args = _safely_parse_tool_args(message_part.args)
+            if parsed_args:
+                # Successfully parsed as dict - format nicely
+                args_str = ", ".join(f"{k}={repr(v)}" for k, v in parsed_args.items())
+                tool_call_str = f"{message_part.tool_name}({args_str})"
+            elif isinstance(message_part.args, str) and message_part.args:
+                # Non-empty string that didn't parse as JSON
+                # Check if it looks like JSON (starts with { or [) - if so, it's incomplete
+                stripped_args = message_part.args.strip()
+                if stripped_args.startswith(("{", "[")):
+                    # Looks like incomplete JSON - log warning and show empty parens
+                    args_preview = (
+                        stripped_args[:100] + "..."
+                        if len(stripped_args) > 100
+                        else stripped_args
+                    )
+                    stack_trace = "".join(traceback.format_stack())
+                    logger.warning(
+                        "ToolCallPart with unparseable args encountered during context extraction",
+                        extra={
+                            "tool_name": message_part.tool_name,
+                            "tool_call_id": message_part.tool_call_id,
+                            "args_preview": args_preview,
+                            "args_type": type(message_part.args).__name__,
+                            "stack_trace": stack_trace,
+                        },
+                    )
+                    tool_call_str = f"{message_part.tool_name}()"
+                else:
+                    # Plain string arg - display as-is
+                    tool_call_str = f"{message_part.tool_name}({message_part.args})"
+            else:
+                # No args
+                tool_call_str = f"{message_part.tool_name}()"
+            return f"<TOOL_CALL>\n{tool_call_str}\n</TOOL_CALL>"
+        except Exception as e:  # pragma: no cover - defensive catch-all
+            # If anything goes wrong, log full exception with stack trace
+            logger.error(
+                "Unexpected error processing ToolCallPart",
+                exc_info=True,
+                extra={
+                    "tool_name": message_part.tool_name,
+                    "tool_call_id": message_part.tool_call_id,
+                    "error": str(e),
+                },
+            )
+            return f"<TOOL_CALL>\n{message_part.tool_name}()\n</TOOL_CALL>"
 
     elif isinstance(message_part, BuiltinToolCallPart):
         return f"<BUILTIN_TOOL_CALL>\n{message_part.tool_name}\n</BUILTIN_TOOL_CALL>"

shotgun/tui/screens/chat.py

@@ -881,6 +881,30 @@ class ChatScreen(Screen[None]):
         except asyncio.CancelledError:
             # Handle cancellation gracefully - DO NOT re-raise
             self.mount_hint("⚠️ Operation cancelled by user")
+        except Exception as e:
+            # Log with full stack trace to shotgun.log
+            logger.exception(
+                "Agent run failed",
+                extra={
+                    "agent_mode": self.mode.value,
+                    "error_type": type(e).__name__,
+                },
+            )
+
+            # Determine user-friendly message based on error type
+            error_name = type(e).__name__
+            error_message = str(e)
+
+            if "APIStatusError" in error_name and "overload" in error_message.lower():
+                hint = "⚠️ The AI service is temporarily overloaded. Please wait a moment and try again."
+            elif "APIStatusError" in error_name and "rate" in error_message.lower():
+                hint = "⚠️ Rate limit reached. Please wait before trying again."
+            elif "APIStatusError" in error_name:
+                hint = f"⚠️ AI service error: {error_message}"
+            else:
+                hint = f"⚠️ An error occurred: {error_message}\n\nCheck logs at ~/.shotgun-sh/logs/shotgun.log"
+
+            self.mount_hint(hint)
         finally:
             self.working = False
             self._current_worker = None
@@ -910,24 +934,41 @@ class ChatScreen(Screen[None]):
         """Load conversation from persistent storage."""
         conversation = self.conversation_manager.load()
         if conversation is None:
+            # Check if file existed but was corrupted (backup was created)
+            backup_path = self.conversation_manager.conversation_path.with_suffix(
+                ".json.backup"
+            )
+            if backup_path.exists():
+                # File was corrupted - show friendly notification
+                self.mount_hint(
+                    "⚠️ Previous session was corrupted and has been backed up. Starting fresh conversation."
+                )
             return
 
-        # Restore agent state
-        agent_messages = conversation.get_agent_messages()
-        ui_messages = conversation.get_ui_messages()
+        try:
+            # Restore agent state
+            agent_messages = conversation.get_agent_messages()
+            ui_messages = conversation.get_ui_messages()
+
+            # Create ConversationState for restoration
+            state = ConversationState(
+                agent_messages=agent_messages,
+                ui_messages=ui_messages,
+                agent_type=conversation.last_agent_model,
+            )
 
-        # Create ConversationState for restoration
-        state = ConversationState(
-            agent_messages=agent_messages,
-            ui_messages=ui_messages,
-            agent_type=conversation.last_agent_model,
-        )
+            self.agent_manager.restore_conversation_state(state)
 
-        self.agent_manager.restore_conversation_state(state)
+            # Update the current mode
+            self.mode = AgentType(conversation.last_agent_model)
+            self.deps.usage_manager.restore_usage_state()
 
-        # Update the current mode
-        self.mode = AgentType(conversation.last_agent_model)
-        self.deps.usage_manager.restore_usage_state()
+        except Exception as e:  # pragma: no cover
+            # If anything goes wrong during restoration, log it and continue
+            logger.error("Failed to restore conversation state: %s", e)
+            self.mount_hint(
+                "⚠️ Could not restore previous session. Starting fresh conversation."
+            )
 
 
 def help_text_with_codebase(already_indexed: bool = False) -> str:

shotgun_sh-0.2.7.dev1.dist-info/METADATA

@@ -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.6.dev5.dist-info → shotgun_sh-0.2.7.dev1.dist-info}/RECORD

@@ -8,10 +8,10 @@ shotgun/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shotgun/sentry_telemetry.py,sha256=VD8es-tREfgtRKhDsEVvqpo0_kM_ab6iVm2lkOEmTlI,2950
 shotgun/telemetry.py,sha256=C8dM7Feo1OxJMwDvgAMaA2RyRDO2rYPvC_8kLBuRUS8,3683
 shotgun/agents/__init__.py,sha256=8Jzv1YsDuLyNPFJyckSr_qI4ehTVeDyIMDW4omsfPGc,25
-shotgun/agents/agent_manager.py,sha256=6f86XooirrBRxyfTWRwsJk6M_kKaaoAP4Yfi6Lu7zGc,28995
+shotgun/agents/agent_manager.py,sha256=Fjm_7fDqmaqWgjAgGiiIdMNnK0ahanLLZ4bxJIbrMlE,32611
 shotgun/agents/common.py,sha256=g8QW782XZfZHjAJPC6k2uXqoX4UZufvbGaejzWgya8E,17768
-shotgun/agents/conversation_history.py,sha256=5J8_1yxdZiiWTq22aDio88DkBDZ4_Lh_p5Iy5_ENszc,3898
-shotgun/agents/conversation_manager.py,sha256=fxAvXbEl3Cl2ugJ4N9aWXaqZtkrnfj3QzwjWC4LFXwI,3514
+shotgun/agents/conversation_history.py,sha256=c-1PBaG9FXPfSmekWtrD6s6YVT0sd98DdDhzS4a1Hyo,7859
+shotgun/agents/conversation_manager.py,sha256=X3DWZZIqrv0hS1SUasyoxexnLPBUrZMBg4ZmRAipkBE,4429
 shotgun/agents/export.py,sha256=7ZNw7781WJ4peLSeoUc7zxKeaZVxFpow2y4nU4dCfbo,2919
 shotgun/agents/llm.py,sha256=hs8j1wwTczGtehzahL1Z_5D4qus5QUx4-h9-m5ZPzm4,2209
 shotgun/agents/messages.py,sha256=wNn0qC5AqASM8LMaSGFOerZEJPn5FsIOmaJs1bdosuU,1036
@@ -29,7 +29,7 @@ shotgun/agents/config/provider.py,sha256=K2uW7DkdAhZfoDJcWV7NxOrSoEq1rQzArtZnxIg
 shotgun/agents/history/__init__.py,sha256=XFQj2a6fxDqVg0Q3juvN9RjV_RJbgvFZtQOCOjVJyp4,147
 shotgun/agents/history/compaction.py,sha256=9RMpG0aY_7L4TecbgwHSOkGtbd9W5XZTg-MbzZmNl00,3515
 shotgun/agents/history/constants.py,sha256=yWY8rrTZarLA3flCCMB_hS2NMvUDRDTwP4D4j7MIh1w,446
-shotgun/agents/history/context_extraction.py,sha256=yVka1U6TqNVsORR4JlxpWi9yBt3Quip8g_u3x2Vi9Gs,3564
+shotgun/agents/history/context_extraction.py,sha256=yPF3oYpv5GFsFQT5y53ORKdADtrkGH4u8LwPdO0YVzU,7157
 shotgun/agents/history/history_building.py,sha256=6LFDZ60MTPDoGAcmu_mjlnjVYu8YYWdIi-cGbF3jm7A,3532
 shotgun/agents/history/history_processors.py,sha256=D3z-hzrXHxE7OAZaVX4_YAKN_nyxSF5iYMIYO24V_CI,17943
 shotgun/agents/history/message_utils.py,sha256=aPusAl2RYKbjc7lBxPaNprRHmZEG6fe97q7DQUlhlzU,2918
@@ -127,7 +127,7 @@ shotgun/tui/components/prompt_input.py,sha256=Ss-htqraHZAPaehGE4x86ij0veMjc4Ugad
 shotgun/tui/components/spinner.py,sha256=ovTDeaJ6FD6chZx_Aepia6R3UkPOVJ77EKHfRmn39MY,2427
 shotgun/tui/components/splash.py,sha256=vppy9vEIEvywuUKRXn2y11HwXSRkQZHLYoVjhDVdJeU,1267
 shotgun/tui/components/vertical_tail.py,sha256=kROwTaRjUwVB7H35dtmNcUVPQqNYvvfq7K2tXBKEb6c,638
-shotgun/tui/screens/chat.py,sha256=78GaZMKN2iE7bQQwiKBWFTsRoraWnuWl91qPjo5q1Nw,35446
+shotgun/tui/screens/chat.py,sha256=VAsgX7YiXTXAH7pAwcWaWr2hGu_Ft0i8VpoUETTPsTM,37424
 shotgun/tui/screens/chat.tcss,sha256=2Yq3E23jxsySYsgZf4G1AYrYVcpX0UDW6kNNI0tDmtM,437
 shotgun/tui/screens/directory_setup.py,sha256=lIZ1J4A6g5Q2ZBX8epW7BhR96Dmdcg22CyiM5S-I5WU,3237
 shotgun/tui/screens/feedback.py,sha256=VxpW0PVxMp22ZvSfQkTtgixNrpEOlfWtekjqlVfYEjA,5708
@@ -148,8 +148,8 @@ shotgun/utils/env_utils.py,sha256=ulM3BRi9ZhS7uC-zorGeDQm4SHvsyFuuU9BtVPqdrHY,14
 shotgun/utils/file_system_utils.py,sha256=l-0p1bEHF34OU19MahnRFdClHufThfGAjQ431teAIp0,1004
 shotgun/utils/source_detection.py,sha256=Co6Q03R3fT771TF3RzB-70stfjNP2S4F_ArZKibwzm8,454
 shotgun/utils/update_checker.py,sha256=IgzPHRhS1ETH7PnJR_dIx6lxgr1qHpCkMTgzUxvGjhI,7586
-shotgun_sh-0.2.6.dev5.dist-info/METADATA,sha256=XyTZmnYtmdUKWPMWrXAzzUv9HZeIZuGjXf2GvpzHY2k,11226
-shotgun_sh-0.2.6.dev5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-shotgun_sh-0.2.6.dev5.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
-shotgun_sh-0.2.6.dev5.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
-shotgun_sh-0.2.6.dev5.dist-info/RECORD,,
+shotgun_sh-0.2.7.dev1.dist-info/METADATA,sha256=MEaQlu9HJSSTi9_WuCgVgC8nX5J34O8PzyP8b8mCj_4,4268
+shotgun_sh-0.2.7.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+shotgun_sh-0.2.7.dev1.dist-info/entry_points.txt,sha256=asZxLU4QILneq0MWW10saVCZc4VWhZfb0wFZvERnzfA,45
+shotgun_sh-0.2.7.dev1.dist-info/licenses/LICENSE,sha256=YebsZl590zCHrF_acCU5pmNt0pnAfD2DmAnevJPB1tY,1065
+shotgun_sh-0.2.7.dev1.dist-info/RECORD,,

shotgun_sh-0.2.6.dev5.dist-info/METADATA

@@ -1,467 +0,0 @@
-Metadata-Version: 2.4
-Name: shotgun-sh
-Version: 0.2.6.dev5
-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
-
-A Python CLI tool for research, planning, and task management powered by AI agents.
-
-## Features
-
-- **Research**: Perform research with agentic loops
-- **Planning**: Generate structured plans for achieving goals
-- **Tasks**: Generate prioritized task lists with agentic approaches
-
-## Installation
-
-### From PyPI (Recommended)
-
-```bash
-pip install shotgun-sh
-```
-
-### From Source
-
-```bash
-git clone https://github.com/shotgun-sh/shotgun.git
-cd shotgun
-uv sync --all-extras
-```
-
-After installation from source, you can use either method:
-
-**Method 1: Direct command (after uv sync)**
-```bash
-shotgun --help
-```
-
-**Method 2: Via uv run**
-```bash
-uv run shotgun --help
-```
-
-If installed from PyPI, simply use:
-```bash
-shotgun --help
-```
-
-### Virtual Environment Setup (Optional)
-
-If you prefer using a local virtual environment:
-
-```bash
-uv venv
-source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-uv sync --all-extras
-shotgun --help
-```
-
-## Usage
-
-### Using Direct Commands (after uv sync)
-
-```bash
-# Research a topic
-shotgun research "What is quantum computing?"
-
-# Generate a plan
-shotgun plan "Build a web application"
-shotgun plan "build me a house"
-
-# Generate tasks for a project
-shotgun tasks "Create a machine learning model"
-```
-
-### Using uv run
-
-```bash
-# Research a topic
-uv run shotgun research "What is quantum computing?"
-
-# Generate a plan
-uv run shotgun plan "Build a web application"
-
-# Generate tasks for a project
-uv run shotgun tasks "Create a machine learning model"
-```
-
-## Auto-Updates
-
-Shotgun automatically checks for updates to keep you on the latest version.
-
-### How it works
-
-- Checks for updates on startup (runs in background, non-blocking)
-- Caches results for 24 hours to minimize API calls
-- Shows notification after command execution if an update is available
-- Never auto-updates development versions
-
-### Update Commands
-
-```bash
-# Check for available updates
-shotgun update --check
-
-# Install available updates
-shotgun update
-
-# Force update (even for dev versions with confirmation)
-shotgun update --force
-```
-
-### Disable Update Checks
-
-```bash
-# Disable for a single command
-shotgun --no-update-check research "topic"
-```
-
-### Installation Methods
-
-The update command automatically detects and uses the appropriate method:
-- **pipx**: `pipx upgrade shotgun-sh`
-- **pip**: `pip install --upgrade shotgun-sh`
-- **venv**: Updates within the virtual environment
-
-## Development Setup
-
-### Requirements
-
-- **Python 3.11+** (3.13 recommended)
-- **uv** - Fast Python package installer and resolver
-- **actionlint** (optional) - For GitHub Actions workflow validation
-
-### Quick Start
-
-1. **Clone and setup**:
-   ```bash
-   git clone https://github.com/shotgun-sh/shotgun.git
-   cd shotgun
-   ```
-
-2. **Install uv** (if not already installed):
-   ```bash
-   # macOS/Linux
-   curl -LsSf https://astral.sh/uv/install.sh | sh
-   
-   # Or via brew
-   brew install uv
-   ```
-
-3. **Install dependencies**:
-   ```bash
-   uv sync --all-extras
-   ```
-
-4. **Install git hooks**:
-   ```bash
-   uv run lefthook install
-   ```
-
-5. **Verify setup**:
-   ```bash
-   uv run shotgun --version
-   ```
-
-### Development Commands
-
-```bash
-# Run the CLI
-uv run shotgun --help
-
-# Run the TUI
-uv run tui
-
-# Run tests
-uv run pytest
-
-# Run tests with coverage
-uv run pytest --cov=src --cov-report=term-missing --cov-report=html
-
-# Run linting
-uv run ruff check .
-
-# Run formatting
-uv run ruff format .
-
-# Run type checking
-uv run mypy src/
-
-# Run all pre-commit hooks manually
-uv run lefthook run pre-commit
-```
-
-### Code Coverage
-
-To analyze test coverage and identify areas that need testing:
-
-```bash
-# Run tests with coverage analysis
-uv run pytest --cov=src --cov-report=term-missing --cov-report=html
-```
-
-This will:
-- Display coverage summary in the terminal
-- Generate a detailed HTML coverage report
-
-**Viewing the coverage report:**
-Open `htmlcov/index.html` in your browser to see:
-- Overall coverage percentage
-- File-by-file coverage breakdown  
-- Line-by-line coverage highlighting
-- Missing coverage areas
-
-The coverage configuration is in `pyproject.toml` and will automatically run when you use `uv run pytest`.
-
-### Git Hooks (Lefthook)
-
-This project uses [lefthook](https://github.com/evilmartians/lefthook) for git hooks. The hooks automatically run:
-
-- **ruff** - Python linting with auto-fix
-- **ruff-format** - Code formatting  
-- **mypy** - Type checking
-- **commitizen** - Commit message validation
-- **actionlint** - GitHub Actions workflow validation (if installed)
-
-#### Installing actionlint (recommended)
-
-```bash
-# macOS
-brew install actionlint
-
-# Linux/macOS (direct download)
-curl -sSfL https://raw.githubusercontent.com/rhysd/actionlint/main/scripts/download-actionlint.bash | bash
-
-# Go install
-go install github.com/rhysd/actionlint/cmd/actionlint@latest
-```
-
-
-### Python Version Management
-
-The project supports **Python 3.11+**. The `.python-version` file specifies Python 3.11 to ensure development against the minimum supported version.
-
-If using **pyenv**:
-```bash
-pyenv install 3.11
-```
-
-If using **uv** (recommended):
-```bash
-uv python install 3.11
-uv sync --python 3.11
-```
-
-### Commit Message Convention
-
-This project enforces **Conventional Commits** specification. All commit messages must follow this format:
-
-```
-<type>[optional scope]: <description>
-```
-
-**Required commit types:**
-- `feat`: New feature
-- `fix`: Bug fix
-- `docs`: Documentation changes
-- `style`: Code formatting changes
-- `refactor`: Code restructuring without feature changes
-- `perf`: Performance improvements
-- `test`: Adding or updating tests
-- `build`: Build system changes
-- `ci`: CI/CD changes
-- `chore`: Maintenance tasks
-- `revert`: Reverting previous commits
-
-**Examples:**
-```bash
-feat: add user authentication system
-fix: resolve memory leak in data processing
-docs: update API documentation
-refactor: simplify user validation logic
-```
-
-**For interactive commit creation:**
-```bash
-uv run cz commit
-```
-
-### Contributing
-
-1. Fork the repository
-2. Create a feature branch: `git checkout -b feat/feature-name`
-3. Make your changes
-4. Run the pre-commit hooks: `uv run lefthook run pre-commit`
-5. Commit with conventional format: `git commit -m "feat: add new feature"`
-6. Push to your fork: `git push origin feat/feature-name`
-7. Create a Pull Request with conventional title format
-
-### CI/CD
-
-GitHub Actions automatically:
-- Runs on pull requests and pushes to main
-- Tests with Python 3.11
-- Validates code with ruff, ruff-format, and mypy
-- Ensures all checks pass before merge
-
-## Observability & Telemetry
-
-Shotgun includes built-in observability with Sentry for error tracking and Logfire for logging and tracing. Both services track users anonymously using a UUID generated on first run.
-
-### Anonymous User Tracking
-
-Each user gets a unique anonymous ID stored in their config:
-```bash
-# Get your anonymous user ID
-shotgun config get-user-id
-```
-
-This ID is automatically included in:
-- **Sentry**: Error reports and exceptions
-- **Logfire**: All logs, traces, and spans
-
-### Logfire Queries
-
-Logfire uses SQL for querying logs. Here are helpful queries for debugging and analysis:
-
-#### Find all logs for a specific user
-```sql
-SELECT * FROM records
-WHERE attributes->>'user_id' = 'your-user-id-here'
-ORDER BY timestamp DESC;
-```
-
-#### Track user actions
-```sql
-SELECT
-  timestamp,
-  span_name,
-  message,
-  attributes
-FROM records
-WHERE attributes->>'user_id' = 'your-user-id-here'
-  AND span_name LIKE '%research%'
-ORDER BY timestamp DESC;
-```
-
-#### Find slow operations for a user
-```sql
-SELECT
-  span_name,
-  duration_ms,
-  attributes
-FROM records
-WHERE attributes->>'user_id' = 'your-user-id-here'
-  AND duration_ms > 1000
-ORDER BY duration_ms DESC;
-```
-
-#### Find errors for a user
-```sql
-SELECT * FROM records
-WHERE attributes->>'user_id' = 'your-user-id-here'
-  AND level = 'error'
-ORDER BY timestamp DESC;
-```
-
-#### Analyze user's AI provider usage
-```sql
-SELECT
-  attributes->>'provider' as provider,
-  COUNT(*) as usage_count,
-  AVG(duration_ms) as avg_duration
-FROM records
-WHERE attributes->>'user_id' = 'your-user-id-here'
-  AND attributes->>'provider' IS NOT NULL
-GROUP BY provider;
-```
-
-#### Track feature usage by user
-```sql
-SELECT
-  span_name,
-  COUNT(*) as usage_count
-FROM records
-WHERE attributes->>'user_id' = 'your-user-id-here'
-  AND span_name IN ('research', 'plan', 'tasks')
-GROUP BY span_name
-ORDER BY usage_count DESC;
-```
-
-### Setting Up Observability (Optional)
-
-For local development with Logfire:
-```bash
-# Set environment variables
-export LOGFIRE_ENABLED=true
-export LOGFIRE_TOKEN=your-logfire-token
-
-# Run shotgun - will now send logs to Logfire
-shotgun research "topic"
-```
-
-For Sentry (automatically configured in production builds):
-```bash
-# Set for local development
-export SENTRY_DSN=your-sentry-dsn
-```
-
-### Privacy
-
-- **No PII collected**: Only anonymous UUIDs are used for identification
-- **Opt-in for development**: Telemetry requires explicit environment variables
-- **Automatic in production**: Production builds include telemetry for error tracking
-
-## Support
-
-Join our discord https://discord.gg/5RmY6J2N7s