shotgun-sh 0.4.0.dev1__py3-none-any.whl → 0.6.2__py3-none-any.whl

shotgun/prompts/agents/specify.j2

@@ -38,6 +38,20 @@ Before I expand it, I have a few questions:
 
 {% include 'agents/partials/router_delegation_mode.j2' %}
 
+## CRITICAL: YOUR OUTPUT IS THE FILE
+
+Your deliverable is specification.md - content must be saved to the file, not just output to chat.
+
+For updates, prefer markdown tools (faster, cheaper, less error-prone):
+- replace_markdown_section - update a specific section
+- insert_markdown_section - add a new section
+- remove_markdown_section - remove a section
+
+Only use write_file when creating the file from scratch or doing major restructuring.
+
+FAILURE: Rewriting the entire file when user asked to update one section
+SUCCESS: Using markdown tools for targeted updates
+
 ## YOUR SCOPE
 
 You are the **Specification agent**. Your files are `specification.md` and `.shotgun/contracts/*` - these are the ONLY files you can write to.

shotgun/prompts/agents/state/codebase/codebase_graphs_available.j2

@@ -5,12 +5,25 @@
 You have access to the following codebase graphs:
 
 {% for graph in codebase_understanding_graphs -%}
+{% if indexing_graph_ids and graph.graph_id in indexing_graph_ids -%}
+- {{ graph.name }} ID: {{ graph.graph_id }} Path: {{ graph.repo_path }} **[INDEXING - NOT AVAILABLE]**
+{% else -%}
 - {{ graph.name }} ID: {{ graph.graph_id }} Path: {{ graph.repo_path }}
+{% endif -%}
 {% endfor -%}
 
+{% if indexing_graph_ids -%}
+
+Note: Graphs marked [INDEXING - NOT AVAILABLE] are currently being built. Do not attempt to query these graphs until indexing is complete.
+{% endif -%}
+
 {% else -%}
 
-{% if is_tui_context -%}
+{% if indexing_graph_ids -%}
+A codebase is currently being indexed. This process can take a few minutes for large codebases. Once indexing completes, you will be able to query the code structure and answer questions about it.
+
+Please ask the user to wait for indexing to finish before asking questions about the codebase.
+{% elif is_tui_context -%}
 No codebase has been indexed yet. To enable code analysis, please tell the user to restart the TUI and follow the prompt to 'Index this codebase?' when it appears.
 {% else -%}
 No codebase has been indexed yet. If the user needs code analysis, ask them to index a codebase first.

shotgun/prompts/agents/state/system_state.j2

@@ -1,24 +1,25 @@
-## System Status
-
+<SYSTEM_STATUS>
 Your training data may be old. The current date and time is: {{ current_datetime }} in {{ timezone_name }} (UTC{{ utc_offset }})
+</SYSTEM_STATUS>
 
 {% include 'agents/state/codebase/codebase_graphs_available.j2' %}
 
 {% if execution_plan %}
-## Current Execution Plan
-
+<EXECUTION_PLAN>
 {{ execution_plan }}
+</EXECUTION_PLAN>
 
 {% if pending_approval %}
-**⚠️ PLAN AWAITING USER APPROVAL**
-
+<PLAN_RULES>
+The current plan is pending approval for the user.
 The plan above requires user approval before execution can begin.
 You MUST call `final_result` now to present this plan to the user.
 Do NOT attempt to delegate to any sub-agents until the user approves.
+</PLAN_RULES>
 {% endif %}
 
 {% endif %}
-## Available Files
+<AVAILABLE_FILES>
 
 {% if existing_files %}
 The following files already exist.
@@ -32,11 +33,12 @@ No research or planning documents exist yet. Refer to your agent-specific instru
 {% endif %}
 
 {% if markdown_toc %}
-## Document Table of Contents - READ THE ENTIRE FILE TO UNDERSTAND MORE
-
+<TABLE_OF_CONTENTS note="READ THE ENTIRE FILE TO UNDERSTAND MORE">
 {{ markdown_toc }}
