shotgun-sh 0.1.11__tar.gz → 0.1.12__tar.gz

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.11
+Version: 0.1.12
 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

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.1.11"
+version = "0.1.12"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README.md"
 license = { text = "MIT" }

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/codebase/core/manager.py

@@ -353,7 +353,19 @@ class CodebaseGraphManager:
 
         # Check if graph already exists
         if graph_path.exists():
-            raise CodebaseAlreadyIndexedError(repo_path)
+            # Verify it's not corrupted by checking if we can load the Project node
+            existing_graph = await self.get_graph(graph_id)
+            if existing_graph:
+                # Valid existing graph
+                raise CodebaseAlreadyIndexedError(repo_path)
+            else:
+                # Corrupted database - remove and re-index
+                logger.warning(
+                    f"Found corrupted database at {graph_path}, removing for re-indexing..."
+                )
+                import shutil
+
+                shutil.rmtree(graph_path)
 
         # Import the builder from local core module
         from shotgun.codebase.core import CodebaseIngestor

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/codebase/service.py

@@ -69,6 +69,10 @@ class CodebaseService:
             # Otherwise, check if current directory is in the allowed list
             elif target_path in graph.indexed_from_cwds:
                 filtered_graphs.append(graph)
+            # Also allow access if current directory IS the repository itself
+            # Use Path.resolve() for robust comparison (handles symlinks, etc.)
+            elif Path(target_path).resolve() == Path(graph.repo_path).resolve():
+                filtered_graphs.append(graph)
 
         return filtered_graphs
 

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/main.py

