shotgun-sh 0.3.3.dev1__py3-none-any.whl → 0.4.0.dev1__py3-none-any.whl

shotgun/tui/utils/mode_progress.py

@@ -113,93 +113,24 @@ class ModeProgressChecker:
 
 
 class PlaceholderHints:
-    """Manages dynamic placeholder hints for each mode based on progress."""
+    """Manages dynamic placeholder hints for the Router agent."""
 
-    # Placeholder variations for each mode and state
+    # Placeholder variations for Router mode
     HINTS = {
-        # Research mode
-        AgentType.RESEARCH: {
+        AgentType.ROUTER: {
             False: [
-                "Research a product or idea (SHIFT+TAB to cycle modes)",
-                "What would you like to explore? Start your research journey here (SHIFT+TAB to switch modes)",
-                "Dive into discovery mode - research anything that sparks curiosity (SHIFT+TAB for mode menu)",
-                "Ready to investigate? Feed me your burning questions (SHIFT+TAB to explore other modes)",
-                " 🔍 The research rabbit hole awaits! What shall we uncover? (SHIFT+TAB for mode carousel)",
+                "What would you like to work on? (SHIFT+TAB to toggle Planning/Drafting)",
+                "Ask me to research, plan, or implement anything (SHIFT+TAB toggles mode)",
+                "Describe your goal and I'll help break it down (SHIFT+TAB for mode toggle)",
+                "Ready to help with research, specs, plans, or tasks (SHIFT+TAB toggles mode)",
+                "Tell me what you need - I'll coordinate the work (SHIFT+TAB for Planning/Drafting)",
             ],
             True: [
-                "Research complete! SHIFT+TAB to move to Specify mode",
-                "Great research! Time to specify (SHIFT+TAB to Specify mode)",
-                "Research done! Ready to create specifications (SHIFT+TAB to Specify)",
-                "Findings gathered! Move to specifications (SHIFT+TAB for Specify mode)",
-                " 🎯 Research complete! Advance to Specify mode (SHIFT+TAB)",
-            ],
-        },
-        # Specify mode
-        AgentType.SPECIFY: {
-            False: [
-                "Create detailed specifications and requirements (SHIFT+TAB to switch modes)",
-                "Define your project specifications here (SHIFT+TAB to navigate modes)",
-                "Time to get specific - write comprehensive specs (SHIFT+TAB for mode options)",
-                "Specification station: Document requirements and designs (SHIFT+TAB to change modes)",
-                " 📋 Spec-tacular time! Let's architect your ideas (SHIFT+TAB for mode magic)",
-            ],
-            True: [
-                "Specifications complete! SHIFT+TAB to create a Plan",
-                "Specs ready! Time to plan (SHIFT+TAB to Plan mode)",
-                "Requirements defined! Move to planning (SHIFT+TAB to Plan)",
-                "Specifications done! Create your roadmap (SHIFT+TAB for Plan mode)",
-                " 🚀 Specs complete! Advance to Plan mode (SHIFT+TAB)",
-            ],
-        },
-        # Tasks mode
-        AgentType.TASKS: {
-            False: [
-                "Break down your project into actionable tasks (SHIFT+TAB for modes)",
-                "Task creation time! Define your implementation steps (SHIFT+TAB to switch)",
-                "Ready to get tactical? Create your task list (SHIFT+TAB for mode options)",
-                "Task command center: Organize your work items (SHIFT+TAB to navigate)",
-                " ✅ Task mode activated! Break it down into bite-sized pieces (SHIFT+TAB)",
-            ],
-            True: [
-                "Tasks defined! Ready to export or cycle back (SHIFT+TAB)",
-                "Task list complete! Export your work (SHIFT+TAB to Export)",
-                "All tasks created! Time to export (SHIFT+TAB for Export mode)",
-                "Implementation plan ready! Export everything (SHIFT+TAB to Export)",
-                " 🎊 Tasks complete! Export your masterpiece (SHIFT+TAB)",
-            ],
-        },
-        # Export mode
-        AgentType.EXPORT: {
-            False: [
-                "Export your complete project documentation (SHIFT+TAB for modes)",
-                "Ready to package everything? Export time! (SHIFT+TAB to switch)",
-                "Export station: Generate deliverables (SHIFT+TAB for mode menu)",
-                "Time to share your work! Export documents (SHIFT+TAB to navigate)",
-                " 📦 Export mode! Package and share your creation (SHIFT+TAB)",
-            ],
-            True: [
-                "Exported! Start new research or continue refining (SHIFT+TAB)",
-                "Export complete! New cycle begins (SHIFT+TAB to Research)",
-                "All exported! Ready for another round (SHIFT+TAB for Research)",
-                "Documents exported! Start fresh (SHIFT+TAB to Research mode)",
-                " 🎉 Export complete! Begin a new adventure (SHIFT+TAB)",
-            ],
-        },
-        # Plan mode
-        AgentType.PLAN: {
-            False: [
-                "Create a strategic plan for your project (SHIFT+TAB for modes)",
-                "Planning phase: Map out your roadmap (SHIFT+TAB to switch)",
-                "Time to strategize! Create your project plan (SHIFT+TAB for options)",
-                "Plan your approach and milestones (SHIFT+TAB to navigate)",
-                " 🗺️ Plan mode! Chart your course to success (SHIFT+TAB)",
-            ],
-            True: [
-                "Plan complete! Move to Tasks mode (SHIFT+TAB)",
-                "Strategy ready! Time for tasks (SHIFT+TAB to Tasks mode)",
-                "Roadmap done! Create task list (SHIFT+TAB for Tasks)",
-                "Planning complete! Break into tasks (SHIFT+TAB to Tasks)",
-                " ⚡ Plan ready! Advance to Tasks mode (SHIFT+TAB)",
+                "Continue working or start something new (SHIFT+TAB toggles mode)",
+                "What's next? (SHIFT+TAB to toggle Planning/Drafting)",
+                "Ready for the next task (SHIFT+TAB toggles Planning/Drafting)",
+                "Let's keep going! (SHIFT+TAB to toggle mode)",
+                "What else can I help with? (SHIFT+TAB for mode toggle)",
             ],
         },
     }
@@ -224,19 +155,22 @@ class PlaceholderHints:
         Returns:
             A contextual hint string for the placeholder.
         """
+        # Always use Router hints since Router is the only user-facing agent
+        mode_key = AgentType.ROUTER
+
         # Default hint if mode not configured
-        if current_mode not in self.HINTS:
-            return f"Enter your {current_mode.value} mode prompt (SHIFT+TAB to switch modes)"
+        if mode_key not in self.HINTS:
+            return "Enter your prompt (SHIFT+TAB to toggle Planning/Drafting mode)"
 
         # For placeholder text, we default to "no content" state (initial hints)
         # This avoids async file system checks in the UI rendering path
         has_content = False
 
         # Get hint variations for this mode and state
-        hints_list = self.HINTS[current_mode][has_content]
+        hints_list = self.HINTS[mode_key][has_content]
 
         # Cache key for this mode and state
-        cache_key = (current_mode, has_content)
+        cache_key = (mode_key, has_content)
 
         # Force refresh or first time
         if force_refresh or cache_key not in self._cached_hints:

shotgun/tui/widgets/__init__.py

@@ -1,5 +1,6 @@
 """Widget utilities and coordinators for TUI."""
 
+from shotgun.tui.widgets.plan_panel import PlanPanelWidget
 from shotgun.tui.widgets.widget_coordinator import WidgetCoordinator
 
-__all__ = ["WidgetCoordinator"]
+__all__ = ["PlanPanelWidget", "WidgetCoordinator"]

shotgun/tui/widgets/approval_widget.py

@@ -0,0 +1,152 @@
+"""Plan approval widget for Planning mode.
+
+This widget displays when a multi-step plan is created in Planning mode,
+allowing the user to approve or reject the plan before execution begins.
+"""
+
+from textual import events, on
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.css.query import NoMatches
+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 (
+    PlanApproved,
+    PlanRejected,
+)
+
+
+class PlanApprovalWidget(Widget):
+    """Widget for plan approval in Planning mode.
+
+    Displays the execution plan summary with goal and steps,
+    and provides action buttons for the user to approve or reject.
+
+    Attributes:
+        plan: The execution plan that needs user approval.
+    """
+
+    DEFAULT_CSS = """
+        PlanApprovalWidget {
+            background: $secondary-background-darken-1;
+            height: auto;
+            max-height: 20;
+            margin: 0 1;
+            padding: 1;
+        }
+
+        PlanApprovalWidget .approval-header {
+            height: auto;
+        }
+
+        PlanApprovalWidget .plan-content {
+            height: auto;
+            max-height: 12;
+            margin: 1 0;
+        }
+
+        PlanApprovalWidget .plan-goal {
+            color: $text;
+            margin-bottom: 1;
+        }
+
+        PlanApprovalWidget .plan-steps-label {
+            color: $text-muted;
+        }
+
+        PlanApprovalWidget .step-item {
+            color: $text;
+            margin-left: 2;
+        }
+
+        PlanApprovalWidget .approval-buttons {
+            height: auto;
+            width: 100%;
+            dock: bottom;
+        }
+
+        PlanApprovalWidget Button {
+            margin-right: 1;
+            min-width: 18;
+        }
+
+        PlanApprovalWidget #btn-approve {
+            background: $success;
+        }
+
+        PlanApprovalWidget #btn-reject {
+            background: $error;
+        }
+    """
+
+    def __init__(self, plan: ExecutionPlan) -> None:
+        """Initialize the approval widget.
+
+        Args:
+            plan: The execution plan that needs user approval.
+        """
+        super().__init__()
+        self.plan = plan
+
+    def compose(self) -> ComposeResult:
+        """Compose the approval widget layout."""
+        # Header with step count
+        yield Static(
+            f"[bold]📋 Plan created with {len(self.plan.steps)} steps[/]",
+            classes="approval-header",
+        )
+
+        # Scrollable content area for goal and steps
+        with VerticalScroll(classes="plan-content"):
+            # Goal
+            yield Static(
+                f"[dim]Goal:[/] {self.plan.goal}",
+                classes="plan-goal",
+            )
+
+            # Steps list
+            yield Static("[dim]Steps:[/]", classes="plan-steps-label")
+            for i, step in enumerate(self.plan.steps, 1):
+                yield Static(
+                    f"{i}. {step.title}",
+                    classes="step-item",
+                )
+
+        # Action buttons (always visible at bottom)
+        with Horizontal(classes="approval-buttons"):
+            yield Button("✓ Go Ahead", id="btn-approve")
+            yield Button("✗ No, Let Me Clarify", id="btn-reject")
+
+    def on_mount(self) -> None:
+        """Auto-focus the Go Ahead button on mount."""
+        try:
+            approve_btn = self.query_one("#btn-approve", Button)
+            approve_btn.focus()
+        except NoMatches:
+            pass
+
+    @on(Button.Pressed, "#btn-approve")
+    def handle_approve(self) -> None:
+        """Handle Go Ahead button press."""
+        self.post_message(PlanApproved())
+
+    @on(Button.Pressed, "#btn-reject")
+    def handle_reject(self) -> None:
+        """Handle No, Let Me Clarify button press."""
+        self.post_message(PlanRejected())
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle keyboard shortcuts for approval actions.
+
+        Shortcuts:
+            Enter/Y: Approve plan (Go Ahead)
+            Escape/N: Reject plan (No, Let Me Clarify)
+        """
+        if event.key in ("enter", "y", "Y"):
+            self.post_message(PlanApproved())
+            event.stop()
+        elif event.key in ("escape", "n", "N"):
+            self.post_message(PlanRejected())
+            event.stop()

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