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

shotgun/tui/widgets/cascade_confirmation_widget.py

@@ -0,0 +1,203 @@
+"""Cascade confirmation widget for Planning mode.
+
+This widget displays after a file with dependents is updated,
+allowing the user to choose which dependent files should also be updated.
+"""
+
+from textual import events, on
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.css.query import NoMatches
+from textual.widget import Widget
+from textual.widgets import Button, Static
+
+from shotgun.agents.router.models import CascadeScope
+from shotgun.tui.screens.chat_screen.messages import (
+    CascadeConfirmed,
+    CascadeDeclined,
+)
+
+# File descriptions for cascade confirmation UI
+FILE_DESCRIPTIONS: dict[str, str] = {
+    "specification.md": "may need updated requirements",
+    "plan.md": "may need new implementation steps",
+    "tasks.md": "may need new tasks",
+}
+
+
+class CascadeConfirmationWidget(Widget):
+    """Widget for cascade confirmation in Planning mode.
+
+    Displays information about the updated file and its dependents,
+    providing action buttons for the user to choose the cascade scope.
+
+    Attributes:
+        updated_file: The file that was just updated.
+        dependent_files: List of files that depend on the updated file.
+    """
+
+    DEFAULT_CSS = """
+        CascadeConfirmationWidget {
+            background: $secondary-background-darken-1;
+            height: auto;
+            margin: 1;
+            padding: 1;
+        }
+
+        CascadeConfirmationWidget .cascade-header {
+            margin-bottom: 1;
+        }
+
+        CascadeConfirmationWidget .cascade-info {
+            color: $text-muted;
+            margin-bottom: 1;
+        }
+
+        CascadeConfirmationWidget .dependent-file {
+            color: $text;
+            margin-left: 2;
+        }
+
+        CascadeConfirmationWidget .cascade-question {
+            margin-top: 1;
+            margin-bottom: 1;
+        }
+
+        CascadeConfirmationWidget .cascade-buttons {
+            height: auto;
+            width: 100%;
+            margin-top: 1;
+        }
+
+        CascadeConfirmationWidget Button {
+            margin-right: 1;
+            min-width: 14;
+        }
+
+        CascadeConfirmationWidget #btn-update-all {
+            background: $success;
+        }
+
+        CascadeConfirmationWidget #btn-plan-only {
+            background: $primary;
+        }
+
+        CascadeConfirmationWidget #btn-tasks-only {
+            background: $primary;
+        }
+
+        CascadeConfirmationWidget #btn-decline {
+            background: $error;
+        }
+    """
+
+    def __init__(self, updated_file: str, dependent_files: list[str]) -> None:
+        """Initialize the cascade confirmation widget.
+
+        Args:
+            updated_file: The file that was just updated.
+            dependent_files: List of files that depend on the updated file.
+        """
+        super().__init__()
+        self.updated_file = updated_file
+        self.dependent_files = dependent_files
+
+    def compose(self) -> ComposeResult:
+        """Compose the cascade confirmation widget layout."""
+        # Header showing updated file
+        file_name = self.updated_file.split("/")[-1]
+        yield Static(
+            f"[bold green]✅ Updated {file_name}[/]",
+            classes="cascade-header",
+        )
+
+        # Show dependent files
+        if self.dependent_files:
+            yield Static(
+                "[dim]This affects dependent files:[/]",
+                classes="cascade-info",
+            )
+            for dep_file in self.dependent_files:
+                dep_name = dep_file.split("/")[-1]
+                description = FILE_DESCRIPTIONS.get(dep_name, "may need updates")
+                yield Static(
+                    f"• {dep_name} - {description}",
+                    classes="dependent-file",
+                )
+
+            yield Static(
+                "Should I update these to match?",
+                classes="cascade-question",
+            )
+
+        # Action buttons based on dependent files
+        with Horizontal(classes="cascade-buttons"):
+            if self.dependent_files:
+                # Update all button
+                yield Button("Update all", id="btn-update-all")
+
+                # Selective buttons if multiple dependents
+                if "plan.md" in self.dependent_files and len(self.dependent_files) > 1:
+                    yield Button("Just plan.md", id="btn-plan-only")
+                if "tasks.md" in self.dependent_files and len(self.dependent_files) > 1:
+                    yield Button("Just tasks.md", id="btn-tasks-only")
+
+            # Always show decline button
+            yield Button("No, I'll handle it", id="btn-decline")
+
+    def on_mount(self) -> None:
+        """Auto-focus the Update all button on mount."""
+        try:
+            update_btn = self.query_one("#btn-update-all", Button)
+            update_btn.focus()
+        except NoMatches:
+            try:
+                decline_btn = self.query_one("#btn-decline", Button)
+                decline_btn.focus()
+            except NoMatches:
+                pass  # No buttons to focus
+
+    @on(Button.Pressed, "#btn-update-all")
+    def handle_update_all(self) -> None:
+        """Handle Update all button press."""
+        self.post_message(CascadeConfirmed(CascadeScope.ALL))
+
+    @on(Button.Pressed, "#btn-plan-only")
+    def handle_plan_only(self) -> None:
+        """Handle Just plan.md button press."""
+        self.post_message(CascadeConfirmed(CascadeScope.PLAN_ONLY))
+
+    @on(Button.Pressed, "#btn-tasks-only")
+    def handle_tasks_only(self) -> None:
+        """Handle Just tasks.md button press."""
+        self.post_message(CascadeConfirmed(CascadeScope.TASKS_ONLY))
+
+    @on(Button.Pressed, "#btn-decline")
+    def handle_decline(self) -> None:
+        """Handle No button press."""
+        self.post_message(CascadeDeclined())
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle keyboard shortcuts for cascade actions.
+
+        Shortcuts:
+            Enter/A: Update all dependent files
+            P: Just update plan.md (if available)
+            T: Just update tasks.md (if available)
+            N/Escape: No, I'll handle it
+        """
+        if event.key in ("enter", "a", "A"):
+            if self.dependent_files:
+                self.post_message(CascadeConfirmed(CascadeScope.ALL))
+                event.stop()
+        elif event.key in ("p", "P"):
+            if "plan.md" in self.dependent_files and len(self.dependent_files) > 1:
+                self.post_message(CascadeConfirmed(CascadeScope.PLAN_ONLY))
+                event.stop()
+        elif event.key in ("t", "T"):
+            if "tasks.md" in self.dependent_files and len(self.dependent_files) > 1:
+                self.post_message(CascadeConfirmed(CascadeScope.TASKS_ONLY))
+                event.stop()
+        elif event.key in ("n", "N", "escape"):
+            self.post_message(CascadeDeclined())
+            event.stop()

shotgun/tui/widgets/plan_panel.py

@@ -0,0 +1,129 @@
+"""Plan panel widget for displaying the current execution plan.
+
+This widget displays the current RouterDeps execution plan.
+It auto-shows when a plan exists and can be closed with × button.
+"""
+
+from textual import on
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.widget import Widget
+from textual.widgets import Button, Static
+
+from shotgun.agents.router.models import ExecutionPlan
+from shotgun.tui.screens.chat_screen.messages import PlanPanelClosed
+
+
+class PlanPanelWidget(Widget):
+    """Widget for displaying the current execution plan.
+
+    Displays the plan goal and steps with status indicators.
+    Provides a close button to dismiss the panel.
+
+    Attributes:
+        plan: The execution plan to display.
+    """
+
+    DEFAULT_CSS = """
+        PlanPanelWidget {
+            background: $secondary-background-darken-1;
+            height: auto;
+            max-height: 10;
+            margin: 0 1;
+            padding: 1;
+            border: solid $primary-darken-2;
+        }
+
+        PlanPanelWidget .panel-header-row {
+            height: auto;
+            margin-bottom: 1;
+        }
+
+        PlanPanelWidget .panel-header {
+            color: $text-accent;
+        }
+
+        PlanPanelWidget #btn-close {
+            dock: right;
+            min-width: 3;
+            height: 1;
+            background: transparent;
+            border: none;
+            color: $text-muted;
+        }
+
+        PlanPanelWidget #btn-close:hover {
+            color: $error;
+        }
+
+        PlanPanelWidget .plan-goal {
+            color: $text;
+            margin-bottom: 1;
+        }
+
+        PlanPanelWidget .step-item {
+            color: $text;
+            margin-left: 2;
+        }
+
+        PlanPanelWidget .step-done {
+            color: $text-muted;
+            margin-left: 2;
+        }
+
+        PlanPanelWidget .step-current {
+            color: $text-accent;
+            margin-left: 2;
+        }
+    """
+
+    def __init__(self, plan: ExecutionPlan) -> None:
+        """Initialize the plan panel widget.
+
+        Args:
+            plan: The execution plan to display.
+        """
+        super().__init__()
+        self._plan = plan
+
+    @property
+    def plan(self) -> ExecutionPlan:
+        """Get the current plan."""
+        return self._plan
+
+    def update_plan(self, plan: ExecutionPlan) -> None:
+        """Update the displayed plan and refresh the widget.
+
+        Args:
+            plan: The new plan to display.
+        """
+        self._plan = plan
+        self.refresh(layout=True)
+
+    def compose(self) -> ComposeResult:
+        """Compose the plan panel layout."""
+        # Header with close button
+        with Horizontal(classes="panel-header-row"):
+            yield Static("[bold]📋 Execution Plan[/]", classes="panel-header")
+            yield Button("×", id="btn-close")
+
+        # Goal
+        yield Static(f"[dim]Goal:[/] {self._plan.goal}", classes="plan-goal")
+
+        # Steps
+        for i, step in enumerate(self._plan.steps):
+            marker = "✅" if step.done else "⬜"
+            current = (
+                " ◀" if i == self._plan.current_step_index and not step.done else ""
+            )
+            css_class = (
+                "step-done"
+                if step.done
+                else ("step-current" if current else "step-item")
+            )
+            yield Static(f"{i + 1}. {marker} {step.title}{current}", classes=css_class)
+
+    @on(Button.Pressed, "#btn-close")
+    def handle_close(self) -> None:
+        """Handle close button press."""
+        self.post_message(PlanPanelClosed())

shotgun/tui/widgets/step_checkpoint_widget.py

@@ -0,0 +1,180 @@
+"""Step checkpoint widget for Planning mode.
+
+This widget displays after each step completes in Planning mode,
+allowing the user to continue, modify the plan, or stop execution.
+"""
+
+from textual import events, on
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.css.query import NoMatches
+from textual.widget import Widget
+from textual.widgets import Button, Static
+
+from shotgun.agents.router.models import ExecutionStep
+from shotgun.tui.screens.chat_screen.messages import (
+    CheckpointContinue,
+    CheckpointModify,
+    CheckpointStop,
+)
+
+
+class StepCheckpointWidget(Widget):
+    """Widget for step completion checkpoints in Planning mode.
+
+    Displays information about the completed step and provides
+    action buttons for the user to choose how to proceed.
+
+    Attributes:
+        step: The step that was just completed.
+        next_step: The next step to execute, or None if this was the last step.
+    """
+
+    DEFAULT_CSS = """
+        StepCheckpointWidget {
+            background: $secondary-background-darken-1;
+            height: auto;
+            margin: 1;
+            padding: 1;
+        }
+
+        StepCheckpointWidget .checkpoint-header {
+            margin-bottom: 1;
+        }
+
+        StepCheckpointWidget .next-step-preview {
+            color: $text-muted;
+        }
+
+        StepCheckpointWidget .checkpoint-buttons {
+            height: auto;
+            width: 100%;
+            margin-top: 1;
+        }
+
+        StepCheckpointWidget Button {
+            margin-right: 1;
+            min-width: 14;
+        }
+
+        StepCheckpointWidget #btn-continue {
+            background: $success;
+        }
+
+        StepCheckpointWidget #btn-modify {
+            background: $warning;
+        }
+
+        StepCheckpointWidget #btn-stop {
+            background: $error;
+        }
+
+        StepCheckpointWidget #btn-done {
+            background: $success;
+        }
+    """
+
+    def __init__(self, step: ExecutionStep, next_step: ExecutionStep | None) -> None:
+        """Initialize the checkpoint widget.
+
+        Args:
+            step: The step that was just completed.
+            next_step: The next step to execute, or None if last step.
+        """
+        super().__init__()
+        self.step = step
+        self.next_step = next_step
+
+    def compose(self) -> ComposeResult:
+        """Compose the checkpoint widget layout."""
+        if self.next_step:
+            # Mid-plan checkpoint: show step completed with next step preview
+            yield Static(
+                f"[bold green]✅ Step completed:[/] {self.step.title}",
+                classes="checkpoint-header",
+            )
+            yield Static(
+                f"[dim]Next:[/] {self.next_step.title}",
+                classes="next-step-preview",
+            )
+            with Horizontal(classes="checkpoint-buttons"):
+                yield Button("Continue", id="btn-continue")
+                yield Button("Modify plan", id="btn-modify")
+                yield Button("Stop here", id="btn-stop")
+        else:
+            # Plan completed: show completion message with Done button only
+            yield Static(
+                "[bold green]✅ Plan completed![/]",
+                classes="checkpoint-header",
+            )
+            yield Static(
+                f"[dim]Final step:[/] {self.step.title}",
+                classes="next-step-preview",
+            )
+            with Horizontal(classes="checkpoint-buttons"):
+                yield Button("Done", id="btn-done")
+
+    def on_mount(self) -> None:
+        """Auto-focus the appropriate button on mount."""
+        # Auto-focus Continue button if available, otherwise Done, then Modify
+        try:
+            continue_btn = self.query_one("#btn-continue", Button)
+            continue_btn.focus()
+        except NoMatches:
+            try:
+                done_btn = self.query_one("#btn-done", Button)
+                done_btn.focus()
+            except NoMatches:
+                try:
+                    modify_btn = self.query_one("#btn-modify", Button)
+                    modify_btn.focus()
+                except NoMatches:
+                    pass  # No buttons to focus
+
+    @on(Button.Pressed, "#btn-continue")
+    def handle_continue(self) -> None:
+        """Handle Continue button press."""
+        self.post_message(CheckpointContinue())
+
+    @on(Button.Pressed, "#btn-modify")
+    def handle_modify(self) -> None:
+        """Handle Modify plan button press."""
+        self.post_message(CheckpointModify())
+
+    @on(Button.Pressed, "#btn-stop")
+    def handle_stop(self) -> None:
+        """Handle Stop here button press."""
+        self.post_message(CheckpointStop())
+
+    @on(Button.Pressed, "#btn-done")
+    def handle_done(self) -> None:
+        """Handle Done button press (plan completed)."""
+        self.post_message(CheckpointStop())
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle keyboard shortcuts for checkpoint actions.
+
+        Shortcuts:
+            Enter/C: Continue to next step (if available), or Done (if plan complete)
+            M: Modify the plan (only if not complete)
+            S/Escape: Stop execution (only if not complete)
+        """
+        if event.key in ("enter", "c", "C"):
+            if self.next_step:
+                self.post_message(CheckpointContinue())
+            else:
+                # Plan complete - Enter dismisses
+                self.post_message(CheckpointStop())
+            event.stop()
+        elif event.key in ("m", "M"):
+            if self.next_step:
+                self.post_message(CheckpointModify())
+                event.stop()
+        elif event.key in ("s", "S", "escape"):
+            if self.next_step:
+                self.post_message(CheckpointStop())
+                event.stop()
+            else:
+                # Plan complete - Escape also dismisses
+                self.post_message(CheckpointStop())
+                event.stop()