@@ -118,7 +118,15 @@ def main(
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
         logger.debug("Launching shotgun TUI application")
-        tui_app.run(no_update_check=no_update_check, continue_session=continue_session)
+        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

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/tui/app.py

@@ -83,6 +83,10 @@ class ShotgunApp(App[None]):
 
     async def action_quit(self) -> None:
         """Quit the application."""
+        # Shut down PostHog client to prevent threading errors
+        from shotgun.posthog_telemetry import shutdown
+
+        shutdown()
         self.exit()
 
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/tui/components/vertical_tail.py

@@ -1,4 +1,5 @@
 from textual.containers import VerticalScroll
+from textual.geometry import Size
 from textual.reactive import reactive
 
 
@@ -11,3 +12,8 @@ class VerticalTail(VerticalScroll):
         """Handle auto_scroll property changes."""
         if value:
             self.scroll_end(animate=False)
+
+    def watch_virtual_size(self, value: Size) -> None:
+        """Handle virtual_size property changes."""
+
+        self.call_later(self.scroll_end, animate=False)

shotgun_sh-0.1.12/src/shotgun/tui/filtered_codebase_service.py

@@ -0,0 +1,46 @@
+"""Filtered codebase service that restricts access to current directory's codebase only."""
+
+from pathlib import Path
+
+from shotgun.codebase.models import CodebaseGraph
+from shotgun.codebase.service import CodebaseService
+
+
+class FilteredCodebaseService(CodebaseService):
+    """CodebaseService subclass that filters graphs to only those accessible from CWD.
+
+    This ensures TUI agents can only see and access the codebase indexed from the
+    current working directory, providing isolation between different project directories.
+    """
+
+    def __init__(self, storage_dir: Path | str):
+        """Initialize the filtered service.
+
+        Args:
+            storage_dir: Directory to store graph databases
+        """
+        super().__init__(storage_dir)
+        self._cwd = str(Path.cwd().resolve())
+
+    async def list_graphs(self) -> list[CodebaseGraph]:
+        """List only graphs accessible from the current working directory.
+
+        Returns:
+            Filtered list of CodebaseGraph objects accessible from CWD
+        """
+        # Use the existing filtering logic from list_graphs_for_directory
+        return await super().list_graphs_for_directory(self._cwd)
+
+    async def list_graphs_for_directory(
+        self, directory: Path | str | None = None
+    ) -> list[CodebaseGraph]:
+        """List graphs for directory - always filters to CWD for TUI context.
+
+        Args:
+            directory: Ignored in TUI context, always uses CWD
+
+        Returns:
+            Filtered list of CodebaseGraph objects accessible from CWD
+        """
+        # Always use CWD regardless of what directory is passed
+        return await super().list_graphs_for_directory(self._cwd)

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/tui/screens/chat.py

@@ -1,6 +1,5 @@
 import asyncio
 import logging
-from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
 from typing import cast
@@ -17,10 +16,11 @@ from textual import events, on, work
 from textual.app import ComposeResult
 from textual.command import CommandPalette
 from textual.containers import Container, Grid
+from textual.keys import Keys
 from textual.reactive import reactive
 from textual.screen import ModalScreen, Screen
 from textual.widget import Widget
-from textual.widgets import Button, DirectoryTree, Input, Label, Markdown, Static
+from textual.widgets import Button, Label, Markdown, Static
 
 from shotgun.agents.agent_manager import (
     AgentManager,
@@ -44,10 +44,11 @@ from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
 from shotgun.posthog_telemetry import track_event
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
-from shotgun.sdk.services import get_codebase_service
 from shotgun.tui.commands import CommandHandler
+from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.tui.screens.chat_screen.history import ChatHistory
+from shotgun.utils import get_shotgun_home
 
 from ..components.prompt_input import PromptInput
 from ..components.spinner import Spinner
@@ -167,11 +168,6 @@ class ModeIndicator(Widget):
         return f"[bold $text-accent]{mode_title}{status_icon} mode[/][$foreground-muted] ({description})[/]"
 
 
-class FilteredDirectoryTree(DirectoryTree):
-    def filter_paths(self, paths: Iterable[Path]) -> Iterable[Path]:
-        return [path for path in paths if path.is_dir()]
-
-
 class CodebaseIndexPromptScreen(ModalScreen[bool]):
     """Modal dialog asking whether to index the detected codebase."""
 
@@ -226,105 +222,6 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
         self.dismiss(True)
 
 
-class CodebaseIndexScreen(ModalScreen[CodebaseIndexSelection | None]):
-    """Modal dialog for choosing a repository and name to index."""
-
-    DEFAULT_CSS = """
-        CodebaseIndexScreen {
-            align: center middle;
-            background: rgba(0, 0, 0, 0.0);
-        }
-        CodebaseIndexScreen > #index-dialog {
-            width: 80%;
-            max-width: 80;
-            height: 80%;
-            max-height: 40;
-            border: wide $primary;
-            padding: 1;
-            layout: vertical;
-            background: $surface;
-        }
-
-        #index-dialog DirectoryTree {
-            height: 1fr;
-            border: solid $accent;
-            overflow: auto;
-        }
-
-        #index-dialog-controls {
-            layout: horizontal;
-            align-horizontal: right;
-            padding-top: 1;
-        }
-    """
-
-    def __init__(self, start_path: Path | None = None) -> None:
-        super().__init__()
-        self.start_path = Path(start_path or Path.cwd())
-        self.selected_path: Path | None = self.start_path
-
-    def compose(self) -> ComposeResult:
-        with Container(id="index-dialog"):
-            yield Label("Index a codebase", id="index-dialog-title")
-            yield FilteredDirectoryTree(self.start_path, id="index-directory-tree")
-            yield Input(
-                placeholder="Enter a name for the codebase",
-                id="index-codebase-name",
-            )
-            with Container(id="index-dialog-controls"):
-                yield Button("Cancel", id="index-cancel")
-                yield Button(
-                    "Index",
-                    id="index-confirm",
-                    variant="primary",
-                    disabled=True,
-                )
-
-    def on_mount(self) -> None:
-        name_input = self.query_one("#index-codebase-name", Input)
-        if not name_input.value and self.selected_path:
-            name_input.value = self.selected_path.name
-        self._update_confirm()
-
-    def _update_confirm(self) -> None:
-        confirm = self.query_one("#index-confirm", Button)
-        name_input = self.query_one("#index-codebase-name", Input)
-        confirm.disabled = not (self.selected_path and name_input.value.strip())
-
-    @on(DirectoryTree.DirectorySelected, "#index-directory-tree")
-    def handle_directory_selected(self, event: DirectoryTree.DirectorySelected) -> None:
-        event.stop()
-        selected = event.path if event.path.is_dir() else event.path.parent
-        self.selected_path = selected
-        name_input = self.query_one("#index-codebase-name", Input)
-        if not name_input.value:
-            name_input.value = selected.name
-        self._update_confirm()
-
-    @on(Input.Changed, "#index-codebase-name")
-    def handle_name_changed(self, event: Input.Changed) -> None:
-        event.stop()
-        self._update_confirm()
-
-    @on(Button.Pressed, "#index-cancel")
-    def handle_cancel(self, event: Button.Pressed) -> None:
-        event.stop()
-        self.dismiss(None)
-
-    @on(Button.Pressed, "#index-confirm")
-    def handle_confirm(self, event: Button.Pressed) -> None:
-        event.stop()
-        name_input = self.query_one("#index-codebase-name", Input)
-        if not self.selected_path:
-            self.dismiss(None)
-            return
-        selection = CodebaseIndexSelection(
-            repo_path=self.selected_path,
-            name=name_input.value.strip(),
-        )
-        self.dismiss(selection)
-
-
 class ChatScreen(Screen[None]):
     CSS_PATH = "chat.tcss"
 
@@ -349,7 +246,9 @@ class ChatScreen(Screen[None]):
         super().__init__()
         # Get the model configuration and services
         model_config = get_provider_model()
-        codebase_service = get_codebase_service()
+        # Use filtered service in TUI to restrict access to CWD codebase only
+        storage_dir = get_shotgun_home() / "codebases"
+        codebase_service = FilteredCodebaseService(storage_dir)
         self.codebase_sdk = CodebaseSDK()
 
         # Create shared deps without system_prompt_fn (agents provide their own)
@@ -387,13 +286,18 @@ class ChatScreen(Screen[None]):
 
     async def on_key(self, event: events.Key) -> None:
         """Handle key presses for cancellation."""
-        # If escape is pressed while agent is working, cancel the operation
-        if event.key == "escape" and self.working and self._current_worker:
-            # Track ESC cancellation event
+        # If escape or ctrl+c is pressed while agent is working, cancel the operation
+        if (
+            event.key in (Keys.Escape, Keys.ControlC)
+            and self.working
+            and self._current_worker
+        ):
+            # Track cancellation event
             track_event(
-                "agent_cancelled_escape",
+                "agent_cancelled",
                 {
                     "agent_mode": self.mode.value,
+                    "cancel_key": event.key,
                 },
             )
 
@@ -404,6 +308,8 @@ class ChatScreen(Screen[None]):
             # Re-enable the input
             prompt_input = self.query_one(PromptInput)
             prompt_input.focus()
+            # Prevent the event from propagating (don't quit the app)
+            event.stop()
 
     @work
     async def check_if_codebase_is_indexed(self) -> None:
@@ -423,6 +329,7 @@ class ChatScreen(Screen[None]):
             self.mount_hint(help_text_with_codebase(already_indexed=True))
             return
 
+        # Ask user if they want to index the current directory
         should_index = await self.app.push_screen_wait(CodebaseIndexPromptScreen())
         if not should_index:
             self.mount_hint(help_text_empty_dir())
@@ -430,7 +337,10 @@ class ChatScreen(Screen[None]):
 
         self.mount_hint(help_text_with_codebase(already_indexed=False))
 
-        self.index_codebase_command()
+        # Auto-index the current directory with its name
+        cwd_name = cur_dir.name
+        selection = CodebaseIndexSelection(repo_path=cur_dir, name=cwd_name)
+        self.call_later(lambda: self.index_codebase(selection))
 
     def watch_mode(self, new_mode: AgentType) -> None:
         """React to mode changes by updating the agent manager."""
@@ -529,12 +439,16 @@ class ChatScreen(Screen[None]):
     @on(PartialResponseMessage)
     def handle_partial_response(self, event: PartialResponseMessage) -> None:
         self.partial_message = event.message
-
         history = self.query_one(ChatHistory)
-        history.update_messages(
-            self.messages + cast(list[ModelMessage | HintMessage], event.messages)
+
+        # Only update messages if the message list changed
+        new_message_list = self.messages + cast(
+            list[ModelMessage | HintMessage], event.messages
         )
+        if len(new_message_list) != len(history.items):
+            history.update_messages(new_message_list)
 
+        # Always update the partial response (reactive property handles the update)
         history.partial_response = self.partial_message
 
     def _clear_partial_response(self) -> None:
@@ -640,16 +554,11 @@ class ChatScreen(Screen[None]):
         return self.placeholder_hints.get_placeholder_for_mode(mode)
 
     def index_codebase_command(self) -> None:
-        start_path = Path.cwd()
-
-        def handle_result(result: CodebaseIndexSelection | None) -> None:
-            if result:
-                self.call_later(lambda: self.index_codebase(result))
-
-        self.app.push_screen(
-            CodebaseIndexScreen(start_path=start_path),
-            handle_result,
-        )
+        # Simplified: always index current working directory with its name
+        cur_dir = Path.cwd().resolve()
+        cwd_name = cur_dir.name
+        selection = CodebaseIndexSelection(repo_path=cur_dir, name=cwd_name)
+        self.call_later(lambda: self.index_codebase(selection))
 
     def delete_codebase_command(self) -> None:
         self.app.push_screen(

{shotgun_sh-0.1.11 → shotgun_sh-0.1.12}/src/shotgun/tui/screens/chat_screen/history.py

@@ -41,7 +41,6 @@ class PartialResponseWidget(Widget):  # TODO: doesn't work lol
         self.item = item
 
     def compose(self) -> ComposeResult:
-        yield Markdown(markdown="**partial response**")
         if self.item is None:
             pass
         elif self.item.kind == "response":
@@ -82,12 +81,14 @@ class ChatHistory(Widget):
         self.items: Sequence[ModelMessage | HintMessage] = []
         self.vertical_tail: VerticalTail | None = None
         self.partial_response = None
+        self._rendered_count = 0  # Track how many messages have been mounted
 
     def compose(self) -> ComposeResult:
         self.vertical_tail = VerticalTail()
 
+        filtered = list(self.filtered_items())
         with self.vertical_tail:
-            for item in self.filtered_items():
+            for item in filtered:
                 if isinstance(item, ModelRequest):
                     yield UserQuestionWidget(item)
                 elif isinstance(item, HintMessage):
@@ -97,7 +98,9 @@ class ChatHistory(Widget):
             yield PartialResponseWidget(self.partial_response).data_bind(
                 item=ChatHistory.partial_response
             )
-        self.call_later(self.autoscroll)
+
+        # Track how many messages were rendered during initial compose
+        self._rendered_count = len(filtered)
 
     def filtered_items(self) -> Generator[ModelMessage | HintMessage, None, None]:
         for idx, next_item in enumerate(self.items):
@@ -138,17 +141,31 @@ class ChatHistory(Widget):
             yield next_item
 
     def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
-        """Update the displayed messages without recomposing."""
+        """Update the displayed messages using incremental mounting."""
         if not self.vertical_tail:
             return
 
         self.items = messages
-        self.refresh(recompose=True)
-        self.call_later(self.autoscroll)
+        filtered = list(self.filtered_items())
+
+        # Only mount new messages that haven't been rendered yet
+        if len(filtered) > self._rendered_count:
+            new_messages = filtered[self._rendered_count :]
+            for item in new_messages:
+                widget: Widget
+                if isinstance(item, ModelRequest):
+                    widget = UserQuestionWidget(item)
+                elif isinstance(item, HintMessage):
+                    widget = HintMessageWidget(item)
+                elif isinstance(item, ModelResponse):
+                    widget = AgentResponseWidget(item)
+                else:
+                    continue
+
+                # Mount before the PartialResponseWidget
+                self.vertical_tail.mount(widget, before=self.vertical_tail.children[-1])
 
-    def autoscroll(self) -> None:
-        if self.vertical_tail:
-            self.vertical_tail.scroll_end(animate=False, immediate=False, force=True)
+            self._rendered_count = len(filtered)
 
 
 class UserQuestionWidget(Widget):
@@ -221,25 +238,97 @@ class AgentResponseWidget(Widget):
                     continue
         return acc.strip()
 
+    def _truncate(self, text: str, max_length: int = 100) -> str:
+        """Truncate text to max_length characters, adding ellipsis if needed."""
+        if len(text) <= max_length:
+            return text
+        return text[: max_length - 3] + "..."
+
+    def _parse_args(self, args: dict[str, object] | str | None) -> dict[str, object]:
+        """Parse tool call arguments, handling both dict and JSON string formats."""
+        if args is None:
+            return {}
+        if isinstance(args, str):
+            try:
+                return json.loads(args) if args.strip() else {}
+            except json.JSONDecodeError:
+                return {}
+        return args if isinstance(args, dict) else {}
+
     def _format_tool_call_part(self, part: ToolCallPart) -> str:
         if part.tool_name == "ask_user":
             return self._format_ask_user_part(part)
+
+        # Parse args once (handles both JSON string and dict)
+        args = self._parse_args(part.args)
+
+        # Codebase tools - show friendly names
+        if part.tool_name == "query_graph":
+            if "query" in args:
+                query = self._truncate(str(args["query"]))
+                return f'Querying code: "{query}"'
+            return "Querying code"
+
+        if part.tool_name == "retrieve_code":
+            if "qualified_name" in args:
+                return f'Retrieving code: "{args["qualified_name"]}"'
+            return "Retrieving code"
+
+        if part.tool_name == "file_read":
+            if "file_path" in args:
+                return f'Reading file: "{args["file_path"]}"'
+            return "Reading file"
+
+        if part.tool_name == "directory_lister":
+            if "directory" in args:
+                return f'Listing directory: "{args["directory"]}"'
+            return "Listing directory"
+
+        if part.tool_name == "codebase_shell":
+            command = args.get("command", "")
+            cmd_args = args.get("args", [])
+            # Handle cmd_args as list of strings
+            if isinstance(cmd_args, list):
+                args_str = " ".join(str(arg) for arg in cmd_args)
+            else:
+                args_str = ""
+            full_cmd = f"{command} {args_str}".strip()
+            if full_cmd:
+                return f'Running shell: "{self._truncate(full_cmd)}"'
+            return "Running shell"
+
+        # File management tools
+        if part.tool_name == "read_file":
+            if "filename" in args:
+                return f'Reading file: "{args["filename"]}"'
+            return "Reading file"
+
+        # Web search tools
+        if part.tool_name in [
+            "openai_web_search_tool",
+            "anthropic_web_search_tool",
+            "gemini_web_search_tool",
+        ]:
+            if "query" in args:
+                query = self._truncate(str(args["query"]))
+                return f'Searching web: "{query}"'
+            return "Searching web"
+
         # write_file
         if part.tool_name == "write_file" or part.tool_name == "append_file":
-            if isinstance(part.args, dict) and "filename" in part.args:
-                return f"{part.tool_name}({part.args['filename']})"
-            else:
-                return f"{part.tool_name}()"
+            if "filename" in args:
+                return f"{part.tool_name}({args['filename']})"
+            return f"{part.tool_name}()"
+
         if part.tool_name == "write_artifact_section":
-            if isinstance(part.args, dict) and "section_title" in part.args:
-                return f"{part.tool_name}({part.args['section_title']})"
-            else:
-                return f"{part.tool_name}()"
+            if "section_title" in args:
+                return f"{part.tool_name}({args['section_title']})"
+            return f"{part.tool_name}()"
+
         if part.tool_name == "create_artifact":
-            if isinstance(part.args, dict) and "name" in part.args:
-                return f"{part.tool_name}({part.args['name']})"
-            else:
-                return f"▪ {part.tool_name}()"
+            if "name" in args:
+                return f"{part.tool_name}({args['name']})"
+            return f"▪ {part.tool_name}()"
 
         return f"{part.tool_name}({part.args})"