shotgun-sh 0.1.0.dev1__py3-none-any.whl

shotgun/sdk/codebase.py

@@ -0,0 +1,195 @@
+"""Codebase SDK for framework-agnostic business logic."""
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from shotgun.codebase.models import CodebaseGraph, QueryType
+
+from .exceptions import CodebaseNotFoundError, InvalidPathError
+from .models import (
+    DeleteResult,
+    IndexResult,
+    InfoResult,
+    ListResult,
+    QueryCommandResult,
+    ReindexResult,
+)
+from .services import get_codebase_service
+
+
+class CodebaseSDK:
+    """Framework-agnostic SDK for codebase operations.
+
+    This SDK provides business logic for codebase management that can be
+    used by both CLI and TUI implementations without framework dependencies.
+    """
+
+    def __init__(self, storage_dir: Path | None = None):
+        """Initialize SDK with optional storage directory.
+
+        Args:
+            storage_dir: Optional custom storage directory.
+                        Defaults to ~/.shotgun-sh/codebases/
+        """
+        self.service = get_codebase_service(storage_dir)
+
+    async def list_codebases(self) -> ListResult:
+        """List all indexed codebases.
+
+        Returns:
+            ListResult containing list of codebases
+        """
+        graphs = await self.service.list_graphs()
+        return ListResult(graphs=graphs)
+
+    async def index_codebase(self, path: Path, name: str) -> IndexResult:
+        """Index a new codebase.
+
+        Args:
+            path: Path to the repository to index
+            name: Human-readable name for the codebase
+
+        Returns:
+            IndexResult with indexing details
+
+        Raises:
+            InvalidPathError: If the path does not exist
+        """
+        resolved_path = path.resolve()
+        if not resolved_path.exists():
+            raise InvalidPathError(f"Path does not exist: {resolved_path}")
+
+        graph = await self.service.create_graph(resolved_path, name)
+        file_count = sum(graph.language_stats.values()) if graph.language_stats else 0
+
+        return IndexResult(
+            graph_id=graph.graph_id,
+            name=name,
+            repo_path=str(resolved_path),
+            file_count=file_count,
+            node_count=graph.node_count,
+            relationship_count=graph.relationship_count,
+        )
+
+    async def delete_codebase(
+        self,
+        graph_id: str,
+        confirm_callback: Callable[[CodebaseGraph], bool]
+        | Callable[[CodebaseGraph], Awaitable[bool]]
+        | None = None,
+    ) -> DeleteResult:
+        """Delete a codebase with optional confirmation.
+
+        Args:
+            graph_id: ID of the graph to delete
+            confirm_callback: Optional callback for confirmation.
+                            Can be sync or async function that receives
+                            the CodebaseGraph object and returns boolean.
+
+        Returns:
+            DeleteResult indicating success, failure, or cancellation
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        # Handle confirmation callback if provided
+        if confirm_callback:
+            if asyncio.iscoroutinefunction(confirm_callback):
+                confirmed = await confirm_callback(graph)
+            else:
+                confirmed = confirm_callback(graph)
+
+            if not confirmed:
+                return DeleteResult(
+                    graph_id=graph_id,
+                    name=graph.name,
+                    deleted=False,
+                    cancelled=True,
+                )
+
+        await self.service.delete_graph(graph_id)
+        return DeleteResult(
+            graph_id=graph_id,
+            name=graph.name,
+            deleted=True,
+            cancelled=False,
+        )
+
+    async def get_info(self, graph_id: str) -> InfoResult:
+        """Get detailed information about a codebase.
+
+        Args:
+            graph_id: ID of the graph to get info for
+
+        Returns:
+            InfoResult with detailed graph information
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        return InfoResult(graph=graph)
+
+    async def query_codebase(
+        self, graph_id: str, query_text: str, query_type: QueryType
+    ) -> QueryCommandResult:
+        """Query a codebase using natural language or Cypher.
+
+        Args:
+            graph_id: ID of the graph to query
+            query_text: Query text (natural language or Cypher)
+            query_type: Type of query (NATURAL_LANGUAGE or CYPHER)
+
+        Returns:
+            QueryCommandResult with query results
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        query_result = await self.service.execute_query(
+            graph_id, query_text, query_type
+        )
+
+        return QueryCommandResult(
+            graph_name=graph.name,
+            query_type="Cypher"
+            if query_type == QueryType.CYPHER
+            else "natural language",
+            result=query_result,
+        )
+
+    async def reindex_codebase(self, graph_id: str) -> ReindexResult:
+        """Reindex an existing codebase.
+
+        Args:
+            graph_id: ID of the graph to reindex
+
+        Returns:
+            ReindexResult with reindexing details
+
+        Raises:
+            CodebaseNotFoundError: If the graph is not found
+        """
+        graph = await self.service.get_graph(graph_id)
+        if not graph:
+            raise CodebaseNotFoundError(f"Graph not found: {graph_id}")
+
+        stats = await self.service.reindex_graph(graph_id)
+
+        return ReindexResult(
+            graph_id=graph_id,
+            name=graph.name,
+            stats=stats,
+        )

shotgun/sdk/exceptions.py

@@ -0,0 +1,17 @@
+"""SDK-specific exceptions."""
+
+
+class ShotgunSDKError(Exception):
+    """Base exception for all SDK operations."""
+
+
+class CodebaseNotFoundError(ShotgunSDKError):
+    """Raised when a codebase or graph is not found."""
+
+
+class CodebaseOperationError(ShotgunSDKError):
+    """Raised when a codebase operation fails."""
+
+
+class InvalidPathError(ShotgunSDKError):
+    """Raised when a provided path is invalid."""

shotgun/sdk/models.py

@@ -0,0 +1,189 @@
+"""Result models for SDK operations."""
+
+from typing import Any
+
+from pydantic import BaseModel
+
+from shotgun.codebase.models import CodebaseGraph, QueryResult
+
+
+class ListResult(BaseModel):
+    """Result for list command."""
+
+    graphs: list[CodebaseGraph]
+
+    def __str__(self) -> str:
+        """Format list result as plain text table."""
+        if not self.graphs:
+            return "No codebases found."
+
+        lines = [
+            f"{'ID':<12} {'Name':<30} {'Status':<10} {'Files':<8} {'Path'}",
+            "-" * 80,
+        ]
+
+        for graph in self.graphs:
+            file_count = (
+                sum(graph.language_stats.values()) if graph.language_stats else 0
+            )
+            lines.append(
+                f"{graph.graph_id[:12]:<12} {graph.name[:30]:<30} {graph.status.value:<10} {file_count:<8} {graph.repo_path}"
+            )
+
+        return "\n".join(lines)
+
+
+class IndexResult(BaseModel):
+    """Result for index command."""
+
+    graph_id: str
+    name: str
+    repo_path: str
+    file_count: int
+    node_count: int
+    relationship_count: int
+
+    def __str__(self) -> str:
+        """Format index result as success message."""
+        return (
+            "Successfully indexed codebase!\n"
+            f"Graph ID: {self.graph_id}\n"
+            f"Files processed: {self.file_count}\n"
+            f"Nodes: {self.node_count}\n"
+            f"Relationships: {self.relationship_count}"
+        )
+
+
+class DeleteResult(BaseModel):
+    """Result for delete command."""
+
+    graph_id: str
+    name: str
+    deleted: bool
+    cancelled: bool = False
+
+    def __str__(self) -> str:
+        """Format delete result message."""
+        if self.cancelled:
+            return "Deletion cancelled."
+        elif self.deleted:
+            return f"Successfully deleted codebase: {self.graph_id}"
+        else:
+            return f"Failed to delete codebase: {self.graph_id}"
+
+
+class InfoResult(BaseModel):
+    """Result for info command."""
+
+    graph: CodebaseGraph
+
+    def __str__(self) -> str:
+        """Format detailed graph information."""
+        graph = self.graph
+        lines = [
+            f"Graph ID: {graph.graph_id}",
+            f"Name: {graph.name}",
+            f"Status: {graph.status.value}",
+            f"Repository Path: {graph.repo_path}",
+            f"Database Path: {graph.graph_path}",
+            f"Created: {graph.created_at}",
+            f"Updated: {graph.updated_at}",
+            f"Schema Version: {graph.schema_version}",
+            f"Total Nodes: {graph.node_count}",
+            f"Total Relationships: {graph.relationship_count}",
+        ]
+
+        if graph.language_stats:
+            lines.append("\nLanguage Statistics:")
+            for lang, count in graph.language_stats.items():
+                lines.append(f"  {lang}: {count} files")
+
+        if graph.node_stats:
+            lines.append("\nNode Statistics:")
+            for node_type, count in graph.node_stats.items():
+                lines.append(f"  {node_type}: {count}")
+
+        if graph.relationship_stats:
+            lines.append("\nRelationship Statistics:")
+            for rel_type, count in graph.relationship_stats.items():
+                lines.append(f"  {rel_type}: {count}")
+
+        return "\n".join(lines)
+
+
+class QueryCommandResult(BaseModel):
+    """Result for query command."""
+
+    graph_name: str
+    query_type: str
+    result: QueryResult
+
+    def __str__(self) -> str:
+        """Format query results table."""
+        query_result = self.result
+
+        if not query_result.success:
+            return f"Query failed: {query_result.error}"
+
+        if not query_result.results:
+            return "No results found."
+
+        lines = [
+            f"Query executed in {query_result.execution_time_ms:.2f}ms",
+            f"Results: {query_result.row_count} rows",
+        ]
+
+        if query_result.cypher_query:
+            lines.append(f"Generated Cypher: {query_result.cypher_query}")
+
+        lines.append("")  # Empty line
+
+        # Format results table
+        if query_result.column_names:
+            header = " | ".join(f"{col:<20}" for col in query_result.column_names)
+            lines.append(header)
+            lines.append("-" * len(header))
+
+            for row in query_result.results:
+                row_data = " | ".join(
+                    f"{str(row.get(col, '')):<20}" for col in query_result.column_names
+                )
+                lines.append(row_data)
+        else:
+            # Fallback for results without column names
+            for i, row in enumerate(query_result.results):
+                lines.append(f"Row {i + 1}:")
+                for key, value in row.items():
+                    lines.append(f"  {key}: {value}")
+                lines.append("")
+
+        return "\n".join(lines)
+
+
+class ReindexResult(BaseModel):
+    """Result for reindex command."""
+
+    graph_id: str
+    name: str
+    stats: dict[str, Any] | None = None
+
+    def __str__(self) -> str:
+        """Format reindex completion message."""
+        lines = ["Reindexing completed!"]
+        if self.stats:
+            lines.append(f"Stats: {self.stats}")
+        return "\n".join(lines)
+
+
+class ErrorResult(BaseModel):
+    """Result for error cases."""
+
+    error_message: str
+    details: str | None = None
+
+    def __str__(self) -> str:
+        """Format error message."""
+        output = f"Error: {self.error_message}"
+        if self.details:
+            output += f"\n{self.details}"
+        return output

shotgun/sdk/services.py

@@ -0,0 +1,23 @@
+"""Service factory functions for SDK."""
+
+from pathlib import Path
+
+from shotgun.codebase.service import CodebaseService
+from shotgun.utils import get_shotgun_home
+
+
+def get_codebase_service(storage_dir: Path | str | None = None) -> CodebaseService:
+    """Get CodebaseService instance with configurable storage.
+
+    Args:
+        storage_dir: Optional custom storage directory.
+                    Defaults to ~/.shotgun-sh/codebases/
+
+    Returns:
+        Configured CodebaseService instance
+    """
+    if storage_dir is None:
+        storage_dir = get_shotgun_home() / "codebases"
+    elif isinstance(storage_dir, str):
+        storage_dir = Path(storage_dir)
+    return CodebaseService(storage_dir)

shotgun/telemetry.py

@@ -0,0 +1,68 @@
+"""Phoenix AI observability setup for cloud and local deployment."""
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def setup_phoenix_observability() -> bool:
+    """Set up Phoenix AI observability if enabled.
+
+    Supports both local Phoenix and cloud Phoenix (Arize) configurations.
+
+    Returns:
+        True if Phoenix was successfully set up, False otherwise
+    """
+    # Check if Phoenix observability is enabled
+    if os.getenv("PHOENIX_ENABLED", "false").lower() not in ("true", "1", "yes"):
+        logger.debug("Phoenix AI observability disabled via PHOENIX_ENABLED env var")
+        return False
+
+    try:
+        # Check if using cloud Phoenix (Arize) or local Phoenix
+        phoenix_collector_endpoint = os.getenv("PHOENIX_COLLECTOR_ENDPOINT")
+        phoenix_api_key = os.getenv("PHOENIX_API_KEY")
+
+        if not phoenix_collector_endpoint or not phoenix_api_key:
+            return False
+
+        # Cloud Phoenix setup (Arize) - following exact docs pattern
+        logger.debug("Setting up cloud Phoenix AI observability")
+
+        from openinference.instrumentation.pydantic_ai import (
+            OpenInferenceSpanProcessor,
+        )
+        from opentelemetry import trace
+        from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+            OTLPSpanExporter,
+        )
+        from opentelemetry.sdk.trace import TracerProvider
+        from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+        # Set up tracer provider
+        tracer_provider = TracerProvider()
+        trace.set_tracer_provider(tracer_provider)
+
+        # Set up OTLP exporter for cloud Phoenix
+        # Phoenix cloud expects Authorization header, not api_key
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=phoenix_collector_endpoint,
+            headers={"authorization": f"Bearer {phoenix_api_key}"},
+        )
+
+        # Add both span processors - OpenInference for semantics and BatchSpanProcessor for export
+        tracer_provider.add_span_processor(OpenInferenceSpanProcessor())
+        tracer_provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+
+        logger.debug("Cloud Phoenix AI observability configured successfully")
+        logger.debug("Endpoint: %s", phoenix_collector_endpoint)
+        logger.debug("API key configured: %s", "Yes" if phoenix_api_key else "No")
+        return True
+
+    except ImportError as e:
+        logger.warning("Phoenix AI not available: %s", e)
+        return False
+    except Exception as e:
+        logger.warning("Failed to setup Phoenix AI observability: %s", e)
+        return False

shotgun/tui/app.py

@@ -0,0 +1,49 @@
+from textual.app import App
+from textual.binding import Binding
+
+from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.tui.screens.splash import SplashScreen
+
+from .screens.chat import ChatScreen
+from .screens.provider_config import ProviderConfigScreen
+
+
+class ShotgunApp(App[None]):
+    SCREENS = {"chat": ChatScreen, "provider_config": ProviderConfigScreen}
+    BINDINGS = [
+        Binding("ctrl+c", "quit", "Quit the app"),
+    ]
+    CSS_PATH = "styles.tcss"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.config_manager: ConfigManager = get_config_manager()
+
+    def on_mount(self) -> None:
+        self.push_screen(
+            SplashScreen(), callback=lambda _arg: self.refresh_startup_screen()
+        )
+        # self.refresh_startup_screen()
+
+    def refresh_startup_screen(self) -> None:
+        """Push the appropriate screen based on configured providers."""
+        if self.config_manager.has_any_provider_key():
+            if isinstance(self.screen, ChatScreen):
+                return
+            self.push_screen("chat")
+        else:
+            if isinstance(self.screen, ProviderConfigScreen):
+                return
+
+            self.push_screen(
+                "provider_config", callback=lambda _arg: self.refresh_startup_screen()
+            )
+
+
+def run() -> None:
+    app = ShotgunApp()
+    app.run(inline_no_clear=True)
+
+
+if __name__ == "__main__":
+    run()

shotgun/tui/components/prompt_input.py

@@ -0,0 +1,69 @@
+from textual import events
+from textual.message import Message
+from textual.widgets import TextArea
+
+
+class PromptInput(TextArea):
+    """A TextArea with a submit binding."""
+
+    DEFAULT_CSS = """
+        PromptInput {
+            outline: round $primary;
+            background: transparent;
+        }
+    """
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool:
+        if action != "copy":
+            return True
+        # run copy action if there is selected text
+        # otherwise, do nothing, so global ctrl+c still works.
+        return bool(self.selected_text)
+
+    class Submitted(Message):
+        """A message to indicate that the text has been submitted."""
+
+        def __init__(self, text: str) -> None:
+            super().__init__()
+            self.text = text
+
+    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
+        if event.key == "enter":
+            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()
+
+        if event.is_printable or key in insert_values:
+            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)

shotgun/tui/components/spinner.py

@@ -0,0 +1,86 @@
+"""Spinner component for showing loading/working state."""
+
+from textual.app import ComposeResult
+from textual.containers import Container
+from textual.css.query import NoMatches
+from textual.reactive import reactive
+from textual.timer import Timer
+from textual.widget import Widget
+from textual.widgets import Static
+
+
+class Spinner(Widget):
+    """A spinner widget that shows a rotating animation when working."""
+
+    DEFAULT_CSS = """
+    Spinner {
+        width: auto;
+        height: 1;
+    }
+
+    Spinner > Container {
+        width: auto;
+        height: 1;
+        layout: horizontal;
+    }
+
+    Spinner .spinner-icon {
+        width: 1;
+        margin-right: 1;
+    }
+
+    Spinner .spinner-text {
+        width: auto;
+    }
+    """
+
+    # Animation frames for the spinner
+    FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+    text = reactive("Working...")
+    _frame_index = reactive(0)
+
+    def __init__(
+        self,
+        text: str = "Working...",
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        super().__init__(name=name, id=id, classes=classes)
+        self.text = text
+        self._timer: Timer | None = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the spinner widget."""
+        with Container():
+            yield Static("", classes="spinner-icon")
+            yield Static(self.text, classes="spinner-text")
+
+    def on_mount(self) -> None:
+        """Set up the animation timer when mounted."""
+        self._timer = self.set_interval(0.1, self._advance_frame)
+
+    def _advance_frame(self) -> None:
+        """Advance to the next animation frame."""
+        self._frame_index = (self._frame_index + 1) % len(self.FRAMES)
+        self._update_display()
+
+    def _update_display(self) -> None:
+        """Update the spinner display."""
+        try:
+            icon_widget = self.query_one(".spinner-icon", Static)
+            icon_widget.update(self.FRAMES[self._frame_index])
+        except NoMatches:
+            # Widget not mounted yet, ignore
+            pass
+
+    def watch_text(self, text: str) -> None:
+        """React to changes in the text."""
+        try:
+            text_widget = self.query_one(".spinner-text", Static)
+            text_widget.update(text)
+        except NoMatches:
+            # Widget not mounted yet, ignore
+            return