@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/tui/widgets/danger_warning.py

@@ -0,0 +1,65 @@
+from typing import Literal
+from textual.content import Content
+
+from textual.widget import Widget
+
+
+from tui.danger import DangerLevel
+
+
+class DangerWarning(Widget):
+    DEFAULT_CSS = """
+    DangerWarning {
+        height: auto;
+        padding: 0 1;
+        margin: 1 0;
+        &.-dangerous {            
+            color: $text-warning;
+            border: round $warning;
+        }
+
+        &.-destructive {            
+            color: $text-error;
+            border: round $error;
+        }
+    }
+
+    """
+
+    def __init__(
+        self,
+        level: Literal[DangerLevel.DANGEROUS, DangerLevel.DESTRUCTIVE],
+        *,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        self.level = level
+        super().__init__(id=id, classes=classes)
+
+    def on_mount(self) -> None:
+        if self.level == DangerLevel.DANGEROUS:
+            self.add_class("-dangerous")
+        elif self.level == DangerLevel.DESTRUCTIVE:
+            self.add_class("-destructive")
+
+    def render(self) -> Content:
+        if self.level == DangerLevel.DANGEROUS:
+            return Content.from_markup(
+                " Potentially dangeous operation — [dim]please review carefully!"
+            )
+        else:
+            return Content.from_markup(
+                " [b]Destructive operation[/b] (may alter files outside of project directory) — [dim]please review carefully!"
+            )
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    class DangerApp(App):
+        def compose(self) -> ComposeResult:
+            yield DangerWarning(DangerLevel.DANGEROUS)
+            yield DangerWarning(DangerLevel.DESTRUCTIVE)
+
+    app = DangerApp()
+    app.run()

package/tui/widgets/diff_view.py

@@ -0,0 +1,69 @@
+from textual_diff_view import DiffView
+
+# Workaround for textual_diff_view crash: DiffCode has ALLOW_SELECT = True
+# but its parent chain is not a proper Widget, causing Textual's
+# _forward_event to assert-fail on mouse move.
+try:
+    from textual_diff_view._diff_view import DiffCode
+
+    DiffCode.ALLOW_SELECT = False
+except ImportError:
+    pass
+
+from tui.app import A2TUIApp
+
+
+def make_diff(
+    path_original: str,
+    path_modified: str,
+    code_before: str | None,
+    code_after: str | None,
+    id: str | None = None,
+    classes: str | None = None,
+) -> DiffView:
+    """Make a diff view widget, configured with app settings.
+
+    Args:
+        app: Instance of the app.
+        path_original: Path to the original file.
+        path_modified: Path to the modified file.,
+        code_before: Original code.
+        code_after: Modified code.
+        id: Textual CSS ID.
+        classes: Textual CSS classses.
+
+    Returns:
+        A diff view widget.
+    """
+    split = False
+    annotations = False
+    auto_split = False
+    wrap = False
+    from textual._context import active_app
+
+    try:
+        app = active_app.get()
+    except LookupError:
+        pass
+    else:
+        if isinstance(app, A2TUIApp):
+            diff_view_setting = app.settings.get("diff.view", str)
+            split = diff_view_setting == "split"
+            auto_split = diff_view_setting == "auto"
+            wrap = app.settings.get("diff.wrap") == "wrap"
+            annotations = app.settings.get("diff.annotations", bool)
+
+    diff_view = DiffView(
+        path_original,
+        path_modified,
+        code_before or "",
+        code_after or "",
+        classes=classes,
+        id=id,
+        split=split,
+        annotations=annotations,
+        auto_split=auto_split,
+        wrap=wrap,
+    )
+
+    return diff_view

package/tui/widgets/directory_input.py

@@ -0,0 +1,8 @@
+from textual.widgets import Input
+
+from tui.directory_suggester import DirectorySuggester
+
+
+class DirectoryInput(Input):
+    def on_mount(self) -> None:
+        self.suggester = DirectorySuggester()

package/tui/widgets/edit_field.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, Static
+
+
+class EditFieldScreen(ModalScreen[str]):
+    def __init__(self, field_label: str, current_value: str):
+        super().__init__()
+        self.field_label = field_label
+        self.current_value = current_value
+
+    BINDINGS = [
+        Binding("escape", "dismiss_modal", "Cancel"),
+    ]
+
+    CSS = """
+    EditFieldScreen { background: rgba(0,0,0,0.7); align: center middle; }
+
+    #edit-dialog {
+        width: 60;
+        height: auto;
+        background: $surface;
+        border: solid $border;
+        padding: 0 1;
+    }
+
+    #edit-label {
+        height: 1;
+        background: $panel;
+        color: $text;
+        padding: 0 1;
+        text-style: bold;
+    }
+
+    #edit-input {
+        height: 3;
+        margin: 1 0;
+        padding: 0 1;
+        background: $surface;
+        color: $text;
+        border: tall $border;
+    }
+
+    #edit-input:focus {
+        border: tall $primary;
+    }
+
+    #edit-input > .input--selection {
+        background: $primary;
+        color: $text;
+    }
+
+    #edit-input > .input--cursor {
+        background: $primary;
+        color: $text;
+        text-style: bold;
+    }
+
+    #edit-input Input.-placeholder {
+        color: $text-muted;
+    }
+
+    #edit-buttons {
+        height: 3;
+        background: $panel;
+        align: center middle;
+    }
+
+    Button {
+        margin: 0 1;
+        background: $panel;
+        color: $text;
+    }
+
+    Button:hover {
+        background: $primary-darken-2;
+    }
+
+    Button:focus {
+        background: $primary-darken-1;
+    }
+
+    #edit-save {
+        background: $primary-background;
+        color: $text;
+    }
+
+    #edit-save:hover {
+        background: $primary-darken-1;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="edit-dialog"):
+            yield Label(f"  {self.field_label}", id="edit-label")
+            yield Input(value=self.current_value, id="edit-input")
+            with Horizontal(id="edit-buttons"):
+                yield Button("Cancel", id="edit-cancel")
+                yield Button("Save", id="edit-save", variant="primary")
+
+    def on_mount(self) -> None:
+        self.query_one("#edit-input", Input).focus()
+
+    @on(Button.Pressed, "#edit-save")
+    def on_save(self) -> None:
+        value = self.query_one("#edit-input", Input).value.strip()
+        self.dismiss(value or None)
+
+    @on(Button.Pressed, "#edit-cancel")
+    def on_cancel(self) -> None:
+        self.dismiss(None)
+
+    @on(Input.Submitted)
+    def on_input_submitted(self) -> None:
+        value = self.query_one("#edit-input", Input).value.strip()
+        self.dismiss(value or None)
+
+    def action_dismiss_modal(self) -> None:
+        self.dismiss(None)
+
+
+class OptionPickerScreen(ModalScreen[str]):
+    def __init__(self, field_label: str, options: list[tuple[str, str]], current_value: str):
+        super().__init__()
+        self.field_label = field_label
+        self.options = options
+        self.current_value = current_value
+        self._selected_index = 0
+
+    BINDINGS = [
+        Binding("escape", "dismiss_modal", "Cancel"),
+        Binding("up", "cursor_up", "Up"),
+        Binding("down", "cursor_down", "Down"),
+        Binding("enter", "confirm", "Confirm"),
+    ]
+
+    CSS = """
+    OptionPickerScreen { background: rgba(0,0,0,0.7); align: center middle; }
+    #picker-dialog { width: 50; height: auto; background: #111; border: solid #555; max-height: 20; }
+    #picker-label { height: 1; background: #333; color: #fff; padding: 0 1; }
+    #picker-list { height: auto; max-height: 15; background: #000; }
+    .option-item { height: 1; padding: 0 1; color: #fff; background: #000; }
+    .option-item:hover, .option-item.selected { background: #444; }
+    #picker-buttons { height: 3; background: #222; align: center middle; }
+    Button { margin: 0 1; background: #444; color: #fff; }
+    Button:hover { background: #666; }
+    Button:focus { background: #555; }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="picker-dialog"):
+            yield Label(f"  {self.field_label}", id="picker-label")
+            with Vertical(id="picker-list"):
+                pass
+            with Horizontal(id="picker-buttons"):
+                yield Button("Cancel (ESC)", id="picker-cancel")
+                yield Button("Confirm (ENTER)", id="picker-confirm")
+
+    def on_mount(self) -> None:
+        list_container = self.query_one("#picker-list", Vertical)
+        for i, (label, val) in enumerate(self.options):
+            is_selected = (val == self.current_value) or (self.current_value is None and i == 0)
+            if is_selected:
+                self._selected_index = i
+            item = Static(f"  {'>' if is_selected else ' '}{label}", classes="option-item")
+            item._option_index = i
+            list_container.mount(item)
+        self.query_one("#picker-confirm", Button).focus()
+
+    def _refresh_list(self) -> None:
+        list_container = self.query_one("#picker-list", Vertical)
+        for i, item in enumerate(list_container.children):
+            if isinstance(item, Static):
+                label = self.options[i][0]
+                marker = ">" if i == self._selected_index else " "
+                item.update(f"  {marker}{label}")
+
+    def action_cursor_up(self) -> None:
+        if self._selected_index > 0:
+            self._selected_index -= 1
+            self._refresh_list()
+
+    def action_cursor_down(self) -> None:
+        if self._selected_index < len(self.options) - 1:
+            self._selected_index += 1
+            self._refresh_list()
+
+    def action_confirm(self) -> None:
+        _, val = self.options[self._selected_index]
+        self.dismiss(val)
+
+    @on(Button.Pressed, "#picker-confirm")
+    def on_confirm_button(self) -> None:
+        self.action_confirm()
+
+    @on(Button.Pressed, "#picker-cancel")
+    def on_cancel(self) -> None:
+        self.dismiss(None)
+
+    def action_dismiss_modal(self) -> None:
+        self.dismiss(None)

package/tui/widgets/flash.py

@@ -0,0 +1,81 @@
+from typing import Literal
+
+from textual.content import Content
+from textual.reactive import var
+from textual.widgets import Static
+from textual.timer import Timer
+from textual import getters
+
+
+from tui.app import A2TUIApp
+
+
+class Flash(Static):
+    DEFAULT_CSS = """
+    Flash {
+        height: 1;
+        width: 1fr;
+        background: $success 10%;
+        color: $text-success;
+        text-align: center;
+        visibility: hidden;
+        text-wrap: nowrap;
+        text-overflow: ellipsis;     
+        # overlay: screen;
+        # offset-y: -1;           
+        &.-default {
+            background: $primary 10%;
+            color: $text-primary;
+        }
+        
+        &.-success {
+            background: $success 10%;
+            color: $text-success;
+        }
+        
+        
+        &.-warning {
+            background: $warning 10%;
+            color: $text-warning;
+        }
+
+        &.-error {
+            background: $error 10%;
+            color: $text-error;
+        }
+    }
+    """
+    app = getters.app(A2TUIApp)
+    flash_timer: var[Timer | None] = var(None)
+
+    def flash(
+        self,
+        content: str | Content,
+        *,
+        duration: float | None = None,
+        style: Literal["default", "success", "warning", "error"] = "default",
+    ) -> None:
+        """Flash the content for a brief period.
+
+        Args:
+            content: Content to show.
+            duration: Duration in seconds to show content.
+            style: A semantic style.
+        """
+        if self.flash_timer is not None:
+            self.flash_timer.stop()
+        self.visible = False
+
+        def hide() -> None:
+            """Hide the content after a while."""
+            self.visible = False
+
+        self.update(content)
+        self.remove_class("-default", "-success", "-warning", "-error", update=False)
+        self.add_class(f"-{style}")
+        self.visible = True
+
+        if duration is None:
+            duration = self.app.settings.get("ui.flash_duration", float)
+
+        self.flash_timer = self.set_timer(duration or 3, hide)

package/tui/widgets/future_text.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from math import ceil
+from typing import ClassVar
+from time import monotonic
+
+from textual.color import Color
+from textual.reactive import var
+from textual.content import Content
+from textual.style import Style
+from textual.timer import Timer
+from textual.widgets import Static
+
+
+class FutureText(Static):
+    """Text which appears one letter at time, like the movies."""
+
+    DEFAULT_CSS = """
+    FutureText {
+        width: auto;
+        height: 1;
+        text-wrap: nowrap;
+        text-align: center;
+        color: $primary;
+        &>.future-text--cursor {
+            color: $primary;
+        }
+    }
+    """
+    ALLOW_SELECT = False
+    COMPONENT_CLASSES = {"future-text--cursor"}
+
+    BARS: ClassVar[list[str]] = ["▉", "▊", "▋", "▌", "▍", "▎", "▏", " "]
+    text_offset = var(0)
+
+    def __init__(
+        self,
+        text_list: list[Content],
+        *,
+        speed: float = 16.0,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ):
+        self.text_list = text_list
+        self.speed = speed
+        self.start_time = monotonic()
+        super().__init__(name=name, id=id, classes=classes)
+        self._update_timer: Timer | None = None
+
+    @property
+    def text(self) -> Content:
+        return self.text_list[self.text_offset % len(self.text_list)]
+
+    @property
+    def time(self) -> float:
+        return monotonic() - self.start_time
+
+    def on_mount(self) -> None:
+        self.start_time = monotonic()
+        self.set_interval(1 / 60, self._update_text)
+
+    def _update_text(self) -> None:
+        if not self.is_attached or not self.screen.is_active:
+            return
+        text = self.text + " "
+        speed_time = self.time * self.speed
+        progress, fractional_progress = divmod(speed_time, 1)
+        end = progress >= len(text)
+        cursor_progress = 0 if end else int(fractional_progress * 8)
+        text = text[: ceil(progress)]
+
+        bar_character = self.BARS[7 - cursor_progress]
+
+        cursor_styles = self.get_component_styles("future-text--cursor")
+        cursor_style = Style(foreground=cursor_styles.color)
+        reverse_cursor_style = cursor_style + Style(reverse=True)
+
+        # Fade in last character
+        fade_style = Style(
+            foreground=Color.blend(
+                cursor_styles.background, cursor_styles.color, ceil(fractional_progress)
+            )
+        )
+
+        fade_text = Content.assemble(
+            text[:-1],
+            ((text[-1].plain if text else " "), fade_style),
+        )
+
+        if speed_time >= 1:
+            text = Content.assemble(
+                fade_text,
+                (bar_character, reverse_cursor_style),
+                (bar_character, cursor_style),
+                " " * (len(self.text) + 1 - len(fade_text)),
+            )
+        self.update(text, layout=False)
+
+        if progress > len(text) + 10 * 5:
+            self.text_offset += 1
+            self.start_time = monotonic()
+
+
+if __name__ == "__main__":
+    from textual.app import App, ComposeResult
+
+    TEXT = [Content("Thinking..."), Content("Working hard..."), Content("Nearly there")]
+
+    class TextApp(App):
+        CSS = """
+        Screen {
+            padding: 2 4;
+            FutureText {
+                width: auto;
+                max-width: 1fr;
+                height: auto;
+               
+            }
+        }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield FutureText(TEXT)
+
+    TextApp().run()