shotgun-sh 0.1.0.dev12__py3-none-any.whl → 0.1.0.dev13__py3-none-any.whl

shotgun/sdk/artifacts.py

@@ -0,0 +1,448 @@
+"""Artifact SDK for framework-agnostic business logic."""
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from shotgun.artifacts.exceptions import (
+    ArtifactAlreadyExistsError,
+    ArtifactError,
+    ArtifactNotFoundError,
+    SectionAlreadyExistsError,
+    SectionNotFoundError,
+)
+from shotgun.artifacts.models import AgentMode, ArtifactSection
+from shotgun.artifacts.service import ArtifactService
+from shotgun.artifacts.utils import generate_artifact_name
+
+from .artifact_models import (
+    ArtifactCreateResult,
+    ArtifactDeleteResult,
+    ArtifactErrorResult,
+    ArtifactInfoResult,
+    ArtifactListResult,
+    SectionContentResult,
+    SectionCreateResult,
+    SectionDeleteResult,
+    SectionUpdateResult,
+)
+
+
+class ArtifactSDK:
+    """Framework-agnostic SDK for artifact operations.
+
+    This SDK provides business logic for artifact management that can be
+    used by both CLI and TUI implementations without framework dependencies.
+    """
+
+    def __init__(self, base_path: Path | None = None):
+        """Initialize SDK with optional base path.
+
+        Args:
+            base_path: Optional custom base path for artifacts.
+                      Defaults to .shotgun in current directory.
+        """
+        self.service = ArtifactService(base_path)
+
+    # Artifact operations
+
+    def list_artifacts(
+        self, agent_mode: AgentMode | None = None
+    ) -> ArtifactListResult | ArtifactErrorResult:
+        """List all artifacts, optionally filtered by agent mode.
+
+        Args:
+            agent_mode: Optional agent mode filter
+
+        Returns:
+            ArtifactListResult containing list of artifacts or ArtifactErrorResult
+        """
+        try:
+            artifacts = self.service.list_artifacts(agent_mode)
+            return ArtifactListResult(artifacts=artifacts, agent_mode=agent_mode)
+        except ArtifactError as e:
+            return ArtifactErrorResult(error_message=str(e), agent_mode=agent_mode)
+
+    def create_artifact(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        name: str,
+        template_id: str | None = None,
+    ) -> ArtifactCreateResult | ArtifactErrorResult:
+        """Create a new artifact.
+
+        Args:
+            artifact_id: Unique identifier for the artifact
+            agent_mode: Agent mode this artifact belongs to
+            name: Human-readable name for the artifact
+            template_id: Optional template ID to use for creating the artifact
+
+        Returns:
+            ArtifactCreateResult or ArtifactErrorResult
+        """
+        try:
+            self.service.create_artifact(artifact_id, agent_mode, name, template_id)
+            return ArtifactCreateResult(
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                name=name,
+            )
+        except ArtifactAlreadyExistsError as e:
+            return ArtifactErrorResult(
+                error_message="Artifact already exists",
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                details=str(e),
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+            )
+
+    def delete_artifact(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        confirm_callback: Callable[[str, AgentMode], bool] | None = None,
+    ) -> ArtifactDeleteResult | ArtifactErrorResult:
+        """Delete an artifact with optional confirmation.
+
+        Args:
+            artifact_id: ID of the artifact to delete
+            agent_mode: Agent mode
+            confirm_callback: Optional callback for confirmation that receives
+                            artifact_id and agent_mode and returns boolean.
+
+        Returns:
+            ArtifactDeleteResult or ArtifactErrorResult
+        """
+        try:
+            # Handle confirmation callback if provided
+            if confirm_callback and not confirm_callback(artifact_id, agent_mode):
+                return ArtifactDeleteResult(
+                    artifact_id=artifact_id,
+                    agent_mode=agent_mode,
+                    deleted=False,
+                    cancelled=True,
+                )
+
+            self.service.delete_artifact(artifact_id, agent_mode)
+            return ArtifactDeleteResult(
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                deleted=True,
+            )
+        except ArtifactNotFoundError as e:
+            return ArtifactErrorResult(
+                error_message="Artifact not found",
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                details=str(e),
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+            )
+
+    def get_artifact_info(
+        self, artifact_id: str, agent_mode: AgentMode
+    ) -> ArtifactInfoResult | ArtifactErrorResult:
+        """Get detailed information about an artifact.
+
+        Args:
+            artifact_id: ID of the artifact to get info for
+            agent_mode: Agent mode
+
+        Returns:
+            ArtifactInfoResult or ArtifactErrorResult
+        """
+        try:
+            artifact = self.service.get_artifact(artifact_id, agent_mode, "")
+            return ArtifactInfoResult(artifact=artifact)
+        except ArtifactNotFoundError as e:
+            return ArtifactErrorResult(
+                error_message="Artifact not found",
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                details=str(e),
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+            )
+
+    # Section operations
+
+    def create_section(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        section_number: int,
+        section_slug: str,
+        section_title: str,
+        content: str = "",
+    ) -> SectionCreateResult | ArtifactErrorResult:
+        """Create a new section in an artifact.
+
+        Args:
+            artifact_id: Artifact identifier
+            agent_mode: Agent mode
+            section_number: Section number
+            section_slug: Section slug
+            section_title: Section title
+            content: Section content
+
+        Returns:
+            SectionCreateResult or ArtifactErrorResult
+        """
+        try:
+            section = ArtifactSection(
+                number=section_number,
+                slug=section_slug,
+                title=section_title,
+                content=content,
+            )
+            self.service.add_section(artifact_id, agent_mode, section)
+            return SectionCreateResult(
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+                section_title=section_title,
+            )
+        except (SectionAlreadyExistsError, ArtifactNotFoundError) as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+
+    def update_section(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        section_number: int,
+        **kwargs: Any,
+    ) -> SectionUpdateResult | ArtifactErrorResult:
+        """Update a section in an artifact.
+
+        Args:
+            artifact_id: Artifact identifier
+            agent_mode: Agent mode
+            section_number: Section number to update
+            **kwargs: Fields to update
+
+        Returns:
+            SectionUpdateResult or ArtifactErrorResult
+        """
+        try:
+            self.service.update_section(
+                artifact_id, agent_mode, section_number, **kwargs
+            )
+            return SectionUpdateResult(
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+                updated_fields=list(kwargs.keys()),
+            )
+        except (SectionNotFoundError, ArtifactNotFoundError) as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+
+    def delete_section(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        section_number: int,
+    ) -> SectionDeleteResult | ArtifactErrorResult:
+        """Delete a section from an artifact.
+
+        Args:
+            artifact_id: Artifact identifier
+            agent_mode: Agent mode
+            section_number: Section number to delete
+
+        Returns:
+            SectionDeleteResult or ArtifactErrorResult
+        """
+        try:
+            self.service.delete_section(artifact_id, agent_mode, section_number)
+            return SectionDeleteResult(
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+        except (SectionNotFoundError, ArtifactNotFoundError) as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+
+    def get_section_content(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        section_number: int,
+    ) -> SectionContentResult | ArtifactErrorResult:
+        """Get the content of a section.
+
+        Args:
+            artifact_id: Artifact identifier
+            agent_mode: Agent mode
+            section_number: Section number
+
+        Returns:
+            SectionContentResult or ArtifactErrorResult
+        """
+        try:
+            content = self.service.get_section_content(
+                artifact_id, agent_mode, section_number
+            )
+            return SectionContentResult(
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+                content=content,
+            )
+        except (SectionNotFoundError, ArtifactNotFoundError) as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+        except ArtifactError as e:
+            return ArtifactErrorResult(
+                error_message=str(e),
+                artifact_id=artifact_id,
+                agent_mode=agent_mode,
+                section_number=section_number,
+            )
+
+    # Template operations
+
+    def list_templates(
+        self, agent_mode: AgentMode | None = None
+    ) -> list[Any] | ArtifactErrorResult:
+        """List available artifact templates.
+
+        Args:
+            agent_mode: Optional agent mode filter
+
+        Returns:
+            List of template summaries or ArtifactErrorResult
+        """
+        try:
+            return self.service.list_templates(agent_mode)
+        except Exception as e:
+            return ArtifactErrorResult(
+                error_message=f"Failed to list templates: {str(e)}",
+                agent_mode=agent_mode,
+            )
+
+    # Convenience methods
+
+    def ensure_artifact_exists(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        name: str | None = None,
+    ) -> ArtifactCreateResult | ArtifactInfoResult | ArtifactErrorResult:
+        """Ensure an artifact exists, creating it if necessary.
+
+        Args:
+            artifact_id: Artifact identifier
+            agent_mode: Agent mode
+            name: Optional name (defaults to formatted artifact_id)
+
+        Returns:
+            ArtifactCreateResult if created, ArtifactInfoResult if already existed, ArtifactErrorResult on error
+        """
+        if name is None:
+            name = generate_artifact_name(artifact_id)
+
+        # Try to get existing artifact
+        info_result = self.get_artifact_info(artifact_id, agent_mode)
+        if isinstance(info_result, ArtifactInfoResult):
+            return info_result
+
+        # Create new artifact
+        create_result = self.create_artifact(artifact_id, agent_mode, name)
+        return create_result
+
+    def ensure_section_exists(
+        self,
+        artifact_id: str,
+        agent_mode: AgentMode,
+        section_number: int,
+        section_slug: str,
+        section_title: str,
+        initial_content: str = "",
+    ) -> SectionCreateResult | SectionContentResult | ArtifactErrorResult:
+        """Ensure a section exists, creating it if necessary.
+
+        Args:
+            artifact_id: Artifact identifier
+            agent_mode: Agent mode
+            section_number: Section number
+            section_slug: Section slug
+            section_title: Section title
+            initial_content: Initial content for new sections
+
+        Returns:
+            SectionCreateResult if created, SectionContentResult if already existed, ArtifactErrorResult on error
+        """
+        # Try to get existing section
+        content_result = self.get_section_content(
+            artifact_id, agent_mode, section_number
+        )
+        if isinstance(content_result, SectionContentResult):
+            return content_result
+
+        # Ensure artifact exists first
+        self.ensure_artifact_exists(artifact_id, agent_mode)
+
+        # Create new section
+        create_result = self.create_section(
+            artifact_id,
+            agent_mode,
+            section_number,
+            section_slug,
+            section_title,
+            initial_content,
+        )
+        return create_result

shotgun/tui/app.py

@@ -2,18 +2,24 @@ from textual.app import App
 from textual.binding import Binding
 
 from shotgun.agents.config import ConfigManager, get_config_manager
+from shotgun.agents.tools.file_management import get_shotgun_base_path
 from shotgun.logging_config import get_logger
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.update_checker import check_for_updates_async
 
 from .screens.chat import ChatScreen
+from .screens.directory_setup import DirectorySetupScreen
 from .screens.provider_config import ProviderConfigScreen
 
 logger = get_logger(__name__)
 
 
 class ShotgunApp(App[None]):
-    SCREENS = {"chat": ChatScreen, "provider_config": ProviderConfigScreen}
+    SCREENS = {
+        "chat": ChatScreen,
+        "provider_config": ProviderConfigScreen,
+        "directory_setup": DirectorySetupScreen,
+    }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
     ]
@@ -43,21 +49,34 @@ class ShotgunApp(App[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 not self.config_manager.has_any_provider_key():
             if isinstance(self.screen, ProviderConfigScreen):
                 return
 
             self.push_screen(
                 "provider_config", callback=lambda _arg: self.refresh_startup_screen()
             )
+            return
+
+        if not self.check_local_shotgun_directory_exists():
+            if isinstance(self.screen, DirectorySetupScreen):
+                return
+
+            self.push_screen(
+                "directory_setup", callback=lambda _arg: self.refresh_startup_screen()
+            )
+            return
+
+        if isinstance(self.screen, ChatScreen):
+            return
+        self.push_screen("chat")
+
+    def check_local_shotgun_directory_exists(self) -> bool:
+        shotgun_dir = get_shotgun_base_path()
+        return shotgun_dir.exists() and shotgun_dir.is_dir()
 
     async def action_quit(self) -> None:
         """Override quit action to show update notification."""

shotgun/tui/screens/chat.py

@@ -1,7 +1,7 @@
 from collections.abc import AsyncGenerator
 from typing import cast
 
-from pydantic_ai import DeferredToolResults
+from pydantic_ai import DeferredToolResults, RunContext
 from pydantic_ai.messages import (
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
@@ -31,6 +31,11 @@ from ..components.spinner import Spinner
 from ..components.vertical_tail import VerticalTail
 
 
+def _dummy_system_prompt_fn(ctx: RunContext[AgentDeps]) -> str:
+    """Dummy system prompt function for TUI chat interface."""
+    return "You are a helpful AI assistant."
+
+
 class PromptHistory:
     def __init__(self) -> None:
         self.prompts: list[str] = ["Hello there!"]
@@ -289,6 +294,18 @@ class ChatScreen(Screen[None]):
 
     COMMANDS = {AgentModeProvider, ProviderSetupProvider}
 
+    _PLACEHOLDER_BY_MODE: dict[AgentType, str] = {
+        AgentType.RESEARCH: (
+            "Ask for investigations, e.g. research strengths and weaknesses of PydanticAI vs its rivals"
+        ),
+        AgentType.PLAN: (
+            "Describe a goal to plan, e.g. draft a rollout plan for launching our Slack automation"
+        ),
+        AgentType.TASKS: (
+            "Request actionable work, e.g. break down tasks to wire OpenTelemetry into the API"
+        ),
+    }
+
     value = reactive("")
     mode = reactive(AgentType.RESEARCH)
     history: PromptHistory = PromptHistory()
@@ -305,6 +322,7 @@ class ChatScreen(Screen[None]):
             interactive_mode=True,
             llm_model=model_config,
             codebase_service=codebase_service,
+            system_prompt_fn=_dummy_system_prompt_fn,
         )
         self.agent_manager = AgentManager(deps=self.deps, initial_type=self.mode)
 
@@ -323,6 +341,10 @@ class ChatScreen(Screen[None]):
             mode_indicator.mode = new_mode
             mode_indicator.refresh()
 
+            prompt_input = self.query_one(PromptInput)
+            prompt_input.placeholder = self._placeholder_for_mode(new_mode)
+            prompt_input.refresh()
+
     def watch_working(self, is_working: bool) -> None:
         """Show or hide the spinner based on working state."""
         if self.is_mounted:
@@ -379,7 +401,7 @@ class ChatScreen(Screen[None]):
                     text=self.value,
                     highlight_cursor_line=False,
                     id="prompt-input",
-                    placeholder="Type your message",
+                    placeholder=self._placeholder_for_mode(self.mode),
                 )
                 yield ModeIndicator(mode=self.mode)
 
@@ -398,7 +420,10 @@ class ChatScreen(Screen[None]):
 
         prompt_input = self.query_one(PromptInput)
         prompt_input.clear()
-        prompt_input.focus()
+
+    def _placeholder_for_mode(self, mode: AgentType) -> str:
+        """Return the placeholder text appropriate for the current mode."""
+        return self._PLACEHOLDER_BY_MODE.get(mode, "Type your message")
 
     @work
     async def run_agent(self, message: str) -> None:

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()