+</TABLE_OF_CONTENTS>
 
-**IMPORTANT**: The above shows ONLY the Table of Contents from prior stages in the pipeline. Review this context before asking questions or creating new content.
+It is imporant that TABLE_OF_CONTENTS shows ONLY the Table of Contents from prior stages in the pipeline. You must review this context before asking questions or creating new content.
 {% else %}
 Review the existing documents above before adding new content to avoid duplication.
-{% endif %}
+{% endif %}
+</AVAILABLE_FILES>

shotgun/prompts/agents/tasks.j2

@@ -28,6 +28,20 @@ Instead:
 
 {% include 'agents/partials/router_delegation_mode.j2' %}
 
+## CRITICAL: YOUR OUTPUT IS THE FILE
+
+Your deliverable is tasks.md - content must be saved to the file, not just output to chat.
+
+For updates, prefer markdown tools (faster, cheaper, less error-prone):
+- replace_markdown_section - update a specific stage's tasks
+- insert_markdown_section - add a new stage of tasks
+- remove_markdown_section - remove a stage
+
+Only use write_file when creating the file from scratch or doing major restructuring.
+
+FAILURE: Rewriting the entire file when user asked to update one stage
+SUCCESS: Using markdown tools for targeted updates
+
 ## YOUR SCOPE
 
 You are the **Tasks agent**. Your file is `tasks.md` - this is the ONLY file you can write to.

shotgun/settings.py

@@ -10,8 +10,8 @@ Example usage:
     from shotgun.settings import settings
 
     # Access telemetry settings
-    if settings.telemetry.sentry_dsn:
-        sentry_sdk.init(dsn=settings.telemetry.sentry_dsn)
+    if settings.telemetry.posthog_api_key:
+        posthog.init(api_key=settings.telemetry.posthog_api_key)
 
     # Access logging settings
     logger.setLevel(settings.logging.log_level)
@@ -30,7 +30,7 @@ def _get_build_constant(name: str, default: Any = None) -> Any:
     """Get a value from build_constants.py, falling back to default.
 
     Args:
-        name: The constant name to retrieve (e.g., "SENTRY_DSN")
+        name: The constant name to retrieve (e.g., "POSTHOG_API_KEY")
         default: Default value if constant not found
 
     Returns:
@@ -47,14 +47,10 @@ def _get_build_constant(name: str, default: Any = None) -> Any:
 class TelemetrySettings(BaseSettings):
     """Telemetry and observability settings.
 
-    These settings control error tracking (Sentry), analytics (PostHog),
-    and observability (Logfire) integrations.
+    These settings control analytics (PostHog) and observability (Logfire)
+    integrations. PostHog handles both analytics and exception tracking.
     """
 
-    sentry_dsn: str = Field(
-        default_factory=lambda: _get_build_constant("SENTRY_DSN", ""),
-        description="Sentry DSN for error tracking",
-    )
     posthog_api_key: str = Field(
         default_factory=lambda: _get_build_constant("POSTHOG_API_KEY", ""),
         description="PostHog API key for analytics",
@@ -198,6 +194,45 @@ class DevelopmentSettings(BaseSettings):
         return bool(v)
 
 
+class IndexingSettings(BaseSettings):
+    """Codebase indexing settings.
+
+    Controls parallel processing behavior for code indexing.
+    """
+
+    index_parallel: bool = Field(
+        default=True,
+        description="Enable parallel indexing (requires 4+ CPU cores)",
+    )
+    index_workers: int | None = Field(
+        default=None,
+        description="Number of worker processes for parallel indexing (default: CPU count - 1)",
+        ge=1,
+    )
+    index_batch_size: int | None = Field(
+        default=None,
+        description="Files per batch for parallel indexing (default: auto-calculated)",
+        ge=1,
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="SHOTGUN_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @field_validator("index_parallel", mode="before")
+    @classmethod
+    def parse_bool(cls, v: Any) -> bool:
+        """Parse boolean values from strings."""
+        if isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            return v.lower() in ("true", "1", "yes")
+        return bool(v)
+
+
 class Settings(BaseSettings):
     """Main application settings with SHOTGUN_ prefix.
 
@@ -208,7 +243,6 @@ class Settings(BaseSettings):
         from shotgun.settings import settings
 
         # Telemetry settings
-        settings.telemetry.sentry_dsn
         settings.telemetry.posthog_api_key
         settings.telemetry.logfire_enabled
 
@@ -223,12 +257,17 @@ class Settings(BaseSettings):
         # Development settings
         settings.dev.home
         settings.dev.pipx_simulate
+
+        # Indexing settings
+        settings.indexing.index_parallel
+        settings.indexing.index_workers
     """
 
     telemetry: TelemetrySettings = Field(default_factory=TelemetrySettings)
     logging: LoggingSettings = Field(default_factory=LoggingSettings)
     api: ApiSettings = Field(default_factory=ApiSettings)
     dev: DevelopmentSettings = Field(default_factory=DevelopmentSettings)
+    indexing: IndexingSettings = Field(default_factory=IndexingSettings)
 
     model_config = SettingsConfigDict(
         env_prefix="SHOTGUN_",

shotgun/tui/app.py

@@ -1,5 +1,13 @@
+from __future__ import annotations
+
+import os
+import platform
+import sys
 from collections.abc import Iterable
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from shotgun.codebase.core.errors import DatabaseIssue
 
 from textual.app import App, SystemCommand
 from textual.binding import Binding
@@ -45,7 +53,10 @@ class ShotgunApp(App[None]):
         "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
-        Binding("ctrl+c", "quit", "Quit the app"),
+        # Use smart_quit to support ctrl+c for copying selected text
+        Binding("ctrl+c", "smart_quit", "Quit/Copy", show=False),
+        # Cancel quit confirmation with ESC
+        Binding("escape", "cancel_quit", "Cancel Quit", show=False),
     ]
 
     CSS_PATH = "styles.tcss"
@@ -57,6 +68,7 @@ class ShotgunApp(App[None]):
         force_reindex: bool = False,
         show_pull_hint: bool = False,
         pull_version_id: str | None = None,
+        pending_db_issues: list[DatabaseIssue] | None = None,
     ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
@@ -65,6 +77,12 @@ class ShotgunApp(App[None]):
         self.force_reindex = force_reindex
         self.show_pull_hint = show_pull_hint
         self.pull_version_id = pull_version_id
+        # Database issues detected at startup (locked, corrupted, timeout)
+        # These will be shown to the user via dialogs when ChatScreen mounts
+        self.pending_db_issues = pending_db_issues or []
+
+        # Quit confirmation state for double Ctrl+C to quit
+        self._quit_pending = False
 
         # Initialize dependency injection container
         self.container = TUIContainer()
@@ -227,6 +245,63 @@ class ShotgunApp(App[None]):
         # Continue to ChatScreen
         self.refresh_startup_screen()
 
+    @property
+    def quit_pending(self) -> bool:
+        """Whether a quit confirmation is pending.
+
+        Returns True if user pressed Ctrl+C and needs to press again or ESC to cancel.
+        """
+        return self._quit_pending
+
+    def _reset_quit_pending(self) -> None:
+        """Reset the quit confirmation state and refresh the status bar."""
+        self._quit_pending = False
+        self._refresh_status_bar()
+
+    def _refresh_status_bar(self) -> None:
+        """Refresh the StatusBar widget to reflect current state."""
+        from textual.css.query import NoMatches
+
+        from shotgun.tui.components.status_bar import StatusBar
+
+        try:
+            status_bar = self.screen.query_one(StatusBar)
+            status_bar.refresh()
+        except NoMatches:
+            # StatusBar might not exist on all screens
+            pass
+
+    def action_cancel_quit(self) -> None:
+        """Cancel the quit confirmation when ESC is pressed."""
+        if self._quit_pending:
+            self._reset_quit_pending()
+
+    async def action_smart_quit(self) -> None:
+        """Handle ctrl+c: copy selected text if any, otherwise quit.
+
+        This allows users to select text in the TUI and copy it with ctrl+c,
+        while still supporting ctrl+c to quit when no text is selected.
+        Requires pressing Ctrl+C twice to quit, or ESC to cancel.
+        """
+        # Check if there's selected text on the current screen
+        selected_text = self.screen.get_selected_text()
+        if selected_text:
+            # Copy selected text to clipboard
+            self.copy_to_clipboard(selected_text)
+            # Clear the selection after copying
+            self.screen.clear_selection()
+            self.notify("Copied to clipboard", timeout=2)
+            return
+
+        # No selection - check if quit is already pending
+        if self._quit_pending:
+            await self.action_quit()
+            return
+
+        # Start quit confirmation
+        self._quit_pending = True
+        self._refresh_status_bar()
+
     async def action_quit(self) -> None:
         """Quit the application."""
         # Shut down PostHog client to prevent threading errors
@@ -249,6 +324,22 @@ class ShotgunApp(App[None]):
         self.push_screen(GitHubIssueScreen())
 
 
+def _log_startup_info() -> None:
+    """Log startup information for debugging purposes."""
+    # Import here to avoid circular import (shotgun.__init__ imports from submodules)
+    from shotgun import __version__
+
+    logger.info("=" * 60)
+    logger.info("Shotgun TUI Starting")
+    logger.info("=" * 60)
+    logger.info(f"  Version: {__version__}")
+    logger.info(f"  Python: {sys.version.split()[0]}")
+    logger.info(f"  Platform: {platform.system()} {platform.release()}")
+    logger.info(f"  Architecture: {platform.machine()}")
+    logger.info(f"  Working Directory: {os.getcwd()}")
+    logger.info("=" * 60)
+
+
 def run(
     no_update_check: bool = False,
     continue_session: bool = False,
@@ -265,24 +356,54 @@ def run(
         show_pull_hint: If True, show hint about recently pulled spec.
         pull_version_id: If provided, pull this spec version before showing ChatScreen.
     """