shotgun/tui/widgets/widget_coordinator.py

@@ -24,6 +24,7 @@ from shotgun.tui.screens.chat_screen.history.chat_history import ChatHistory
 
 if TYPE_CHECKING:
     from shotgun.agents.context_analyzer.models import ContextAnalysis
+    from shotgun.attachments import FileAttachment
     from shotgun.tui.screens.chat import ChatScreen
     from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 
@@ -261,3 +262,20 @@ class WidgetCoordinator:
             context_indicator.set_streaming(streaming)
         except Exception as e:
             logger.exception(f"Failed to set context streaming: {e}")
+
+    def update_attachment_bar(self, attachment: "FileAttachment | None") -> None:
+        """Update the attachment bar with pending attachment.
+
+        Args:
+            attachment: FileAttachment to display, or None to hide bar.
+        """
+        if not self.screen.is_mounted:
+            return
+
+        try:
+            from shotgun.tui.components.attachment_bar import AttachmentBar
+
+            attachment_bar = self.screen.query_one(AttachmentBar)
+            attachment_bar.update_attachment(attachment)
+        except Exception as e:
+            logger.exception(f"Failed to update attachment bar: {e}")

shotgun/utils/file_system_utils.py

@@ -1,5 +1,6 @@
 """File system utility functions."""
 
+import os
 from pathlib import Path
 
 import aiofiles
@@ -24,7 +25,9 @@ def get_shotgun_home() -> Path:
     if custom_home := settings.dev.home:
         return Path(custom_home)
 
-    return Path.home() / ".shotgun-sh"
+    # Use os.path.join for explicit path separator handling on Windows
+    # This avoids potential edge cases with pathlib's / operator
+    return Path(os.path.join(os.path.expanduser("~"), ".shotgun-sh"))
 
 
 def ensure_shotgun_directory_exists() -> Path: