shotgun-sh 0.2.9.dev1__tar.gz → 0.2.10.dev1__tar.gz

{shotgun_sh-0.2.9.dev1 → shotgun_sh-0.2.10.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.2.9.dev1
+Version: 0.2.10.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
@@ -36,6 +36,7 @@ Requires-Dist: sentencepiece>=0.2.0
 Requires-Dist: sentry-sdk[pure-eval]>=2.0.0
 Requires-Dist: tenacity>=8.0.0
 Requires-Dist: textual-dev>=1.7.0
+Requires-Dist: textual-serve>=0.1.0
 Requires-Dist: textual>=6.1.0
 Requires-Dist: tiktoken>=0.7.0
 Requires-Dist: tree-sitter-go>=0.23.0

{shotgun_sh-0.2.9.dev1 → shotgun_sh-0.2.10.dev1}/README.md

@@ -408,6 +408,90 @@ export SENTRY_DSN=your-sentry-dsn
 - **Opt-in for development**: Telemetry requires explicit environment variables
 - **Automatic in production**: Production builds include telemetry for error tracking
 
+## Docker
+
+Run Shotgun in a Docker container with web access.
+
+### Using Pre-built Images (Recommended)
+
+Pull the official image from GitHub Container Registry:
+
+```bash
+# Pull latest stable version
+docker pull ghcr.io/shotgun-sh/shotgun:latest
+
+# Or pull a specific version
+docker pull ghcr.io/shotgun-sh/shotgun:v0.1.0
+
+# Or pull development version
+docker pull ghcr.io/shotgun-sh/shotgun:dev
+```
+
+Then run:
+
+```bash
+docker run -p 8000:8000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+```
+
+**Note:** The Docker image automatically includes `--force-reindex` to ensure fresh indexing on startup. You don't need to add any additional flags.
+
+### Building from Source (Optional)
+
+If you prefer to build the image yourself:
+
+```bash
+docker build -t shotgun:latest .
+```
+
+### Run the Container
+
+The container requires two volume mounts:
+1. Your codebase/workspace directory (mounted to `/workspace`)
+2. Config directory for API keys and settings (mounted to `/home/shotgun/.shotgun-sh`)
+
+```bash
+# Basic usage (serves on port 8000)
+docker run -p 8000:8000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+
+# Custom port
+docker run -p 3000:3000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check --port 3000
+
+# Different codebase directory
+docker run -p 8000:8000 \
+  -v /path/to/your/project:/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+
+# Run in background with auto-restart
+docker run -d --restart unless-stopped \
+  --name shotgun-web \
+  -p 8000:8000 \
+  -v $(pwd):/workspace \
+  -v ~/.shotgun-sh:/home/shotgun/.shotgun-sh \
+  ghcr.io/shotgun-sh/shotgun:latest --no-update-check
+```
+
+**All Docker commands automatically include `--force-reindex`** - you don't need to specify it. The flag is baked into the Docker image's ENTRYPOINT to ensure reliable codebase indexing in containerized environments.
+
+### Configuration
+
+On first run, configure your API keys through the web UI. The configuration will persist in the mounted `~/.shotgun-sh` directory.
+
+Access the web interface at `http://localhost:8000` (or your custom port).
+
+### Codebase Indexing in Docker
+
+The Docker image automatically prompts you to index the codebase on each startup. This ensures you're always working with up-to-date code analysis, even if the container restarts or you mount a different directory. Simply click "Index now" when prompted.
+
 ## Support
 
 Join our discord https://discord.gg/5RmY6J2N7s

{shotgun_sh-0.2.9.dev1 → shotgun_sh-0.2.10.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shotgun-sh"
-version = "0.2.9.dev1"
+version = "0.2.10.dev1"
 description = "AI-powered research, planning, and task management CLI tool"
 readme = "README_PYPI.md"
 license = { text = "MIT" }
@@ -32,6 +32,7 @@ dependencies = [
     "posthog>=3.0.0",
     "textual>=6.1.0",
     "textual-dev>=1.7.0",
+    "textual-serve>=0.1.0",
     "kuzu>=0.7.0",
     "tree-sitter>=0.21.0",
     "tree-sitter-python>=0.23.0",

{shotgun_sh-0.2.9.dev1 → shotgun_sh-0.2.10.dev1}/src/shotgun/main.py

@@ -125,6 +125,41 @@ def main(
             help="Continue previous TUI conversation",
         ),
     ] = False,
+    web: Annotated[
+        bool,
+        typer.Option(
+            "--web",
+            help="Serve TUI as web application",
+        ),
+    ] = False,
+    port: Annotated[
+        int,
+        typer.Option(
+            "--port",
+            help="Port for web server (only used with --web)",
+        ),
+    ] = 8000,
+    host: Annotated[
+        str,
+        typer.Option(
+            "--host",
+            help="Host address for web server (only used with --web)",
+        ),
+    ] = "localhost",
+    public_url: Annotated[
+        str | None,
+        typer.Option(
+            "--public-url",
+            help="Public URL if behind proxy (only used with --web)",
+        ),
+    ] = None,
+    force_reindex: Annotated[
+        bool,
+        typer.Option(
+            "--force-reindex",
+            help="Force re-indexing of codebase (ignores existing index)",
+        ),
+    ] = False,
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
@@ -134,16 +169,35 @@ def main(
         perform_auto_update_async(no_update_check=no_update_check)
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
-        logger.debug("Launching shotgun TUI application")
-        try:
-            tui_app.run(
-                no_update_check=no_update_check, continue_session=continue_session
-            )
-        finally:
-            # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
-            from shotgun.posthog_telemetry import shutdown
-
-            shutdown()
+        if web:
+            logger.debug("Launching shotgun TUI as web application")
+            try:
+                tui_app.serve(
+                    host=host,
+                    port=port,
+                    public_url=public_url,
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if server exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
+        else:
+            logger.debug("Launching shotgun TUI application")
+            try:
+                tui_app.run(
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            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.2.9.dev1 → shotgun_sh-0.2.10.dev1}/src/shotgun/tui/app.py

@@ -36,12 +36,16 @@ class ShotgunApp(App[None]):
     CSS_PATH = "styles.tcss"
 
     def __init__(
-        self, no_update_check: bool = False, continue_session: bool = False
+        self,
+        no_update_check: bool = False,
+        continue_session: bool = False,
+        force_reindex: bool = False,
     ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
         self.no_update_check = no_update_check
         self.continue_session = continue_session
+        self.force_reindex = force_reindex
 
         # Start async update check and install
         if not no_update_check:
@@ -87,8 +91,12 @@ class ShotgunApp(App[None]):
 
         if isinstance(self.screen, ChatScreen):
             return
-        # Pass continue_session flag to ChatScreen
-        self.push_screen(ChatScreen(continue_session=self.continue_session))
+        # Pass continue_session and force_reindex flags to ChatScreen
+        self.push_screen(
+            ChatScreen(
+                continue_session=self.continue_session, force_reindex=self.force_reindex
+            )
+        )
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -121,12 +129,17 @@ class ShotgunApp(App[None]):
         self.push_screen(FeedbackScreen(), callback=handle_feedback)
 
 
-def run(no_update_check: bool = False, continue_session: bool = False) -> None:
+def run(
+    no_update_check: bool = False,
+    continue_session: bool = False,
+    force_reindex: bool = False,
+) -> None:
     """Run the TUI application.
 
     Args:
         no_update_check: If True, disable automatic update checks.
         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
@@ -148,9 +161,133 @@ def run(no_update_check: bool = False, continue_session: bool = False) -> None:
         logger.error(f"Failed to cleanup corrupted databases: {e}")
         # Continue anyway - the TUI can still function
 
-    app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
+    app = ShotgunApp(
+        no_update_check=no_update_check,
+        continue_session=continue_session,
+        force_reindex=force_reindex,
+    )
     app.run(inline_no_clear=True)
 
 
+def serve(
+    host: str = "localhost",
+    port: int = 8000,
+    public_url: str | None = None,
+    no_update_check: bool = False,
+    continue_session: bool = False,
+    force_reindex: bool = False,
+) -> None:
+    """Serve the TUI application as a web application.
+
+    Args:
+        host: Host address for the web server.
+        port: Port number for the web server.
+        public_url: Public URL if behind a proxy.
+        no_update_check: If True, disable automatic update checks.
+        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
+    import asyncio
+
+    from textual_serve.server import Server
+
+    from shotgun.codebase.core.manager import CodebaseGraphManager
+    from shotgun.utils import get_shotgun_home
+
+    storage_dir = get_shotgun_home() / "codebases"
+    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"
+            )
+    except Exception as e:
+        logger.error(f"Failed to cleanup corrupted databases: {e}")
+        # Continue anyway - the TUI can still function
+
+    # Create a new event loop after asyncio.run() closes the previous one
+    # This is needed for the Server.serve() method
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    # Build the command string based on flags
+    command = "shotgun"
+    if no_update_check:
+        command += " --no-update-check"
+    if continue_session:
+        command += " --continue"
+    if force_reindex:
+        command += " --force-reindex"
+
+    # Create and start the server with hardcoded title and debug=False
+    server = Server(
+        command=command,
+        host=host,
+        port=port,
+        title="The Shotgun",
+        public_url=public_url,
+    )
+
+    # Set up graceful shutdown on SIGTERM/SIGINT
+    import signal
+    import sys
+
+    def signal_handler(_signum: int, _frame: Any) -> None:
+        """Handle shutdown signals gracefully."""
+        from shotgun.posthog_telemetry import shutdown
+
+        logger.info("Received shutdown signal, cleaning up...")
+        # Restore stdout/stderr before shutting down
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        shutdown()
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Suppress the textual-serve banner by redirecting stdout/stderr
+    import io
+
+    # Capture and suppress the banner, but show the actual serving URL
+    original_stdout = sys.stdout
+    original_stderr = sys.stderr
+
+    captured_output = io.StringIO()
+    sys.stdout = captured_output
+    sys.stderr = captured_output
+
+    try:
+        # This will print the banner to our captured output
+        import logging
+
+        # Temporarily set logging to ERROR level to suppress INFO messages
+        textual_serve_logger = logging.getLogger("textual_serve")
+        original_level = textual_serve_logger.level
+        textual_serve_logger.setLevel(logging.ERROR)
+
+        # Print our own message to the original stdout
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        print(f"Serving Shotgun TUI at http://{host}:{port}")
+        print("Press Ctrl+C to quit")
+
+        # Now suppress output again for the serve call
+        sys.stdout = captured_output
+        sys.stderr = captured_output
+
+        server.serve(debug=False)
+    finally:
+        # Restore original stdout/stderr
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        if "textual_serve_logger" in locals():
+            textual_serve_logger.setLevel(original_level)
+
+
 if __name__ == "__main__":
     run()

{shotgun_sh-0.2.9.dev1 → shotgun_sh-0.2.10.dev1}/src/shotgun/tui/screens/chat.py

@@ -291,7 +291,9 @@ class ChatScreen(Screen[None]):
     qa_current_index = reactive(0)
     qa_answers: list[str] = []
 
-    def __init__(self, continue_session: bool = False) -> None:
+    def __init__(
+        self, continue_session: bool = False, force_reindex: bool = False
+    ) -> None:
         super().__init__()
         # Get the model configuration and services
         model_config = get_provider_model()
@@ -319,6 +321,7 @@ class ChatScreen(Screen[None]):
         self.placeholder_hints = PlaceholderHints()
         self.conversation_manager = ConversationManager()
         self.continue_session = continue_session
+        self.force_reindex = force_reindex
 
     def on_mount(self) -> None:
         self.query_one(PromptInput).focus(scroll_visible=True)
@@ -378,6 +381,22 @@ class ChatScreen(Screen[None]):
         if is_empty or self.continue_session:
             return
 
+        # If force_reindex is True, delete any existing graphs for this directory
+        if self.force_reindex:
+            accessible_graphs = (
+                await self.codebase_sdk.list_codebases_for_directory()
+            ).graphs
+            for graph in accessible_graphs:
+                try:
+                    await self.codebase_sdk.delete_codebase(graph.graph_id)
+                    logger.info(
+                        f"Deleted existing graph {graph.graph_id} due to --force-reindex"
+                    )
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to delete graph {graph.graph_id} during force reindex: {e}"
+                    )
+
         # Check if the current directory has any accessible codebases
         accessible_graphs = (
             await self.codebase_sdk.list_codebases_for_directory()