-    # Clean up any corrupted databases BEFORE starting the TUI
-    # This prevents crashes from corrupted databases during initialization
+    # Log startup information
+    _log_startup_info()
+
+    # Detect database issues BEFORE starting the TUI (but don't auto-delete)
+    # Issues will be presented to the user via dialogs once the TUI is running
     import asyncio
 
+    from shotgun.codebase.core.errors import KuzuErrorType
     from shotgun.codebase.core.manager import CodebaseGraphManager
     from shotgun.utils import get_shotgun_home
 
     storage_dir = get_shotgun_home() / "codebases"
     manager = CodebaseGraphManager(storage_dir)
 
+    pending_db_issues: list[DatabaseIssue] = []
     try:
-        removed = asyncio.run(manager.cleanup_corrupted_databases())
-        if removed:
-            logger.info(
-                f"Cleaned up {len(removed)} corrupted database(s) before TUI startup"
-            )
+        # First pass: 10-second timeout
+        issues = asyncio.run(manager.detect_database_issues(timeout_seconds=10.0))
+        if issues:
+            # Categorize issues for logging
+            for issue in issues:
+                logger.info(
+                    f"Detected database issue: {issue.graph_id} - "
+                    f"{issue.error_type.value}: {issue.message}"
+                )
+
+            # Only pass issues that require user interaction to the TUI
+            # Schema issues (incomplete builds) can be auto-cleaned silently
+            user_facing_issues = [
+                i
+                for i in issues
+                if i.error_type
+                in (
+                    KuzuErrorType.LOCKED,
+                    KuzuErrorType.CORRUPTION,
+                    KuzuErrorType.TIMEOUT,
+                )
+            ]
+
+            # Auto-delete schema issues (incomplete builds) - safe to remove
+            schema_issues = [i for i in issues if i.error_type == KuzuErrorType.SCHEMA]
+            for issue in schema_issues:
+                asyncio.run(manager.delete_database(issue.graph_id))
+                logger.info(f"Auto-removed incomplete database: {issue.graph_id}")
+
+            pending_db_issues = user_facing_issues
     except Exception as e:
-        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        logger.error(f"Failed to detect database issues: {e}")
         # Continue anyway - the TUI can still function
 
     app = ShotgunApp(
@@ -291,6 +412,7 @@ def run(
         force_reindex=force_reindex,
         show_pull_hint=show_pull_hint,
         pull_version_id=pull_version_id,
+        pending_db_issues=pending_db_issues,
     )
     app.run(inline_no_clear=True)
 
@@ -313,12 +435,14 @@ def serve(
         continue_session: If True, continue from previous conversation.
         force_reindex: If True, force re-indexing of codebase (ignores existing index).
     """
-    # Clean up any corrupted databases BEFORE starting the TUI
-    # This prevents crashes from corrupted databases during initialization
+    # Detect database issues BEFORE starting the TUI
+    # Note: In serve mode, issues are logged but user interaction happens in
+    # the spawned process via run()
     import asyncio
 
     from textual_serve.server import Server
 
+    from shotgun.codebase.core.errors import KuzuErrorType
     from shotgun.codebase.core.manager import CodebaseGraphManager
     from shotgun.utils import get_shotgun_home
 
@@ -326,13 +450,20 @@ def serve(
     manager = CodebaseGraphManager(storage_dir)
 
     try:
-        removed = asyncio.run(manager.cleanup_corrupted_databases())
-        if removed:
-            logger.info(
-                f"Cleaned up {len(removed)} corrupted database(s) before TUI startup"
-            )
+        issues = asyncio.run(manager.detect_database_issues(timeout_seconds=10.0))
+        if issues:
+            for issue in issues:
+                logger.info(
+                    f"Detected database issue: {issue.graph_id} - "
+                    f"{issue.error_type.value}: {issue.message}"
+                )
+            # Auto-delete only schema issues (incomplete builds)
+            schema_issues = [i for i in issues if i.error_type == KuzuErrorType.SCHEMA]
+            for issue in schema_issues:
+                asyncio.run(manager.delete_database(issue.graph_id))
+                logger.info(f"Auto-removed incomplete database: {issue.graph_id}")
     except Exception as e:
-        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        logger.error(f"Failed to detect database issues: {e}")
         # Continue anyway - the TUI can still function
 
     # Create a new event loop after asyncio.run() closes the previous one

shotgun/tui/commands/__init__.py

@@ -54,10 +54,18 @@ class CommandHandler:
 **Commands:**
 • `/help` - Show this help message
 
+**Shell Commands:**
+• `!<command>` - Execute shell commands directly (e.g., `!ls`, `!git status`)
+  - Commands run in your current working directory
+  - Output is displayed in the chat (not sent to AI)
+  - Commands are NOT added to conversation history
+  - Leading whitespace is allowed: `  !echo hi` works
+  - Note: `!!` is treated as `!` (no history expansion in this version)
+
 **Keyboard Shortcuts:**
 
 * `Enter` - Send message
-* `Ctrl+P` - Open command palette (for usage, context, and other commands)
+* `/` - Open command palette (for usage, context, and other commands)
 * `Shift+Tab` - Cycle agent modes
 * `Ctrl+C` - Quit application
 

shotgun/tui/components/attachment_bar.py

@@ -0,0 +1,87 @@
+"""Attachment bar widget for showing pending file attachment."""
+
+from textual.app import ComposeResult
+from textual.css.query import NoMatches
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Static
+
+from shotgun.attachments import (
+    AttachmentBarState,
+    FileAttachment,
+    format_file_size,
+    get_attachment_icon,
+)
+
+
+class AttachmentBar(Widget):
+    """Widget showing pending attachment above input.
+
+    Displays format: [icon filename.ext (size)]
+    Hidden when no attachment is pending.
+
+    Styles defined in chat.tcss.
+    """
+
+    state: reactive[AttachmentBarState] = reactive(AttachmentBarState, init=False)
+
+    def __init__(
+        self,
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the attachment bar.
+
+        Args:
+            name: Optional widget name.
+            id: Optional widget ID.
+            classes: Optional CSS classes.
+        """
+        super().__init__(name=name, id=id, classes=classes)
+        self.state = AttachmentBarState(attachment=None)
+        self.add_class("hidden")
+
+    def compose(self) -> ComposeResult:
+        """Compose the attachment bar widget."""
+        yield Static("", id="attachment-display")
+
+    def update_attachment(self, attachment: FileAttachment | None) -> None:
+        """Update the displayed attachment.
+
+        Args:
+            attachment: FileAttachment to display, or None to hide bar.
+        """
+        self.state = AttachmentBarState(attachment=attachment)
+
+        if attachment is None:
+            self.add_class("hidden")
+        else:
+            self.remove_class("hidden")
+            self._refresh_display()
+
+    def _refresh_display(self) -> None:
+        """Refresh the attachment display text."""
+        attachment = self.state.attachment
+        if attachment is None:
+            return
+
+        icon = get_attachment_icon(attachment.file_type)
+        size_str = format_file_size(attachment.file_size_bytes)
+        display_text = f"[{icon} {attachment.file_name} ({size_str})]"
+
+        try:
+            display_widget = self.query_one("#attachment-display", Static)
+            display_widget.update(display_text)
+        except NoMatches:
+            pass  # Widget not mounted yet
+
+    def watch_state(self, new_state: AttachmentBarState) -> None:
+        """React to state changes.
+
+        Args:
+            new_state: The new attachment bar state.
+        """
+        if new_state.attachment is not None:
+            self._refresh_display()

shotgun/tui/components/prompt_input.py

@@ -27,43 +27,40 @@ class PromptInput(TextArea):
             super().__init__()
             self.text = text
 
+    class OpenCommandPalette(Message):
+        """Request to open the command palette."""
+
     def action_submit(self) -> None:
         """An action to submit the text."""
         self.post_message(self.Submitted(self.text))
 
-    async def _on_key(self, event: events.Key) -> None:
-        """Handle key presses which correspond to document inserts."""
-
-        # Don't handle Enter key here - let the binding handle it
+    def on_key(self, event: events.Key) -> None:
+        """Handle key presses for special actions."""
+        # Submit on Enter
         if event.key == "enter":
+            event.stop()
+            event.prevent_default()
             self.action_submit()
-
-        self._restart_blink()
-
-        if self.read_only:
             return
 
-        key = event.key
-        insert_values = {
-            "ctrl+j": "\n",
-        }
-        if self.tab_behavior == "indent":
-            if key == "escape":
-                event.stop()
-                event.prevent_default()
-                self.screen.focus_next()
-                return
-            if self.indent_type == "tabs":
-                insert_values["tab"] = "\t"
-            else:
-                insert_values["tab"] = " " * self._find_columns_to_next_tab_stop()
+        # Detect "/" as first character to trigger command palette
+        if event.character == "/" and not self.text.strip():
+            event.stop()
+            event.prevent_default()
+            self.post_message(self.OpenCommandPalette())
+            return
 
-        if event.is_printable or key in insert_values:
+        # Handle ctrl+j or shift+enter for newline (since enter is for submit)
+        # Note: shift+enter only works if terminal is configured to send escape sequence
+        # Common terminals: iTerm2, VS Code, WezTerm can be configured for this
+        if event.key in ("ctrl+j", "shift+enter"):
             event.stop()
             event.prevent_default()
-            insert = insert_values.get(key, event.character)
-            # `insert` is not None because event.character cannot be
-            # None because we've checked that it's printable.
-            assert insert is not None  # noqa: S101
             start, end = self.selection
-            self._replace_via_keyboard(insert, start, end)
+            self.replace(
+                "\n",
+                start,
+                end,
+                maintain_selection_offset=False,
+            )
+            return