galangal-orchestrate 0.13.0__py3-none-any.whl

galangal/ui/tui/entry.py

@@ -0,0 +1,24 @@
+"""
+Entry points for TUI-based stage execution.
+"""
+
+
+def run_stage_with_tui(
+    task_name: str,
+    stage: str,
+    branch: str,
+    attempt: int,
+    prompt: str,
+) -> tuple[bool, str]:
+    """Run a single stage with TUI."""
+    from galangal.ui.tui.app import StageTUIApp
+
+    app = StageTUIApp(
+        task_name=task_name,
+        stage=stage,
+        branch=branch,
+        attempt=attempt,
+        prompt=prompt,
+    )
+    app.run()
+    return app.result

galangal/ui/tui/mixins.py

@@ -0,0 +1,196 @@
+"""
+Mixin classes for WorkflowTUIApp functionality.
+
+These mixins separate concerns while keeping the app class cohesive:
+- WidgetAccessMixin: Safe widget access patterns
+- WorkflowControlMixin: Workflow control state and actions
+- PromptsMixin: Modal prompts and text input
+- DiscoveryMixin: Discovery Q&A session handling
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar
+
+from textual.widgets import RichLog
+
+if TYPE_CHECKING:
+    from textual.widget import Widget
+
+T = TypeVar("T", bound="Widget")
+
+
+class WidgetAccessMixin:
+    """
+    Safe widget access patterns for TUI apps.
+
+    Provides helper methods that gracefully handle widget access
+    during screen transitions and shutdown.
+    """
+
+    def _safe_query(self, selector: str, widget_type: type[T]) -> T | None:
+        """
+        Safely query a widget, returning None if not found.
+
+        Use this instead of query_one() when the widget might not exist
+        (e.g., during screen transitions or shutdown).
+
+        Args:
+            selector: CSS selector for the widget.
+            widget_type: Expected widget type.
+
+        Returns:
+            The widget if found, None otherwise.
+        """
+        try:
+            return self.query_one(selector, widget_type)
+        except Exception:
+            return None
+
+    def _safe_update(self, fn: Callable[[], None]) -> None:
+        """
+        Safely execute a UI update function.
+
+        Tries call_from_thread first (for background thread calls),
+        then falls back to direct call. Silently ignores errors
+        that occur during screen transitions.
+
+        Args:
+            fn: Function to execute for UI update.
+        """
+        try:
+            self.call_from_thread(fn)
+        except Exception:
+            try:
+                fn()
+            except Exception:
+                pass  # Silently ignore errors during transitions
+
+    def _safe_log_write(self, message: str) -> None:
+        """
+        Safely write to the activity log.
+
+        Args:
+            message: Rich-formatted message to write.
+        """
+
+        def _write():
+            log = self._safe_query("#activity-log", RichLog)
+            if log:
+                log.write(message)
+
+        self._safe_update(_write)
+
+
+class WorkflowControlMixin:
+    """
+    Workflow control state and related actions.
+
+    Manages the control flags that coordinate between the TUI
+    and the background workflow thread.
+    """
+
+    def _init_control_state(self) -> None:
+        """Initialize workflow control state flags."""
+        self._paused = False
+        self._interrupt_requested = False
+        self._skip_stage_requested = False
+        self._back_stage_requested = False
+        self._manual_edit_requested = False
+        self._workflow_result: str | None = None
+
+    def _reset_control_flags(self) -> None:
+        """Reset all control flags to default state."""
+        self._paused = False
+        self._interrupt_requested = False
+        self._skip_stage_requested = False
+        self._back_stage_requested = False
+        self._manual_edit_requested = False
+
+    @property
+    def is_paused(self) -> bool:
+        """Check if workflow is paused."""
+        return self._paused
+
+    @property
+    def has_pending_action(self) -> bool:
+        """Check if any control action is pending."""
+        return (
+            self._interrupt_requested
+            or self._skip_stage_requested
+            or self._back_stage_requested
+            or self._manual_edit_requested
+        )
+
+
+class PromptsMixin:
+    """
+    Modal prompts and text input handling.
+
+    Provides both callback-based and async versions of prompt methods.
+    """
+
+    def _init_prompt_state(self) -> None:
+        """Initialize prompt-related state."""
+        from galangal.ui.tui.adapters import PromptType
+
+        self._prompt_type = PromptType.NONE
+        self._prompt_callback: Callable | None = None
+        self._active_prompt_screen = None
+        self._input_callback: Callable | None = None
+        self._active_input_screen = None
+
+    def _text_input_active(self) -> bool:
+        """Check if text input is currently active and should capture keys."""
+        return self._input_callback is not None or self._active_input_screen is not None
+
+    def _prompt_active(self) -> bool:
+        """Check if a prompt modal is currently active."""
+        return self._prompt_callback is not None or self._active_prompt_screen is not None
+
+
+class DiscoveryMixin:
+    """
+    Discovery Q&A session handling.
+
+    Provides async methods for the PM stage discovery Q&A flow.
+    """
+
+    async def _run_qa_session(self, questions: list[str]) -> list[str] | None:
+        """
+        Run a Q&A session and return answers.
+
+        This is a convenience wrapper around question_answer_session_async
+        that handles the modal display and result collection.
+
+        Args:
+            questions: List of questions to ask.
+
+        Returns:
+            List of answers, or None if cancelled.
+        """
+        future: asyncio.Future[list[str] | None] = asyncio.Future()
+
+        def _show():
+            from galangal.ui.tui.modals import QuestionAnswerModal
+
+            try:
+
+                def _handle(result: list[str] | None) -> None:
+                    if not future.done():
+                        future.set_result(result)
+
+                screen = QuestionAnswerModal(questions)
+                self.push_screen(screen, _handle)
+            except Exception:
+                if not future.done():
+                    future.set_result(None)
+
+        try:
+            self.call_from_thread(_show)
+        except Exception:
+            _show()
+
+        return await future

galangal/ui/tui/modals.py

@@ -0,0 +1,339 @@
+"""
+Modal screens for TUI prompts and inputs.
+"""
+
+from dataclasses import dataclass
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static, TextArea
+
+
+@dataclass(frozen=True)
+class PromptOption:
+    """Option for a prompt modal."""
+
+    key: str
+    label: str
+    result: str
+    color: str
+
+
+class PromptModal(ModalScreen[str]):
+    """Modal prompt for multi-choice selections."""
+
+    CSS_PATH = "styles/modals.tcss"
+
+    BINDINGS = [
+        Binding("1", "choose_1", show=False),
+        Binding("2", "choose_2", show=False),
+        Binding("3", "choose_3", show=False),
+        Binding("4", "choose_4", show=False),
+        Binding("5", "choose_5", show=False),
+        Binding("6", "choose_6", show=False),
+        Binding("y", "choose_yes", show=False),
+        Binding("n", "choose_no", show=False),
+        Binding("q", "choose_quit", show=False),
+        Binding("escape", "choose_quit", show=False),
+    ]
+
+    def __init__(self, message: str, options: list[PromptOption]):
+        super().__init__()
+        self._message = message
+        self._options = options
+        self._key_map = {option.key: option.result for option in options}
+
+    def compose(self) -> ComposeResult:
+        options_text = "\n".join(
+            f"[{option.color}]{option.key}[/] {option.label}" for option in self._options
+        )
+        # Dynamic hint based on number of options
+        max_key = max((int(o.key) for o in self._options if o.key.isdigit()), default=3)
+        hint = f"Press 1-{max_key} to choose, Esc to cancel"
+        with Vertical(id="prompt-dialog"):
+            yield Static(self._message, id="prompt-message")
+            yield Static(Text.from_markup(options_text), id="prompt-options")
+            yield Static(hint, id="prompt-hint")
+
+    def _submit_key(self, key: str) -> None:
+        result = self._key_map.get(key)
+        if result:
+            self.dismiss(result)
+
+    def action_choose_1(self) -> None:
+        self._submit_key("1")
+
+    def action_choose_2(self) -> None:
+        self._submit_key("2")
+
+    def action_choose_3(self) -> None:
+        self._submit_key("3")
+
+    def action_choose_4(self) -> None:
+        self._submit_key("4")
+
+    def action_choose_5(self) -> None:
+        self._submit_key("5")
+
+    def action_choose_6(self) -> None:
+        self._submit_key("6")
+
+    def action_choose_yes(self) -> None:
+        self.dismiss("yes")
+
+    def action_choose_no(self) -> None:
+        self.dismiss("no")
+
+    def action_choose_quit(self) -> None:
+        self.dismiss("quit")
+
+
+class TextInputModal(ModalScreen[str | None]):
+    """Modal for collecting short text input."""
+
+    CSS_PATH = "styles/modals.tcss"
+
+    BINDINGS = [
+        Binding("escape", "cancel", show=False),
+    ]
+
+    def __init__(self, label: str, default: str = ""):
+        super().__init__()
+        self._label = label
+        self._default = default
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="text-input-dialog"):
+            yield Static(self._label, id="text-input-label")
+            yield Input(value=self._default, placeholder=self._label, id="text-input-field")
+            yield Static("Press Enter to submit, Esc to cancel", id="text-input-hint")
+
+    def on_mount(self) -> None:
+        field = self.query_one("#text-input-field", Input)
+        self.set_focus(field)
+        field.cursor_position = len(field.value)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "text-input-field":
+            value = event.value.strip()
+            self.dismiss(value if value else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class QuestionAnswerModal(ModalScreen[list[str] | None]):
+    """Modal for Q&A sessions - displays questions and collects answers sequentially."""
+
+    CSS_PATH = "styles/modals.tcss"
+
+    BINDINGS = [
+        Binding("escape", "cancel", show=False),
+    ]
+
+    def __init__(self, questions: list[str]):
+        super().__init__()
+        self._questions = questions
+        self._answers: list[str] = []
+        self._current_index = 0
+
+    def compose(self) -> ComposeResult:
+        # Format all questions for display
+        questions_display = "\n".join(f"  {i + 1}. {q}" for i, q in enumerate(self._questions))
+
+        with Vertical(id="qa-dialog"):
+            yield Static("Discovery Questions", id="qa-title")
+            yield Static(questions_display, id="qa-questions")
+            yield Static(self._get_current_question_text(), id="qa-current-question")
+            yield Input(placeholder="Your answer...", id="qa-input-field")
+            yield Static(self._get_progress_text(), id="qa-progress")
+            yield Static("Press Enter to submit answer, Esc to cancel", id="qa-hint")
+
+    def _get_current_question_text(self) -> str:
+        if self._current_index < len(self._questions):
+            return f"→ Q{self._current_index + 1}: {self._questions[self._current_index]}"
+        return "All questions answered!"
+
+    def _get_progress_text(self) -> str:
+        return f"Question {self._current_index + 1} of {len(self._questions)}"
+
+    def on_mount(self) -> None:
+        field = self.query_one("#qa-input-field", Input)
+        self.set_focus(field)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "qa-input-field":
+            answer = event.value.strip()
+            if not answer:
+                return  # Require non-empty answer
+
+            self._answers.append(answer)
+            self._current_index += 1
+
+            if self._current_index >= len(self._questions):
+                # All questions answered
+                self.dismiss(self._answers)
+            else:
+                # Update UI for next question
+                self._update_question_display()
+                event.input.value = ""
+
+    def _update_question_display(self) -> None:
+        question_widget = self.query_one("#qa-current-question", Static)
+        question_widget.update(self._get_current_question_text())
+
+        progress_widget = self.query_one("#qa-progress", Static)
+        progress_widget.update(self._get_progress_text())
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class UserQuestionsModal(ModalScreen[list[str] | None]):
+    """Modal for user to enter their own questions."""
+
+    CSS_PATH = "styles/modals.tcss"
+
+    BINDINGS = [
+        Binding("escape", "cancel", show=False),
+        Binding("ctrl+s", "submit", "Submit", show=True, priority=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="user-questions-dialog"):
+            yield Static("Enter your questions (one per line):", id="user-questions-label")
+            yield TextArea("", id="user-questions-field")
+            yield Static("Ctrl+S to submit, Esc to cancel", id="user-questions-hint")
+
+    def on_mount(self) -> None:
+        field = self.query_one("#user-questions-field", TextArea)
+        self.set_focus(field)
+
+    def action_submit(self) -> None:
+        field = self.query_one("#user-questions-field", TextArea)
+        text = field.text.strip()
+        if not text:
+            self.dismiss(None)
+            return
+
+        # Parse questions (one per line, skip empty lines)
+        questions = [q.strip() for q in text.split("\n") if q.strip()]
+        self.dismiss(questions if questions else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class MultilineInputModal(ModalScreen[str | None]):
+    """Modal for collecting multi-line text input (task descriptions, briefs)."""
+
+    CSS_PATH = "styles/modals.tcss"
+
+    BINDINGS = [
+        Binding("escape", "cancel", show=False),
+        Binding("ctrl+s", "submit", "Submit", show=True, priority=True),
+    ]
+
+    def __init__(self, label: str, default: str = ""):
+        super().__init__()
+        self._label = label
+        self._default = default
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="multiline-input-dialog"):
+            yield Static(self._label, id="multiline-input-label")
+            yield TextArea(self._default, id="multiline-input-field")
+            yield Static("Ctrl+S to submit, Esc to cancel", id="multiline-input-hint")
+
+    def on_mount(self) -> None:
+        field = self.query_one("#multiline-input-field", TextArea)
+        self.set_focus(field)
+        # Move cursor to end of text
+        field.move_cursor(field.document.end)
+
+    def action_submit(self) -> None:
+        field = self.query_one("#multiline-input-field", TextArea)
+        value = field.text.strip()
+        self.dismiss(value if value else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+@dataclass
+class GitHubIssueOption:
+    """A GitHub issue option for selection."""
+
+    number: int
+    title: str
+
+
+class GitHubIssueSelectModal(ModalScreen[int | None]):
+    """Modal for selecting a GitHub issue from a list."""
+
+    CSS_PATH = "styles/modals.tcss"
+
+    BINDINGS = [
+        Binding("escape", "cancel", show=False),
+        Binding("up", "move_up", show=False),
+        Binding("down", "move_down", show=False),
+        Binding("enter", "select", show=False),
+        Binding("k", "move_up", show=False),
+        Binding("j", "move_down", show=False),
+    ]
+
+    def __init__(self, issues: list[GitHubIssueOption]):
+        super().__init__()
+        self._issues = issues
+        self._selected_index = 0
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="issue-select-dialog"):
+            yield Static("Select GitHub Issue", id="issue-select-title")
+            yield Static(self._render_issue_list(), id="issue-select-list")
+            yield Static(
+                "↑/↓ or j/k to navigate, Enter to select, Esc to cancel", id="issue-select-hint"
+            )
+
+    def _render_issue_list(self) -> str:
+        if not self._issues:
+            return "[dim]No issues found[/]"
+
+        lines = []
+        for i, issue in enumerate(self._issues):
+            prefix = "→ " if i == self._selected_index else "  "
+            color = "#b8bb26" if i == self._selected_index else "#ebdbb2"
+            # Truncate title if too long
+            title = issue.title[:50] + "..." if len(issue.title) > 50 else issue.title
+            lines.append(f"[{color}]{prefix}#{issue.number} {title}[/]")
+
+        return "\n".join(lines)
+
+    def _update_display(self) -> None:
+        list_widget = self.query_one("#issue-select-list", Static)
+        list_widget.update(Text.from_markup(self._render_issue_list()))
+
+    def action_move_up(self) -> None:
+        if self._selected_index > 0:
+            self._selected_index -= 1
+            self._update_display()
+
+    def action_move_down(self) -> None:
+        if self._selected_index < len(self._issues) - 1:
+            self._selected_index += 1
+            self._update_display()
+
+    def action_select(self) -> None:
+        if self._issues:
+            self.dismiss(self._issues[self._selected_index].number)
+        else:
+            self.dismiss(None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

galangal/ui/tui/styles/app.tcss

@@ -0,0 +1,86 @@
+/*
+ * Main TUI Application Styles
+ * Gruvbox Dark color scheme
+ */
+
+Screen {
+    background: #282828;
+}
+
+#workflow-root {
+    layout: grid;
+    grid-size: 1;
+    grid-rows: 2 2 1fr 1 auto;
+    height: 100%;
+    width: 100%;
+}
+
+#header {
+    background: #3c3836;
+    padding: 0 2;
+    border-bottom: solid #504945;
+    content-align: left middle;
+}
+
+#progress {
+    background: #282828;
+    padding: 0 2;
+    content-align: center middle;
+}
+
+#main-content {
+    layout: vertical;
+    height: 100%;
+}
+
+#error-panel {
+    background: #282828;
+    padding: 0 1;
+    max-height: 8;
+}
+
+#error-panel.hidden {
+    height: 0;
+    padding: 0;
+    display: none;
+}
+
+#content-area {
+    layout: horizontal;
+    height: 1fr;
+}
+
+#activity-container {
+    width: 75%;
+    border-right: solid #504945;
+    height: 100%;
+}
+
+#files-container {
+    width: 25%;
+    padding: 0 1;
+    background: #1d2021;
+    height: 100%;
+}
+
+#activity-log {
+    background: #282828;
+    scrollbar-color: #fe8019;
+    scrollbar-background: #3c3836;
+    height: 100%;
+}
+
+#current-action {
+    background: #3c3836;
+    padding: 0 2;
+    border-top: solid #504945;
+}
+
+Footer {
+    background: #1d2021;
+}
+
+Footer > .footer--key {
+    background: #d3869b;
+    color: #1d2021;
+}