shotgun-sh 0.1.0__py3-none-any.whl

shotgun/tui/screens/chat.tcss

@@ -0,0 +1,43 @@
+ChatHistory {
+  height: auto;
+}
+
+PromptInput {
+  min-height: 3;
+  max-height: 7;
+  height: auto;
+}
+
+StatusBar {
+  height: auto;
+}
+
+ModeIndicator {
+  height: auto;
+}
+
+#footer {
+  dock: bottom;
+  height: auto;
+  padding: 1 1 1 2;
+  max-height: 14;
+}
+
+#window {
+  align: left bottom;
+}
+
+.hidden {
+  display: none;
+}
+
+#footer > Grid {
+  height: auto;
+  grid-columns: 1fr auto;
+  grid-size: 2;
+}
+
+
+#indexing-job-display {
+  text-align: end;
+}

shotgun/tui/screens/chat_screen/command_providers.py

@@ -0,0 +1,219 @@
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, cast
+
+from textual.command import DiscoveryHit, Hit, Provider
+
+from shotgun.agents.models import AgentType
+from shotgun.codebase.models import CodebaseGraph
+
+if TYPE_CHECKING:
+    from shotgun.tui.screens.chat import ChatScreen
+
+
+class AgentModeProvider(Provider):
+    """Command provider for agent mode switching."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    def set_mode(self, mode: AgentType) -> None:
+        """Switch to research mode."""
+        self.chat_screen.mode = mode
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        """Provide default mode switching commands when palette opens."""
+        yield DiscoveryHit(
+            "Switch to Research Mode",
+            lambda: self.set_mode(AgentType.RESEARCH),
+            help="🔬 Research topics with web search and synthesize findings",
+        )
+        yield DiscoveryHit(
+            "Switch to Specify Mode",
+            lambda: self.set_mode(AgentType.SPECIFY),
+            help="📝 Create detailed specifications and requirements documents",
+        )
+        yield DiscoveryHit(
+            "Switch to Plan Mode",
+            lambda: self.set_mode(AgentType.PLAN),
+            help="📋 Create comprehensive, actionable plans with milestones",
+        )
+        yield DiscoveryHit(
+            "Switch to Tasks Mode",
+            lambda: self.set_mode(AgentType.TASKS),
+            help="✅ Generate specific, actionable tasks from research and plans",
+        )
+        yield DiscoveryHit(
+            "Switch to Export Mode",
+            lambda: self.set_mode(AgentType.EXPORT),
+            help="📤 Export artifacts and findings to various formats",
+        )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        """Search for mode commands."""
+        matcher = self.matcher(query)
+
+        commands = [
+            (
+                "Switch to Research Mode",
+                "🔬 Research topics with web search and synthesize findings",
+                lambda: self.set_mode(AgentType.RESEARCH),
+                AgentType.RESEARCH,
+            ),
+            (
+                "Switch to Specify Mode",
+                "📝 Create detailed specifications and requirements documents",
+                lambda: self.set_mode(AgentType.SPECIFY),
+                AgentType.SPECIFY,
+            ),
+            (
+                "Switch to Plan Mode",
+                "📋 Create comprehensive, actionable plans with milestones",
+                lambda: self.set_mode(AgentType.PLAN),
+                AgentType.PLAN,
+            ),
+            (
+                "Switch to Tasks Mode",
+                "✅ Generate specific, actionable tasks from research and plans",
+                lambda: self.set_mode(AgentType.TASKS),
+                AgentType.TASKS,
+            ),
+            (
+                "Switch to Export Mode",
+                "📤 Export artifacts and findings to various formats",
+                lambda: self.set_mode(AgentType.EXPORT),
+                AgentType.EXPORT,
+            ),
+        ]
+
+        for title, help_text, callback, mode in commands:
+            if self.chat_screen.mode == mode:
+                continue
+            score = matcher.match(title)
+            if score > 0:
+                yield Hit(score, matcher.highlight(title), callback, help=help_text)
+
+
+class ProviderSetupProvider(Provider):
+    """Command palette entries for provider configuration."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    def open_provider_config(self) -> None:
+        """Show the provider configuration screen."""
+        self.chat_screen.app.push_screen("provider_config")
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        yield DiscoveryHit(
+            "Open Provider Setup",
+            self.open_provider_config,
+            help="⚙️ Manage API keys for available providers",
+        )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        matcher = self.matcher(query)
+        title = "Open Provider Setup"
+        score = matcher.match(title)
+        if score > 0:
+            yield Hit(
+                score,
+                matcher.highlight(title),
+                self.open_provider_config,
+                help="⚙️ Manage API keys for available providers",
+            )
+
+
+class CodebaseCommandProvider(Provider):
+    """Command palette entries for codebase management."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        yield DiscoveryHit(
+            "Codebase: Index Codebase",
+            self.chat_screen.index_codebase_command,
+            help="Index a repository into the codebase graph",
+        )
+        yield DiscoveryHit(
+            "Codebase: Delete Codebase Index",
+            self.chat_screen.delete_codebase_command,
+            help="Delete an existing codebase index",
+        )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        matcher = self.matcher(query)
+        commands = [
+            (
+                "Codebase: Index Codebase",
+                self.chat_screen.index_codebase_command,
+                "Index a repository into the codebase graph",
+            ),
+            (
+                "Codebase: Delete Codebase Index",
+                self.chat_screen.delete_codebase_command,
+                "Delete an existing codebase index",
+            ),
+        ]
+        for title, callback, help_text in commands:
+            score = matcher.match(title)
+            if score > 0:
+                yield Hit(score, matcher.highlight(title), callback, help=help_text)
+
+
+class DeleteCodebasePaletteProvider(Provider):
+    """Provider that lists indexed codebases for deletion."""
+
+    @property
+    def chat_screen(self) -> "ChatScreen":
+        from shotgun.tui.screens.chat import ChatScreen
+
+        return cast(ChatScreen, self.screen)
+
+    async def _codebases(self) -> list[CodebaseGraph]:
+        try:
+            result = await self.chat_screen.codebase_sdk.list_codebases()
+        except Exception as exc:  # pragma: no cover - defensive UI path
+            self.chat_screen.notify(
+                f"Unable to load codebases: {exc}", severity="error"
+            )
+            return []
+        return result.graphs
+
+    async def discover(self) -> AsyncGenerator[DiscoveryHit, None]:
+        graphs = await self._codebases()
+        for graph in graphs:
+            title = f"Delete {graph.name}"
+            help_text = f"{graph.graph_id} • {graph.repo_path}"
+            yield DiscoveryHit(
+                title,
+                lambda graph_id=graph.graph_id: self.chat_screen.delete_codebase_from_palette(
+                    graph_id
+                ),
+                help=help_text,
+            )
+
+    async def search(self, query: str) -> AsyncGenerator[Hit, None]:
+        matcher = self.matcher(query)
+        graphs = await self._codebases()
+        for graph in graphs:
+            display = f"{graph.name} ({graph.graph_id[:8]})"
+            score = matcher.match(display)
+            if score > 0:
+                yield Hit(
+                    score,
+                    matcher.highlight(display),
+                    lambda graph_id=graph.graph_id: self.chat_screen.delete_codebase_from_palette(
+                        graph_id
+                    ),
+                    help=graph.repo_path,
+                )

shotgun/tui/screens/chat_screen/hint_message.py

@@ -0,0 +1,40 @@
+from typing import Literal
+
+from pydantic import BaseModel
+from textual.app import ComposeResult
+from textual.widget import Widget
+from textual.widgets import Markdown
+
+
+class HintMessage(BaseModel):
+    message: str
+    kind: Literal["hint"] = "hint"
+
+
+class HintMessageWidget(Widget):
+    """A message for the user generated by shotgun, not the agent.."""
+
+    DEFAULT_CSS = """
+        HintMessageWidget {
+          background: $secondary-background-darken-1;
+          height: auto;
+          margin: 1;
+          margin-left: 1;
+          padding: 1;
+
+          * > Markdown {
+              height: auto;
+              offset-x: -1;
+              padding: 0;
+              margin: 0;
+          }
+        }
+
+    """
+
+    def __init__(self, message: HintMessage) -> None:
+        super().__init__()
+        self.message = message
+
+    def compose(self) -> ComposeResult:
+        yield Markdown(markdown=f"{self.message.message}")

shotgun/tui/screens/chat_screen/history.py

@@ -0,0 +1,221 @@
+import json
+from collections.abc import Sequence
+
+from pydantic_ai.messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
+    ModelMessage,
+    ModelRequest,
+    ModelRequestPart,
+    ModelResponse,
+    TextPart,
+    ThinkingPart,
+    ToolCallPart,
+    ToolReturnPart,
+    UserPromptPart,
+)
+from textual.app import ComposeResult
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import Markdown
+
+from shotgun.tui.components.vertical_tail import VerticalTail
+from shotgun.tui.screens.chat_screen.hint_message import HintMessage, HintMessageWidget
+
+
+class PartialResponseWidget(Widget):  # TODO: doesn't work lol
+    DEFAULT_CSS = """
+        PartialResponseWidget {
+            height: auto;
+        }
+        Markdown, AgentResponseWidget, UserQuestionWidget {
+            height: auto;
+        }
+    """
+
+    item: reactive[ModelMessage | None] = reactive(None, recompose=True)
+
+    def __init__(self, item: ModelMessage | None) -> None:
+        super().__init__()
+        self.item = item
+
+    def compose(self) -> ComposeResult:
+        yield Markdown(markdown="**partial response**")
+        if self.item is None:
+            pass
+        elif self.item.kind == "response":
+            yield AgentResponseWidget(self.item)
+        elif self.item.kind == "request":
+            yield UserQuestionWidget(self.item)
+
+    def watch_item(self, item: ModelMessage | None) -> None:
+        if item is None:
+            self.display = False
+        else:
+            self.display = True
+
+
+class ChatHistory(Widget):
+    DEFAULT_CSS = """
+        VerticalTail {
+            align: left bottom;
+
+        }
+        VerticalTail > * {
+            height: auto;
+        }
+
+        Horizontal {
+            height: auto;
+            background: $secondary-muted;
+        }
+
+        Markdown {
+            height: auto;
+        }
+    """
+    partial_response: reactive[ModelMessage | None] = reactive(None)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.items: Sequence[ModelMessage | HintMessage] = []
+        self.vertical_tail: VerticalTail | None = None
+        self.partial_response = None
+
+    def compose(self) -> ComposeResult:
+        self.vertical_tail = VerticalTail()
+
+        with self.vertical_tail:
+            for item in self.items:
+                if isinstance(item, ModelRequest):
+                    yield UserQuestionWidget(item)
+                elif isinstance(item, HintMessage):
+                    yield HintMessageWidget(item)
+                elif isinstance(item, ModelResponse):
+                    yield AgentResponseWidget(item)
+            yield PartialResponseWidget(self.partial_response).data_bind(
+                item=ChatHistory.partial_response
+            )
+        self.call_later(self.autoscroll)
+
+    def update_messages(self, messages: list[ModelMessage | HintMessage]) -> None:
+        """Update the displayed messages without recomposing."""
+        if not self.vertical_tail:
+            return
+
+        self.items = messages
+        self.refresh(recompose=True)
+        self.call_later(self.autoscroll)
+
+    def autoscroll(self) -> None:
+        if self.vertical_tail:
+            self.vertical_tail.scroll_end(animate=False, immediate=False, force=True)
+
+
+class UserQuestionWidget(Widget):
+    def __init__(self, item: ModelRequest | None) -> None:
+        super().__init__()
+        self.item = item
+
+    def compose(self) -> ComposeResult:
+        self.display = self.item is not None
+        if self.item is None:
+            yield Markdown(markdown="")
+        else:
+            prompt = self.format_prompt_parts(self.item.parts)
+            yield Markdown(markdown=prompt)
+
+    def format_prompt_parts(self, parts: Sequence[ModelRequestPart]) -> str:
+        acc = ""
+        for part in parts:
+            if isinstance(part, UserPromptPart):
+                acc += (
+                    f"**>** {part.content if isinstance(part.content, str) else ''}\n\n"
+                )
+            elif isinstance(part, ToolReturnPart):
+                if part.tool_name == "ask_user" and isinstance(part.content, dict):
+                    acc += f"**>** {part.content['answer']}\n\n"
+                else:
+                    acc += "  ∟ finished\n\n"  # let's not show anything yet
+            elif isinstance(part, UserPromptPart):
+                acc += f"**>** {part.content}\n\n"
+        return acc
+
+
+class AgentResponseWidget(Widget):
+    def __init__(self, item: ModelResponse | None) -> None:
+        super().__init__()
+        self.item = item
+
+    def compose(self) -> ComposeResult:
+        self.display = self.item is not None
+        if self.item is None:
+            yield Markdown(markdown="")
+        else:
+            yield Markdown(markdown=f"**⏺** {self.compute_output()}")
+
+    def compute_output(self) -> str:
+        acc = ""
+        if self.item is None:
+            return ""
+        for idx, part in enumerate(self.item.parts):
+            if isinstance(part, TextPart):
+                acc += f"{part.content}\n\n"
+            elif isinstance(part, ToolCallPart):
+                parts_str = self._format_tool_call_part(part)
+                acc += f"{part.tool_name}: " + parts_str + "\n\n"
+            elif isinstance(part, BuiltinToolCallPart):
+                acc += f"{part.tool_name}({part.args})\n\n"
+            elif isinstance(part, BuiltinToolReturnPart):
+                acc += f"builtin tool ({part.tool_name}) return: {part.content}\n\n"
+            elif isinstance(part, ThinkingPart):
+                if (
+                    idx == len(self.item.parts) - 1
+                ):  # show the thinking part only if it's the last part
+                    acc += (
+                        f"thinking: {part.content}\n\n"
+                        if part.content
+                        else "Thinking..."
+                    )
+                else:
+                    continue
+        return acc.strip()
+
+    def _format_tool_call_part(self, part: ToolCallPart) -> str:
+        if part.tool_name == "ask_user":
+            return self._format_ask_user_part(part)
+        # 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 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 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}()"
+
+        return f"{part.tool_name}({part.args})"
+
+    def _format_ask_user_part(
+        self,
+        part: ToolCallPart,
+    ) -> str:
+        if isinstance(part.args, str):
+            try:
+                _args = json.loads(part.args) if part.args.strip() else {}
+            except json.JSONDecodeError:
+                _args = {}
+        else:
+            _args = part.args
+
+        if isinstance(_args, dict) and "question" in _args:
+            return f"{_args['question']}"
+        else:
+            return "❓ "

shotgun/tui/screens/directory_setup.py

@@ -0,0 +1,113 @@
+"""Screen for setting up the local .shotgun directory."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Static
+
+from shotgun.utils.file_system_utils import ensure_shotgun_directory_exists
+
+
+class DirectorySetupScreen(Screen[None]):
+    """Prompt the user to initialize the .shotgun directory."""
+
+    CSS = """
+        DirectorySetupScreen {
+            layout: vertical;
+        }
+
+        DirectorySetupScreen > * {
+            height: auto;
+        }
+
+        #titlebox {
+            height: auto;
+            margin: 2 0;
+            padding: 1;
+            border: hkey $border;
+            content-align: center middle;
+
+            & > * {
+                text-align: center;
+            }
+        }
+
+        #directory-setup-title {
+            padding: 1 0;
+            text-style: bold;
+            color: $text-accent;
+        }
+
+        #directory-setup-summary {
+            padding: 0 1;
+        }
+
+        #directory-actions {
+            padding: 1;
+            content-align: center middle;
+            align: center middle;
+        }
+
+        #directory-actions > * {
+            margin-right: 2;
+        }
+    """
+
+    BINDINGS = [
+        ("enter", "confirm", "Initialize"),
+        ("escape", "cancel", "Exit"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="titlebox"):
+            yield Static("Directory setup", id="directory-setup-title")
+            yield Static("Shotgun keeps workspace data in a .shotgun directory.\n")
+            yield Static("Initialize it in the current directory?\n")
+            yield Static(f"[$foreground-muted]({Path.cwd().resolve()})[/]")
+        with Horizontal(id="directory-actions"):
+            yield Button(
+                "Initialize and proceed \\[ENTER]", variant="primary", id="initialize"
+            )
+            yield Button("Exit without setup \\[ESC]", variant="default", id="exit")
+
+    def on_mount(self) -> None:
+        self.set_focus(self.query_one("#initialize", Button))
+
+    def action_confirm(self) -> None:
+        self._initialize_directory()
+
+    def action_cancel(self) -> None:
+        self._exit_application()
+
+    @on(Button.Pressed, "#initialize")
+    def _on_initialize_pressed(self) -> None:
+        self._initialize_directory()
+
+    @on(Button.Pressed, "#exit")
+    def _on_exit_pressed(self) -> None:
+        self._exit_application()
+
+    def _initialize_directory(self) -> None:
+        try:
+            path = ensure_shotgun_directory_exists()
+        except Exception as exc:  # pragma: no cover - defensive; textual path
+            self.notify(f"Failed to initialize directory: {exc}", severity="error")
+            return
+
+        # Double-check a directory now exists; guard against unexpected filesystem state.
+        if not path.is_dir():
+            self.notify(
+                "Unable to initialize .shotgun directory due to filesystem conflict.",
+                severity="error",
+            )
+            return
+
+        self.dismiss()
+
+    def _exit_application(self) -> None:
+        self.app.exit()